#include <Spell.h>

Classes
struct	CorpseTargetInfo

struct	GOTargetInfo

struct	HitTriggerSpell

struct	ItemTargetInfo

struct	TargetInfo

struct	TargetInfoBase

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

Public Member Functions
void	EffectNULL ()

void	EffectUnused ()

void	EffectDistract ()

void	EffectSchoolDMG ()

void	EffectEnvironmentalDMG ()

void	EffectInstaKill ()

void	EffectDummy ()

void	EffectTeleportUnits ()

void	EffectTeleportUnitsWithVisualLoadingScreen ()

void	EffectApplyAura ()

void	EffectSendEvent ()

void	EffectPowerBurn ()

void	EffectPowerDrain ()

void	EffectHeal ()

void	EffectBind ()

void	EffectTeleportToReturnPoint ()

void	EffectIncreaseCurrencyCap ()

void	EffectHealthLeech ()

void	EffectQuestComplete ()

void	EffectCreateItem ()

void	EffectCreateItem2 ()

void	EffectCreateRandomItem ()

void	EffectPersistentAA ()

void	EffectEnergize ()

void	EffectOpenLock ()

void	EffectSummonChangeItem ()

void	EffectProficiency ()

void	EffectSummonType ()

void	EffectLearnSpell ()

void	EffectDispel ()

void	EffectDualWield ()

void	EffectPickPocket ()

void	EffectAddFarsight ()

void	EffectUntrainTalents ()

void	EffectHealMechanical ()

void	EffectJump ()

void	EffectJumpDest ()

void	EffectLeapBack ()

void	EffectQuestClear ()

void	EffectTeleUnitsFaceCaster ()

void	EffectLearnSkill ()

void	EffectPlayMovie ()

void	EffectTradeSkill ()

void	EffectEnchantItemPerm ()

void	EffectEnchantItemTmp ()

void	EffectTameCreature ()

void	EffectSummonPet ()

void	EffectLearnPetSpell ()

void	EffectWeaponDmg ()

void	EffectForceCast ()

void	EffectTriggerSpell ()

void	EffectTriggerMissileSpell ()

void	EffectThreat ()

void	EffectHealMaxHealth ()

void	EffectInterruptCast ()

void	EffectSummonObjectWild ()

void	EffectScriptEffect ()

void	EffectSanctuary ()

void	EffectDuel ()

void	EffectStuck ()

void	EffectSummonPlayer ()

void	EffectActivateObject ()

void	EffectApplyGlyph ()

void	EffectEnchantHeldItem ()

void	EffectSummonObject ()

void	EffectChangeRaidMarker ()

void	EffectResurrect ()

void	EffectParry ()

void	EffectBlock ()

void	EffectLeap ()

void	EffectTransmitted ()

void	EffectDisEnchant ()

void	EffectInebriate ()

void	EffectFeedPet ()

void	EffectDismissPet ()

void	EffectReputation ()

void	EffectForceDeselect ()

void	EffectSelfResurrect ()

void	EffectSkinning ()

void	EffectCharge ()

void	EffectChargeDest ()

void	EffectProspecting ()

void	EffectMilling ()

void	EffectRenamePet ()

void	EffectSendTaxi ()

void	EffectKnockBack ()

void	EffectPullTowards ()

void	EffectPullTowardsDest ()

void	EffectDispelMechanic ()

void	EffectResurrectPet ()

void	EffectDestroyAllTotems ()

void	EffectDurabilityDamage ()

void	EffectSkill ()

void	EffectTaunt ()

void	EffectDurabilityDamagePCT ()

void	EffectModifyThreatPercent ()

void	EffectResurrectNew ()

void	EffectAddExtraAttacks ()

void	EffectSpiritHeal ()

void	EffectSkinPlayerCorpse ()

void	EffectStealBeneficialBuff ()

void	EffectUnlearnSpecialization ()

void	EffectHealPct ()

void	EffectEnergizePct ()

void	EffectTriggerRitualOfSummoning ()

void	EffectSummonRaFFriend ()

void	EffectUnlockGuildVaultTab ()

void	EffectKillCreditPersonal ()

void	EffectKillCredit ()

void	EffectQuestFail ()

void	EffectQuestStart ()

void	EffectRedirectThreat ()

void	EffectGameObjectDamage ()

void	EffectGameObjectRepair ()

void	EffectGameObjectSetDestructionState ()

void	EffectCreateTamedPet ()

void	EffectDiscoverTaxi ()

void	EffectTitanGrip ()

void	EffectEnchantItemPrismatic ()

void	EffectPlayMusic ()

void	EffectActivateSpec ()

void	EffectPlaySound ()

void	EffectRemoveAura ()

void	EffectDamageFromMaxHealthPCT ()

void	EffectCastButtons ()

void	EffectRechargeItem ()

void	EffectGiveCurrency ()

void	EffectSummonPersonalGameObject ()

void	EffectResurrectWithAura ()

void	EffectCreateAreaTrigger ()

void	EffectRemoveTalent ()

void	EffectDestroyItem ()

void	EffectLearnGarrisonBuilding ()

void	EffectRemoveAuraBySpellLabel ()

void	EffectCreateGarrison ()

void	EffectCreateConversation ()

void	EffectCancelConversation ()

void	EffectAddGarrisonFollower ()

void	EffectActivateGarrisonBuilding ()

void	EffectGrantBattlePetLevel ()

void	EffectGiveExperience ()

void	EffectGiveRestedExperience ()

void	EffectHealBattlePetPct ()

void	EffectEnableBattlePets ()

void	EffectChangeBattlePetQuality ()

void	EffectLaunchQuestChoice ()

void	EffectUncageBattlePet ()

void	EffectCreateHeirloomItem ()

void	EffectUpgradeHeirloom ()

void	EffectApplyEnchantIllusion ()

void	EffectUpdatePlayerPhase ()

void	EffectUpdateZoneAurasAndPhases ()

void	EffectGiveArtifactPower ()

void	EffectGiveArtifactPowerNoBonus ()

void	EffectPlaySceneScriptPackage ()

void	EffectCreateSceneObject ()

void	EffectCreatePrivateSceneObject ()

void	EffectPlayScene ()

void	EffectGiveHonor ()

void	EffectJumpCharge ()

void	EffectLearnTransmogSet ()

void	EffectRespecAzeriteEmpoweredItem ()

void	EffectLearnAzeriteEssencePower ()

void	EffectCreatePrivateConversation ()

void	EffectSendChatMessage ()

void	EffectGrantBattlePetExperience ()

void	EffectLearnTransmogIllusion ()

void	EffectModifyAuraStacks ()

void	EffectModifyCooldown ()

void	EffectModifyCooldowns ()

void	EffectModifyCooldownsByCategory ()

void	EffectModifySpellCharges ()

void	EffectCreateTraitTreeConfig ()

void	EffectChangeActiveCombatTraitConfig ()

	Spell (WorldObject caster, SpellInfo const info, TriggerCastFlags triggerFlags, ObjectGuid originalCasterGUID=ObjectGuid::Empty, ObjectGuid originalCastId=ObjectGuid::Empty)

	~Spell ()

void	InitExplicitTargets (SpellCastTargets const &targets)

void	SelectExplicitTargets ()

void	SelectSpellTargets ()

void	SelectEffectImplicitTargets (SpellEffectInfo const &spellEffectInfo, SpellImplicitTargetInfo const &targetType, uint32 &processedEffectMask)

void	SelectImplicitChannelTargets (SpellEffectInfo const &spellEffectInfo, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitNearbyTargets (SpellEffectInfo const &spellEffectInfo, SpellImplicitTargetInfo const &targetType, uint32 effMask)

void	SelectImplicitConeTargets (SpellEffectInfo const &spellEffectInfo, SpellImplicitTargetInfo const &targetType, uint32 effMask)

void	SelectImplicitAreaTargets (SpellEffectInfo const &spellEffectInfo, SpellImplicitTargetInfo const &targetType, uint32 effMask)

void	SelectImplicitCasterDestTargets (SpellEffectInfo const &spellEffectInfo, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitTargetDestTargets (SpellEffectInfo const &spellEffectInfo, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitDestDestTargets (SpellEffectInfo const &spellEffectInfo, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitCasterObjectTargets (SpellEffectInfo const &spellEffectInfo, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitTargetObjectTargets (SpellEffectInfo const &spellEffectInfo, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitChainTargets (SpellEffectInfo const &spellEffectInfo, SpellImplicitTargetInfo const &targetType, WorldObject *target, uint32 effMask)

void	SelectImplicitTrajTargets (SpellEffectInfo const &spellEffectInfo, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitLineTargets (SpellEffectInfo const &spellEffectInfo, SpellImplicitTargetInfo const &targetType, uint32 effMask)

void	SelectEffectTypeImplicitTargets (SpellEffectInfo const &spellEffectInfo)

uint32	GetSearcherTypeMask (SpellTargetObjectTypes objType, ConditionContainer *condList)

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

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

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

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

GameObject *	SearchSpellFocus ()

SpellCastResult	prepare (SpellCastTargets const &targets, AuraEffect const *triggeredByAura=nullptr)

void	cancel ()

void	update (uint32 difftime)

void	cast (bool skipCheck=false)

void	finish (SpellCastResult result=SPELL_CAST_OK)

void	TakePower ()

void	TakeRunePower (bool didHit)

void	TakeReagents ()

void	TakeCastItem ()

SpellCastResult	CheckCast (bool strict, int32 param1=nullptr, int32 param2=nullptr)

SpellCastResult	CheckPetCast (Unit *target)

void	handle_immediate ()

uint64	handle_delayed (uint64 t_offset)

void	_handle_immediate_phase ()

void	_handle_finish_phase ()

SpellCastResult	CheckItems (int32 param1, int32 param2) const

SpellCastResult	CheckRange (bool strict) const

SpellCastResult	CheckPower () const

SpellCastResult	CheckRuneCost () const

SpellCastResult	CheckCasterAuras (int32 *param1) const

SpellCastResult	CheckArenaAndRatedBattlegroundCastRules ()

SpellCastResult	CheckMovement () const

bool	CheckSpellCancelsAuraEffect (AuraType auraType, int32 *param1) const

bool	CheckSpellCancelsCharm (int32 *param1) const

bool	CheckSpellCancelsStun (int32 *param1) const

bool	CheckSpellCancelsSilence (int32 *param1) const

bool	CheckSpellCancelsPacify (int32 *param1) const

bool	CheckSpellCancelsFear (int32 *param1) const

bool	CheckSpellCancelsConfuse (int32 *param1) const

bool	CheckSpellCancelsNoActions (int32 *param1) const

int32	CalculateDamage (SpellEffectInfo const &spellEffectInfo, Unit const target, float var=nullptr) const

void	Delayed ()

void	DelayedChannel ()

uint32	getState () const

void	setState (uint32 state)

void	DoCreateItem (uint32 itemId, ItemContext context=ItemContext::NONE, std::vector< int32 > const &bonusListIDs=std::vector< int32 >())

bool	CheckEffectTarget (Unit const target, SpellEffectInfo const &spellEffectInfo, Position const losPosition) const

bool	CheckEffectTarget (GameObject const *target, SpellEffectInfo const &spellEffectInfo) const

bool	CheckEffectTarget (Item const *target, SpellEffectInfo const &spellEffectInfo) const

bool	CanAutoCast (Unit *target)

void	CheckSrc ()

void	CheckDst ()

void	SendCastResult (SpellCastResult result, int32 param1=nullptr, int32 param2=nullptr) const

void	SendPetCastResult (SpellCastResult result, int32 param1=nullptr, int32 param2=nullptr) const

void	SendMountResult (MountResult result)

void	SendSpellStart ()

void	SendSpellGo ()

void	SendSpellCooldown ()

void	SendSpellExecuteLog ()

SpellLogEffect &	GetExecuteLogEffect (SpellEffectName effect)

template<typename T >
std::vector< T > &	GetExecuteLogEffectTargets (SpellEffectName effect, Optional< std::vector< T > > SpellLogEffect::*member)

void	ExecuteLogEffectTakeTargetPower (SpellEffectName effect, Unit *target, uint32 powerType, uint32 points, float amplitude)

void	ExecuteLogEffectExtraAttacks (SpellEffectName effect, Unit *victim, uint32 numAttacks)

void	ExecuteLogEffectDurabilityDamage (SpellEffectName effect, Unit *victim, int32 itemId, int32 amount)

void	ExecuteLogEffectOpenLock (SpellEffectName effect, Object *obj)

void	ExecuteLogEffectCreateItem (SpellEffectName effect, uint32 entry)

void	ExecuteLogEffectDestroyItem (SpellEffectName effect, uint32 entry)

void	ExecuteLogEffectSummonObject (SpellEffectName effect, WorldObject *obj)

void	ExecuteLogEffectUnsummonObject (SpellEffectName effect, WorldObject *obj)

void	ExecuteLogEffectResurrect (SpellEffectName effect, Unit *target)

void	SendSpellInterruptLog (Unit *victim, uint32 spellId)

void	SendInterrupted (uint8 result)

void	SendChannelUpdate (uint32 time)

void	SendChannelStart (uint32 duration)

void	SendResurrectRequest (Player *target)

void	HandleEffects (Unit pUnitTarget, Item pItemTarget, GameObject pGoTarget, Corpse pCorpseTarget, SpellEffectInfo const &spellEffectInfo, SpellEffectHandleMode mode)

void	HandleThreatSpells ()

int32	GetCastTime () const

bool	IsAutoRepeat () const

void	SetAutoRepeat (bool rep)

void	ReSetTimer ()

bool	IsTriggered () const

bool	IsIgnoringCooldowns () const

bool	IsFocusDisabled () const

bool	IsProcDisabled () const

bool	IsChannelActive () const

bool	IsAutoActionResetSpell () const

bool	IsPositive () const

bool	IsTriggeredByAura (SpellInfo const *auraSpellInfo) 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

uint64	CalculateDelayMomentForDst (float launchDelay) const

void	RecalculateDelayMomentForDst ()

uint8	GetRuneState () const

void	SetRuneState (uint8 value)

bool	IsNeedSendToClient () const

CurrentSpellTypes	GetCurrentContainer () const

WorldObject *	GetCaster () const

ObjectGuid	GetOriginalCasterGUID () const

Unit *	GetOriginalCaster () const

SpellInfo const *	GetSpellInfo () const

Difficulty	GetCastDifficulty () const

std::vector< SpellPowerCost > const &	GetPowerCost () const

bool	HasPowerTypeCost (Powers power) const

Optional< int32 >	GetPowerTypeCostAmount (Powers power) const

bool	UpdatePointers ()

void	CleanupTargetList ()

void	SetSpellValue (SpellValueMod mod, int32 value)

SpellInfo const *	GetTriggeredByAuraSpell () const

int32	GetTimer () const

int64	GetUnitTargetCountForEffect (SpellEffIndex effect) const

int64	GetGameObjectTargetCountForEffect (SpellEffIndex effect) const

int64	GetItemTargetCountForEffect (SpellEffIndex effect) const

int64	GetCorpseTargetCountForEffect (SpellEffIndex effect) const

std::string	GetDebugInfo () const

void	CallScriptOnResistAbsorbCalculateHandlers (DamageInfo const &damageInfo, uint32 &resistAmount, int32 &absorbAmount)

void	CallScriptCalcCritChanceHandlers (Unit const *victim, float &chance)

Static Public Member Functions
static void	SendCastResult (Player caster, SpellInfo const spellInfo, SpellCastVisual spellVisual, ObjectGuid cast_count, SpellCastResult result, SpellCustomErrors customError=SPELL_CUSTOM_ERROR_NONE, int32 param1=nullptr, int32 param2=nullptr)

static Spell const *	ExtractSpellFromEvent (BasicEvent *event)

Public Attributes
SpellInfo const *const	m_spellInfo

Item *	m_CastItem

ObjectGuid	m_castItemGUID

uint32	m_castItemEntry

int32	m_castItemLevel

ObjectGuid	m_castId

ObjectGuid	m_originalCastId

bool	m_fromClient

uint32	m_castFlagsEx

union {
uint32 TalentId

uint32 SpellId

uint32 SpecializationId

struct {
uint32 Id

uint32 AbilityId

} GarrFollower

uint32 GarrMissionId

uint32 ItemId

struct {
uint32 Data [2]

} Raw

}	m_misc

std::any	m_customArg

SpellCastVisual	m_SpellVisual

SpellCastTargets	m_targets

int8	m_comboPointGain

SpellCustomErrors	m_customError

UsedSpellMods	m_appliedMods

Spell **	m_selfContainer

Protected Types
typedef std::vector< HitTriggerSpell >	HitTriggerSpellList

Protected Member Functions
bool	HasGlobalCooldown () const

void	TriggerGlobalCooldown ()

void	CancelGlobalCooldown ()

void	_cast (bool skipCheck=false)

std::pair< float, float >	GetMinMaxRange (bool strict) const

bool	IsDelayableNoMore ()

Unit *	GetUnitCasterForEffectHandlers () const

void	prepareDataForTriggerSystem ()

template<class Container >
void	DoProcessTargetContainer (Container &targetContainer)

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	AddCorpseTarget (Corpse *target, uint32 effectMask)

void	AddDestTarget (SpellDestination const &dest, uint32 effIndex)

void	PreprocessSpellLaunch (TargetInfo &targetInfo)

SpellMissInfo	PreprocessSpellHit (Unit *unit, TargetInfo &targetInfo)

void	DoSpellEffectHit (Unit *unit, SpellEffectInfo const &spellEffectInfo, TargetInfo &targetInfo)

void	DoTriggersOnSpellHit (Unit *unit)

bool	UpdateChanneledTargetList ()

bool	IsValidDeadOrAliveTarget (Unit const *target) const

void	HandleLaunchPhase ()

void	DoEffectOnLaunchTarget (TargetInfo &targetInfo, float multiplier, SpellEffectInfo const &spellEffectInfo)

void	PrepareTargetProcessing ()

void	FinishTargetProcessing ()

void	LoadScripts ()

void	CallScriptOnPrecastHandler ()

void	CallScriptBeforeCastHandlers ()

void	CallScriptOnCastHandlers ()

void	CallScriptAfterCastHandlers ()

SpellCastResult	CallScriptCheckCastHandlers ()

int32	CallScriptCalcCastTimeHandlers (int32 originalCastTime)

bool	CallScriptEffectHandlers (SpellEffIndex effIndex, SpellEffectHandleMode mode)

void	CallScriptSuccessfulDispel (SpellEffIndex effIndex)

void	CallScriptBeforeHitHandlers (SpellMissInfo missInfo)

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 (Unit unit, SpellInfo const triggeredByAura=nullptr) const

void	PrepareTriggersExecutedOnHit ()

void	SummonGuardian (SpellEffectInfo const effect, uint32 entry, SummonPropertiesEntry const properties, uint32 numSummons, ObjectGuid privateObjectOwner)

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...

void	UpdateSpellCastDataAmmo (WorldPackets::Spells::SpellAmmo &data)

SpellCastResult	CanOpenLock (SpellEffectInfo const &effect, uint32 lockid, SkillType &skillid, int32 &reqSkillValue, int32 &skillValue)

	Spell (Spell const &right)=delete

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

Protected Attributes
WorldObject *const	m_caster

SpellValue *const	m_spellValue

ObjectGuid	m_originalCasterGUID

Unit *	m_originalCaster

SpellSchoolMask	m_spellSchoolMask

WeaponAttackType	m_attackType

std::vector< SpellPowerCost >	m_powerCost

int32	m_casttime

int32	m_channeledDuration

bool	m_canReflect

bool	m_autoRepeat

uint8	m_runesState

uint8	m_delayAtDamageCount

uint64	m_delayStart

uint64	m_delayMoment

bool	m_launchHandled

bool	m_immediateHandled

bool	m_referencedFromCurrentSpell

bool	m_executedCurrently

bool	m_needComboPoints

uint32	m_applyMultiplierMask

float	m_damageMultipliers [MAX_SPELL_EFFECTS]

Unit *	unitTarget

Item *	itemTarget

GameObject *	gameObjTarget

Corpse *	m_corpseTarget

WorldLocation *	destTarget

int32	damage

SpellMissInfo	targetMissInfo

float	variance

SpellEffectHandleMode	effectHandleMode

SpellEffectInfo const *	effectInfo

UnitAura *	_spellAura

DynObjAura *	_dynObjAura

GameObject *	focusObject

int32	m_damage

int32	m_healing

ProcFlagsInit	m_procAttacker

ProcFlagsInit	m_procVictim

ProcFlagsHit	m_hitMask

std::vector< TargetInfo >	m_UniqueTargetInfo

uint32	m_channelTargetEffectMask

std::vector< GOTargetInfo >	m_UniqueGOTargetInfo

std::vector< ItemTargetInfo >	m_UniqueItemInfo

std::vector< CorpseTargetInfo >	m_UniqueCorpseTargetInfo

SpellDestination	m_destTargets [MAX_SPELL_EFFECTS]

std::vector< SpellScript * >	m_loadedScripts

HitTriggerSpellList	m_hitTriggerSpells

uint32	m_spellState

int32	m_timer

SpellEvent *	_spellEvent

TriggerCastFlags	_triggeredCastFlags

SpellInfo const *	m_triggeredByAuraSpell

std::unique_ptr< PathGenerator >	m_preGeneratedPath

std::vector< SpellLogEffect >	_executeLogEffects

Friends
class	SpellScript

Member Typedef Documentation

◆ HitTriggerSpellList

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

protected

◆ UsedSpellMods

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

Constructor & Destructor Documentation

◆ Spell() [1/2]

Spell::Spell	(	WorldObject *	caster,
		SpellInfo const *	info,
		TriggerCastFlags	triggerFlags,
		ObjectGuid	originalCasterGUID = `ObjectGuid::Empty`,
		ObjectGuid	originalCastId = `ObjectGuid::Empty`
	)

 :
m_spellInfo(info), m_caster((info->HasAttribute(SPELL_ATTR6_ORIGINATE_FROM_CONTROLLER) && caster->GetCharmerOrOwner()) ? caster->GetCharmerOrOwner() : caster),
m_spellValue(new SpellValue(m_spellInfo, caster)), _spellEvent(nullptr)
{
 m_customError = SPELL_CUSTOM_ERROR_NONE;
 m_fromClient = false;
 m_selfContainer = nullptr;
 m_referencedFromCurrentSpell = false;
 m_executedCurrently = false;
 m_needComboPoints = m_spellInfo->NeedsComboPoints();
 m_comboPointGain = 0;
 m_delayStart = 0;
 m_delayAtDamageCount = 0;
 
 m_applyMultiplierMask = 0;
 memset(m_damageMultipliers, 0, sizeof(m_damageMultipliers));
 
 // Get data for type of attack
 m_attackType = info->GetAttackType();
 
 m_spellSchoolMask = info->GetSchoolMask(); // Can be override for some spell (wand shoot for example)
 
 if (Player const* playerCaster = m_caster->ToPlayer())
 {
 // wand case
 if (m_attackType == RANGED_ATTACK)
 if ((playerCaster->GetClassMask() & CLASSMASK_WAND_USERS) != 0)
 if (Item* pItem = playerCaster->GetWeaponForAttack(RANGED_ATTACK))
 m_spellSchoolMask = SpellSchoolMask(1 << pItem->GetTemplate()->GetDamageType());
 }
 
 if (Player const* modOwner = caster->GetSpellModOwner())
 modOwner->ApplySpellMod(info, SpellModOp::Doses, m_spellValue->AuraStackAmount, this);
 
 if (!originalCasterGUID.IsEmpty())
 m_originalCasterGUID = originalCasterGUID;
 else
 m_originalCasterGUID = m_caster->GetGUID();
 
 if (m_originalCasterGUID == m_caster->GetGUID())
 m_originalCaster = m_caster->ToUnit();
 else
 {
 m_originalCaster = ObjectAccessor::GetUnit(*m_caster, m_originalCasterGUID);
 if (m_originalCaster && !m_originalCaster->IsInWorld())
 m_originalCaster = nullptr;
 }
 
 m_spellState = SPELL_STATE_NULL;
 _triggeredCastFlags = triggerFlags;
 
 if (info->HasAttribute(SPELL_ATTR2_DO_NOT_REPORT_SPELL_FAILURE))
 _triggeredCastFlags = TriggerCastFlags(uint32(_triggeredCastFlags) | TRIGGERED_DONT_REPORT_CAST_ERROR);
 
 if (info->HasAttribute(SPELL_ATTR4_ALLOW_CAST_WHILE_CASTING))
 _triggeredCastFlags = TriggerCastFlags(uint32(_triggeredCastFlags) | TRIGGERED_IGNORE_CAST_IN_PROGRESS);
 
 m_CastItem = nullptr;
 m_castItemGUID.Clear();
 m_castItemEntry = 0;
 m_castItemLevel = -1;
 m_castFlagsEx = 0;
 
 if (IsIgnoringCooldowns())
 m_castFlagsEx |= CAST_FLAG_EX_IGNORE_COOLDOWN;
 
 unitTarget = nullptr;
 itemTarget = nullptr;
 gameObjTarget = nullptr;
 m_corpseTarget = nullptr;
 destTarget = nullptr;
 damage = 0;
 targetMissInfo = SPELL_MISS_NONE;
 variance = 0.0f;
 effectHandleMode = SPELL_EFFECT_HANDLE_LAUNCH;
 effectInfo = nullptr;
 m_damage = 0;
 m_healing = 0;
 m_hitMask = PROC_HIT_NONE;
 focusObject = nullptr;
 m_castId = ObjectGuid::Create<HighGuid::Cast>(SPELL_CAST_SOURCE_NORMAL, m_caster->GetMapId(), m_spellInfo->Id, m_caster->GetMap()->GenerateLowGuid<HighGuid::Cast>());
 m_originalCastId = originalCastId;
 memset(m_misc.Raw.Data, 0, sizeof(m_misc.Raw.Data));
 m_SpellVisual.SpellXSpellVisualID = caster->GetCastSpellXSpellVisualId(m_spellInfo);
 m_triggeredByAuraSpell = nullptr;
 _spellAura = nullptr;
 _dynObjAura = nullptr;
 
 //Auto Shot & Shoot (wand)
 m_autoRepeat = m_spellInfo->IsAutoRepeatRangedSpell();
 
 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_launchHandled = false;
 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 = caster->IsUnit() && m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MAGIC && !m_spellInfo->HasAttribute(SPELL_ATTR0_IS_ABILITY)
 && !m_spellInfo->HasAttribute(SPELL_ATTR1_NO_REFLECTION) && !m_spellInfo->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES)
 && !m_spellInfo->IsPassive();
 
 CleanupTargetList();
 
 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::~Spell ( )

{
 // unload scripts
 for (auto itr = m_loadedScripts.begin(); itr != m_loadedScripts.end(); ++itr)
 {
 (*itr)->_Unload();
 delete (*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 {}. However, spell still referenced.", m_spellInfo->Id);
 *m_selfContainer = nullptr;
 }
 
 if (m_caster && m_caster->GetTypeId() == TYPEID_PLAYER)
 ASSERT(m_caster->ToPlayer()->m_spellModTakingSpell != this);
 
 delete m_spellValue;
}

Here is the call graph for this function:

◆ Spell() [2/2]

Spell::Spell ( Spell const & right )

protecteddelete

Member Function Documentation

◆ _cast()

void Spell::_cast ( bool skipCheck = false )

protected

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 (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 (GetSpellInfo()->DmgClass != SPELL_DAMAGE_CLASS_NONE)
 if (Unit* target = m_targets.GetUnitTarget())
 for (Unit* controlled : playerCaster->m_Controlled)
 if (Creature* cControlled = controlled->ToCreature())
 if (CreatureAI* controlledAI = cControlled->AI())
 controlledAI->OwnerAttacked(target);
 }
 
 SetExecutedCurrently(true);
 
 // Should this be done for original caster?
 Player* modOwner = m_caster->GetSpellModOwner();
 if (modOwner)
 {
 // Set spell which will drop charges for triggered cast spells
 // if not successfully cast, will be remove in finish(false)
 modOwner->SetSpellModTakingSpell(this, true);
 }
 
 CallScriptBeforeCastHandlers();
 
 // skip check if done already (for instant cast spells for example)
 if (!skipCheck)
 {
 auto cleanupSpell = [this, modOwner](SpellCastResult res, int32* p1 = nullptr, int32* p2 = nullptr)
 {
 SendCastResult(res, p1, p2);
 SendInterrupted(0);
 
 if (modOwner)
 modOwner->SetSpellModTakingSpell(this, false);
 
 finish(res);
 SetExecutedCurrently(false);
 };
 
 int32 param1 = 0, param2 = 0;
 SpellCastResult castResult = CheckCast(false, &param1, &param2);
 if (castResult != SPELL_CAST_OK)
 {
 cleanupSpell(castResult, &param1, &param2);
 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 (modOwner)
 {
 if (TradeData* my_trade = modOwner->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);
 cleanupSpell(SPELL_FAILED_DONT_REPORT);
 return;
 }
 }
 }
 }
 
 // check diminishing returns (again, only after finish cast bar, tested on retail)
 if (Unit* target = m_targets.GetUnitTarget())
 {
 uint32 aura_effmask = 0;
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 if (spellEffectInfo.IsUnitOwnedAuraEffect())
 aura_effmask |= 1 << spellEffectInfo.EffectIndex;
 
 if (aura_effmask)
 {
 if (m_spellInfo->GetDiminishingReturnsGroupForSpell())
 {
 DiminishingReturnsType type = m_spellInfo->GetDiminishingReturnsGroupType();
 if (type == DRTYPE_ALL || (type == DRTYPE_PLAYER && target->IsAffectedByDiminishingReturns()))
 {
 if (Unit* caster = m_originalCaster ? m_originalCaster : m_caster->ToUnit())
 {
 if (target->HasStrongerAuraWithDR(m_spellInfo, caster))
 {
 cleanupSpell(SPELL_FAILED_AURA_BOUNCED);
 return;
 }
 }
 }
 }
 }
 }
 }
 // The spell focusing is making sure that we have a valid cast target guid when we need it so only check for a guid value here.
 if (Creature* creatureCaster = m_caster->ToCreature())
 if (!creatureCaster->GetTarget().IsEmpty() && !creatureCaster->HasUnitFlag(UNIT_FLAG_POSSESSED))
 if (WorldObject const* target = ObjectAccessor::GetUnit(*creatureCaster, creatureCaster->GetTarget()))
 creatureCaster->SetInFront(target);
 
 SelectSpellTargets();
 
 // Spell may be finished after target map check
 if (m_spellState == SPELL_STATE_FINISHED)
 {
 SendInterrupted(0);
 
 // cleanup after mod system
 // triggered spell pointer can be not removed in some cases
 if (m_caster->GetTypeId() == TYPEID_PLAYER)
 m_caster->ToPlayer()->SetSpellModTakingSpell(this, false);
 
 finish(SPELL_FAILED_INTERRUPTED);
 SetExecutedCurrently(false);
 return;
 }
 
 if (Unit* unitCaster = m_caster->ToUnit())
 if (m_spellInfo->HasAttribute(SPELL_ATTR1_DISMISS_PET_FIRST))
 if (Creature* pet = ObjectAccessor::GetCreature(*m_caster, unitCaster->GetPetGUID()))
 pet->DespawnOrUnsummon();
 
 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->StartCriteriaTimer(CriteriaStartEvent::UseItem, m_CastItem->GetEntry());
 player->UpdateCriteria(CriteriaType::UseItem, m_CastItem->GetEntry());
 }
 
 player->UpdateCriteria(CriteriaType::CastSpell, 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
 if (!m_spellInfo->HasAttribute(SPELL_ATTR12_START_COOLDOWN_ON_CAST_START))
 SendSpellCooldown();
 
 if (!m_spellInfo->LaunchDelay)
 {
 HandleLaunchPhase();
 m_launchHandled = true;
 }
 
 // we must send smsg_spell_go packet before m_castItem delete in TakeCastItem()...
 SendSpellGo();
 
 if (!m_spellInfo->IsChanneled())
 if (Creature* creatureCaster = m_caster->ToCreature())
 creatureCaster->ReleaseSpellFocus(this);
 
 // Okay, everything is prepared. Now we need to distinguish between immediate and evented delayed spells
 if ((m_spellInfo->HasHitDelay() && !m_spellInfo->IsChanneled()) || m_spellInfo->HasAttribute(SPELL_ATTR4_NO_HARMFUL_THREAT))
 {
 // 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 (Unit* unitCaster = m_caster->ToUnit())
 if (unitCaster->HasUnitState(UNIT_STATE_CASTING) && !unitCaster->IsNonMeleeSpellCast(false, false, true))
 unitCaster->ClearUnitState(UNIT_STATE_CASTING);
 }
 else
 {
 // Immediate spell, no big deal
 handle_immediate();
 }
 
 CallScriptAfterCastHandlers();
 
 if (std::vector<int32> const* spell_triggered = sSpellMgr->GetSpellLinked(SPELL_LINK_CAST, m_spellInfo->Id))
 {
 for (int32 id : *spell_triggered)
 {
 if (id < 0)
 {
 if (Unit* unitCaster = m_caster->ToUnit())
 unitCaster->RemoveAurasDueToSpell(-id);
 }
 else
 m_caster->CastSpell(m_targets.GetUnitTarget() ? m_targets.GetUnitTarget() : m_caster, id, CastSpellExtraArgs(TRIGGERED_FULL_MASK)
 .SetTriggeringSpell(this));
 }
 }
 
 if (modOwner)
 {
 modOwner->SetSpellModTakingSpell(this, false);
 
 //Clear spell cooldowns after every spell is cast if .cheat cooldown is enabled.
 if (m_originalCaster && modOwner->GetCommandStatus(CHEAT_COOLDOWN))
 {
 m_originalCaster->GetSpellHistory()->ResetCooldown(m_spellInfo->Id, true);
 m_originalCaster->GetSpellHistory()->RestoreCharge(m_spellInfo->ChargeCategoryId);
 }
 }
 
 SetExecutedCurrently(false);
 
 if (!m_originalCaster)
 return;
 
 // Handle procs on cast
 ProcFlagsInit procAttacker = m_procAttacker;
 if (!procAttacker)
 {
 if (m_spellInfo->HasAttribute(SPELL_ATTR3_TREAT_AS_PERIODIC))
 {
 if (IsPositive())
 procAttacker |= PROC_FLAG_DEAL_HELPFUL_PERIODIC;
 else
 procAttacker |= PROC_FLAG_DEAL_HARMFUL_PERIODIC;
 }
 else if (m_spellInfo->HasAttribute(SPELL_ATTR0_IS_ABILITY))
 {
 if (IsPositive())
 procAttacker |= PROC_FLAG_DEAL_HELPFUL_ABILITY;
 else
 procAttacker |= PROC_FLAG_DEAL_HARMFUL_ABILITY;
 }
 else
 {
 if (IsPositive())
 procAttacker |= PROC_FLAG_DEAL_HELPFUL_SPELL;
 else
 procAttacker |= PROC_FLAG_DEAL_HARMFUL_SPELL;
 }
 }
 
 procAttacker |= PROC_FLAG_2_CAST_SUCCESSFUL;
 
 ProcFlagsHit hitMask = m_hitMask;
 if (!(hitMask & PROC_HIT_CRITICAL))
 hitMask |= PROC_HIT_NORMAL;
 
 if (!(_triggeredCastFlags & TRIGGERED_IGNORE_AURA_INTERRUPT_FLAGS) && !m_spellInfo->HasAttribute(SPELL_ATTR2_NOT_AN_ACTION))
 m_originalCaster->RemoveAurasWithInterruptFlags(SpellAuraInterruptFlags::ActionDelayed, m_spellInfo);
 
 if (!m_spellInfo->HasAttribute(SPELL_ATTR3_SUPPRESS_CASTER_PROCS))
 Unit::ProcSkillsAndAuras(m_originalCaster, nullptr, procAttacker, PROC_FLAG_NONE, PROC_SPELL_TYPE_MASK_ALL, PROC_SPELL_PHASE_CAST, hitMask, this, nullptr, nullptr);
 
 // Call CreatureAI hook OnSpellCast
 if (Creature* caster = m_originalCaster->ToCreature())
 if (caster->IsAIEnabled())
 caster->AI()->OnSpellCast(GetSpellInfo());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _handle_finish_phase()

void Spell::_handle_finish_phase ( )

{
 if (Unit* unitCaster = m_caster->ToUnit())
 {
 // Take for real after all targets are processed
 if (m_needComboPoints)
 unitCaster->ClearComboPoints();
 
 // Real add combo points from effects
 if (m_comboPointGain)
 unitCaster->AddComboPoints(m_comboPointGain);
 
 if (m_spellInfo->HasEffect(SPELL_EFFECT_ADD_EXTRA_ATTACKS))
 unitCaster->SetLastExtraAttackSpell(m_spellInfo->Id);
 }
 
 // Handle procs on finish
 if (!m_originalCaster)
 return;
 
 ProcFlagsInit procAttacker = m_procAttacker;
 if (!procAttacker)
 {
 if (m_spellInfo->HasAttribute(SPELL_ATTR3_TREAT_AS_PERIODIC))
 {
 if (IsPositive())
 procAttacker |= PROC_FLAG_DEAL_HELPFUL_PERIODIC;
 else
 procAttacker |= PROC_FLAG_DEAL_HARMFUL_PERIODIC;
 }
 else if (m_spellInfo->HasAttribute(SPELL_ATTR0_IS_ABILITY))
 {
 if (IsPositive())
 procAttacker |= PROC_FLAG_DEAL_HELPFUL_ABILITY;
 else
 procAttacker |= PROC_FLAG_DEAL_HARMFUL_ABILITY;
 }
 else
 {
 if (IsPositive())
 procAttacker |= PROC_FLAG_DEAL_HELPFUL_SPELL;
 else
 procAttacker |= PROC_FLAG_DEAL_HARMFUL_SPELL;
 }
 }
 
 if (!m_spellInfo->HasAttribute(SPELL_ATTR3_SUPPRESS_CASTER_PROCS))
 Unit::ProcSkillsAndAuras(m_originalCaster, nullptr, procAttacker, PROC_FLAG_NONE, PROC_SPELL_TYPE_MASK_ALL, PROC_SPELL_PHASE_FINISH, m_hitMask, this, nullptr, nullptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _handle_immediate_phase()

void Spell::_handle_immediate_phase ( )

{
 // handle some immediate features of the spell here
 HandleThreatSpells();
 
 // handle effects with SPELL_EFFECT_HANDLE_HIT mode
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 {
 // don't do anything for empty effect
 if (!spellEffectInfo.IsEffect())
 continue;
 
 // call effect handlers to handle destination hit
 HandleEffects(nullptr, nullptr, nullptr, nullptr, spellEffectInfo, SPELL_EFFECT_HANDLE_HIT);
 }
 
 // process items
 DoProcessTargetContainer(m_UniqueItemInfo);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddCorpseTarget()

void Spell::AddCorpseTarget	(	Corpse *	target,
		uint32	effectMask
	)

protected

{
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 if (!spellEffectInfo.IsEffect())
 effectMask &= ~(1 << spellEffectInfo.EffectIndex);
 
 // no effects left
 if (!effectMask)
 return;
 
 ObjectGuid targetGUID = corpse->GetGUID();
 
 // Lookup target in already in list
 auto ihit = std::find_if(std::begin(m_UniqueCorpseTargetInfo), std::end(m_UniqueCorpseTargetInfo), [targetGUID](CorpseTargetInfo const& target) { return target.TargetGUID == targetGUID; });
 if (ihit != std::end(m_UniqueCorpseTargetInfo)) // Found in list
 {
 // Add only effect mask
 ihit->EffectMask |= effectMask;
 return;
 }
 
 // This is new target calculate data for him
 CorpseTargetInfo target;
 target.TargetGUID = targetGUID;
 target.EffectMask = effectMask;
 
 // Spell have speed - need calculate incoming time
 if (m_caster != corpse)
 {
 float hitDelay = m_spellInfo->LaunchDelay;
 if (m_spellInfo->HasAttribute(SPELL_ATTR9_SPECIAL_DELAY_CALCULATION))
 hitDelay += m_spellInfo->Speed;
 else if (m_spellInfo->Speed > 0.0f)
 {
 // calculate spell incoming interval
 float dist = std::max(m_caster->GetDistance(corpse->GetPositionX(), corpse->GetPositionY(), corpse->GetPositionZ()), 5.0f);
 hitDelay += dist / m_spellInfo->Speed;
 }
 
 target.TimeDelay = uint64(std::floor(hitDelay * 1000.0f));
 }
 else
 target.TimeDelay = 0LL;
 
 // Calculate minimum incoming time
 if (target.TimeDelay && (!m_delayMoment || m_delayMoment > target.TimeDelay))
 m_delayMoment = target.TimeDelay;
 
 // Add target to list
 m_UniqueCorpseTargetInfo.emplace_back(std::move(target));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddDestTarget()

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

protected

{
 m_destTargets[effIndex] = dest;
}

Here is the caller graph for this function:

◆ AddGOTarget()

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

protected

{
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 if (!spellEffectInfo.IsEffect() || !CheckEffectTarget(go, spellEffectInfo))
 effectMask &= ~(1 << spellEffectInfo.EffectIndex);
 
 // no effects left
 if (!effectMask)
 return;
 
 ObjectGuid targetGUID = go->GetGUID();
 
 // Lookup target in already in list
 auto ihit = std::find_if(std::begin(m_UniqueGOTargetInfo), std::end(m_UniqueGOTargetInfo), [targetGUID](GOTargetInfo const& target) { return target.TargetGUID == targetGUID; });
 if (ihit != std::end(m_UniqueGOTargetInfo)) // Found in list
 {
 // Add only effect mask
 ihit->EffectMask |= effectMask;
 return;
 }
 
 // This is new target calculate data for him
 
 GOTargetInfo target;
 target.TargetGUID = targetGUID;
 target.EffectMask = effectMask;
 
 // Spell have speed - need calculate incoming time
 if (static_cast<WorldObject*>(m_caster) != go)
 {
 float hitDelay = m_spellInfo->LaunchDelay;
 if (m_spellInfo->HasAttribute(SPELL_ATTR9_SPECIAL_DELAY_CALCULATION))
 hitDelay += m_spellInfo->Speed;
 else if (m_spellInfo->Speed > 0.0f)
 {
 // calculate spell incoming interval
 float dist = std::max(m_caster->GetDistance(go->GetPositionX(), go->GetPositionY(), go->GetPositionZ()), 5.0f);
 hitDelay += dist / m_spellInfo->Speed;
 }
 
 target.TimeDelay = uint64(std::floor(hitDelay * 1000.0f));
 }
 else
 target.TimeDelay = 0ULL;
 
 // Calculate minimum incoming time
 if (target.TimeDelay && (!m_delayMoment || m_delayMoment > target.TimeDelay))
 m_delayMoment = target.TimeDelay;
 
 // Add target to list
 m_UniqueGOTargetInfo.emplace_back(std::move(target));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddItemTarget()

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

protected

{
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 if (!spellEffectInfo.IsEffect() || !CheckEffectTarget(item, spellEffectInfo))
 effectMask &= ~(1 << spellEffectInfo.EffectIndex);
 
 // no effects left
 if (!effectMask)
 return;
 
 // Lookup target in already in list
 auto ihit = std::find_if(std::begin(m_UniqueItemInfo), std::end(m_UniqueItemInfo), [item](ItemTargetInfo const& target) { return target.TargetItem == item; });
 if (ihit != std::end(m_UniqueItemInfo)) // Found in list
 {
 // Add only effect mask
 ihit->EffectMask |= effectMask;
 return;
 }
 
 // This is new target add data
 
 ItemTargetInfo target;
 target.TargetItem = item;
 target.EffectMask = effectMask;
 
 m_UniqueItemInfo.emplace_back(std::move(target));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddUnitTarget()

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

protected

Todo:: this is a hack

{
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 if (!spellEffectInfo.IsEffect() || !CheckEffectTarget(target, spellEffectInfo, losPosition))
 effectMask &= ~(1 << spellEffectInfo.EffectIndex);
 
 // no effects left
 if (!effectMask)
 return;
 
 if (checkIfValid)
 if (m_spellInfo->CheckTarget(m_caster, target, implicit) != SPELL_CAST_OK) // skip stealth checks for AOE
 return;
 
 // Check for effect immune skip if immuned
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 if (target->IsImmunedToSpellEffect(m_spellInfo, spellEffectInfo, m_caster))
 effectMask &= ~(1 << spellEffectInfo.EffectIndex);
 
 ObjectGuid targetGUID = target->GetGUID();
 
 // Lookup target in already in list
 auto ihit = std::find_if(std::begin(m_UniqueTargetInfo), std::end(m_UniqueTargetInfo), [targetGUID](TargetInfo const& target) { return target.TargetGUID == targetGUID; });
 if (ihit != std::end(m_UniqueTargetInfo)) // Found in list
 {
 // Immune effects removed from mask
 ihit->EffectMask |= effectMask;
 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.IsAlive = target->IsAlive();
 targetInfo.Damage = 0;
 targetInfo.Healing = 0;
 targetInfo.IsCrit = false;
 
 // Calculate hit result
 WorldObject* caster = m_originalCaster ? m_originalCaster : m_caster;
 targetInfo.MissCondition = caster->SpellHitResult(target, m_spellInfo, m_canReflect && !(IsPositive() && m_caster->IsFriendlyTo(target)));
 
 // Spell have speed - need calculate incoming time
 // Incoming time is zero for self casts. At least I think so.
 if (m_caster != target)
 {
 float hitDelay = m_spellInfo->LaunchDelay;
 WorldObject const* missileSource = m_caster;
 if (m_spellInfo->HasAttribute(SPELL_ATTR4_BOUNCY_CHAIN_MISSILES))
 {
 auto previousTargetItr = std::find_if(m_UniqueTargetInfo.rbegin(), m_UniqueTargetInfo.rend(), [effectMask](TargetInfo const& target)
 {
 return (target.EffectMask & effectMask) != 0;
 });
 if (previousTargetItr != std::rend(m_UniqueTargetInfo))
 {
 hitDelay = 0.0f; // this is not the first target in chain, LaunchDelay was already included
 
 if (WorldObject* previousTarget = ObjectAccessor::GetWorldObject(*m_caster, previousTargetItr->TargetGUID))
 missileSource = previousTarget;
 
 targetInfo.TimeDelay += previousTargetItr->TimeDelay;
 }
 }
 
 if (m_spellInfo->HasAttribute(SPELL_ATTR9_SPECIAL_DELAY_CALCULATION))
 hitDelay += m_spellInfo->Speed;
 else if (m_spellInfo->Speed > 0.0f)
 {
 // calculate spell incoming interval
 float dist = std::max(missileSource->GetDistance(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ()), 5.0f);
 hitDelay += dist / m_spellInfo->Speed;
 }
 
 targetInfo.TimeDelay += uint64(std::floor(hitDelay * 1000.0f));
 }
 else
 targetInfo.TimeDelay = 0ULL;
 
 // If target reflect spell back to caster
 if (targetInfo.MissCondition == SPELL_MISS_REFLECT)
 {
 // Calculate reflected spell result on caster (shouldn't be able to reflect gameobject spells)
 Unit* unitCaster = ASSERT_NOTNULL(m_caster->ToUnit());
 targetInfo.ReflectResult = unitCaster->SpellHitResult(unitCaster, m_spellInfo, false); // can't reflect twice
 
 // Proc spell reflect aura when missile hits the original target
 target->m_Events.AddEvent(new ProcReflectDelayed(target, m_originalCasterGUID), target->m_Events.CalculateTime(Milliseconds(targetInfo.TimeDelay)));
 
 // Increase time interval for reflected spells by 1.5
 targetInfo.TimeDelay += targetInfo.TimeDelay >> 1;
 }
 else
 targetInfo.ReflectResult = SPELL_MISS_NONE;
 
 // Calculate minimum incoming time
 if (targetInfo.TimeDelay && (!m_delayMoment || m_delayMoment > targetInfo.TimeDelay))
 m_delayMoment = targetInfo.TimeDelay;
 
 // Add target to list
 m_UniqueTargetInfo.emplace_back(std::move(targetInfo));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalculateDamage()

int32 Spell::CalculateDamage	(	SpellEffectInfo const &	spellEffectInfo,
		Unit const *	target,
		float *	var = `nullptr`
	)		const

{
 bool needRecalculateBasePoints = !(m_spellValue->CustomBasePointsMask & (1 << spellEffectInfo.EffectIndex));
 return m_caster->CalculateSpellDamage(target, spellEffectInfo, needRecalculateBasePoints ? nullptr : &m_spellValue->EffectBasePoints[spellEffectInfo.EffectIndex], var, m_castItemEntry, m_castItemLevel);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalculateDelayMomentForDst()

uint64 Spell::CalculateDelayMomentForDst ( float launchDelay ) const

{
 if (m_targets.HasDst())
 {
 if (m_targets.HasTraj())
 {
 float speed = m_targets.GetSpeedXY();
 if (speed > 0.0f)
 return uint64(std::floor((m_targets.GetDist2d() / speed + launchDelay) * 1000.0f));
 }
 else if (m_spellInfo->HasAttribute(SPELL_ATTR9_SPECIAL_DELAY_CALCULATION))
 return uint64(std::floor((m_spellInfo->Speed + launchDelay) * 1000.0f));
 else if (m_spellInfo->Speed > 0.0f)
 {
 // We should not subtract caster size from dist calculation (fixes execution time desync with animation on client, eg. Malleable Goo cast by PP)
 float dist = m_caster->GetExactDist(*m_targets.GetDstPos());
 return uint64(std::floor((dist / m_spellInfo->Speed + launchDelay) * 1000.0f));
 }
 
 return uint64(std::floor(launchDelay * 1000.0f));
 }
 
 return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalculateJumpSpeeds()

void Spell::CalculateJumpSpeeds	(	SpellEffectInfo const *	effInfo,
		float	dist,
		float &	speedXY,
		float &	speedZ
	)

protected

{
 Unit* unitCaster = GetUnitCasterForEffectHandlers();
 ASSERT(unitCaster);
 
 float multiplier = effInfo->Amplitude;
 if (multiplier <= 0.0f)
 multiplier = 1.0f;
 
 float minHeight = effInfo->MiscValue ? effInfo->MiscValue / 10.0f : 0.5f; // Lower bound is blizzlike
 float maxHeight = effInfo->MiscValueB ? effInfo->MiscValueB / 10.0f : 1000.0f; // Upper bound is unknown
 
 unitCaster->GetMotionMaster()->CalculateJumpSpeeds(dist, MOVE_RUN, multiplier, minHeight, maxHeight, speedXY, speedZ);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CallScriptAfterCastHandlers()

void Spell::CallScriptAfterCastHandlers ( )

protected

{
 for (auto scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_AFTER_CAST);
 auto 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:

◆ CallScriptAfterHitHandlers()

void Spell::CallScriptAfterHitHandlers ( )

protected

{
 for (auto scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_AFTER_HIT);
 auto 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:

◆ CallScriptBeforeCastHandlers()

void Spell::CallScriptBeforeCastHandlers ( )

protected

{
 for (auto scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_BEFORE_CAST);
 auto 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:

◆ CallScriptBeforeHitHandlers()

void Spell::CallScriptBeforeHitHandlers ( SpellMissInfo missInfo )

protected

{
 for (auto scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_InitHit();
 (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_BEFORE_HIT);
 auto hookItrEnd = (*scritr)->BeforeHit.end(), hookItr = (*scritr)->BeforeHit.begin();
 for (; hookItr != hookItrEnd; ++hookItr)
 (*hookItr).Call(*scritr, missInfo);
 
 (*scritr)->_FinishScriptCall();
 }
}

Here is the caller graph for this function:

◆ CallScriptCalcCastTimeHandlers()

int32 Spell::CallScriptCalcCastTimeHandlers ( int32 originalCastTime )

protected

{
 for (auto scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_CALC_CAST_TIME);
 castTime = (*scritr)->CalcCastTime(castTime);
 (*scritr)->_FinishScriptCall();
 }
 return castTime;
}

Here is the caller graph for this function:

◆ CallScriptCalcCritChanceHandlers()

void Spell::CallScriptCalcCritChanceHandlers	(	Unit const *	victim,
		float &	chance
	)

{
 for (SpellScript* loadedScript : m_loadedScripts)
 {
 loadedScript->_PrepareScriptCall(SPELL_SCRIPT_HOOK_CALC_CRIT_CHANCE);
 for (SpellScript::OnCalcCritChanceHandler const& hook : loadedScript->OnCalcCritChance)
 hook.Call(loadedScript, victim, critChance);
 
 loadedScript->_FinishScriptCall();
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CallScriptCheckCastHandlers()

SpellCastResult Spell::CallScriptCheckCastHandlers ( )

protected

{
 SpellCastResult retVal = SPELL_CAST_OK;
 for (auto scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_CHECK_CAST);
 auto 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:

◆ CallScriptDestinationTargetSelectHandlers()

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

protected

{
 for (auto scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_DESTINATION_TARGET_SELECT);
 auto 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:

◆ CallScriptEffectHandlers()

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

protected

{
 // execute script effect handler hooks and check if effects was prevented
 bool preventDefault = false;
 for (auto scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_InitHit();
 
 HookList<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 call graph for this function:

Here is the caller graph for this function:

◆ CallScriptObjectAreaTargetSelectHandlers()

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

protected

{
 for (auto scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_OBJECT_AREA_TARGET_SELECT);
 auto 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:

◆ CallScriptObjectTargetSelectHandlers()

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

protected

{
 for (auto scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_OBJECT_TARGET_SELECT);
 auto 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:

◆ CallScriptOnCastHandlers()

void Spell::CallScriptOnCastHandlers ( )

protected

{
 for (auto scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_ON_CAST);
 auto 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:

◆ CallScriptOnHitHandlers()

void Spell::CallScriptOnHitHandlers ( )

protected

{
 for (auto scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_HIT);
 auto 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:

◆ CallScriptOnPrecastHandler()

void Spell::CallScriptOnPrecastHandler ( )

protected

{
 for (auto scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_ON_PRECAST);
 (*scritr)->OnPrecast();
 (*scritr)->_FinishScriptCall();
 }
}

Here is the caller graph for this function:

◆ CallScriptOnResistAbsorbCalculateHandlers()

void Spell::CallScriptOnResistAbsorbCalculateHandlers	(	DamageInfo const &	damageInfo,
		uint32 &	resistAmount,
		int32 &	absorbAmount
	)

{
 for (auto scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_ON_RESIST_ABSORB_CALCULATION);
 auto hookItrEnd = (*scritr)->OnCalculateResistAbsorb.end(), hookItr = (*scritr)->OnCalculateResistAbsorb.begin();
 for (; hookItr != hookItrEnd; ++hookItr)
 hookItr->Call(*scritr, damageInfo, resistAmount, absorbAmount);
 
 (*scritr)->_FinishScriptCall();
 }
}

Here is the caller graph for this function:

◆ CallScriptSuccessfulDispel()

void Spell::CallScriptSuccessfulDispel ( SpellEffIndex effIndex )

protected

{
 for (auto scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_EFFECT_SUCCESSFUL_DISPEL);
 auto 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:

◆ CanAutoCast()

bool Spell::CanAutoCast ( Unit * target )

{
 if (!target)
 return (CheckPetCast(target) == SPELL_CAST_OK);
 
 ObjectGuid targetguid = target->GetGUID();
 
 // check if target already has the same or a more powerful aura
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 {
 if (!spellEffectInfo.IsAura())
 continue;
 
 AuraType const& auraType = spellEffectInfo.ApplyAuraName;
 Unit::AuraEffectList const& auras = target->GetAuraEffectsByType(auraType);
 for (Unit::AuraEffectList::const_iterator auraIt = auras.begin(); auraIt != auras.end(); ++auraIt)
 {
 if (GetSpellInfo()->Id == (*auraIt)->GetSpellInfo()->Id)
 return false;
 
 switch (sSpellMgr->CheckSpellGroupStackRules(GetSpellInfo(), (*auraIt)->GetSpellInfo()))
 {
 case SPELL_GROUP_STACK_RULE_EXCLUSIVE:
 return false;
 case SPELL_GROUP_STACK_RULE_EXCLUSIVE_FROM_SAME_CASTER:
 if (GetCaster() == (*auraIt)->GetCaster())
 return false;
 break;
 case SPELL_GROUP_STACK_RULE_EXCLUSIVE_SAME_EFFECT: // this one has further checks, but i don't think they're necessary for autocast logic
 case SPELL_GROUP_STACK_RULE_EXCLUSIVE_HIGHEST:
 if (abs(spellEffectInfo.BasePoints) <= abs((*auraIt)->GetAmount()))
 return false;
 break;
 case SPELL_GROUP_STACK_RULE_DEFAULT:
 default:
 break;
 }
 }
 }
 
 SpellCastResult result = CheckPetCast(target);
 if (result == SPELL_CAST_OK || result == SPELL_FAILED_UNIT_NOT_INFRONT)
 {
 // do not check targets for ground-targeted spells (we target them on top of the intended target anyway)
 if (GetSpellInfo()->ExplicitTargetMask & TARGET_FLAG_DEST_LOCATION)
 return true;
 SelectSpellTargets();
 //check if among target units, our WANTED target is as well (->only self cast spells return false)
 for (auto ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
 if (ihit->TargetGUID == targetguid)
 return true;
 }
 // either the cast failed or the intended target wouldn't be hit
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cancel()

void Spell::cancel ( )

{
 if (m_spellState == SPELL_STATE_FINISHED)
 return;
 
 uint32 oldState = m_spellState;
 m_spellState = SPELL_STATE_FINISHED;
 
 m_autoRepeat = false;
 switch (oldState)
 {
 case SPELL_STATE_PREPARING:
 CancelGlobalCooldown();
 [[fallthrough]];
 case SPELL_STATE_DELAYED:
 SendInterrupted(0);
 SendCastResult(SPELL_FAILED_INTERRUPTED);
 break;
 
 case SPELL_STATE_CASTING:
 for (TargetInfo const& targetInfo : m_UniqueTargetInfo)
 if (targetInfo.MissCondition == SPELL_MISS_NONE)
 if (Unit* unit = m_caster->GetGUID() == targetInfo.TargetGUID ? m_caster->ToUnit() : ObjectAccessor::GetUnit(*m_caster, targetInfo.TargetGUID))
 unit->RemoveOwnedAura(m_spellInfo->Id, m_originalCasterGUID, 0, AURA_REMOVE_BY_CANCEL);
 
 SendChannelUpdate(0);
 SendInterrupted(0);
 SendCastResult(SPELL_FAILED_INTERRUPTED);
 
 m_appliedMods.clear();
 break;
 
 default:
 break;
 }
 
 SetReferencedFromCurrent(false);
 if (m_selfContainer && *m_selfContainer == this)
 *m_selfContainer = nullptr;
 
 // originalcaster handles gameobjects/dynobjects for gob caster
 if (m_originalCaster)
 {
 m_originalCaster->RemoveDynObject(m_spellInfo->Id);
 if (m_spellInfo->IsChanneled()) // if not channeled then the object for the current cast wasn't summoned yet
 m_originalCaster->RemoveGameObject(m_spellInfo->Id, true);
 }
 
 //set state back so finish will be processed
 m_spellState = oldState;
 
 finish(SPELL_FAILED_INTERRUPTED);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CancelGlobalCooldown()

void Spell::CancelGlobalCooldown ( )

protected

{
 if (!CanHaveGlobalCooldown(m_caster))
 return;
 
 if (!m_spellInfo->StartRecoveryTime)
 return;
 
 // Cancel global cooldown when interrupting current cast
 if (m_caster->ToUnit()->GetCurrentSpell(CURRENT_GENERIC_SPELL) != this)
 return;
 
 m_caster->ToUnit()->GetSpellHistory()->CancelGlobalCooldown(m_spellInfo);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanExecuteTriggersOnHit()

bool Spell::CanExecuteTriggersOnHit	(	Unit *	unit,
		SpellInfo const *	triggeredByAura = `nullptr`
	)		const

protected

{
 bool onlyOnTarget = (triggeredByAura && (triggeredByAura->HasAttribute(SPELL_ATTR4_CLASS_TRIGGER_ONLY_ON_TARGET)));
 if (!onlyOnTarget)
 return true;
 
 // If triggeredByAura has SPELL_ATTR4_CLASS_TRIGGER_ONLY_ON_TARGET then it can only proc on either noncaster units...
 if (unit != m_caster)
 return true;
 
 // ... or caster if it is the only target
 if (m_UniqueTargetInfo.size() == 1)
 return true;
 
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanOpenLock()

SpellCastResult Spell::CanOpenLock	(	SpellEffectInfo const &	effect,
		uint32	lockid,
		SkillType &	skillid,
		int32 &	reqSkillValue,
		int32 &	skillValue
	)

protected

{
 if (!lockId) // possible case for GO and maybe for items.
 return SPELL_CAST_OK;
 
 Unit const* unitCaster = m_caster->ToUnit();
 if (!unitCaster)
 return SPELL_FAILED_BAD_TARGETS;
 
 // Get LockInfo
 LockEntry const* lockInfo = sLockStore.LookupEntry(lockId);
 
 if (!lockInfo)
 return SPELL_FAILED_BAD_TARGETS;
 
 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 && int32(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 (effect.MiscValue != lockInfo->Index[j])
 continue;
 
 skillId = SkillByLockType(LockType(lockInfo->Index[j]));
 
 if (skillId != SKILL_NONE || lockInfo->Index[j] == LOCKTYPE_LOCKPICKING)
 {
 reqSkillValue = lockInfo->Skill[j];
 
 // castitem check: rogue using skeleton keys. the skill values should not be added in this case.
 skillValue = 0;
 if (!m_CastItem && unitCaster->GetTypeId() == TYPEID_PLAYER)
 skillValue = unitCaster->ToPlayer()->GetSkillValue(skillId);
 else if (lockInfo->Index[j] == LOCKTYPE_LOCKPICKING)
 skillValue = unitCaster->GetLevel() * 5;
 
 // 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;
 }
 case LOCK_KEY_SPELL:
 if (m_spellInfo->Id == uint32(lockInfo->Index[j]))
 return SPELL_CAST_OK;
 reqKey = true;
 break;
 }
 }
 
 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:

◆ cast()

void Spell::cast ( bool skipCheck = false )

{
 Player* modOwner = m_caster->GetSpellModOwner();
 Spell* lastSpellMod = nullptr;
 if (modOwner)
 {
 lastSpellMod = modOwner->m_spellModTakingSpell;
 if (lastSpellMod)
 modOwner->SetSpellModTakingSpell(lastSpellMod, false);
 }
 
 _cast(skipCheck);
 
 if (lastSpellMod)
 modOwner->SetSpellModTakingSpell(lastSpellMod, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckArenaAndRatedBattlegroundCastRules()

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_IGNORE_DEFAULT_ARENA_RESTRICTIONS))
 return SPELL_CAST_OK;
 
 // check NOT_USABLE attributes
 if (m_spellInfo->HasAttribute(SPELL_ATTR4_NOT_IN_ARENA_OR_RATED_BATTLEGROUND))
 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:

◆ CheckCast()

SpellCastResult Spell::CheckCast	(	bool	strict,
		int32 *	param1 = `nullptr`,
		int32 *	param2 = `nullptr`
	)

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

{
 // check death state
 if (m_caster->ToUnit() && !m_caster->ToUnit()->IsAlive() && !m_spellInfo->IsPassive() && !(m_spellInfo->HasAttribute(SPELL_ATTR0_ALLOW_CAST_WHILE_DEAD) || (IsTriggered() && !m_triggeredByAuraSpell)))
 return SPELL_FAILED_CASTER_DEAD;
 
 // Prevent cheating in case the player has an immunity effect and tries to interact with a non-allowed gameobject. The error message is handled by the client so we don't report anything here
 if (m_caster->ToPlayer() && m_targets.GetGOTarget())
 {
 if (m_targets.GetGOTarget()->GetGOInfo()->GetNoDamageImmune() && m_caster->ToUnit()->HasUnitFlag(UNIT_FLAG_IMMUNE))
 return SPELL_FAILED_DONT_REPORT;
 }
 
 // check cooldowns to prevent cheating
 if (!m_spellInfo->IsPassive())
 {
 if (Player const* playerCaster = m_caster->ToPlayer())
 {
 //can cast triggered (by aura only?) spells while have this flag
 if (!(_triggeredCastFlags & TRIGGERED_IGNORE_CASTER_AURASTATE))
 {
 // These two auras check SpellFamilyName defined by db2 class data instead of current spell SpellFamilyName
 if (playerCaster->HasAuraType(SPELL_AURA_DISABLE_CASTING_EXCEPT_ABILITIES)
 && !m_spellInfo->HasAttribute(SPELL_ATTR0_USES_RANGED_SLOT)
 && !m_spellInfo->HasEffect(SPELL_EFFECT_ATTACK)
 && !m_spellInfo->HasAttribute(SPELL_ATTR12_IGNORE_CASTING_DISABLED)
 && !playerCaster->HasAuraTypeWithFamilyFlags(SPELL_AURA_DISABLE_CASTING_EXCEPT_ABILITIES, sChrClassesStore.AssertEntry(playerCaster->GetClass())->SpellClassSet, m_spellInfo->SpellFamilyFlags))
 return SPELL_FAILED_CANT_DO_THAT_RIGHT_NOW;
 
 if (playerCaster->HasAuraType(SPELL_AURA_DISABLE_ATTACKING_EXCEPT_ABILITIES))
 {
 if (!playerCaster->HasAuraTypeWithFamilyFlags(SPELL_AURA_DISABLE_ATTACKING_EXCEPT_ABILITIES, sChrClassesStore.AssertEntry(playerCaster->GetClass())->SpellClassSet, m_spellInfo->SpellFamilyFlags))
 {
 if (m_spellInfo->HasAttribute(SPELL_ATTR0_USES_RANGED_SLOT)
 || m_spellInfo->IsNextMeleeSwingSpell()
 || m_spellInfo->HasAttribute(SPELL_ATTR1_INITIATES_COMBAT_ENABLES_AUTO_ATTACK)
 || m_spellInfo->HasAttribute(SPELL_ATTR2_INITIATE_COMBAT_POST_CAST_ENABLES_AUTO_ATTACK)
 || m_spellInfo->HasEffect(SPELL_EFFECT_ATTACK)
 || m_spellInfo->HasEffect(SPELL_EFFECT_NORMALIZED_WEAPON_DMG)
 || m_spellInfo->HasEffect(SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL)
 || m_spellInfo->HasEffect(SPELL_EFFECT_WEAPON_PERCENT_DAMAGE)
 || m_spellInfo->HasEffect(SPELL_EFFECT_WEAPON_DAMAGE))
 return SPELL_FAILED_CANT_DO_THAT_RIGHT_NOW;
 }
 }
 }
 
 // check if we are using a potion in combat for the 2nd+ time. Cooldown is added only after caster gets out of combat
 if (!IsIgnoringCooldowns() && playerCaster->GetLastPotionId() && m_CastItem && (m_CastItem->IsPotion() || m_spellInfo->IsCooldownStartedOnEvent()))
 return SPELL_FAILED_NOT_READY;
 }
 
 if (!IsIgnoringCooldowns() && m_caster->ToUnit())
 {
 if (!m_caster->ToUnit()->GetSpellHistory()->IsReady(m_spellInfo, m_castItemEntry))
 {
 if (m_triggeredByAuraSpell)
 return SPELL_FAILED_DONT_REPORT;
 else
 return SPELL_FAILED_NOT_READY;
 }
 
 if ((IsAutoRepeat() || m_spellInfo->CategoryId == 76) && !m_caster->ToUnit()->isAttackReady(RANGED_ATTACK))
 return SPELL_FAILED_DONT_REPORT;
 }
 }
 
 if (m_spellInfo->HasAttribute(SPELL_ATTR7_IS_CHEAT_SPELL) && m_caster->IsUnit() && !m_caster->ToUnit()->HasUnitFlag2(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 !m_spellInfo->HasAttribute(SPELL_ATTR0_COOLDOWN_ON_EVENT) ? SPELL_FAILED_NOT_READY : SPELL_FAILED_DONT_REPORT;
 
 // 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_ONLY_OUTDOORS) &&
 !m_caster->IsOutdoors())
 return SPELL_FAILED_ONLY_OUTDOORS;
 
 if (m_spellInfo->HasAttribute(SPELL_ATTR0_ONLY_INDOORS) &&
 m_caster->IsOutdoors())
 return SPELL_FAILED_ONLY_INDOORS;
 }
 
 if (Unit* unitCaster = m_caster->ToUnit())
 {
 if (m_spellInfo->HasAttribute(SPELL_ATTR5_NOT_AVAILABLE_WHILE_CHARMED) && unitCaster->IsCharmed())
 return SPELL_FAILED_CHARMED;
 
 // 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 = unitCaster->GetAuraEffectsByType(SPELL_AURA_MOD_IGNORE_SHAPESHIFT);
 for (AuraEffect const* aurEff : ignore)
 {
 if (!aurEff->IsAffectingSpell(m_spellInfo))
 continue;
 
 checkForm = false;
 break;
 }
 
 if (checkForm)
 {
 // Cannot be used in this stance/form
 SpellCastResult shapeError = m_spellInfo->CheckShapeshift(unitCaster->GetShapeshiftForm());
 if (shapeError != SPELL_CAST_OK)
 return shapeError;
 
 if (m_spellInfo->HasAttribute(SPELL_ATTR0_ONLY_STEALTHED) && !(unitCaster->HasStealthAura()))
 return SPELL_FAILED_ONLY_STEALTHED;
 }
 }
 
 bool reqCombat = true;
 Unit::AuraEffectList const& stateAuras = unitCaster->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 && !unitCaster->HasAuraState(AuraStateType(m_spellInfo->CasterAuraState), m_spellInfo, unitCaster))
 return SPELL_FAILED_CASTER_AURASTATE;
 if (m_spellInfo->ExcludeCasterAuraState && unitCaster->HasAuraState(AuraStateType(m_spellInfo->ExcludeCasterAuraState), m_spellInfo, unitCaster))
 return SPELL_FAILED_CASTER_AURASTATE;
 
 // Note: spell 62473 requres casterAuraSpell = triggering spell
 if (m_spellInfo->CasterAuraSpell && !unitCaster->HasAura(m_spellInfo->CasterAuraSpell))
 return SPELL_FAILED_CASTER_AURASTATE;
 if (m_spellInfo->ExcludeCasterAuraSpell && unitCaster->HasAura(m_spellInfo->ExcludeCasterAuraSpell))
 return SPELL_FAILED_CASTER_AURASTATE;
 
 if (m_spellInfo->CasterAuraType && !unitCaster->HasAuraType(m_spellInfo->CasterAuraType))
 return SPELL_FAILED_CASTER_AURASTATE;
 if (m_spellInfo->ExcludeCasterAuraType && unitCaster->HasAuraType(m_spellInfo->ExcludeCasterAuraType))
 return SPELL_FAILED_CASTER_AURASTATE;
 
 if (reqCombat && unitCaster->IsInCombat() && !m_spellInfo->CanBeUsedInCombat())
 return SPELL_FAILED_AFFECTING_COMBAT;
 }
 
 // Check vehicle flags
 if (!(_triggeredCastFlags & TRIGGERED_IGNORE_CASTER_MOUNTED_OR_ON_VEHICLE))
 {
 SpellCastResult vehicleCheck = m_spellInfo->CheckVehicle(unitCaster);
 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->IsPassive() && (!m_targets.GetUnitTarget() || m_targets.GetUnitTarget() == m_caster)))
 {
 // Check explicit target for m_originalCaster - todo: get rid of such workarounds
 WorldObject* caster = m_caster;
 // in case of gameobjects like traps, we need the gameobject itself to check target validity
 // otherwise, if originalCaster is far away and cannot detect the target, the trap would not hit the target
 if (m_originalCaster && !caster->ToGameObject())
 caster = m_originalCaster;
 
 SpellCastResult castResult = m_spellInfo->CheckExplicitTarget(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, m_caster->GetTypeId() == TYPEID_GAMEOBJECT); // skip stealth checks for GO casts
 if (castResult != SPELL_CAST_OK)
 return castResult;
 
 // If it's not a melee spell, check if vision is obscured by SPELL_AURA_INTERFERE_TARGETTING
 if (m_spellInfo->DmgClass != SPELL_DAMAGE_CLASS_MELEE)
 {
 if (Unit const* unitCaster = m_caster->ToUnit())
 {
 for (AuraEffect const* auraEff : unitCaster->GetAuraEffectsByType(SPELL_AURA_INTERFERE_TARGETTING))
 if (!unitCaster->IsFriendlyTo(auraEff->GetCaster()) && !target->HasAura(auraEff->GetId(), auraEff->GetCasterGUID()))
 return SPELL_FAILED_VISION_OBSCURED;
 
 for (AuraEffect const* auraEff : target->GetAuraEffectsByType(SPELL_AURA_INTERFERE_TARGETTING))
 if (!unitCaster->IsFriendlyTo(auraEff->GetCaster()) && (!target->HasAura(auraEff->GetId(), auraEff->GetCasterGUID()) || !unitCaster->HasAura(auraEff->GetId(), auraEff->GetCasterGUID())))
 return SPELL_FAILED_VISION_OBSCURED;
 }
 }
 
 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;
 
 // Ignore LOS for gameobjects casts
 if (m_caster->GetTypeId() != TYPEID_GAMEOBJECT)
 {
 WorldObject* losTarget = m_caster;
 if (IsTriggered() && m_triggeredByAuraSpell)
 if (DynamicObject* dynObj = m_caster->ToUnit()->GetDynObject(m_triggeredByAuraSpell->Id))
 losTarget = dynObj;
 
 if (!m_spellInfo->HasAttribute(SPELL_ATTR2_IGNORE_LINE_OF_SIGHT) && !DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, m_spellInfo->Id, nullptr, SPELL_DISABLE_LOS) && !target->IsWithinLOSInMap(losTarget, LINEOFSIGHT_ALL_CHECKS, VMAP::ModelIgnoreFlags::M2))
 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_IGNORE_LINE_OF_SIGHT) && !DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, m_spellInfo->Id, nullptr, SPELL_DISABLE_LOS) && !m_caster->IsWithinLOS(x, y, z, LINEOFSIGHT_ALL_CHECKS, VMAP::ModelIgnoreFlags::M2))
 return SPELL_FAILED_LINE_OF_SIGHT;
 }
 
 // check pet presence
 if (Unit* unitCaster = m_caster->ToUnit())
 {
 if (m_spellInfo->HasAttribute(SPELL_ATTR2_NO_ACTIVE_PETS))
 if (!unitCaster->GetPetGUID().IsEmpty())
 return SPELL_FAILED_ALREADY_HAVE_PET;
 
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 {
 if (spellEffectInfo.TargetA.GetTarget() == TARGET_UNIT_PET)
 {
 if (!unitCaster->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_ONLY_BATTLEGROUNDS))
 if (!m_caster->GetMap()->IsBattleground())
 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_PLAYER || !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 (!(_triggeredCastFlags & TRIGGERED_IGNORE_CASTER_MOUNTED_OR_ON_VEHICLE))
 {
 if (m_caster->GetTypeId() == TYPEID_PLAYER && m_caster->ToPlayer()->IsMounted() && !m_spellInfo->IsPassive() && !m_spellInfo->HasAttribute(SPELL_ATTR0_ALLOW_WHILE_MOUNTED))
 {
 if (m_caster->ToPlayer()->IsInFlight())
 return SPELL_FAILED_NOT_ON_TAXI;
 else
 return SPELL_FAILED_NOT_MOUNTED;
 }
 }
 
 // check spell focus object
 if (m_spellInfo->RequiresSpellFocus)
 {
 if (!m_caster->IsUnit() || !m_caster->ToUnit()->HasAuraTypeWithMiscvalue(SPELL_AURA_PROVIDE_SPELL_FOCUS, 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(param1, param2);
 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(param1);
 if (castResult != SPELL_CAST_OK)
 return castResult;
 }
 
 // script hook
 castResult = CallScriptCheckCastHandlers();
 if (castResult != SPELL_CAST_OK)
 return castResult;
 
 uint32 approximateAuraEffectMask = 0;
 uint32 nonAuraEffectMask = 0;
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 {
 // for effects of spells that have only one target
 switch (spellEffectInfo.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 (spellEffectInfo.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(spellEffectInfo.TriggerSpell, DIFFICULTY_NONE);
 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(spellEffectInfo.TriggerSpell, DIFFICULTY_NONE);
 
 if (!learn_spellproto)
 return SPELL_FAILED_NOT_KNOWN;
 
 if (m_spellInfo->SpellLevel > pet->GetLevel())
 return SPELL_FAILED_LOWLEVEL;
 }
 break;
 }
 case SPELL_EFFECT_APPLY_GLYPH:
 {
 if (m_caster->GetTypeId() != TYPEID_PLAYER)
 return SPELL_FAILED_GLYPH_NO_SPEC;
 
 Player* caster = m_caster->ToPlayer();
 if (!caster->HasSpell(m_misc.SpellId))
 return SPELL_FAILED_NOT_KNOWN;
 
 if (uint32 glyphId = spellEffectInfo.MiscValue)
 {
 GlyphPropertiesEntry const* glyphProperties = sGlyphPropertiesStore.LookupEntry(glyphId);
 if (!glyphProperties)
 return SPELL_FAILED_INVALID_GLYPH;
 
 std::vector<uint32> const* glyphBindableSpells = sDB2Manager.GetGlyphBindableSpells(glyphId);
 if (!glyphBindableSpells)
 return SPELL_FAILED_INVALID_GLYPH;
 
 if (std::find(glyphBindableSpells->begin(), glyphBindableSpells->end(), m_misc.SpellId) == glyphBindableSpells->end())
 return SPELL_FAILED_INVALID_GLYPH;
 
 if (std::vector<uint32> const* glyphRequiredSpecs = sDB2Manager.GetGlyphRequiredSpecs(glyphId))
 {
 if (!caster->GetPrimarySpecialization())
 return SPELL_FAILED_GLYPH_NO_SPEC;
 
 if (std::find(glyphRequiredSpecs->begin(), glyphRequiredSpecs->end(), caster->GetPrimarySpecialization()) == glyphRequiredSpecs->end())
 return SPELL_FAILED_GLYPH_INVALID_SPEC;
 }
 
 uint32 replacedGlyph = 0;
 for (uint32 activeGlyphId : caster->GetGlyphs(caster->GetActiveTalentGroup()))
 {
 if (std::vector<uint32> const* activeGlyphBindableSpells = sDB2Manager.GetGlyphBindableSpells(activeGlyphId))
 {
 if (std::find(activeGlyphBindableSpells->begin(), activeGlyphBindableSpells->end(), m_misc.SpellId) != activeGlyphBindableSpells->end())
 {
 replacedGlyph = activeGlyphId;
 break;
 }
 }
 }
 
 for (uint32 activeGlyphId : caster->GetGlyphs(caster->GetActiveTalentGroup()))
 {
 if (activeGlyphId == replacedGlyph)
 continue;
 
 if (activeGlyphId == glyphId)
 return SPELL_FAILED_UNIQUE_GLYPH;
 
 if (sGlyphPropertiesStore.AssertEntry(activeGlyphId)->GlyphExclusiveCategoryID == glyphProperties->GlyphExclusiveCategoryID)
 return SPELL_FAILED_GLYPH_EXCLUSIVE_CATEGORY;
 }
 }
 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 (foodItem->GetTemplate()->GetBaseItemLevel() + 30 <= pet->GetLevel())
 return SPELL_FAILED_FOOD_LOWLEVEL;
 
 if (m_caster->ToPlayer()->IsInCombat() || pet->IsInCombat())
 return SPELL_FAILED_AFFECTING_COMBAT;
 
 break;
 }
 case SPELL_EFFECT_CHARGE:
 {
 Unit* unitCaster = m_caster->ToUnit();
 if (!unitCaster)
 return SPELL_FAILED_BAD_TARGETS;
 
 if (!(_triggeredCastFlags & TRIGGERED_IGNORE_CASTER_AURAS) && unitCaster->HasUnitState(UNIT_STATE_ROOT))
 return SPELL_FAILED_ROOTED;
 
 if (GetSpellInfo()->NeedsExplicitUnitTarget())
 {
 Unit* target = m_targets.GetUnitTarget();
 if (!target)
 return SPELL_FAILED_DONT_REPORT;
 
 // first we must check to see if the target is in LoS. A path can usually be built but LoS matters for charge spells
 if (!target->IsWithinLOSInMap(unitCaster)) //Do full LoS/Path check. Don't exclude m2
 return SPELL_FAILED_LINE_OF_SIGHT;
 
 float objSize = target->GetCombatReach();
 float range = m_spellInfo->GetMaxRange(true, unitCaster, this) * 1.5f + objSize; // can't be overly strict
 
 m_preGeneratedPath = std::make_unique<PathGenerator>(unitCaster);
 m_preGeneratedPath->SetPathLengthLimit(range);
 
 // first try with raycast, if it fails fall back to normal path
 bool result = m_preGeneratedPath->CalculatePath(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), false);
 if (m_preGeneratedPath->GetPathType() & PATHFIND_SHORT)
 return SPELL_FAILED_NOPATH;
 else if (!result || m_preGeneratedPath->GetPathType() & (PATHFIND_NOPATH | PATHFIND_INCOMPLETE))
 return SPELL_FAILED_NOPATH;
 else if (m_preGeneratedPath->IsInvalidDestinationZ(target)) // Check position z, if not in a straight line
 return SPELL_FAILED_NOPATH;
 
 m_preGeneratedPath->ShortenPathUntilDist(PositionToVector3(target), 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()->HasUnitFlag(UNIT_FLAG_SKINNABLE))
 return SPELL_FAILED_TARGET_UNSKINNABLE;
 
 Creature* creature = m_targets.GetUnitTarget()->ToCreature();
 Loot* loot = creature->GetLootForPlayer(m_caster->ToPlayer());
 if (loot && (!loot->isLooted() || loot->loot_type == LOOT_SKINNING))
 return SPELL_FAILED_TARGET_NOT_LOOTED;
 
 uint32 skill = creature->GetCreatureTemplate()->GetRequiredLootSkill();
 
 int32 skillValue = m_caster->ToPlayer()->GetSkillValue(skill);
 int32 TargetLevel = m_targets.GetUnitTarget()->GetLevelForTarget(m_caster);
 int32 ReqValue = (skillValue < 100 ? (TargetLevel-10) * 10 : TargetLevel * 5);
 if (ReqValue > skillValue)
 return SPELL_FAILED_LOW_CASTLEVEL;
 
 break;
 }
 case SPELL_EFFECT_OPEN_LOCK:
 {
 if (spellEffectInfo.TargetA.GetTarget() != TARGET_GAMEOBJECT_TARGET &&
 spellEffectInfo.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
 || (spellEffectInfo.TargetA.GetTarget() == TARGET_GAMEOBJECT_TARGET && !m_targets.GetGOTarget()))
 return SPELL_FAILED_BAD_TARGETS;
 
 Item* pTempItem = nullptr;
 if (m_targets.GetTargetMask() & TARGET_FLAG_TRADE_ITEM)
 {
 if (TradeData* pTrade = m_caster->ToPlayer()->GetTradeData())
 pTempItem = pTrade->GetTraderData()->GetItem(TRADE_SLOT_NONTRADED);
 }
 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 (spellEffectInfo.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;
 
 if (go->GetGOInfo()->GetNotInCombat() && m_caster->ToUnit()->IsInCombat())
 return SPELL_FAILED_AFFECTING_COMBAT;
 }
 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(spellEffectInfo, lockId, skillId, reqSkillValue, skillValue);
 if (res != SPELL_CAST_OK)
 return res;
 break;
 }
 case SPELL_EFFECT_RESURRECT_PET:
 {
 Player* playerCaster = m_caster->ToPlayer();
 if (!playerCaster || !playerCaster->GetPetStable())
 return SPELL_FAILED_BAD_TARGETS;
 
 Pet* pet = playerCaster->GetPet();
 if (pet && pet->IsAlive())
 return SPELL_FAILED_ALREADY_HAVE_SUMMON;
 
 PetStable const* petStable = playerCaster->GetPetStable();
 auto deadPetItr = std::find_if(petStable->ActivePets.begin(), petStable->ActivePets.end(), [](Optional<PetStable::PetInfo> const& petInfo)
 {
 return petInfo && !petInfo->Health;
 });
 
 if (deadPetItr == petStable->ActivePets.end())
 return SPELL_FAILED_BAD_TARGETS;
 
 break;
 }
 // This is generic summon effect
 case SPELL_EFFECT_SUMMON:
 {
 Unit* unitCaster = m_caster->ToUnit();
 if (!unitCaster)
 break;
 
 SummonPropertiesEntry const* SummonProperties = sSummonPropertiesStore.LookupEntry(spellEffectInfo.MiscValueB);
 if (!SummonProperties)
 break;
 
 switch (SummonProperties->Control)
 {
 case SUMMON_CATEGORY_PET:
 if (!m_spellInfo->HasAttribute(SPELL_ATTR1_DISMISS_PET_FIRST) && !unitCaster->GetPetGUID().IsEmpty())
 return SPELL_FAILED_ALREADY_HAVE_SUMMON;
 [[fallthrough]]; // check both GetPetGUID() and GetCharmGUID for SUMMON_CATEGORY_PET
 case SUMMON_CATEGORY_PUPPET:
 if (!unitCaster->GetCharmedGUID().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_spellInfo->HasAttribute(SPELL_ATTR1_DISMISS_PET_FIRST) && !m_targets.GetUnitTarget()->GetPetGUID().IsEmpty())
 return SPELL_FAILED_ALREADY_HAVE_SUMMON;
 }
 break;
 }
 case SPELL_EFFECT_SUMMON_PET:
 {
 Unit* unitCaster = m_caster->ToUnit();
 if (!unitCaster)
 return SPELL_FAILED_BAD_TARGETS;
 
 if (!unitCaster->GetPetGUID().IsEmpty()) //let warlock do a replacement summon
 {
 if (unitCaster->GetTypeId() == TYPEID_PLAYER)
 {
 if (strict) //starting cast, trigger pet stun (cast by pet so it doesn't attack player)
 if (Pet* pet = unitCaster->ToPlayer()->GetPet())
 pet->CastSpell(pet, 32752, CastSpellExtraArgs(TRIGGERED_FULL_MASK)
 .SetOriginalCaster(pet->GetGUID())
 .SetTriggeringSpell(this));
 }
 else if (!m_spellInfo->HasAttribute(SPELL_ATTR1_DISMISS_PET_FIRST))
 return SPELL_FAILED_ALREADY_HAVE_SUMMON;
 }
 
 if (!unitCaster->GetCharmedGUID().IsEmpty())
 return SPELL_FAILED_ALREADY_HAVE_CHARM;
 
 Player* playerCaster = unitCaster->ToPlayer();
 if (playerCaster && playerCaster->GetPetStable())
 {
 Optional<PetSaveMode> petSlot;
 if (!spellEffectInfo.MiscValue)
 {
 petSlot = PetSaveMode(spellEffectInfo.CalcValue());
 
 // No pet can be summoned if any pet is dead
 for (Optional<PetStable::PetInfo> const& activePet : playerCaster->GetPetStable()->ActivePets)
 {
 if (activePet && !activePet->Health)
 {
 playerCaster->SendTameFailure(PetTameResult::Dead);
 return SPELL_FAILED_DONT_REPORT;
 }
 }
 }
 
 std::pair<PetStable::PetInfo const*, PetSaveMode> info = Pet::GetLoadPetInfo(*playerCaster->GetPetStable(), spellEffectInfo.MiscValue, 0, petSlot);
 if (info.first)
 {
 if (info.first->Type == HUNTER_PET)
 {
 CreatureTemplate const* creatureInfo = sObjectMgr->GetCreatureTemplate(info.first->CreatureId);
 if (!creatureInfo || !creatureInfo->IsTameable(playerCaster->CanTameExoticPets()))
 {
 // if problem in exotic pet
  if (creatureInfo && creatureInfo->IsTameable(true))
 playerCaster->SendTameFailure(PetTameResult::CantControlExotic);
 else
 playerCaster->SendTameFailure(PetTameResult::NoPetAvailable);
 
 return SPELL_FAILED_DONT_REPORT;
 }
 }
 }
 else if (!spellEffectInfo.MiscValue) // when miscvalue is present it is allowed to create new pets
 {
 playerCaster->SendTameFailure(PetTameResult::NoPetAvailable);
 return SPELL_FAILED_DONT_REPORT;
 }
 }
 
 break;
 }
 case SPELL_EFFECT_DISMISS_PET:
 {
 Player* playerCaster = m_caster->ToPlayer();
 if (!playerCaster)
 return SPELL_FAILED_BAD_TARGETS;
 
 Pet* pet = playerCaster->GetPet();
 if (!pet)
 return SPELL_FAILED_NO_PET;
 
 if (!pet->IsAlive())
 return SPELL_FAILED_TARGETS_DEAD;
 
 break;
 }
 case SPELL_EFFECT_SUMMON_PLAYER:
 {
 if (m_caster->GetTypeId() != TYPEID_PLAYER)
 return SPELL_FAILED_BAD_TARGETS;
 
 if (!m_caster->ToPlayer()->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;
 
 if (target->HasSummonPending())
 return SPELL_FAILED_SUMMON_PENDING;
 
 // check if our map is dungeon
 if (InstanceMap const* map = m_caster->GetMap()->ToInstanceMap())
 {
 uint32 mapId = map->GetId();
 Difficulty difficulty = map->GetDifficultyID();
 if (InstanceLock const* mapLock = map->GetInstanceLock())
 if (sInstanceLockMgr.CanJoinInstanceLock(target->GetGUID(), { mapId, difficulty }, mapLock) != TRANSFER_ABORT_NONE)
 return SPELL_FAILED_TARGET_LOCKED_TO_RAID_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_targets.GetUnitTarget() == m_caster)
 return SPELL_FAILED_BAD_TARGETS;
 break;
 }
 case SPELL_EFFECT_LEAP_BACK:
 {
 Unit* unitCaster = m_caster->ToUnit();
 if (!unitCaster)
 return SPELL_FAILED_BAD_TARGETS;
 
 if (unitCaster->HasUnitState(UNIT_STATE_ROOT))
 {
 if (unitCaster->GetTypeId() == TYPEID_PLAYER)
 return SPELL_FAILED_ROOTED;
 else
 return SPELL_FAILED_DONT_REPORT;
 }
 break;
 }
 case SPELL_EFFECT_JUMP:
 case SPELL_EFFECT_JUMP_DEST:
 {
 Unit* unitCaster = m_caster->ToUnit();
 if (!unitCaster)
 return SPELL_FAILED_BAD_TARGETS;
 
 if (unitCaster->HasUnitState(UNIT_STATE_ROOT))
 return SPELL_FAILED_ROOTED;
 break;
 }
 case SPELL_EFFECT_TALENT_SPEC_SELECT:
 {
 ChrSpecializationEntry const* spec = sChrSpecializationStore.LookupEntry(m_misc.SpecializationId);
 Player* player = m_caster->ToPlayer();
 if (!player)
 return SPELL_FAILED_TARGET_NOT_PLAYER;
 
 if (!spec || (spec->ClassID != player->GetClass() && !spec->IsPetSpecialization()))
 return SPELL_FAILED_NO_SPEC;
 
 if (spec->IsPetSpecialization())
 {
 Pet* pet = player->GetPet();
 if (!pet || pet->getPetType() != HUNTER_PET || !pet->GetCharmInfo())
 return SPELL_FAILED_NO_PET;
 }
 
 // can't change during already started arena/battleground
 if (Battleground const* bg = player->GetBattleground())
 if (bg->GetStatus() == STATUS_IN_PROGRESS)
 return SPELL_FAILED_NOT_IN_BATTLEGROUND;
 break;
 }
 case SPELL_EFFECT_REMOVE_TALENT:
 {
 Player* playerCaster = m_caster->ToPlayer();
 if (!playerCaster)
 return SPELL_FAILED_BAD_TARGETS;
 
 TalentEntry const* talent = sTalentStore.LookupEntry(m_misc.TalentId);
 if (!talent)
 return SPELL_FAILED_DONT_REPORT;
 
 if (playerCaster->GetSpellHistory()->HasCooldown(talent->SpellID))
 {
 if (param1)
 *param1 = talent->SpellID;
 return SPELL_FAILED_CANT_UNTALENT;
 }
 break;
 }
 case SPELL_EFFECT_GIVE_ARTIFACT_POWER:
 case SPELL_EFFECT_GIVE_ARTIFACT_POWER_NO_BONUS:
 {
 Player* playerCaster = m_caster->ToPlayer();
 if (!playerCaster)
 return SPELL_FAILED_BAD_TARGETS;
 
 Aura* artifactAura = playerCaster->GetAura(ARTIFACTS_ALL_WEAPONS_GENERAL_WEAPON_EQUIPPED_PASSIVE);
 if (!artifactAura)
 return SPELL_FAILED_NO_ARTIFACT_EQUIPPED;
 
 Item* artifact = playerCaster->GetItemByGuid(artifactAura->GetCastItemGUID());
 if (!artifact)
 return SPELL_FAILED_NO_ARTIFACT_EQUIPPED;
 
 if (spellEffectInfo.Effect == SPELL_EFFECT_GIVE_ARTIFACT_POWER)
 {
 ArtifactEntry const* artifactEntry = sArtifactStore.LookupEntry(artifact->GetTemplate()->GetArtifactID());
 if (!artifactEntry || artifactEntry->ArtifactCategoryID != spellEffectInfo.MiscValue)
 return SPELL_FAILED_WRONG_ARTIFACT_EQUIPPED;
 }
 break;
 }
 case SPELL_EFFECT_CHANGE_BATTLEPET_QUALITY:
 case SPELL_EFFECT_GRANT_BATTLEPET_LEVEL:
 case SPELL_EFFECT_GRANT_BATTLEPET_EXPERIENCE:
 {
 Player* playerCaster = m_caster->ToPlayer();
 if (!playerCaster || !m_targets.GetUnitTarget() || !m_targets.GetUnitTarget()->IsCreature())
 return SPELL_FAILED_BAD_TARGETS;
 
 BattlePets::BattlePetMgr* battlePetMgr = playerCaster->GetSession()->GetBattlePetMgr();
 if (!battlePetMgr->HasJournalLock())
 return SPELL_FAILED_CANT_DO_THAT_RIGHT_NOW;
 
 Creature* creature = m_targets.GetUnitTarget()->ToCreature();
 if (creature)
 {
 if (playerCaster->GetSummonedBattlePetGUID().IsEmpty() || creature->GetBattlePetCompanionGUID().IsEmpty())
 return SPELL_FAILED_NO_PET;
 
 if (playerCaster->GetSummonedBattlePetGUID() != creature->GetBattlePetCompanionGUID())
 return SPELL_FAILED_BAD_TARGETS;
 
 if (BattlePets::BattlePet* battlePet = battlePetMgr->GetPet(creature->GetBattlePetCompanionGUID()))
 {
 if (BattlePetSpeciesEntry const* battlePetSpecies = sBattlePetSpeciesStore.LookupEntry(battlePet->PacketInfo.Species))
 {
 if (uint32 battlePetType = spellEffectInfo.MiscValue)
 if (!(battlePetType & (1 << battlePetSpecies->PetTypeEnum)))
 return SPELL_FAILED_WRONG_BATTLE_PET_TYPE;
 
 if (spellEffectInfo.Effect == SPELL_EFFECT_CHANGE_BATTLEPET_QUALITY)
 {
 auto qualityItr = std::lower_bound(sBattlePetBreedQualityStore.begin(), sBattlePetBreedQualityStore.end(), spellEffectInfo.BasePoints, [](BattlePetBreedQualityEntry const* a1, int32 selector)
 {
 return a1->MaxQualityRoll < selector;
 });
 
 BattlePets::BattlePetBreedQuality quality = BattlePets::BattlePetBreedQuality::Poor;
 if (qualityItr != sBattlePetBreedQualityStore.end())
 quality = BattlePets::BattlePetBreedQuality(qualityItr->QualityEnum);
 
 if (battlePet->PacketInfo.Quality >= AsUnderlyingType(quality))
 return SPELL_FAILED_CANT_UPGRADE_BATTLE_PET;
 }
 
 if (spellEffectInfo.Effect == SPELL_EFFECT_GRANT_BATTLEPET_LEVEL || spellEffectInfo.Effect == SPELL_EFFECT_GRANT_BATTLEPET_EXPERIENCE)
 if (battlePet->PacketInfo.Level >= BattlePets::MAX_BATTLE_PET_LEVEL)
 return GRANT_PET_LEVEL_FAIL;
 
 if (battlePetSpecies->GetFlags().HasFlag(BattlePetSpeciesFlags::CantBattle))
 return SPELL_FAILED_BAD_TARGETS;
 }
 }
 }
 break;
 }
 default:
 break;
 }
 
 if (spellEffectInfo.IsAura())
 approximateAuraEffectMask |= 1 << spellEffectInfo.EffectIndex;
 else if (spellEffectInfo.IsEffect())
 nonAuraEffectMask |= 1 << spellEffectInfo.EffectIndex;
 }
 
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 {
 switch (spellEffectInfo.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_ALREADY_HAVE_CHARM;
 break;
 }
 case SPELL_AURA_MOD_POSSESS:
 case SPELL_AURA_MOD_CHARM:
 case SPELL_AURA_AOE_CHARM:
 {
 Unit* unitCaster = (m_originalCaster ? m_originalCaster : m_caster->ToUnit());
 if (!unitCaster)
 return SPELL_FAILED_BAD_TARGETS;
 
 if (!unitCaster->GetCharmerGUID().IsEmpty())
 return SPELL_FAILED_CHARMED;
 
 if (spellEffectInfo.ApplyAuraName == SPELL_AURA_MOD_CHARM
 || spellEffectInfo.ApplyAuraName == SPELL_AURA_MOD_POSSESS)
 {
 if (!m_spellInfo->HasAttribute(SPELL_ATTR1_DISMISS_PET_FIRST) && !unitCaster->GetPetGUID().IsEmpty())
 return SPELL_FAILED_ALREADY_HAVE_SUMMON;
 
 if (!unitCaster->GetCharmedGUID().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_ALREADY_HAVE_CHARM;
 
 if (target->GetOwner() && target->GetOwner()->GetTypeId() == TYPEID_PLAYER)
 return SPELL_FAILED_TARGET_IS_PLAYER_CONTROLLED;
 
 int32 value = CalculateDamage(spellEffectInfo, target);
 if (value && int32(target->GetLevelForTarget(m_caster)) > value)
 return SPELL_FAILED_HIGHLEVEL;
 }
 
 break;
 }
 case SPELL_AURA_MOUNTED:
 {
 Unit* unitCaster = m_caster->ToUnit();
 if (!unitCaster)
 return SPELL_FAILED_BAD_TARGETS;
 
 if (unitCaster->IsInWater() && m_spellInfo->HasAura(SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED))
 return SPELL_FAILED_ONLY_ABOVEWATER;
 
 if (unitCaster->IsInDisallowedMountForm())
 {
 SendMountResult(MountResult::Shapeshifted); // mount result gets sent before the cast result
 return SPELL_FAILED_DONT_REPORT;
 }
 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->GetMap(), 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 SPELL_FAILED_NOT_HERE;
 }
 break;
 }
 case SPELL_AURA_PERIODIC_MANA_LEECH:
 {
 if (spellEffectInfo.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 if target already has the same type, but more powerful aura
 if (!m_spellInfo->HasAttribute(SPELL_ATTR4_AURA_NEVER_BOUNCES)
 && (!nonAuraEffectMask || m_spellInfo->HasAttribute(SPELL_ATTR4_AURA_BOUNCE_FAILS_SPELL))
 && (approximateAuraEffectMask & (1 << spellEffectInfo.EffectIndex))
 && !m_spellInfo->IsTargetingArea())
 if (Unit* target = m_targets.GetUnitTarget())
 if (!target->IsHighestExclusiveAuraEffect(m_spellInfo, spellEffectInfo.ApplyAuraName,
 spellEffectInfo.CalcValue(m_caster, &m_spellValue->EffectBasePoints[spellEffectInfo.EffectIndex], nullptr, nullptr, m_castItemEntry, m_castItemLevel),
 approximateAuraEffectMask, false))
 return SPELL_FAILED_AURA_BOUNCED;
 }
 
 // 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_spellInfo->HasAttribute(SPELL_ATTR2_ENCHANT_OWN_ITEM_ONLY))
 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 call graph for this function:

Here is the caller graph for this function:

◆ CheckCasterAuras()

SpellCastResult Spell::CheckCasterAuras ( int32 * param1 ) const

{
 Unit* unitCaster = (m_originalCaster ? m_originalCaster : m_caster->ToUnit());
 if (!unitCaster)
 return SPELL_CAST_OK;
 
 // these attributes only show the spell as usable on the client when it has related aura applied
 // still they need to be checked against certain mechanics
 
 // SPELL_ATTR5_USABLE_WHILE_STUNNED by default only MECHANIC_STUN (ie no sleep, knockout, freeze, etc.)
 bool usableWhileStunned = m_spellInfo->HasAttribute(SPELL_ATTR5_ALLOW_WHILE_STUNNED);
 
 // SPELL_ATTR5_USABLE_WHILE_FEARED by default only fear (ie no horror)
 bool usableWhileFeared = m_spellInfo->HasAttribute(SPELL_ATTR5_ALLOW_WHILE_FLEEING);
 
 // SPELL_ATTR5_USABLE_WHILE_CONFUSED by default only disorient (ie no polymorph)
 bool usableWhileConfused = m_spellInfo->HasAttribute(SPELL_ATTR5_ALLOW_WHILE_CONFUSED);
 
 // Check whether the cast should be prevented by any state you might have.
 SpellCastResult result = SPELL_CAST_OK;
 
 // Get unit state
 uint32 const unitflag = unitCaster->m_unitData->Flags;
 
 // this check should only be done when player does cast directly
 // (ie not when it's called from a script) Breaks for example PlayerAI when charmed
 /*
 if (!unitCaster->GetCharmerGUID().IsEmpty())
 {
 if (Unit* charmer = unitCaster->GetCharmer())
 if (charmer->GetUnitBeingMoved() != unitCaster && !CheckSpellCancelsCharm(param1))
 result = SPELL_FAILED_CHARMED;
 }
 */
 
 // spell has attribute usable while having a cc state, check if caster has allowed mechanic auras, another mechanic types must prevent cast spell
 auto mechanicCheck = [&](AuraType type) -> SpellCastResult
 {
 bool foundNotMechanic = false;
 Unit::AuraEffectList const& auras = unitCaster->GetAuraEffectsByType(type);
 for (AuraEffect const* aurEff : auras)
 {
 uint64 const mechanicMask = aurEff->GetSpellInfo()->GetAllEffectsMechanicMask();
 if (mechanicMask && !(mechanicMask & GetSpellInfo()->GetAllowedMechanicMask()))
 {
 foundNotMechanic = true;
 
 // fill up aura mechanic info to send client proper error message
 if (param1)
 {
 *param1 = aurEff->GetSpellEffectInfo().Mechanic;
 if (!*param1)
 *param1 = aurEff->GetSpellInfo()->Mechanic;
 }
 
 break;
 }
 }
 
 if (foundNotMechanic)
 {
 switch (type)
 {
 case SPELL_AURA_MOD_STUN:
 case SPELL_AURA_MOD_STUN_DISABLE_GRAVITY:
 return SPELL_FAILED_STUNNED;
 case SPELL_AURA_MOD_FEAR:
 return SPELL_FAILED_FLEEING;
 case SPELL_AURA_MOD_CONFUSE:
 return SPELL_FAILED_CONFUSED;
 default:
 ABORT();
 

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Friends

Member Typedef Documentation

◆ HitTriggerSpellList

◆ UsedSpellMods

Constructor & Destructor Documentation

◆ Spell() [1/2]

◆ ~Spell()

◆ Spell() [2/2]

Member Function Documentation

◆ _cast()

◆ _handle_finish_phase()

◆ _handle_immediate_phase()

◆ AddCorpseTarget()

◆ AddDestTarget()

◆ AddGOTarget()

◆ AddItemTarget()

◆ AddUnitTarget()

◆ CalculateDamage()

◆ CalculateDelayMomentForDst()

◆ CalculateJumpSpeeds()

◆ CallScriptAfterCastHandlers()

◆ CallScriptAfterHitHandlers()

◆ CallScriptBeforeCastHandlers()

◆ CallScriptBeforeHitHandlers()

◆ CallScriptCalcCastTimeHandlers()

◆ CallScriptCalcCritChanceHandlers()

◆ CallScriptCheckCastHandlers()

◆ CallScriptDestinationTargetSelectHandlers()

◆ CallScriptEffectHandlers()

◆ CallScriptObjectAreaTargetSelectHandlers()

◆ CallScriptObjectTargetSelectHandlers()

◆ CallScriptOnCastHandlers()

◆ CallScriptOnHitHandlers()

◆ CallScriptOnPrecastHandler()

◆ CallScriptOnResistAbsorbCalculateHandlers()

◆ CallScriptSuccessfulDispel()

◆ CanAutoCast()

◆ cancel()

◆ CancelGlobalCooldown()

◆ CanExecuteTriggersOnHit()

◆ CanOpenLock()

◆ cast()

◆ CheckArenaAndRatedBattlegroundCastRules()

◆ CheckCast()

◆ CheckCasterAuras()