#include "Spell.h"

Classes
struct	GOTargetInfo

struct	HitTriggerSpell

struct	ItemTargetInfo

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

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

	~Spell ()

void	EffectNULL (SpellEffIndex effIndex)

void	EffectUnused (SpellEffIndex effIndex)

void	EffectDistract (SpellEffIndex effIndex)

void	EffectPull (SpellEffIndex effIndex)

void	EffectSchoolDMG (SpellEffIndex effIndex)

void	EffectEnvironmentalDMG (SpellEffIndex effIndex)

void	EffectInstaKill (SpellEffIndex effIndex)

void	EffectDummy (SpellEffIndex effIndex)

void	EffectTeleportUnits (SpellEffIndex effIndex)

void	EffectApplyAura (SpellEffIndex effIndex)

void	EffectSendEvent (SpellEffIndex effIndex)

void	EffectPowerBurn (SpellEffIndex effIndex)

void	EffectPowerDrain (SpellEffIndex effIndex)

void	EffectHeal (SpellEffIndex effIndex)

void	EffectBind (SpellEffIndex effIndex)

void	EffectHealthLeech (SpellEffIndex effIndex)

void	EffectQuestComplete (SpellEffIndex effIndex)

void	EffectCreateItem (SpellEffIndex effIndex)

void	EffectCreateItem2 (SpellEffIndex effIndex)

void	EffectCreateRandomItem (SpellEffIndex effIndex)

void	EffectPersistentAA (SpellEffIndex effIndex)

void	EffectEnergize (SpellEffIndex effIndex)

void	EffectOpenLock (SpellEffIndex effIndex)

void	EffectSummonChangeItem (SpellEffIndex effIndex)

void	EffectProficiency (SpellEffIndex effIndex)

void	EffectApplyAreaAura (SpellEffIndex effIndex)

void	EffectSummonType (SpellEffIndex effIndex)

void	EffectLearnSpell (SpellEffIndex effIndex)

void	EffectDispel (SpellEffIndex effIndex)

void	EffectDualWield (SpellEffIndex effIndex)

void	EffectPickPocket (SpellEffIndex effIndex)

void	EffectAddFarsight (SpellEffIndex effIndex)

void	EffectUntrainTalents (SpellEffIndex effIndex)

void	EffectHealMechanical (SpellEffIndex effIndex)

void	EffectJump (SpellEffIndex effIndex)

void	EffectJumpDest (SpellEffIndex effIndex)

void	EffectLeapBack (SpellEffIndex effIndex)

void	EffectQuestClear (SpellEffIndex effIndex)

void	EffectTeleUnitsFaceCaster (SpellEffIndex effIndex)

void	EffectLearnSkill (SpellEffIndex effIndex)

void	EffectAddHonor (SpellEffIndex effIndex)

void	EffectTradeSkill (SpellEffIndex effIndex)

void	EffectEnchantItemPerm (SpellEffIndex effIndex)

void	EffectEnchantItemTmp (SpellEffIndex effIndex)

void	EffectTameCreature (SpellEffIndex effIndex)

void	EffectSummonPet (SpellEffIndex effIndex)

void	EffectLearnPetSpell (SpellEffIndex effIndex)

void	EffectWeaponDmg (SpellEffIndex effIndex)

void	EffectForceCast (SpellEffIndex effIndex)

void	EffectTriggerSpell (SpellEffIndex effIndex)

void	EffectTriggerMissileSpell (SpellEffIndex effIndex)

void	EffectThreat (SpellEffIndex effIndex)

void	EffectHealMaxHealth (SpellEffIndex effIndex)

void	EffectInterruptCast (SpellEffIndex effIndex)

void	EffectSummonObjectWild (SpellEffIndex effIndex)

void	EffectScriptEffect (SpellEffIndex effIndex)

void	EffectSanctuary (SpellEffIndex effIndex)

void	EffectAddComboPoints (SpellEffIndex effIndex)

void	EffectDuel (SpellEffIndex effIndex)

void	EffectStuck (SpellEffIndex effIndex)

void	EffectSummonPlayer (SpellEffIndex effIndex)

void	EffectActivateObject (SpellEffIndex effIndex)

void	EffectApplyGlyph (SpellEffIndex effIndex)

void	EffectEnchantHeldItem (SpellEffIndex effIndex)

void	EffectSummonObject (SpellEffIndex effIndex)

void	EffectResurrect (SpellEffIndex effIndex)

void	EffectParry (SpellEffIndex effIndex)

void	EffectBlock (SpellEffIndex effIndex)

void	EffectLeap (SpellEffIndex effIndex)

void	EffectTransmitted (SpellEffIndex effIndex)

void	EffectDisEnchant (SpellEffIndex effIndex)

void	EffectInebriate (SpellEffIndex effIndex)

void	EffectFeedPet (SpellEffIndex effIndex)

void	EffectDismissPet (SpellEffIndex effIndex)

void	EffectReputation (SpellEffIndex effIndex)

void	EffectForceDeselect (SpellEffIndex effIndex)

void	EffectSelfResurrect (SpellEffIndex effIndex)

void	EffectSkinning (SpellEffIndex effIndex)

void	EffectCharge (SpellEffIndex effIndex)

void	EffectChargeDest (SpellEffIndex effIndex)

void	EffectProspecting (SpellEffIndex effIndex)

void	EffectMilling (SpellEffIndex effIndex)

void	EffectRenamePet (SpellEffIndex effIndex)

void	EffectSendTaxi (SpellEffIndex effIndex)

void	EffectSummonCritter (SpellEffIndex effIndex)

void	EffectKnockBack (SpellEffIndex effIndex)

void	EffectPullTowards (SpellEffIndex effIndex)

void	EffectDispelMechanic (SpellEffIndex effIndex)

void	EffectResurrectPet (SpellEffIndex effIndex)

void	EffectDestroyAllTotems (SpellEffIndex effIndex)

void	EffectDurabilityDamage (SpellEffIndex effIndex)

void	EffectSkill (SpellEffIndex effIndex)

void	EffectTaunt (SpellEffIndex effIndex)

void	EffectDurabilityDamagePCT (SpellEffIndex effIndex)

void	EffectModifyThreatPercent (SpellEffIndex effIndex)

void	EffectResurrectNew (SpellEffIndex effIndex)

void	EffectAddExtraAttacks (SpellEffIndex effIndex)

void	EffectSpiritHeal (SpellEffIndex effIndex)

void	EffectSkinPlayerCorpse (SpellEffIndex effIndex)

void	EffectStealBeneficialBuff (SpellEffIndex effIndex)

void	EffectUnlearnSpecialization (SpellEffIndex effIndex)

void	EffectHealPct (SpellEffIndex effIndex)

void	EffectEnergizePct (SpellEffIndex effIndex)

void	EffectTriggerRitualOfSummoning (SpellEffIndex effIndex)

void	EffectSummonRaFFriend (SpellEffIndex effIndex)

void	EffectKillCreditPersonal (SpellEffIndex effIndex)

void	EffectKillCredit (SpellEffIndex effIndex)

void	EffectQuestFail (SpellEffIndex effIndex)

void	EffectQuestStart (SpellEffIndex effIndex)

void	EffectRedirectThreat (SpellEffIndex effIndex)

void	EffectGameObjectDamage (SpellEffIndex effIndex)

void	EffectGameObjectRepair (SpellEffIndex effIndex)

void	EffectGameObjectSetDestructionState (SpellEffIndex effIndex)

void	EffectActivateRune (SpellEffIndex effIndex)

void	EffectCreateTamedPet (SpellEffIndex effIndex)

void	EffectDiscoverTaxi (SpellEffIndex effIndex)

void	EffectTitanGrip (SpellEffIndex effIndex)

void	EffectEnchantItemPrismatic (SpellEffIndex effIndex)

void	EffectPlayMusic (SpellEffIndex effIndex)

void	EffectSpecCount (SpellEffIndex effIndex)

void	EffectActivateSpec (SpellEffIndex effIndex)

void	EffectPlaySound (SpellEffIndex effIndex)

void	EffectRemoveAura (SpellEffIndex effIndex)

void	EffectCastButtons (SpellEffIndex effIndex)

void	EffectRechargeManaGem (SpellEffIndex effIndex)

void	InitExplicitTargets (SpellCastTargets const &targets)

void	SelectExplicitTargets ()

void	SelectSpellTargets ()

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

void	SelectImplicitChannelTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType)

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

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

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

void	SelectImplicitCasterDestTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitTargetDestTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitDestDestTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitCasterObjectTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitTargetObjectTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType)

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

void	SelectImplicitTrajTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType)

void	SelectEffectTypeImplicitTargets (uint8 effIndex)

uint32	GetSearcherTypeMask (SpellTargetObjectTypes objType, ConditionList *condList)

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

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

void	SearchAreaTargets (std::list< WorldObject * > &targets, float range, Position const position, Unit referer, SpellTargetObjectTypes objectType, SpellTargetCheckTypes selectionType, ConditionList *condList, Acore::WorldObjectSpellAreaTargetSearchReason searchReason=Acore::WorldObjectSpellAreaTargetSearchReason::Area)

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

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

void	cancel (bool bySelf=false)

void	update (uint32 difftime)

void	cast (bool skipCheck=false)

void	_cast (bool skipCheck)

void	finish (bool ok=true)

void	TakePower ()

void	TakeAmmo ()

void	TakeRunePower (bool didHit)

void	TakeReagents ()

void	TakeCastItem ()

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

SpellCastResult	CheckPetCast (Unit *target)

void	handle_immediate ()

uint64	handle_delayed (uint64 t_offset)

void	_handle_immediate_phase ()

void	_handle_finish_phase ()

void	OnSpellLaunch ()

SpellCastResult	CheckItems (uint32 param1=nullptr, uint32 param2=nullptr)

SpellCastResult	CheckSpellFocus ()

SpellCastResult	CheckRange (bool strict)

SpellCastResult	CheckPower ()

SpellCastResult	CheckRuneCost (uint32 RuneCostID)

SpellCastResult	CheckCasterAuras (bool preventionOnly) const

int32	CalculateSpellDamage (uint8 i, Unit const *target) const

bool	HaveTargetsForEffect (uint8 effect) const

void	Delayed ()

void	DelayedChannel ()

uint32	getState () const

void	setState (uint32 state)

void	DoCreateItem (uint8 effIndex, uint32 itemId)

void	WriteSpellGoTargets (WorldPacket *data)
	Writes miss and hit targets for a SMSG_SPELL_GO packet.

void	WriteAmmoToPacket (WorldPacket *data)

bool	CheckEffectTarget (Unit const *target, uint32 eff) const

bool	CanAutoCast (Unit *target)

void	CheckSrc ()

void	CheckDst ()

void	SendCastResult (SpellCastResult result)

void	SendPetCastResult (SpellCastResult result)

void	SendSpellStart ()

void	SendSpellGo ()

void	SendSpellCooldown ()

void	SendLogExecute ()

void	ExecuteLogEffectTakeTargetPower (uint8 effIndex, Unit *target, uint32 PowerType, uint32 powerTaken, float gainMultiplier)

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

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

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

void	ExecuteLogEffectOpenLock (uint8 effIndex, Object *obj)

void	ExecuteLogEffectCreateItem (uint8 effIndex, uint32 entry)

void	ExecuteLogEffectDestroyItem (uint8 effIndex, uint32 entry)

void	ExecuteLogEffectSummonObject (uint8 effIndex, WorldObject *obj)

void	ExecuteLogEffectUnsummonObject (uint8 effIndex, WorldObject *obj)

void	ExecuteLogEffectResurrect (uint8 effIndex, Unit *target)

void	SendInterrupted (uint8 result)

void	SendChannelUpdate (uint32 time)

void	SendChannelStart (uint32 duration)

void	SendResurrectRequest (Player *target)

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

void	HandleThreatSpells ()

void	AddComboPointGain (Unit *target, int8 amount)

int32	GetCastTime () const

bool	IsAutoRepeat () const

void	SetAutoRepeat (bool rep)

void	ReSetTimer ()

int32	GetCastTimeRemaining ()

bool	IsNextMeleeSwingSpell () const

bool	IsTriggered () const

bool	HasTriggeredCastFlag (TriggerCastFlags flag) const

bool	IsProcDisabled () const

bool	IsChannelActive () const

bool	IsAutoActionResetSpell () const

bool	IsIgnoringCooldowns () 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	GetDelayTrajectory () const

uint64	CalculateDelayMomentForDst () const

void	RecalculateDelayMomentForDst ()

bool	IsNeedSendToClient (bool go) const

CurrentSpellTypes	GetCurrentContainer () const

Unit *	GetCaster () const

Unit *	GetOriginalCaster () const

Unit *	GetOriginalTarget () const

SpellInfo const *	GetSpellInfo () const

int32	GetPowerCost () const

bool	UpdatePointers ()

void	CleanupTargetList ()

void	SetSpellValue (SpellValueMod mod, int32 value)

SpellValue const *	GetSpellValue ()

void	LoadScripts ()

std::list< TargetInfo > *	GetUniqueTargetInfo ()

uint32	GetTriggeredByAuraTickNumber () const

SpellInfo const *	GetTriggeredByAuraSpellInfo () const

TriggerCastFlags	GetTriggeredCastFlags () const

SpellSchoolMask	GetSpellSchoolMask () const

Static Public Member Functions
static void	WriteCastResultInfo (WorldPacket &data, Player caster, SpellInfo const spellInfo, uint8 castCount, SpellCastResult result, SpellCustomErrors customError)

static void	SendCastResult (Player caster, SpellInfo const spellInfo, uint8 castCount, SpellCastResult result, SpellCustomErrors customError=SPELL_CUSTOM_ERROR_NONE)

Public Attributes
SpellInfo const *const	m_spellInfo

Item *	m_CastItem

Item *	m_weaponItem

ObjectGuid	m_castItemGUID

uint8	m_cast_count

uint32	m_glyphIndex

uint32	m_preCastSpell

SpellCastTargets	m_targets

SpellCustomErrors	m_customError

Unit *	m_comboTarget

int8	m_comboPointGain

UsedSpellMods	m_appliedMods

Protected Types
typedef std::list< HitTriggerSpell >	HitTriggerSpellList

Protected Member Functions
bool	HasGlobalCooldown () const

void	TriggerGlobalCooldown ()

void	CancelGlobalCooldown ()

void	SendLoot (ObjectGuid guid, LootType loottype)

std::string	GetDebugInfo () const

bool	isDelayableNoMore ()

void	prepareDataForTriggerSystem (AuraEffect const *triggeredByAura)

void	AddUnitTarget (Unit *target, uint32 effectMask, bool checkIfValid=true, bool implicit=true)

void	AddGOTarget (GameObject *target, uint32 effectMask)

void	AddItemTarget (Item *item, uint32 effectMask)

void	AddDestTarget (SpellDestination const &dest, uint32 effIndex)

void	DoAllEffectOnTarget (TargetInfo *target)

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

void	DoTriggersOnSpellHit (Unit *unit, uint8 effMask)

void	DoAllEffectOnTarget (GOTargetInfo *target)

void	DoAllEffectOnTarget (ItemTargetInfo *target)

bool	UpdateChanneledTargetList ()

bool	IsValidDeadOrAliveTarget (Unit const *target) const

void	HandleLaunchPhase ()

void	DoAllEffectOnLaunchTarget (TargetInfo &targetInfo, float *multiplier)

void	PrepareTargetProcessing ()

void	FinishTargetProcessing ()

void	InitEffectExecuteData (uint8 effIndex)

void	CheckEffectExecuteData ()

void	CallScriptBeforeCastHandlers ()

void	CallScriptOnCastHandlers ()

void	CallScriptAfterCastHandlers ()

SpellCastResult	CallScriptCheckCastHandlers ()

void	PrepareScriptHitHandlers ()

bool	CallScriptEffectHandlers (SpellEffIndex effIndex, SpellEffectHandleMode mode)

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 (uint8 effMask, SpellInfo const *triggeredByAura=nullptr) const

void	PrepareTriggersExecutedOnHit ()

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

void	CalculateJumpSpeeds (uint8 i, float dist, float &speedxy, float &speedz)

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

Protected Attributes
Unit *const	m_caster

SpellValue *const	m_spellValue

ObjectGuid	m_originalCasterGUID

Unit *	m_originalCaster

ObjectGuid	m_originalTargetGUID

Spell **	m_selfContainer

SpellSchoolMask	m_spellSchoolMask

WeaponAttackType	m_attackType

int32	m_powerCost

int32	m_casttime

int32	m_channeledDuration

bool	m_canReflect

uint8	m_spellFlags

bool	m_autoRepeat

uint8	m_runesState

uint8	m_delayAtDamageCount

uint64	m_delayStart

uint64	m_delayMoment

uint64	m_delayTrajectory

bool	m_immediateHandled

bool	m_referencedFromCurrentSpell

bool	m_executedCurrently

bool	m_needComboPoints

uint8	m_applyMultiplierMask

float	m_damageMultipliers [3]

Unit *	unitTarget

Item *	itemTarget

GameObject *	gameObjTarget

WorldLocation *	destTarget

int32	damage

SpellEffectHandleMode	effectHandleMode

Unit *	m_reflectionTarget

ObjectGuid	m_reflectionTargetGuid

Position	m_reflectionTargetPosition

Aura *	m_spellAura

DiminishingLevels	m_diminishLevel

DiminishingGroup	m_diminishGroup

GameObject *	focusObject

int32	m_damage

int32	m_healing

int32	m_damageBeforeTakenMods

uint32	m_procAttacker

uint32	m_procVictim

uint32	m_procEx

std::list< TargetInfo >	m_UniqueTargetInfo

uint8	m_channelTargetEffectMask

std::list< GOTargetInfo >	m_UniqueGOTargetInfo

std::list< ItemTargetInfo >	m_UniqueItemInfo

SpellDestination	m_destTargets [MAX_SPELL_EFFECTS]

bool	_scriptsLoaded

std::list< SpellScript * >	m_loadedScripts

HitTriggerSpellList	m_hitTriggerSpells

uint32	m_spellState

int32	m_timer

SpellEvent *	_spellEvent

TriggerCastFlags	_triggeredCastFlags

TriggeredByAuraSpellData	m_triggeredByAuraSpell

bool	m_skipCheck

uint8	m_auraScaleMask

std::unique_ptr< PathGenerator >	m_preGeneratedPath

bool	_spellTargetsSelected

ByteBuffer *	m_effectExecuteData [MAX_SPELL_EFFECTS]

Friends
class	SpellScript

void	Unit::SetCurrentCastedSpell (Spell *pSpell)

Detailed Description

Member Typedef Documentation

◆ HitTriggerSpellList

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

protected

◆ UsedSpellMods

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

Constructor & Destructor Documentation

◆ Spell()

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

                                                                                                                              :
    m_spellInfo(sSpellMgr->GetSpellForDifficultyFromSpell(info, caster)),
    m_caster((info->HasAttribute(SPELL_ATTR6_ORIGINATE_FROM_CONTROLLER) && caster->GetCharmerOrOwner()) ? caster->GetCharmerOrOwner() : caster)
    , m_spellValue(new SpellValue(m_spellInfo)), _spellEvent(nullptr)
{
    m_customError = SPELL_CUSTOM_ERROR_NONE;
    m_skipCheck = skipCheck;
    m_selfContainer = nullptr;
    m_referencedFromCurrentSpell = false;
    m_executedCurrently = false;
    m_needComboPoints = m_spellInfo->NeedsComboPoints();
    m_comboPointGain = 0;
    m_comboTarget = nullptr;
    m_delayStart = 0;
    m_delayAtDamageCount = 0;
 
    m_applyMultiplierMask = 0;
    m_auraScaleMask = 0;
    memset(m_damageMultipliers, 0, sizeof(m_damageMultipliers));
 
    // Get data for type of attack
    switch (m_spellInfo->DmgClass)
    {
        case SPELL_DAMAGE_CLASS_MELEE:
            if (m_spellInfo->HasAttribute(SPELL_ATTR3_REQUIRES_OFF_HAND_WEAPON))
                m_attackType = OFF_ATTACK;
            else
                m_attackType = BASE_ATTACK;
            break;
        case SPELL_DAMAGE_CLASS_RANGED:
            m_attackType = m_spellInfo->IsRangedWeaponSpell() ? RANGED_ATTACK : BASE_ATTACK;
            break;
        default:
            // Wands
            if (m_spellInfo->HasAttribute(SPELL_ATTR2_AUTO_REPEAT))
                m_attackType = RANGED_ATTACK;
            else
                m_attackType = BASE_ATTACK;
            break;
    }
 
    m_spellSchoolMask = info->GetSchoolMask();           // Can be override for some spell (wand shoot for example)
 
    if (m_attackType == RANGED_ATTACK)
        // wand case
        if ((m_caster->getClassMask() & CLASSMASK_WAND_USERS) != 0 && m_caster->IsPlayer())
            if (Item* pItem = m_caster->ToPlayer()->GetWeaponForAttack(RANGED_ATTACK))
                m_spellSchoolMask = SpellSchoolMask(1 << pItem->GetTemplate()->Damage[0].DamageType);
 
    if (originalCasterGUID)
        m_originalCasterGUID = originalCasterGUID;
    else
        m_originalCasterGUID = m_caster->GetGUID();
 
    if (m_originalCasterGUID == m_caster->GetGUID())
        m_originalCaster = m_caster;
    else
    {
        m_originalCaster = ObjectAccessor::GetUnit(*m_caster, m_originalCasterGUID);
        if (m_originalCaster && !m_originalCaster->IsInWorld())
            m_originalCaster = nullptr;
    }
 
    m_spellState = SPELL_STATE_NULL;
    _triggeredCastFlags = triggerFlags;
    if (info->HasAttribute(SPELL_ATTR4_ALLOW_CAST_WHILE_CASTING))
        _triggeredCastFlags = TriggerCastFlags(uint32(_triggeredCastFlags) | TRIGGERED_IGNORE_CAST_IN_PROGRESS | TRIGGERED_CAST_DIRECTLY);
 
    m_CastItem = nullptr;
 
    unitTarget = nullptr;
    itemTarget = nullptr;
    gameObjTarget = nullptr;
    destTarget = nullptr;
    damage = 0;
    m_reflectionTarget = nullptr;
    m_reflectionTargetGuid.Clear();
    effectHandleMode = SPELL_EFFECT_HANDLE_LAUNCH;
    m_diminishLevel = DIMINISHING_LEVEL_1;
    m_diminishGroup = DIMINISHING_NONE;
    m_damage = 0;
    m_healing = 0;
    m_damageBeforeTakenMods = 0;
    m_procAttacker = 0;
    m_procVictim = 0;
    m_procEx = 0;
    focusObject = nullptr;
    m_cast_count = 0;
    m_glyphIndex = 0;
    m_preCastSpell = 0;
    m_spellAura = nullptr;
    _scriptsLoaded = false;
 
    //Auto Shot & Shoot (wand)
    m_autoRepeat = m_spellInfo->IsAutoRepeatRangedSpell();
 
    m_runesState = 0;
    m_powerCost = 0;                                        // setup to correct value in Spell::prepare, must not be used before.
    m_casttime = 0;                                         // setup to correct value in Spell::prepare, must not be used before.
    m_timer = 0;                                            // will set to castime in prepare
    m_channeledDuration = 0;                                // will be setup in Spell::handle_immediate
    m_immediateHandled = false;
 
    m_channelTargetEffectMask = 0;
 
    m_spellFlags = SPELL_FLAG_NORMAL;
 
    // Determine if spell can be reflected back to the caster
    // Patch 1.2 notes: Spell Reflection no longer reflects abilities
    m_canReflect = m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MAGIC && !m_spellInfo->HasAttribute(SPELL_ATTR0_IS_ABILITY)
                   && !m_spellInfo->HasAttribute(SPELL_ATTR1_NO_REFLECTION) && !m_spellInfo->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES)
                   && !m_spellInfo->IsPassive() && (!m_spellInfo->IsPositive() || m_spellInfo->HasEffect(SPELL_EFFECT_DISPEL));
 
    CleanupTargetList();
    memset(m_effectExecuteData, 0, MAX_SPELL_EFFECTS * sizeof(ByteBuffer*));
 
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        m_destTargets[i] = SpellDestination(*m_caster);
 
    // xinef:
    _spellTargetsSelected = false;
 
    m_weaponItem = nullptr;
}

References _scriptsLoaded, _spellTargetsSelected, _triggeredCastFlags, BASE_ATTACK, CLASSMASK_WAND_USERS, CleanupTargetList(), ObjectGuid::Clear(), damage, destTarget, DIMINISHING_LEVEL_1, DIMINISHING_NONE, SpellInfo::DmgClass, effectHandleMode, focusObject, gameObjTarget, Unit::getClassMask(), Object::GetGUID(), SpellInfo::GetSchoolMask(), ObjectAccessor::GetUnit(), Player::GetWeaponForAttack(), SpellInfo::HasAttribute(), SpellInfo::HasEffect(), SpellInfo::IsAutoRepeatRangedSpell(), Object::IsInWorld(), SpellInfo::IsPassive(), Object::IsPlayer(), SpellInfo::IsPositive(), SpellInfo::IsRangedWeaponSpell(), itemTarget, m_applyMultiplierMask, m_attackType, m_auraScaleMask, m_autoRepeat, m_canReflect, m_cast_count, m_caster, m_CastItem, m_casttime, m_channeledDuration, m_channelTargetEffectMask, m_comboPointGain, m_comboTarget, m_customError, m_damage, m_damageBeforeTakenMods, m_damageMultipliers, m_delayAtDamageCount, m_delayStart, m_destTargets, m_diminishGroup, m_diminishLevel, m_effectExecuteData, m_executedCurrently, m_glyphIndex, m_healing, m_immediateHandled, m_needComboPoints, m_originalCaster, m_originalCasterGUID, m_powerCost, m_preCastSpell, m_procAttacker, m_procEx, m_procVictim, m_referencedFromCurrentSpell, m_reflectionTarget, m_reflectionTargetGuid, m_runesState, m_selfContainer, m_skipCheck, m_spellAura, m_spellFlags, m_spellInfo, m_spellSchoolMask, m_spellState, m_timer, m_weaponItem, MAX_SPELL_EFFECTS, SpellInfo::NeedsComboPoints(), OFF_ATTACK, RANGED_ATTACK, SPELL_ATTR0_IS_ABILITY, SPELL_ATTR0_NO_IMMUNITIES, SPELL_ATTR1_NO_REFLECTION, SPELL_ATTR2_AUTO_REPEAT, SPELL_ATTR3_REQUIRES_OFF_HAND_WEAPON, SPELL_ATTR4_ALLOW_CAST_WHILE_CASTING, SPELL_CUSTOM_ERROR_NONE, SPELL_DAMAGE_CLASS_MAGIC, SPELL_DAMAGE_CLASS_MELEE, SPELL_DAMAGE_CLASS_RANGED, SPELL_EFFECT_DISPEL, SPELL_EFFECT_HANDLE_LAUNCH, SPELL_FLAG_NORMAL, SPELL_STATE_NULL, Object::ToPlayer(), TRIGGERED_CAST_DIRECTLY, TRIGGERED_IGNORE_CAST_IN_PROGRESS, and unitTarget.

Referenced by Creature::HasSpellFocus().

◆ ~Spell()

Spell::~Spell ( )

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

References CheckEffectExecuteData(), SpellInfo::Id, LOG_ERROR, m_loadedScripts, m_referencedFromCurrentSpell, m_selfContainer, m_spellInfo, and m_spellValue.

Member Function Documentation

◆ _cast()

void Spell::_cast ( bool skipCheck )

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() && !m_targets.GetObjectTarget())
    {
        cancel();
        return;
    }
 
    // Xinef: implement attribute SPELL_ATTR1_DISMISS_PET_FIRST, on spell cast current pet is dismissed and charms are removed
    if (m_spellInfo->HasAttribute(SPELL_ATTR1_DISMISS_PET_FIRST))
    {
        if (m_caster->IsPlayer() && !m_spellInfo->HasEffect(SPELL_EFFECT_SUMMON_PET))
            if (Pet* pet = m_caster->ToPlayer()->GetPet())
                m_caster->ToPlayer()->RemovePet(pet, PET_SAVE_AS_CURRENT);
 
        if (Unit* charm = m_caster->GetCharm())
            charm->RemoveAurasByType(SPELL_AURA_MOD_CHARM, m_caster->GetGUID());
    }
 
    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
        // xinef: take into account SPELL_ATTR3_SUPPRESS_TARGET_PROCS
        if ((m_targets.GetTargetMask() & TARGET_FLAG_UNIT) && GetSpellInfo()->DmgClass != SPELL_DAMAGE_CLASS_NONE && !GetSpellInfo()->HasAttribute(SPELL_ATTR3_SUPPRESS_TARGET_PROCS))
            if (!playerCaster->m_Controlled.empty())
                for (Unit::ControlSet::iterator itr = playerCaster->m_Controlled.begin(); itr != playerCaster->m_Controlled.end(); ++itr)
                    if (Unit* pet = *itr)
                        if (pet->IsAlive() && pet->IsCreature())
                            pet->ToCreature()->AI()->OwnerAttacked(m_targets.GetUnitTarget());
    }
 
    SetExecutedCurrently(true);
 
    if (!HasTriggeredCastFlag(TRIGGERED_IGNORE_SET_FACING))
        if (m_caster->IsCreature() && m_targets.GetObjectTarget() && m_caster != m_targets.GetObjectTarget())
            m_caster->SetInFront(m_targets.GetObjectTarget());
 
    CallScriptBeforeCastHandlers();
 
    Player* modOwner = m_caster->GetSpellModOwner();
    // skip check if done already (for instant cast spells for example)
    if (!skipCheck)
    {
        SpellCastResult castResult = CheckCast(false);
        if (castResult != SPELL_CAST_OK)
        {
            SendCastResult(castResult);
            SendInterrupted(0);
 
            finish(false);
            SetExecutedCurrently(false);
            return;
        }
 
        // additional check after cast bar completes (must not be in CheckCast)
        // if trade not complete then remember it in trade data
        if (m_targets.GetTargetMask() & TARGET_FLAG_TRADE_ITEM)
        {
            if (m_caster->IsPlayer())
            {
                if (TradeData* my_trade = m_caster->ToPlayer()->GetTradeData())
                {
                    if (!my_trade->IsInAcceptProcess())
                    {
                        // Spell will be casted at completing the trade. Silently ignore at this place
                        my_trade->SetSpell(m_spellInfo->Id, m_CastItem);
                        SendCastResult(SPELL_FAILED_DONT_REPORT);
                        SendInterrupted(0);
 
                        finish(false);
                        SetExecutedCurrently(false);
                        return;
                    }
                }
            }
        }
    }
 
    if (modOwner)
        modOwner->SetSpellModTakingSpell(this, true);
 
    if (!_spellTargetsSelected)
        SelectSpellTargets();
 
    if (modOwner)
        modOwner->SetSpellModTakingSpell(this, false);
 
    // Spell may be finished after target map check
    if (m_spellState == SPELL_STATE_FINISHED)
    {
        SendInterrupted(0);
        finish(false);
        SetExecutedCurrently(false);
        return;
    }
 
    if (modOwner)
        modOwner->SetSpellModTakingSpell(this, true);
 
    PrepareTriggersExecutedOnHit();
 
    CallScriptOnCastHandlers();
 
    if (modOwner)
        modOwner->SetSpellModTakingSpell(this, false);
 
    // 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 (m_caster->IsPlayer())
    {
        if (!HasTriggeredCastFlag(TRIGGERED_IGNORE_CAST_ITEM) && m_CastItem)
        {
            m_caster->ToPlayer()->StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_ITEM, m_CastItem->GetEntry());
            m_caster->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM, m_CastItem->GetEntry());
        }
 
        m_caster->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL, m_spellInfo->Id, 0, (m_targets.GetUnitTarget() ? m_targets.GetUnitTarget() : m_caster));
    }
 
    if (!HasTriggeredCastFlag(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();
    }
 
    SendSpellCooldown();
 
    // CAST SPELL
    if (modOwner)
        modOwner->SetSpellModTakingSpell(this, true);
 
    PrepareScriptHitHandlers();
 
    HandleLaunchPhase();
 
    // we must send smsg_spell_go packet before m_castItem delete in TakeCastItem()...
    SendSpellGo();
 
    bool resetAttackTimers = IsAutoActionResetSpell() && !m_spellInfo->HasAttribute(SPELL_ATTR2_DO_NOT_RESET_COMBAT_TIMERS);
    if (resetAttackTimers)
    {
        Unit::AuraEffectList const& vIgnoreReset = m_caster->GetAuraEffectsByType(SPELL_AURA_IGNORE_MELEE_RESET);
        for (Unit::AuraEffectList::const_iterator i = vIgnoreReset.begin(); i != vIgnoreReset.end(); ++i)
        {
            if ((*i)->IsAffectedOnSpell(m_spellInfo))
            {
                resetAttackTimers = false;
                break;
            }
        }
    }
 
    // Okay, everything is prepared. Now we need to distinguish between immediate and evented delayed spells
    if ((m_spellInfo->Speed > 0.0f && !m_spellInfo->IsChanneled())/* xinef: we dont need this || m_spellInfo->Id == 14157*/)
    {
        // Remove used for cast item if need (it can be already nullptr after TakeReagents call
        // in case delayed spell remove item at cast delay start
        TakeCastItem();
 
        // Okay, maps created, now prepare flags
        m_immediateHandled = false;
        m_spellState = SPELL_STATE_DELAYED;
        SetDelayStart(0);
 
        if (m_caster->HasUnitState(UNIT_STATE_CASTING) && !m_caster->IsNonMeleeSpellCast(false, false, true))
            m_caster->ClearUnitState(UNIT_STATE_CASTING);
 
        // remove all applied mods at this point
        // dont allow user to use them twice in case spell did not reach current target
        if (modOwner)
            modOwner->RemoveSpellMods(this);
 
        // Xinef: why do we keep focus after spell is sent to air?
        // Xinef: Because of this, in the middle of some animation after setting targetguid to 0 etc
        // Xinef: we get focused to it out of nowhere...
        if (Creature* creatureCaster = m_caster->ToCreature())
            creatureCaster->ReleaseFocus(this);
    }
    else
    {
        // Immediate spell, no big deal
        handle_immediate();
    }
 
    if (resetAttackTimers)
    {
        if (m_casttime == 0 && m_spellInfo->CalcCastTime())
        {
            resetAttackTimers = false;
        }
 
        if (resetAttackTimers)
        {
            m_caster->resetAttackTimer(BASE_ATTACK);
 
            if (m_caster->HasOffhandWeaponForAttack())
            {
                m_caster->resetAttackTimer(OFF_ATTACK);
            }
 
            m_caster->resetAttackTimer(RANGED_ATTACK);
        }
    }
 
    CallScriptAfterCastHandlers();
 
    if (modOwner)
        modOwner->SetSpellModTakingSpell(this, false);
 
    // Handle procs on cast - only for non-triggered spells
    // Triggered spells (from auras, items, etc.) should not fire CAST phase procs
    // as they are not player-initiated casts. This prevents issues like Arcane Potency
    // charges being consumed by periodic damage effects (e.g., Blizzard ticks).
    // Must be called AFTER handle_immediate() so spell mods (like Missile Barrage's
    // duration reduction) are applied before the aura is consumed by the proc.
    if (m_originalCaster && !IsTriggered())
    {
        uint32 procAttacker = m_procAttacker;
        if (!procAttacker)
        {
            bool IsPositive = m_spellInfo->IsPositive();
            if (m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MAGIC)
            {
                procAttacker = IsPositive ? PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS : PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG;
            }
            else
            {
                procAttacker = IsPositive ? PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS : PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_NEG;
            }
        }
 
        uint32 hitMask = PROC_HIT_NORMAL;
 
        for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
        {
            if (ihit->missCondition != SPELL_MISS_NONE)
                continue;
 
            if (!ihit->crit)
                continue;
 
            hitMask |= PROC_HIT_CRITICAL;
            break;
        }
 
        Unit::ProcSkillsAndAuras(m_originalCaster, nullptr, procAttacker, PROC_FLAG_NONE, hitMask, 1, BASE_ATTACK, m_spellInfo, m_triggeredByAuraSpell.spellInfo,
            m_triggeredByAuraSpell.effectIndex, this, nullptr, nullptr, PROC_SPELL_PHASE_CAST);
    }
 
    if (std::vector<int32> const* spell_triggered = sSpellMgr->GetSpellLinked(m_spellInfo->Id))
    {
        for (int32 id : *spell_triggered)
        {
            if (id < 0)
                m_caster->RemoveAurasDueToSpell(-id);
            else
                m_caster->CastSpell(m_targets.GetUnitTarget() ? m_targets.GetUnitTarget() : m_caster, id, true);
        }
    }
 
    // Interrupt Spell casting
    // handle this here, in other places SpellHitTarget can be set to nullptr, if there is an error in this function
    if (m_spellInfo->HasAttribute(SPELL_ATTR7_CAN_CAUSE_INTERRUPT))
        if (Unit* target = m_targets.GetUnitTarget())
            if (target->IsCreature())
                m_caster->CastSpell(target, 32747, true);
 
    if (m_caster->IsPlayer())
        if (m_caster->ToPlayer()->GetCommandStatus(CHEAT_COOLDOWN))
            m_caster->ToPlayer()->RemoveSpellCooldown(m_spellInfo->Id, true);
 
    sScriptMgr->OnSpellCast(this, m_caster, m_spellInfo, skipCheck);
 
    SetExecutedCurrently(false);
 
    // Call CreatureAI hook on successful cast
    if (Creature* caster = m_caster->ToCreature())
        if (caster->IsAIEnabled)
            caster->AI()->OnSpellCast(GetSpellInfo());
}

References _spellTargetsSelected, ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL, ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM, ACHIEVEMENT_TIMED_TYPE_ITEM, BASE_ATTACK, SpellInfo::CalcCastTime(), CallScriptAfterCastHandlers(), CallScriptBeforeCastHandlers(), CallScriptOnCastHandlers(), cancel(), Unit::CastSpell(), CHEAT_COOLDOWN, CheckCast(), Unit::ClearUnitState(), SpellInfo::DmgClass, TriggeredByAuraSpellData::effectIndex, finish(), Unit::GetAuraEffectsByType(), Unit::GetCharm(), Player::GetCommandStatus(), Object::GetEntry(), Object::GetGUID(), SpellCastTargets::GetItemTarget(), SpellCastTargets::GetObjectTarget(), SpellCastTargets::GetObjectTargetGUID(), Player::GetPet(), GetSpellInfo(), Unit::GetSpellModOwner(), SpellCastTargets::GetTargetMask(), Player::GetTradeData(), SpellCastTargets::GetUnitTarget(), handle_immediate(), HandleLaunchPhase(), SpellInfo::HasAttribute(), SpellInfo::HasEffect(), Unit::HasOffhandWeaponForAttack(), HasTriggeredCastFlag(), Unit::HasUnitState(), SpellInfo::Id, IsAutoActionResetSpell(), SpellInfo::IsChanneled(), Object::IsCreature(), Unit::IsNonMeleeSpellCast(), Object::IsPlayer(), SpellInfo::IsPositive(), IsTriggered(), m_caster, m_CastItem, m_casttime, m_immediateHandled, m_originalCaster, m_procAttacker, m_spellInfo, m_spellState, m_targets, m_triggeredByAuraSpell, m_UniqueTargetInfo, OFF_ATTACK, PET_SAVE_AS_CURRENT, PrepareScriptHitHandlers(), PrepareTriggersExecutedOnHit(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS, PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_NEG, PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS, PROC_FLAG_NONE, PROC_HIT_CRITICAL, PROC_HIT_NORMAL, PROC_SPELL_PHASE_CAST, Unit::ProcSkillsAndAuras(), RANGED_ATTACK, Unit::RemoveAurasDueToSpell(), Player::RemovePet(), Player::RemoveSpellCooldown(), Player::RemoveSpellMods(), Unit::resetAttackTimer(), SelectSpellTargets(), SendCastResult(), SendInterrupted(), SendSpellCooldown(), SendSpellGo(), SetDelayStart(), SetExecutedCurrently(), Unit::SetInFront(), Player::SetSpellModTakingSpell(), SpellInfo::Speed, SPELL_ATTR1_DISMISS_PET_FIRST, SPELL_ATTR2_DO_NOT_RESET_COMBAT_TIMERS, SPELL_ATTR3_SUPPRESS_TARGET_PROCS, SPELL_ATTR7_CAN_CAUSE_INTERRUPT, SPELL_AURA_IGNORE_MELEE_RESET, SPELL_AURA_MOD_CHARM, SPELL_CAST_OK, SPELL_DAMAGE_CLASS_MAGIC, SPELL_DAMAGE_CLASS_NONE, SPELL_EFFECT_SUMMON_PET, SPELL_FAILED_DONT_REPORT, SPELL_MISS_NONE, SPELL_STATE_DELAYED, SPELL_STATE_FINISHED, TriggeredByAuraSpellData::spellInfo, sScriptMgr, sSpellMgr, Player::StartTimedAchievement(), TakeCastItem(), TakePower(), TakeReagents(), TARGET_FLAG_TRADE_ITEM, TARGET_FLAG_UNIT, Object::ToCreature(), Object::ToPlayer(), TRIGGERED_IGNORE_CAST_ITEM, TRIGGERED_IGNORE_POWER_AND_REAGENT_COST, TRIGGERED_IGNORE_SET_FACING, UNIT_STATE_CASTING, Player::UpdateAchievementCriteria(), UpdatePointers(), and SpellCastTargets::UpdateTradeSlotItem().

Referenced by cast().

◆ _handle_finish_phase()

void Spell::_handle_finish_phase ( )

{
    // Take for real after all targets are processed
    if (m_needComboPoints)
    {
        m_caster->ClearComboPoints();
    }
 
    // Real add combo points from effects
    if (m_comboTarget && m_comboPointGain)
    {
        // remove Premed-like effects unless they were caused by ourselves
        // (this Aura removes the already-added CP when it expires from duration - now that we've added CP, this shouldn't happen anymore!)
        if (!m_spellInfo->HasAura(SPELL_AURA_RETAIN_COMBO_POINTS))
        {
            m_caster->RemoveAurasByType(SPELL_AURA_RETAIN_COMBO_POINTS);
        }
 
        m_caster->AddComboPoints(m_comboTarget, m_comboPointGain);
    }
 
    if (m_spellInfo->HasEffect(SPELL_EFFECT_ADD_EXTRA_ATTACKS))
    {
        m_caster->SetLastExtraAttackSpell(m_spellInfo->Id);
    }
 
    if (!IsAutoRepeat() && !IsNextMeleeSwingSpell())
        if (m_caster->GetCharmerOrOwnerPlayerOrPlayerItself())
            for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
            {
                // Xinef: Properly clear infinite cooldowns in some cases
                if (ihit->targetGUID == m_caster->GetGUID() && ihit->missCondition != SPELL_MISS_NONE)
                    if (m_caster->IsPlayer() && m_spellInfo->IsCooldownStartedOnEvent())
                        m_caster->ToPlayer()->SendCooldownEvent(m_spellInfo);
            }
 
    // Handle procs on finish
    if (m_originalCaster)
    {
        uint32 procAttacker = m_procAttacker;
        if (!procAttacker)
        {
            bool IsPositive = m_spellInfo->IsPositive();
            if (m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MAGIC)
            {
                procAttacker = IsPositive ? PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS : PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG;
            }
            else
            {
                procAttacker = IsPositive ? PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS : PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_NEG;
            }
        }
 
        uint32 hitMask = PROC_HIT_NORMAL;
        for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
        {
            if (ihit->missCondition != SPELL_MISS_NONE)
                continue;
 
            if (!ihit->crit)
                continue;
 
            hitMask |= PROC_HIT_CRITICAL;
            break;
        }
 
        // For trap activation, pass the original target (trap triggerer) so proc trigger spells
        // like Entrapment can find a valid target to cast on
        Unit* finishVictim = nullptr;
        if (procAttacker & PROC_FLAG_DONE_TRAP_ACTIVATION)
            finishVictim = GetOriginalTarget();
 
        Unit::ProcSkillsAndAuras(m_originalCaster, finishVictim, procAttacker, PROC_FLAG_NONE, hitMask, 1, BASE_ATTACK, m_spellInfo, m_triggeredByAuraSpell.spellInfo,
            m_triggeredByAuraSpell.effectIndex, this, nullptr, nullptr, PROC_SPELL_PHASE_FINISH);
    }
}

References Unit::AddComboPoints(), BASE_ATTACK, Unit::ClearComboPoints(), SpellInfo::DmgClass, TriggeredByAuraSpellData::effectIndex, Unit::GetCharmerOrOwnerPlayerOrPlayerItself(), Object::GetGUID(), GetOriginalTarget(), SpellInfo::HasAura(), SpellInfo::HasEffect(), SpellInfo::Id, IsAutoRepeat(), SpellInfo::IsCooldownStartedOnEvent(), IsNextMeleeSwingSpell(), Object::IsPlayer(), SpellInfo::IsPositive(), m_caster, m_comboPointGain, m_comboTarget, m_needComboPoints, m_originalCaster, m_procAttacker, m_spellInfo, m_triggeredByAuraSpell, m_UniqueTargetInfo, PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS, PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_NEG, PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS, PROC_FLAG_DONE_TRAP_ACTIVATION, PROC_FLAG_NONE, PROC_HIT_CRITICAL, PROC_HIT_NORMAL, PROC_SPELL_PHASE_FINISH, Unit::ProcSkillsAndAuras(), Unit::RemoveAurasByType(), Player::SendCooldownEvent(), Unit::SetLastExtraAttackSpell(), SPELL_AURA_RETAIN_COMBO_POINTS, SPELL_DAMAGE_CLASS_MAGIC, SPELL_EFFECT_ADD_EXTRA_ATTACKS, SPELL_MISS_NONE, TriggeredByAuraSpellData::spellInfo, and Object::ToPlayer().

Referenced by handle_delayed(), and handle_immediate().

◆ _handle_immediate_phase()

void Spell::_handle_immediate_phase ( )

{
    m_spellAura = nullptr;
    // initialize Diminishing Returns Data
    m_diminishLevel = DIMINISHING_LEVEL_1;
    m_diminishGroup = DIMINISHING_NONE;
 
    // handle some immediate features of the spell here
    HandleThreatSpells();
 
    PrepareScriptHitHandlers();
 
    // handle effects with SPELL_EFFECT_HANDLE_HIT mode
    for (uint32 j = 0; j < MAX_SPELL_EFFECTS; ++j)
    {
        // don't do anything for empty effect
        if (!m_spellInfo->Effects[j].IsEffect())
            continue;
 
        // call effect handlers to handle destination hit
        HandleEffects(nullptr, nullptr, nullptr, j, SPELL_EFFECT_HANDLE_HIT);
    }
 
    // process items
    for (std::list<ItemTargetInfo>::iterator ihit = m_UniqueItemInfo.begin(); ihit != m_UniqueItemInfo.end(); ++ihit)
        DoAllEffectOnTarget(&(*ihit));
}

References DIMINISHING_LEVEL_1, DIMINISHING_NONE, DoAllEffectOnTarget(), SpellInfo::Effects, HandleEffects(), HandleThreatSpells(), m_diminishGroup, m_diminishLevel, m_spellAura, m_spellInfo, m_UniqueItemInfo, MAX_SPELL_EFFECTS, PrepareScriptHitHandlers(), and SPELL_EFFECT_HANDLE_HIT.

Referenced by handle_delayed(), and handle_immediate().

◆ AddComboPointGain()

void Spell::AddComboPointGain	(	Unit *	target,
		int8	amount
	)

inline

    {
        if (target != m_comboTarget)
        {
            m_comboTarget = target;
            m_comboPointGain = amount;
        }
        else
        {
            m_comboPointGain += amount;
        }
    }

References m_comboPointGain, and m_comboTarget.

Referenced by EffectAddComboPoints(), and EffectWeaponDmg().

◆ AddDestTarget()

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

protected

{
    m_destTargets[effIndex] = dest;
}

References m_destTargets.

Referenced by SelectSpellTargets().

◆ AddGOTarget()

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

protected

{
    for (uint32 effIndex = 0; effIndex < MAX_SPELL_EFFECTS; ++effIndex)
    {
        if (!m_spellInfo->Effects[effIndex].IsEffect())
            effectMask &= ~(1 << effIndex);
        else
        {
            switch (m_spellInfo->Effects[effIndex].Effect)
            {
                case SPELL_EFFECT_GAMEOBJECT_DAMAGE:
                case SPELL_EFFECT_GAMEOBJECT_REPAIR:
                case SPELL_EFFECT_GAMEOBJECT_SET_DESTRUCTION_STATE:
                    if (go->GetGoType() != GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING)
                        effectMask &= ~(1 << effIndex);
                    break;
                default:
                    break;
            }
        }
    }
 
    if (!effectMask)
        return;
 
    ObjectGuid targetGUID = go->GetGUID();
 
    // Lookup target in already in list
    for (std::list<GOTargetInfo>::iterator ihit = m_UniqueGOTargetInfo.begin(); ihit != m_UniqueGOTargetInfo.end(); ++ihit)
    {
        if (targetGUID == ihit->targetGUID)                 // Found in list
        {
            ihit->effectMask |= effectMask;                 // Add only effect mask
            return;
        }
    }
 
    // This is new target calculate data for him
 
    GOTargetInfo target;
    target.targetGUID = targetGUID;
    target.effectMask = effectMask;
    target.processed  = false;                              // Effects not apply on target
 
    // Spell have speed - need calculate incoming time
    if (m_spellInfo->Speed > 0.0f)
    {
        // calculate spell incoming interval
        float dist = m_caster->GetDistance(go->GetPositionX(), go->GetPositionY(), go->GetPositionZ());
        if (dist < 5.0f)
            dist = 5.0f;
        target.timeDelay = uint64(std::floor(dist / m_spellInfo->Speed * 1000.0f));
        if (m_delayMoment == 0 || m_delayMoment > target.timeDelay)
            m_delayMoment = target.timeDelay;
    }
    else
        target.timeDelay = 0LL;
 
    // Add target to list
    m_UniqueGOTargetInfo.push_back(target);
}

References Spell::GOTargetInfo::effectMask, SpellInfo::Effects, GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING, WorldObject::GetDistance(), GameObject::GetGoType(), Object::GetGUID(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), m_caster, m_delayMoment, m_spellInfo, m_UniqueGOTargetInfo, MAX_SPELL_EFFECTS, Spell::GOTargetInfo::processed, SpellInfo::Speed, SPELL_EFFECT_GAMEOBJECT_DAMAGE, SPELL_EFFECT_GAMEOBJECT_REPAIR, SPELL_EFFECT_GAMEOBJECT_SET_DESTRUCTION_STATE, Spell::GOTargetInfo::targetGUID, and Spell::GOTargetInfo::timeDelay.

Referenced by SelectEffectTypeImplicitTargets(), SelectImplicitAreaTargets(), SelectImplicitConeTargets(), SelectImplicitNearbyTargets(), and SelectImplicitTargetObjectTargets().

◆ AddItemTarget()

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

protected

{
    for (uint32 effIndex = 0; effIndex < MAX_SPELL_EFFECTS; ++effIndex)
        if (!m_spellInfo->Effects[effIndex].IsEffect())
            effectMask &= ~(1 << effIndex);
 
    // no effects left
    if (!effectMask)
        return;
 
    // Lookup target in already in list
    for (std::list<ItemTargetInfo>::iterator ihit = m_UniqueItemInfo.begin(); ihit != m_UniqueItemInfo.end(); ++ihit)
    {
        if (item == ihit->item)                            // Found in list
        {
            ihit->effectMask |= effectMask;                 // Add only effect mask
            return;
        }
    }
 
    // This is new target add data
 
    ItemTargetInfo target;
    target.item       = item;
    target.effectMask = effectMask;
 
    m_UniqueItemInfo.push_back(target);
}

References Spell::ItemTargetInfo::effectMask, SpellInfo::Effects, Spell::ItemTargetInfo::item, m_spellInfo, m_UniqueItemInfo, and MAX_SPELL_EFFECTS.

Referenced by SelectEffectTypeImplicitTargets(), and SelectImplicitTargetObjectTargets().

◆ AddUnitTarget()

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

protected

Todo:: : this is a hack

Todo:: : seduction should be casted only on humanoids (not demons)

{
    for (uint32 effIndex = 0; effIndex < MAX_SPELL_EFFECTS; ++effIndex)
        if (!m_spellInfo->Effects[effIndex].IsEffect() || !CheckEffectTarget(target, effIndex))
            effectMask &= ~(1 << effIndex);
 
    // no effects left
    if (!effectMask)
        return;
 
    if (checkIfValid)
    {
        SpellCastResult res = m_spellInfo->CheckTarget(m_caster, target, implicit);
        if (res != SPELL_CAST_OK)
            return;
    }
 
    // Check for effect immune skip if immuned
    for (uint32 effIndex = 0; effIndex < MAX_SPELL_EFFECTS; ++effIndex)
        if (target->IsImmunedToSpellEffect(m_spellInfo, effIndex, m_caster))
            effectMask &= ~(1 << effIndex);
 
    ObjectGuid targetGUID = target->GetGUID();
 
    // Lookup target in already in list
    for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
    {
        if (targetGUID == ihit->targetGUID)             // Found in list
        {
            ihit->effectMask |= effectMask;             // Immune effects removed from mask
            ihit->scaleAura = false;
            if (m_auraScaleMask && ihit->effectMask == m_auraScaleMask && m_caster != target)
            {
                SpellInfo const* auraSpell = m_spellInfo->GetFirstRankSpell();
                if (uint32(target->GetLevel() + 10) >= auraSpell->SpellLevel)
                    ihit->scaleAura = true;
            }
 
            sScriptMgr->OnScaleAuraUnitAdd(this, target, effectMask, checkIfValid, implicit, m_auraScaleMask, *ihit);
            return;
        }
    }
 
    // This is new target calculate data for him
 
    // Get spell hit result on target
    TargetInfo targetInfo;
    targetInfo.targetGUID = targetGUID;                         // Store target GUID
    targetInfo.effectMask = effectMask;                         // Store all effects not immune
    targetInfo.processed  = false;                              // Effects not apply on target
    targetInfo.alive      = target->IsAlive();
    targetInfo.damage     = 0;
    targetInfo.damageBeforeTakenMods = 0;
    targetInfo.crit       = false;
    targetInfo.scaleAura  = false;
    if (m_auraScaleMask && targetInfo.effectMask == m_auraScaleMask && m_caster != target)
    {
        SpellInfo const* auraSpell = m_spellInfo->GetFirstRankSpell();
        if (uint32(target->GetLevel() + 10) >= auraSpell->SpellLevel)
            targetInfo.scaleAura = true;
    }
 
    sScriptMgr->OnScaleAuraUnitAdd(this, target, effectMask, checkIfValid, implicit, m_auraScaleMask, targetInfo);
 
    // Calculate hit result
    if (m_originalCaster)
    {
        targetInfo.missCondition = m_originalCaster->SpellHitResult(target, this, m_canReflect);
        if (m_skipCheck && targetInfo.missCondition != SPELL_MISS_IMMUNE)
        {
            targetInfo.missCondition = SPELL_MISS_NONE;
        }
    }
    else
        targetInfo.missCondition = SPELL_MISS_EVADE; //SPELL_MISS_NONE;
 
    // Spell have speed - need calculate incoming time
    // Incoming time is zero for self casts. At least I think so.
    if (m_spellInfo->Speed > 0.0f && m_caster != target)
    {
        // calculate spell incoming interval
        float dist = m_caster->GetDistance(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ());
 
        if (dist < 5.0f)
            dist = 5.0f;
        targetInfo.timeDelay = (uint64) std::floor(dist / m_spellInfo->Speed * 1000.0f);
 
        // Calculate minimum incoming time
        if (m_delayMoment == 0 || m_delayMoment > targetInfo.timeDelay)
            m_delayMoment = targetInfo.timeDelay;
    }
    else
        targetInfo.timeDelay = 0LL;
 
    // If target reflect spell back to caster
    if (targetInfo.missCondition == SPELL_MISS_REFLECT)
    {
        // Calculate reflected spell result on caster
        targetInfo.reflectResult = m_caster->SpellHitResult(m_caster, this, m_canReflect);
 
        if (targetInfo.reflectResult == SPELL_MISS_REFLECT)     // Impossible reflect again, so simply deflect spell
            targetInfo.reflectResult = SPELL_MISS_PARRY;
 
        // Increase time interval for reflected spells by 1.5
        m_caster->m_Events.AddEventAtOffset(new ReflectEvent(m_caster, targetInfo.targetGUID, m_spellInfo), Milliseconds(targetInfo.timeDelay));
        targetInfo.timeDelay += targetInfo.timeDelay >> 1;
 
        m_spellFlags |= SPELL_FLAG_REFLECTED;
 
        // HACK: workaround check for succubus seduction case
        if (m_caster->IsPet())
        {
            CreatureTemplate const* ci = sObjectMgr->GetCreatureTemplate(m_caster->GetEntry());
            switch (ci->family)
            {
                case CREATURE_FAMILY_SUCCUBUS:
                    {
                        if (m_spellInfo->SpellIconID != 694) // Soothing Kiss
                            cancel();
                    }
                    break;
                    return;
            }
        }
    }
    else
        targetInfo.reflectResult = SPELL_MISS_NONE;
 
    // Add target to list
    m_UniqueTargetInfo.push_back(targetInfo);
}

References EventProcessor::AddEventAtOffset(), TargetInfo::alive, cancel(), CheckEffectTarget(), SpellInfo::CheckTarget(), CREATURE_FAMILY_SUCCUBUS, TargetInfo::crit, TargetInfo::damage, TargetInfo::damageBeforeTakenMods, TargetInfo::effectMask, SpellInfo::Effects, CreatureTemplate::family, WorldObject::GetDistance(), Object::GetEntry(), SpellInfo::GetFirstRankSpell(), Object::GetGUID(), Unit::GetLevel(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Unit::IsAlive(), Unit::IsImmunedToSpellEffect(), Unit::IsPet(), m_auraScaleMask, m_canReflect, m_caster, m_delayMoment, WorldObject::m_Events, m_originalCaster, m_skipCheck, m_spellFlags, m_spellInfo, m_UniqueTargetInfo, MAX_SPELL_EFFECTS, TargetInfo::missCondition, TargetInfo::processed, TargetInfo::reflectResult, TargetInfo::scaleAura, sObjectMgr, SpellInfo::Speed, SPELL_CAST_OK, SPELL_FLAG_REFLECTED, SPELL_MISS_EVADE, SPELL_MISS_IMMUNE, SPELL_MISS_NONE, SPELL_MISS_PARRY, SPELL_MISS_REFLECT, Unit::SpellHitResult(), SpellInfo::SpellIconID, SpellInfo::SpellLevel, sScriptMgr, TargetInfo::targetGUID, and TargetInfo::timeDelay.

Referenced by SelectEffectTypeImplicitTargets(), SelectImplicitAreaTargets(), SelectImplicitCasterObjectTargets(), SelectImplicitChainTargets(), SelectImplicitChannelTargets(), SelectImplicitConeTargets(), SelectImplicitNearbyTargets(), and SelectImplicitTargetObjectTargets().

◆ CalculateDelayMomentForDst()

uint64 Spell::CalculateDelayMomentForDst ( ) 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 * 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 * 1000.0f);
        }
    }
 
    return 0;
}

References SpellCastTargets::GetDist2d(), SpellCastTargets::GetDstPos(), Position::GetExactDist(), SpellCastTargets::GetSpeedXY(), SpellCastTargets::HasDst(), SpellCastTargets::HasTraj(), m_caster, m_spellInfo, m_targets, and SpellInfo::Speed.

Referenced by RecalculateDelayMomentForDst(), and SelectSpellTargets().

◆ CalculateJumpSpeeds()

void Spell::CalculateJumpSpeeds	(	uint8	i,
		float	dist,
		float &	speedxy,
		float &	speedz
	)

protected

{
    float runSpeed = m_caster->IsControlledByPlayer() ? playerBaseMoveSpeed[MOVE_RUN] : baseMoveSpeed[MOVE_RUN];
    if (Creature* creature = m_caster->ToCreature())
        runSpeed *= creature->GetCreatureTemplate()->speed_run;
 
    float multiplier = m_spellInfo->Effects[i].ValueMultiplier;
    if (multiplier <= 0.0f)
        multiplier = 1.0f;
 
    speedXY = std::min(runSpeed * 3.0f * multiplier, std::max(28.0f, m_caster->GetSpeed(MOVE_RUN) * 4.0f));
 
    float duration = dist / speedXY;
    float durationSqr = duration * duration;
    float minHeight = m_spellInfo->Effects[i].MiscValue  ? m_spellInfo->Effects[i].MiscValue  / 10.0f :    0.5f; // Lower bound is blizzlike
    float maxHeight = m_spellInfo->Effects[i].MiscValueB ? m_spellInfo->Effects[i].MiscValueB / 10.0f : 1000.0f; // Upper bound is unknown
    float height;
    if (durationSqr < minHeight * 8 / Movement::gravity)
        height = minHeight;
    else if (durationSqr > maxHeight * 8 / Movement::gravity)
        height = maxHeight;
    else
        height = Movement::gravity * durationSqr / 8;
 
    speedZ = std::sqrt(2 * Movement::gravity * height);
}

References baseMoveSpeed, SpellInfo::Effects, Unit::GetSpeed(), Movement::gravity, Unit::IsControlledByPlayer(), m_caster, m_spellInfo, MOVE_RUN, playerBaseMoveSpeed, and Object::ToCreature().

Referenced by EffectJump(), and EffectJumpDest().

◆ CalculateSpellDamage()

int32 Spell::CalculateSpellDamage	(	uint8	i,
		Unit const *	target
	)		const

inline

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

Unit::CalculateSpellDamage

int32 CalculateSpellDamage(Unit const *target, SpellInfo const *spellProto, uint8 effect_index, int32 const *basePoints=nullptr) const

Definition Unit.cpp:11584

SpellValue::EffectBasePoints

int32 EffectBasePoints[MAX_SPELL_EFFECTS]

Definition Spell.h:225

References Unit::CalculateSpellDamage(), SpellValue::EffectBasePoints, m_caster, m_spellInfo, and m_spellValue.

Referenced by CheckCast(), CheckEffectTarget(), EffectWeaponDmg(), and HandleEffects().

◆ CallScriptAfterCastHandlers()

void Spell::CallScriptAfterCastHandlers ( )

protected

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

References m_loadedScripts, and SPELL_SCRIPT_HOOK_AFTER_CAST.

Referenced by _cast().

◆ CallScriptAfterHitHandlers()

void Spell::CallScriptAfterHitHandlers ( )

protected

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

References m_loadedScripts, and SPELL_SCRIPT_HOOK_AFTER_HIT.

Referenced by DoAllEffectOnTarget(), DoAllEffectOnTarget(), and DoAllEffectOnTarget().

◆ CallScriptBeforeCastHandlers()

void Spell::CallScriptBeforeCastHandlers ( )

protected

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

References m_loadedScripts, and SPELL_SCRIPT_HOOK_BEFORE_CAST.

Referenced by _cast().

◆ CallScriptBeforeHitHandlers()

void Spell::CallScriptBeforeHitHandlers ( SpellMissInfo missInfo )

protected

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

References m_loadedScripts, and SPELL_SCRIPT_HOOK_BEFORE_HIT.

Referenced by DoAllEffectOnTarget(), DoAllEffectOnTarget(), and DoAllEffectOnTarget().

◆ CallScriptCheckCastHandlers()

SpellCastResult Spell::CallScriptCheckCastHandlers ( )

protected

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

References m_loadedScripts, SPELL_CAST_OK, and SPELL_SCRIPT_HOOK_CHECK_CAST.

Referenced by CheckCast().

◆ CallScriptDestinationTargetSelectHandlers()

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

protected

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

References SpellImplicitTargetInfo::GetTarget(), m_loadedScripts, m_spellInfo, and SPELL_SCRIPT_HOOK_DESTINATION_TARGET_SELECT.

Referenced by SelectImplicitCasterDestTargets(), SelectImplicitDestDestTargets(), SelectImplicitTargetDestTargets(), and SelectImplicitTrajTargets().

◆ CallScriptEffectHandlers()

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

protected

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

References ABORT, m_loadedScripts, m_spellInfo, SPELL_EFFECT_HANDLE_HIT, SPELL_EFFECT_HANDLE_HIT_TARGET, SPELL_EFFECT_HANDLE_LAUNCH, SPELL_EFFECT_HANDLE_LAUNCH_TARGET, SPELL_SCRIPT_HOOK_EFFECT_HIT, SPELL_SCRIPT_HOOK_EFFECT_HIT_TARGET, SPELL_SCRIPT_HOOK_EFFECT_LAUNCH, and SPELL_SCRIPT_HOOK_EFFECT_LAUNCH_TARGET.

Referenced by HandleEffects().

◆ CallScriptObjectAreaTargetSelectHandlers()

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

protected

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

References SpellImplicitTargetInfo::GetTarget(), m_loadedScripts, m_spellInfo, and SPELL_SCRIPT_HOOK_OBJECT_AREA_TARGET_SELECT.

Referenced by SelectImplicitAreaTargets(), SelectImplicitChainTargets(), and SelectImplicitConeTargets().

◆ CallScriptObjectTargetSelectHandlers()

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

protected

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

References SpellImplicitTargetInfo::GetTarget(), m_loadedScripts, m_spellInfo, and SPELL_SCRIPT_HOOK_OBJECT_TARGET_SELECT.

Referenced by SelectEffectTypeImplicitTargets(), SelectImplicitCasterObjectTargets(), SelectImplicitChannelTargets(), SelectImplicitNearbyTargets(), and SelectImplicitTargetObjectTargets().

◆ CallScriptOnCastHandlers()

void Spell::CallScriptOnCastHandlers ( )

protected

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

References m_loadedScripts, and SPELL_SCRIPT_HOOK_ON_CAST.

Referenced by _cast().

◆ CallScriptOnHitHandlers()

void Spell::CallScriptOnHitHandlers ( )

protected

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

References m_loadedScripts, and SPELL_SCRIPT_HOOK_HIT.

Referenced by DoAllEffectOnTarget(), DoAllEffectOnTarget(), and DoAllEffectOnTarget().

◆ CanAutoCast()

bool Spell::CanAutoCast ( Unit * target )

{
    ObjectGuid targetguid = target->GetGUID();
 
    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)
    {
        SelectSpellTargets();
        //check if among target units, our WANTED target is as well (->only self cast spells return false)
        for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
            if (ihit->targetGUID == targetguid)
                return true;
    }
    return false;                                           //target invalid
}

References CheckPetCast(), Unit::GetAuraEffectsByType(), GetCaster(), SpellInfo::GetEffects(), Object::GetGUID(), GetSpellInfo(), SpellInfo::Id, m_spellInfo, m_UniqueTargetInfo, SelectSpellTargets(), SPELL_CAST_OK, SPELL_FAILED_UNIT_NOT_INFRONT, SPELL_GROUP_STACK_RULE_DEFAULT, SPELL_GROUP_STACK_RULE_EXCLUSIVE, SPELL_GROUP_STACK_RULE_EXCLUSIVE_FROM_SAME_CASTER, SPELL_GROUP_STACK_RULE_EXCLUSIVE_HIGHEST, SPELL_GROUP_STACK_RULE_EXCLUSIVE_SAME_EFFECT, and sSpellMgr.

Referenced by PetAI::UpdateAI().

◆ cancel()

void Spell::cancel ( bool bySelf = false )

{
    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();
            SendCastResult(SPELL_FAILED_INTERRUPTED);
 
            if (m_caster->IsPlayer())
            {
                if (m_caster->ToPlayer()->NeedSendSpectatorData())
                    ArenaSpectator::SendCommand_Spell(m_caster->FindMap(), m_caster->GetGUID(), "SPE", m_spellInfo->Id, bySelf ? 99998 : 99999);
            }
            [[fallthrough]];
        case SPELL_STATE_DELAYED:
            SendInterrupted(SPELL_FAILED_INTERRUPTED);
            break;
        case SPELL_STATE_CASTING:
            if (!bySelf)
            {
                for (std::list<TargetInfo>::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
                    if ((*ihit).missCondition == SPELL_MISS_NONE)
                        if (Unit* unit = m_caster->GetGUID() == ihit->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID))
                            unit->RemoveOwnedAura(m_spellInfo->Id, m_originalCasterGUID, 0, AURA_REMOVE_BY_CANCEL);
 
                if (m_caster->IsPlayer() && m_spellInfo->IsCooldownStartedOnEvent())
                    m_caster->ToPlayer()->RemoveSpellCooldown(m_spellInfo->Id, true);
 
                SendChannelUpdate(0);
                SendInterrupted(SPELL_FAILED_INTERRUPTED);
            }
 
            if (m_caster->IsPlayer() && m_caster->ToPlayer()->NeedSendSpectatorData())
                ArenaSpectator::SendCommand_Spell(m_caster->FindMap(), m_caster->GetGUID(), "SPE", m_spellInfo->Id, bySelf ? 99998 : 99999);
 
            // spell is canceled-take mods and clear list
            if (Player* player = m_caster->GetSpellModOwner())
                player->RemoveSpellMods(this);
 
            m_appliedMods.clear();
            break;
        default:
            break;
    }
 
    SetReferencedFromCurrent(false);
    if (m_selfContainer && *m_selfContainer == this)
        *m_selfContainer = nullptr;
 
    // Do not remove current far sight object (already done in Spell::EffectAddFarsight) to prevent from reset viewpoint to player
    if (!(bySelf && m_spellInfo->HasEffect(SPELL_EFFECT_ADD_FARSIGHT)))
    {
        m_caster->RemoveDynObject(m_spellInfo->Id);
    }
 
    if (m_spellInfo->IsChanneled()) // if not channeled then the object for the current cast wasn't summoned yet
        m_caster->RemoveGameObject(m_spellInfo->Id, true);
 
    //set state back so finish will be processed
    m_spellState = oldState;
 
    sScriptMgr->OnSpellCastCancel(this, m_caster, m_spellInfo, bySelf);
 
    finish(false);
}

References AURA_REMOVE_BY_CANCEL, CancelGlobalCooldown(), WorldObject::FindMap(), finish(), Object::GetGUID(), Unit::GetSpellModOwner(), ObjectAccessor::GetUnit(), SpellInfo::HasEffect(), SpellInfo::Id, SpellInfo::IsChanneled(), SpellInfo::IsCooldownStartedOnEvent(), Object::IsPlayer(), m_appliedMods, m_autoRepeat, m_caster, m_originalCasterGUID, m_selfContainer, m_spellInfo, m_spellState, m_UniqueTargetInfo, Player::NeedSendSpectatorData(), Unit::RemoveDynObject(), Unit::RemoveGameObject(), Player::RemoveSpellCooldown(), SendCastResult(), SendChannelUpdate(), ArenaSpectator::SendCommand_Spell(), SendInterrupted(), SetReferencedFromCurrent(), SPELL_EFFECT_ADD_FARSIGHT, SPELL_FAILED_INTERRUPTED, SPELL_MISS_NONE, SPELL_STATE_CASTING, SPELL_STATE_DELAYED, SPELL_STATE_FINISHED, SPELL_STATE_PREPARING, sScriptMgr, and Object::ToPlayer().

Referenced by _cast(), SpellEvent::Abort(), AddUnitTarget(), SpellScript::Cancel(), Unit::InterruptSpell(), update(), and SpellEvent::~SpellEvent().

◆ CancelGlobalCooldown()

void Spell::CancelGlobalCooldown ( )

protected

{
    if (!m_spellInfo->StartRecoveryTime)
        return;
 
    // Cancel global cooldown when interrupting current cast
    if (m_caster->GetCurrentSpell(CURRENT_GENERIC_SPELL) != this)
        return;
 
    // Only players or controlled units have global cooldown
    if (m_caster->GetCharmInfo())
        m_caster->GetCharmInfo()->GetGlobalCooldownMgr().CancelGlobalCooldown(m_spellInfo);
    else if (m_caster->IsPlayer())
        m_caster->ToPlayer()->GetGlobalCooldownMgr().CancelGlobalCooldown(m_spellInfo);
}

References GlobalCooldownMgr::CancelGlobalCooldown(), CURRENT_GENERIC_SPELL, Unit::GetCharmInfo(), Unit::GetCurrentSpell(), Player::GetGlobalCooldownMgr(), CharmInfo::GetGlobalCooldownMgr(), Object::IsPlayer(), m_caster, m_spellInfo, SpellInfo::StartRecoveryTime, and Object::ToPlayer().

Referenced by cancel().

◆ CanExecuteTriggersOnHit()

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

protected

{
    // Relentless strikes, proc only from first effect
    if (triggeredByAura && triggeredByAura->SpellIconID == 559)
        return effMask & (1 << EFFECT_0);
 
    bool only_on_caster = (triggeredByAura && triggeredByAura->HasAttribute(SPELL_ATTR4_CLASS_TRIGGER_ONLY_ON_TARGET));
    // If triggeredByAura has SPELL_ATTR4_CLASS_TRIGGER_ONLY_ON_TARGET then it can only proc on a casted spell with TARGET_UNIT_CASTER
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if ((effMask & (1 << i)) && (!only_on_caster || (m_spellInfo->Effects[i].TargetA.GetTarget() == TARGET_UNIT_CASTER)))
            return true;
    }
    return effMask;
}

References EFFECT_0, SpellInfo::Effects, SpellInfo::HasAttribute(), m_spellInfo, MAX_SPELL_EFFECTS, SPELL_ATTR4_CLASS_TRIGGER_ONLY_ON_TARGET, SpellInfo::SpellIconID, and TARGET_UNIT_CASTER.

Referenced by DoAllEffectOnTarget(), and DoTriggersOnSpellHit().

◆ CanOpenLock()

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

protected

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

References SpellInfo::Effects, Object::GetEntry(), Player::GetSkillValue(), SpellInfo::Id, LockEntry::Index, SpellInfo::IsAbilityOfSkillType(), Object::IsPlayer(), LOCK_KEY_ITEM, LOCK_KEY_SKILL, LOCK_KEY_SPELL, m_caster, m_CastItem, m_spellInfo, MAX_LOCK_CASE, LockEntry::Skill, SKILL_LOCKPICKING, SKILL_NONE, SkillByLockType(), sLockStore, SPELL_CAST_OK, SPELL_FAILED_BAD_TARGETS, SPELL_FAILED_LOW_CASTLEVEL, TARGET_GAMEOBJECT_ITEM_TARGET, Object::ToPlayer(), and LockEntry::Type.

Referenced by CheckCast(), and EffectOpenLock().

◆ cast()

void Spell::cast ( bool skipCheck = false )

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

References _cast(), Unit::GetSpellModOwner(), m_caster, Player::m_spellModTakingSpell, and Player::SetSpellModTakingSpell().

Referenced by Unit::AttackerStateUpdate(), prepare(), and update().

◆ CheckCast()

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

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

{
    // check death state
    if (!m_caster->IsAlive() && !m_spellInfo->HasAttribute(SPELL_ATTR0_PASSIVE) && !(m_spellInfo->HasAttribute(SPELL_ATTR0_ALLOW_CAST_WHILE_DEAD) || (IsTriggered() && !m_triggeredByAuraSpell)))
        return SPELL_FAILED_CASTER_DEAD;
 
    // Spectator check
    if (m_caster->IsPlayer())
        if (((Player const*)m_caster)->IsSpectator() && m_spellInfo->Id != SPECTATOR_SPELL_BINDSIGHT)
            return SPELL_FAILED_NOT_HERE;
 
    SpellCastResult res = SPELL_CAST_OK;
 
    sScriptMgr->OnSpellCheckCast(this, strict, res);
 
    if (res != SPELL_CAST_OK)
        return res;
 
    // check cooldowns to prevent cheating
    if (!m_spellInfo->HasAttribute(SPELL_ATTR0_PASSIVE))
    {
        if (m_caster->IsPlayer())
        {
            //can cast triggered (by aura only?) spells while have this flag
            if (!HasTriggeredCastFlag(TRIGGERED_IGNORE_CASTER_AURASTATE) && m_caster->ToPlayer()->HasPlayerFlag(PLAYER_ALLOW_ONLY_ABILITY) && !IsNextMeleeSwingSpell())
                return SPELL_FAILED_SPELL_IN_PROGRESS;
 
            if (!HasTriggeredCastFlag(TRIGGERED_IGNORE_SPELL_AND_CATEGORY_CD) && m_caster->ToPlayer()->HasSpellCooldown(m_spellInfo->Id))
            {
                if (m_triggeredByAuraSpell)
                    return SPELL_FAILED_DONT_REPORT;
                else
                    return SPELL_FAILED_NOT_READY;
            }
 
            // check if we are using a potion in combat for the 2nd+ time. Cooldown is added only after caster gets out of combat
            if (m_caster->ToPlayer()->GetLastPotionId() && m_CastItem && (m_CastItem->IsPotion() || m_spellInfo->IsCooldownStartedOnEvent()))
                return SPELL_FAILED_NOT_READY;
        }
        else if (!IsTriggered() && m_caster->IsCreature() && m_caster->ToCreature()->IsSpellProhibited(m_spellInfo->GetSchoolMask()))
            return SPELL_FAILED_NOT_READY;
    }
 
    if (m_spellInfo->HasAttribute(SPELL_ATTR7_DEBUG_SPELL) && !m_caster->HasUnitFlag2(UNIT_FLAG2_ALLOW_CHEAT_SPELLS))
    {
        m_customError = SPELL_CUSTOM_ERROR_GM_ONLY;
        return SPELL_FAILED_CUSTOM_ERROR;
    }
 
    // Check global cooldown
    if (strict && !HasTriggeredCastFlag(TRIGGERED_IGNORE_GCD) && HasGlobalCooldown())
        return SPELL_FAILED_NOT_READY;
 
    // only triggered spells can be processed an ended battleground
    if (!IsTriggered() && m_caster->IsPlayer())
        if (Battleground* bg = m_caster->ToPlayer()->GetBattleground())
            if (bg->GetStatus() == STATUS_WAIT_LEAVE)
                return SPELL_FAILED_DONT_REPORT;
 
    if (m_caster->IsPlayer() /*&& VMAP::VMapFactory::createOrGetVMapMgr()->isLineOfSightCalcEnabled()*/) // pussywizard: optimization (commented)
    {
        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;
    }
 
    // only check at first call, Stealth auras are already removed at second call
    // for now, ignore triggered spells
    if (strict && !HasTriggeredCastFlag(TRIGGERED_IGNORE_SHAPESHIFT))
    {
        bool checkForm = true;
        // Ignore form req aura
        Unit::AuraEffectList const& ignore = m_caster->GetAuraEffectsByType(SPELL_AURA_MOD_IGNORE_SHAPESHIFT);
        for (Unit::AuraEffectList::const_iterator i = ignore.begin(); i != ignore.end(); ++i)
        {
            if (!(*i)->IsAffectedOnSpell(m_spellInfo))
                continue;
            checkForm = false;
            break;
        }
        if (checkForm)
        {
            // Cannot be used in this stance/form
            SpellCastResult shapeError = m_spellInfo->CheckShapeshift(m_caster->GetShapeshiftForm());
            if (shapeError != SPELL_CAST_OK)
                return shapeError;
 
            if (m_spellInfo->HasAttribute(SPELL_ATTR0_ONLY_STEALTHED) && !(m_caster->HasStealthAura()))
                return SPELL_FAILED_ONLY_STEALTHED;
        }
    }
 
    Unit::AuraEffectList const& blockSpells = m_caster->GetAuraEffectsByType(SPELL_AURA_BLOCK_SPELL_FAMILY);
    for (Unit::AuraEffectList::const_iterator blockItr = blockSpells.begin(); blockItr != blockSpells.end(); ++blockItr)
        if (uint32((*blockItr)->GetMiscValue()) == m_spellInfo->SpellFamilyName)
            return SPELL_FAILED_SPELL_UNAVAILABLE;
 
    bool reqCombat = true;
    Unit::AuraEffectList const& stateAuras = m_caster->GetAuraEffectsByType(SPELL_AURA_ABILITY_IGNORE_AURASTATE);
    for (Unit::AuraEffectList::const_iterator j = stateAuras.begin(); j != stateAuras.end(); ++j)
    {
        if ((*j)->IsAffectedOnSpell(m_spellInfo))
        {
            m_needComboPoints = false;
            if ((*j)->GetMiscValue() == 1)
            {
                reqCombat = false;
                break;
            }
        }
    }
 
    // caster state requirements
    // not for triggered spells (needed by execute)
    if (!HasTriggeredCastFlag(TRIGGERED_IGNORE_CASTER_AURASTATE))
    {
        if (m_spellInfo->CasterAuraState && !m_caster->HasAuraState(AuraStateType(m_spellInfo->CasterAuraState), m_spellInfo, m_caster))
            return SPELL_FAILED_CASTER_AURASTATE;
        if (m_spellInfo->CasterAuraStateNot && m_caster->HasAuraState(AuraStateType(m_spellInfo->CasterAuraStateNot), m_spellInfo, m_caster))
            return SPELL_FAILED_CASTER_AURASTATE;
 
        // Note: spell 62473 requres CasterAuraSpell = triggering spell
        if (m_spellInfo->CasterAuraSpell && !m_caster->HasAura(sSpellMgr->GetSpellIdForDifficulty(m_spellInfo->CasterAuraSpell, m_caster)))
            return SPELL_FAILED_CASTER_AURASTATE;
        if (m_spellInfo->ExcludeCasterAuraSpell && m_caster->HasAura(sSpellMgr->GetSpellIdForDifficulty(m_spellInfo->ExcludeCasterAuraSpell, m_caster)))
            return SPELL_FAILED_CASTER_AURASTATE;
 
        if (reqCombat && m_caster->IsInCombat() && !m_spellInfo->CanBeUsedInCombat())
            return SPELL_FAILED_AFFECTING_COMBAT;
    }
 
    // Xinef: exploit protection
    if (reqCombat && !m_spellInfo->CanBeUsedInCombat() && (m_spellInfo->HasEffect(SPELL_EFFECT_RESURRECT) || m_spellInfo->HasEffect(SPELL_EFFECT_RESURRECT_NEW)))
    {
        if (m_caster->IsPlayer() && m_caster->GetMap()->IsDungeon())
            if (InstanceScript* instanceScript = m_caster->GetInstanceScript())
                if (instanceScript->IsEncounterInProgress())
                {
                    if (Group* group = m_caster->ToPlayer()->GetGroup())
                        for (GroupReference* itr = group->GetFirstMember(); itr != nullptr; itr = itr->next())
                            if (Player* member = itr->GetSource())
                                if (member->IsInMap(m_caster))
                                    if (Unit* victim = member->GetVictim())
                                        if (victim->IsInCombat() && m_caster->GetDistance(victim) < m_caster->GetVisibilityRange())
                                        {
                                            m_caster->EngageWithTarget(victim);
                                            break;
                                        }
                    return SPELL_FAILED_TARGET_CANNOT_BE_RESURRECTED;
                }
    }
 
    // cancel autorepeat spells if cast start when moving
    // (not wand currently autorepeat cast delayed to moving stop anyway in spell update code)
    if (m_caster->IsPlayer() && m_caster->ToPlayer()->isMoving() && !IsTriggered())
    {
        // skip stuck spell to allow use it in falling case and apply spell limitations at movement
        if ((!m_caster->HasUnitMovementFlag(MOVEMENTFLAG_FALLING_FAR) || m_spellInfo->Effects[0].Effect != SPELL_EFFECT_STUCK) &&
                (IsAutoRepeat() || (m_spellInfo->AuraInterruptFlags & AURA_INTERRUPT_FLAG_NOT_SEATED) != 0))
            return SPELL_FAILED_MOVING;
    }
 
    Vehicle* vehicle = m_caster->GetVehicle();
    if (vehicle && !HasTriggeredCastFlag(TRIGGERED_IGNORE_CASTER_MOUNTED_OR_ON_VEHICLE))
    {
        uint16 checkMask = 0;
        for (uint8 effIndex = EFFECT_0; effIndex < MAX_SPELL_EFFECTS; ++effIndex)
        {
            SpellEffectInfo const* effInfo = &m_spellInfo->Effects[effIndex];
            if (effInfo->ApplyAuraName == SPELL_AURA_MOD_SHAPESHIFT)
            {
                SpellShapeshiftFormEntry const* shapeShiftEntry = sSpellShapeshiftFormStore.LookupEntry(effInfo->MiscValue);
                if (shapeShiftEntry && (shapeShiftEntry->flags1 & SHAPESHIFT_FLAG_STANCE) == 0)
                    checkMask |= VEHICLE_SEAT_FLAG_UNCONTROLLED;
                break;
            }
        }
 
        if (m_spellInfo->HasAura(SPELL_AURA_MOUNTED))
            checkMask |= VEHICLE_SEAT_FLAG_CAN_CAST_MOUNT_SPELL;
 
        if (!checkMask)
            checkMask = VEHICLE_SEAT_FLAG_CAN_ATTACK;
 
        // All creatures should be able to cast as passengers freely, restriction and attribute are only for players
        VehicleSeatEntry const* vehicleSeat = vehicle->GetSeatForPassenger(m_caster);
        if (!m_spellInfo->HasAttribute(SPELL_ATTR6_ALLOW_WHILE_RIDING_VEHICLE) && !m_spellInfo->HasAttribute(SPELL_ATTR0_ALLOW_WHILE_MOUNTED)
                && (vehicleSeat->m_flags & checkMask) != checkMask && m_caster->IsPlayer())
            return SPELL_FAILED_DONT_REPORT;
    }
 
    // check spell cast conditions from database
    {
        ConditionSourceInfo condInfo = ConditionSourceInfo(m_caster);
        condInfo.mConditionTargets[1] = m_targets.GetObjectTarget();
        ConditionList conditions = sConditionMgr->GetConditionsForNotGroupedEntry(CONDITION_SOURCE_TYPE_SPELL, m_spellInfo->Id);
        if (!conditions.empty() && !sConditionMgr->IsObjectMeetToConditions(condInfo, conditions))
        {
            // mLastFailedCondition can be nullptr 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
    // Xinef: do not check explicit casts for self cast of triggered spells (eg. reflect case)
    if (!(m_spellInfo->HasAttribute(SPELL_ATTR0_PASSIVE) && (!m_targets.GetUnitTarget() || m_targets.GetUnitTarget() == m_caster)))
    {
        // Check explicit target for m_originalCaster - todo: get rid of such workarounds
        // Xinef: do not check explicit target for triggered spell casted on self with targetflag enemy
        if (!m_triggeredByAuraSpell || m_targets.GetUnitTarget() != m_caster || !(m_spellInfo->GetExplicitTargetMask() & TARGET_FLAG_UNIT_ENEMY))
        {
            SpellCastResult castResult = m_spellInfo->CheckExplicitTarget((m_originalCaster && m_caster->GetEntry() != WORLD_TRIGGER) ? m_originalCaster : m_caster, m_targets.GetObjectTarget(), m_targets.GetItemTarget());
            if (castResult != SPELL_CAST_OK)
                return castResult;
        }
    }
 
    if (Unit* target = m_targets.GetUnitTarget())
    {
        SpellCastResult castResult = m_spellInfo->CheckTarget(m_caster, target, false);
        if (castResult != SPELL_CAST_OK)
            return castResult;
 
        if (target != m_caster)
        {
            // Must be behind the target
            if (m_spellInfo->HasAttribute(SPELL_ATTR0_CU_REQ_CASTER_BEHIND_TARGET) && target->HasInArc(static_cast<float>(M_PI), m_caster))
                return SPELL_FAILED_NOT_BEHIND;
 
            // Target must be facing you
            if (m_spellInfo->HasAttribute(SPELL_ATTR0_CU_REQ_TARGET_FACING_CASTER) && !target->HasInArc(static_cast<float>(M_PI), m_caster))
                return SPELL_FAILED_NOT_INFRONT;
 
            if ((!m_caster->IsTotem() || !m_spellInfo->IsPositive()) && !m_spellInfo->HasAttribute(SPELL_ATTR2_IGNORE_LINE_OF_SIGHT) &&
                !m_spellInfo->HasAttribute(SPELL_ATTR5_ALWAYS_AOE_LINE_OF_SIGHT) && !(m_spellFlags & SPELL_FLAG_REDIRECTED))
            {
                bool castedByGameobject = false;
                uint32 losChecks = LINEOFSIGHT_ALL_CHECKS;
                if (m_originalCasterGUID.IsGameObject())
                {
                    castedByGameobject = m_caster->GetMap()->GetGameObject(m_originalCasterGUID) != nullptr;
                }
                else if (m_caster->GetEntry() == WORLD_TRIGGER)
                {
                    if (TempSummon* tempSummon = m_caster->ToTempSummon())
                    {
                        castedByGameobject = tempSummon->GetSummonerGameObject() != nullptr;
                    }
                }
 
                if (castedByGameobject)
                {
                    // If spell casted by gameobject then ignore M2 models
                    losChecks &= ~LINEOFSIGHT_CHECK_GOBJECT_M2;
                }
 
                if (!m_caster->IsWithinLOSInMap(target, VMAP::ModelIgnoreFlags::M2, LineOfSightChecks(losChecks)))
                {
                    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_caster->IsTotem() || !m_spellInfo->IsPositive()) && !m_spellInfo->HasAttribute(SPELL_ATTR2_IGNORE_LINE_OF_SIGHT) &&
            !m_spellInfo->HasAttribute(SPELL_ATTR5_ALWAYS_AOE_LINE_OF_SIGHT))
        {
            bool castedByGameobject = false;
            uint32 losChecks = LINEOFSIGHT_ALL_CHECKS;
            if (m_originalCasterGUID.IsGameObject())
            {
                castedByGameobject = m_caster->GetMap()->GetGameObject(m_originalCasterGUID) != nullptr;
            }
            else if (m_caster->GetEntry() == WORLD_TRIGGER)
            {
                if (TempSummon* tempSummon = m_caster->ToTempSummon())
                {
                    castedByGameobject = tempSummon->GetSummonerGameObject() != nullptr;
                }
            }
 
            if (castedByGameobject)
            {
                // If spell casted by gameobject then ignore M2 models
                losChecks &= ~LINEOFSIGHT_CHECK_GOBJECT_M2;
            }
 
            if (!m_caster->IsWithinLOS(x, y, z, VMAP::ModelIgnoreFlags::M2, LineOfSightChecks((losChecks))))
            {
                return SPELL_FAILED_LINE_OF_SIGHT;
            }
        }
    }
 
    // check pet presence
    for (int j = 0; j < MAX_SPELL_EFFECTS; ++j)
    {
        if (m_spellInfo->Effects[j].TargetA.GetTarget() == TARGET_UNIT_PET)
        {
            if (!m_caster->GetGuardianPet() && !m_caster->GetCharm())
            {
                if (m_triggeredByAuraSpell.spellInfo) // not report pet not existence for triggered spells
                    return SPELL_FAILED_DONT_REPORT;
                else
                    return SPELL_FAILED_NO_PET;
            }
            break;
        }
    }
    // Spell casted only on battleground
    if (m_spellInfo->HasAttribute(SPELL_ATTR3_ONLY_BATTLEGROUNDS) &&  m_caster->IsPlayer())
        if (!m_caster->ToPlayer()->InBattleground())
            return SPELL_FAILED_ONLY_BATTLEGROUNDS;
 
    // do not allow spells to be cast in arenas
    // - with greater than 10 min CD without SPELL_ATTR4_IGNORE_DEFAULT_ARENA_RESTRICTIONS flag
    // - with SPELL_ATTR4_NOT_IN_ARENA_OR_RATED_BATTLEGROUND flag
    if (m_spellInfo->HasAttribute(SPELL_ATTR4_NOT_IN_ARENA_OR_RATED_BATTLEGROUND) ||
            (m_spellInfo->GetRecoveryTime() >= 10 * MINUTE * IN_MILLISECONDS && !m_spellInfo->HasAttribute(SPELL_ATTR4_IGNORE_DEFAULT_ARENA_RESTRICTIONS)))
        if (MapEntry const* mapEntry = sMapStore.LookupEntry(m_caster->GetMapId()))
            if (mapEntry->IsBattleArena())
                return SPELL_FAILED_NOT_IN_ARENA;
 
    // zone check
    if (m_caster->IsCreature() || !m_caster->ToPlayer()->IsGameMaster())
    {
        uint32 zone, area;
        m_caster->GetZoneAndAreaId(zone, area);
 
        SpellCastResult locRes = m_spellInfo->CheckLocation(m_caster->GetMapId(), zone, area,
                                 m_caster->IsPlayer() ? m_caster->ToPlayer() : nullptr);
        if (locRes != SPELL_CAST_OK)
            return locRes;
    }
 
    // not let players cast spells at mount (and let do it to creatures)
    if (m_caster->IsMounted() && m_caster->IsPlayer() && !HasTriggeredCastFlag(TRIGGERED_IGNORE_CASTER_MOUNTED_OR_ON_VEHICLE) &&
            !m_spellInfo->IsPassive() && !m_spellInfo->HasAttribute(SPELL_ATTR0_ALLOW_WHILE_MOUNTED))
    {
        if (m_caster->IsInFlight())
            return SPELL_FAILED_NOT_ON_TAXI;
        else
            return SPELL_FAILED_NOT_MOUNTED;
    }
 
    SpellCastResult castResult = SPELL_CAST_OK;
 
    // always (except passive spells) check items (focus object can be required for any type casts)
    if (!m_spellInfo->IsPassive())
    {
        // spell focus needs to be checked not only for players! there are vehicle spells that require spell focus
        castResult = CheckSpellFocus();
        if (castResult != SPELL_CAST_OK)
            return castResult;
 
        castResult = CheckItems();
        if (castResult != SPELL_CAST_OK)
            return castResult;
    }
 
    // Triggered spells also have range check
    castResult = CheckRange(strict);
    if (castResult != SPELL_CAST_OK)
        return castResult;
 
    if (!HasTriggeredCastFlag(TRIGGERED_IGNORE_POWER_AND_REAGENT_COST))
    {
        castResult = CheckPower();
        if (castResult != SPELL_CAST_OK)
            return castResult;
    }
 
    if (HasTriggeredCastFlag(TRIGGERED_IGNORE_EFFECTS))
    {
        return SPELL_CAST_OK;
    }
 
    // xinef: do not skip triggered spells if they posses prevention type (eg. Bladestorm vs Hand of Protection)
    if (!HasTriggeredCastFlag(TRIGGERED_IGNORE_CASTER_AURAS) || (m_spellInfo->PreventionType > SPELL_PREVENTION_TYPE_NONE && m_triggeredByAuraSpell && m_triggeredByAuraSpell.spellInfo->IsPositive()))
    {
        castResult = CheckCasterAuras(HasTriggeredCastFlag(TRIGGERED_IGNORE_CASTER_AURAS));
        if (castResult != SPELL_CAST_OK)
            return castResult;
 
        // xinef: Enraged Regeneration: While this is active, the warrior is blocked from using abilities that trigger being enraged (which would do nothing and waste the cooldowns).
        if (m_spellInfo->Mechanic && m_spellInfo->IsSelfCast())
        {
            auto const& mechanicList = m_caster->m_spellImmune[IMMUNITY_MECHANIC];
            if (mechanicList.count(m_spellInfo->Mechanic) > 0)
                return SPELL_FAILED_DAMAGE_IMMUNE;
        }
    }
 
    // script hook
    castResult = CallScriptCheckCastHandlers();
    if (castResult != SPELL_CAST_OK)
        return castResult;
 
    bool hasDispellableAura = false;
    bool hasNonDispelEffect = false;
    uint32 dispelMask = 0;
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (m_spellInfo->Effects[i].Effect == SPELL_EFFECT_DISPEL)
        {
            if (m_spellInfo->Effects[i].IsTargetingArea() || m_spellInfo->HasAttribute(SPELL_ATTR1_INITIATE_COMBAT))
            {
                hasDispellableAura = true;
                break;
            }
 
            dispelMask |= SpellInfo::GetDispelMask(DispelType(m_spellInfo->Effects[i].MiscValue));
        }
        else if (m_spellInfo->Effects[i].IsEffect())
        {
            hasNonDispelEffect = true;
            break;
        }
 
    if (!hasNonDispelEffect && !hasDispellableAura && dispelMask && !IsTriggered())
    {
        if (Unit* target = m_targets.GetUnitTarget())
        {
            // Xinef: do not allow to cast on hostile targets in sanctuary
            if (!m_caster->IsFriendlyTo(target))
            {
                if (m_caster->IsInSanctuary() || target->IsInSanctuary())
                {
                    // Xinef: fix for duels
                    Player* player = m_caster->ToPlayer();
                    if (!player || !player->duel || target != player->duel->Opponent)
                        return SPELL_FAILED_NOTHING_TO_DISPEL;
                }
            }
 
            DispelChargesList dispelList;
            target->GetDispellableAuraList(m_caster, dispelMask, dispelList, m_spellInfo);
 
            if (dispelList.empty())
                return SPELL_FAILED_NOTHING_TO_DISPEL;
        }
    }
 
    uint8 approximateAuraEffectMask = 0;
    uint8 nonAuraEffectMask = 0;
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        // for effects of spells that have only one target
        switch (m_spellInfo->Effects[i].Effect)
        {
            case SPELL_EFFECT_LEARN_SPELL:
                {
                    if (!m_caster->IsPlayer())
                        return SPELL_FAILED_BAD_TARGETS;
 
                    if (m_spellInfo->Effects[i].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(m_spellInfo->Effects[i].TriggerSpell);
 
                    if (!learn_spellproto)
                        return SPELL_FAILED_NOT_KNOWN;
 
                    if (m_spellInfo->SpellLevel > pet->GetLevel())
                        return SPELL_FAILED_LOWLEVEL;
 
                    break;
                }
            case SPELL_EFFECT_LEARN_PET_SPELL:
                {
                    // check target only for unit target case
                    if (Unit* unitTarget = m_targets.GetUnitTarget())
                    {
                        if (!m_caster->IsPlayer())
                            return SPELL_FAILED_BAD_TARGETS;
 
                        Pet* pet = unitTarget->ToPet();
                        if (!pet || pet->GetOwner() != m_caster)
                            return SPELL_FAILED_BAD_TARGETS;
 
                        SpellInfo const* learn_spellproto = sSpellMgr->GetSpellInfo(m_spellInfo->Effects[i].TriggerSpell);
 
                        if (!learn_spellproto)
                            return SPELL_FAILED_NOT_KNOWN;
 
                        if (m_spellInfo->SpellLevel > pet->GetLevel())
                            return SPELL_FAILED_LOWLEVEL;
                    }
                    break;
                }
            case SPELL_EFFECT_APPLY_GLYPH:
                {
                    uint32 glyphId = m_spellInfo->Effects[i].MiscValue;
                    if (GlyphPropertiesEntry const* gp = sGlyphPropertiesStore.LookupEntry(glyphId))
                        if (m_caster->HasAura(gp->SpellId))
                            return SPELL_FAILED_UNIQUE_GLYPH;
                    break;
                }
            case SPELL_EFFECT_FEED_PET:
                {
                    if (!m_caster->IsPlayer())
                        return SPELL_FAILED_BAD_TARGETS;
 
                    Item* foodItem = m_targets.GetItemTarget();
                    if (!foodItem)
                        return SPELL_FAILED_BAD_TARGETS;
 
                    Pet* pet = m_caster->ToPlayer()->GetPet();
 
                    if (!pet)
                        return SPELL_FAILED_NO_PET;
 
                    if (!pet->HaveInDiet(foodItem->GetTemplate()))
                        return SPELL_FAILED_WRONG_PET_FOOD;
 
                    if (!pet->GetCurrentFoodBenefitLevel(foodItem->GetTemplate()->ItemLevel))
                        return SPELL_FAILED_FOOD_LOWLEVEL;
 
                    if (m_caster->IsInCombat() || pet->IsInCombat())
                        return SPELL_FAILED_AFFECTING_COMBAT;
 
                    break;
                }
            case SPELL_EFFECT_POWER_BURN:
            case SPELL_EFFECT_POWER_DRAIN:
                {
                    // Can be area effect, Check only for players and not check if target - caster (spell can have multiply drain/burn effects)
                    if (m_caster->IsPlayer())
                        if (Unit* target = m_targets.GetUnitTarget())
                            if (target != m_caster && !target->HasActivePowerType(Powers(m_spellInfo->Effects[i].MiscValue)))
                                return SPELL_FAILED_BAD_TARGETS;
                    break;
                }
            case SPELL_EFFECT_CHARGE:
                {
                    if (m_caster->HasUnitState(UNIT_STATE_CHARGING))
                    {
                        return SPELL_FAILED_DONT_REPORT;
                    }
 
                    if (m_spellInfo->SpellFamilyName == SPELLFAMILY_WARRIOR)
                    {
                        // Warbringer - can't be handled in proc system - should be done before checkcast root check and charge effect process
                        if (strict && m_caster->IsScriptOverriden(m_spellInfo, 6953))
                            m_caster->RemoveMovementImpairingAuras(true);
                    }
                    if (m_caster->HasUnitState(UNIT_STATE_ROOT))
                    {
                        // Exception for Master's Call
                        if (m_spellInfo->Id != 54216)
                        {
                            return SPELL_FAILED_ROOTED;
                        }
                    }
                    if (m_caster->IsPlayer())
                        if (Unit* target = m_targets.GetUnitTarget())
                            if (!target->IsAlive())
                                return SPELL_FAILED_BAD_TARGETS;
                    // Xinef: Pass only explicit unit target spells
                    // pussywizard:
                    if (sDisableMgr->IsPathfindingEnabled(m_caster->FindMap()) && m_spellInfo->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(m_caster)) //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, m_caster, this) * 1.5f + objSize; // can't be overly strict
 
                        m_preGeneratedPath = std::make_unique<PathGenerator>(m_caster);
                        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(G3D::Vector3(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ()), objSize); // move back
                    }
                    if (Player* player = m_caster->ToPlayer())
                        player->SetCanTeleport(true);
                    break;
                }
            case SPELL_EFFECT_SKINNING:
                {
                    if (!m_caster->IsPlayer() || !m_targets.GetUnitTarget() || !m_targets.GetUnitTarget()->IsCreature())
                        return SPELL_FAILED_BAD_TARGETS;
 
                    if (!(m_targets.GetUnitTarget()->GetUnitFlags() & UNIT_FLAG_SKINNABLE))
                        return SPELL_FAILED_TARGET_UNSKINNABLE;
 
                    Creature* creature = m_targets.GetUnitTarget()->ToCreature();
                    if (!creature->IsCritter() && !creature->loot.isLooted())
                        return SPELL_FAILED_TARGET_NOT_LOOTED;
 
                    uint32 skill = creature->GetCreatureTemplate()->GetRequiredLootSkill();
 
                    int32 skillValue = m_caster->ToPlayer()->GetSkillValue(skill);
                    int32 TargetLevel = m_targets.GetUnitTarget()->GetLevel();
                    int32 ReqValue = (skillValue < 100 ? (TargetLevel - 10) * 10 : TargetLevel * 5);
                    if (ReqValue > skillValue)
                        return SPELL_FAILED_LOW_CASTLEVEL;
 
                    break;
                }
            case SPELL_EFFECT_OPEN_LOCK:
                {
                    if (m_spellInfo->Effects[i].TargetA.GetTarget() != TARGET_GAMEOBJECT_TARGET &&
                            m_spellInfo->Effects[i].TargetA.GetTarget() != TARGET_GAMEOBJECT_ITEM_TARGET)
                        break;
 
                    if (!m_caster->IsPlayer()  // only players can open locks, gather etc.
                            // we need a go target in case of TARGET_GAMEOBJECT_TARGET
                            || (m_spellInfo->Effects[i].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(TradeSlots(m_targets.GetItemTargetGUID().GetRawValue()));
                    }
                    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 (m_spellInfo->Effects[i].TargetA.GetTarget() == TARGET_GAMEOBJECT_ITEM_TARGET &&
                            !m_targets.GetGOTarget() &&
                            (!pTempItem || !pTempItem->GetTemplate()->LockID || !pTempItem->IsLocked()))
                        return SPELL_FAILED_BAD_TARGETS;
 
                    // We must also ensure the gameobject we are opening is still closed by the time the spell finishes.
                    if (GameObject* go = m_targets.GetGOTarget())
                    {
                        if (go->GetGoType() == GAMEOBJECT_TYPE_DOOR && go->GetGoState() != GO_STATE_READY)
                        {
                            return SPELL_FAILED_ALREADY_OPEN;
                        }
                    }
                    if (m_spellInfo->Id != 1842 || (m_targets.GetGOTarget() &&
                                                    m_targets.GetGOTarget()->GetGOInfo()->type != GAMEOBJECT_TYPE_TRAP))
                    {
                        if (m_targets.GetGOTarget() && m_targets.GetGOTarget()->GetEntry() == 179697)
                        {
                            if (!m_caster->ToPlayer()->CanUseBattlegroundObject(nullptr))
                                return SPELL_FAILED_TRY_AGAIN;
                        }
                        else if (m_caster->ToPlayer()->InBattleground() && // In Battleground players can use only flags and banners, or Gurubashi chest
                                 !m_caster->ToPlayer()->CanUseBattlegroundObject(m_targets.GetGOTarget()))
                            return SPELL_FAILED_TRY_AGAIN;
                    }
 
                    // get the lock entry
                    uint32 lockId = 0;
                    if (GameObject* go = m_targets.GetGOTarget())
                    {
                        lockId = go->GetGOInfo()->GetLockId();
                        if (!lockId)
                            return SPELL_FAILED_BAD_TARGETS;
                    }
                    else if (Item* itm = m_targets.GetItemTarget())
                        lockId = itm->GetTemplate()->LockID;
 
                    SkillType skillId = SKILL_NONE;
                    int32 reqSkillValue = 0;
                    int32 skillValue = 0;
 
                    // check lock compatibility
                    SpellCastResult res = CanOpenLock(i, lockId, skillId, reqSkillValue, skillValue);
                    if (res != SPELL_CAST_OK)
                        return res;
 
                    // chance for fail at lockpicking attempt
                    // second check prevent fail at rechecks
                    // herbalism and mining cannot fail as of patch 3.1.0
                    if (skillId != SKILL_NONE && skillId != SKILL_HERBALISM && skillId != SKILL_MINING && (!m_selfContainer || ((*m_selfContainer) != this)))
                    {
                        // chance for failure in orange lockpick
                        if (skillId == SKILL_LOCKPICKING && reqSkillValue > irand(skillValue - 25, skillValue + 37))
                        {
                            return SPELL_FAILED_TRY_AGAIN;
                        }
                    }
                    break;
                }
            case SPELL_EFFECT_RESURRECT_PET:
                {
                    Unit* unitCaster = m_caster->ToUnit();
                    if (!unitCaster)
                    {
                        return SPELL_FAILED_BAD_TARGETS;
                    }
 
                    Creature* pet = unitCaster->GetGuardianPet();
                    if (pet)
                    {
                        if (pet->IsAlive())
                        {
                            return SPELL_FAILED_ALREADY_HAVE_SUMMON;
                        }
                    }
                    else if (Player* playerCaster = m_caster->ToPlayer())
                    {
                        PetStable& petStable = playerCaster->GetOrInitPetStable();
                        if (!petStable.CurrentPet && petStable.UnslottedPets.empty())
                        {
                            return SPELL_FAILED_NO_PET;
                        }
                    }
 
                    break;
                }
            // This is generic summon effect
            case SPELL_EFFECT_SUMMON:
                {
                    SummonPropertiesEntry const* SummonProperties = sSummonPropertiesStore.LookupEntry(m_spellInfo->Effects[i].MiscValueB);
                    if (!SummonProperties || m_spellInfo->HasAttribute(SPELL_ATTR1_DISMISS_PET_FIRST))
                        break;
                    switch (SummonProperties->Category)
                    {
                        case SUMMON_CATEGORY_PET:
                            if (m_caster->GetPetGUID())
                                return SPELL_FAILED_ALREADY_HAVE_SUMMON;
                            [[fallthrough]];
                        case SUMMON_CATEGORY_PUPPET:
                            if (m_caster->GetCharmGUID())
                                return SPELL_FAILED_ALREADY_HAVE_CHARM;
                            break;
                    }
                    break;
                }
            case SPELL_EFFECT_CREATE_TAMED_PET:
                {
                    if (m_targets.GetUnitTarget())
                    {
                        if (!m_targets.GetUnitTarget()->IsPlayer())
                            return SPELL_FAILED_BAD_TARGETS;
                        if (m_targets.GetUnitTarget()->GetPetGUID())
                            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 (!m_spellInfo->HasAttribute(SPELL_ATTR1_DISMISS_PET_FIRST))
                    {
                        if (m_caster->GetPetGUID())
                            return SPELL_FAILED_ALREADY_HAVE_SUMMON;
                        if (m_caster->GetCharmGUID())
                            return SPELL_FAILED_ALREADY_HAVE_CHARM;
                    }
 
                    if (m_caster->IsPlayer() && m_caster->IsClass(CLASS_WARLOCK, CLASS_CONTEXT_PET) && strict)
                        if (Pet* pet = m_caster->ToPlayer()->GetPet())
                            pet->CastSpell(pet, 32752, true, nullptr, nullptr, pet->GetGUID()); //starting cast, trigger pet stun (cast by pet so it doesn't attack player)
 
                    Player* playerCaster = unitCaster->ToPlayer();
                    if (playerCaster && playerCaster->GetPetStable())
                    {
                        std::pair<PetStable::PetInfo const*, PetSaveMode> info = Pet::GetLoadPetInfo(*playerCaster->GetPetStable(), m_spellInfo->Effects[i].MiscValue, 0, false);
                        if (info.first)
                        {
                            if (info.first->Type == HUNTER_PET)
                            {
                                if (!info.first->Health)
                                {
                                    playerCaster->SendTameFailure(PET_TAME_DEAD);
                                    return SPELL_FAILED_DONT_REPORT;
                                }
 
                                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(PET_TAME_CANT_CONTROL_EXOTIC);
                                    else
                                        playerCaster->SendTameFailure(PET_TAME_NOPET_AVAILABLE);
 
                                    return SPELL_FAILED_DONT_REPORT;
                                }
                            }
                        }
                        else if (!m_spellInfo->Effects[i].MiscValue) // when miscvalue is present it is allowed to create new pets
                        {
                            playerCaster->SendTameFailure(PET_TAME_NOPET_AVAILABLE);
                            return SPELL_FAILED_DONT_REPORT;
                        }
                    }
                    break;
                }
            case SPELL_EFFECT_SUMMON_PLAYER:
                {
                    if (!m_caster->IsPlayer())
                        return SPELL_FAILED_BAD_TARGETS;
                    if (!m_caster->GetTarget())
                        return SPELL_FAILED_BAD_TARGETS;
 
                    Player* target = ObjectAccessor::FindPlayer(m_caster->ToPlayer()->GetTarget());
                    if (!target || (!target->IsInSameRaidWith(m_caster->ToPlayer()) && m_spellInfo->Id != 48955)) // refer-a-friend spell
                        return SPELL_FAILED_BAD_TARGETS;
 
                    // Xinef: Implement summon pending error
                    if (target->GetSummonExpireTimer() > GameTime::GetGameTime().count())
                        return SPELL_FAILED_SUMMON_PENDING;
 
                    // check if our map is dungeon
                    MapEntry const* map = sMapStore.LookupEntry(m_caster->GetMapId());
                    if (map->IsDungeon())
                    {
                        uint32 mapId = m_caster->GetMap()->GetId();
                        Difficulty difficulty = m_caster->GetMap()->GetDifficulty();
                        /*if (map->IsRaid())
                            if (InstancePlayerBind* targetBind = target->GetBoundInstance(mapId, difficulty))
                                if (targetBind->perm && targetBind != m_caster->ToPlayer()->GetBoundInstance(mapId, difficulty))
                                    return SPELL_FAILED_TARGET_LOCKED_TO_RAID_INSTANCE;*/
 
                        InstanceTemplate const* instance = sObjectMgr->GetInstanceTemplate(mapId);
                        if (!instance)
                            return SPELL_FAILED_TARGET_NOT_IN_INSTANCE;
                        if (!target->Satisfy(sObjectMgr->GetAccessRequirement(mapId, difficulty), mapId))
                            return SPELL_FAILED_BAD_TARGETS;
                    }
                    break;
                }
            // RETURN HERE
            case SPELL_EFFECT_SUMMON_RAF_FRIEND:
                {
                    if (!m_caster->IsPlayer())
                        return SPELL_FAILED_BAD_TARGETS;
 
                    Player* playerCaster = m_caster->ToPlayer();
                    //
                    if (!(playerCaster->GetTarget()))
                        return SPELL_FAILED_BAD_TARGETS;
 
                    Player* target = ObjectAccessor::FindPlayer(m_caster->ToPlayer()->GetTarget());
 
                    if (!target ||
                            !(target->GetSession()->GetRecruiterId() == playerCaster->GetSession()->GetAccountId() || target->GetSession()->GetAccountId() == playerCaster->GetSession()->GetRecruiterId()))
                        return SPELL_FAILED_BAD_TARGETS;
 
                    // Xinef: Implement summon pending error
                    if (target->GetSummonExpireTimer() > GameTime::GetGameTime().count())
                        return SPELL_FAILED_SUMMON_PENDING;
 
                    break;
                }
            case SPELL_EFFECT_LEAP:
            case SPELL_EFFECT_TELEPORT_UNITS_FACE_CASTER:
                {
                    //Do not allow to cast it before BG starts.
                    if (m_caster->IsPlayer())
                        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;
 
                    bool found = false;
                    Unit::VisibleAuraMap const* visibleAuras = m_targets.GetUnitTarget()->GetVisibleAuras();
                    for(Unit::VisibleAuraMap::const_iterator itr = visibleAuras->begin(); itr != visibleAuras->end(); ++itr)
                    {
                        if (itr->second->GetBase()->IsPassive())
                            continue;
 
                        if (!itr->second->IsPositive())
                            continue;
 
                        found = true;
                        break;
                    }
 
                    if (!found)
                        return SPELL_FAILED_NOTHING_TO_STEAL;
 
                    break;
                }
            case SPELL_EFFECT_LEAP_BACK:
                {
                    if (m_caster->HasUnitState(UNIT_STATE_ROOT))
                    {
                        if (m_caster->IsPlayer())
                            return SPELL_FAILED_ROOTED;
                        else
                            return SPELL_FAILED_DONT_REPORT;
                    }
                    break;
                }
            // xinef: do not allow to use leaps while rooted
            case SPELL_EFFECT_JUMP:
            case SPELL_EFFECT_JUMP_DEST:
                {
                    if (m_caster->HasUnitState(UNIT_STATE_ROOT))
                        return SPELL_FAILED_ROOTED;
                    break;
                }
            case SPELL_EFFECT_TALENT_SPEC_SELECT:
                if (!sScriptMgr->CanSelectSpecTalent(this))
                    return SPELL_FAILED_DONT_REPORT;
                // can't change during already started arena/battleground
                if (m_caster->IsPlayer())
                    if (Battleground const* bg = m_caster->ToPlayer()->GetBattleground())
                        if (bg->GetStatus() == STATUS_IN_PROGRESS)
                            return SPELL_FAILED_NOT_IN_BATTLEGROUND;
                break;
            default:
                break;
        }
 
        if (m_spellInfo->Effects[i].IsAura())
            approximateAuraEffectMask |= 1 << i;
        else if (m_spellInfo->Effects[i].IsEffect())
            nonAuraEffectMask |= 1 << i;
    }
 
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        switch (m_spellInfo->Effects[i].ApplyAuraName)
        {
            case SPELL_AURA_DUMMY:
                break;
            case SPELL_AURA_MOD_POSSESS_PET:
                {
                    if (!m_caster->IsPlayer())
                        return SPELL_FAILED_NO_PET;
 
                    Pet* pet = m_caster->ToPlayer()->GetPet();
                    if (!pet)
                        return SPELL_FAILED_NO_PET;
 
                    if (pet->GetCharmerGUID())
                        return SPELL_FAILED_CHARMED;
                    break;
                }
            case SPELL_AURA_MOD_POSSESS:
            case SPELL_AURA_MOD_CHARM:
            case SPELL_AURA_AOE_CHARM:
                {
                    if (m_caster->GetCharmerGUID())
                        return SPELL_FAILED_CHARMED;
 
                    // Xinef: allow SPELL_AURA_MOD_POSSESS to posses target if caster has some pet
                    if (m_spellInfo->Effects[i].ApplyAuraName == SPELL_AURA_MOD_CHARM && !m_spellInfo->HasAttribute(SPELL_ATTR1_DISMISS_PET_FIRST))
                    {
                        if (m_caster->GetPetGUID())
                            return SPELL_FAILED_ALREADY_HAVE_SUMMON;
 
                        if (m_caster->GetCharmGUID())
                            return SPELL_FAILED_ALREADY_HAVE_CHARM;
                    }
                    else if (m_spellInfo->Effects[i].ApplyAuraName == SPELL_AURA_MOD_POSSESS)
                    {
                        if (m_caster->GetCharmGUID())
                            return SPELL_FAILED_ALREADY_HAVE_CHARM;
                    }
 
                    if (Unit* target = m_targets.GetUnitTarget())
                    {
                        if (target->IsCreature() && target->ToCreature()->IsVehicle())
                            return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
 
                        // Allow SPELL_AURA_MOD_POSSESS to work on mounted players,
                        // but keep the old restriction for everything else.
                        if (target->IsMounted())
                        {
                            if (!(target->IsPlayer() && m_spellInfo->Effects[i].ApplyAuraName == SPELL_AURA_MOD_POSSESS))
                                return SPELL_FAILED_CANT_BE_CHARMED;
                        }
 
                        if (target->GetCharmerGUID())
                            return SPELL_FAILED_CHARMED;
 
                        if (target->GetOwnerGUID() && target->GetOwnerGUID().IsPlayer())
                            return SPELL_FAILED_TARGET_IS_PLAYER_CONTROLLED;
 
                        if (target->IsPet() && (!target->GetOwner() || target->GetOwner()->ToPlayer()))
                            return SPELL_FAILED_CANT_BE_CHARMED;
 
                        int32 damage = CalculateSpellDamage(i, target);
                        if (damage && int32(target->GetLevel()) > damage)
                            return SPELL_FAILED_HIGHLEVEL;
                    }
 
                    break;
                }
            case SPELL_AURA_MOUNTED:
                {
                    // Disallow casting flying mounts in water
                    if (m_caster->IsInWater() && m_spellInfo->HasAura(SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED))
                        return SPELL_FAILED_ONLY_ABOVEWATER;
 
                    // Ignore map check if spell have AreaId. AreaId already checked and this prevent special mount spells
                    bool allowMount = !m_caster->GetMap()->IsDungeon() || m_caster->GetMap()->IsBattlegroundOrArena();
                    InstanceTemplate const* it = sObjectMgr->GetInstanceTemplate(m_caster->GetMapId());
                    if (it)
                        allowMount = it->AllowMount;
                    if (m_caster->IsPlayer() && !allowMount && !m_spellInfo->AreaGroupId)
                        return SPELL_FAILED_NO_MOUNTS_ALLOWED;
 
                    if (m_caster->IsInDisallowedMountForm())
                        return SPELL_FAILED_NOT_SHAPESHIFT;
 
                    // xinef: dont allow to cast mounts in specific transforms
                    if (m_caster->getTransForm())
                        if (SpellInfo const* transformSpellInfo = sSpellMgr->GetSpellInfo(m_caster->getTransForm()))
                            if (transformSpellInfo->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES) &&
                                    !transformSpellInfo->HasAttribute(SpellAttr0(SPELL_ATTR0_ALLOW_WHILE_MOUNTED | SPELL_ATTR0_AURA_IS_DEBUFF)))
                                return SPELL_FAILED_NOT_SHAPESHIFT;
 
                    break;
                }
            case SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS:
                {
                    if (!m_targets.GetUnitTarget())
                        return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
 
                    // can be casted 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:
                {
                    // Xinef: added water check
                    if (m_caster->IsInWater())
                        return SPELL_FAILED_ONLY_ABOVEWATER;
 
                    // 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->IsPlayer() && m_originalCaster->IsAlive())
                    {
                        Battlefield* Bf = sBattlefieldMgr->GetBattlefieldToZoneId(m_originalCaster->GetZoneId());
                        if (AreaTableEntry const* pArea = sAreaTableStore.LookupEntry(m_originalCaster->GetAreaId()))
                            if ((pArea->flags & AREA_FLAG_NO_FLY_ZONE) || (Bf && !Bf->CanFlyIn()))
                                return SPELL_FAILED_NOT_HERE;
                    }
                    break;
                }
            case SPELL_AURA_PERIODIC_MANA_LEECH:
                {
                    if (m_spellInfo->Effects[i].IsTargetingArea())
                        break;
 
                    if (!m_caster->IsPlayer() || m_CastItem)
                        break;
 
                    if (!m_targets.GetUnitTarget())
                        return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
 
                    if (!m_targets.GetUnitTarget()->HasActivePowerType(POWER_MANA))
                        return SPELL_FAILED_BAD_TARGETS;
 
                    break;
                }
            case SPELL_AURA_HOVER:
                {
                    if ((m_spellInfo->AuraInterruptFlags & AURA_INTERRUPT_FLAG_MOUNT) != 0 && m_targets.GetUnitTarget() && m_targets.GetUnitTarget()->IsMounted())
                    {
                        return SPELL_FAILED_NOT_ON_MOUNTED;
                    }
                    break;
                }
            case SPELL_AURA_MOD_SHAPESHIFT:
                {
                    if (m_caster && m_caster->HasAura(23397)) // Nefarian Class Call (Warrior): Berserk -- Nefertum: I don't really like this but I didn't find another way.
                    {
                        return SPELL_FAILED_NOT_SHAPESHIFT;
                    }
                    break;
                }
            default:
                break;
        }
 
        // check if target already has the same type, but more powerful aura
        if (!nonAuraEffectMask && (approximateAuraEffectMask & (1 << i)) && !m_spellInfo->IsTargetingArea())
            if (Unit* target = m_targets.GetUnitTarget())
                if (!target->IsHighestExclusiveAuraEffect(m_spellInfo, AuraType(m_spellInfo->Effects[i].ApplyAuraName),
                    m_spellInfo->Effects[i].CalcValue(m_caster, &m_spellValue->EffectBasePoints[i]), 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_caster->IsPlayer())
            return SPELL_FAILED_NOT_TRADING;
 
        TradeData* my_trade = m_caster->ToPlayer()->GetTradeData();
 
        if (!my_trade)
            return SPELL_FAILED_NOT_TRADING;
 
        TradeSlots slot = TradeSlots(m_targets.GetItemTargetGUID().GetRawValue());
        if (slot != TRADE_SLOT_NONTRADED)
            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 on target for spells that require combo points
    if (m_needComboPoints)
    {
        if (m_spellInfo->NeedsExplicitUnitTarget())
        {
            if (!m_caster->GetComboPoints(m_targets.GetUnitTarget()))
            {
                return SPELL_FAILED_NO_COMBO_POINTS;
            }
        }
        else
        {
            if (!m_caster->GetComboPoints())
            {
                return SPELL_FAILED_NO_COMBO_POINTS;
            }
        }
    }
 
    // xinef: check relic cooldown
    if (m_CastItem && m_CastItem->GetTemplate()->InventoryType == INVTYPE_RELIC && m_triggeredByAuraSpell)
        if (m_caster->HasSpellCooldown(SPELL_RELIC_COOLDOWN) && !m_caster->HasSpellItemCooldown(SPELL_RELIC_COOLDOWN, m_CastItem->GetEntry()))
            return SPELL_FAILED_NOT_READY;
 
    // all ok
    return SPELL_CAST_OK;
}

Referenced by _cast(), Unit::_UpdateAutoRepeatSpell(), Unit::AttackerStateUpdate(), Player::CastItemUseSpell(), CheckPetCast(), WorldSession::HandleAcceptTradeOpcode(), prepare(), and go_wind_stone::go_wind_stoneAI::SummonNPC().

◆ CheckCasterAuras()

SpellCastResult Spell::CheckCasterAuras ( bool preventionOnly ) const

{
    // spells totally immuned to caster auras (wsg flag drop, give marks etc)
    if (m_spellInfo->HasAttribute(SPELL_ATTR6_NOT_AN_ATTACK))
        return SPELL_CAST_OK;
 
    uint8 school_immune = 0;
    uint64 mechanic_immune = 0;
    uint32 dispel_immune = 0;
 
    // Check if the spell grants school or mechanic immunity.
    // We use bitmasks so the loop is done only once and not on every aura check below.
    if (m_spellInfo->HasAttribute(SPELL_ATTR1_IMMUNITY_PURGES_EFFECT))
    {
        for (int i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (m_spellInfo->Effects[i].ApplyAuraName == SPELL_AURA_SCHOOL_IMMUNITY)
                school_immune |= uint32(m_spellInfo->Effects[i].MiscValue);
            else if (m_spellInfo->Effects[i].ApplyAuraName == SPELL_AURA_MECHANIC_IMMUNITY)
                mechanic_immune |= 1ULL << uint32(m_spellInfo->Effects[i].MiscValue);
            else if (m_spellInfo->Effects[i].ApplyAuraName == SPELL_AURA_DISPEL_IMMUNITY)
                dispel_immune |= SpellInfo::GetDispelMask(DispelType(m_spellInfo->Effects[i].MiscValue));
        }
        // immune movement impairment and loss of control
        //         PVP trinket                   EMFH                   TOC PVP trinket               Bullheaded                  Bestial Wrath             // Beath Within         // Medalion of Immunity
        if (m_spellInfo->Id == 42292 || m_spellInfo->Id == 59752 || m_spellInfo->Id == 65547 || m_spellInfo->Id == 53490 || m_spellInfo->Id == 19574 || m_spellInfo->Id == 34471 || m_spellInfo->Id == 46227)
            mechanic_immune = IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK;
    }
 
    bool usableInStun = m_spellInfo->HasAttribute(SPELL_ATTR5_ALLOW_WHILE_STUNNED);
 
    // Glyph of Pain Suppression
    // there is no other way to handle it
    if (m_spellInfo->Id == 33206 && !m_caster->HasAura(63248))
        usableInStun = false;
 
    // Check whether the cast should be prevented by any state you might have.
    SpellCastResult prevented_reason = SPELL_CAST_OK;
    // Have to check if there is a stun aura. Otherwise will have problems with ghost aura apply while logging out
    uint32 unitflag = m_caster->GetUnitFlags();     // Get unit state
 
    // Xinef: if spell is triggered check preventionType only
    if (!preventionOnly)
    {
        if (unitflag & UNIT_FLAG_STUNNED)
        {
            // spell is usable while stunned, check if caster has only mechanic stun auras, another stun types must prevent cast spell
            if (usableInStun)
            {
                bool foundNotStun = false;
                uint64 mask = (1ULL << MECHANIC_STUN) | (1ULL << MECHANIC_FREEZE) | (1ULL << MECHANIC_HORROR);
                // Barkskin should skip sleep effects, sap and fears
                if (m_spellInfo->Id == 22812)
                    mask |= 1ULL << MECHANIC_SAPPED | 1ULL << MECHANIC_HORROR | 1ULL << MECHANIC_SLEEP;
                // Hand of Freedom, can be used while sapped and while under fear-mechanic stuns (e.g. Intimidating Shout primary target)
                if (m_spellInfo->Id == 1044)
                    mask |= (1ULL << MECHANIC_SAPPED) | (1ULL << MECHANIC_FEAR);
                Unit::AuraEffectList const& stunAuras = m_caster->GetAuraEffectsByType(SPELL_AURA_MOD_STUN);
                for (Unit::AuraEffectList::const_iterator i = stunAuras.begin(); i != stunAuras.end(); ++i)
                {
                    if ((*i)->GetSpellInfo()->GetAllEffectsMechanicMask() && !((*i)->GetSpellInfo()->GetAllEffectsMechanicMask() & mask))
                    {
                        foundNotStun = true;
                        break;
                    }
                }
                if (foundNotStun)
                    prevented_reason = SPELL_FAILED_STUNNED;
            }
            else
                prevented_reason = SPELL_FAILED_STUNNED;
        }
        else if (unitflag & UNIT_FLAG_CONFUSED && !m_spellInfo->HasAttribute(SPELL_ATTR5_ALLOW_WHILE_CONFUSED))
            prevented_reason = SPELL_FAILED_CONFUSED;
        else if (unitflag & UNIT_FLAG_FLEEING && !m_spellInfo->HasAttribute(SPELL_ATTR5_ALLOW_WHILE_FLEEING))
            prevented_reason = SPELL_FAILED_FLEEING;
    }
 
    // Xinef: if there is no prevented_reason, check prevention types
    if (prevented_reason == SPELL_CAST_OK)
    {
        if (unitflag & UNIT_FLAG_SILENCED && m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE)
            prevented_reason = SPELL_FAILED_SILENCED;
        else if (unitflag & UNIT_FLAG_PACIFIED && m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY)
            prevented_reason = SPELL_FAILED_PACIFIED;
    }
 
    // Attr must make flag drop spell totally immune from all effects
    if (prevented_reason != SPELL_CAST_OK)
    {
        if (school_immune || mechanic_immune || dispel_immune)
        {
            //Checking auras is needed now, because you are prevented by some state but the spell grants immunity.
            Unit::AuraApplicationMap const& auras = m_caster->GetAppliedAuras();
            for (Unit::AuraApplicationMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
            {
                Aura const* aura = itr->second->GetBase();
                SpellInfo const* auraInfo = aura->GetSpellInfo();
                if (auraInfo->GetAllEffectsMechanicMask() & mechanic_immune)
                    continue;
                if (auraInfo->GetSchoolMask() & school_immune && !auraInfo->HasAttribute(SPELL_ATTR1_IMMUNITY_TO_HOSTILE_AND_FRIENDLY_EFFECTS))
                    continue;
                if (auraInfo->GetDispelMask() & dispel_immune)
                    continue;
 
                //Make a second check for spell failed so the right SPELL_FAILED message is returned.
                //That is needed when your casting is prevented by multiple states and you are only immune to some of them.
                for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
                {
                    if (AuraEffect* part = aura->GetEffect(i))
                    {
                        switch (part->GetAuraType())
                        {
                            case SPELL_AURA_MOD_STUN:
                                {
                                    uint64 mask = 1ULL << MECHANIC_STUN;
                                    // Barkskin should skip sleep effects, sap and fears
                                    if (m_spellInfo->Id == 22812)
                                        mask |= 1ULL << MECHANIC_SAPPED | 1ULL << MECHANIC_HORROR | 1ULL << MECHANIC_SLEEP;
                                    // Hand of Freedom, can be used while sapped and while under fear-mechanic stuns (e.g. Intimidating Shout primary target)
                                    if (m_spellInfo->Id == 1044)
                                        mask |= (1ULL << MECHANIC_SAPPED) | (1ULL << MECHANIC_FEAR);
 
                                    if (!usableInStun || !(auraInfo->GetAllEffectsMechanicMask() & mask))
                                        return SPELL_FAILED_STUNNED;
                                    break;
                                }
                            case SPELL_AURA_MOD_CONFUSE:
                                if (!m_spellInfo->HasAttribute(SPELL_ATTR5_ALLOW_WHILE_CONFUSED))
                                    return SPELL_FAILED_CONFUSED;
                                break;
                            case SPELL_AURA_MOD_FEAR:
                                if (!m_spellInfo->HasAttribute(SPELL_ATTR5_ALLOW_WHILE_FLEEING))
                                    return SPELL_FAILED_FLEEING;
                                break;
                            case SPELL_AURA_MOD_SILENCE:
                            case SPELL_AURA_MOD_PACIFY:
                            case SPELL_AURA_MOD_PACIFY_SILENCE:
                                if (m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY)
                                    return SPELL_FAILED_PACIFIED;
                                else if (m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE)
                                    return SPELL_FAILED_SILENCED;
                                break;
                            default:
                                break;
                        }
                    }
                }
            }
        }
        // You are prevented from casting and the spell casted does not grant immunity. Return a failed error.
        else
            return prevented_reason;
    }
    return SPELL_CAST_OK;
}

References SpellInfo::Effects, SpellInfo::GetAllEffectsMechanicMask(), Unit::GetAppliedAuras(), Unit::GetAuraEffectsByType(), SpellInfo::GetDispelMask(), Aura::GetEffect(), SpellInfo::GetSchoolMask(), Aura::GetSpellInfo(), Unit::GetUnitFlags(), SpellInfo::HasAttribute(), Unit::HasAura(), SpellInfo::Id, IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK, m_caster, m_spellInfo, MAX_SPELL_EFFECTS, MECHANIC_FEAR, MECHANIC_FREEZE, MECHANIC_HORROR, MECHANIC_SAPPED, MECHANIC_SLEEP, MECHANIC_STUN, SpellInfo::PreventionType, SPELL_ATTR1_IMMUNITY_PURGES_EFFECT, SPELL_ATTR1_IMMUNITY_TO_HOSTILE_AND_FRIENDLY_EFFECTS, SPELL_ATTR5_ALLOW_WHILE_CONFUSED, SPELL_ATTR5_ALLOW_WHILE_FLEEING, SPELL_ATTR5_ALLOW_WHILE_STUNNED, SPELL_ATTR6_NOT_AN_ATTACK, SPELL_AURA_DISPEL_IMMUNITY, SPELL_AURA_MECHANIC_IMMUNITY, SPELL_AURA_MOD_CONFUSE, SPELL_AURA_MOD_FEAR, SPELL_AURA_MOD_PACIFY, SPELL_AURA_MOD_PACIFY_SILENCE, SPELL_AURA_MOD_SILENCE, SPELL_AURA_MOD_STUN, SPELL_AURA_SCHOOL_IMMUNITY, SPELL_CAST_OK, SPELL_FAILED_CONFUSED, SPELL_FAILED_FLEEING, SPELL_FAILED_PACIFIED, SPELL_FAILED_SILENCED, SPELL_FAILED_STUNNED, SPELL_PREVENTION_TYPE_PACIFY, SPELL_PREVENTION_TYPE_SILENCE, UNIT_FLAG_CONFUSED, UNIT_FLAG_FLEEING, UNIT_FLAG_PACIFIED, UNIT_FLAG_SILENCED, and UNIT_FLAG_STUNNED.

Referenced by CheckCast().

◆ CheckDst()

void Spell::CheckDst ( )

inline

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

SpellCastTargets::SetDst

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

Definition Spell.cpp:405

References SpellCastTargets::HasDst(), m_caster, m_targets, and SpellCastTargets::SetDst().

Referenced by SelectEffectImplicitTargets(), and SelectImplicitDestDestTargets().

◆ CheckEffectExecuteData()

void Spell::CheckEffectExecuteData ( )

protected

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        ASSERT(!m_effectExecuteData[i]);
}

References ASSERT, m_effectExecuteData, and MAX_SPELL_EFFECTS.

Referenced by PrepareTargetProcessing(), and ~Spell().

◆ CheckEffectTarget()

bool Spell::CheckEffectTarget	(	Unit const *	target,
		uint32	eff
	)		const

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

{
    switch (m_spellInfo->Effects[eff].ApplyAuraName)
    {
        case SPELL_AURA_MOD_POSSESS:
        case SPELL_AURA_MOD_CHARM:
        case SPELL_AURA_MOD_POSSESS_PET:
        case SPELL_AURA_AOE_CHARM:
            if (target->IsCreature() && target->IsVehicle())
                return false;
            if (target->IsMounted() && m_spellInfo->Effects[eff].ApplyAuraName != SPELL_AURA_MOD_POSSESS)
                return false;
            if (target->GetCharmerGUID())
                return false;
            if (int32 damage = CalculateSpellDamage(eff, target))
                if ((int32)target->GetLevel() > damage)
                    return false;
            break;
        default:
            break;
    }
 
    // xinef: skip los checking if spell has appropriate attribute, or target requires specific entry
    // this is only for target addition and target has to have unselectable flag, this is valid for FLAG_EXTRA_TRIGGER and quest triggers however there are some without this flag, used not_selectable
    if (m_spellInfo->HasAttribute(SPELL_ATTR2_IGNORE_LINE_OF_SIGHT) || (target->IsCreature() && target->HasUnitFlag(UNIT_FLAG_NOT_SELECTABLE) && (m_spellInfo->Effects[eff].TargetA.GetCheckType() == TARGET_CHECK_ENTRY || m_spellInfo->Effects[eff].TargetB.GetCheckType() == TARGET_CHECK_ENTRY)))
        return true;
 
     // if spell is triggered, need to check for LOS disable on the aura triggering it and inherit that behaviour
    if (IsTriggered() && m_triggeredByAuraSpell && (m_triggeredByAuraSpell.spellInfo->HasAttribute(SPELL_ATTR2_IGNORE_LINE_OF_SIGHT) ||
        sDisableMgr->IsDisabledFor(DISABLE_TYPE_SPELL, m_triggeredByAuraSpell.spellInfo->Id, nullptr, SPELL_DISABLE_LOS)))
    {
        return true;
    }
 
    //Check targets for LOS visibility (except spells without range limitations)
    switch (m_spellInfo->Effects[eff].Effect)
    {
        case SPELL_EFFECT_RESURRECT_NEW:
            // player far away, maybe his corpse near?
            if (target != m_caster && !target->IsWithinLOSInMap(m_caster))
            {
                if (!m_targets.GetCorpseTargetGUID())
                    return false;
 
                Corpse* corpse = ObjectAccessor::GetCorpse(*m_caster, m_targets.GetCorpseTargetGUID());
                if (!corpse)
                    return false;
 
                if (target->GetGUID() != corpse->GetOwnerGUID())
                    return false;
 
                if (!corpse->IsWithinLOSInMap(m_caster) && !(m_spellFlags & SPELL_FLAG_REDIRECTED))
                    return false;
            }
            break;
        case SPELL_EFFECT_SKIN_PLAYER_CORPSE:
            {
                if (!m_targets.GetCorpseTargetGUID())
                {
                    if (target->IsWithinLOSInMap(m_caster, VMAP::ModelIgnoreFlags::M2) && target->HasUnitFlag(UNIT_FLAG_SKINNABLE))
                        return true;
 
                    return false;
                }
 
                Corpse* corpse = ObjectAccessor::GetCorpse(*m_caster, m_targets.GetCorpseTargetGUID());
                if (!corpse)
                    return false;
 
                if (target->GetGUID() != corpse->GetOwnerGUID())
                    return false;
 
                if (!corpse->HasFlag(CORPSE_FIELD_FLAGS, CORPSE_FLAG_LOOTABLE))
                    return false;
 
                if (!corpse->IsWithinLOSInMap(m_caster, VMAP::ModelIgnoreFlags::M2))
                    return false;
            }
            break;
        case SPELL_EFFECT_SUMMON_RAF_FRIEND:
            if (!m_caster->IsPlayer() || !target->IsPlayer())
                return false;
            if (m_caster->ToPlayer()->GetSession()->IsARecruiter() && target->ToPlayer()->GetSession()->GetRecruiterId() != m_caster->ToPlayer()->GetSession()->GetAccountId())
                return false;
            if (m_caster->ToPlayer()->GetSession()->GetRecruiterId() != target->ToPlayer()->GetSession()->GetAccountId() && target->ToPlayer()->GetSession()->IsARecruiter())
                return false;
            if (target->ToPlayer()->GetLevel() >= sWorld->getIntConfig(CONFIG_MAX_RECRUIT_A_FRIEND_BONUS_PLAYER_LEVEL))
                return false;
            break;
        default: // normal case
        {
            uint32 losChecks = LINEOFSIGHT_ALL_CHECKS;
            GameObject* gobCaster = nullptr;
            if (m_originalCasterGUID.IsGameObject())
            {
                gobCaster = m_caster->GetMap()->GetGameObject(m_originalCasterGUID);
            }
            else if (m_caster->GetEntry() == WORLD_TRIGGER)
            {
                if (TempSummon* tempSummon = m_caster->ToTempSummon())
                {
                    gobCaster = tempSummon->GetSummonerGameObject();
                }
            }
 
            if (gobCaster)
            {
                if (gobCaster->GetGOInfo()->IsIgnoringLOSChecks())
                {
                    return true;
                }
 
                // If spell casted by gameobject then ignore M2 models
                losChecks &= ~LINEOFSIGHT_CHECK_GOBJECT_M2;
            }
 
            if (target != m_caster)
            {
                if (m_targets.HasDst())
                {
                    float x = m_targets.GetDstPos()->GetPositionX();
                    float y = m_targets.GetDstPos()->GetPositionY();
                    float z = m_targets.GetDstPos()->GetPositionZ();
 
                    if (!target->IsWithinLOS(x, y, z, VMAP::ModelIgnoreFlags::M2, LineOfSightChecks(losChecks)))
                    {
                        return false;
                    }
                }
                else if (!m_caster->IsWithinLOSInMap(target, VMAP::ModelIgnoreFlags::M2, LineOfSightChecks(losChecks)))
                {
                    return false;
                }
            }
            break;
        }
    }
 
    return true;
}

References CalculateSpellDamage(), CONFIG_MAX_RECRUIT_A_FRIEND_BONUS_PLAYER_LEVEL, CORPSE_FIELD_FLAGS, CORPSE_FLAG_LOOTABLE, damage, DISABLE_TYPE_SPELL, SpellInfo::Effects, WorldSession::GetAccountId(), Unit::GetCharmerGUID(), ObjectAccessor::GetCorpse(), SpellCastTargets::GetCorpseTargetGUID(), SpellCastTargets::GetDstPos(), Object::GetEntry(), Map::GetGameObject(), GameObject::GetGOInfo(), Object::GetGUID(), Unit::GetLevel(), WorldObject::GetMap(), Corpse::GetOwnerGUID(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), WorldSession::GetRecruiterId(), Player::GetSession(), SpellInfo::HasAttribute(), SpellCastTargets::HasDst(), Object::HasFlag(), Unit::HasUnitFlag(), SpellInfo::Id, WorldSession::IsARecruiter(), Object::IsCreature(), ObjectGuid::IsGameObject(), GameObjectTemplate::IsIgnoringLOSChecks(), Unit::IsMounted(), Object::IsPlayer(), IsTriggered(), Unit::IsVehicle(), WorldObject::IsWithinLOS(), WorldObject::IsWithinLOSInMap(), LINEOFSIGHT_ALL_CHECKS, VMAP::M2, m_caster, m_originalCasterGUID, m_spellFlags, m_spellInfo, m_targets, m_triggeredByAuraSpell, sDisableMgr, SPELL_ATTR2_IGNORE_LINE_OF_SIGHT, SPELL_AURA_AOE_CHARM, SPELL_AURA_MOD_CHARM, SPELL_AURA_MOD_POSSESS, SPELL_AURA_MOD_POSSESS_PET, SPELL_DISABLE_LOS, SPELL_EFFECT_RESURRECT_NEW, SPELL_EFFECT_SKIN_PLAYER_CORPSE, SPELL_EFFECT_SUMMON_RAF_FRIEND, SPELL_FLAG_REDIRECTED, TriggeredByAuraSpellData::spellInfo, sWorld, TARGET_CHECK_ENTRY, Object::ToPlayer(), Unit::ToTempSummon(), UNIT_FLAG_NOT_SELECTABLE, UNIT_FLAG_SKINNABLE, and WORLD_TRIGGER.

Referenced by AddUnitTarget().

◆ CheckItems()

SpellCastResult Spell::CheckItems	(	uint32 *	param1 = `nullptr`,
		uint32 *	param2 = `nullptr`
	)

Todo:: Needs review

Todo:: : Not sure whether the fallthrough was a mistake (forgetting a break) or intended. This should be double-checked.

{
    Player* player = m_caster->ToPlayer();
    if (!player)
    {
        // Non-player case: Check if creature is disarmed
        if (!m_caster->CanUseAttackType(m_attackType) && (m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MELEE || m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_RANGED))
        {
            return SPELL_FAILED_EQUIPPED_ITEM_CLASS;
        }
 
        return SPELL_CAST_OK;
    }
 
    if (!m_CastItem)
    {
        if (m_castItemGUID)
            return SPELL_FAILED_ITEM_NOT_READY;
    }
    else
    {
        uint32 itemid = m_CastItem->GetEntry();
        if (!player->HasItemCount(itemid))
            return SPELL_FAILED_ITEM_NOT_READY;
 
        ItemTemplate const* proto = m_CastItem->GetTemplate();
        if (!proto)
            return SPELL_FAILED_ITEM_NOT_READY;
 
        for (int i = 0; i < MAX_ITEM_SPELLS; ++i)
            if (proto->Spells[i].SpellCharges)
                if (m_CastItem->GetSpellCharges(i) == 0)
                    return SPELL_FAILED_NO_CHARGES_REMAIN;
 
        // consumable cast item checks
        if (proto->Class == ITEM_CLASS_CONSUMABLE && m_targets.GetUnitTarget())
        {
            // such items should only fail if there is no suitable effect at all - see Rejuvenation Potions for example
            SpellCastResult failReason = SPELL_CAST_OK;
            for (uint8 i = 0; i < MAX_SPELL_EFFECTS; i++)
            {
                // skip check, pet not required like checks, and for TARGET_UNIT_PET m_targets.GetUnitTarget() is not the real target but the caster
                if (m_spellInfo->Effects[i].TargetA.GetTarget() == TARGET_UNIT_PET)
                    continue;
 
                if (m_spellInfo->Effects[i].Effect == SPELL_EFFECT_HEAL)
                {
                    if (m_targets.GetUnitTarget()->IsFullHealth())
                    {
                        failReason = SPELL_FAILED_ALREADY_AT_FULL_HEALTH;
                        continue;
                    }
                    else
                    {
                        failReason = SPELL_CAST_OK;
                        break;
                    }
                }
 
                // Mana Potion, Rage Potion, Thistle Tea(Rogue), ...
                if (m_spellInfo->Effects[i].Effect == SPELL_EFFECT_ENERGIZE)
                {
                    if (m_spellInfo->Effects[i].MiscValue < 0 || m_spellInfo->Effects[i].MiscValue >= int8(MAX_POWERS))
                    {
                        failReason = SPELL_FAILED_ALREADY_AT_FULL_POWER;
                        continue;
                    }
 
                    Powers power = Powers(m_spellInfo->Effects[i].MiscValue);
                    if (m_targets.GetUnitTarget()->GetPower(power) == m_targets.GetUnitTarget()->GetMaxPower(power))
                    {
                        failReason = SPELL_FAILED_ALREADY_AT_FULL_POWER;
                        continue;
                    }
                    else
                    {
                        failReason = SPELL_CAST_OK;
                        break;
                    }
                }
            }
            if (failReason != SPELL_CAST_OK)
                return failReason;
        }
    }
 
    // check target item
    if (m_targets.GetItemTargetGUID())
    {
        if (!m_caster->IsPlayer())
            return SPELL_FAILED_BAD_TARGETS;
 
        if (!m_targets.GetItemTarget())
            return SPELL_FAILED_ITEM_GONE;
 
        if (!m_targets.GetItemTarget()->IsFitToSpellRequirements(m_spellInfo))
            return SPELL_FAILED_EQUIPPED_ITEM_CLASS;
    }
    // if not item target then required item must be equipped
    else
    {
        // Xinef: this is not true in my opinion, in eg bladestorm will not be canceled after disarm
        //if (!HasTriggeredCastFlag(TRIGGERED_IGNORE_EQUIPPED_ITEM_REQUIREMENT))
        if (m_caster->IsPlayer() && !m_caster->ToPlayer()->HasItemFitToSpellRequirements(m_spellInfo))
            return SPELL_FAILED_EQUIPPED_ITEM_CLASS;
    }
 
    // do not take reagents for these item casts
    if (!(m_CastItem && m_CastItem->GetTemplate()->HasFlag(ITEM_FLAG_NO_REAGENT_COST)))
    {
        bool checkReagents = !HasTriggeredCastFlag(TRIGGERED_IGNORE_POWER_AND_REAGENT_COST) && !player->CanNoReagentCast(m_spellInfo);
        // Not own traded item (in trader trade slot) requires reagents even if triggered spell
        if (!checkReagents)
            if (Item* targetItem = m_targets.GetItemTarget())
                if (targetItem->GetOwnerGUID() != m_caster->GetGUID())
                    checkReagents = true;
 
        // check reagents (ignore triggered spells with reagents processed by original spell) and special reagent ignore case.
        if (checkReagents)
        {
            for (uint32 i = 0; i < MAX_SPELL_REAGENTS; i++)
            {
                if (m_spellInfo->Reagent[i] <= 0)
                    continue;
 
                uint32 itemid    = m_spellInfo->Reagent[i];
                uint32 itemcount = m_spellInfo->ReagentCount[i];
 
                // if CastItem is also spell reagent
                if (m_CastItem && m_CastItem->GetEntry() == itemid)
                {
                    ItemTemplate const* proto = m_CastItem->GetTemplate();
                    if (!proto)
                        return SPELL_FAILED_ITEM_NOT_READY;
                    for (int s = 0; s < MAX_ITEM_PROTO_SPELLS; ++s)
                    {
                        // CastItem will be used up and does not count as reagent
                        int32 charges = m_CastItem->GetSpellCharges(s);
                        if (proto->Spells[s].SpellCharges < 0 && std::abs(charges) < 2)
                        {
                            ++itemcount;
                            break;
                        }
                    }
                }
                if (!player->HasItemCount(itemid, itemcount))
                    return SPELL_FAILED_REAGENTS;
            }
        }
 
        // check totem-item requirements (items presence in inventory)
        uint32 totems = 2;
        for (int i = 0; i < 2; ++i)
        {
            if (m_spellInfo->Totem[i] != 0)
            {
                if (player->HasItemCount(m_spellInfo->Totem[i]))
                {
                    totems -= 1;
                    continue;
                }
            }
            else
                totems -= 1;
        }
        if (totems != 0)
            return SPELL_FAILED_TOTEMS;                         //0x7C
 
        // Check items for TotemCategory  (items presence in inventory)
        uint32 TotemCategory = 2;
        for (int i = 0; i < 2; ++i)
        {
            if (m_spellInfo->TotemCategory[i] != 0)
            {
                if (player->HasItemTotemCategory(m_spellInfo->TotemCategory[i]))
                {
                    TotemCategory -= 1;
                    continue;
                }
            }
            else
                TotemCategory -= 1;
        }
        if (TotemCategory != 0)
            return SPELL_FAILED_TOTEM_CATEGORY;                 //0x7B
    }
 
    // special checks for spell effects
    for (int i = 0; i < MAX_SPELL_EFFECTS; i++)
    {
        switch (m_spellInfo->Effects[i].Effect)
        {
            case SPELL_EFFECT_CREATE_ITEM:
            case SPELL_EFFECT_CREATE_ITEM_2:
            {
                // m_targets.GetUnitTarget() means explicit cast, otherwise we dont check for possible equip error
                Unit* target = m_targets.GetUnitTarget() ? m_targets.GetUnitTarget() : player;
                if (target->IsPlayer() && !IsTriggered())
                {
                    // SPELL_EFFECT_CREATE_ITEM_2 differs from SPELL_EFFECT_CREATE_ITEM in that it picks the random item to create from a pool of potential items,
                    // so we need to make sure there is at least one free space in the player's inventory
                    if (m_spellInfo->Effects[i].Effect == SPELL_EFFECT_CREATE_ITEM_2)
                        if (target->ToPlayer()->GetFreeInventorySpace() == 0)
                        {
                            player->SendEquipError(EQUIP_ERR_INVENTORY_FULL, nullptr, nullptr, m_spellInfo->Effects[i].ItemType);
                            return SPELL_FAILED_DONT_REPORT;
                        }
 
                    if (m_spellInfo->Effects[i].ItemType)
                    {
                        ItemTemplate const* itemTemplate = sObjectMgr->GetItemTemplate(m_spellInfo->Effects[i].ItemType);
                        if (!itemTemplate)
                            return SPELL_FAILED_ITEM_NOT_FOUND;
 
                        uint32 createCount = std::clamp<uint32>(m_spellInfo->Effects[i].CalcValue(), 1u, itemTemplate->GetMaxStackSize());
                        ItemPosCountVec dest;
                        InventoryResult msg = target->ToPlayer()->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, m_spellInfo->Effects[i].ItemType, createCount);
                        if (msg != EQUIP_ERR_OK)
                        {
                            if (!itemTemplate->ItemLimitCategory)
                            {
                                player->SendEquipError(msg, nullptr, nullptr, m_spellInfo->Effects[i].ItemType);
                                return SPELL_FAILED_DONT_REPORT;
                            }
                            else
                            {
                                // Conjure Food/Water/Refreshment spells
                                if (m_spellInfo->SpellFamilyName != SPELLFAMILY_MAGE || (!(m_spellInfo->SpellFamilyFlags[0] & 0x40000000)))
                                    return SPELL_FAILED_TOO_MANY_OF_ITEM;
                                else if (!(target->ToPlayer()->HasItemCount(m_spellInfo->Effects[i].ItemType)))
                                {
                                    player->SendEquipError(msg, nullptr, nullptr, m_spellInfo->Effects[i].ItemType);
                                    return SPELL_FAILED_DONT_REPORT;
                                }
                                else
                                    player->CastSpell(player, m_spellInfo->Effects[EFFECT_1].CalcValue(), false);        // move this to anywhere
 
                                return SPELL_FAILED_DONT_REPORT;
                            }
                        }
                    }
                }
                break;
            }
            case SPELL_EFFECT_CREATE_RANDOM_ITEM:
            {
                if (player->GetFreeInventorySpace() == 0)
                {
                    player->SendEquipError(EQUIP_ERR_INVENTORY_FULL, nullptr, nullptr, m_spellInfo->Effects[i].ItemType);
                    return SPELL_FAILED_DONT_REPORT;
                }
                break;
            }
            case SPELL_EFFECT_ENCHANT_ITEM:
                if (m_spellInfo->Effects[i].ItemType && m_targets.GetItemTarget()
                        && (m_targets.GetItemTarget()->IsWeaponVellum() || m_targets.GetItemTarget()->IsArmorVellum()))
                {
                    // cannot enchant vellum for other player
                    if (m_targets.GetItemTarget()->GetOwner() != m_caster)
                        return SPELL_FAILED_NOT_TRADEABLE;
                    // do not allow to enchant vellum from scroll made by vellum-prevent exploit
                    if (m_CastItem && m_CastItem->GetTemplate()->HasFlag(ITEM_FLAG_NO_REAGENT_COST))
                        return SPELL_FAILED_TOTEM_CATEGORY;
                    ItemPosCountVec dest;
                    InventoryResult msg = player->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, m_spellInfo->Effects[i].ItemType, 1);
                    if (msg != EQUIP_ERR_OK)
                    {
                        player->SendEquipError(msg, nullptr, nullptr, m_spellInfo->Effects[i].ItemType);
                        return SPELL_FAILED_DONT_REPORT;
                    }
                }
                [[fallthrough]]; 
            case SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC:
                {
                    Item* targetItem = m_targets.GetItemTarget();
                    if (!targetItem)
                        return SPELL_FAILED_ITEM_NOT_FOUND;
 
                    // Apply item level restriction
                    if (!m_spellInfo->HasAttribute(SPELL_ATTR2_ALLOW_LOW_LEVEL_BUFF))
                    {
                        uint32 requiredLevel = targetItem->GetTemplate()->RequiredLevel;
                        if (!requiredLevel)
                            requiredLevel = targetItem->GetTemplate()->ItemLevel;
 
                        if (requiredLevel < m_spellInfo->BaseLevel)
                            return SPELL_FAILED_LOWLEVEL;
                    }
 
                    if (m_CastItem && m_spellInfo->MaxLevel > 0 && targetItem->GetTemplate()->ItemLevel > m_spellInfo->MaxLevel)
                        return SPELL_FAILED_HIGHLEVEL;
 
                    bool isItemUsable = false;
                    for (uint8 e = 0; e < MAX_ITEM_PROTO_SPELLS; ++e)
                    {
                        ItemTemplate const* proto = targetItem->GetTemplate();
                        if (proto->Spells[e].SpellId && (
                                    proto->Spells[e].SpellTrigger == ITEM_SPELLTRIGGER_ON_USE ||
                                    proto->Spells[e].SpellTrigger == ITEM_SPELLTRIGGER_ON_NO_DELAY_USE))
                        {
                            isItemUsable = true;
                            break;
                        }
                    }
 
                    SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(m_spellInfo->Effects[i].MiscValue);
                    // do not allow adding usable enchantments to items that have use effect already
                    if (enchantEntry)
                    {
                        for (uint8 s = 0; s < MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS; ++s)
                        {
                            switch (enchantEntry->type[s])
                            {
                                case ITEM_ENCHANTMENT_TYPE_USE_SPELL:
                                    if (isItemUsable)
                                        return SPELL_FAILED_ON_USE_ENCHANT;
                                    break;
                                case ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET:
                                    {
                                        uint32 numSockets = 0;
                                        for (uint32 socket = 0; socket < MAX_ITEM_PROTO_SOCKETS; ++socket)
                                            if (targetItem->GetTemplate()->Socket[socket].Color)
                                                ++numSockets;
 
                                        if (numSockets == MAX_ITEM_PROTO_SOCKETS || targetItem->GetEnchantmentId(PRISMATIC_ENCHANTMENT_SLOT))
                                            return SPELL_FAILED_MAX_SOCKETS;
                                        break;
                                    }
                            }
                        }
                    }
 
                    // Not allow enchant in trade slot for some enchant type
                    if (targetItem->GetOwner() != m_caster)
                    {
                        if (!enchantEntry)
                            return SPELL_FAILED_ERROR;
                        if (enchantEntry->slot & ENCHANTMENT_CAN_SOULBOUND)
                            return SPELL_FAILED_NOT_TRADEABLE;
                    }
                    break;
                }
            case SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY:
                {
                    Item* item = m_targets.GetItemTarget();
                    if (!item)
                        return SPELL_FAILED_ITEM_NOT_FOUND;
                    // Not allow enchant in trade slot for some enchant type
                    if (item->GetOwner() != m_caster)
                    {
                        uint32 enchant_id = m_spellInfo->Effects[i].MiscValue;
                        SpellItemEnchantmentEntry const* pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
                        if (!pEnchant)
                            return SPELL_FAILED_ERROR;
                        if (pEnchant->slot & ENCHANTMENT_CAN_SOULBOUND)
                            return SPELL_FAILED_NOT_TRADEABLE;
                    }
 
                    // Apply item level restriction
                    if (!m_spellInfo->HasAttribute(SPELL_ATTR2_ALLOW_LOW_LEVEL_BUFF))
                    {
                        uint32 requiredLevel = item->GetTemplate()->RequiredLevel;
                        if (!requiredLevel)
                            requiredLevel = item->GetTemplate()->ItemLevel;
 
                        if (requiredLevel < m_spellInfo->BaseLevel)
                            return SPELL_FAILED_LOWLEVEL;
                    }
 
                    if (m_CastItem && m_spellInfo->MaxLevel > 0 && item->GetTemplate()->ItemLevel > m_spellInfo->MaxLevel)
                        return SPELL_FAILED_HIGHLEVEL;
 
                    break;
                }
            case SPELL_EFFECT_ENCHANT_HELD_ITEM:
                // check item existence in effect code (not output errors at offhand hold item effect to main hand for example
                break;
            case SPELL_EFFECT_DISENCHANT:
                {
                    if (!m_targets.GetItemTarget())
                        return SPELL_FAILED_CANT_BE_DISENCHANTED;
 
                    // prevent disenchanting in trade slot
                    if (m_targets.GetItemTarget()->GetOwnerGUID() != m_caster->GetGUID())
                        return SPELL_FAILED_CANT_BE_DISENCHANTED;
 
                    ItemTemplate const* itemProto = m_targets.GetItemTarget()->GetTemplate();
                    if (!itemProto)
                        return SPELL_FAILED_CANT_BE_DISENCHANTED;
 
                    uint32 item_quality = itemProto->Quality;
                    // 2.0.x addon: Check player enchanting level against the item disenchanting requirements
                    uint32 item_disenchantskilllevel = itemProto->RequiredDisenchantSkill;
                    if (item_disenchantskilllevel == uint32(-1))
                        return SPELL_FAILED_CANT_BE_DISENCHANTED;
                    if (item_disenchantskilllevel > player->GetSkillValue(SKILL_ENCHANTING))
                        return SPELL_FAILED_LOW_CASTLEVEL;
                    if (item_quality > 4 || item_quality < 2)
                        return SPELL_FAILED_CANT_BE_DISENCHANTED;
                    if (itemProto->Class != ITEM_CLASS_WEAPON && itemProto->Class != ITEM_CLASS_ARMOR)
                        return SPELL_FAILED_CANT_BE_DISENCHANTED;
                    if (!itemProto->DisenchantID)
                        return SPELL_FAILED_CANT_BE_DISENCHANTED;
                    break;
                }
            case SPELL_EFFECT_PROSPECTING:
                {
                    Item* item = m_targets.GetItemTarget();
                    if (!item)
                        return SPELL_FAILED_CANT_BE_PROSPECTED;
                    //ensure item is a prospectable ore
                    if (!(item->GetTemplate()->HasFlag(ITEM_FLAG_IS_PROSPECTABLE)))
                        return SPELL_FAILED_CANT_BE_PROSPECTED;
                    //prevent prospecting in trade slot
                    if (item->GetOwnerGUID() != m_caster->GetGUID())
                        return SPELL_FAILED_CANT_BE_PROSPECTED;
                    //Check for enough skill in jewelcrafting
                    uint32 item_prospectingskilllevel = item->GetTemplate()->RequiredSkillRank;
                    if (item_prospectingskilllevel > player->GetSkillValue(SKILL_JEWELCRAFTING))
                        return SPELL_FAILED_LOW_CASTLEVEL;
                    //make sure the player has the required ores in inventory
                    if (item->GetCount() < 5)
                    {
                        if (param1 && param2)
                        {
                            *param1 = item->GetEntry();
                            *param2 = 5;
                        }
                        return SPELL_FAILED_NEED_MORE_ITEMS;
                    }
 
                    if (!LootTemplates_Prospecting.HaveLootFor(m_targets.GetItemTargetEntry()))
                        return SPELL_FAILED_CANT_BE_PROSPECTED;
 
                    break;
                }
            case SPELL_EFFECT_MILLING:
                {
                    Item* item = m_targets.GetItemTarget();
                    if (!item)
                        return SPELL_FAILED_CANT_BE_MILLED;
                    //ensure item is a millable herb
                    if (!(item->GetTemplate()->HasFlag(ITEM_FLAG_IS_MILLABLE)))
                        return SPELL_FAILED_CANT_BE_MILLED;
                    //prevent milling in trade slot
                    if (item->GetOwnerGUID() != m_caster->GetGUID())
                        return SPELL_FAILED_CANT_BE_MILLED;
                    //Check for enough skill in inscription
                    uint32 item_millingskilllevel = item->GetTemplate()->RequiredSkillRank;
                    if (item_millingskilllevel > player->GetSkillValue(SKILL_INSCRIPTION))
                        return SPELL_FAILED_LOW_CASTLEVEL;
                    //make sure the player has the required herbs in inventory
                    if (item->GetCount() < 5)
                    {
                        if (param1 && param2)
                        {
                            *param1 = item->GetEntry();
                            *param2 = 5;
                        }
                        return SPELL_FAILED_NEED_MORE_ITEMS;
                    }
 
                    if (!LootTemplates_Milling.HaveLootFor(m_targets.GetItemTargetEntry()))
                        return SPELL_FAILED_CANT_BE_MILLED;
 
                    break;
                }
            case SPELL_EFFECT_WEAPON_DAMAGE:
            case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
                {
                    if (!m_caster->IsPlayer())
                        return SPELL_FAILED_TARGET_NOT_PLAYER;
 
                    if (m_attackType != RANGED_ATTACK)
                        break;
 
                    Item* pItem = m_caster->ToPlayer()->GetWeaponForAttack(m_attackType);
                    if (!pItem || pItem->IsBroken())
                        return SPELL_FAILED_EQUIPPED_ITEM;
 
                    switch (pItem->GetTemplate()->SubClass)
                    {
                        case ITEM_SUBCLASS_WEAPON_THROWN:
                            {
                                uint32 ammo = pItem->GetEntry();
                                if (!m_caster->ToPlayer()->HasItemCount(ammo))
                                    return SPELL_FAILED_NO_AMMO;
                            };
                            break;
                        case ITEM_SUBCLASS_WEAPON_GUN:
                        case ITEM_SUBCLASS_WEAPON_BOW:
                        case ITEM_SUBCLASS_WEAPON_CROSSBOW:
                            {
                                uint32 ammo = m_caster->ToPlayer()->GetUInt32Value(PLAYER_AMMO_ID);
                                if (!ammo)
                                {
                                    // Requires No Ammo
                                    if (m_caster->HasAura(46699))
                                        break;                      // skip other checks
 
                                    return SPELL_FAILED_NO_AMMO;
                                }
 
                                ItemTemplate const* ammoProto = sObjectMgr->GetItemTemplate(ammo);
                                if (!ammoProto)
                                    return SPELL_FAILED_NO_AMMO;
 
                                if (ammoProto->Class != ITEM_CLASS_PROJECTILE)
                                    return SPELL_FAILED_NO_AMMO;
 
                                // check ammo ws. weapon compatibility
                                switch (pItem->GetTemplate()->SubClass)
                                {
                                    case ITEM_SUBCLASS_WEAPON_BOW:
                                    case ITEM_SUBCLASS_WEAPON_CROSSBOW:
                                        if (ammoProto->SubClass != ITEM_SUBCLASS_ARROW)
                                            return SPELL_FAILED_NO_AMMO;
                                        break;
                                    case ITEM_SUBCLASS_WEAPON_GUN:
                                        if (ammoProto->SubClass != ITEM_SUBCLASS_BULLET)
                                            return SPELL_FAILED_NO_AMMO;
                                        break;
                                    default:
                                        return SPELL_FAILED_NO_AMMO;
                                }
 
                                if (!m_caster->ToPlayer()->HasItemCount(ammo))
                                {
                                    m_caster->ToPlayer()->SetUInt32Value(PLAYER_AMMO_ID, 0);
                                    return SPELL_FAILED_NO_AMMO;
                                }
                            };
                            break;
                        case ITEM_SUBCLASS_WEAPON_WAND:
                            break;
                        default:
                            break;
                    }
                    break;
                }
            case SPELL_EFFECT_CREATE_MANA_GEM:
                {
                    uint32 item_id = m_spellInfo->Effects[i].ItemType;
                    ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(item_id);
 
                    if (!pProto)
                        return SPELL_FAILED_ITEM_AT_MAX_CHARGES;
 
                    if (Item* pitem = player->GetItemByEntry(item_id))
                    {
                        for (int x = 0; x < MAX_ITEM_PROTO_SPELLS; ++x)
                            if (pProto->Spells[x].SpellCharges != 0 && pitem->GetSpellCharges(x) == pProto->Spells[x].SpellCharges)
                                return SPELL_FAILED_ITEM_AT_MAX_CHARGES;
                    }
                    break;
                }
            default:
                break;
        }
    }
 
    // check weapon presence in slots for main/offhand weapons
    if (/*never skip those checks !HasTriggeredCastFlag(TRIGGERED_IGNORE_EQUIPPED_ITEM_REQUIREMENT) &&*/ m_spellInfo->EquippedItemClass >= 0)
    {
        // main hand weapon required
        if (m_spellInfo->HasAttribute(SPELL_ATTR3_REQUIRES_MAIN_HAND_WEAPON))
        {
            Item* item = m_caster->ToPlayer()->GetWeaponForAttack(BASE_ATTACK);
 
            // skip spell if no weapon in slot or broken
            if (!item || item->IsBroken())
                return SPELL_FAILED_EQUIPPED_ITEM_CLASS_MAINHAND;
 
            // skip spell if weapon not fit to triggered spell
            if (!item->IsFitToSpellRequirements(m_spellInfo))
                return SPELL_FAILED_EQUIPPED_ITEM_CLASS_MAINHAND;
        }
 
        // offhand hand weapon required
        if (m_spellInfo->HasAttribute(SPELL_ATTR3_REQUIRES_OFF_HAND_WEAPON))
        {
            Item* item = m_caster->ToPlayer()->GetWeaponForAttack(OFF_ATTACK);
 
            // skip spell if no weapon in slot or broken
            if (!item || item->IsBroken())
                return SPELL_FAILED_EQUIPPED_ITEM_CLASS_OFFHAND;
 
            // skip spell if weapon not fit to triggered spell
            if (!item->IsFitToSpellRequirements(m_spellInfo))
                return SPELL_FAILED_EQUIPPED_ITEM_CLASS_OFFHAND;
        }
 
        m_weaponItem = m_caster->ToPlayer()->GetWeaponForAttack(m_attackType, true);
    }
 
    return SPELL_CAST_OK;
}

References BASE_ATTACK, Player::CanNoReagentCast(), Player::CanStoreNewItem(), Unit::CanUseAttackType(), Unit::CastSpell(), ItemTemplate::Class, _Socket::Color, ItemTemplate::DisenchantID, SpellInfo::DmgClass, EFFECT_1, SpellInfo::Effects, ENCHANTMENT_CAN_SOULBOUND, EQUIP_ERR_INVENTORY_FULL, EQUIP_ERR_OK, SpellInfo::EquippedItemClass, Item::GetCount(), Item::GetEnchantmentId(), Object::GetEntry(), Player::GetFreeInventorySpace(), Object::GetGUID(), Player::GetItemByEntry(), SpellCastTargets::GetItemTarget(), SpellCastTargets::GetItemTargetEntry(), SpellCastTargets::GetItemTargetGUID(), Unit::GetMaxPower(), ItemTemplate::GetMaxStackSize(), Item::GetOwner(), Item::GetOwnerGUID(), Unit::GetPower(), Player::GetSkillValue(), Item::GetSpellCharges(), Item::GetTemplate(), Object::GetUInt32Value(), SpellCastTargets::GetUnitTarget(), Player::GetWeaponForAttack(), SpellInfo::HasAttribute(), Unit::HasAura(), ItemTemplate::HasFlag(), Player::HasItemCount(), Player::HasItemFitToSpellRequirements(), Player::HasItemTotemCategory(), HasTriggeredCastFlag(), LootStore::HaveLootFor(), Item::IsArmorVellum(), Item::IsBroken(), Item::IsFitToSpellRequirements(), Unit::IsFullHealth(), Object::IsPlayer(), IsTriggered(), Item::IsWeaponVellum(), ITEM_CLASS_ARMOR, ITEM_CLASS_CONSUMABLE, ITEM_CLASS_PROJECTILE, ITEM_CLASS_WEAPON, ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET, ITEM_ENCHANTMENT_TYPE_USE_SPELL, ITEM_FLAG_IS_MILLABLE, ITEM_FLAG_IS_PROSPECTABLE, ITEM_FLAG_NO_REAGENT_COST, ITEM_SPELLTRIGGER_ON_NO_DELAY_USE, ITEM_SPELLTRIGGER_ON_USE, ITEM_SUBCLASS_ARROW, ITEM_SUBCLASS_BULLET, ITEM_SUBCLASS_WEAPON_BOW, ITEM_SUBCLASS_WEAPON_CROSSBOW, ITEM_SUBCLASS_WEAPON_GUN, ITEM_SUBCLASS_WEAPON_THROWN, ITEM_SUBCLASS_WEAPON_WAND, ItemTemplate::ItemLevel, ItemTemplate::ItemLimitCategory, LootTemplates_Milling, LootTemplates_Prospecting, m_attackType, m_caster, m_CastItem, m_castItemGUID, m_spellInfo, m_targets, m_weaponItem, MAX_ITEM_PROTO_SOCKETS, MAX_ITEM_PROTO_SPELLS, MAX_ITEM_SPELLS, MAX_POWERS, MAX_SPELL_EFFECTS, MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS, MAX_SPELL_REAGENTS, SpellInfo::MaxLevel, NULL_BAG, NULL_SLOT, OFF_ATTACK, PLAYER_AMMO_ID, PRISMATIC_ENCHANTMENT_SLOT, ItemTemplate::Quality, RANGED_ATTACK, SpellInfo::Reagent, SpellInfo::ReagentCount, ItemTemplate::RequiredDisenchantSkill, ItemTemplate::RequiredLevel, ItemTemplate::RequiredSkillRank, Player::SendEquipError(), Unit::SetUInt32Value(), SKILL_ENCHANTING, SKILL_INSCRIPTION, SKILL_JEWELCRAFTING, SpellItemEnchantmentEntry::slot, sObjectMgr, ItemTemplate::Socket, SPELL_ATTR2_ALLOW_LOW_LEVEL_BUFF, SPELL_ATTR3_REQUIRES_MAIN_HAND_WEAPON, SPELL_ATTR3_REQUIRES_OFF_HAND_WEAPON, SPELL_CAST_OK, SPELL_DAMAGE_CLASS_MELEE, SPELL_DAMAGE_CLASS_RANGED, SPELL_EFFECT_CREATE_ITEM, SPELL_EFFECT_CREATE_ITEM_2, SPELL_EFFECT_CREATE_MANA_GEM, SPELL_EFFECT_CREATE_RANDOM_ITEM, SPELL_EFFECT_DISENCHANT, SPELL_EFFECT_ENCHANT_HELD_ITEM, SPELL_EFFECT_ENCHANT_ITEM, SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC, SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY, SPELL_EFFECT_ENERGIZE, SPELL_EFFECT_HEAL, SPELL_EFFECT_MILLING, SPELL_EFFECT_PROSPECTING, SPELL_EFFECT_WEAPON_DAMAGE, SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL, SPELL_FAILED_ALREADY_AT_FULL_HEALTH, SPELL_FAILED_ALREADY_AT_FULL_POWER, SPELL_FAILED_BAD_TARGETS, SPELL_FAILED_CANT_BE_DISENCHANTED, SPELL_FAILED_CANT_BE_MILLED, SPELL_FAILED_CANT_BE_PROSPECTED, SPELL_FAILED_DONT_REPORT, SPELL_FAILED_EQUIPPED_ITEM, SPELL_FAILED_EQUIPPED_ITEM_CLASS, SPELL_FAILED_EQUIPPED_ITEM_CLASS_MAINHAND, SPELL_FAILED_EQUIPPED_ITEM_CLASS_OFFHAND, SPELL_FAILED_ERROR, SPELL_FAILED_HIGHLEVEL, SPELL_FAILED_ITEM_AT_MAX_CHARGES, SPELL_FAILED_ITEM_GONE, SPELL_FAILED_ITEM_NOT_FOUND, SPELL_FAILED_ITEM_NOT_READY, SPELL_FAILED_LOW_CASTLEVEL, SPELL_FAILED_LOWLEVEL, SPELL_FAILED_MAX_SOCKETS, SPELL_FAILED_NEED_MORE_ITEMS, SPELL_FAILED_NO_AMMO, SPELL_FAILED_NO_CHARGES_REMAIN, SPELL_FAILED_NOT_TRADEABLE, SPELL_FAILED_ON_USE_ENCHANT, SPELL_FAILED_REAGENTS, SPELL_FAILED_TARGET_NOT_PLAYER, SPELL_FAILED_TOO_MANY_OF_ITEM, SPELL_FAILED_TOTEM_CATEGORY, SPELL_FAILED_TOTEMS, _Spell::SpellCharges, SPELLFAMILY_MAGE, SpellInfo::SpellFamilyFlags, SpellInfo::SpellFamilyName, _Spell::SpellId, ItemTemplate::Spells, _Spell::SpellTrigger, sSpellItemEnchantmentStore, ItemTemplate::SubClass, TARGET_UNIT_PET, Object::ToPlayer(), SpellInfo::Totem, SpellInfo::TotemCategory, TRIGGERED_IGNORE_POWER_AND_REAGENT_COST, and SpellItemEnchantmentEntry::type.

Referenced by CheckCast().

◆ CheckPetCast()

SpellCastResult Spell::CheckPetCast ( Unit * target )

{
    if (m_caster->HasUnitState(UNIT_STATE_CASTING) && !HasTriggeredCastFlag(TRIGGERED_IGNORE_CAST_IN_PROGRESS))              //prevent spellcast interruption by another spellcast
        return SPELL_FAILED_SPELL_IN_PROGRESS;
 
    // dead owner (pets still alive when owners ressed?)
    if (Unit* owner = m_caster->GetCharmerOrOwner())
        if (!owner->IsAlive() && m_caster->GetEntry() != 30230) // Rise Ally
            return SPELL_FAILED_CASTER_DEAD;
 
    if (!target && m_targets.GetUnitTarget())
        target = m_targets.GetUnitTarget();
 
    if (m_spellInfo->NeedsExplicitUnitTarget())
    {
        if (!target)
            return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
        m_targets.SetUnitTarget(target);
    }
 
    // xinef: Calculate power cost here, so funciton checking power can work properly and dont return bad results
    m_powerCost = m_spellInfo->CalcPowerCost(m_caster, m_spellSchoolMask, this);
 
    // cooldown
    if (Creature const* creatureCaster = m_caster->ToCreature())
        if (creatureCaster->HasSpellCooldown(m_spellInfo->Id))
            return SPELL_FAILED_NOT_READY;
 
    // Check if spell is affected by GCD
    if (m_spellInfo->StartRecoveryCategory > 0)
        if (m_caster->GetCharmInfo() && m_caster->GetCharmInfo()->GetGlobalCooldownMgr().HasGlobalCooldown(m_spellInfo))
            return SPELL_FAILED_NOT_READY;
 
    return CheckCast(true);
}

References SpellInfo::CalcPowerCost(), CheckCast(), Unit::GetCharmerOrOwner(), Unit::GetCharmInfo(), Object::GetEntry(), CharmInfo::GetGlobalCooldownMgr(), SpellCastTargets::GetUnitTarget(), GlobalCooldownMgr::HasGlobalCooldown(), HasTriggeredCastFlag(), Unit::HasUnitState(), SpellInfo::Id, m_caster, m_powerCost, m_spellInfo, m_spellSchoolMask, m_targets, SpellInfo::NeedsExplicitUnitTarget(), SpellCastTargets::SetUnitTarget(), SPELL_FAILED_BAD_IMPLICIT_TARGETS, SPELL_FAILED_CASTER_DEAD, SPELL_FAILED_NOT_READY, SPELL_FAILED_SPELL_IN_PROGRESS, SpellInfo::StartRecoveryCategory, Object::ToCreature(), TRIGGERED_IGNORE_CAST_IN_PROGRESS, and UNIT_STATE_CASTING.

Referenced by CanAutoCast(), WorldSession::HandlePetActionHelper(), and WorldSession::HandlePetCastSpellOpcode().

◆ CheckPower()

SpellCastResult Spell::CheckPower ( )

{
    // item cast not used power
    if (m_CastItem)
        return SPELL_CAST_OK;
 
    //While .cheat power is enabled dont check if we need power to cast the spell
    if (m_caster->IsPlayer())
    {
        if (m_caster->ToPlayer()->GetCommandStatus(CHEAT_POWER))
        {
            return SPELL_CAST_OK;
        }
    }
 
    // health as power used - need check health amount
    if (m_spellInfo->PowerType == POWER_HEALTH)
    {
        if (int32(m_caster->GetHealth()) <= m_powerCost)
            return SPELL_FAILED_CASTER_AURASTATE;
        return SPELL_CAST_OK;
    }
    // Check valid power type
    if (m_spellInfo->PowerType >= MAX_POWERS)
    {
        LOG_ERROR("spells", "Spell::CheckPower: Unknown power type '{}'", m_spellInfo->PowerType);
        return SPELL_FAILED_UNKNOWN;
    }
 
    //check rune cost only if a spell has PowerType == POWER_RUNE
    if (m_spellInfo->PowerType == POWER_RUNE)
    {
        SpellCastResult failReason = CheckRuneCost(m_spellInfo->RuneCostID);
        if (failReason != SPELL_CAST_OK)
            return failReason;
    }
 
    // Check power amount
    Powers PowerType = Powers(m_spellInfo->PowerType);
    if (int32(m_caster->GetPower(PowerType)) < m_powerCost)
        return SPELL_FAILED_NO_POWER;
    else
        return SPELL_CAST_OK;
}

References CHEAT_POWER, CheckRuneCost(), Player::GetCommandStatus(), Unit::GetHealth(), Unit::GetPower(), Object::IsPlayer(), LOG_ERROR, m_caster, m_CastItem, m_powerCost, m_spellInfo, MAX_POWERS, POWER_HEALTH, POWER_RUNE, SpellInfo::PowerType, SpellInfo::RuneCostID, SPELL_CAST_OK, SPELL_FAILED_CASTER_AURASTATE, SPELL_FAILED_NO_POWER, SPELL_FAILED_UNKNOWN, and Object::ToPlayer().

Referenced by CheckCast().

◆ CheckRange()

SpellCastResult Spell::CheckRange ( bool strict )

{
    // Don't check for instant cast spells
    if (!strict && m_casttime == 0)
        return SPELL_CAST_OK;
 
    uint32 range_type = 0;
 
    if (m_spellInfo->RangeEntry)
    {
        // check needed by 68766 51693 - both spells are cast on enemies and have 0 max range
        // these are triggered by other spells - possibly we should omit range check in that case?
        if (m_spellInfo->RangeEntry->ID == 1)
            return SPELL_CAST_OK;
 
        range_type = m_spellInfo->RangeEntry->Flags;
    }
 
    Unit* target = m_targets.GetUnitTarget();
    float max_range = m_caster->GetSpellMaxRangeForTarget(target, m_spellInfo);
    float min_range = m_caster->GetSpellMinRangeForTarget(target, m_spellInfo);
 
    // xinef: hack for npc shooters
    if (min_range && GetCaster()->IsCreature() && !GetCaster()->GetOwnerGUID().IsPlayer() && min_range <= 6.0f)
        range_type = SPELL_RANGE_RANGED;
 
    if (Player* modOwner = m_caster->GetSpellModOwner())
        modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_RANGE, max_range, this);
 
    // xinef: dont check max_range to strictly after cast
    if (range_type != SPELL_RANGE_MELEE && !strict)
        max_range += std::min(3.0f, max_range * 0.1f); // 10% but no more than 3yd
 
    if (target)
    {
        if (target != m_caster)
        {
            // Xinef: Spells with 5yd range can hit target 9yd away?
            if (range_type == SPELL_RANGE_MELEE)
            {
                float real_max_range = max_range;
                if (!m_caster->IsCreature() && m_caster->HasLeewayMovement() && target->HasLeewayMovement())
                    real_max_range -= MIN_MELEE_REACH; // Because of lag, we can not check too strictly here (is only used if both caster and target are moving)
                else
                    real_max_range -= 2 * MIN_MELEE_REACH;
 
                if (!m_caster->IsWithinMeleeRange(target, std::max(real_max_range, 0.0f)))
                    return SPELL_FAILED_OUT_OF_RANGE;
            }
            else if (!m_caster->IsWithinCombatRange(target, max_range))
                return SPELL_FAILED_OUT_OF_RANGE; //0x5A;
 
            if (m_caster->IsPlayer() && (m_spellInfo->FacingCasterFlags & SPELL_FACING_FLAG_INFRONT) && !m_caster->HasInArc(static_cast<float>(M_PI), target) && !m_caster->IsWithinBoundaryRadius(target))
                return SPELL_FAILED_UNIT_NOT_INFRONT;
        }
 
        // Check min range - for ranged spells, min range is the spell's min range + melee range (no leeway)
        if (range_type == SPELL_RANGE_RANGED)
        {
            float minRangeCombined = min_range + m_caster->GetMeleeRange(target);
            if (m_caster->IsWithinRange(target, minRangeCombined))
                return SPELL_FAILED_TOO_CLOSE;
        }
        else if (min_range > 0 && m_caster->IsWithinCombatRange(target, min_range))
            return SPELL_FAILED_TOO_CLOSE;
    }
 
    if (GameObject* goTarget = m_targets.GetGOTarget())
    {
        if (!goTarget->IsAtInteractDistance(m_caster->ToPlayer(), m_spellInfo))
        {
            return SPELL_FAILED_OUT_OF_RANGE;
        }
    }
 
    if (m_targets.HasDst() && !m_targets.HasTraj())
    {
        if (!m_caster->IsWithinDist3d(m_targets.GetDstPos(), max_range))
            return SPELL_FAILED_OUT_OF_RANGE;
        if (min_range && m_caster->IsWithinDist3d(m_targets.GetDstPos(), min_range))
            return SPELL_FAILED_TOO_CLOSE;
    }
 
    return SPELL_CAST_OK;
}

References SpellInfo::FacingCasterFlags, SpellRangeEntry::Flags, GetCaster(), SpellCastTargets::GetDstPos(), SpellCastTargets::GetGOTarget(), Unit::GetMeleeRange(), Unit::GetSpellMaxRangeForTarget(), Unit::GetSpellMinRangeForTarget(), Unit::GetSpellModOwner(), SpellCastTargets::GetUnitTarget(), SpellCastTargets::HasDst(), Position::HasInArc(), Unit::HasLeewayMovement(), SpellCastTargets::HasTraj(), SpellInfo::Id, SpellRangeEntry::ID, Object::IsCreature(), Object::IsPlayer(), Unit::IsWithinBoundaryRadius(), Unit::IsWithinCombatRange(), WorldObject::IsWithinDist3d(), Unit::IsWithinMeleeRange(), Unit::IsWithinRange(), m_caster, m_casttime, m_spellInfo, m_targets, MIN_MELEE_REACH, SpellInfo::RangeEntry, SPELL_CAST_OK, SPELL_FACING_FLAG_INFRONT, SPELL_FAILED_OUT_OF_RANGE, SPELL_FAILED_TOO_CLOSE, SPELL_FAILED_UNIT_NOT_INFRONT, SPELL_RANGE_MELEE, SPELL_RANGE_RANGED, SPELLMOD_RANGE, and Object::ToPlayer().

Referenced by CheckCast().

◆ CheckRuneCost()

SpellCastResult Spell::CheckRuneCost ( uint32 RuneCostID )

{
    if (m_spellInfo->PowerType != POWER_RUNE || !RuneCostID)
        return SPELL_CAST_OK;
 
    if (!m_caster->IsPlayer())
        return SPELL_CAST_OK;
 
    Player* player = m_caster->ToPlayer();
    //If we are in .cheat power mode we dont need to check the cost as we are expected to be able to use it anyways (infinite power)
    if (player->GetCommandStatus(CHEAT_POWER))
    {
        return SPELL_CAST_OK;
    }
 
    if (!player->IsClass(CLASS_DEATH_KNIGHT, CLASS_CONTEXT_ABILITY))
        return SPELL_CAST_OK;
 
    SpellRuneCostEntry const* src = sSpellRuneCostStore.LookupEntry(RuneCostID);
 
    if (!src)
        return SPELL_CAST_OK;
 
    if (src->NoRuneCost())
        return SPELL_CAST_OK;
 
    int32 runeCost[NUM_RUNE_TYPES];                         // blood, frost, unholy, death
 
    for (uint32 i = 0; i < RUNE_DEATH; ++i)
    {
        runeCost[i] = src->RuneCost[i];
        if (Player* modOwner = m_caster->GetSpellModOwner())
            modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_COST, runeCost[i], this);
    }
 
    runeCost[RUNE_DEATH] = MAX_RUNES;                       // calculated later
 
    for (uint32 i = 0; i < MAX_RUNES; ++i)
    {
        RuneType rune = player->GetCurrentRune(i);
        if ((player->GetRuneCooldown(i) == 0) && (runeCost[rune] > 0))
            runeCost[rune]--;
    }
 
    for (uint32 i = 0; i < RUNE_DEATH; ++i)
        if (runeCost[i] > 0)
            runeCost[RUNE_DEATH] += runeCost[i];
 
    if (runeCost[RUNE_DEATH] > MAX_RUNES)
        return SPELL_FAILED_NO_POWER;                       // not sure if result code is correct
 
    return SPELL_CAST_OK;
}

References CHEAT_POWER, CLASS_CONTEXT_ABILITY, CLASS_DEATH_KNIGHT, Player::GetCommandStatus(), Player::GetCurrentRune(), Player::GetRuneCooldown(), Unit::GetSpellModOwner(), SpellInfo::Id, Player::IsClass(), Object::IsPlayer(), m_caster, m_spellInfo, MAX_RUNES, SpellRuneCostEntry::NoRuneCost(), NUM_RUNE_TYPES, POWER_RUNE, SpellInfo::PowerType, RUNE_DEATH, SpellRuneCostEntry::RuneCost, SPELL_CAST_OK, SPELL_FAILED_NO_POWER, SPELLMOD_COST, sSpellRuneCostStore, and Object::ToPlayer().

Referenced by CheckPower().

◆ CheckScriptEffectImplicitTargets()

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

protected

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

References m_loadedScripts, and m_spellInfo.

Referenced by SelectEffectImplicitTargets().

◆ CheckSpellFocus()

SpellCastResult Spell::CheckSpellFocus ( )

{
    // check spell focus object
    if (m_spellInfo->RequiresSpellFocus)
    {
        CellCoord p(Acore::ComputeCellCoord(m_caster->GetPositionX(), m_caster->GetPositionY()));
        Cell cell(p);
 
        GameObject* ok = nullptr;
        Acore::GameObjectFocusCheck go_check(m_caster, m_spellInfo->RequiresSpellFocus);
        Acore::GameObjectSearcher<Acore::GameObjectFocusCheck> checker(m_caster, ok, go_check);
 
        TypeContainerVisitor<Acore::GameObjectSearcher<Acore::GameObjectFocusCheck>, GridTypeMapContainer > object_checker(checker);
        Map& map = *m_caster->GetMap();
        cell.Visit(p, object_checker, map, *m_caster, m_caster->GetVisibilityRange());
 
        if (!ok)
            return SPELL_FAILED_REQUIRES_SPELL_FOCUS;
 
        focusObject = ok;                                   // game object found in range
    }
    return SPELL_CAST_OK;
}

References Acore::ComputeCellCoord(), focusObject, WorldObject::GetMap(), Position::GetPositionX(), Position::GetPositionY(), WorldObject::GetVisibilityRange(), m_caster, m_spellInfo, SpellInfo::RequiresSpellFocus, SPELL_CAST_OK, SPELL_FAILED_REQUIRES_SPELL_FOCUS, and Cell::Visit().

Referenced by CheckCast().

◆ CheckSrc()

void Spell::CheckSrc ( )

inline

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

SpellCastTargets::HasSrc

bool HasSrc() const

Definition Spell.h:176

SpellCastTargets::SetSrc

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

Definition Spell.cpp:366

References SpellCastTargets::HasSrc(), m_caster, m_targets, and SpellCastTargets::SetSrc().

◆ CleanupTargetList()

void Spell::CleanupTargetList ( )

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

References m_delayMoment, m_delayTrajectory, m_UniqueGOTargetInfo, m_UniqueItemInfo, and m_UniqueTargetInfo.

Referenced by spell_dk_raise_dead::CheckCast(), and Spell().

◆ Delayed()

void Spell::Delayed ( )

{
    if (!m_caster)// || !m_caster->IsPlayer())
        return;
 
    //if (m_spellState == SPELL_STATE_DELAYED)
    //    return;                                             // spell is active and can't be time-backed
 
    if (isDelayableNoMore())                                 // Spells may only be delayed twice
        return;
 
    if (m_spellInfo->HasAttribute(SPELL_ATTR6_NO_PUSHBACK))
        return;
 
    // spells not loosing casting time (slam, dynamites, bombs..)
    //if (!(m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_DAMAGE))
    //    return;
 
    //check pushback reduce
    int32 delaytime = 500;                                  // spellcasting delay is normally 500ms
    int32 delayReduce = 100;                                // must be initialized to 100 for percent modifiers
    m_caster->ToPlayer()->ApplySpellMod(m_spellInfo->Id, SPELLMOD_NOT_LOSE_CASTING_TIME, delayReduce, this);
    delayReduce += m_caster->GetTotalAuraModifier(SPELL_AURA_REDUCE_PUSHBACK) - 100;
    if (delayReduce >= 100)
        return;
 
    AddPct(delaytime, -delayReduce);
 
    if (m_timer + delaytime > m_casttime)
    {
        delaytime = m_casttime - m_timer;
        m_timer = m_casttime;
    }
    else
        m_timer += delaytime;
 
    LOG_DEBUG("spells", "Spell {} partially interrupted for ({}) ms at damage", m_spellInfo->Id, delaytime);
 
    WorldPacket data(SMSG_SPELL_DELAYED, 8 + 4);
    data << m_caster->GetPackGUID();
    data << uint32(delaytime);
 
    m_caster->SendMessageToSet(&data, true);
}

References AddPct(), Player::ApplySpellMod(), Object::GetPackGUID(), Unit::GetTotalAuraModifier(), SpellInfo::HasAttribute(), SpellInfo::Id, isDelayableNoMore(), LOG_DEBUG, m_caster, m_casttime, m_spellInfo, m_timer, WorldObject::SendMessageToSet(), SMSG_SPELL_DELAYED, SPELL_ATTR6_NO_PUSHBACK, SPELL_AURA_REDUCE_PUSHBACK, SPELLMOD_NOT_LOSE_CASTING_TIME, and Object::ToPlayer().

◆ DelayedChannel()

void Spell::DelayedChannel ( )

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

References AddPct(), Player::ApplySpellMod(), CalculatePct(), SpellInfo::GetDuration(), Unit::GetDynObject(), Object::GetGUID(), getState(), Unit::GetTotalAuraModifier(), ObjectAccessor::GetUnit(), SpellInfo::HasAttribute(), SpellInfo::Id, isDelayableNoMore(), Object::IsPlayer(), LOG_DEBUG, m_caster, m_channeledDuration, m_originalCasterGUID, m_spellInfo, m_timer, m_UniqueTargetInfo, SendChannelUpdate(), SPELL_ATTR6_NO_PUSHBACK, SPELL_AURA_REDUCE_PUSHBACK, SPELL_MISS_NONE, SPELL_STATE_CASTING, SPELLMOD_NOT_LOSE_CASTING_TIME, and Object::ToPlayer().

◆ DoAllEffectOnLaunchTarget()

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

protected

{
    Unit* unit = nullptr;
    // In case spell hit target, do all effect on that target
    if (targetInfo.missCondition == SPELL_MISS_NONE)
        unit = m_caster->GetGUID() == targetInfo.targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, targetInfo.targetGUID);
    // In case spell reflect from target, do all effect on caster (if hit)
    else if (targetInfo.missCondition == SPELL_MISS_REFLECT && targetInfo.reflectResult == SPELL_MISS_NONE)
        unit = m_caster;
    if (!unit)
        return;
 
    for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (targetInfo.effectMask & (1 << i))
        {
            m_damage = 0;
            m_healing = 0;
            m_damageBeforeTakenMods = 0;
 
            HandleEffects(unit, nullptr, nullptr, i, SPELL_EFFECT_HANDLE_LAUNCH_TARGET);
 
            if (m_damage > 0)
            {
                // Xinef: Area Auras, AoE Targetting spells AND Chain Target spells (cleave etc.)
                if (m_spellInfo->Effects[i].IsAreaAuraEffect() || m_spellInfo->Effects[i].IsTargetingArea() || (m_spellInfo->Effects[i].ChainTarget > 1 && m_spellInfo->DmgClass != SPELL_DAMAGE_CLASS_MAGIC))
                {
                    bool npcCaster = (m_caster && !m_caster->IsControlledByPlayer()) || GetSpellInfo()->HasAttribute(SPELL_ATTR7_TREAT_AS_NPC_AOE);
                    m_damage = unit->CalculateAOEDamageReduction(m_damage, m_spellInfo->SchoolMask, npcCaster);
                    if (m_caster->IsPlayer())
                    {
                        uint32 targetAmount = m_UniqueTargetInfo.size();
                        if (targetAmount > 10)
                            m_damage = m_damage * 10 / targetAmount;
                    }
                }
            }
 
            if (m_applyMultiplierMask & (1 << i))
            {
                m_damage = int32(m_damage * m_damageMultipliers[i]);
                m_damageMultipliers[i] *= multiplier[i];
            }
            targetInfo.damage += m_damage;
            targetInfo.damageBeforeTakenMods += m_damageBeforeTakenMods;
        }
    }
 
    // xinef: totem's inherit owner crit chance and dancing rune weapon
    Unit* caster = m_caster;
    if (m_caster->IsTotem() || m_caster->GetEntry() == 27893)
    {
        if (Unit* owner = m_caster->GetOwner())
            caster = owner;
    }
    else if (m_originalCaster)
        caster = m_originalCaster;
 
    float critChance = caster->SpellDoneCritChance(unit, m_spellInfo, m_spellSchoolMask, m_attackType, false);
    critChance = unit->SpellTakenCritChance(caster, m_spellInfo, m_spellSchoolMask, critChance, m_attackType, false);
    targetInfo.crit = roll_chance_f(std::max(0.0f, critChance));
}

References Unit::CalculateAOEDamageReduction(), TargetInfo::crit, TargetInfo::damage, TargetInfo::damageBeforeTakenMods, SpellInfo::DmgClass, TargetInfo::effectMask, SpellInfo::Effects, Object::GetEntry(), Object::GetGUID(), Unit::GetOwner(), GetSpellInfo(), ObjectAccessor::GetUnit(), HandleEffects(), SpellInfo::HasAttribute(), Unit::IsControlledByPlayer(), Object::IsPlayer(), Unit::IsTotem(), m_applyMultiplierMask, m_attackType, m_caster, m_damage, m_damageBeforeTakenMods, m_damageMultipliers, m_healing, m_originalCaster, m_spellInfo, m_spellSchoolMask, m_UniqueTargetInfo, MAX_SPELL_EFFECTS, TargetInfo::missCondition, TargetInfo::reflectResult, roll_chance_f(), SpellInfo::SchoolMask, SPELL_ATTR7_TREAT_AS_NPC_AOE, SPELL_DAMAGE_CLASS_MAGIC, SPELL_EFFECT_HANDLE_LAUNCH_TARGET, SPELL_MISS_NONE, SPELL_MISS_REFLECT, Unit::SpellDoneCritChance(), Unit::SpellTakenCritChance(), and TargetInfo::targetGUID.

Referenced by HandleLaunchPhase().

◆ DoAllEffectOnTarget() [1/3]

void Spell::DoAllEffectOnTarget ( GOTargetInfo * target )

protected

{
    if (target->processed)                                  // Check target
        return;
    target->processed = true;                               // Target checked in apply effects procedure
 
    uint32 effectMask = target->effectMask;
    if (!effectMask)
        return;
 
    GameObject* go = m_caster->GetMap()->GetGameObject(target->targetGUID);
    if (!go)
        return;
 
    PrepareScriptHitHandlers();
    CallScriptBeforeHitHandlers(SPELL_MISS_NONE);
 
    for (uint32 effectNumber = 0; effectNumber < MAX_SPELL_EFFECTS; ++effectNumber)
        if (effectMask & (1 << effectNumber))
            HandleEffects(nullptr, nullptr, go, effectNumber, SPELL_EFFECT_HANDLE_HIT_TARGET);
 
    // xinef: inform ai about spellhit
    go->AI()->SpellHit(m_caster, m_spellInfo);
 
    CallScriptOnHitHandlers();
 
    CallScriptAfterHitHandlers();
}

References GameObject::AI(), CallScriptAfterHitHandlers(), CallScriptBeforeHitHandlers(), CallScriptOnHitHandlers(), Spell::GOTargetInfo::effectMask, Map::GetGameObject(), WorldObject::GetMap(), HandleEffects(), m_caster, m_spellInfo, MAX_SPELL_EFFECTS, PrepareScriptHitHandlers(), Spell::GOTargetInfo::processed, SPELL_EFFECT_HANDLE_HIT_TARGET, SPELL_MISS_NONE, GameObjectAI::SpellHit(), and Spell::GOTargetInfo::targetGUID.

◆ DoAllEffectOnTarget() [2/3]

void Spell::DoAllEffectOnTarget ( ItemTargetInfo * target )

protected

{
    uint32 effectMask = target->effectMask;
    if (!target->item || !effectMask)
        return;
 
    PrepareScriptHitHandlers();
    CallScriptBeforeHitHandlers(SPELL_MISS_NONE);
 
    for (uint32 effectNumber = 0; effectNumber < MAX_SPELL_EFFECTS; ++effectNumber)
        if (effectMask & (1 << effectNumber))
            HandleEffects(nullptr, target->item, nullptr, effectNumber, SPELL_EFFECT_HANDLE_HIT_TARGET);
 
    CallScriptOnHitHandlers();
 
    CallScriptAfterHitHandlers();
}

References CallScriptAfterHitHandlers(), CallScriptBeforeHitHandlers(), CallScriptOnHitHandlers(), Spell::ItemTargetInfo::effectMask, HandleEffects(), Spell::ItemTargetInfo::item, MAX_SPELL_EFFECTS, PrepareScriptHitHandlers(), SPELL_EFFECT_HANDLE_HIT_TARGET, and SPELL_MISS_NONE.

◆ DoAllEffectOnTarget() [3/3]

void Spell::DoAllEffectOnTarget ( TargetInfo * target )

protected

Todo:: : check how broad this rule should be

{
    if (!target || target->processed)
        return;
 
    target->processed = true;                               // Target checked in apply effects procedure
 
    // Get mask of effects for target
    uint8 mask = target->effectMask;
 
    Unit* effectUnit = m_caster->GetGUID() == target->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, target->targetGUID);
    if (!effectUnit && !target->targetGUID.IsPlayer()) // only players may be targeted across maps
        return;
 
    if (!effectUnit || m_spellInfo->Id == 45927)
    {
        uint8 farMask = 0;
        // create far target mask
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
            if (m_spellInfo->Effects[i].IsFarUnitTargetEffect())
                if ((1 << i) & mask)
                    farMask |= (1 << i);
 
        if (!farMask)
            return;
        // find unit in world
        // Xinef: FindUnit Access without Map check!!! Intended
        effectUnit = ObjectAccessor::FindPlayer(target->targetGUID);
        if (!effectUnit)
            return;
 
        // do far effects on the unit
        // can't use default call because of threading, do stuff as fast as possible
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
            if (farMask & (1 << i))
                HandleEffects(effectUnit, nullptr, nullptr, i, SPELL_EFFECT_HANDLE_HIT_TARGET);
        return;
    }
 
    if (effectUnit->IsAlive() != target->alive)
        return;
 
    // Absorb delayed projectiles launched before Sanctuary (e.g. Vanish dodging a Frostbolt in flight)
    if (getState() == SPELL_STATE_DELAYED && !m_spellInfo->IsPositive() &&
            (GameTime::GetGameTimeMS().count() - target->timeDelay) <= effectUnit->m_lastSanctuaryTime)
        return;                                             // No missinfo in that case
 
    // Absorb instant hostile spells on application within brief window after Sanctuary
    if (getState() != SPELL_STATE_DELAYED && !m_spellInfo->IsPositive() &&
            effectUnit->m_lastSanctuaryTime &&
            GameTime::GetGameTimeMS().count() <= (effectUnit->m_lastSanctuaryTime + 400))
        return;                                             // No missinfo in that case
 
    // Get original caster (if exist) and calculate damage/healing from him data
    Unit* caster = m_originalCaster ? m_originalCaster : m_caster;
 
    // Skip if m_originalCaster not avaiable
    if (!caster)
        return;
 
    SpellMissInfo missInfo = target->missCondition;
 
    // Need init unitTarget by default unit (can changed in code on reflect)
    // Or on missInfo != SPELL_MISS_NONE unitTarget undefined (but need in trigger subsystem)
    unitTarget = effectUnit;
 
    // Reset damage/healing counter
    m_damage = target->damage;
    m_healing = -target->damage;
 
    m_spellAura = nullptr; // Set aura to null for every target-make sure that pointer is not used for unit without aura applied
 
    if (m_originalCaster && missInfo != SPELL_MISS_EVADE && !m_originalCaster->IsFriendlyTo(effectUnit) && (!m_spellInfo->IsPositive() || m_spellInfo->HasEffect(SPELL_EFFECT_DISPEL)) && (m_spellInfo->HasInitialAggro() || effectUnit->IsEngaged()))
        effectUnit->SetInCombatWith(m_originalCaster);
 
    PrepareScriptHitHandlers();
    CallScriptBeforeHitHandlers(missInfo);
 
    //Spells with this flag cannot trigger if effect is casted on self
    bool canEffectTrigger = !m_spellInfo->HasAttribute(SPELL_ATTR3_SUPPRESS_CASTER_PROCS) && unitTarget->CanProc() && (CanExecuteTriggersOnHit(mask) || missInfo == SPELL_MISS_IMMUNE2);
    bool reflectedSpell = missInfo == SPELL_MISS_REFLECT;
    Unit* reflectionSource = nullptr;
    Unit* spellHitTarget = nullptr;
 
    if (missInfo == SPELL_MISS_NONE)                          // In case spell hit target, do all effect on that target
        spellHitTarget = unitTarget;
    else if (missInfo == SPELL_MISS_REFLECT)                // In case spell reflect from target, do all effect on caster (if hit)
    {
        missInfo = target->reflectResult;
        if (missInfo == SPELL_MISS_NONE)       // If reflected spell hit caster -> do all effect on him
        {
            spellHitTarget = m_caster;
            unitTarget = m_caster;
            reflectionSource = effectUnit;
            if (m_caster->IsCreature())
                m_caster->ToCreature()->LowerPlayerDamageReq(target->damage);
        }
    }
 
    if (spellHitTarget)
    {
        if (reflectionSource)
        {
            m_reflectionTarget = reflectionSource;
            m_reflectionTargetGuid = reflectionSource->GetGUID();
            m_reflectionTargetPosition.Relocate(reflectionSource);
        }
        else
        {
            m_reflectionTarget = nullptr;
            m_reflectionTargetGuid.Clear();
            m_reflectionTargetPosition = Position();
        }
 
        SpellMissInfo missInfo2 = DoSpellHitOnUnit(spellHitTarget, mask, target->scaleAura);
 
        m_reflectionTarget = nullptr;
        m_reflectionTargetGuid.Clear();
        m_reflectionTargetPosition = Position();
        if (missInfo2 != SPELL_MISS_NONE)
        {
            if (missInfo2 != SPELL_MISS_MISS)
                m_caster->SendSpellMiss(spellHitTarget, m_spellInfo->Id, missInfo2);
            m_damage = 0;
            spellHitTarget = nullptr;
 
            // Xinef: if missInfo2 is MISS_EVADE, override base missinfo data
            if (missInfo2 == SPELL_MISS_EVADE)
                missInfo = SPELL_MISS_EVADE;
        }
    }
 
    // Do not take combo points on dodge and miss
    if (missInfo != SPELL_MISS_NONE && m_needComboPoints && m_targets.GetUnitTargetGUID() == target->targetGUID)
    {
        m_needComboPoints = false;
        // Restore spell mods for a miss/dodge/parry Cold Blood
        if (m_caster->IsPlayer() && (missInfo == SPELL_MISS_MISS || missInfo == SPELL_MISS_DODGE || missInfo == SPELL_MISS_PARRY))
            m_caster->ToPlayer()->RestoreSpellMods(this, 14177);
    }
 
    // Fill base trigger info
    uint32 procAttacker = m_procAttacker;
    uint32 procVictim   = m_procVictim;
 
    // Trigger info was not filled in spell::preparedatafortriggersystem - we do it now
    if (canEffectTrigger && !procAttacker && !procVictim)
    {
        bool positive = true;
        if (m_damage > 0)
            positive = false;
        else if (!m_healing)
        {
            for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
                // If at least one effect negative spell is negative hit
                // Xinef: if missInfo is immune state check all effects to properly determine positiveness of spell
                if ((missInfo == SPELL_MISS_IMMUNE2 || (mask & (1 << i))) && !m_spellInfo->IsPositiveEffect(i))
                {
                    positive = false;
                    break;
                }
        }
        switch (m_spellInfo->DmgClass)
        {
            case SPELL_DAMAGE_CLASS_MAGIC:
                if (positive)
                {
                    procAttacker |= PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS;
                    procVictim   |= PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_POS;
                }
                else
                {
                    procAttacker |= PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG;
                    procVictim   |= PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG;
                }
                break;
            case SPELL_DAMAGE_CLASS_NONE:
                if (positive)
                {
                    procAttacker |= PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS;
                    procVictim   |= PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_POS;
                }
                else
                {
                    procAttacker |= PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_NEG;
                    procVictim   |= PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_NEG;
                }
                break;
        }
    }
    CallScriptOnHitHandlers();
 
    // All calculated do it!
    // Do healing and triggers
    if (m_healing > 0)
    {
        bool crit = target->crit;
        uint32 addhealth = m_healing;
 
        if (crit)
            addhealth = Unit::SpellCriticalHealingBonus(caster, m_spellInfo, addhealth, nullptr);
 
        HealInfo healInfo(caster, unitTarget, addhealth, m_spellInfo, m_spellInfo->GetSchoolMask());
 
        // Heal amount before SpellHealingBonusTaken, used by Beacon of Light
        if (target->damageBeforeTakenMods != 0)
        {
            uint32 healBeforeTakenMods = uint32(-target->damageBeforeTakenMods);
            if (crit)
                healBeforeTakenMods = Unit::SpellCriticalHealingBonus(caster, m_spellInfo, healBeforeTakenMods, nullptr);
            healInfo.SetHealBeforeTakenMods(healBeforeTakenMods);
        }
        else
            healInfo.SetHealBeforeTakenMods(addhealth);
 
        // Set hitMask based on crit
        if (crit)
            healInfo.AddHitMask(PROC_HIT_CRITICAL);
        else
            healInfo.AddHitMask(PROC_HIT_NORMAL);
 
        // Xinef: override with forced crit, only visual result
        if (GetSpellValue()->ForcedCritResult)
        {
            crit = true;
            healInfo.AddHitMask(PROC_HIT_CRITICAL);
        }
 
        int32 gain = caster->HealBySpell(healInfo, crit);
        float threat = float(gain) * 0.5f;
        if (caster->IsClass(CLASS_PALADIN))
            threat *= 0.5f;
        unitTarget->GetThreatMgr().ForwardThreatForAssistingMe(caster, threat, m_spellInfo);
        m_healing = gain;
 
        // Xinef: if heal actually healed something, add no overheal flag
        if (m_healing)
            healInfo.AddHitMask(PROC_EX_NO_OVERHEAL);
 
        // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge)
        if (canEffectTrigger)
        {
            uint32 hitMask = m_procEx | healInfo.GetHitMask();
            Unit::ProcSkillsAndAuras(caster, unitTarget, procAttacker, procVictim, hitMask, addhealth, m_attackType, m_spellInfo, m_triggeredByAuraSpell.spellInfo,
                m_triggeredByAuraSpell.effectIndex, this, nullptr, &healInfo);
        }
    }
    // Do damage and triggers
    else if (m_damage > 0)
    {
        caster->SetLastDamagedTargetGuid(unitTarget->GetGUID());
 
        // Fill base damage struct (unitTarget - is real spell target)
        SpellNonMeleeDamage damageInfo(caster, unitTarget, m_spellInfo, m_spellSchoolMask);
 
        // Check damage immunity
        if (unitTarget->IsImmunedToDamage(caster, m_spellInfo))
        {
            m_damage = 0;
 
            // no packet found in sniffs
        }
        else
        {
            // Add bonuses and fill damageInfo struct
            // Dancing Rune Weapon...
            if (m_caster->GetEntry() == 27893)
            {
                if (Unit* owner = m_caster->GetOwner())
                    owner->CalculateSpellDamageTaken(&damageInfo, m_damage, m_spellInfo, m_attackType,  target->crit);
            }
            else
                caster->CalculateSpellDamageTaken(&damageInfo, m_damage, m_spellInfo, m_attackType,  target->crit);
 
            // xinef: override miss info after absorb / block calculations
            if (missInfo == SPELL_MISS_NONE && damageInfo.damage == 0)
            {
                //if (damageInfo.absorb > 0)
                //  missInfo = SPELL_MISS_ABSORB;
                if (damageInfo.blocked)
                    missInfo = SPELL_MISS_BLOCK;
            }
 
            // Xinef: override with forced crit, only visual result
            if (GetSpellValue()->ForcedCritResult)
            {
                damageInfo.HitInfo |= SPELL_HIT_TYPE_CRIT;
            }
 
            Unit::DealDamageMods(damageInfo.target, damageInfo.damage, &damageInfo.absorb);
 
            // xinef: health leech handling
            if (m_spellInfo->HasEffect(SPELL_EFFECT_HEALTH_LEECH))
            {
                uint8 effIndex = EFFECT_0;
                for (; effIndex < MAX_SPELL_EFFECTS; ++effIndex)
                    if (m_spellInfo->Effects[effIndex].Effect == SPELL_EFFECT_HEALTH_LEECH)
                        break;
 
                float healMultiplier = m_spellInfo->Effects[effIndex].CalcValueMultiplier(m_originalCaster, this);
 
                // get max possible damage, don't count overkill for heal
                uint32 healthGain = uint32(-unitTarget->GetHealthGain(-int32(damageInfo.damage)) * healMultiplier);
 
                if (m_caster->IsAlive())
                {
                    healthGain = m_caster->SpellHealingBonusDone(m_caster, m_spellInfo, healthGain, HEAL, effIndex);
                    healthGain = m_caster->SpellHealingBonusTaken(m_caster, m_spellInfo, healthGain, HEAL);
 
                    HealInfo healInfo(m_caster, m_caster, healthGain, m_spellInfo, m_spellInfo->GetSchoolMask());
                    m_caster->HealBySpell(healInfo);
                }
            }
 
            // Send log damage message to client
            caster->SendSpellNonMeleeDamageLog(&damageInfo);
            // Xinef: send info to target about reflect
            if (reflectedSpell)
                effectUnit->SendSpellNonMeleeReflectLog(&damageInfo, effectUnit);
 
            procVictim |= PROC_FLAG_TAKEN_DAMAGE;
 
            caster->DealSpellDamage(&damageInfo, true, this);
 
            // do procs after damage, eg healing effects
            // no need to check if target is alive, done in procdamageandspell
 
            // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge)
            if (canEffectTrigger)
            {
                DamageInfo dmgInfo(damageInfo, SPELL_DIRECT_DAMAGE, m_attackType, missInfo);
                uint32 hitMask = m_procEx | dmgInfo.GetHitMask();
                Unit::ProcSkillsAndAuras(caster, unitTarget, procAttacker, procVictim, hitMask, damageInfo.damage, m_attackType, m_spellInfo, m_triggeredByAuraSpell.spellInfo,
                    m_triggeredByAuraSpell.effectIndex, this, &dmgInfo);
 
                if (caster->IsPlayer() && m_spellInfo->HasAttribute(SPELL_ATTR0_CANCELS_AUTO_ATTACK_COMBAT) == 0 &&
                        m_spellInfo->HasAttribute(SPELL_ATTR4_SUPPRESS_WEAPON_PROCS) == 0 && (m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MELEE || m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_RANGED))
                    caster->ToPlayer()->CastItemCombatSpell(unitTarget, m_attackType, procVictim, dmgInfo.GetHitMask());
            }
 
            m_damage = damageInfo.damage;
        }
    }
    // Passive spell hits/misses or active spells only misses (only triggers)
    else
    {
        // Fill base damage struct (unitTarget - is real spell target)
        SpellNonMeleeDamage damageInfo(caster, unitTarget, m_spellInfo, m_spellSchoolMask);
        // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge)
        if (canEffectTrigger)
        {
            DamageInfo dmgInfo(damageInfo, NODAMAGE, m_attackType, missInfo);
            uint32 hitMask = m_procEx | dmgInfo.GetHitMask();
            Unit::ProcSkillsAndAuras(caster, unitTarget, procAttacker, procVictim, hitMask, 0, m_attackType, m_spellInfo, m_triggeredByAuraSpell.spellInfo,
                m_triggeredByAuraSpell.effectIndex, this, &dmgInfo);
 
            // Xinef: eg. rogue poisons can proc off cheap shot, etc. so this block should be here also
            // Xinef: ofc count only spells that HIT the target, little hack used to fool the system
            if ((dmgInfo.GetHitMask() & (PROC_HIT_NORMAL | PROC_HIT_CRITICAL)) && caster->IsPlayer() && m_spellInfo->HasAttribute(SPELL_ATTR0_CANCELS_AUTO_ATTACK_COMBAT) == 0 &&
                    m_spellInfo->HasAttribute(SPELL_ATTR4_SUPPRESS_WEAPON_PROCS) == 0 && (m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MELEE || m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_RANGED))
                caster->ToPlayer()->CastItemCombatSpell(unitTarget, m_attackType, procVictim | PROC_FLAG_TAKEN_DAMAGE, dmgInfo.GetHitMask());
        }
 
        // Failed Pickpocket, reveal rogue
        if (missInfo == SPELL_MISS_RESIST && m_spellInfo->HasAttribute(SPELL_ATTR0_CU_PICKPOCKET) && unitTarget->IsCreature() && m_caster)
        {
            m_caster->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TALK);
            unitTarget->ToCreature()->EngageWithTarget(m_caster);
        }
    }
 
    if (m_caster)
    {
        if (missInfo != SPELL_MISS_EVADE && !m_caster->IsFriendlyTo(effectUnit) && (!m_spellInfo->IsPositive() || m_spellInfo->HasEffect(SPELL_EFFECT_DISPEL)))
        {
            if (!m_triggeredByAuraSpell.spellInfo || m_damage || (!(m_triggeredByAuraSpell.spellInfo->Effects[m_triggeredByAuraSpell.effectIndex].TriggerSpell == m_spellInfo->Id) && !(m_triggeredByAuraSpell.spellInfo->IsAuraEffectEqual(m_spellInfo))))
                m_caster->AtTargetAttacked(effectUnit, !(m_spellInfo->HasAttribute(SPELL_ATTR1_NO_THREAT) || m_spellInfo->HasAttribute(SPELL_ATTR3_SUPPRESS_TARGET_PROCS)));
 
            // Spells that don't initiate combat shouldn't affect stand state (e.g. Premeditation, Storm Giant/Felreaver Passive)
            if (m_spellInfo->HasInitialAggro() && !effectUnit->IsStandState())
                effectUnit->SetStandState(UNIT_STAND_STATE_STAND);
        }
    }
 
    if (missInfo != SPELL_MISS_EVADE && effectUnit != m_caster && m_caster->IsFriendlyTo(effectUnit) && m_spellInfo->IsPositive() &&
        effectUnit->IsInCombat() && !m_spellInfo->HasAttribute(SPELL_ATTR1_NO_THREAT))
    {
        m_caster->SetInCombatWith(effectUnit);
    }
 
    // Check for SPELL_ATTR7_CAN_CAUSE_INTERRUPT
    if (m_spellInfo->HasAttribute(SPELL_ATTR7_CAN_CAUSE_INTERRUPT) && !effectUnit->IsPlayer())
        caster->CastSpell(effectUnit, SPELL_INTERRUPT_NONPLAYER, true);
 
    if (spellHitTarget)
    {
        //AI functions
        if (spellHitTarget->IsCreature())
        {
            if (spellHitTarget->ToCreature()->IsAIEnabled)
                spellHitTarget->ToCreature()->AI()->SpellHit(m_caster, m_spellInfo);
        }
 
        if (m_caster->IsCreature() && m_caster->ToCreature()->IsAIEnabled)
            m_caster->ToCreature()->AI()->SpellHitTarget(spellHitTarget, m_spellInfo);
 
        // Needs to be called after dealing damage/healing to not remove breaking on damage auras
        DoTriggersOnSpellHit(spellHitTarget, mask);
 
        // if target is fallged for pvp also flag caster if a player
        // xinef: do not flag spells with aura bind sight (no special attribute)
        if (effectUnit->IsPvP() && effectUnit != m_caster && effectUnit->GetOwnerGUID() != m_caster->GetGUID() &&
            m_caster->IsPlayer() && !m_spellInfo->HasAttribute(SPELL_ATTR0_CU_NO_PVP_FLAG))
        {
            m_caster->ToPlayer()->UpdatePvP(true);
        }
 
        CallScriptAfterHitHandlers();
    }
}

References SpellNonMeleeDamage::absorb, HealInfo::AddHitMask(), Creature::AI(), TargetInfo::alive, Unit::AtTargetAttacked(), AURA_INTERRUPT_FLAG_TALK, SpellNonMeleeDamage::blocked, Unit::CalculateSpellDamageTaken(), CallScriptAfterHitHandlers(), CallScriptBeforeHitHandlers(), CallScriptOnHitHandlers(), CanExecuteTriggersOnHit(), Unit::CanProc(), Player::CastItemCombatSpell(), Unit::CastSpell(), CLASS_PALADIN, ObjectGuid::Clear(), TargetInfo::crit, SpellNonMeleeDamage::damage, TargetInfo::damage, TargetInfo::damageBeforeTakenMods, Unit::DealDamageMods(), Unit::DealSpellDamage(), SpellInfo::DmgClass, DoSpellHitOnUnit(), DoTriggersOnSpellHit(), EFFECT_0, TriggeredByAuraSpellData::effectIndex, TargetInfo::effectMask, SpellInfo::Effects, Unit::EngageWithTarget(), ObjectAccessor::FindPlayer(), ThreatManager::ForwardThreatForAssistingMe(), Object::GetEntry(), GameTime::GetGameTimeMS(), Object::GetGUID(), Unit::GetHealthGain(), DamageInfo::GetHitMask(), HealInfo::GetHitMask(), Unit::GetOwner(), Unit::GetOwnerGUID(), SpellInfo::GetSchoolMask(), GetSpellValue(), getState(), Unit::GetThreatMgr(), ObjectAccessor::GetUnit(), SpellCastTargets::GetUnitTargetGUID(), HandleEffects(), SpellInfo::HasAttribute(), SpellInfo::HasEffect(), SpellInfo::HasInitialAggro(), HEAL, Unit::HealBySpell(), SpellNonMeleeDamage::HitInfo, SpellInfo::Id, Unit::IsAIEnabled, Unit::IsAlive(), SpellInfo::IsAuraEffectEqual(), Unit::IsClass(), Object::IsCreature(), Unit::IsEngaged(), Unit::IsFriendlyTo(), Unit::IsImmunedToDamage(), Unit::IsInCombat(), Object::IsPlayer(), ObjectGuid::IsPlayer(), SpellInfo::IsPositive(), SpellInfo::IsPositiveEffect(), Unit::IsPvP(), Unit::IsStandState(), Creature::LowerPlayerDamageReq(), m_attackType, m_caster, m_damage, m_healing, Unit::m_lastSanctuaryTime, m_needComboPoints, m_originalCaster, m_procAttacker, m_procEx, m_procVictim, m_reflectionTarget, m_reflectionTargetGuid, m_reflectionTargetPosition, m_spellAura, m_spellInfo, m_spellSchoolMask, m_targets, m_triggeredByAuraSpell, MAX_SPELL_EFFECTS, TargetInfo::missCondition, NODAMAGE, PrepareScriptHitHandlers(), PROC_EX_NO_OVERHEAL, PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS, PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_NEG, PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS, PROC_FLAG_TAKEN_DAMAGE, PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG, PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_POS, PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_NEG, PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_POS, PROC_HIT_CRITICAL, PROC_HIT_NORMAL, TargetInfo::processed, Unit::ProcSkillsAndAuras(), TargetInfo::reflectResult, Position::Relocate(), Unit::RemoveAurasWithInterruptFlags(), Player::RestoreSpellMods(), TargetInfo::scaleAura, Unit::SendSpellMiss(), Unit::SendSpellNonMeleeDamageLog(), Unit::SendSpellNonMeleeReflectLog(), HealInfo::SetHealBeforeTakenMods(), Unit::SetInCombatWith(), Unit::SetLastDamagedTargetGuid(), Unit::SetStandState(), SPELL_ATTR0_CANCELS_AUTO_ATTACK_COMBAT, SPELL_ATTR0_CU_NO_PVP_FLAG, SPELL_ATTR0_CU_PICKPOCKET, SPELL_ATTR1_NO_THREAT, SPELL_ATTR3_SUPPRESS_CASTER_PROCS, SPELL_ATTR3_SUPPRESS_TARGET_PROCS, SPELL_ATTR4_SUPPRESS_WEAPON_PROCS, SPELL_ATTR7_CAN_CAUSE_INTERRUPT, SPELL_DAMAGE_CLASS_MAGIC, SPELL_DAMAGE_CLASS_MELEE, SPELL_DAMAGE_CLASS_NONE, SPELL_DAMAGE_CLASS_RANGED, SPELL_DIRECT_DAMAGE, SPELL_EFFECT_DISPEL, SPELL_EFFECT_HANDLE_HIT_TARGET, SPELL_EFFECT_HEALTH_LEECH, SPELL_HIT_TYPE_CRIT, SPELL_INTERRUPT_NONPLAYER, SPELL_MISS_BLOCK, SPELL_MISS_DODGE, SPELL_MISS_EVADE, SPELL_MISS_IMMUNE2, SPELL_MISS_MISS, SPELL_MISS_NONE, SPELL_MISS_PARRY, SPELL_MISS_REFLECT, SPELL_MISS_RESIST, SPELL_STATE_DELAYED, Unit::SpellCriticalHealingBonus(), Unit::SpellHealingBonusDone(), Unit::SpellHealingBonusTaken(), CreatureAI::SpellHit(), CreatureAI::SpellHitTarget(), TriggeredByAuraSpellData::spellInfo, SpellNonMeleeDamage::target, TargetInfo::targetGUID, TargetInfo::timeDelay, Object::ToCreature(), Object::ToPlayer(), UNIT_STAND_STATE_STAND, unitTarget, and Player::UpdatePvP().

Referenced by _handle_immediate_phase(), handle_delayed(), and handle_immediate().

◆ DoCreateItem()

void Spell::DoCreateItem	(	uint8	effIndex,
		uint32	itemId
	)

{
    if (!unitTarget)
        return;
 
    Player* player = unitTarget->ToPlayer();
    if (!player)
    {
        return;
    }
 
    uint32 newitemid = itemId;
 
    ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(newitemid);
    if (!pProto)
    {
        player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, nullptr, nullptr);
        return;
    }
 
    uint32 addNumber = damage;
 
    // bg reward have some special in code work
    bool SelfCast = true;
    switch (m_spellInfo->Id)
    {
        case SPELL_AV_MARK_WINNER:
        case SPELL_AV_MARK_LOSER:
        case SPELL_WS_MARK_WINNER:
        case SPELL_WS_MARK_LOSER:
        case SPELL_WS_MARK_TIE:
        case SPELL_AB_MARK_WINNER:
        case SPELL_AB_MARK_LOSER:
            SelfCast = true;
            break;
        case SPELL_WG_MARK_WINNER:
            if (player->HasAura(55629 /*SPELL_LIEUTENANT*/))
                addNumber = 3;
            else if (player->HasAura(33280 /*SPELL_CORPORAL*/))
                addNumber = 2;
            else
                addNumber = 1;
            SelfCast = true;
            break;
    }
 
    if (addNumber < 1)
        addNumber = 1;
    if (addNumber > pProto->GetMaxStackSize())
        addNumber = pProto->GetMaxStackSize();
 
    /* == gem perfection handling == */
 
    // the chance of getting a perfect result
    float perfectCreateChance = 0.0f;
 
    // the resulting perfect item if successful
    uint32 perfectItemType = itemId;
 
    // get perfection capability and chance
    if (CanCreatePerfectItem(player, m_spellInfo->Id, perfectCreateChance, perfectItemType))
        if (roll_chance_f(perfectCreateChance)) // if the roll succeeds...
            newitemid = perfectItemType;        // the perfect item replaces the regular one
 
    /* == gem perfection handling over == */
 
    /* == profession specialization handling == */
 
    // init items_count to 1, since 1 item will be created regardless of specialization
    int32 itemsCount = 1;
    float additionalCreateChance = 0.0f;
    int32 additionalMaxNum = 0;
    // get the chance and maximum number for creating extra items
    if (canCreateExtraItems(player, m_spellInfo->Id, additionalCreateChance, additionalMaxNum))
    {
        // roll with this chance till we roll not to create or we create the max num
        while (roll_chance_f(additionalCreateChance) && itemsCount <= additionalMaxNum)
            ++itemsCount;
    }
 
    // really will be created more items
    addNumber *= itemsCount;
 
    /* == profession specialization handling over == */
 
    // can the player store the new item?
    ItemPosCountVec dest;
    uint32 no_space = 0;
    InventoryResult msg = player->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, newitemid, addNumber, &no_space);
    if (msg != EQUIP_ERR_OK)
    {
        // convert to possible store amount
        if (msg == EQUIP_ERR_INVENTORY_FULL || msg == EQUIP_ERR_CANT_CARRY_MORE_OF_THIS)
            addNumber -= no_space;
        else
        {
            // if not created by another reason from full inventory or unique items amount limitation
            player->SendEquipError(msg, nullptr, nullptr, newitemid);
            return;
        }
    }
 
    if (addNumber)
    {
        // create the new item and store it
        Item* pItem = player->StoreNewItem(dest, newitemid, true);
 
        // was it successful? return error if not
        if (!pItem)
        {
            player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, nullptr, nullptr);
            return;
        }
 
        // set the "Crafted by ..." property of the item
        if (m_caster->IsPlayer() && pItem->GetTemplate()->HasSignature())
            pItem->SetGuidValue(ITEM_FIELD_CREATOR, player->GetGUID());
 
        // send info to the client
        player->SendNewItem(pItem, addNumber, true, SelfCast);
 
        sScriptMgr->OnPlayerCreateItem(player, pItem, addNumber);
 
        // we succeeded in creating at least one item, so a levelup is possible
        if (SelfCast)
            player->UpdateCraftSkill(m_spellInfo->Id);
    }
}

References canCreateExtraItems(), CanCreatePerfectItem(), Player::CanStoreNewItem(), damage, EQUIP_ERR_CANT_CARRY_MORE_OF_THIS, EQUIP_ERR_INVENTORY_FULL, EQUIP_ERR_ITEM_NOT_FOUND, EQUIP_ERR_OK, Object::GetGUID(), ItemTemplate::GetMaxStackSize(), Item::GetTemplate(), Unit::HasAura(), ItemTemplate::HasSignature(), SpellInfo::Id, Object::IsPlayer(), ITEM_FIELD_CREATOR, m_caster, m_spellInfo, NULL_BAG, NULL_SLOT, roll_chance_f(), Player::SendEquipError(), Player::SendNewItem(), Object::SetGuidValue(), sObjectMgr, SPELL_AB_MARK_LOSER, SPELL_AB_MARK_WINNER, SPELL_AV_MARK_LOSER, SPELL_AV_MARK_WINNER, SPELL_WG_MARK_WINNER, SPELL_WS_MARK_LOSER, SPELL_WS_MARK_TIE, SPELL_WS_MARK_WINNER, sScriptMgr, Player::StoreNewItem(), Object::ToPlayer(), unitTarget, and Player::UpdateCraftSkill().

Referenced by SpellScript::CreateItem(), EffectCreateItem(), EffectCreateItem2(), and EffectEnchantItemPerm().

◆ DoSpellHitOnUnit()

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

protected

Todo:: : this cause soul transfer bugged

{
    if (!unit || !effectMask)
        return SPELL_MISS_EVADE;
 
    // For delayed spells immunity may be applied between missile launch and hit - check immunity for that case
    if (m_spellInfo->Speed && ((m_damage > 0 && unit->IsImmunedToDamage(m_caster, m_spellInfo)) || unit->IsImmunedToSchool(this) || unit->IsImmunedToSpell(m_spellInfo, this)))
    {
        return SPELL_MISS_IMMUNE;
    }
 
    // disable effects to which unit is immune
    SpellMissInfo returnVal = SPELL_MISS_IMMUNE;
    for (uint32 effectNumber = 0; effectNumber < MAX_SPELL_EFFECTS; ++effectNumber)
    {
        if (effectMask & (1 << effectNumber))
        {
            if (unit->IsImmunedToSpellEffect(m_spellInfo, effectNumber, m_caster))
                effectMask &= ~(1 << effectNumber);
            // Xinef: Buggs out polymorph
            // Xinef: And this is checked in MagicSpellHitResult, why we check resistance twice?
            // Xinef: And why we check every spell effect basing on rand and generic dispel info? some effects will be appliend and some wont?
            /*else if (m_spellInfo->Effects[effectNumber].IsAura() && !m_spellInfo->IsPositiveEffect(effectNumber))
            {
                int32 debuff_resist_chance = unit->GetMaxPositiveAuraModifierByMiscValue(SPELL_AURA_MOD_DEBUFF_RESISTANCE, int32(m_spellInfo->Dispel));
                debuff_resist_chance += unit->GetMaxNegativeAuraModifierByMiscValue(SPELL_AURA_MOD_DEBUFF_RESISTANCE, int32(m_spellInfo->Dispel));
 
                if (debuff_resist_chance > 0)
                    if (irand(0,10000) <= (debuff_resist_chance * 100))
                    {
                        effectMask &= ~(1 << effectNumber);
                        returnVal = SPELL_MISS_RESIST;
                    }
            }*/
        }
    }
    if (!effectMask)
        return returnVal;
 
    if (unit->IsPlayer())
    {
        unit->ToPlayer()->StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_SPELL_TARGET, m_spellInfo->Id);
        unit->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, m_spellInfo->Id, 0, m_caster);
        unit->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2, m_spellInfo->Id, 0, m_caster);
    }
 
    if (m_caster->IsPlayer())
    {
        m_caster->ToPlayer()->StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_SPELL_CASTER, m_spellInfo->Id);
        m_caster->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2, m_spellInfo->Id, 0, unit);
    }
 
    if (m_caster != unit)
    {
        // Recheck  UNIT_FLAG_NON_ATTACKABLE for delayed spells
        // Xinef: Also check evade state
        if (m_spellInfo->Speed > 0.0f)
        {
            if (unit->IsCreature() && unit->ToCreature()->IsInEvadeMode())
                return SPELL_MISS_EVADE;
 
            if (unit->HasUnitFlag(UNIT_FLAG_NON_ATTACKABLE) && unit->GetCharmerOrOwnerGUID() != m_caster->GetGUID())
                return SPELL_MISS_EVADE;
        }
 
        if (m_caster->_IsValidAttackTarget(unit, m_spellInfo) && /*Intervene Trigger*/ m_spellInfo->Id != 59667)
        {
            unit->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_HITBYSPELL);
        }
        else if (m_caster->IsFriendlyTo(unit))
        {
            // for delayed spells ignore negative spells (after duel end) for friendly targets
            if (!IsTriggered() && m_spellInfo->Speed > 0.0f && unit->IsPlayer() && !m_spellInfo->IsPositive())
                return SPELL_MISS_EVADE;
 
            // assisting case, healing and resurrection
            if (unit->HasUnitState(UNIT_STATE_ATTACK_PLAYER))
            {
                m_caster->SetContestedPvP();
                if (m_caster->IsPlayer() && !m_spellInfo->HasAttribute(SPELL_ATTR0_CU_NO_PVP_FLAG))
                    m_caster->ToPlayer()->UpdatePvP(true);
            }
 
            // xinef: triggered spells should not prolong combat
            if (m_originalCaster && unit->IsInCombat() && !m_spellInfo->HasAttribute(SPELL_ATTR3_SUPPRESS_TARGET_PROCS) && !m_triggeredByAuraSpell)
            {
                if (m_originalCaster->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED))
                    m_originalCaster->GetCombatManager().InheritCombatStatesFrom(unit);
                unit->GetThreatMgr().ForwardThreatForAssistingMe(m_originalCaster, 0.0f, nullptr, true);
            }
        }
    }
 
    uint8 aura_effmask = 0;
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (effectMask & (1 << i) && m_spellInfo->Effects[i].IsUnitOwnedAuraEffect())
            aura_effmask |= 1 << i;
 
    Unit* originalCaster = GetOriginalCaster();
    if (!originalCaster)
        originalCaster = m_caster;
 
    // Get Data Needed for Diminishing Returns, some effects may have multiple auras, so this must be done on spell hit, not aura add
    // Xinef: Do not increase diminishing level for self cast
    m_diminishGroup = GetDiminishingReturnsGroupForSpell(m_spellInfo, m_triggeredByAuraSpell.spellInfo);
    // xinef: do not increase diminish level for bosses (eg. Void Reaver silence is never diminished)
    if (((m_spellFlags & SPELL_FLAG_REFLECTED) && !(unit->HasReflectSpellsAura())) || (aura_effmask && m_diminishGroup && unit != m_caster && (!m_caster->IsCreature() || !m_caster->ToCreature()->isWorldBoss())))
    {
        m_diminishLevel = unit->GetDiminishing(m_diminishGroup);
        DiminishingReturnsType type = GetDiminishingReturnsGroupType(m_diminishGroup);
 
        uint32 flagsExtra = unit->IsCreature() ? unit->ToCreature()->GetCreatureTemplate()->flags_extra : 0;
 
        // Increase Diminishing on unit, current informations for actually casts will use values above
        if ((type == DRTYPE_PLAYER && (unit->IsCharmedOwnedByPlayerOrPlayer() || flagsExtra & CREATURE_FLAG_EXTRA_ALL_DIMINISH ||
            (m_diminishGroup == DIMINISHING_TAUNT && (flagsExtra & CREATURE_FLAG_EXTRA_OBEYS_TAUNT_DIMINISHING_RETURNS)))) || type == DRTYPE_ALL)
        {
            // Do not apply diminish return if caster is NPC
            if (m_caster->IsCharmedOwnedByPlayerOrPlayer())
            {
                unit->IncrDiminishing(m_diminishGroup);
            }
        }
    }
 
    if (m_caster != unit && m_caster->IsHostileTo(unit) && !m_spellInfo->IsPositive() && !m_triggeredByAuraSpell && !m_spellInfo->HasAttribute(SPELL_ATTR0_CU_DONT_BREAK_STEALTH))
        unit->RemoveAurasByType(SPELL_AURA_MOD_STEALTH);
 
    if (aura_effmask)
    {
        // Select rank for aura with level requirements only in specific cases
        // Unit has to be target only of aura effect, both caster and target have to be players, target has to be other than unit target
        SpellInfo const* aurSpellInfo = m_spellInfo;
        int32 basePoints[3];
        if (scaleAura)
        {
            aurSpellInfo = m_spellInfo->GetAuraRankForLevel(unitTarget->GetLevel());
            ASSERT(aurSpellInfo);
            for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
            {
                basePoints[i] = aurSpellInfo->Effects[i].BasePoints;
                if (m_spellInfo->Effects[i].Effect != aurSpellInfo->Effects[i].Effect)
                {
                    aurSpellInfo = m_spellInfo;
                    break;
                }
            }
        }
 
        if (m_originalCaster)
        {
            bool refresh = false;
            bool refreshPeriodic = m_spellInfo->StackAmount < 2 && !HasTriggeredCastFlag(TRIGGERED_NO_PERIODIC_RESET);
            m_spellAura = Aura::TryRefreshStackOrCreate(aurSpellInfo, effectMask, unit, m_originalCaster,
                          (aurSpellInfo == m_spellInfo) ? &m_spellValue->EffectBasePoints[0] : &basePoints[0], m_CastItem, ObjectGuid::Empty, &refresh, refreshPeriodic);
 
            // xinef: if aura was not refreshed, add proc ex
            if (!refresh)
                m_procEx |= PROC_EX_NO_AURA_REFRESH;
 
            if (m_spellAura)
            {
                // Set aura stack amount to desired value
                if (m_spellValue->AuraStackAmount > 1)
                {
                    if (!refresh)
                        m_spellAura->SetStackAmount(m_spellValue->AuraStackAmount);
                    else
                        m_spellAura->ModStackAmount(m_spellValue->AuraStackAmount);
                }
 
                // Now Reduce spell duration using data received at spell hit
                int32 duration = m_spellAura->GetMaxDuration();
                int32 limitduration = GetDiminishingReturnsLimitDuration(m_diminishGroup, aurSpellInfo);
 
                // Xinef: if unit == caster - test versus original unit if available
                float diminishMod = 1.0f;
                if (unit == m_caster && m_targets.GetUnitTarget())
                    diminishMod = m_targets.GetUnitTarget()->ApplyDiminishingToDuration(m_diminishGroup, duration, m_originalCaster, m_diminishLevel, limitduration);
                else
                    diminishMod = unit->ApplyDiminishingToDuration(m_diminishGroup, duration, m_originalCaster, m_diminishLevel, limitduration);
 
                // unit is immune to aura if it was diminished to 0 duration
                if (diminishMod == 0.0f)
                {
                    m_spellAura->Remove();
                    if (m_diminishGroup == DIMINISHING_TAUNT)
                        return SPELL_MISS_IMMUNE;
                    bool found = false;
                    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
                        if (effectMask & (1 << i) && m_spellInfo->Effects[i].Effect != SPELL_EFFECT_APPLY_AURA)
                            found = true;
                    if (!found)
                        return SPELL_MISS_IMMUNE;
                }
                else
                {
                    ((UnitAura*)m_spellAura)->SetDiminishGroup(m_diminishGroup);
 
                    bool positive = m_spellAura->GetSpellInfo()->IsPositive();
                    if (AuraApplication* aurApp = m_spellAura->GetApplicationOfTarget(m_originalCaster->GetGUID()))
                        positive = aurApp->IsPositive();
 
                    duration = m_originalCaster->ModSpellDuration(aurSpellInfo, unit, duration, positive, effectMask);
 
                    // xinef: haste affects duration of those spells twice
                    if (m_originalCaster->HasAuraTypeWithAffectMask(SPELL_AURA_PERIODIC_HASTE, aurSpellInfo) || m_spellInfo->HasAttribute(SPELL_ATTR5_SPELL_HASTE_AFFECTS_PERIODIC))
                        duration = int32(duration * m_originalCaster->GetFloatValue(UNIT_MOD_CAST_SPEED));
 
                    if (m_spellValue->AuraDuration != 0)
                    {
                        if (m_spellAura->GetMaxDuration() != -1)
                        {
                            m_spellAura->SetMaxDuration(m_spellValue->AuraDuration);
                        }
 
                        m_spellAura->SetDuration(m_spellValue->AuraDuration);
                    }
                    else if (duration != m_spellAura->GetMaxDuration())
                    {
                        m_spellAura->SetMaxDuration(duration);
                        m_spellAura->SetDuration(duration);
                    }
 
                    // xinef: apply relic cooldown, imo best place to add this
                    if (m_CastItem && m_CastItem->GetTemplate()->InventoryType == INVTYPE_RELIC && m_triggeredByAuraSpell)
                        m_caster->AddSpellCooldown(SPELL_RELIC_COOLDOWN, m_CastItem->GetEntry(), duration);
 
                    m_spellAura->SetTriggeredByAuraSpellInfo(m_triggeredByAuraSpell.spellInfo);
                    m_spellAura->_RegisterForTargets();
                }
            }
        }
    }
 
    int8 sanct_effect = -1;
 
    for (uint32 effectNumber = 0; effectNumber < MAX_SPELL_EFFECTS; ++effectNumber)
    {
        // handle sanctuary effects after aura apply!
        if (m_spellInfo->Effects[effectNumber].Effect == SPELL_EFFECT_SANCTUARY)
        {
            sanct_effect = effectNumber;
            continue;
        }
 
        if (effectMask & (1 << effectNumber))
            HandleEffects(unit, nullptr, nullptr, effectNumber, SPELL_EFFECT_HANDLE_HIT_TARGET);
    }
 
    if (sanct_effect >= 0 && (effectMask & (1 << sanct_effect)))
        HandleEffects(unit, nullptr, nullptr, sanct_effect, SPELL_EFFECT_HANDLE_HIT_TARGET);
 
    return SPELL_MISS_NONE;
}

References Unit::_IsValidAttackTarget(), Aura::_RegisterForTargets(), ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2, ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2, ACHIEVEMENT_TIMED_TYPE_SPELL_CASTER, ACHIEVEMENT_TIMED_TYPE_SPELL_TARGET, Unit::AddSpellCooldown(), Unit::ApplyDiminishingToDuration(), ASSERT, AURA_INTERRUPT_FLAG_HITBYSPELL, SpellValue::AuraDuration, SpellValue::AuraStackAmount, CREATURE_FLAG_EXTRA_ALL_DIMINISH, CREATURE_FLAG_EXTRA_OBEYS_TAUNT_DIMINISHING_RETURNS, DIMINISHING_TAUNT, DRTYPE_ALL, DRTYPE_PLAYER, SpellValue::EffectBasePoints, SpellInfo::Effects, ObjectGuid::Empty, CreatureTemplate::flags_extra, ThreatManager::ForwardThreatForAssistingMe(), Aura::GetApplicationOfTarget(), SpellInfo::GetAuraRankForLevel(), Unit::GetCharmerOrOwnerGUID(), Unit::GetCombatManager(), Creature::GetCreatureTemplate(), Unit::GetDiminishing(), GetDiminishingReturnsGroupForSpell(), GetDiminishingReturnsGroupType(), GetDiminishingReturnsLimitDuration(), Object::GetEntry(), Object::GetFloatValue(), Object::GetGUID(), Unit::GetLevel(), Aura::GetMaxDuration(), GetOriginalCaster(), Aura::GetSpellInfo(), Item::GetTemplate(), Unit::GetThreatMgr(), SpellCastTargets::GetUnitTarget(), HandleEffects(), SpellInfo::HasAttribute(), Unit::HasAuraTypeWithAffectMask(), Unit::HasReflectSpellsAura(), HasTriggeredCastFlag(), Unit::HasUnitFlag(), Unit::HasUnitState(), SpellInfo::Id, Unit::IncrDiminishing(), CombatManager::InheritCombatStatesFrom(), ItemTemplate::InventoryType, INVTYPE_RELIC, Unit::IsCharmedOwnedByPlayerOrPlayer(), Object::IsCreature(), Unit::IsFriendlyTo(), Unit::IsHostileTo(), Unit::IsImmunedToDamage(), Unit::IsImmunedToSchool(), Unit::IsImmunedToSpell(), Unit::IsImmunedToSpellEffect(), Unit::IsInCombat(), Creature::IsInEvadeMode(), Object::IsPlayer(), SpellInfo::IsPositive(), IsTriggered(), Creature::isWorldBoss(), m_caster, m_CastItem, m_damage, m_diminishGroup, m_diminishLevel, m_originalCaster, m_procEx, m_spellAura, m_spellFlags, m_spellInfo, m_spellValue, m_targets, m_triggeredByAuraSpell, MAX_SPELL_EFFECTS, Unit::ModSpellDuration(), Aura::ModStackAmount(), PROC_EX_NO_AURA_REFRESH, Aura::Remove(), Unit::RemoveAurasByType(), Unit::RemoveAurasWithInterruptFlags(), Unit::SetContestedPvP(), Aura::SetDuration(), Aura::SetMaxDuration(), Aura::SetStackAmount(), Aura::SetTriggeredByAuraSpellInfo(), SpellInfo::Speed, SPELL_ATTR0_CU_DONT_BREAK_STEALTH, SPELL_ATTR0_CU_NO_PVP_FLAG, SPELL_ATTR3_SUPPRESS_TARGET_PROCS, SPELL_ATTR5_SPELL_HASTE_AFFECTS_PERIODIC, SPELL_AURA_MOD_STEALTH, SPELL_AURA_PERIODIC_HASTE, SPELL_EFFECT_APPLY_AURA, SPELL_EFFECT_HANDLE_HIT_TARGET, SPELL_EFFECT_SANCTUARY, SPELL_FLAG_REFLECTED, SPELL_MISS_EVADE, SPELL_MISS_IMMUNE, SPELL_MISS_NONE, SPELL_RELIC_COOLDOWN, TriggeredByAuraSpellData::spellInfo, SpellInfo::StackAmount, Player::StartTimedAchievement(), Object::ToCreature(), Object::ToPlayer(), TRIGGERED_NO_PERIODIC_RESET, Aura::TryRefreshStackOrCreate(), UNIT_FLAG_NON_ATTACKABLE, UNIT_FLAG_PLAYER_CONTROLLED, UNIT_MOD_CAST_SPEED, UNIT_STATE_ATTACK_PLAYER, unitTarget, Player::UpdateAchievementCriteria(), and Player::UpdatePvP().

Referenced by DoAllEffectOnTarget().

◆ DoTriggersOnSpellHit()

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

protected

Todo:: : move this code to scripts

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

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

References Unit::AddAura(), CanExecuteTriggersOnHit(), Unit::CastSpell(), Unit::GetAura(), Aura::GetDuration(), Object::GetGUID(), SpellInfo::Id, LOG_DEBUG, m_caster, m_hitTriggerSpells, m_preCastSpell, m_spellInfo, Unit::RemoveAurasDueToSpell(), roll_chance_i(), SPELL_LINK_HIT, and sSpellMgr.

Referenced by DoAllEffectOnTarget().

◆ EffectActivateObject()

void Spell::EffectActivateObject ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!gameObjTarget)
        return;
 
    GameObjectActions action = GameObjectActions(m_spellInfo->Effects[effIndex].MiscValue);
    switch (action)
    {
        case GameObjectActions::AnimateCustom0:
        case GameObjectActions::AnimateCustom1:
        case GameObjectActions::AnimateCustom2:
        case GameObjectActions::AnimateCustom3:
            gameObjTarget->SendCustomAnim(uint32(action) - uint32(GameObjectActions::AnimateCustom0));
            break;
        case GameObjectActions::Disturb: // What's the difference with Open?
        case GameObjectActions::Open:
            if (Unit* unitCaster = m_caster->ToUnit())
                gameObjTarget->Use(unitCaster);
            break;
        case GameObjectActions::OpenAndUnlock:
            if (Unit* unitCaster = m_caster->ToUnit())
                gameObjTarget->UseDoorOrButton(0, false, unitCaster);
            [[fallthrough]];
        case GameObjectActions::Unlock:
        case GameObjectActions::Lock:
            gameObjTarget->ApplyModFlag(GAMEOBJECT_FLAGS, GO_FLAG_LOCKED, action == GameObjectActions::Lock);
            break;
        case GameObjectActions::Close:
        case GameObjectActions::Rebuild:
            gameObjTarget->ResetDoorOrButton();
            break;
        case GameObjectActions::Despawn:
            gameObjTarget->DespawnOrUnsummon();
            break;
        case GameObjectActions::MakeInert:
        case GameObjectActions::MakeActive:
            gameObjTarget->ApplyModFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE, action == GameObjectActions::MakeInert);
            break;
        case GameObjectActions::CloseAndLock:
            gameObjTarget->ResetDoorOrButton();
            gameObjTarget->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_LOCKED);
            break;
        case GameObjectActions::Destroy:
            if (Unit* unitCaster = m_caster->ToUnit())
                gameObjTarget->UseDoorOrButton(0, true, unitCaster);
            break;
        case GameObjectActions::UseArtKit0:
        case GameObjectActions::UseArtKit1:
        case GameObjectActions::UseArtKit2:
        case GameObjectActions::UseArtKit3:
        {
            GameObjectTemplateAddon const* templateAddon = gameObjTarget->GetTemplateAddon();
 
            uint32 artKitIndex = uint32(action) - uint32(GameObjectActions::UseArtKit0);
 
            uint32 artKitValue = 0;
            if (templateAddon)
                artKitValue = templateAddon->artKits[artKitIndex];
 
            if (artKitValue == 0)
                LOG_ERROR("sql.sql", "GameObject {} hit by spell {} needs `artkit{}` in `gameobject_template_addon`", gameObjTarget->GetEntry(), m_spellInfo->Id, artKitIndex);
            else
                gameObjTarget->SetGoArtKit(artKitValue);
 
            break;
        }
        case GameObjectActions::None:
            LOG_FATAL("spell", "Spell {} has action type NONE in effect {}", m_spellInfo->Id, int32(effIndex));
            break;
        default:
            LOG_ERROR("spell", "Spell {} has unhandled action {} in effect {}", m_spellInfo->Id, int32(action), int32(effIndex));
            break;
    }
}

References AnimateCustom0, AnimateCustom1, AnimateCustom2, AnimateCustom3, Object::ApplyModFlag(), GameObjectTemplateAddon::artKits, Close, CloseAndLock, Despawn, GameObject::DespawnOrUnsummon(), Destroy, Disturb, effectHandleMode, SpellInfo::Effects, GAMEOBJECT_FLAGS, gameObjTarget, Object::GetEntry(), GameObject::GetTemplateAddon(), GO_FLAG_LOCKED, GO_FLAG_NOT_SELECTABLE, SpellInfo::Id, Lock, LOG_ERROR, LOG_FATAL, m_caster, m_spellInfo, MakeActive, MakeInert, None, Open, OpenAndUnlock, Rebuild, GameObject::ResetDoorOrButton(), GameObject::SendCustomAnim(), Object::SetFlag(), GameObject::SetGoArtKit(), SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToUnit(), Unlock, GameObject::Use(), UseArtKit0, UseArtKit1, UseArtKit2, UseArtKit3, and GameObject::UseDoorOrButton().

◆ EffectActivateRune()

void Spell::EffectActivateRune ( SpellEffIndex effIndex )

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

References Unit::CastSpell(), CLASS_CONTEXT_ABILITY, CLASS_DEATH_KNIGHT, damage, effectHandleMode, SpellInfo::Effects, Player::GetBaseRune(), Player::GetCurrentRune(), Player::GetRuneCooldown(), Player::GetRunesState(), SpellInfo::Id, Player::IsClass(), Unit::IsInCombat(), Object::IsPlayer(), m_caster, m_runesState, m_spellInfo, MAX_RUNES, RUNE_DEATH, RUNE_FROST, Player::SetGracePeriod(), Player::SetRuneCooldown(), SPELL_EFFECT_HANDLE_LAUNCH, and Object::ToPlayer().

◆ EffectActivateSpec()

void Spell::EffectActivateSpec ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    if (Player* player = unitTarget->ToPlayer())
    {
        player->ActivateSpec(damage - 1); // damage is 1 or 2, spec is 0 or 1
    }
}

References damage, effectHandleMode, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectAddComboPoints()

void Spell::EffectAddComboPoints ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
    {
        return;
    }
 
    if (!unitTarget || damage <= 0)
    {
        return;
    }
 
    AddComboPointGain(unitTarget, damage);
}

References AddComboPointGain(), damage, effectHandleMode, SPELL_EFFECT_HANDLE_HIT_TARGET, and unitTarget.

◆ EffectAddExtraAttacks()

void Spell::EffectAddExtraAttacks ( SpellEffIndex effIndex )

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

References Unit::AddExtraAttacks(), damage, effectHandleMode, ExecuteLogEffectExtraAttacks(), Unit::IsAlive(), SPELL_EFFECT_HANDLE_HIT_TARGET, and unitTarget.

◆ EffectAddFarsight()

void Spell::EffectAddFarsight ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
        return;
 
    if (!m_caster->IsPlayer())
        return;
 
    float radius = m_spellInfo->Effects[effIndex].CalcRadius();
    int32 duration = m_spellInfo->GetDuration();
    // Caster not in world, might be spell triggered from aura removal
    if (!m_caster->IsInWorld())
        return;
 
    // Remove old farsight if exist
    bool updateViewerVisibility = m_caster->RemoveDynObject(m_spellInfo->Id);
 
    DynamicObject* dynObj = new DynamicObject();
    if (!dynObj->CreateDynamicObject(m_caster->GetMap()->GenerateLowGuid<HighGuid::DynamicObject>(), m_caster, m_spellInfo->Id, *destTarget, radius, DYNAMIC_OBJECT_FARSIGHT_FOCUS))
    {
        delete dynObj;
        return;
    }
 
    dynObj->SetDuration(duration);
    dynObj->SetCasterViewpoint(updateViewerVisibility);
}

References DynamicObject::CreateDynamicObject(), destTarget, DYNAMIC_OBJECT_FARSIGHT_FOCUS, DynamicObject, effectHandleMode, SpellInfo::Effects, Map::GenerateLowGuid(), SpellInfo::GetDuration(), WorldObject::GetMap(), SpellInfo::Id, Object::IsInWorld(), Object::IsPlayer(), m_caster, m_spellInfo, Unit::RemoveDynObject(), DynamicObject::SetCasterViewpoint(), DynamicObject::SetDuration(), and SPELL_EFFECT_HANDLE_HIT.

◆ EffectAddHonor()

void Spell::EffectAddHonor ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget->IsPlayer())
        return;
 
    // not scale value for item based reward (/10 value expected)
    if (m_CastItem)
    {
        unitTarget->ToPlayer()->RewardHonor(nullptr, 1, damage / 10, false);
        LOG_DEBUG("spells.aura", "SpellEffect::AddHonor (spell_id {}) rewards {} honor points (item {}) for player: {}",
            m_spellInfo->Id, damage / 10, m_CastItem->GetEntry(), unitTarget->ToPlayer()->GetGUID().ToString());
        return;
    }
 
    // do not allow to add too many honor for player (50 * 21) = 1040 at level 70, or (50 * 31) = 1550 at level 80
    if (damage <= 50)
    {
        uint32 honor_reward = Acore::Honor::hk_honor_at_level(unitTarget->GetLevel(), float(damage));
        unitTarget->ToPlayer()->RewardHonor(nullptr, 1, honor_reward, false);
        LOG_DEBUG("spells.aura", "SpellEffect::AddHonor (spell_id {}) rewards {} honor points (scale) to player: {}",
            m_spellInfo->Id, honor_reward, unitTarget->ToPlayer()->GetGUID().ToString());
    }
    else
    {
        //maybe we have correct honor_gain in damage already
        unitTarget->ToPlayer()->RewardHonor(nullptr, 1, damage, false);
        LOG_DEBUG("spells.aura", "SpellEffect::AddHonor (spell_id {}) rewards {} honor points (non scale) for player: {}",
            m_spellInfo->Id, damage, unitTarget->ToPlayer()->GetGUID().ToString());
    }
}

References damage, effectHandleMode, Object::GetEntry(), Object::GetGUID(), Unit::GetLevel(), Acore::Honor::hk_honor_at_level(), SpellInfo::Id, Object::IsPlayer(), LOG_DEBUG, m_CastItem, m_spellInfo, Player::RewardHonor(), SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), ObjectGuid::ToString(), and unitTarget.

◆ EffectApplyAreaAura()

void Spell::EffectApplyAreaAura ( SpellEffIndex effIndex )

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

References Aura::_ApplyEffectForTargets(), ASSERT, effectHandleMode, Aura::GetOwner(), m_spellAura, SPELL_EFFECT_HANDLE_HIT_TARGET, and unitTarget.

◆ EffectApplyAura()

void Spell::EffectApplyAura ( SpellEffIndex effIndex )

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

References Aura::_ApplyEffectForTargets(), ASSERT, effectHandleMode, Aura::GetOwner(), m_spellAura, SPELL_EFFECT_HANDLE_HIT_TARGET, and unitTarget.

◆ EffectApplyGlyph()

void Spell::EffectApplyGlyph ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
        return;
 
    if (!m_caster->IsPlayer() || m_glyphIndex >= MAX_GLYPH_SLOT_INDEX)
        return;
 
    Player* player = m_caster->ToPlayer();
 
    // glyph sockets level requirement
    uint8 minLevel = 0;
    switch (m_glyphIndex)
    {
        case 0:
        case 1:
            minLevel = 15;
            break;
        case 2:
            minLevel = 50;
            break;
        case 3:
            minLevel = 30;
            break;
        case 4:
            minLevel = 70;
            break;
        case 5:
            minLevel = 80;
            break;
    }
    if (minLevel && m_caster->GetLevel() < minLevel)
    {
        SendCastResult(SPELL_FAILED_GLYPH_SOCKET_LOCKED);
        return;
    }
 
    // apply new one
    if (uint32 glyph = m_spellInfo->Effects[effIndex].MiscValue)
    {
        if (GlyphPropertiesEntry const* glyphEntry = sGlyphPropertiesStore.LookupEntry(glyph))
        {
            if (GlyphSlotEntry const* glyphSlotEntry = sGlyphSlotStore.LookupEntry(player->GetGlyphSlot(m_glyphIndex)))
            {
                if (glyphEntry->TypeFlags != glyphSlotEntry->TypeFlags)
                {
                    SendCastResult(SPELL_FAILED_INVALID_GLYPH);
                    return;                                 // glyph slot mismatch
                }
            }
 
            // remove old glyph aura
            if (uint32 oldGlyph = player->GetGlyph(m_glyphIndex))
                if (GlyphPropertiesEntry const* oldGlyphEntry = sGlyphPropertiesStore.LookupEntry(oldGlyph))
                {
                    player->RemoveAurasDueToSpell(oldGlyphEntry->SpellId);
 
                    // Removed any triggered auras
                    Unit::AuraMap& ownedAuras = player->GetOwnedAuras();
                    for (Unit::AuraMap::iterator iter = ownedAuras.begin(); iter != ownedAuras.end();)
                    {
                        Aura* aura = iter->second;
                        if (SpellInfo const* triggeredByAuraSpellInfo = aura->GetTriggeredByAuraSpellInfo())
                        {
                            if (triggeredByAuraSpellInfo->Id == oldGlyphEntry->SpellId)
                            {
                                player->RemoveOwnedAura(iter);
                                continue;
                            }
                        }
                        ++iter;
                    }
 
                    player->SendLearnPacket(oldGlyphEntry->SpellId, false); // Send packet to properly handle client-side spell tooltips
                }
 
            player->SendLearnPacket(glyphEntry->SpellId, true); // Send packet to properly handle client-side spell tooltips
            player->CastSpell(m_caster, glyphEntry->SpellId, TriggerCastFlags(TRIGGERED_FULL_MASK & ~(TRIGGERED_IGNORE_SHAPESHIFT | TRIGGERED_IGNORE_CASTER_AURASTATE)));
            player->SetGlyph(m_glyphIndex, glyph, !player->GetSession()->PlayerLoading());
            player->SendTalentsInfoData(false);
        }
    }
}

References Unit::CastSpell(), effectHandleMode, SpellInfo::Effects, Player::GetGlyph(), Player::GetGlyphSlot(), Unit::GetLevel(), Unit::GetOwnedAuras(), Player::GetSession(), Aura::GetTriggeredByAuraSpellInfo(), Object::IsPlayer(), m_caster, m_glyphIndex, m_spellInfo, MAX_GLYPH_SLOT_INDEX, WorldSession::PlayerLoading(), Unit::RemoveAurasDueToSpell(), Unit::RemoveOwnedAura(), SendCastResult(), Player::SendLearnPacket(), Player::SendTalentsInfoData(), Player::SetGlyph(), sGlyphPropertiesStore, sGlyphSlotStore, SPELL_EFFECT_HANDLE_HIT, SPELL_FAILED_GLYPH_SOCKET_LOCKED, SPELL_FAILED_INVALID_GLYPH, Object::ToPlayer(), TRIGGERED_FULL_MASK, TRIGGERED_IGNORE_CASTER_AURASTATE, and TRIGGERED_IGNORE_SHAPESHIFT.

◆ EffectBind()

void Spell::EffectBind ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    Player* player = unitTarget->ToPlayer();
    if (!player)
    {
        return;
    }
 
    WorldLocation homeLoc;
    uint32 areaId = player->GetAreaId();
 
    if (m_spellInfo->Effects[effIndex].MiscValue)
        areaId = m_spellInfo->Effects[effIndex].MiscValue;
 
    if (m_targets.HasDst())
        homeLoc.WorldRelocate(*destTarget);
    else
    {
        homeLoc = player->GetWorldLocation();
    }
 
    player->SetHomebind(homeLoc, areaId);
 
    // binding
    WorldPacket data(SMSG_BINDPOINTUPDATE, 4 + 4 + 4 + 4 + 4);
    data << float(homeLoc.GetPositionX());
    data << float(homeLoc.GetPositionY());
    data << float(homeLoc.GetPositionZ());
    data << uint32(homeLoc.GetMapId());
    data << uint32(areaId);
    player->SendDirectMessage(&data);
 
    LOG_DEBUG("spells.aura", "EffectBind: New homebind X: {}, Y: {}, Z: {}, MapId: {}, AreaId: {}",
                   homeLoc.GetPositionX(), homeLoc.GetPositionY(), homeLoc.GetPositionZ(), homeLoc.GetMapId(), areaId);
    // zone update
    data.Initialize(SMSG_PLAYERBOUND, 8 + 4);
    data << m_caster->GetGUID();
    data << uint32(areaId);
    player->SendDirectMessage(&data);
}

References destTarget, effectHandleMode, SpellInfo::Effects, WorldObject::GetAreaId(), Object::GetGUID(), WorldLocation::GetMapId(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), WorldLocation::GetWorldLocation(), SpellCastTargets::HasDst(), WorldPacket::Initialize(), LOG_DEBUG, m_caster, m_spellInfo, m_targets, Player::SendDirectMessage(), Player::SetHomebind(), SMSG_BINDPOINTUPDATE, SMSG_PLAYERBOUND, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), unitTarget, and WorldLocation::WorldRelocate().

◆ EffectBlock()

void Spell::EffectBlock ( SpellEffIndex effIndex )

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

References effectHandleMode, Object::IsPlayer(), m_caster, Player::SetCanBlock(), SPELL_EFFECT_HANDLE_HIT, and Object::ToPlayer().

◆ EffectCastButtons()

void Spell::EffectCastButtons ( SpellEffIndex effIndex )

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

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
        return;
 
    if (!m_caster->IsPlayer())
        return;
 
    Player* p_caster = m_caster->ToPlayer();
    uint32 button_id = m_spellInfo->Effects[effIndex].MiscValue + 132;
    uint32 n_buttons = m_spellInfo->Effects[effIndex].MiscValueB;
 
    for (; n_buttons; --n_buttons, ++button_id)
    {
        ActionButton const* ab = p_caster->GetActionButton(button_id);
        if (!ab || ab->GetType() != ACTION_BUTTON_SPELL)
            continue;
 
        uint32 spell_id = ab->GetAction();
        if (!spell_id)
            continue;
 
        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell_id);
        if (!spellInfo)
            continue;
 
        if (!p_caster->HasSpell(spell_id) || p_caster->HasSpellCooldown(spell_id))
            continue;
 
        if (!spellInfo->HasAttribute(SPELL_ATTR7_CAN_BE_MULTI_CAST))
            continue;
 
        uint32 cost = spellInfo->CalcPowerCost(m_caster, spellInfo->GetSchoolMask(), this);
        if (m_caster->GetPower(POWER_MANA) < cost)
            continue;
 
        TriggerCastFlags triggerFlags = TriggerCastFlags(TRIGGERED_IGNORE_GCD | TRIGGERED_IGNORE_CAST_IN_PROGRESS | TRIGGERED_CAST_DIRECTLY);
        m_caster->CastSpell(m_caster, spell_id, triggerFlags);
    }
}

References ACTION_BUTTON_SPELL, SpellInfo::CalcPowerCost(), Unit::CastSpell(), effectHandleMode, SpellInfo::Effects, ActionButton::GetAction(), Player::GetActionButton(), Unit::GetPower(), SpellInfo::GetSchoolMask(), ActionButton::GetType(), SpellInfo::HasAttribute(), Player::HasSpell(), Player::HasSpellCooldown(), Object::IsPlayer(), m_caster, m_spellInfo, POWER_MANA, SPELL_ATTR7_CAN_BE_MULTI_CAST, SPELL_EFFECT_HANDLE_HIT, sSpellMgr, Object::ToPlayer(), TRIGGERED_CAST_DIRECTLY, TRIGGERED_IGNORE_CAST_IN_PROGRESS, and TRIGGERED_IGNORE_GCD.

◆ EffectCharge()

void Spell::EffectCharge ( SpellEffIndex effIndex )

{
    if (effectHandleMode == SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
    {
        if (!unitTarget)
            return;
 
        ObjectGuid targetGUID = ObjectGuid::Empty;
        Player* player = m_caster->ToPlayer();
        if (player)
        {
            // charge changes fall time
            player->SetFallInformation(GameTime::GetGameTime().count(), m_caster->GetPositionZ());
 
            if (!m_spellInfo->HasAttribute(SPELL_ATTR0_CANCELS_AUTO_ATTACK_COMBAT) && !m_spellInfo->IsPositive() && m_caster->GetTarget() == unitTarget->GetGUID())
            {
                targetGUID = unitTarget->GetGUID();
            }
        }
 
        float speed = G3D::fuzzyGt(m_spellInfo->Speed, 0.0f) ? m_spellInfo->Speed : SPEED_CHARGE;
        // Spell is not using explicit target - no generated path
        if (!m_preGeneratedPath)
        {
            Position pos = unitTarget->GetFirstCollisionPosition(unitTarget->GetCombatReach(), unitTarget->GetRelativeAngle(m_caster));
            m_caster->GetMotionMaster()->MoveCharge(pos.m_positionX, pos.m_positionY, pos.m_positionZ, speed, EVENT_CHARGE, nullptr, false, 0.0f, targetGUID);
        }
        else
        {
            m_caster->GetMotionMaster()->MoveCharge(*m_preGeneratedPath, speed, targetGUID);
        }
 
        if (player)
        {
            sScriptMgr->AnticheatSetUnderACKmount(player);
        }
    }
}

References effectHandleMode, ObjectGuid::Empty, EVENT_CHARGE, Unit::GetCombatReach(), WorldObject::GetFirstCollisionPosition(), GameTime::GetGameTime(), Object::GetGUID(), Unit::GetMotionMaster(), Position::GetPositionZ(), Position::GetRelativeAngle(), Unit::GetTarget(), SpellInfo::HasAttribute(), SpellInfo::IsPositive(), m_caster, Position::m_positionX, Position::m_positionY, Position::m_positionZ, m_preGeneratedPath, m_spellInfo, MotionMaster::MoveCharge(), Player::SetFallInformation(), SpellInfo::Speed, SPEED_CHARGE, SPELL_ATTR0_CANCELS_AUTO_ATTACK_COMBAT, SPELL_EFFECT_HANDLE_LAUNCH_TARGET, sScriptMgr, Object::ToPlayer(), and unitTarget.

◆ EffectChargeDest()

void Spell::EffectChargeDest ( SpellEffIndex effIndex )

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

References destTarget, effectHandleMode, WorldObject::GetDistance(), WorldObject::GetFirstCollisionPosition(), Unit::GetMotionMaster(), Position::GetPosition(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Position::GetRelativeAngle(), SpellCastTargets::HasDst(), Object::IsPlayer(), WorldObject::IsWithinLOS(), m_caster, Position::m_positionX, Position::m_positionY, Position::m_positionZ, m_targets, MotionMaster::MoveCharge(), SPELL_EFFECT_HANDLE_LAUNCH, sScriptMgr, and Object::ToPlayer().

◆ EffectCreateItem()

void Spell::EffectCreateItem ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    DoCreateItem(effIndex, m_spellInfo->Effects[effIndex].ItemType);
    ExecuteLogEffectCreateItem(effIndex, m_spellInfo->Effects[effIndex].ItemType);
}

References DoCreateItem(), effectHandleMode, SpellInfo::Effects, ExecuteLogEffectCreateItem(), m_spellInfo, and SPELL_EFFECT_HANDLE_HIT_TARGET.

◆ EffectCreateItem2()

void Spell::EffectCreateItem2 ( SpellEffIndex effIndex )

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

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

References Player::AutoStoreLoot(), Player::DestroyItemCount(), DoCreateItem(), effectHandleMode, SpellInfo::Effects, Player::HasItemCount(), SpellInfo::Id, SpellInfo::IsLootCrafting(), LootTemplates_Spell, m_spellInfo, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectCreateRandomItem()

void Spell::EffectCreateRandomItem ( SpellEffIndex effIndex )

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

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

References Player::AutoStoreLoot(), effectHandleMode, SpellInfo::Id, LootTemplates_Spell, m_spellInfo, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectCreateTamedPet()

void Spell::EffectCreateTamedPet ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget || !unitTarget->IsPlayer() || unitTarget->GetPetGUID() || !unitTarget->IsClass(CLASS_HUNTER, CLASS_CONTEXT_PET))
        return;
 
    uint32 creatureEntry = m_spellInfo->Effects[effIndex].MiscValue;
    Pet* pet = unitTarget->CreateTamedPetFrom(creatureEntry, m_spellInfo->Id);
    if (!pet)
        return;
 
    // add to world
    pet->GetMap()->AddToMap(pet->ToCreature(), true);
 
    // unitTarget has pet now
    unitTarget->SetMinion(pet, true);
 
    pet->InitTalentForLevel();
 
    if (unitTarget->IsPlayer())
    {
        pet->SavePetToDB(PET_SAVE_AS_CURRENT);
        unitTarget->ToPlayer()->PetSpellInitialize();
    }
}

References Map::AddToMap(), CLASS_CONTEXT_PET, CLASS_HUNTER, Unit::CreateTamedPetFrom(), effectHandleMode, SpellInfo::Effects, WorldObject::GetMap(), Unit::GetPetGUID(), SpellInfo::Id, Pet::InitTalentForLevel(), Unit::IsClass(), Object::IsPlayer(), m_spellInfo, PET_SAVE_AS_CURRENT, Player::PetSpellInitialize(), Pet::SavePetToDB(), Unit::SetMinion(), SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToCreature(), Object::ToPlayer(), and unitTarget.

◆ EffectDestroyAllTotems()

void Spell::EffectDestroyAllTotems ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
        return;
 
    int32 mana = 0;
    for (uint8 slot = SUMMON_SLOT_TOTEM_FIRE; slot < MAX_TOTEM_SLOT; ++slot)
    {
        if (!m_caster->m_SummonSlot[slot])
            continue;
 
        Creature* totem = m_caster->GetMap()->GetCreature(m_caster->m_SummonSlot[slot]);
        if (totem && totem->IsTotem())
        {
            uint32 spell_id = totem->GetUInt32Value(UNIT_CREATED_BY_SPELL);
            SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell_id);
            if (spellInfo)
            {
                mana += spellInfo->ManaCost;
                mana += int32(CalculatePct(m_caster->GetCreateMana(), spellInfo->ManaCostPercentage));
            }
            totem->ToTotem()->UnSummon();
        }
    }
    ApplyPct(mana, damage);
    if (mana)
        m_caster->CastCustomSpell(m_caster, 39104, &mana, nullptr, nullptr, true);
}

References ApplyPct(), CalculatePct(), Unit::CastCustomSpell(), damage, effectHandleMode, Unit::GetCreateMana(), Map::GetCreature(), WorldObject::GetMap(), Object::GetUInt32Value(), Unit::IsTotem(), m_caster, Unit::m_SummonSlot, SpellInfo::ManaCost, SpellInfo::ManaCostPercentage, MAX_TOTEM_SLOT, SPELL_EFFECT_HANDLE_HIT, sSpellMgr, SUMMON_SLOT_TOTEM_FIRE, Unit::ToTotem(), UNIT_CREATED_BY_SPELL, and Totem::UnSummon().

◆ EffectDiscoverTaxi()

void Spell::EffectDiscoverTaxi ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    Player* player = unitTarget->ToPlayer();
    if (!player)
    {
        return;
    }
 
    uint32 nodeid = m_spellInfo->Effects[effIndex].MiscValue;
    if (sTaxiNodesStore.LookupEntry(nodeid))
        player->GetSession()->SendDiscoverNewTaxiNode(nodeid);
}

References effectHandleMode, SpellInfo::Effects, Player::GetSession(), m_spellInfo, WorldSession::SendDiscoverNewTaxiNode(), SPELL_EFFECT_HANDLE_HIT_TARGET, sTaxiNodesStore, Object::ToPlayer(), and unitTarget.

◆ EffectDisEnchant()

void Spell::EffectDisEnchant ( SpellEffIndex effIndex )

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

References ItemTemplate::DisenchantID, effectHandleMode, Object::GetGUID(), Item::GetTemplate(), SpellInfo::Id, itemTarget, LOOT_DISENCHANTING, m_caster, m_spellInfo, SPELL_EFFECT_HANDLE_HIT_TARGET, and Object::ToPlayer().

◆ EffectDismissPet()

void Spell::EffectDismissPet ( SpellEffIndex effIndex )

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

References effectHandleMode, ExecuteLogEffectUnsummonObject(), Unit::IsPet(), PET_SAVE_NOT_IN_SLOT, Pet::Remove(), SPELL_EFFECT_HANDLE_HIT_TARGET, Unit::ToPet(), and unitTarget.

◆ EffectDispel()

void Spell::EffectDispel ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    // Create dispel mask by dispel type
    uint32 dispel_type = m_spellInfo->Effects[effIndex].MiscValue;
    uint32 dispelMask  = SpellInfo::GetDispelMask(DispelType(dispel_type));
 
    DispelChargesList dispel_list;
    unitTarget->GetDispellableAuraList(m_caster, dispelMask, dispel_list, m_spellInfo);
    if (dispel_list.empty())
        return;
 
    // Ok if exist some buffs for dispel try dispel it
    uint32 failCount = 0;
    DispelChargesList success_list;
    WorldPacket dataFail(SMSG_DISPEL_FAILED, 8 + 8 + 4 + 4 + damage * 4);
    // dispel N = damage buffs (or while exist buffs for dispel)
    for (int32 count = 0; count < damage && !dispel_list.empty();)
    {
        // Random select buff for dispel
        DispelChargesList::iterator itr = dispel_list.begin();
        std::advance(itr, urand(0, dispel_list.size() - 1));
 
        int32 chance = itr->first->CalcDispelChance(unitTarget, !unitTarget->IsFriendlyTo(m_caster));
        // 2.4.3 Patch Notes: "Dispel effects will no longer attempt to remove effects that have 100% dispel resistance."
        if (!chance)
        {
            dispel_list.erase(itr);
            continue;
        }
        else
        {
            if (roll_chance_i(chance))
            {
                bool alreadyListed = false;
                for (DispelChargesList::iterator successItr = success_list.begin(); successItr != success_list.end(); ++successItr)
                {
                    if (successItr->first->GetId() == itr->first->GetId())
                    {
                        ++successItr->second;
                        alreadyListed = true;
                    }
                }
                if (!alreadyListed)
                    success_list.push_back(std::make_pair(itr->first, 1));
                --itr->second;
                if (itr->second <= 0)
                    dispel_list.erase(itr);
            }
            else
            {
                if (!failCount)
                {
                    // Failed to dispell
                    dataFail << m_caster->GetGUID();                    // Caster GUID
                    dataFail << unitTarget->GetGUID();                  // Victim GUID
                    dataFail << uint32(m_spellInfo->Id);                // dispel spell id
                }
                ++failCount;
                dataFail << uint32(itr->first->GetId());                // Spell Id
            }
            ++count;
        }
    }
 
    if (failCount)
        m_caster->SendMessageToSet(&dataFail, true);
 
    // put in combat
    if (unitTarget->IsFriendlyTo(m_caster))
        unitTarget->GetThreatMgr().ForwardThreatForAssistingMe(m_caster, 0.0f, m_spellInfo);
 
    if (success_list.empty())
        return;
 
    WorldPacket dataSuccess(SMSG_SPELLDISPELLOG, 8 + 8 + 4 + 1 + 4 + success_list.size() * 5);
    // Send packet header
    dataSuccess << unitTarget->GetPackGUID();               // Victim GUID
    dataSuccess << m_caster->GetPackGUID();                 // Caster GUID
    dataSuccess << uint32(m_spellInfo->Id);                // dispel spell id
    dataSuccess << uint8(0);                               // not used
    dataSuccess << uint32(success_list.size());            // count
    for (DispelChargesList::iterator itr = success_list.begin(); itr != success_list.end(); ++itr)
    {
        // Send dispelled spell info
        dataSuccess << uint32(itr->first->GetId());              // Spell Id
        dataSuccess << uint8(0);                        // 0 - dispelled !=0 cleansed
        unitTarget->RemoveAurasDueToSpellByDispel(itr->first->GetId(), m_spellInfo->Id, itr->first->GetCasterGUID(), m_caster, itr->second);
    }
    m_caster->SendMessageToSet(&dataSuccess, true);
 
    // On success dispel
    // Devour Magic
    if (m_spellInfo->SpellFamilyName == SPELLFAMILY_WARLOCK && m_spellInfo->GetCategory() == SPELLCATEGORY_DEVOUR_MAGIC)
    {
        int32 heal_amount = m_spellInfo->Effects[EFFECT_1].CalcValue();
        m_caster->CastCustomSpell(m_caster, 19658, &heal_amount, nullptr, nullptr, true);
        // Glyph of Felhunter
        if (Unit* owner = m_caster->GetOwner())
            if (owner->GetAura(56249))
                owner->CastCustomSpell(owner, 19658, &heal_amount, nullptr, nullptr, true);
    }
}

References Unit::CastCustomSpell(), damage, EFFECT_1, effectHandleMode, SpellInfo::Effects, ThreatManager::ForwardThreatForAssistingMe(), SpellInfo::GetCategory(), Unit::GetDispellableAuraList(), SpellInfo::GetDispelMask(), Object::GetGUID(), Unit::GetOwner(), Object::GetPackGUID(), Unit::GetThreatMgr(), SpellInfo::Id, Unit::IsFriendlyTo(), m_caster, m_spellInfo, Unit::RemoveAurasDueToSpellByDispel(), roll_chance_i(), WorldObject::SendMessageToSet(), SMSG_DISPEL_FAILED, SMSG_SPELLDISPELLOG, SPELL_EFFECT_HANDLE_HIT_TARGET, SPELLCATEGORY_DEVOUR_MAGIC, SPELLFAMILY_WARLOCK, SpellInfo::SpellFamilyName, unitTarget, and urand().

◆ EffectDispelMechanic()

void Spell::EffectDispelMechanic ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    uint32 mechanic = m_spellInfo->Effects[effIndex].MiscValue;
 
    std::queue<std::pair<uint32, ObjectGuid>> dispel_list;
 
    Unit::AuraMap const& auras = unitTarget->GetOwnedAuras();
    for (Unit::AuraMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
    {
        Aura* aura = itr->second;
        if (!aura->GetApplicationOfTarget(unitTarget->GetGUID()))
            continue;
        if (roll_chance_i(aura->CalcDispelChance(unitTarget, !unitTarget->IsFriendlyTo(m_caster))))
        {
            if (aura->GetSpellInfo()->GetAllEffectsMechanicMask() & (1ULL << mechanic))
            {
                dispel_list.push(std::make_pair(aura->GetId(), aura->GetCasterGUID()));
 
                // spell only removes 1 bleed effect do not continue
                if (m_spellInfo->Effects[effIndex].BasePoints == 1)
                {
                    break;
                }
            }
        }
    }
 
    for (; dispel_list.size(); dispel_list.pop())
    {
        unitTarget->RemoveAura(dispel_list.front().first, dispel_list.front().second, 0, AURA_REMOVE_BY_ENEMY_SPELL);
    }
 
    // put in combat
    if (unitTarget->IsFriendlyTo(m_caster))
        unitTarget->GetThreatMgr().ForwardThreatForAssistingMe(m_caster, 0.0f, m_spellInfo);
}

References AURA_REMOVE_BY_ENEMY_SPELL, Aura::CalcDispelChance(), effectHandleMode, SpellInfo::Effects, ThreatManager::ForwardThreatForAssistingMe(), SpellInfo::GetAllEffectsMechanicMask(), Aura::GetApplicationOfTarget(), Aura::GetCasterGUID(), Object::GetGUID(), Aura::GetId(), Unit::GetOwnedAuras(), Aura::GetSpellInfo(), Unit::GetThreatMgr(), Unit::IsFriendlyTo(), m_caster, m_spellInfo, Unit::RemoveAura(), roll_chance_i(), SPELL_EFFECT_HANDLE_HIT_TARGET, and unitTarget.

◆ EffectDistract()

void Spell::EffectDistract ( SpellEffIndex effIndex )

@BUG Causes the player to stop moving.

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

References damage, destTarget, effectHandleMode, Position::GetAngle(), Unit::GetMotionMaster(), Unit::HasUnitState(), IN_MILLISECONDS, Unit::IsEngaged(), MotionMaster::MoveDistract(), Unit::SetFacingTo(), SPELL_EFFECT_HANDLE_HIT_TARGET, UNIT_STATE_CONFUSED, UNIT_STATE_FLEEING, UNIT_STATE_STUNNED, and unitTarget.

◆ EffectDualWield()

void Spell::EffectDualWield ( SpellEffIndex effIndex )

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

References effectHandleMode, Unit::SetCanDualWield(), SPELL_EFFECT_HANDLE_HIT_TARGET, and unitTarget.

◆ EffectDuel()

void Spell::EffectDuel ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget || !m_caster->IsPlayer() || !unitTarget->IsPlayer())
        return;
 
    Player* caster = m_caster->ToPlayer();
    Player* target = unitTarget->ToPlayer();
 
    // caster or target already have requested duel
    if (caster->duel || target->duel || !target->GetSocial() || target->GetSocial()->HasIgnore(caster->GetGUID()))
        return;
 
    // Players can only fight a duel in zones with this flag
    AreaTableEntry const* casterAreaEntry = sAreaTableStore.LookupEntry(caster->GetAreaId());
    if (casterAreaEntry && !(casterAreaEntry->flags & AREA_FLAG_ALLOW_DUELS))
    {
        SendCastResult(SPELL_FAILED_NO_DUELING);            // Dueling isn't allowed here
        return;
    }
 
    AreaTableEntry const* targetAreaEntry = sAreaTableStore.LookupEntry(target->GetAreaId());
    if (targetAreaEntry && !(targetAreaEntry->flags & AREA_FLAG_ALLOW_DUELS))
    {
        SendCastResult(SPELL_FAILED_NO_DUELING);            // Dueling isn't allowed here
        return;
    }
 
    //CREATE DUEL FLAG OBJECT
    uint32 gameobject_id = m_spellInfo->Effects[effIndex].MiscValue;
    GameObject* pGameObj = sObjectMgr->IsGameObjectStaticTransport(gameobject_id) ? new StaticTransport() : new GameObject();
 
    Map* map = m_caster->GetMap();
    G3D::Quat rotation = G3D::Quat::fromAxisAngleRotation(G3D::Vector3::unitZ(), m_caster->GetOrientation());
    if (!pGameObj->Create(map->GenerateLowGuid<HighGuid::GameObject>(), gameobject_id,
                          map, m_caster->GetPhaseMask(),
                          m_caster->GetPositionX() + (unitTarget->GetPositionX() - m_caster->GetPositionX()) / 2,
                          m_caster->GetPositionY() + (unitTarget->GetPositionY() - m_caster->GetPositionY()) / 2,
                          m_caster->GetPositionZ(),
                          m_caster->GetOrientation(), rotation, 0, GO_STATE_READY))
    {
        delete pGameObj;
        return;
    }
 
    pGameObj->SetUInt32Value(GAMEOBJECT_FACTION, m_caster->GetFaction());
    pGameObj->SetUInt32Value(GAMEOBJECT_LEVEL, m_caster->GetLevel() + 1);
    int32 duration = m_spellInfo->GetDuration();
    pGameObj->SetRespawnTime(duration > 0 ? duration / IN_MILLISECONDS : 0);
    pGameObj->SetSpellId(m_spellInfo->Id);
 
    ExecuteLogEffectSummonObject(effIndex, pGameObj);
 
    m_caster->AddGameObject(pGameObj);
    map->AddToMap(pGameObj, true);
    //END
 
    // Send request
    WorldPacket data(SMSG_DUEL_REQUESTED, 8 + 8);
    data << pGameObj->GetGUID();
    data << caster->GetGUID();
    caster->SendDirectMessage(&data);
    target->SendDirectMessage(&data);
 
    // create duel-info
    bool isMounted = (GetSpellInfo()->Id == 62875);
    caster->duel = std::make_unique<DuelInfo>(target, caster, isMounted);
    target->duel = std::make_unique<DuelInfo>(caster, caster, isMounted);
 
    caster->SetGuidValue(PLAYER_DUEL_ARBITER, pGameObj->GetGUID());
    target->SetGuidValue(PLAYER_DUEL_ARBITER, pGameObj->GetGUID());
 
    sScriptMgr->OnPlayerDuelRequest(target, caster);
}

References Unit::AddGameObject(), Map::AddToMap(), AREA_FLAG_ALLOW_DUELS, GameObject::Create(), Player::duel, effectHandleMode, SpellInfo::Effects, ExecuteLogEffectSummonObject(), AreaTableEntry::flags, GameObject, GAMEOBJECT_FACTION, GAMEOBJECT_LEVEL, Map::GenerateLowGuid(), WorldObject::GetAreaId(), SpellInfo::GetDuration(), Unit::GetFaction(), Object::GetGUID(), Unit::GetLevel(), WorldObject::GetMap(), Position::GetOrientation(), WorldObject::GetPhaseMask(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Player::GetSocial(), GetSpellInfo(), GO_STATE_READY, PlayerSocial::HasIgnore(), SpellInfo::Id, IN_MILLISECONDS, Object::IsPlayer(), m_caster, m_spellInfo, PLAYER_DUEL_ARBITER, sAreaTableStore, SendCastResult(), Player::SendDirectMessage(), Object::SetGuidValue(), GameObject::SetRespawnTime(), GameObject::SetSpellId(), Object::SetUInt32Value(), SMSG_DUEL_REQUESTED, sObjectMgr, SPELL_EFFECT_HANDLE_HIT_TARGET, SPELL_FAILED_NO_DUELING, sScriptMgr, Object::ToPlayer(), and unitTarget.

◆ EffectDummy()

void Spell::EffectDummy ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget && !gameObjTarget && !itemTarget)
        return;
 
    // selection by spell family
    switch (m_spellInfo->SpellFamilyName)
    {
        case SPELLFAMILY_GENERIC:
            {
                switch (m_spellInfo->Id)
                {
                    // Trial of the Champion, Trample
                    case 67866:
                        {
                            if (unitTarget && !unitTarget->IsVehicle() && !unitTarget->GetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID))
                                unitTarget->CastSpell(unitTarget, 67867, false);
                            return;
                        }
                    // Trial of the Champion, Hammer of the Righteous
                    case 66867:
                        {
                            if (!unitTarget)
                                return;
                            if (unitTarget->HasAura(66940))
                                m_caster->CastSpell(unitTarget, 66903, true);
                            else
                                m_caster->CastSpell(unitTarget, 66904, true);
                            return;
                        }
                    case 17731:
                    case 69294:
                        {
                            if (!gameObjTarget || gameObjTarget->GetRespawnTime() > GameTime::GetGameTime().count())
                                return;
 
                            gameObjTarget->SetRespawnTime(10);
                            gameObjTarget->SendCustomAnim(gameObjTarget->GetGoAnimProgress());
                            if (Creature* trigger = gameObjTarget->SummonCreature(12758, *gameObjTarget, TEMPSUMMON_TIMED_DESPAWN, 1000))
                                trigger->CastSpell(trigger, 17731, false);
 
                            return;
                        }
                    // HoL, Arc Weld
                    case 59086:
                        {
                            if (m_caster && m_caster->IsPlayer() && m_caster->ToPlayer()->isMoving())
                                m_caster->CastSpell(m_caster, 59097, true);
 
                            return;
                        }
                }
                break;
            }
        case SPELLFAMILY_PALADIN:
            switch (m_spellInfo->Id)
            {
                case 31789:                                 // Righteous Defense (step 1)
                    {
                        if (!unitTarget)
                            return;
                        // not empty (checked), copy
                        Unit::AttackerSet attackers = unitTarget->getAttackers();
 
                        // remove invalid attackers
                        for (Unit::AttackerSet::iterator aItr = attackers.begin(); aItr != attackers.end();)
                            if (!(*aItr)->IsValidAttackTarget(m_caster))
                                aItr = attackers.erase(aItr);
                            else
                                ++aItr;
 
                        // selected from list 3
                        uint32 maxTargets = std::min<uint32>(3, attackers.size());
                        for (uint32 i = 0; i < maxTargets; ++i)
                        {
                            Unit::AttackerSet::iterator aItr = attackers.begin();
                            std::advance(aItr, urand(0, attackers.size() - 1));
                            m_caster->CastSpell((*aItr), 31790, true);
                            attackers.erase(aItr);
                        }
 
                        return;
                    }
            }
            break;
        case SPELLFAMILY_ROGUE:
            // Hunger for Blood
            if (m_spellInfo->Id == 51662)
            {
                m_caster->CastSpell(m_caster, 63848, true);
                return;
            }
            break;
    }
 
    // pet auras
    if (PetAura const* petSpell = sSpellMgr->GetPetAura(m_spellInfo->Id, effIndex))
    {
        m_caster->AddPetAura(petSpell);
        return;
    }
 
    // normal DB scripted effect
    LOG_DEBUG("spells.aura", "Spell ScriptStart spellid {} in EffectDummy({})", m_spellInfo->Id, effIndex);
    m_caster->GetMap()->ScriptsStart(sSpellScripts, uint32(m_spellInfo->Id | (effIndex << 24)), m_caster, unitTarget);
 
    if (gameObjTarget)
    {
        sScriptMgr->OnDummyEffect(m_caster, m_spellInfo->Id, effIndex, gameObjTarget);
    }
    else if (unitTarget && unitTarget->IsCreature())
    {
        sScriptMgr->OnDummyEffect(m_caster, m_spellInfo->Id, effIndex, unitTarget->ToCreature());
    }
    else if (itemTarget)
    {
        sScriptMgr->OnDummyEffect(m_caster, m_spellInfo->Id, effIndex, itemTarget);
    }
}

References Unit::AddPetAura(), Unit::CastSpell(), effectHandleMode, gameObjTarget, Unit::getAttackers(), GameTime::GetGameTime(), GameObject::GetGoAnimProgress(), WorldObject::GetMap(), GameObject::GetRespawnTime(), Object::GetUInt32Value(), Unit::HasAura(), SpellInfo::Id, Object::IsCreature(), Unit::isMoving(), Object::IsPlayer(), Unit::IsVehicle(), itemTarget, LOG_DEBUG, m_caster, m_spellInfo, Map::ScriptsStart(), GameObject::SendCustomAnim(), GameObject::SetRespawnTime(), SPELL_EFFECT_HANDLE_HIT_TARGET, SPELLFAMILY_GENERIC, SPELLFAMILY_PALADIN, SPELLFAMILY_ROGUE, SpellInfo::SpellFamilyName, sScriptMgr, sSpellMgr, sSpellScripts, WorldObject::SummonCreature(), TEMPSUMMON_TIMED_DESPAWN, Object::ToCreature(), Object::ToPlayer(), UNIT_FIELD_MOUNTDISPLAYID, unitTarget, and urand().

◆ EffectDurabilityDamage()

void Spell::EffectDurabilityDamage ( SpellEffIndex effIndex )

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

References damage, Player::DurabilityPointsLoss(), Player::DurabilityPointsLossAll(), effectHandleMode, SpellInfo::Effects, ExecuteLogEffectDurabilityDamage(), Object::GetEntry(), Player::GetItemByPos(), INVENTORY_SLOT_BAG_0, INVENTORY_SLOT_BAG_END, m_spellInfo, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectDurabilityDamagePCT()

void Spell::EffectDurabilityDamagePCT ( SpellEffIndex effIndex )

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

References damage, Player::DurabilityLoss(), Player::DurabilityLossAll(), effectHandleMode, SpellInfo::Effects, Player::GetItemByPos(), INVENTORY_SLOT_BAG_0, INVENTORY_SLOT_BAG_END, m_spellInfo, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectEnchantHeldItem()

void Spell::EffectEnchantHeldItem ( SpellEffIndex effIndex )

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

References Player::ApplyEnchantment(), SpellItemEnchantmentEntry::charges, damage, effectHandleMode, SpellInfo::Effects, EQUIPMENT_SLOT_MAINHAND, SpellInfo::GetDuration(), Item::GetEnchantmentId(), Object::GetGUID(), Player::GetItemByPos(), SpellInfo::Id, IN_MILLISECONDS, INVENTORY_SLOT_BAG_0, Item::IsEquipped(), m_caster, m_spellInfo, MINUTE, Item::SetEnchantment(), SPELL_EFFECT_HANDLE_HIT_TARGET, sSpellItemEnchantmentStore, TEMP_ENCHANTMENT_SLOT, Object::ToPlayer(), and unitTarget.

◆ EffectEnchantItemPerm()

void Spell::EffectEnchantItemPerm ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!m_caster->IsPlayer())
        return;
    if (!itemTarget)
        return;
 
    Player* p_caster = m_caster->ToPlayer();
 
    // Handle vellums
    if (itemTarget->IsWeaponVellum() || itemTarget->IsArmorVellum())
    {
        // destroy one vellum from stack
        uint32 count = 1;
        p_caster->DestroyItemCount(itemTarget, count, true);
        unitTarget = p_caster;
        // and add a scroll
        DoCreateItem(effIndex, m_spellInfo->Effects[effIndex].ItemType);
        itemTarget = nullptr;
        m_targets.SetItemTarget(nullptr);
    }
    else
    {
        // do not increase skill if vellum used
        if (!(m_CastItem && m_CastItem->GetTemplate()->HasFlag(ITEM_FLAG_NO_REAGENT_COST)))
            p_caster->UpdateCraftSkill(m_spellInfo->Id);
 
        uint32 enchant_id = m_spellInfo->Effects[effIndex].MiscValue;
        if (!enchant_id)
            return;
 
        SpellItemEnchantmentEntry const* pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
        if (!pEnchant)
            return;
 
        // item can be in trade slot and have owner diff. from caster
        Player* item_owner = itemTarget->GetOwner();
        if (!item_owner)
            return;
 
        // remove old enchanting before applying new if equipped
        item_owner->ApplyEnchantment(itemTarget, PERM_ENCHANTMENT_SLOT, false);
 
        itemTarget->SetEnchantment(PERM_ENCHANTMENT_SLOT, enchant_id, 0, 0, m_caster->GetGUID());
 
        // add new enchanting if equipped
        item_owner->ApplyEnchantment(itemTarget, PERM_ENCHANTMENT_SLOT, true);
 
        if (item_owner != p_caster && p_caster->GetSession()->HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
        {
            LOG_GM(p_caster->GetSession()->GetAccountId(), "GM {} (Account: {}) enchanting(perm): {} (SpellID: {} EncID: {}) on {}'s item: {} (Entry: {})",
                p_caster->GetName(), p_caster->GetSession()->GetAccountId(),
                m_spellInfo->SpellName[0], m_spellInfo->Id, enchant_id,
                item_owner->GetName(), itemTarget->GetTemplate()->Name1, itemTarget->GetEntry());
        }
 
        item_owner->RemoveTradeableItem(itemTarget);
        itemTarget->ClearSoulboundTradeable(item_owner);
    }
}

References Player::ApplyEnchantment(), Item::ClearSoulboundTradeable(), Player::DestroyItemCount(), DoCreateItem(), effectHandleMode, SpellInfo::Effects, WorldSession::GetAccountId(), Object::GetEntry(), Object::GetGUID(), WorldObject::GetName(), Item::GetOwner(), Player::GetSession(), Item::GetTemplate(), ItemTemplate::HasFlag(), WorldSession::HasPermission(), SpellInfo::Id, Item::IsArmorVellum(), Object::IsPlayer(), Item::IsWeaponVellum(), ITEM_FLAG_NO_REAGENT_COST, itemTarget, LOG_GM, m_caster, m_CastItem, m_spellInfo, m_targets, ItemTemplate::Name1, PERM_ENCHANTMENT_SLOT, rbac::RBAC_PERM_LOG_GM_TRADE, Player::RemoveTradeableItem(), Item::SetEnchantment(), SpellCastTargets::SetItemTarget(), SPELL_EFFECT_HANDLE_HIT_TARGET, SpellInfo::SpellName, sSpellItemEnchantmentStore, Object::ToPlayer(), unitTarget, and Player::UpdateCraftSkill().

◆ EffectEnchantItemPrismatic()

void Spell::EffectEnchantItemPrismatic ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!m_caster->IsPlayer())
        return;
    if (!itemTarget)
        return;
 
    uint32 enchant_id = m_spellInfo->Effects[effIndex].MiscValue;
    if (!enchant_id)
        return;
 
    SpellItemEnchantmentEntry const* pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
    if (!pEnchant)
        return;
 
    // support only enchantings with add socket in this slot
    {
        bool add_socket = false;
        for (uint8 i = 0; i < MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS; ++i)
        {
            if (pEnchant->type[i] == ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET)
            {
                add_socket = true;
                break;
            }
        }
        if (!add_socket)
        {
            LOG_ERROR("spells.effect", "Spell::EffectEnchantItemPrismatic: attempt apply enchant spell {} with SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC ({}) but without ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET ({}), not suppoted yet.",
                           m_spellInfo->Id, SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC, ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET);
            return;
        }
    }
 
    // item can be in trade slot and have owner diff. from caster
    Player* item_owner = itemTarget->GetOwner();
    if (!item_owner)
        return;
 
    Player* p_caster = m_caster->ToPlayer();
    if (item_owner != p_caster && p_caster->GetSession()->HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
    {
        LOG_GM(p_caster->GetSession()->GetAccountId(), "GM {} (Account: {}) enchanting(prismatic): {} (SpellID: {} EncID: {}) on {}'s item: {} (Entry: {})",
            p_caster->GetName(), p_caster->GetSession()->GetAccountId(),
            m_spellInfo->SpellName[0], m_spellInfo->Id, enchant_id,
            item_owner->GetName(), itemTarget->GetTemplate()->Name1, itemTarget->GetEntry());
    }
 
    // remove old enchanting before applying new if equipped
    item_owner->ApplyEnchantment(itemTarget, PRISMATIC_ENCHANTMENT_SLOT, false);
 
    itemTarget->SetEnchantment(PRISMATIC_ENCHANTMENT_SLOT, enchant_id, 0, 0, m_caster->GetGUID());
 
    // add new enchanting if equipped
    item_owner->ApplyEnchantment(itemTarget, PRISMATIC_ENCHANTMENT_SLOT, true);
 
    item_owner->RemoveTradeableItem(itemTarget);
    itemTarget->ClearSoulboundTradeable(item_owner);
}

References Player::ApplyEnchantment(), Item::ClearSoulboundTradeable(), effectHandleMode, SpellInfo::Effects, WorldSession::GetAccountId(), Object::GetEntry(), Object::GetGUID(), WorldObject::GetName(), Item::GetOwner(), Player::GetSession(), Item::GetTemplate(), WorldSession::HasPermission(), SpellInfo::Id, Object::IsPlayer(), ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET, itemTarget, LOG_ERROR, LOG_GM, m_caster, m_spellInfo, MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS, ItemTemplate::Name1, PRISMATIC_ENCHANTMENT_SLOT, rbac::RBAC_PERM_LOG_GM_TRADE, Player::RemoveTradeableItem(), Item::SetEnchantment(), SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC, SPELL_EFFECT_HANDLE_HIT_TARGET, SpellInfo::SpellName, sSpellItemEnchantmentStore, Object::ToPlayer(), and SpellItemEnchantmentEntry::type.

◆ EffectEnchantItemTmp()

void Spell::EffectEnchantItemTmp ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!m_caster->IsPlayer())
        return;
 
    Player* p_caster = m_caster->ToPlayer();
 
    // Rockbiter Weapon apply to both weapon
    if (!itemTarget)
        return;
    if (m_spellInfo->SpellFamilyName == SPELLFAMILY_SHAMAN && m_spellInfo->SpellFamilyFlags[0] & 0x400000)
    {
        uint32 spell_id = 0;
 
        // enchanting spell selected by calculated damage-per-sec stored in Effect[1] base value
        // Note: damage calculated (correctly) with rounding int32(float(v)) but
        // RW enchantments applied damage int32(float(v)+0.5), this create  0..1 difference sometime
        switch (damage)
        {
            // Rank 1
            case  2:
                spell_id = 36744;
                break;               //  0% [ 7% == 2, 14% == 2, 20% == 2]
            // Rank 2
            case  4:
                spell_id = 36753;
                break;               //  0% [ 7% == 4, 14% == 4]
            case  5:
                spell_id = 36751;
                break;               // 20%
            // Rank 3
            case  6:
                spell_id = 36754;
                break;               //  0% [ 7% == 6, 14% == 6]
            case  7:
                spell_id = 36755;
                break;               // 20%
            // Rank 4
            case  9:
                spell_id = 36761;
                break;               //  0% [ 7% == 6]
            case 10:
                spell_id = 36758;
                break;               // 14%
            case 11:
                spell_id = 36760;
                break;               // 20%
            default:
                LOG_ERROR("spells.effect", "Spell::EffectEnchantItemTmp: Damage {} not handled in S'RW", damage);
                return;
        }
 
        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell_id);
        if (!spellInfo)
        {
            LOG_ERROR("spells.effect", "Spell::EffectEnchantItemTmp: unknown spell id {}", spell_id);
            return;
        }
 
        for (int j = BASE_ATTACK; j <= OFF_ATTACK; ++j)
        {
            if (Item* item = p_caster->GetWeaponForAttack(WeaponAttackType(j)))
            {
                if (item->IsFitToSpellRequirements(m_spellInfo))
                {
                    Spell* spell = new Spell(m_caster, spellInfo, TRIGGERED_FULL_MASK);
                    SpellCastTargets targets;
                    targets.SetItemTarget(item);
                    spell->prepare(&targets);
                }
            }
        }
        return;
    }
    if (!itemTarget)
        return;
 
    uint32 enchant_id = m_spellInfo->Effects[effIndex].MiscValue;
 
    if (!enchant_id)
    {
        LOG_ERROR("spells.effect", "Spell {} Effect {} (SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY) have 0 as enchanting id", m_spellInfo->Id, effIndex);
        return;
    }
 
    SpellItemEnchantmentEntry const* pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
    if (!pEnchant)
    {
        LOG_ERROR("spells.effect", "Spell {} Effect {} (SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY) have not existed enchanting id {} ", m_spellInfo->Id, effIndex, enchant_id);
        return;
    }
 
    // select enchantment duration
    uint32 duration;
 
    // rogue family enchantments exception by duration
    if (m_spellInfo->Id == 38615)
        duration = 1800;                                    // 30 mins
    // other rogue family enchantments always 1 hour (some have spell damage=0, but some have wrong data in EffBasePoints)
    else if (m_spellInfo->SpellFamilyName == SPELLFAMILY_ROGUE)
        duration = 3600;                                    // 1 hour
    // shaman family enchantments
    else if (m_spellInfo->SpellFamilyName == SPELLFAMILY_SHAMAN)
        duration = 1800;                                    // 30 mins
    // other cases with this SpellVisual already selected
    else if (m_spellInfo->SpellVisual[0] == 215)
        duration = 1800;                                    // 30 mins
    // some fishing pole bonuses except Glow Worm which lasts full hour
    else if (m_spellInfo->SpellVisual[0] == 563 && m_spellInfo->Id != 64401)
        duration = 600;                                     // 10 mins
    // shaman rockbiter enchantments
    else if (m_spellInfo->SpellVisual[0] == 0)
        duration = 1800;                                    // 30 mins
    else if (m_spellInfo->Id == 29702)
        duration = 300;                                     // 5 mins
    else if (m_spellInfo->Id == 37360)
        duration = 300;                                     // 5 mins
    // default case
    else
        duration = 3600;                                    // 1 hour
 
    // item can be in trade slot and have owner diff. from caster
    Player* item_owner = itemTarget->GetOwner();
    if (!item_owner)
        return;
 
    // remove old enchanting before applying new if equipped
    item_owner->ApplyEnchantment(itemTarget, TEMP_ENCHANTMENT_SLOT, false);
 
    itemTarget->SetEnchantment(TEMP_ENCHANTMENT_SLOT, enchant_id, duration * 1000, pEnchant->charges, m_caster->GetGUID());
 
    // add new enchanting if equipped
    item_owner->ApplyEnchantment(itemTarget, TEMP_ENCHANTMENT_SLOT, true);
 
    if (item_owner != p_caster && p_caster->GetSession()->HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
    {
        LOG_GM(p_caster->GetSession()->GetAccountId(), "GM {} (Account: {}) enchanting(temp): {} (SpellID: {} EncID: {}) on {}'s item: {} (Entry: {})",
            p_caster->GetName(), p_caster->GetSession()->GetAccountId(),
            m_spellInfo->SpellName[0], m_spellInfo->Id, enchant_id,
            item_owner->GetName(), itemTarget->GetTemplate()->Name1, itemTarget->GetEntry());
    }
 
    item_owner->RemoveTradeableItem(itemTarget);
    itemTarget->ClearSoulboundTradeable(item_owner);
}

References Player::ApplyEnchantment(), BASE_ATTACK, SpellItemEnchantmentEntry::charges, Item::ClearSoulboundTradeable(), damage, effectHandleMode, SpellInfo::Effects, WorldSession::GetAccountId(), Object::GetEntry(), Object::GetGUID(), WorldObject::GetName(), Item::GetOwner(), Player::GetSession(), Item::GetTemplate(), Player::GetWeaponForAttack(), WorldSession::HasPermission(), SpellInfo::Id, Object::IsPlayer(), itemTarget, LOG_ERROR, LOG_GM, m_caster, m_spellInfo, ItemTemplate::Name1, OFF_ATTACK, prepare(), rbac::RBAC_PERM_LOG_GM_TRADE, Player::RemoveTradeableItem(), Item::SetEnchantment(), SpellCastTargets::SetItemTarget(), SPELL_EFFECT_HANDLE_HIT_TARGET, SPELLFAMILY_ROGUE, SPELLFAMILY_SHAMAN, SpellInfo::SpellFamilyFlags, SpellInfo::SpellFamilyName, SpellInfo::SpellName, SpellInfo::SpellVisual, sSpellItemEnchantmentStore, sSpellMgr, TEMP_ENCHANTMENT_SLOT, Object::ToPlayer(), and TRIGGERED_FULL_MASK.

◆ EffectEnergize()

void Spell::EffectEnergize ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
    if (!unitTarget->IsAlive())
        return;
 
    if (unitTarget->IsImmunedToAuraPeriodicTick(m_caster, m_spellInfo))
    {
        m_caster->SendSpellDamageImmune(unitTarget, GetSpellInfo()->Id);
        return;
    }
 
    if (m_spellInfo->Effects[effIndex].MiscValue < 0 || m_spellInfo->Effects[effIndex].MiscValue >= int8(MAX_POWERS))
        return;
 
    Powers power = Powers(m_spellInfo->Effects[effIndex].MiscValue);
 
    if (unitTarget->IsPlayer() && !unitTarget->HasActivePowerType(power) && m_spellInfo->SpellFamilyName != SPELLFAMILY_POTION
            && !m_spellInfo->HasAttribute(SPELL_ATTR7_ONLY_IN_SPELLBOOK_UNTIL_LEARNED))
        return;
 
    if (unitTarget->GetMaxPower(power) == 0)
        return;
 
    // Some level depends spells
    int level_multiplier = 0;
    int level_diff = 0;
    switch (m_spellInfo->Id)
    {
        case 9512:                                          // Restore Energy
            level_diff = m_caster->GetLevel() - 40;
            level_multiplier = 2;
            break;
        case 24571:                                         // Blood Fury
            level_diff = m_caster->GetLevel() - 60;
            level_multiplier = 10;
            break;
        case 24532:                                         // Burst of Energy
            level_diff = m_caster->GetLevel() - 60;
            level_multiplier = 4;
            break;
        case 31930:                                         // Judgements of the Wise
        case 63375:                                         // Improved Stormstrike
        case 68082:                                         // Glyph of Seal of Command
            damage = int32(CalculatePct(unitTarget->GetCreateMana(), damage));
            break;
        case 48542:                                         // Revitalize
            damage = int32(CalculatePct(unitTarget->GetMaxPower(power), damage));
            break;
        case 71132:                                         // Glyph of Shadow Word: Pain
            damage = int32(CalculatePct(unitTarget->GetCreateMana(), 1));  // set 1 as value, missing in dbc
            break;
        default:
            break;
    }
 
    if (level_diff > 0)
        damage -= level_multiplier * level_diff;
 
    if (damage < 0)
        return;
 
    m_caster->EnergizeBySpell(unitTarget, m_spellInfo->Id, damage, power);
 
    // Mad Alchemist's Potion
    if (m_spellInfo->Id == 45051)
    {
        // find elixirs on target
        bool guardianFound = false;
        bool battleFound = false;
        Unit::AuraApplicationMap& Auras = unitTarget->GetAppliedAuras();
        for (Unit::AuraApplicationMap::iterator itr = Auras.begin(); itr != Auras.end(); ++itr)
        {
            if (!guardianFound && sSpellMgr->IsSpellMemberOfSpellGroup(itr->second->GetBase()->GetId(), SPELL_GROUP_ELIXIR_GUARDIAN))
                guardianFound = true;
            if (!battleFound && sSpellMgr->IsSpellMemberOfSpellGroup(itr->second->GetBase()->GetId(), SPELL_GROUP_ELIXIR_BATTLE))
                battleFound = true;
            if (battleFound && guardianFound)
                break;
        }
 
        // get all available elixirs by mask and spell level
        std::set<uint32> availableElixirs;
        if (!guardianFound)
            sSpellMgr->GetSetOfSpellsInSpellGroup(SPELL_GROUP_ELIXIR_GUARDIAN, availableElixirs);
        if (!battleFound)
            sSpellMgr->GetSetOfSpellsInSpellGroup(SPELL_GROUP_ELIXIR_BATTLE, availableElixirs);
        for (std::set<uint32>::iterator itr = availableElixirs.begin(); itr != availableElixirs.end();)
        {
            SpellInfo const* spellInfo = sSpellMgr->AssertSpellInfo(*itr);
            if (spellInfo->SpellLevel < m_spellInfo->SpellLevel || spellInfo->SpellLevel > unitTarget->GetLevel())
                availableElixirs.erase(itr++);
            else
                ++itr;
        }
 
        if (!availableElixirs.empty())
        {
            // cast random elixir on target
            m_caster->CastSpell(unitTarget, Acore::Containers::SelectRandomContainerElement(availableElixirs), true, m_CastItem);
        }
    }
}

References CalculatePct(), Unit::CastSpell(), damage, effectHandleMode, SpellInfo::Effects, Unit::EnergizeBySpell(), Unit::GetAppliedAuras(), Unit::GetCreateMana(), Unit::GetLevel(), Unit::GetMaxPower(), GetSpellInfo(), Unit::HasActivePowerType(), SpellInfo::HasAttribute(), SpellInfo::Id, Unit::IsAlive(), Unit::IsImmunedToAuraPeriodicTick(), Object::IsPlayer(), m_caster, m_CastItem, m_spellInfo, MAX_POWERS, Acore::Containers::SelectRandomContainerElement(), Unit::SendSpellDamageImmune(), SPELL_ATTR7_ONLY_IN_SPELLBOOK_UNTIL_LEARNED, SPELL_EFFECT_HANDLE_HIT_TARGET, SPELL_GROUP_ELIXIR_BATTLE, SPELL_GROUP_ELIXIR_GUARDIAN, SPELLFAMILY_POTION, SpellInfo::SpellFamilyName, SpellInfo::SpellLevel, sSpellMgr, and unitTarget.

◆ EffectEnergizePct()

void Spell::EffectEnergizePct ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
    if (!unitTarget->IsAlive())
        return;
 
    if (unitTarget->HasUnitState(UNIT_STATE_ISOLATED))
    {
        m_caster->SendSpellDamageImmune(unitTarget, GetSpellInfo()->Id);
        return;
    }
 
    if (m_spellInfo->Effects[effIndex].MiscValue < 0 || m_spellInfo->Effects[effIndex].MiscValue >= int8(MAX_POWERS))
        return;
 
    Powers power = Powers(m_spellInfo->Effects[effIndex].MiscValue);
 
    if (unitTarget->IsPlayer() && !unitTarget->HasActivePowerType(power) && !m_spellInfo->HasAttribute(SPELL_ATTR7_ONLY_IN_SPELLBOOK_UNTIL_LEARNED))
        return;
 
    uint32 maxPower = unitTarget->GetMaxPower(power);
    if (maxPower == 0)
        return;
 
    uint32 gain = CalculatePct(maxPower, damage);
    m_caster->EnergizeBySpell(unitTarget, m_spellInfo->Id, gain, power);
}

References CalculatePct(), damage, effectHandleMode, SpellInfo::Effects, Unit::EnergizeBySpell(), Unit::GetMaxPower(), GetSpellInfo(), Unit::HasActivePowerType(), SpellInfo::HasAttribute(), Unit::HasUnitState(), SpellInfo::Id, Unit::IsAlive(), Object::IsPlayer(), m_caster, m_spellInfo, MAX_POWERS, Unit::SendSpellDamageImmune(), SPELL_ATTR7_ONLY_IN_SPELLBOOK_UNTIL_LEARNED, SPELL_EFFECT_HANDLE_HIT_TARGET, UNIT_STATE_ISOLATED, and unitTarget.

◆ EffectEnvironmentalDMG()

void Spell::EffectEnvironmentalDMG ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget || !unitTarget->IsAlive())
        return;
 
    if (unitTarget->IsPlayer())
        unitTarget->ToPlayer()->EnvironmentalDamage(DAMAGE_FIRE, damage);
    else
    {
        DamageInfo dmgInfo(m_caster, unitTarget, damage, m_spellInfo, m_spellInfo->GetSchoolMask(), SPELL_DIRECT_DAMAGE);
 
        uint32 absorb = dmgInfo.GetAbsorb();
        uint32 resist = dmgInfo.GetResist();
        uint32 envDamage = dmgInfo.GetDamage();
 
        Unit::DealDamageMods(unitTarget, envDamage, &absorb);
        damage = envDamage;
 
        m_caster->SendSpellNonMeleeDamageLog(unitTarget, m_spellInfo, damage, m_spellInfo->GetSchoolMask(), absorb, resist, false, 0);
    }
}

References damage, DAMAGE_FIRE, Unit::DealDamageMods(), effectHandleMode, Player::EnvironmentalDamage(), DamageInfo::GetAbsorb(), DamageInfo::GetDamage(), DamageInfo::GetResist(), SpellInfo::GetSchoolMask(), Unit::IsAlive(), Object::IsPlayer(), m_caster, m_spellInfo, Unit::SendSpellNonMeleeDamageLog(), SPELL_DIRECT_DAMAGE, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectFeedPet()

void Spell::EffectFeedPet ( SpellEffIndex effIndex )

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

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

References Unit::CastCustomSpell(), Player::DestroyItemCount(), effectHandleMode, SpellInfo::Effects, ExecuteLogEffectDestroyItem(), Pet::GetCurrentFoodBenefitLevel(), Object::GetEntry(), Player::GetPet(), Item::GetTemplate(), Unit::IsAlive(), ItemTemplate::ItemLevel, itemTarget, m_caster, m_spellInfo, SPELL_EFFECT_HANDLE_HIT_TARGET, and Object::ToPlayer().

◆ EffectForceCast()

void Spell::EffectForceCast ( SpellEffIndex effIndex )

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

References CustomSpellValues::AddSpellMod(), Unit::CastCustomSpell(), Unit::CastSpell(), damage, effectHandleMode, SpellInfo::Effects, SpellInfo::Id, LOG_ERROR, m_caster, m_originalCasterGUID, m_spellInfo, Unit::RemoveAura(), SpellCastTargets::SetUnitTarget(), SPELL_EFFECT_FORCE_CAST, SPELL_EFFECT_FORCE_CAST_WITH_VALUE, SPELL_EFFECT_HANDLE_HIT_TARGET, SPELLVALUE_BASE_POINT0, SPELLVALUE_BASE_POINT1, SPELLVALUE_BASE_POINT2, sSpellMgr, TRIGGERED_FULL_MASK, and unitTarget.

◆ EffectForceDeselect()

void Spell::EffectForceDeselect ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
        return;
 
    // xinef: clear focus
    m_caster->SendClearTarget();
 
    WorldPacket data(SMSG_CLEAR_TARGET, 8);
    data << m_caster->GetGUID();
 
    float dist = m_caster->GetVisibilityRange() + VISIBILITY_COMPENSATION;
    Acore::MessageDistDelivererToHostile notifier(m_caster, &data, dist);
    Cell::VisitObjects(m_caster, notifier, dist);
 
    // xinef: we should also force pets to remove us from current target
    Unit::AttackerSet attackerSet;
    for (Unit::AttackerSet::const_iterator itr = m_caster->getAttackers().begin(); itr != m_caster->getAttackers().end(); ++itr)
        if ((*itr)->IsCreature() && !(*itr)->CanHaveThreatList())
            attackerSet.insert(*itr);
 
    for (Unit::AttackerSet::const_iterator itr = attackerSet.begin(); itr != attackerSet.end(); ++itr)
        (*itr)->AttackStop();
 
    // Xinef: Mirror images code Initialize Images
    if (m_spellInfo->Id == 58836)
    {
        std::vector<Unit*> images;
        for (Unit::ControlSet::const_iterator itr = m_caster->m_Controlled.begin(); itr != m_caster->m_Controlled.end(); ++itr)
            if ((*itr)->GetEntry() == 31216 /*NPC_MIRROR_IMAGE*/)
                images.push_back(*itr);
 
        if (images.empty())
            return;
 
        UnitList targets;
        Acore::AnyUnfriendlyUnitInObjectRangeCheck u_check(m_caster, m_caster, m_caster->GetVisibilityRange()); // no VISIBILITY_COMPENSATION, distance is enough
        Acore::UnitListSearcher<Acore::AnyUnfriendlyUnitInObjectRangeCheck> searcher(m_caster, targets, u_check);
        Cell::VisitObjects(m_caster, searcher, m_caster->GetVisibilityRange());
        for (UnitList::iterator iter = targets.begin(); iter != targets.end(); ++iter)
        {
            if (!(*iter)->HasUnitState(UNIT_STATE_CASTING))
                continue;
 
            if (Spell* spell = (*iter)->GetCurrentSpell(CURRENT_GENERIC_SPELL))
            {
                if (spell->m_targets.GetUnitTargetGUID() == m_caster->GetGUID())
                {
                    SpellInfo const* si = spell->GetSpellInfo();
                    if (si->HasAttribute(SPELL_ATTR6_IGNORE_PHASE_SHIFT) && (*iter)->IsCreature())
                    {
                        Creature* c = (*iter)->ToCreature();
                        if ((!c->IsPet() && c->GetCreatureTemplate()->rank == CREATURE_ELITE_WORLDBOSS) || c->isWorldBoss() || c->IsDungeonBoss())
                            continue;
                    }
 
                    bool interrupt = false; // pussywizard: skip spells that don't target units, but casted on unit (eg. TARGET_DEST_TARGET_ENEMY)
                    for (uint8 j = 0; j < MAX_SPELL_EFFECTS; ++j)
                        if (si->Effects[j].Effect && (si->Effects[j].GetUsedTargetObjectType() == TARGET_OBJECT_TYPE_UNIT || si->Effects[j].GetUsedTargetObjectType() == TARGET_OBJECT_TYPE_UNIT_AND_DEST))
                        {
                            // at least one effect truly targets an unit, interrupt the spell
                            interrupt = true;
                            break;
                        }
 
                    if (interrupt)
                        spell->m_targets.SetUnitTarget(images.at(urand(0, images.size() - 1)));
                }
            }
        }
    }
}

References CREATURE_ELITE_WORLDBOSS, CURRENT_GENERIC_SPELL, effectHandleMode, SpellInfo::Effects, Unit::getAttackers(), Creature::GetCreatureTemplate(), Object::GetGUID(), WorldObject::GetVisibilityRange(), SpellInfo::HasAttribute(), SpellInfo::Id, Creature::IsDungeonBoss(), Unit::IsPet(), Creature::isWorldBoss(), m_caster, Unit::m_Controlled, m_spellInfo, MAX_SPELL_EFFECTS, CreatureTemplate::rank, Unit::SendClearTarget(), SMSG_CLEAR_TARGET, SPELL_ATTR6_IGNORE_PHASE_SHIFT, SPELL_EFFECT_HANDLE_HIT, TARGET_OBJECT_TYPE_UNIT, TARGET_OBJECT_TYPE_UNIT_AND_DEST, Object::ToCreature(), UNIT_STATE_CASTING, urand(), VISIBILITY_COMPENSATION, and Cell::VisitObjects().

◆ EffectGameObjectDamage()

void Spell::EffectGameObjectDamage ( SpellEffIndex effIndex )

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

References damage, effectHandleMode, GAMEOBJECT_FACTION, gameObjTarget, Unit::GetFactionTemplateEntry(), GetSpellInfo(), Object::GetUInt32Value(), FactionTemplateEntry::IsFriendlyTo(), m_originalCaster, GameObject::ModifyHealth(), sFactionTemplateStore, and SPELL_EFFECT_HANDLE_HIT_TARGET.

◆ EffectGameObjectRepair()

void Spell::EffectGameObjectRepair ( SpellEffIndex effIndex )

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

References damage, effectHandleMode, gameObjTarget, m_caster, GameObject::ModifyHealth(), and SPELL_EFFECT_HANDLE_HIT_TARGET.

◆ EffectGameObjectSetDestructionState()

void Spell::EffectGameObjectSetDestructionState ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!gameObjTarget || !m_originalCaster)
        return;
 
    Player* player = m_originalCaster->GetCharmerOrOwnerPlayerOrPlayerItself();
    gameObjTarget->SetDestructibleState(GameObjectDestructibleState(m_spellInfo->Effects[effIndex].MiscValue), player, true);
}

References effectHandleMode, SpellInfo::Effects, gameObjTarget, Unit::GetCharmerOrOwnerPlayerOrPlayerItself(), m_originalCaster, m_spellInfo, GameObject::SetDestructibleState(), and SPELL_EFFECT_HANDLE_HIT_TARGET.

◆ EffectHeal()

void Spell::EffectHeal ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
        return;
 
    if (unitTarget && unitTarget->IsAlive() && damage >= 0)
    {
        // Try to get original caster
        Unit* caster = m_originalCasterGUID ? m_originalCaster : m_caster;
 
        // Skip if m_originalCaster not available
        if (!caster)
            return;
 
        int32 addhealth = damage;
 
        // Vessel of the Naaru (Vial of the Sunwell trinket)
        if (m_spellInfo->Id == 45064)
        {
            // Amount of heal - depends from stacked Holy Energy
            int damageAmount = 0;
            if (AuraEffect const* aurEff = m_caster->GetAuraEffect(45062, 0))
            {
                damageAmount += aurEff->GetAmount();
                m_caster->RemoveAurasDueToSpell(45062);
            }
 
            addhealth += damageAmount;
        }
        // Swiftmend - consumes Regrowth or Rejuvenation
        else if (m_spellInfo->TargetAuraState == AURA_STATE_SWIFTMEND && unitTarget->HasAuraState(AURA_STATE_SWIFTMEND, m_spellInfo, m_caster))
        {
            Unit::AuraEffectList const& RejorRegr = unitTarget->GetAuraEffectsByType(SPELL_AURA_PERIODIC_HEAL);
            // find most short by duration
            AuraEffect* forcedTargetAura = nullptr;
            AuraEffect* targetAura = nullptr;
            for (Unit::AuraEffectList::const_iterator i = RejorRegr.begin(); i != RejorRegr.end(); ++i)
            {
                if ((*i)->GetSpellInfo()->SpellFamilyName == SPELLFAMILY_DRUID
                        && (*i)->GetSpellInfo()->SpellFamilyFlags[0] & 0x50)
                {
                    if (m_caster->GetGUID() == (*i)->GetCasterGUID())
                    {
                        if (!forcedTargetAura || (*i)->GetBase()->GetDuration() < forcedTargetAura->GetBase()->GetDuration())
                            forcedTargetAura = *i;
                    }
                    else if (!targetAura || (*i)->GetBase()->GetDuration() < targetAura->GetBase()->GetDuration())
                        targetAura = *i;
                }
            }
 
            if (forcedTargetAura)
                targetAura = forcedTargetAura;
 
            if (!targetAura)
            {
                LOG_ERROR("spells.effect", "Target({}) has aurastate AURA_STATE_SWIFTMEND but no matching aura.", unitTarget->GetGUID().ToString());
                return;
            }
 
            int32 tickheal = targetAura->GetAmount();
            if (Unit* auraCaster = targetAura->GetCaster())
            {
                // MOD_HEALING_DONE_PERCENT is applied per-tick, not baked into GetAmount.
                tickheal = int32(float(tickheal) * auraCaster->GetTotalAuraMultiplier(SPELL_AURA_MOD_HEALING_DONE_PERCENT));
                tickheal = unitTarget->SpellHealingBonusTaken(auraCaster, targetAura->GetSpellInfo(), tickheal, DOT);
            }
 
            //int32 tickheal = targetAura->GetSpellInfo()->EffectBasePoints[idx] + 1;
            //It is said that talent bonus should not be included
 
            int32 tickcount = 0;
            // Rejuvenation
            if (targetAura->GetSpellInfo()->SpellFamilyFlags[0] & 0x10)
                tickcount = 4;
            // Regrowth
            else // if (targetAura->GetSpellInfo()->SpellFamilyFlags[0] & 0x40)
                tickcount = 6;
 
            addhealth += tickheal * tickcount;
 
            // Glyph of Swiftmend
            if (!caster->HasAura(54824))
                unitTarget->RemoveAura(targetAura->GetId(), targetAura->GetCasterGUID());
 
            //addhealth += tickheal * tickcount;
            //addhealth = caster->SpellHealingBonus(m_spellInfo, addhealth, HEAL, unitTarget);
        }
        // Death Pact - return pct of max health to caster
        else if (m_spellInfo->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT && m_spellInfo->SpellFamilyFlags[0] & 0x00080000)
        {
            addhealth = caster->SpellHealingBonusDone(unitTarget, m_spellInfo, int32(caster->CountPctFromMaxHealth(damage)), HEAL, effIndex);
            m_damageBeforeTakenMods -= addhealth;
            addhealth = unitTarget->SpellHealingBonusTaken(caster, m_spellInfo, addhealth, HEAL);
        }
        else if (m_spellInfo->Id != 33778) // not lifebloom
        {
            addhealth = caster->SpellHealingBonusDone(unitTarget, m_spellInfo, addhealth, HEAL, effIndex);
            m_damageBeforeTakenMods -= addhealth;
            addhealth = unitTarget->SpellHealingBonusTaken(caster, m_spellInfo, addhealth, HEAL);
        }
 
        // Implemented this way as there is no other way to do it currently (that I know :P)...
        if (caster->ToPlayer() && caster->HasAura(23401)) // Nefarian Corrupted Healing (priest)
        {
            if (!m_spellInfo->HasAura(SPELL_AURA_PERIODIC_HEAL) && (m_spellInfo->GetSchoolMask() & SPELL_SCHOOL_MASK_HOLY))
            {
                m_damage = 0;
                caster->CastSpell(unitTarget, 23402, false); // Nefarian Corrupted Healing Periodic Damage effect.
                return;
            }
        }
 
        m_damage -= addhealth;
    }
}

References AURA_STATE_SWIFTMEND, Unit::CastSpell(), Unit::CountPctFromMaxHealth(), damage, DOT, effectHandleMode, AuraEffect::GetAmount(), Unit::GetAuraEffect(), Unit::GetAuraEffectsByType(), AuraEffect::GetBase(), AuraEffect::GetCaster(), AuraEffect::GetCasterGUID(), Aura::GetDuration(), Object::GetGUID(), AuraEffect::GetId(), SpellInfo::GetSchoolMask(), AuraEffect::GetSpellInfo(), SpellInfo::HasAura(), Unit::HasAura(), Unit::HasAuraState(), HEAL, SpellInfo::Id, Unit::IsAlive(), LOG_ERROR, m_caster, m_damage, m_damageBeforeTakenMods, m_originalCaster, m_originalCasterGUID, m_spellInfo, Unit::RemoveAura(), Unit::RemoveAurasDueToSpell(), SPELL_AURA_MOD_HEALING_DONE_PERCENT, SPELL_AURA_PERIODIC_HEAL, SPELL_EFFECT_HANDLE_LAUNCH_TARGET, SPELL_SCHOOL_MASK_HOLY, SPELLFAMILY_DEATHKNIGHT, SPELLFAMILY_DRUID, SpellInfo::SpellFamilyFlags, SpellInfo::SpellFamilyName, Unit::SpellHealingBonusDone(), Unit::SpellHealingBonusTaken(), SpellInfo::TargetAuraState, Object::ToPlayer(), ObjectGuid::ToString(), and unitTarget.

◆ EffectHealMaxHealth()

void Spell::EffectHealMaxHealth ( SpellEffIndex effIndex )

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

References damage, effectHandleMode, Unit::GetHealth(), Unit::GetMaxHealth(), GetSpellInfo(), Unit::IsAlive(), Unit::IsImmunedToAuraPeriodicTick(), m_caster, m_healing, m_spellInfo, Unit::SendSpellDamageImmune(), SPELL_EFFECT_HANDLE_HIT_TARGET, and unitTarget.

◆ EffectHealMechanical()

void Spell::EffectHealMechanical ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
        return;
 
    if (!unitTarget || !unitTarget->IsAlive() || damage < 0)
        return;
 
    // Skip if m_originalCaster not available
    if (!m_originalCaster)
        return;
 
    uint32 heal = m_originalCaster->SpellHealingBonusDone(unitTarget, m_spellInfo, uint32(damage), HEAL, effIndex);
    m_damageBeforeTakenMods -= heal;
 
    m_damage -= unitTarget->SpellHealingBonusTaken(m_originalCaster, m_spellInfo, heal, HEAL);
}

References damage, effectHandleMode, HEAL, Unit::IsAlive(), m_damage, m_damageBeforeTakenMods, m_originalCaster, m_spellInfo, SPELL_EFFECT_HANDLE_LAUNCH_TARGET, Unit::SpellHealingBonusDone(), Unit::SpellHealingBonusTaken(), and unitTarget.

◆ EffectHealPct()

void Spell::EffectHealPct ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
        return;
 
    if (!unitTarget || !unitTarget->IsAlive() || damage < 0)
        return;
 
    // Skip if m_originalCaster not available
    if (!m_originalCaster)
        return;
 
    uint32 heal = m_originalCaster->SpellHealingBonusDone(unitTarget, m_spellInfo, unitTarget->CountPctFromMaxHealth(damage), HEAL, effIndex);
    m_damageBeforeTakenMods -= heal;
    heal = unitTarget->SpellHealingBonusTaken(m_originalCaster, m_spellInfo, heal, HEAL);
 
    m_damage -= heal;
}

References Unit::CountPctFromMaxHealth(), damage, effectHandleMode, HEAL, Unit::IsAlive(), m_damage, m_damageBeforeTakenMods, m_originalCaster, m_spellInfo, SPELL_EFFECT_HANDLE_LAUNCH_TARGET, Unit::SpellHealingBonusDone(), Unit::SpellHealingBonusTaken(), and unitTarget.

◆ EffectHealthLeech()

void Spell::EffectHealthLeech ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget || !unitTarget->IsAlive() || damage < 0)
        return;
 
    damage = m_caster->SpellDamageBonusDone(unitTarget, m_spellInfo, uint32(damage), SPELL_DIRECT_DAMAGE, effIndex);
    damage = unitTarget->SpellDamageBonusTaken(m_caster, m_spellInfo, uint32(damage), SPELL_DIRECT_DAMAGE);
 
    LOG_DEBUG("spells.aura", "HealthLeech :{}", damage);
 
    // xinef: handled in spell.cpp
    //float healMultiplier = m_spellInfo->Effects[effIndex].CalcValueMultiplier(m_originalCaster, this);
 
    m_damage += damage;
    // get max possible damage, don't count overkill for heal
    //uint32 healthGain = uint32(-unitTarget->GetHealthGain(-damage) * healMultiplier);
 
    //if (m_caster->IsAlive())
    //{
    //    healthGain = m_caster->SpellHealingBonusDone(m_caster, m_spellInfo, healthGain, HEAL);
    //    healthGain = m_caster->SpellHealingBonusTaken(m_caster, m_spellInfo, healthGain, HEAL);
 
    //    m_caster->HealBySpell(m_caster, m_spellInfo, uint32(healthGain));
    //}
}

References damage, effectHandleMode, Unit::IsAlive(), LOG_DEBUG, m_caster, m_damage, m_spellInfo, SPELL_DIRECT_DAMAGE, SPELL_EFFECT_HANDLE_HIT_TARGET, Unit::SpellDamageBonusDone(), Unit::SpellDamageBonusTaken(), and unitTarget.

◆ EffectInebriate()

void Spell::EffectInebriate ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    Player* player = unitTarget->ToPlayer();
    if (!player)
    {
        return;
    }
 
    uint8 currentDrunk = player->GetDrunkValue();
    int32 drunkMod = damage;
 
    if (drunkMod == 0)
        return;
 
    // drunkMod may contain values ​​that are guaranteed to cause uint8 overflow/underflow (examples: 29690, 46874)
    // In addition, we would not want currentDrunk to become more than 100.
    // So before adding the values, let's check that everything is fine.
    if (drunkMod > 0 && drunkMod > static_cast<int32>(100 - currentDrunk))
        currentDrunk = 100;
    else if (drunkMod < 0 && drunkMod < static_cast<int32>(0 - currentDrunk))
        currentDrunk = 0;
    else
        currentDrunk += drunkMod; // Due to previous checks we can be sure that currentDrunk will not go beyond [0-100] range.
 
    player->SetDrunkValue(currentDrunk, m_CastItem ? m_CastItem->GetEntry() : 0);
 
    if (currentDrunk == 100 && roll_chance_i(25))
        player->CastSpell(player, 67468, false);    // Drunken Vomit
}

References Unit::CastSpell(), damage, effectHandleMode, Player::GetDrunkValue(), Object::GetEntry(), m_CastItem, roll_chance_i(), Player::SetDrunkValue(), SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectInstaKill()

void Spell::EffectInstaKill ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget || !unitTarget->IsAlive() || unitTarget->HasAura(27827)) // Spirit of redemption doesn't make you death, but can cause infinite loops
        return;
 
    if (unitTarget->IsPlayer())
        if (unitTarget->ToPlayer()->GetCommandStatus(CHEAT_GOD))
            return;
 
    if (m_caster == unitTarget)                              // prevent interrupt message
        finish();
 
    WorldPacket data(SMSG_SPELLINSTAKILLLOG, 8 + 8 + 4);
    data << m_caster->GetGUID();
    data << unitTarget->GetGUID();
    data << uint32(m_spellInfo->Id);
    m_caster->SendMessageToSet(&data, true);
 
    Unit::DealDamage(m_caster, unitTarget, unitTarget->GetHealth(), nullptr, NODAMAGE, SPELL_SCHOOL_MASK_NORMAL, nullptr, false);
}

References CHEAT_GOD, Unit::DealDamage(), effectHandleMode, finish(), Player::GetCommandStatus(), Object::GetGUID(), Unit::GetHealth(), Unit::HasAura(), SpellInfo::Id, Unit::IsAlive(), Object::IsPlayer(), m_caster, m_spellInfo, NODAMAGE, WorldObject::SendMessageToSet(), SMSG_SPELLINSTAKILLLOG, SPELL_EFFECT_HANDLE_HIT_TARGET, SPELL_SCHOOL_MASK_NORMAL, Object::ToPlayer(), and unitTarget.

◆ EffectInterruptCast()

void Spell::EffectInterruptCast ( SpellEffIndex effIndex )

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

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

References Unit::CalcSpellDuration(), CHANNEL_INTERRUPT_FLAG_INTERRUPT, SpellInfo::ChannelInterruptFlags, CURRENT_AUTOREPEAT_SPELL, CURRENT_CHANNELED_SPELL, CURRENT_FIRST_NON_MELEE_SPELL, CURRENT_GENERIC_SPELL, effectHandleMode, ExecuteLogEffectInterruptCast(), Unit::GetCurrentSpell(), SpellInfo::GetSchoolMask(), SpellInfo::Id, SpellInfo::InterruptFlags, Unit::InterruptSpell(), Unit::IsAlive(), m_originalCaster, m_spellInfo, Unit::ModSpellDuration(), SpellInfo::PreventionType, Unit::ProhibitSpellSchool(), SPELL_EFFECT_HANDLE_LAUNCH_TARGET, SPELL_INTERRUPT_FLAG_INTERRUPT, SPELL_PREVENTION_TYPE_SILENCE, SPELL_STATE_CASTING, SPELL_STATE_PREPARING, and unitTarget.

◆ EffectJump()

void Spell::EffectJump ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
        return;
 
    if (m_caster->IsInFlight())
        return;
 
    if (!unitTarget)
        return;
 
    float speedXY, speedZ;
    CalculateJumpSpeeds(effIndex, m_caster->GetExactDist2d(unitTarget), speedXY, speedZ);
    m_caster->GetMotionMaster()->MoveJump(*unitTarget, speedXY, speedZ);
 
    if (m_caster->IsPlayer())
    {
        sScriptMgr->AnticheatSetUnderACKmount(m_caster->ToPlayer());
    }
}

References CalculateJumpSpeeds(), effectHandleMode, Position::GetExactDist2d(), Unit::GetMotionMaster(), Unit::IsInFlight(), Object::IsPlayer(), m_caster, MotionMaster::MoveJump(), SPELL_EFFECT_HANDLE_LAUNCH_TARGET, sScriptMgr, Object::ToPlayer(), and unitTarget.

◆ EffectJumpDest()

void Spell::EffectJumpDest ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)
        return;
 
    if (m_caster->IsInFlight())
        return;
 
    if (!m_targets.HasDst() || m_caster->GetVehicle())
        return;
 
    // Init dest coordinates
    float x, y, z;
    destTarget->GetPosition(x, y, z);
    // xinef: this can happen if MovePositionToFirstCollision detects that X, Y cords are invalid and returns prematurely
    if (!Acore::IsValidMapCoord(x, y, z) || z <= INVALID_HEIGHT)
        return;
 
    float speedXY, speedZ;
    float dist = m_caster->GetExactDist2d(x, y);
    CalculateJumpSpeeds(effIndex, dist, speedXY, speedZ);
 
    // Override, calculations are incorrect
    if (m_spellInfo->Id == 49376) // feral charge
    {
        speedXY = pow(speedZ * 10, 8);
        m_caster->GetMotionMaster()->MoveJump(x, y, z, speedXY, speedZ, 0, ObjectAccessor::GetUnit(*m_caster, m_caster->GetGuidValue(UNIT_FIELD_TARGET)));
 
        if (Player* player = m_caster->ToPlayer())
        {
            player->SetCanTeleport(true);
        }
 
        if (m_caster->IsPlayer())
        {
            sScriptMgr->AnticheatSetUnderACKmount(m_caster->ToPlayer());
        }
 
        return;
    }
 
    if (m_spellInfo->Id == 57604) // death grip
    {
        speedZ = 3.0f;
        speedXY = 50.0f;
    }
 
    // crash fix?
    if (speedXY < 1.0f)
        speedXY = 1.0f;
 
    if (Player* player = m_caster->ToPlayer())
    {
        player->SetCanTeleport(true);
    }
    m_caster->GetMotionMaster()->MoveJump(x, y, z, speedXY, speedZ);
 
    if (m_caster->IsPlayer())
    {
        sScriptMgr->AnticheatSetUnderACKmount(m_caster->ToPlayer());
    }
}

References CalculateJumpSpeeds(), destTarget, effectHandleMode, Position::GetExactDist2d(), Object::GetGuidValue(), Unit::GetMotionMaster(), Position::GetPosition(), ObjectAccessor::GetUnit(), Unit::GetVehicle(), SpellCastTargets::HasDst(), SpellInfo::Id, INVALID_HEIGHT, Unit::IsInFlight(), Object::IsPlayer(), Acore::IsValidMapCoord(), m_caster, m_spellInfo, m_targets, MotionMaster::MoveJump(), SPELL_EFFECT_HANDLE_LAUNCH, sScriptMgr, Object::ToPlayer(), and UNIT_FIELD_TARGET.

◆ EffectKillCredit()

void Spell::EffectKillCredit ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    Player* player = unitTarget->GetCharmerOrOwnerPlayerOrPlayerItself();
    if (!player)
    {
        return;
    }
 
    int32 creatureEntry = m_spellInfo->Effects[effIndex].MiscValue;
    if (!creatureEntry)
    {
        if (m_spellInfo->Id == 42793) // Burn Body
            creatureEntry = 24008; // Fallen Combatant
    }
 
    if (creatureEntry)
        player->RewardPlayerAndGroupAtEvent(creatureEntry, unitTarget);
}

References effectHandleMode, SpellInfo::Effects, Unit::GetCharmerOrOwnerPlayerOrPlayerItself(), SpellInfo::Id, m_spellInfo, Player::RewardPlayerAndGroupAtEvent(), SPELL_EFFECT_HANDLE_HIT_TARGET, and unitTarget.

◆ EffectKillCreditPersonal()

void Spell::EffectKillCreditPersonal ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    if (Player* player = unitTarget->GetCharmerOrOwnerPlayerOrPlayerItself())
    {
        player->KilledMonsterCredit(m_spellInfo->Effects[effIndex].MiscValue);
    }
}

References effectHandleMode, SpellInfo::Effects, Unit::GetCharmerOrOwnerPlayerOrPlayerItself(), m_spellInfo, SPELL_EFFECT_HANDLE_HIT_TARGET, and unitTarget.

◆ EffectKnockBack()

void Spell::EffectKnockBack ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    // Xinef: allow entry specific spells to skip those checks
    if (m_spellInfo->Effects[effIndex].TargetA.GetCheckType() != TARGET_CHECK_ENTRY && m_spellInfo->Effects[effIndex].TargetB.GetCheckType() != TARGET_CHECK_ENTRY)
    {
        if (unitTarget->IsVehicle() && unitTarget->GetCreatureType() != CREATURE_TYPE_BEAST)
            return;
 
        if (unitTarget->GetVehicle())
            return;
 
        if (Creature* creatureTarget = unitTarget->ToCreature())
            if (creatureTarget->isWorldBoss() || creatureTarget->IsDungeonBoss() || creatureTarget->IsImmuneToKnockback() || unitTarget->ToCreature()->GetCreatureType() == CREATURE_TYPE_GIANT)
                return;
    }
 
    // Spells with SPELL_EFFECT_KNOCK_BACK(like Thunderstorm) can't knoback target if target has ROOT
    if (unitTarget->HasUnitState(UNIT_STATE_ROOT))
        return;
 
    // Instantly interrupt non melee spells being casted
    if (unitTarget->IsNonMeleeSpellCast(true))
        unitTarget->InterruptNonMeleeSpells(true);
 
    float ratio = 0.1f;
    float speedxy = float(m_spellInfo->Effects[effIndex].MiscValue) * ratio;
    float speedz = float(damage) * ratio;
    if (speedxy <= 0.1f && speedz <= 0.1f)
        return;
 
    float x, y;
    Unit* reflectionSource = m_reflectionTarget;
 
    if (!reflectionSource && !m_reflectionTargetGuid.IsEmpty())
    {
        if (Unit* resolvedSource = ObjectAccessor::GetUnit(*m_caster, m_reflectionTargetGuid))
            reflectionSource = resolvedSource;
    }
 
    if (reflectionSource)
    {
        reflectionSource->GetPosition(x, y);
    }
    else if (!m_reflectionTargetGuid.IsEmpty())
    {
        x = m_reflectionTargetPosition.GetPositionX();
        y = m_reflectionTargetPosition.GetPositionY();
    }
    else if (m_spellInfo->Effects[effIndex].Effect == SPELL_EFFECT_KNOCK_BACK_DEST)
    {
        if (m_targets.HasDst())
            destTarget->GetPosition(x, y);
        else
            return;
    }
    else //if (m_spellInfo->Effects[i].Effect == SPELL_EFFECT_KNOCK_BACK)
    {
        m_caster->GetPosition(x, y);
    }
 
    unitTarget->KnockbackFrom(x, y, speedxy, speedz);
 
    if (unitTarget->IsPlayer())
    {
        sScriptMgr->AnticheatSetUnderACKmount(unitTarget->ToPlayer());
    }
}

References CREATURE_TYPE_BEAST, CREATURE_TYPE_GIANT, damage, destTarget, effectHandleMode, SpellInfo::Effects, Unit::GetCreatureType(), Position::GetPosition(), Position::GetPositionX(), Position::GetPositionY(), ObjectAccessor::GetUnit(), Unit::GetVehicle(), SpellCastTargets::HasDst(), Unit::HasUnitState(), Unit::InterruptNonMeleeSpells(), ObjectGuid::IsEmpty(), Unit::IsNonMeleeSpellCast(), Object::IsPlayer(), Unit::IsVehicle(), Unit::KnockbackFrom(), m_caster, m_reflectionTarget, m_reflectionTargetGuid, m_reflectionTargetPosition, m_spellInfo, m_targets, SPELL_EFFECT_HANDLE_HIT_TARGET, SPELL_EFFECT_KNOCK_BACK_DEST, sScriptMgr, TARGET_CHECK_ENTRY, Object::ToCreature(), Object::ToPlayer(), UNIT_STATE_ROOT, and unitTarget.

◆ EffectLeap()

void Spell::EffectLeap ( SpellEffIndex effIndex )

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

References destTarget, effectHandleMode, Position::GetOrientation(), Position::GetPosition(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), SpellCastTargets::HasDst(), Unit::IsInFlight(), m_caster, m_targets, Unit::NearTeleportTo(), SPELL_EFFECT_HANDLE_HIT_TARGET, and unitTarget.

◆ EffectLeapBack()

void Spell::EffectLeapBack ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    float speedxy = m_spellInfo->Effects[effIndex].MiscValue / 10.0f;
    float speedz = damage / 10.0f;
    //1891: Disengage
    unitTarget->JumpTo(speedxy, speedz, m_spellInfo->SpellFamilyName != SPELLFAMILY_HUNTER);
 
    if (m_caster->IsPlayer())
    {
        sScriptMgr->AnticheatSetUnderACKmount(m_caster->ToPlayer());
    }
 
    // xinef: changes fall time
    if (m_caster->IsPlayer())
        m_caster->ToPlayer()->SetFallInformation(GameTime::GetGameTime().count(), m_caster->GetPositionZ());
}

References damage, effectHandleMode, SpellInfo::Effects, GameTime::GetGameTime(), Position::GetPositionZ(), Object::IsPlayer(), Unit::JumpTo(), m_caster, m_spellInfo, Player::SetFallInformation(), SPELL_EFFECT_HANDLE_LAUNCH_TARGET, SPELLFAMILY_HUNTER, SpellInfo::SpellFamilyName, sScriptMgr, Object::ToPlayer(), and unitTarget.

◆ EffectLearnPetSpell()

void Spell::EffectLearnPetSpell ( SpellEffIndex effIndex )

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

References effectHandleMode, EffectLearnSpell(), SpellInfo::Effects, Pet::GetOwner(), SpellInfo::Id, Pet::learnSpell(), m_spellInfo, PET_SAVE_AS_CURRENT, Player::PetSpellInitialize(), Pet::SavePetToDB(), SPELL_EFFECT_HANDLE_HIT_TARGET, sSpellMgr, Unit::ToPet(), Object::ToPlayer(), and unitTarget.

Referenced by EffectLearnSpell().

◆ EffectLearnSkill()

void Spell::EffectLearnSkill ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget->IsPlayer())
        return;
 
    if (damage < 0)
        return;
 
    uint32 skillid = m_spellInfo->Effects[effIndex].MiscValue;
    uint16 skillval = unitTarget->ToPlayer()->GetPureSkillValue(skillid);
    unitTarget->ToPlayer()->SetSkill(skillid, m_spellInfo->Effects[effIndex].CalcValue(), skillval ? skillval : 1, damage * 75);
}

References damage, effectHandleMode, SpellInfo::Effects, Player::GetPureSkillValue(), Object::IsPlayer(), m_spellInfo, Player::SetSkill(), SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectLearnSpell()

void Spell::EffectLearnSpell ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    if (!unitTarget->IsPlayer())
    {
        if (unitTarget->ToPet())
            EffectLearnPetSpell(effIndex);
        return;
    }
 
    Player* player = unitTarget->ToPlayer();
 
    uint32 spellToLearn = (m_spellInfo->Id == 483 || m_spellInfo->Id == 55884) ? damage : m_spellInfo->Effects[effIndex].TriggerSpell;
    player->learnSpell(spellToLearn);
 
    LOG_DEBUG("spells.aura", "Spell: Player {} has learned spell {} from Npc {}",
        player->GetGUID().ToString(), spellToLearn, m_caster->GetGUID().ToString());
}

References damage, effectHandleMode, EffectLearnPetSpell(), SpellInfo::Effects, Object::GetGUID(), SpellInfo::Id, Object::IsPlayer(), Player::learnSpell(), LOG_DEBUG, m_caster, m_spellInfo, SPELL_EFFECT_HANDLE_HIT_TARGET, Unit::ToPet(), Object::ToPlayer(), ObjectGuid::ToString(), and unitTarget.

Referenced by EffectLearnPetSpell().

◆ EffectMilling()

void Spell::EffectMilling ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!m_caster->IsPlayer())
        return;
 
    Player* p_caster = m_caster->ToPlayer();
    if (!itemTarget || !itemTarget->GetTemplate()->HasFlag(ITEM_FLAG_IS_MILLABLE))
        return;
 
    if (itemTarget->GetCount() < 5)
        return;
 
    if (sWorld->getBoolConfig(CONFIG_SKILL_MILLING))
    {
        uint32 SkillValue = p_caster->GetPureSkillValue(SKILL_INSCRIPTION);
        uint32 reqSkillValue = itemTarget->GetTemplate()->RequiredSkillRank;
        p_caster->UpdateGatherSkill(SKILL_INSCRIPTION, SkillValue, reqSkillValue);
    }
 
    m_caster->ToPlayer()->SendLoot(itemTarget->GetGUID(), LOOT_MILLING);
}

References CONFIG_SKILL_MILLING, effectHandleMode, Item::GetCount(), Object::GetGUID(), Player::GetPureSkillValue(), Item::GetTemplate(), ItemTemplate::HasFlag(), Object::IsPlayer(), ITEM_FLAG_IS_MILLABLE, itemTarget, LOOT_MILLING, m_caster, ItemTemplate::RequiredSkillRank, Player::SendLoot(), SKILL_INSCRIPTION, SPELL_EFFECT_HANDLE_HIT_TARGET, sWorld, Object::ToPlayer(), and Player::UpdateGatherSkill().

◆ EffectModifyThreatPercent()

void Spell::EffectModifyThreatPercent ( SpellEffIndex effIndex )

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

References damage, effectHandleMode, Unit::GetThreatMgr(), m_caster, ThreatManager::ModifyThreatByPercent(), SPELL_EFFECT_HANDLE_HIT_TARGET, and unitTarget.

◆ EffectNULL()

void Spell::EffectNULL ( SpellEffIndex effIndex )

{
    LOG_DEBUG("spells.aura", "WORLD: Spell Effect DUMMY");
}

References LOG_DEBUG.

Referenced by EffectPull().

◆ EffectOpenLock()

void Spell::EffectOpenLock ( SpellEffIndex effIndex )

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

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

References GameObject::AddToSkillupList(), BATTLEGROUND_EY, GameObjectTemplate::button, CanOpenLock(), effectHandleMode, ExecuteLogEffectOpenLock(), GAMEOBJECT_TYPE_BUTTON, GAMEOBJECT_TYPE_FLAGSTAND, GAMEOBJECT_TYPE_GOOBER, GAMEOBJECT_TYPE_TRAP, gameObjTarget, GameObjectTemplate::GetAutoCloseTime(), Player::GetBattleground(), GameObject::GetGOInfo(), Object::GetGUID(), GameObjectTemplate::GetLockId(), GameObject::getLootState(), GameObject::GetOwner(), Item::GetOwner(), Player::GetPureSkillValue(), Item::GetTemplate(), GO_JUST_DEACTIVATED, GameObjectTemplate::goober, SpellInfo::Id, IN_MILLISECONDS, GameObject::IsInSkillupList(), Object::IsPlayer(), ITEM_CHANGED, ITEM_FIELD_FLAG_UNLOCKED, ITEM_FIELD_FLAGS, itemTarget, ItemTemplate::LockID, LOG_DEBUG, LOOT_SKINNING, GameObjectTemplate::losOK, m_caster, m_CastItem, m_spellInfo, GameObjectTemplate::noDamageImmune, SendCastResult(), SendLoot(), Object::SetFlag(), GameObject::SetLootState(), GameObject::SetRespawnTime(), Item::SetState(), SKILL_NONE, sOutdoorPvPMgr, SPELL_CAST_OK, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), GameObjectTemplate::type, and Player::UpdateGatherSkill().

◆ EffectParry()

void Spell::EffectParry ( SpellEffIndex effIndex )

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

References effectHandleMode, Object::IsPlayer(), m_caster, Player::SetCanParry(), SPELL_EFFECT_HANDLE_HIT, and Object::ToPlayer().

◆ EffectPersistentAA()

void Spell::EffectPersistentAA ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
        return;
 
    if (!m_spellAura)
    {
        Unit* caster = m_caster->GetEntry() == WORLD_TRIGGER ? m_originalCaster : m_caster;
        float radius = m_spellInfo->Effects[effIndex].CalcRadius(caster);
 
        // Caster not in world, might be spell triggered from aura removal
        if (!caster->IsInWorld() || !caster->FindMap() || !ObjectAccessor::GetUnit(*caster, caster->GetGUID())) // pussywizard: temporary crash fix (FindMap and GetUnit are mine)
            return;
        DynamicObject* dynObj = new DynamicObject();
        if (!dynObj->CreateDynamicObject(caster->GetMap()->GenerateLowGuid<HighGuid::DynamicObject>(), caster, m_spellInfo->Id, *destTarget, radius, DYNAMIC_OBJECT_AREA_SPELL))
        {
            delete dynObj;
            return;
        }
 
        if (Aura* aura = Aura::TryCreate(m_spellInfo, MAX_EFFECT_MASK, dynObj, caster, &m_spellValue->EffectBasePoints[0]))
        {
            m_spellAura = aura;
            m_spellAura->SetTriggeredByAuraSpellInfo(m_triggeredByAuraSpell.spellInfo);
            m_spellAura->_RegisterForTargets();
        }
        else
            return;
    }
 
    ASSERT(m_spellAura->GetDynobjOwner());
    m_spellAura->_ApplyEffectForTargets(effIndex);
}

References Aura::_ApplyEffectForTargets(), Aura::_RegisterForTargets(), ASSERT, DynamicObject::CreateDynamicObject(), destTarget, DYNAMIC_OBJECT_AREA_SPELL, DynamicObject, SpellValue::EffectBasePoints, effectHandleMode, SpellInfo::Effects, WorldObject::FindMap(), Map::GenerateLowGuid(), Aura::GetDynobjOwner(), Object::GetEntry(), Object::GetGUID(), WorldObject::GetMap(), ObjectAccessor::GetUnit(), SpellInfo::Id, Object::IsInWorld(), m_caster, m_originalCaster, m_spellAura, m_spellInfo, m_spellValue, m_triggeredByAuraSpell, MAX_EFFECT_MASK, Aura::SetTriggeredByAuraSpellInfo(), SPELL_EFFECT_HANDLE_HIT, TriggeredByAuraSpellData::spellInfo, Aura::TryCreate(), and WORLD_TRIGGER.

◆ EffectPickPocket()

void Spell::EffectPickPocket ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!m_caster->IsPlayer())
        return;
 
    m_caster->ToPlayer()->SendLoot(unitTarget->GetGUID(), LOOT_PICKPOCKETING);
}

References effectHandleMode, Object::GetGUID(), Object::IsPlayer(), LOOT_PICKPOCKETING, m_caster, Player::SendLoot(), SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectPlayMusic()

void Spell::EffectPlayMusic ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    Player* player = unitTarget->ToPlayer();
    if (!player)
    {
        return;
    }
 
    uint32 soundid = m_spellInfo->Effects[effIndex].MiscValue;
 
    if (!sSoundEntriesStore.LookupEntry(soundid))
    {
        LOG_ERROR("spells.effect", "EffectPlayMusic: Sound (Id: {}) not exist in spell {}.", soundid, m_spellInfo->Id);
        return;
    }
 
    unitTarget->ToPlayer()->SendDirectMessage(WorldPackets::Misc::PlayMusic(soundid).Write());
}

References effectHandleMode, SpellInfo::Effects, SpellInfo::Id, LOG_ERROR, m_spellInfo, Player::SendDirectMessage(), SPELL_EFFECT_HANDLE_HIT_TARGET, sSoundEntriesStore, Object::ToPlayer(), and unitTarget.

◆ EffectPlaySound()

void Spell::EffectPlaySound ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    Player* player = unitTarget->ToPlayer();
    if (!player)
    {
        return;
    }
 
    switch (m_spellInfo->Id)
    {
        case 58730: // Restricted Flight Area
        case 58600: // Restricted Flight Area
            ChatHandler(player->GetSession()).SendNotification(LANG_ZONE_NOFLYZONE);
            break;
        default:
            break;
    }
 
    uint32 soundId = m_spellInfo->Effects[effIndex].MiscValue;
 
    if (!sSoundEntriesStore.LookupEntry(soundId))
    {
        LOG_ERROR("spells.effect", "EffectPlayerSound: Sound (Id: {}) not exist in spell {}.", soundId, m_spellInfo->Id);
        return;
    }
 
    player->PlayDirectSound(soundId, player);
}

References effectHandleMode, SpellInfo::Effects, Player::GetSession(), SpellInfo::Id, LANG_ZONE_NOFLYZONE, LOG_ERROR, m_spellInfo, WorldObject::PlayDirectSound(), ChatHandler::SendNotification(), SPELL_EFFECT_HANDLE_HIT_TARGET, sSoundEntriesStore, Object::ToPlayer(), and unitTarget.

◆ EffectPowerBurn()

void Spell::EffectPowerBurn ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (m_spellInfo->Effects[effIndex].MiscValue < 0 || m_spellInfo->Effects[effIndex].MiscValue >= int8(MAX_POWERS))
        return;
 
    Powers PowerType = Powers(m_spellInfo->Effects[effIndex].MiscValue);
 
    if (!unitTarget || !unitTarget->IsAlive() || !unitTarget->HasActivePowerType(PowerType) || damage < 0)
        return;
 
    // burn x% of target's mana, up to maximum of 2x% of caster's mana (Mana Burn)
    if (m_spellInfo->Id == 8129)
    {
        int32 maxDamage = int32(CalculatePct(m_caster->GetMaxPower(PowerType), damage * 2));
        damage = int32(CalculatePct(unitTarget->GetMaxPower(PowerType), damage));
        damage = std::min(damage, maxDamage);
 
        // Remove fear
        unitTarget->RemoveAurasByType(SPELL_AURA_MOD_FEAR);
    }
 
    int32 power = damage;
    // resilience reduce mana draining effect at spell crit damage reduction (added in 2.4)
    if (PowerType == POWER_MANA)
        power -= unitTarget->GetSpellCritDamageReduction(power);
 
    int32 newDamage = -(unitTarget->ModifyPower(PowerType, -power));
 
    // NO - Not a typo - EffectPowerBurn uses effect value multiplier - not effect damage multiplier
    float dmgMultiplier = m_spellInfo->Effects[effIndex].CalcValueMultiplier(m_originalCaster, this);
 
    // add log data before multiplication (need power amount, not damage)
    ExecuteLogEffectTakeTargetPower(effIndex, unitTarget, PowerType, newDamage, 0.0f);
 
    newDamage = int32(newDamage * dmgMultiplier);
 
    m_damage += newDamage;
}

References CalculatePct(), damage, effectHandleMode, SpellInfo::Effects, ExecuteLogEffectTakeTargetPower(), Unit::GetMaxPower(), Unit::GetSpellCritDamageReduction(), Unit::HasActivePowerType(), SpellInfo::Id, Unit::IsAlive(), m_caster, m_damage, m_originalCaster, m_spellInfo, MAX_POWERS, Unit::ModifyPower(), POWER_MANA, Unit::RemoveAurasByType(), SPELL_AURA_MOD_FEAR, SPELL_EFFECT_HANDLE_HIT_TARGET, and unitTarget.

◆ EffectPowerDrain()

void Spell::EffectPowerDrain ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (m_spellInfo->Effects[effIndex].MiscValue < 0 || m_spellInfo->Effects[effIndex].MiscValue >= int8(MAX_POWERS))
        return;
 
    Powers PowerType = Powers(m_spellInfo->Effects[effIndex].MiscValue);
 
    if (!unitTarget || !unitTarget->IsAlive() || !unitTarget->HasActivePowerType(PowerType) || damage < 0)
        return;
 
    // add spell damage bonus
    damage = m_caster->SpellDamageBonusDone(unitTarget, m_spellInfo, uint32(damage), SPELL_DIRECT_DAMAGE, effIndex);
    damage = unitTarget->SpellDamageBonusTaken(m_caster, m_spellInfo, uint32(damage), SPELL_DIRECT_DAMAGE);
 
    // resilience reduce mana draining effect at spell crit damage reduction (added in 2.4)
    int32 power = damage;
    if (PowerType == POWER_MANA)
        power -= unitTarget->GetSpellCritDamageReduction(power);
 
    int32 newDamage = -(unitTarget->ModifyPower(PowerType, -int32(power)));
 
    float gainMultiplier = 0.0f;
 
    // Don`t restore from self drain
    if (m_caster != unitTarget)
    {
        gainMultiplier = m_spellInfo->Effects[effIndex].CalcValueMultiplier(m_originalCaster, this);
 
        int32 gain = int32(newDamage * gainMultiplier);
 
        m_caster->EnergizeBySpell(m_caster, m_spellInfo->Id, gain, PowerType);
    }
    ExecuteLogEffectTakeTargetPower(effIndex, unitTarget, PowerType, newDamage, gainMultiplier);
}

References damage, effectHandleMode, SpellInfo::Effects, Unit::EnergizeBySpell(), ExecuteLogEffectTakeTargetPower(), Unit::GetSpellCritDamageReduction(), Unit::HasActivePowerType(), SpellInfo::Id, Unit::IsAlive(), m_caster, m_originalCaster, m_spellInfo, MAX_POWERS, Unit::ModifyPower(), POWER_MANA, SPELL_DIRECT_DAMAGE, SPELL_EFFECT_HANDLE_HIT_TARGET, Unit::SpellDamageBonusDone(), Unit::SpellDamageBonusTaken(), and unitTarget.

◆ EffectProficiency()

void Spell::EffectProficiency ( SpellEffIndex effIndex )

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

References Player::AddArmorProficiency(), Player::AddWeaponProficiency(), effectHandleMode, SpellInfo::EquippedItemClass, SpellInfo::EquippedItemSubClassMask, Player::GetArmorProficiency(), Player::GetWeaponProficiency(), Object::IsPlayer(), ITEM_CLASS_ARMOR, ITEM_CLASS_WEAPON, m_caster, m_spellInfo, Player::SendProficiency(), SPELL_EFFECT_HANDLE_HIT, and Object::ToPlayer().

◆ EffectProspecting()

void Spell::EffectProspecting ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!m_caster->IsPlayer())
        return;
 
    Player* p_caster = m_caster->ToPlayer();
    if (!itemTarget || !itemTarget->GetTemplate()->HasFlag(ITEM_FLAG_IS_PROSPECTABLE))
        return;
 
    if (itemTarget->GetCount() < 5)
        return;
 
    if (sWorld->getBoolConfig(CONFIG_SKILL_PROSPECTING))
    {
        uint32 SkillValue = p_caster->GetPureSkillValue(SKILL_JEWELCRAFTING);
        uint32 reqSkillValue = itemTarget->GetTemplate()->RequiredSkillRank;
        p_caster->UpdateGatherSkill(SKILL_JEWELCRAFTING, SkillValue, reqSkillValue);
    }
 
    m_caster->ToPlayer()->SendLoot(itemTarget->GetGUID(), LOOT_PROSPECTING);
}

References CONFIG_SKILL_PROSPECTING, effectHandleMode, Item::GetCount(), Object::GetGUID(), Player::GetPureSkillValue(), Item::GetTemplate(), ItemTemplate::HasFlag(), Object::IsPlayer(), ITEM_FLAG_IS_PROSPECTABLE, itemTarget, LOOT_PROSPECTING, m_caster, ItemTemplate::RequiredSkillRank, Player::SendLoot(), SKILL_JEWELCRAFTING, SPELL_EFFECT_HANDLE_HIT_TARGET, sWorld, Object::ToPlayer(), and Player::UpdateGatherSkill().

◆ EffectPull()

void Spell::EffectPull ( SpellEffIndex effIndex )

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

{
    EffectNULL(effIndex);
}

References EffectNULL().

◆ EffectPullTowards()

void Spell::EffectPullTowards ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    Position pos;
    if (m_spellInfo->Effects[effIndex].Effect == SPELL_EFFECT_PULL_TOWARDS_DEST)
    {
        if (m_targets.HasDst())
            pos.Relocate(*destTarget);
        else
            return;
    }
    else //if (m_spellInfo->Effects[i].Effect == SPELL_EFFECT_PULL_TOWARDS)
    {
        // Xinef: Increase Z position a little bit, should protect from falling through textures
        pos.Relocate(m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ() + 1.0f, m_caster->GetOrientation());
    }
 
    float speedXY = float(m_spellInfo->Effects[effIndex].MiscValue) ? float(m_spellInfo->Effects[effIndex].MiscValue) * 0.1f : 30.f;
    float speedZ = unitTarget->GetDistance(pos) / speedXY * 0.5f * Movement::gravity;
 
    unitTarget->GetMotionMaster()->MoveJump(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), speedXY, speedZ);
 
    if (unitTarget->IsPlayer())
    {
        sScriptMgr->AnticheatSetUnderACKmount(unitTarget->ToPlayer());
    }
}

References destTarget, effectHandleMode, SpellInfo::Effects, WorldObject::GetDistance(), Unit::GetMotionMaster(), Position::GetOrientation(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Movement::gravity, SpellCastTargets::HasDst(), Object::IsPlayer(), m_caster, m_spellInfo, m_targets, MotionMaster::MoveJump(), Position::Relocate(), SPELL_EFFECT_HANDLE_HIT_TARGET, SPELL_EFFECT_PULL_TOWARDS_DEST, sScriptMgr, Object::ToPlayer(), and unitTarget.

◆ EffectQuestClear()

void Spell::EffectQuestClear ( SpellEffIndex effIndex )

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

References effectHandleMode, SpellInfo::Effects, Player::GetQuestSlotQuestId(), Player::GetQuestStatus(), Quest::HasFlag(), Player::HasPvPForcingQuest(), PvPInfo::IsHostile, PvPInfo::IsInHostileArea, m_spellInfo, MAX_QUEST_LOG_SIZE, Player::pvpInfo, QUEST_FLAGS_FLAGS_PVP, QUEST_STATUS_NONE, Player::RemoveActiveQuest(), Player::RemoveRewardedQuest(), Player::SetQuestSlot(), sObjectMgr, SPELL_EFFECT_HANDLE_HIT_TARGET, Player::TakeQuestSourceItem(), Object::ToPlayer(), unitTarget, and Player::UpdatePvPState().

◆ EffectQuestComplete()

void Spell::EffectQuestComplete ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    Player* player = unitTarget->ToPlayer();
    if (!player)
    {
        return;
    }
 
    uint32 questId = m_spellInfo->Effects[effIndex].MiscValue;
    if (questId)
    {
        Quest const* quest = sObjectMgr->GetQuestTemplate(questId);
        if (!quest)
            return;
 
        uint16 logSlot = player->FindQuestSlot(questId);
        if (logSlot < MAX_QUEST_LOG_SIZE)
            player->AreaExploredOrEventHappens(questId);
        else if (player->CanTakeQuest(quest, false)) // Check if the quest has already been turned in.
            player->SetRewardedQuest(questId);           // If not, set status to rewarded without broadcasting it to client.
    }
}

References Player::AreaExploredOrEventHappens(), Player::CanTakeQuest(), effectHandleMode, SpellInfo::Effects, Player::FindQuestSlot(), m_spellInfo, MAX_QUEST_LOG_SIZE, Player::SetRewardedQuest(), sObjectMgr, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectQuestFail()

void Spell::EffectQuestFail ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    if (Player* player = unitTarget->ToPlayer())
    {
        player->FailQuest(m_spellInfo->Effects[effIndex].MiscValue);
    }
}

References effectHandleMode, SpellInfo::Effects, m_spellInfo, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectQuestStart()

void Spell::EffectQuestStart ( SpellEffIndex effIndex )

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

References Player::AddQuestAndCheckCompletion(), Player::CanAddQuest(), Player::CanTakeQuest(), effectHandleMode, SpellInfo::Effects, Object::GetGUID(), m_spellInfo, Player::PlayerTalkClass, PlayerMenu::SendQuestGiverQuestDetails(), sObjectMgr, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectRechargeManaGem()

void Spell::EffectRechargeManaGem ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget || !unitTarget->IsPlayer())
        return;
 
    Player* player = m_caster->ToPlayer();
 
    if (!player)
        return;
 
    uint32 item_id = m_spellInfo->Effects[EFFECT_0].ItemType;
 
    ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(item_id);
    if (!pProto)
    {
        player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, nullptr, nullptr);
        return;
    }
 
    if (Item* pItem = player->GetItemByEntry(item_id))
    {
        for (int x = 0; x < MAX_ITEM_PROTO_SPELLS; ++x)
            pItem->SetSpellCharges(x, pProto->Spells[x].SpellCharges);
        pItem->SetState(ITEM_CHANGED, player);
    }
}

References EFFECT_0, effectHandleMode, SpellInfo::Effects, EQUIP_ERR_ITEM_NOT_FOUND, Player::GetItemByEntry(), Object::IsPlayer(), ITEM_CHANGED, m_caster, m_spellInfo, MAX_ITEM_PROTO_SPELLS, Player::SendEquipError(), sObjectMgr, SPELL_EFFECT_HANDLE_HIT_TARGET, _Spell::SpellCharges, ItemTemplate::Spells, Object::ToPlayer(), and unitTarget.

◆ EffectRedirectThreat()

void Spell::EffectRedirectThreat ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (unitTarget)
        m_caster->GetThreatMgr().RegisterRedirectThreat(m_spellInfo->Id, unitTarget->GetGUID(), uint32(damage));
}

References damage, effectHandleMode, Object::GetGUID(), Unit::GetThreatMgr(), SpellInfo::Id, m_caster, m_spellInfo, ThreatManager::RegisterRedirectThreat(), SPELL_EFFECT_HANDLE_HIT_TARGET, and unitTarget.

◆ EffectRemoveAura()

void Spell::EffectRemoveAura ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
    // there may be need of specifying casterguid of removed auras
    unitTarget->RemoveAurasDueToSpell(m_spellInfo->Effects[effIndex].TriggerSpell);
}

References effectHandleMode, SpellInfo::Effects, m_spellInfo, Unit::RemoveAurasDueToSpell(), SPELL_EFFECT_HANDLE_HIT_TARGET, and unitTarget.

◆ EffectRenamePet()

void Spell::EffectRenamePet ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget || !unitTarget->IsCreature() ||
            !unitTarget->IsPet() || unitTarget->ToPet()->getPetType() != HUNTER_PET)
        return;
 
    unitTarget->SetByteFlag(UNIT_FIELD_BYTES_2, 2, UNIT_CAN_BE_RENAMED);
}

References effectHandleMode, Pet::getPetType(), HUNTER_PET, Object::IsCreature(), Unit::IsPet(), Object::SetByteFlag(), SPELL_EFFECT_HANDLE_HIT_TARGET, Unit::ToPet(), UNIT_CAN_BE_RENAMED, UNIT_FIELD_BYTES_2, and unitTarget.

◆ EffectReputation()

void Spell::EffectReputation ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    Player* player = unitTarget->ToPlayer();
    if (!player)
    {
        return;
    }
 
    float repChange = static_cast<float>(damage);
 
    uint32 factionId = m_spellInfo->Effects[effIndex].MiscValue;
 
    FactionEntry const* factionEntry = sFactionStore.LookupEntry(factionId);
    if (!factionEntry)
        return;
 
    repChange = player->CalculateReputationGain(REPUTATION_SOURCE_SPELL, 0, repChange, factionId);
    player->GetReputationMgr().ModifyReputation(factionEntry, repChange);
}

References Player::CalculateReputationGain(), damage, effectHandleMode, SpellInfo::Effects, Player::GetReputationMgr(), m_spellInfo, ReputationMgr::ModifyReputation(), REPUTATION_SOURCE_SPELL, sFactionStore, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectResurrect()

void Spell::EffectResurrect ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    if (!unitTarget)
        return;
 
    Player* target = unitTarget->ToPlayer();
    if (!target)
    {
        return;
    }
 
    if (unitTarget->IsAlive() || !unitTarget->IsInWorld())
        return;
 
    if (target->isResurrectRequested())       // already have one active request
        return;
 
    uint32 health = target->CountPctFromMaxHealth(damage);
    uint32 mana   = CalculatePct(target->GetMaxPower(POWER_MANA), damage);
 
    ExecuteLogEffectResurrect(effIndex, target);
 
    target->setResurrectRequestData(m_caster->GetGUID(), m_caster->GetMapId(), m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ(), health, mana);
    SendResurrectRequest(target);
}

References CalculatePct(), Unit::CountPctFromMaxHealth(), damage, effectHandleMode, ExecuteLogEffectResurrect(), Object::GetGUID(), WorldLocation::GetMapId(), Unit::GetMaxPower(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Unit::IsAlive(), Object::IsInWorld(), Player::isResurrectRequested(), m_caster, POWER_MANA, SendResurrectRequest(), Player::setResurrectRequestData(), SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectResurrectNew()

void Spell::EffectResurrectNew ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget || unitTarget->IsAlive())
        return;
 
    if (!unitTarget->IsPlayer())
        return;
 
    if (!unitTarget->IsInWorld())
        return;
 
    Player* target = unitTarget->ToPlayer();
 
    if (target->isResurrectRequested())       // already have one active request
        return;
 
    uint32 health = damage;
    uint32 mana = m_spellInfo->Effects[effIndex].MiscValue;
    ExecuteLogEffectResurrect(effIndex, target);
    target->setResurrectRequestData(m_caster->GetGUID(), m_caster->GetMapId(), m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ(), health, mana);
    SendResurrectRequest(target);
}

References damage, effectHandleMode, SpellInfo::Effects, ExecuteLogEffectResurrect(), Object::GetGUID(), WorldLocation::GetMapId(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Unit::IsAlive(), Object::IsInWorld(), Object::IsPlayer(), Player::isResurrectRequested(), m_caster, m_spellInfo, SendResurrectRequest(), Player::setResurrectRequestData(), SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectResurrectPet()

void Spell::EffectResurrectPet ( SpellEffIndex effIndex )

Todo:: : Better to fail Hunter's "Revive Pet" at cast instead of here when casting ends

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
        return;
 
    if (damage < 0)
        return;
 
    Player* player = m_caster->ToPlayer();
    if (!player)
    {
        return;
    }
 
    Pet* pet = player->GetPet();
    if (!pet)
    {
        // Position passed to SummonPet is irrelevant with current implementation,
        // pet will be relocated without using these coords in Pet::LoadPetFromDB
        player->SummonPet(0, 0.0f, 0.0f, 0.0f, 0.0f, SUMMON_PET, 0ms, damage);
        return;
    }
 
    if (pet->IsAlive())
    {
        return;
    }
 
    // Reposition the pet's corpse before reviving so as not to grab aggro
    // We can use a different, more accurate version of GetClosePoint() since we have a pet
    float x, y, z; // Will be used later to reposition the pet if we have one
    player->GetClosePoint(x, y, z, pet->GetCombatReach(), PET_FOLLOW_DIST, pet->GetFollowAngle());
    pet->NearTeleportTo(x, y, z, player->GetOrientation());
    pet->Relocate(x, y, z, player->GetOrientation()); // This is needed so SaveStayPosition() will get the proper coords.
    pet->ReplaceAllDynamicFlags(UNIT_DYNFLAG_NONE);
    pet->RemoveUnitFlag(UNIT_FLAG_SKINNABLE);
    pet->setDeathState(DeathState::Alive);
    pet->ClearUnitState(uint32(UNIT_STATE_ALL_STATE & ~(UNIT_STATE_POSSESSED))); // xinef: just in case
    pet->SetHealth(pet->CountPctFromMaxHealth(damage));
    pet->SetDisplayId(pet->GetNativeDisplayId());
 
    // xinef: restore movement
    if (auto ci = pet->GetCharmInfo())
    {
        ci->SetIsAtStay(false);
        ci->SetIsFollowing(false);
    }
 
    pet->SavePetToDB(PET_SAVE_AS_CURRENT);
}

References Alive, Unit::ClearUnitState(), Unit::CountPctFromMaxHealth(), damage, effectHandleMode, Unit::GetCharmInfo(), WorldObject::GetClosePoint(), Unit::GetCombatReach(), Minion::GetFollowAngle(), Unit::GetNativeDisplayId(), Position::GetOrientation(), Player::GetPet(), Unit::IsAlive(), m_caster, Unit::NearTeleportTo(), PET_FOLLOW_DIST, PET_SAVE_AS_CURRENT, Position::Relocate(), Unit::RemoveUnitFlag(), Unit::ReplaceAllDynamicFlags(), Pet::SavePetToDB(), Pet::setDeathState(), Pet::SetDisplayId(), Unit::SetHealth(), SPELL_EFFECT_HANDLE_HIT, SUMMON_PET, Player::SummonPet(), Object::ToPlayer(), UNIT_DYNFLAG_NONE, UNIT_FLAG_SKINNABLE, UNIT_STATE_ALL_STATE, and UNIT_STATE_POSSESSED.

◆ EffectSanctuary()

void Spell::EffectSanctuary ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    unitTarget->GetThreatMgr().EvaluateSuppressed();
 
    if (unitTarget->IsPlayer() && !unitTarget->GetMap()->IsDungeon())
    {
        // stop all pve combat for players outside dungeons, suppress pvp combat
        unitTarget->CombatStop(false, false);
    }
    else
    {
        // in dungeons (or for nonplayers), reset this unit on all enemies' threat lists
        for (auto const& pair : unitTarget->GetThreatMgr().GetThreatenedByMeList())
            pair.second->ScaleThreat(0.0f);
    }
 
    UnitList targets;
    Acore::AnyUnfriendlyUnitInObjectRangeCheck u_check(unitTarget, unitTarget, unitTarget->GetVisibilityRange()); // no VISIBILITY_COMPENSATION, distance is enough
    Acore::UnitListSearcher<Acore::AnyUnfriendlyUnitInObjectRangeCheck> searcher(unitTarget, targets, u_check);
    Cell::VisitObjects(unitTarget, searcher, unitTarget->GetVisibilityRange());
    for (UnitList::iterator iter = targets.begin(); iter != targets.end(); ++iter)
    {
        if (!(*iter)->HasUnitState(UNIT_STATE_CASTING))
            continue;
 
        for (uint32 i = CURRENT_FIRST_NON_MELEE_SPELL; i < CURRENT_MAX_SPELL; i++)
        {
            if ((*iter)->GetCurrentSpell(i) && (*iter)->GetCurrentSpell(i)->m_targets.GetUnitTargetGUID() == unitTarget->GetGUID())
            {
                SpellInfo const* si = (*iter)->GetCurrentSpell(i)->GetSpellInfo();
                if (si->HasAttribute(SPELL_ATTR6_IGNORE_PHASE_SHIFT) && (*iter)->IsCreature())
                {
                    Creature* c = (*iter)->ToCreature();
                    if ((!c->IsPet() && c->GetCreatureTemplate()->rank == CREATURE_ELITE_WORLDBOSS) || c->isWorldBoss() || c->IsDungeonBoss())
                        continue;
                }
                bool interrupt = false; // pussywizard: skip spells that don't target units, but casted on unit (eg. TARGET_DEST_TARGET_ENEMY)
                for (uint8 j = 0; j < MAX_SPELL_EFFECTS; ++j)
                    if (si->Effects[j].Effect && (si->Effects[j].GetUsedTargetObjectType() == TARGET_OBJECT_TYPE_UNIT || si->Effects[j].GetUsedTargetObjectType() == TARGET_OBJECT_TYPE_UNIT_AND_DEST))
                    {
                        // at least one effect truly targets an unit, interrupt the spell
                        interrupt = true;
                        break;
                    }
                if (interrupt)
                    (*iter)->InterruptSpell(CurrentSpellTypes(i), false);
            }
        }
    }
 
    // Xinef: Set last sanctuary time
    unitTarget->m_lastSanctuaryTime = GameTime::GetGameTimeMS().count();
}

References Unit::CombatStop(), CREATURE_ELITE_WORLDBOSS, CURRENT_FIRST_NON_MELEE_SPELL, CURRENT_MAX_SPELL, effectHandleMode, SpellInfo::Effects, ThreatManager::EvaluateSuppressed(), Creature::GetCreatureTemplate(), GameTime::GetGameTimeMS(), Object::GetGUID(), WorldObject::GetMap(), ThreatManager::GetThreatenedByMeList(), Unit::GetThreatMgr(), WorldObject::GetVisibilityRange(), SpellInfo::HasAttribute(), Unit::InterruptSpell(), Map::IsDungeon(), Creature::IsDungeonBoss(), Unit::IsPet(), Object::IsPlayer(), Creature::isWorldBoss(), Unit::m_lastSanctuaryTime, MAX_SPELL_EFFECTS, CreatureTemplate::rank, SPELL_ATTR6_IGNORE_PHASE_SHIFT, SPELL_EFFECT_HANDLE_HIT_TARGET, TARGET_OBJECT_TYPE_UNIT, TARGET_OBJECT_TYPE_UNIT_AND_DEST, Object::ToCreature(), UNIT_STATE_CASTING, unitTarget, and Cell::VisitObjects().

◆ EffectSchoolDMG()

void Spell::EffectSchoolDMG ( SpellEffIndex effIndex )

Todo:: : should this be put on taken but not done?

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
        return;
 
    if (unitTarget && unitTarget->IsAlive())
    {
        bool apply_direct_bonus = true;
        switch (m_spellInfo->SpellFamilyName)
        {
            case SPELLFAMILY_GENERIC:
                {
                    // Meteor like spells (divided damage to targets)
                    if (m_spellInfo->HasAttribute(SPELL_ATTR0_CU_SHARE_DAMAGE))
                    {
                        uint32 count = 0;
                        for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
                            if (ihit->effectMask & (1 << effIndex))
                                ++count;
 
                        damage /= count;                    // divide to all targets
                    }
                    break;
                }
            case SPELLFAMILY_WARRIOR:
                {
                    // Shield Slam
                    if (m_spellInfo->SpellFamilyFlags[1] & 0x200 && m_spellInfo->GetCategory() == 1209)
                    {
                        uint8 level = m_caster->GetLevel();
                        // xinef: shield block should increase the limit
                        float limit = m_caster->HasAura(2565) ? 2.0f : 1.0f;
                        uint32 block_value = m_caster->GetShieldBlockValue(uint32(float(level) * 24.5f * limit), uint32(float(level) * 34.5f * limit));
 
                        damage += int32(m_caster->ApplyEffectModifiers(m_spellInfo, effIndex, float(block_value)));
                    }
                    // Victory Rush
                    else if (m_spellInfo->SpellFamilyFlags[1] & 0x100)
                        ApplyPct(damage, m_caster->GetTotalAttackPowerValue(BASE_ATTACK));
                    // Shockwave
                    else if (m_spellInfo->Id == 46968)
                    {
                        int32 pct = m_caster->CalculateSpellDamage(unitTarget, m_spellInfo, 2);
                        if (pct > 0)
                            damage += int32(CalculatePct(m_caster->GetTotalAttackPowerValue(BASE_ATTACK), pct));
                        break;
                    }
                    break;
                }
            case SPELLFAMILY_WARLOCK:
                {
                    // Incinerate Rank 1 & 2
                    if ((m_spellInfo->SpellFamilyFlags[1] & 0x000040) && m_spellInfo->SpellIconID == 2128)
                    {
                        // Incinerate does more dmg (dmg*0.25) if the target have Immolate debuff.
                        // Check aura state for speed but aura state set not only for Immolate spell
                        if (unitTarget->HasAuraState(AURA_STATE_CONFLAGRATE))
                        {
                            if (unitTarget->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_WARLOCK, 0x4, 0, 0))
                                damage += damage / 4;
                        }
                    }
                    // Conflagrate - consumes Immolate or Shadowflame
                    else if (m_spellInfo->TargetAuraState == AURA_STATE_CONFLAGRATE)
                    {
                        AuraEffect const* aura = nullptr;                // found req. aura for damage calculation
 
                        Unit::AuraEffectList const& mPeriodic = unitTarget->GetAuraEffectsByType(SPELL_AURA_PERIODIC_DAMAGE);
                        for (Unit::AuraEffectList::const_iterator i = mPeriodic.begin(); i != mPeriodic.end(); ++i)
                        {
                            // for caster applied auras only
                            if ((*i)->GetSpellInfo()->SpellFamilyName != SPELLFAMILY_WARLOCK ||
                                    (*i)->GetCasterGUID() != m_caster->GetGUID())
                                continue;
 
                            // Immolate
                            if ((*i)->GetSpellInfo()->SpellFamilyFlags[0] & 0x4)
                            {
                                aura = *i;                      // it selected always if exist
                                break;
                            }
 
                            // Shadowflame
                            if ((*i)->GetSpellInfo()->SpellFamilyFlags[2] & 0x00000002)
                                aura = *i;                      // remember but wait possible Immolate as primary priority
                        }
 
                        // found Immolate or Shadowflame
                        if (aura)
                        {
                            uint32 pdamage = uint32(std::max(aura->GetAmount(), 0));
                            pdamage = unitTarget->SpellDamageBonusTaken(m_caster, aura->GetSpellInfo(), pdamage, DOT, aura->GetBase()->GetStackAmount());
                            uint32 pct_dir = m_caster->CalculateSpellDamage(unitTarget, m_spellInfo, (effIndex + 1));
                            uint8 baseTotalTicks = uint8(m_caster->CalcSpellDuration(aura->GetSpellInfo()) / aura->GetSpellInfo()->Effects[EFFECT_0].Amplitude);
 
                            damage += int32(CalculatePct(pdamage * baseTotalTicks, pct_dir));
 
                            uint32 pct_dot = m_caster->CalculateSpellDamage(unitTarget, m_spellInfo, (effIndex + 2)) / 3;
                            m_spellValue->EffectBasePoints[1] = m_spellInfo->Effects[EFFECT_1].CalcBaseValue(int32(CalculatePct(pdamage * baseTotalTicks, pct_dot)));
 
                            apply_direct_bonus = false;
                            // Glyph of Conflagrate
                            if (!m_caster->HasAura(56235))
                                unitTarget->RemoveAurasDueToSpell(aura->GetId(), m_caster->GetGUID());
 
                            break;
                        }
                    }
                    // Shadow Bite
                    else if (m_spellInfo->SpellFamilyFlags[1] & 0x400000)
                    {
                        if (m_caster->IsCreature() && m_caster->IsPet())
                        {
                            if (Player* owner = m_caster->GetOwner()->ToPlayer())
                            {
                                if (AuraEffect* aurEff = owner->GetAuraEffect(SPELL_AURA_ADD_FLAT_MODIFIER, SPELLFAMILY_WARLOCK, 214, 0))
                                {
                                    int32 bp0 = aurEff->GetId() == 54037 ? 4 : 8;
                                    m_caster->CastCustomSpell(m_caster, 54425, &bp0, nullptr, nullptr, true);
                                }
                            }
                        }
                    }
                    break;
                }
            case SPELLFAMILY_PRIEST:
                {
                    // Improved Mind Blast (Mind Blast in shadow form bonus)
                    if (m_caster->GetShapeshiftForm() == FORM_SHADOW && (m_spellInfo->SpellFamilyFlags[0] & 0x00002000))
                    {
                        Unit::AuraEffectList const& ImprMindBlast = m_caster->GetAuraEffectsByType(SPELL_AURA_ADD_FLAT_MODIFIER);
                        for (Unit::AuraEffectList::const_iterator i = ImprMindBlast.begin(); i != ImprMindBlast.end(); ++i)
                        {
                            if ((*i)->GetSpellInfo()->SpellFamilyName == SPELLFAMILY_PRIEST &&
                                    ((*i)->GetSpellInfo()->SpellIconID == 95))
                            {
                                int chance = (*i)->GetSpellInfo()->Effects[EFFECT_1].CalcValue(m_caster);
                                if (roll_chance_i(chance))
                                    // Mind Trauma
                                    m_caster->CastSpell(unitTarget, 48301, true, 0);
                                break;
                            }
                        }
                    }
                    break;
                }
            case SPELLFAMILY_DRUID:
                {
                    // Ferocious Bite
                    if (m_caster->IsPlayer() && (m_spellInfo->SpellFamilyFlags[0] & 0x000800000) && m_spellInfo->SpellVisual[0] == 6587)
                    {
                        // converts each extra point of energy into ($f1+$AP/410) additional damage
                        float ap = m_caster->GetTotalAttackPowerValue(BASE_ATTACK);
                        float multiple = ap / 410 + m_spellInfo->Effects[effIndex].DamageMultiplier;
                        int32 energy = -(m_caster->ModifyPower(POWER_ENERGY, -30));
                        damage += int32(energy * multiple);
                        damage += int32(CalculatePct(m_caster->GetComboPoints() * ap, 7));
                    }
                    // Wrath
                    else if (m_spellInfo->SpellFamilyFlags[0] & 0x00000001)
                    {
                        // Improved Insect Swarm
                        if (AuraEffect const* aurEff = m_caster->GetDummyAuraEffect(SPELLFAMILY_DRUID, 1771, 0))
                            if (unitTarget->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DRUID, 0x00200000, 0, 0))
                                AddPct(damage, aurEff->GetAmount());
                    }
                    break;
                }
            case SPELLFAMILY_ROGUE:
                {
                    // Envenom
                    if (m_spellInfo->SpellFamilyFlags[1] & 0x00000008)
                    {
                        if (Player* player = m_caster->ToPlayer())
                        {
                            // consume from stack dozes not more that have combo-points
                            if (uint32 combo = player->GetComboPoints())
                            {
                                // Lookup for Deadly poison (only attacker applied)
                                if (AuraEffect const* aurEff = unitTarget->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_ROGUE, 0x00010000, 0, 0, m_caster->GetGUID()))
                                {
                                    // count consumed deadly poison doses at target
                                    bool needConsume = true;
                                    uint32 spellId = aurEff->GetId();
 
                                    uint32 doses = aurEff->GetBase()->GetStackAmount();
                                    if (doses > combo)
                                        doses = combo;
 
                                    // Master Poisoner
                                    Unit::AuraEffectList const& auraList = player->GetAuraEffectsByType(SPELL_AURA_MOD_AURA_DURATION_BY_DISPEL_NOT_STACK);
                                    for (Unit::AuraEffectList::const_iterator iter = auraList.begin(); iter != auraList.end(); ++iter)
                                    {
                                        if ((*iter)->GetSpellInfo()->SpellFamilyName == SPELLFAMILY_ROGUE && (*iter)->GetSpellInfo()->SpellIconID == 1960)
                                        {
                                            uint32 chance = (*iter)->GetSpellInfo()->Effects[EFFECT_2].CalcValue(m_caster);
 
                                            if (chance && roll_chance_i(chance))
                                                needConsume = false;
 
                                            break;
                                        }
                                    }
 
                                    if (needConsume)
                                        for (uint32 i = 0; i < doses; ++i)
                                            unitTarget->RemoveAuraFromStack(spellId, m_caster->GetGUID());
 
                                    damage *= doses;
                                    damage += int32(player->GetTotalAttackPowerValue(BASE_ATTACK) * 0.09f * combo);
                                }
 
                                // Eviscerate and Envenom Bonus Damage (item set effect)
                                if (m_caster->HasAura(37169))
                                    damage += combo * 40;
                            }
                        }
                    }
                    // Eviscerate
                    else if (m_spellInfo->SpellFamilyFlags[0] & 0x00020000)
                    {
                        if (m_caster->IsPlayer())
                        {
                            if (uint32 combo = m_caster->ToPlayer()->GetComboPoints())
                            {
                                float ap = m_caster->GetTotalAttackPowerValue(BASE_ATTACK);
                                damage += int32(ap * combo * 0.07f);
 
                                // Eviscerate and Envenom Bonus Damage (item set effect)
                                if (m_caster->HasAura(37169))
                                    damage += combo * 40;
                            }
                        }
                    }
                    break;
                }
            case SPELLFAMILY_HUNTER:
                {
                    //Gore
                    if (m_spellInfo->SpellIconID == 1578)
                    {
                        if (m_caster->HasAura(57627))           // Charge 6 sec post-affect
                            damage *= 2;
                    }
                    // Steady Shot
                    else if (m_spellInfo->SpellFamilyFlags[1] & 0x1)
                    {
                        bool found = false;
                        // check dazed affect
                        Unit::AuraEffectList const& decSpeedList = unitTarget->GetAuraEffectsByType(SPELL_AURA_MOD_DECREASE_SPEED);
                        for (Unit::AuraEffectList::const_iterator iter = decSpeedList.begin(); iter != decSpeedList.end(); ++iter)
                        {
                            if ((*iter)->GetSpellInfo()->SpellIconID == 15 && (*iter)->GetSpellInfo()->Dispel == 0)
                            {
                                found = true;
                                break;
                            }
                        }
 
                        if (found)
                            damage += m_spellInfo->Effects[EFFECT_1].CalcValue();
 
                        if (Player* caster = m_caster->ToPlayer())
                        {
                            // Add Ammo and Weapon damage plus RAP * 0.1
                            float dmg_min = 0.f;
                            float dmg_max = 0.f;
                            for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
                            {
                                dmg_min += caster->GetWeaponDamageRange(RANGED_ATTACK, MINDAMAGE, i);
                                dmg_max += caster->GetWeaponDamageRange(RANGED_ATTACK, MAXDAMAGE, i);
                            }
 
                            if (dmg_max == 0.0f && dmg_min > dmg_max)
                            {
                                damage += int32(dmg_min);
                            }
                            else
                            {
                                damage += irand(int32(dmg_min), int32(dmg_max));
                            }
                            damage += int32(caster->GetAmmoDPS() * caster->GetAttackTime(RANGED_ATTACK) * 0.001f);
                        }
                    }
                    break;
                }
            case SPELLFAMILY_PALADIN:
                {
                    // Hammer of the Righteous
                    if (m_spellInfo->SpellFamilyFlags[1] & 0x00040000)
                    {
                        // Add main hand dps * effect[2] amount
                        if (Player* player = m_caster->ToPlayer())
                        {
                            float minTotal = 0.f;
                            float maxTotal = 0.f;
                            for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
                            {
                                float tmpMin, tmpMax;
                                player->CalculateMinMaxDamage(BASE_ATTACK, false, false, tmpMin, tmpMax, i);
                                minTotal += tmpMin;
                                maxTotal += tmpMax;
                            }
 
                            float average = (minTotal + maxTotal) / 2;
                            int32 count = m_caster->CalculateSpellDamage(unitTarget, m_spellInfo, EFFECT_2);
                            damage += count * int32(average * IN_MILLISECONDS) / m_caster->GetAttackTime(BASE_ATTACK);
                        }
                        break;
                    }
                    // Shield of Righteousness
                    if (m_spellInfo->SpellFamilyFlags[EFFECT_1] & 0x100000)
                    {
                        uint8 level = m_caster->GetLevel();
                        uint32 block_value = m_caster->GetShieldBlockValue(uint32(float(level) * 29.5f), uint32(float(level) * 34.5f));
                        if (m_caster->GetAuraEffect(64882, EFFECT_0))
                            block_value += 225;
                        damage += CalculatePct(block_value, m_spellInfo->Effects[EFFECT_1].CalcValue());
                        break;
                    }
                    break;
                }
        }
 
        if (m_originalCaster /*&& damage > 0 Xinef: this can be increased from 0*/ && apply_direct_bonus)
        {
            // Xinef: protection
            if (damage < 0)
                damage = 0;
 
            damage = m_originalCaster->SpellDamageBonusDone(unitTarget, m_spellInfo, (uint32)damage, SPELL_DIRECT_DAMAGE, effIndex);
            damage = unitTarget->SpellDamageBonusTaken(m_originalCaster, m_spellInfo, (uint32)damage, SPELL_DIRECT_DAMAGE);
        }
 
        m_damage += damage;
    }
}

References AddPct(), Unit::ApplyEffectModifiers(), ApplyPct(), AURA_STATE_CONFLAGRATE, BASE_ATTACK, Unit::CalcSpellDuration(), CalculatePct(), Unit::CalculateSpellDamage(), Unit::CastCustomSpell(), Unit::CastSpell(), damage, DOT, EFFECT_0, EFFECT_1, EFFECT_2, SpellValue::EffectBasePoints, effectHandleMode, SpellInfo::Effects, FORM_SHADOW, AuraEffect::GetAmount(), Unit::GetAttackTime(), Unit::GetAuraEffect(), Unit::GetAuraEffectsByType(), AuraEffect::GetBase(), SpellInfo::GetCategory(), Unit::GetComboPoints(), Unit::GetDummyAuraEffect(), Object::GetGUID(), AuraEffect::GetId(), Unit::GetLevel(), Unit::GetOwner(), Unit::GetShapeshiftForm(), Unit::GetShieldBlockValue(), AuraEffect::GetSpellInfo(), Aura::GetStackAmount(), Unit::GetTotalAttackPowerValue(), SpellInfo::HasAttribute(), Unit::HasAura(), Unit::HasAuraState(), SpellInfo::Id, IN_MILLISECONDS, irand(), Unit::IsAlive(), Object::IsCreature(), Unit::IsPet(), Object::IsPlayer(), m_caster, m_damage, m_originalCaster, m_spellInfo, m_spellValue, m_UniqueTargetInfo, MAX_ITEM_PROTO_DAMAGES, MAXDAMAGE, MINDAMAGE, Unit::ModifyPower(), POWER_ENERGY, RANGED_ATTACK, Unit::RemoveAuraFromStack(), Unit::RemoveAurasDueToSpell(), roll_chance_i(), SPELL_ATTR0_CU_SHARE_DAMAGE, SPELL_AURA_ADD_FLAT_MODIFIER, SPELL_AURA_MOD_AURA_DURATION_BY_DISPEL_NOT_STACK, SPELL_AURA_MOD_DECREASE_SPEED, SPELL_AURA_PERIODIC_DAMAGE, SPELL_DIRECT_DAMAGE, SPELL_EFFECT_HANDLE_LAUNCH_TARGET, Unit::SpellDamageBonusDone(), Unit::SpellDamageBonusTaken(), SPELLFAMILY_DRUID, SPELLFAMILY_GENERIC, SPELLFAMILY_HUNTER, SPELLFAMILY_PALADIN, SPELLFAMILY_PRIEST, SPELLFAMILY_ROGUE, SPELLFAMILY_WARLOCK, SPELLFAMILY_WARRIOR, SpellInfo::SpellFamilyFlags, SpellInfo::SpellFamilyName, SpellInfo::SpellIconID, SpellInfo::SpellVisual, SpellInfo::TargetAuraState, Object::ToPlayer(), and unitTarget.

◆ EffectScriptEffect()

void Spell::EffectScriptEffect ( SpellEffIndex effIndex )

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

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
 
    switch (m_spellInfo->SpellFamilyName)
    {
        case SPELLFAMILY_GENERIC:
            {
                switch (m_spellInfo->Id)
                {
                    // Shadow Flame (All script effects, not just end ones to prevent player from dodging the last triggered spell)
                    case 22539:
                    case 22972:
                    case 22975:
                    case 22976:
                    case 22977:
                    case 22978:
                    case 22979:
                    case 22980:
                    case 22981:
                    case 22982:
                    case 22983:
                    case 22984:
                    case 22985:
                        {
                            if (!unitTarget || !unitTarget->IsAlive())
                                return;
 
                            // Onyxia Scale Cloak
                            if (unitTarget->HasAura(22683))
                                return;
 
                            // Shadow Flame
                            m_caster->CastSpell(unitTarget, 22682, true);
                            return;
                        }
                    // Plant Warmaul Ogre Banner
                    case 32307:
                        if (Player* caster = m_caster->ToPlayer())
                        {
                            caster->RewardPlayerAndGroupAtEvent(18388, unitTarget);
                            if (Creature* target = unitTarget->ToCreature())
                            {
                                target->setDeathState(DeathState::Corpse);
                                target->RemoveCorpse();
                            }
                        }
                        break;
                    // SOTA defender teleport
                    case 54640:
                        {
                            if (Player* player = unitTarget->ToPlayer())
                                if (player->GetBattleground() && player->GetBattleground()->GetBgTypeID(true) == BATTLEGROUND_SA)
                                {
                                    if (GameObject* dportal = player->FindNearestGameObject(192819, 10.0f))
                                    {
                                        BattlegroundSA* bg = ((BattlegroundSA*)player->GetBattleground());
                                        bg->DefendersPortalTeleport(dportal, player);
                                    }
                                }
                            return;
                        }
                    /*// Mug Transformation
                    case 41931:
                    {
                        if (!m_caster->IsPlayer())
                            return;
 
                        uint8 bag = 19;
                        uint8 slot = 0;
                        Item* item = nullptr;
 
                        while (bag) // 256 = 0 due to var type
                        {
                            item = m_caster->ToPlayer()->GetItemByPos(bag, slot);
                            if (item && item->GetEntry() == 38587)
                                break;
 
                            ++slot;
                            if (slot == 39)
                            {
                                slot = 0;
                                ++bag;
                            }
                        }
                        if (bag)
                        {
                            if (m_caster->ToPlayer()->GetItemByPos(bag, slot)->GetCount() == 1) m_caster->ToPlayer()->RemoveItem(bag, slot, true);
                            else m_caster->ToPlayer()->GetItemByPos(bag, slot)->SetCount(m_caster->ToPlayer()->GetItemByPos(bag, slot)->GetCount()-1);
                            // Spell 42518 (Braufest - Gratisprobe des Braufest herstellen)
                            m_caster->CastSpell(m_caster, 42518, true);
                            return;
                        }
                        break;
                    }*/
                    // Roll Dice - Decahedral Dwarven Dice
                    case 47770:
                        {
                            char buf[128];
                            const char* gender = "his";
                            if (m_caster->getGender() > 0)
                                gender = "her";
                            snprintf(buf, sizeof(buf), "%s rubs %s [Decahedral Dwarven Dice] between %s hands and rolls. One %u and one %u.", m_caster->GetName().c_str(), gender, gender, urand(1, 10), urand(1, 10));
                            m_caster->TextEmote(buf);
                            break;
                        }
                    case 52173: // Coyote Spirit Despawn
                    case 60243: // Blood Parrot Despawn
                        if (unitTarget->IsCreature() && unitTarget->ToCreature()->IsSummon())
                            unitTarget->ToTempSummon()->UnSummon();
                        return;
                    case 57347: // Retrieving (Wintergrasp RP-GG pickup spell)
                        {
                            if (!unitTarget || !unitTarget->IsCreature() || !m_caster->IsPlayer())
                                return;
 
                            unitTarget->ToCreature()->DespawnOrUnsummon();
 
                            return;
                        }
                    case 57349: // Drop RP-GG (Wintergrasp RP-GG at death drop spell)
                        {
                            if (!m_caster->IsPlayer())
                                return;
 
                            // Delete item from inventory at death
                            m_caster->ToPlayer()->DestroyItemCount(damage, 5, true);
 
                            return;
                        }
                    case 58418:                                 // Portal to Orgrimmar
                    case 58420:                                 // Portal to Stormwind
                        {
                            if (!unitTarget || !unitTarget->IsPlayer() || effIndex != 0)
                                return;
 
                            uint32 spellID = m_spellInfo->Effects[EFFECT_0].CalcValue();
                            uint32 questID = m_spellInfo->Effects[EFFECT_1].CalcValue();
 
                            if (unitTarget->ToPlayer()->GetQuestStatus(questID) == QUEST_STATUS_COMPLETE)
                                unitTarget->CastSpell(unitTarget, spellID, true);
 
                            return;
                        }
                    case 61263: // for item Intravenous Healing Potion (44698)
                        {
                            if (!m_caster || !unitTarget)
                                return;
 
                            m_caster->CastSpell(m_caster, 61267, true);
                            m_caster->CastSpell(m_caster, 61268, true);
                            return;
                        }
                }
                break;
            }
        case SPELLFAMILY_ROGUE:
            {
                switch (m_spellInfo->Id)
                {
                    // Master of Subtlety
                    case 31666:
                        {
                            if (!unitTarget)
                                return;
 
                            Aura* mos = unitTarget->GetAura(31665);
                            if (mos)
                            {
                                mos->SetMaxDuration(6000);
                                mos->SetDuration(6000, true);
                            }
 
                            break;
                        }
                    // Overkill
                    case 58428:
                        {
                            if (!unitTarget)
                                return;
 
                            Aura* overkill = unitTarget->GetAura(58427);
                            if (overkill)
                            {
                                overkill->SetMaxDuration(20000);
                                overkill->SetDuration(20000, true);
                            }
 
                            break;
                        }
                }
                break;
            }
    }
 
    // normal DB scripted effect
    LOG_DEBUG("spells.aura", "Spell ScriptStart spellid {} in EffectScriptEffect({})", m_spellInfo->Id, effIndex);
    m_caster->GetMap()->ScriptsStart(sSpellScripts, uint32(m_spellInfo->Id | (effIndex << 24)), m_caster, unitTarget);
}

References BATTLEGROUND_SA, Unit::CastSpell(), Corpse, damage, BattlegroundSA::DefendersPortalTeleport(), Creature::DespawnOrUnsummon(), Player::DestroyItemCount(), EFFECT_0, EFFECT_1, effectHandleMode, SpellInfo::Effects, WorldObject::FindNearestGameObject(), Unit::GetAura(), Unit::getGender(), WorldObject::GetMap(), WorldObject::GetName(), Player::GetQuestStatus(), Unit::HasAura(), SpellInfo::Id, Unit::IsAlive(), Object::IsCreature(), Object::IsPlayer(), Unit::IsSummon(), LOG_DEBUG, m_caster, m_spellInfo, QUEST_STATUS_COMPLETE, Map::ScriptsStart(), Aura::SetDuration(), Aura::SetMaxDuration(), SPELL_EFFECT_HANDLE_HIT_TARGET, SPELLFAMILY_GENERIC, SPELLFAMILY_ROGUE, SpellInfo::SpellFamilyName, sSpellScripts, Unit::TextEmote(), Object::ToCreature(), Object::ToPlayer(), Unit::ToTempSummon(), unitTarget, TempSummon::UnSummon(), and urand().

◆ EffectSelfResurrect()

void Spell::EffectSelfResurrect ( SpellEffIndex effIndex )

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

References CalculatePct(), Unit::CountPctFromMaxHealth(), damage, effectHandleMode, SpellInfo::Effects, Unit::GetMaxPower(), Unit::IsAlive(), Object::IsInWorld(), Object::IsPlayer(), m_caster, m_spellInfo, POWER_ENERGY, POWER_MANA, POWER_RAGE, Player::ResurrectPlayer(), Unit::SetHealth(), Unit::SetPower(), Player::SpawnCorpseBones(), SPELL_EFFECT_HANDLE_HIT, and Object::ToPlayer().

◆ EffectSendEvent()

void Spell::EffectSendEvent ( SpellEffIndex effIndex )

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

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

References effectHandleMode, SpellInfo::Effects, focusObject, gameObjTarget, WorldObject::GetInstanceScript(), WorldObject::GetMap(), WorldObject::GetZoneScript(), SpellInfo::Id, LOG_DEBUG, m_caster, m_spellInfo, Map::ScriptsStart(), sEventScripts, SPELL_EFFECT_HANDLE_HIT, SPELL_EFFECT_HANDLE_HIT_TARGET, TARGET_FLAG_GAMEOBJECT_MASK, TARGET_FLAG_UNIT_MASK, and unitTarget.

◆ EffectSendTaxi()

void Spell::EffectSendTaxi ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    if (Player* player = unitTarget->ToPlayer())
    {
        player->ActivateTaxiPathTo(m_spellInfo->Effects[effIndex].MiscValue, m_spellInfo->Id);
    }
}

References effectHandleMode, SpellInfo::Effects, SpellInfo::Id, m_spellInfo, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectSkill()

void Spell::EffectSkill ( SpellEffIndex effIndex )

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

References effectHandleMode, LOG_DEBUG, and SPELL_EFFECT_HANDLE_HIT.

◆ EffectSkinning()

void Spell::EffectSkinning ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget->IsCreature())
        return;
    if (!m_caster->IsPlayer())
        return;
 
    Creature* creature = unitTarget->ToCreature();
    int32 targetLevel = creature->GetLevel();
 
    uint32 skill = creature->GetCreatureTemplate()->GetRequiredLootSkill();
 
    creature->RemoveUnitFlag(UNIT_FLAG_SKINNABLE);
    creature->SetDynamicFlag(UNIT_DYNFLAG_LOOTABLE);
    m_caster->ToPlayer()->SendLoot(creature->GetGUID(), LOOT_SKINNING);
 
    int32 reqValue = targetLevel < 10 ? 0 : targetLevel < 20 ? (targetLevel - 10) * 10 : targetLevel * 5;
 
    int32 skillValue = m_caster->ToPlayer()->GetPureSkillValue(skill);
 
    // Double chances for elites
    m_caster->ToPlayer()->UpdateGatherSkill(skill, skillValue, reqValue, creature->isElite() ? 2 : 1);
}

References effectHandleMode, Creature::GetCreatureTemplate(), Object::GetGUID(), Unit::GetLevel(), Player::GetPureSkillValue(), CreatureTemplate::GetRequiredLootSkill(), Object::IsCreature(), Creature::isElite(), Object::IsPlayer(), LOOT_SKINNING, m_caster, Unit::RemoveUnitFlag(), Player::SendLoot(), Object::SetDynamicFlag(), SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToCreature(), Object::ToPlayer(), UNIT_DYNFLAG_LOOTABLE, UNIT_FLAG_SKINNABLE, unitTarget, and Player::UpdateGatherSkill().

◆ EffectSkinPlayerCorpse()

void Spell::EffectSkinPlayerCorpse ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    LOG_DEBUG("spells.aura", "Effect: SkinPlayerCorpse");
    if ((!m_caster->IsPlayer()) || (!unitTarget->IsPlayer()) || (unitTarget->IsAlive()))
        return;
 
    unitTarget->ToPlayer()->RemovedInsignia(m_caster->ToPlayer());
 
    // We have a corpse object as the target.
    // This target was deleted in RemovedInsignia() -> ConvertCorpseToBones().
    m_targets.RemoveObjectTarget();
}

References effectHandleMode, Unit::IsAlive(), Object::IsPlayer(), LOG_DEBUG, m_caster, m_targets, Player::RemovedInsignia(), SpellCastTargets::RemoveObjectTarget(), SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectSpecCount()

void Spell::EffectSpecCount ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    if (Player* player = unitTarget->ToPlayer())
    {
        player->UpdateSpecCount(damage);
    }
}

References damage, effectHandleMode, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectSpiritHeal()

void Spell::EffectSpiritHeal ( SpellEffIndex effIndex )

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

References effectHandleMode, and SPELL_EFFECT_HANDLE_HIT_TARGET.

◆ EffectStealBeneficialBuff()

void Spell::EffectStealBeneficialBuff ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    LOG_DEBUG("spells.aura", "Effect: StealBeneficialBuff");
 
    if (!unitTarget || unitTarget == m_caster)                 // can't steal from self
        return;
 
    DispelChargesList steal_list;
 
    // Create dispel mask by dispel type
    uint32 dispelMask  = SpellInfo::GetDispelMask(DispelType(m_spellInfo->Effects[effIndex].MiscValue));
    Unit::AuraMap const& auras = unitTarget->GetOwnedAuras();
    for (Unit::AuraMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
    {
        Aura* aura = itr->second;
        AuraApplication* aurApp = aura->GetApplicationOfTarget(unitTarget->GetGUID());
        if (!aurApp)
            continue;
 
        if ((aura->GetSpellInfo()->GetDispelMask()) & dispelMask)
        {
            // Need check for passive? this
            if (!aurApp->IsPositive() || aura->IsPassive() || aura->GetSpellInfo()->HasAttribute(SPELL_ATTR4_CANNOT_BE_STOLEN))
                continue;
 
            // The charges / stack amounts don't count towards the total number of auras that can be dispelled.
            // Ie: A dispel on a target with 5 stacks of Winters Chill and a Polymorph has 1 / (1 + 1) -> 50% chance to dispell
            // Polymorph instead of 1 / (5 + 1) -> 16%.
            bool dispel_charges = aura->GetSpellInfo()->HasAttribute(SPELL_ATTR7_DISPEL_REMOVES_CHARGES);
            uint8 charges = dispel_charges ? aura->GetCharges() : aura->GetStackAmount();
            if (charges > 0)
                steal_list.push_back(std::make_pair(aura, charges));
        }
    }
 
    if (steal_list.empty())
        return;
 
    // Ok if exist some buffs for dispel try dispel it
    uint32 failCount = 0;
    DispelList success_list;
    WorldPacket dataFail(SMSG_DISPEL_FAILED, 8 + 8 + 4 + 4 + damage * 4);
    // dispel N = damage buffs (or while exist buffs for dispel)
    for (int32 count = 0; count < damage && !steal_list.empty();)
    {
        // Random select buff for dispel
        DispelChargesList::iterator itr = steal_list.begin();
        std::advance(itr, urand(0, steal_list.size() - 1));
 
        int32 chance = itr->first->CalcDispelChance(unitTarget, !unitTarget->IsFriendlyTo(m_caster));
        // 2.4.3 Patch Notes: "Dispel effects will no longer attempt to remove effects that have 100% dispel resistance."
        if (!chance)
        {
            steal_list.erase(itr);
            continue;
        }
        else
        {
            if (roll_chance_i(chance))
            {
                success_list.push_back(std::make_pair(itr->first->GetId(), itr->first->GetCasterGUID()));
                --itr->second;
                if (itr->second <= 0)
                    steal_list.erase(itr);
            }
            else
            {
                if (!failCount)
                {
                    // Failed to dispell
                    dataFail << m_caster->GetGUID();                    // Caster GUID
                    dataFail << unitTarget->GetGUID();                  // Victim GUID
                    dataFail << uint32(m_spellInfo->Id);                // dispel spell id
                }
                ++failCount;
                dataFail << uint32(itr->first->GetId());                // Spell Id
            }
            ++count;
        }
    }
 
    if (failCount)
        m_caster->SendMessageToSet(&dataFail, true);
 
    if (success_list.empty())
        return;
 
    WorldPacket dataSuccess(SMSG_SPELLSTEALLOG, 8 + 8 + 4 + 1 + 4 + damage * 5);
    dataSuccess << unitTarget->GetPackGUID();       // Victim GUID
    dataSuccess << m_caster->GetPackGUID();         // Caster GUID
    dataSuccess << uint32(m_spellInfo->Id);         // dispel spell id
    dataSuccess << uint8(0);                        // not used
    dataSuccess << uint32(success_list.size());     // count
    for (DispelList::iterator itr = success_list.begin(); itr != success_list.end(); ++itr)
    {
        dataSuccess << uint32(itr->first);          // Spell Id
        dataSuccess << uint8(0);                    // 0 - steals !=0 transfers
        unitTarget->RemoveAurasDueToSpellBySteal(itr->first, itr->second, m_caster);
    }
    m_caster->SendMessageToSet(&dataSuccess, true);
}

References damage, effectHandleMode, SpellInfo::Effects, Aura::GetApplicationOfTarget(), Aura::GetCharges(), SpellInfo::GetDispelMask(), Object::GetGUID(), Unit::GetOwnedAuras(), Object::GetPackGUID(), Aura::GetSpellInfo(), Aura::GetStackAmount(), SpellInfo::HasAttribute(), SpellInfo::Id, Unit::IsFriendlyTo(), Aura::IsPassive(), AuraApplication::IsPositive(), LOG_DEBUG, m_caster, m_spellInfo, Unit::RemoveAurasDueToSpellBySteal(), roll_chance_i(), WorldObject::SendMessageToSet(), SMSG_DISPEL_FAILED, SMSG_SPELLSTEALLOG, SPELL_ATTR4_CANNOT_BE_STOLEN, SPELL_ATTR7_DISPEL_REMOVES_CHARGES, SPELL_EFFECT_HANDLE_HIT_TARGET, unitTarget, and urand().

◆ EffectStuck()

void Spell::EffectStuck ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
        return;
 
    if (!m_caster->IsPlayer())
        return;
 
    Player* target = m_caster->ToPlayer();
    if (target->IsInFlight())
        return;
 
    // xinef: if player is dead - teleport to graveyard
    if (!target->IsAlive())
    {
        if (target->HasPreventResurectionAura())
            return;
 
        // xinef: player is in corpse
        if (!target->HasPlayerFlag(PLAYER_FLAGS_GHOST))
            target->BuildPlayerRepop();
        target->RepopAtGraveyard();
        return;
    }
 
    // xinef: no hearthstone in bag or on cooldown
    Item* hearthStone = target->GetItemByEntry(6948);
    if (!hearthStone || target->HasSpellCooldown(8690))
    {
        float o = rand_norm() * 2 * M_PI;
        Position pos = *target;
        target->MovePositionToFirstCollision(pos, 5.0f, o);
        target->NearTeleportTo(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), target->GetOrientation());
        return;
    }
 
    // xinef: we have hearthstone not on cooldown, just use it
    target->CastSpell(target, 8690, TriggerCastFlags(TRIGGERED_FULL_MASK & ~TRIGGERED_IGNORE_SPELL_AND_CATEGORY_CD));
}

References Player::BuildPlayerRepop(), Unit::CastSpell(), effectHandleMode, Player::GetItemByEntry(), Position::GetOrientation(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Player::HasPlayerFlag(), Unit::HasPreventResurectionAura(), Player::HasSpellCooldown(), Unit::IsAlive(), Unit::IsInFlight(), Object::IsPlayer(), m_caster, WorldObject::MovePositionToFirstCollision(), Unit::NearTeleportTo(), PLAYER_FLAGS_GHOST, rand_norm(), Player::RepopAtGraveyard(), SPELL_EFFECT_HANDLE_HIT, Object::ToPlayer(), TRIGGERED_FULL_MASK, and TRIGGERED_IGNORE_SPELL_AND_CATEGORY_CD.

◆ EffectSummonChangeItem()

void Spell::EffectSummonChangeItem ( SpellEffIndex effIndex )

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

References Player::AutoUnequipOffhandIfNeed(), Player::BankItem(), Player::CanBankItem(), Player::CanEquipItem(), Player::CanStoreItem(), ObjectGuid::Clear(), Item::CreateItem(), Player::DestroyItem(), Player::DurabilityLoss(), effectHandleMode, SpellInfo::Effects, EQUIP_ERR_CANT_DO_RIGHT_NOW, EQUIP_ERR_OK, Player::EquipItem(), EQUIPMENT_SLOT_MAINHAND, Item::GetBagSlot(), Item::GetEnchantmentCharges(), Item::GetEnchantmentDuration(), Item::GetEnchantmentId(), Object::GetEntry(), Object::GetGUID(), SpellCastTargets::GetItemTarget(), Item::GetOwnerGUID(), Item::GetPos(), Item::GetSlot(), Object::GetUInt32Value(), Player::IsBankPos(), Player::IsEquipmentPos(), Player::IsInventoryPos(), Object::IsPlayer(), ITEM_FIELD_DURABILITY, ITEM_FIELD_MAXDURABILITY, Player::ItemAddedQuestCheck(), m_caster, m_CastItem, m_castItemGUID, m_spellInfo, m_targets, PERM_ENCHANTMENT_SLOT, Item::SetEnchantment(), SpellCastTargets::SetItemTarget(), SPELL_EFFECT_HANDLE_HIT, Player::StoreItem(), TEMP_ENCHANTMENT_SLOT, Object::ToPlayer(), and Player::UpdateEnchantmentDurations().

◆ EffectSummonCritter()

void Spell::EffectSummonCritter ( SpellEffIndex effIndex )

◆ EffectSummonObject()

void Spell::EffectSummonObject ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
        return;
 
    uint32 gameobjectId = m_spellInfo->Effects[effIndex].MiscValue;
 
    uint8 slot = 0;
    switch (m_spellInfo->Effects[effIndex].Effect)
    {
        case SPELL_EFFECT_SUMMON_OBJECT_SLOT1:
            slot = 0;
            break;
        case SPELL_EFFECT_SUMMON_OBJECT_SLOT2:
            slot = 1;
            break;
        case SPELL_EFFECT_SUMMON_OBJECT_SLOT3:
            slot = 2;
            break;
        case SPELL_EFFECT_SUMMON_OBJECT_SLOT4:
            slot = 3;
            break;
        default:
            return;
    }
 
    if (m_caster)
    {
        ObjectGuid guid = m_caster->m_ObjectSlot[slot];
        if (guid)
        {
            if (GameObject* gameObject = m_caster->GetMap()->GetGameObject(guid))
            {
                // Recast case - null spell id to make auras not be removed on object remove from world
                if (m_spellInfo->Id == gameObject->GetSpellId())
                    gameObject->SetSpellId(0);
                m_caster->RemoveGameObject(gameObject, true);
            }
            m_caster->m_ObjectSlot[slot].Clear();
        }
    }
 
    GameObject* pGameObj = sObjectMgr->IsGameObjectStaticTransport(gameobjectId) ? new StaticTransport() : new GameObject();
 
    float x, y, z;
    // If dest location if present
    if (m_targets.HasDst())
        destTarget->GetPosition(x, y, z);
    // Summon in random point all other units if location present
    else
        m_caster->GetClosePoint(x, y, z, DEFAULT_WORLD_OBJECT_SIZE);
 
    Map* map = m_caster->GetMap();
    G3D::Quat rotation = G3D::Quat::fromAxisAngleRotation(G3D::Vector3::unitZ(), m_caster->GetOrientation());
    if (!pGameObj->Create(map->GenerateLowGuid<HighGuid::GameObject>(), gameobjectId, map, m_caster->GetPhaseMask(), x, y, z, m_caster->GetOrientation(), rotation, 0, GO_STATE_READY))
    {
        delete pGameObj;
        return;
    }
 
    //pGameObj->SetUInt32Value(GAMEOBJECT_LEVEL, m_caster->GetLevel());
    int32 duration = m_spellInfo->GetDuration();
    pGameObj->SetRespawnTime(duration > 0 ? duration / IN_MILLISECONDS : 0);
    pGameObj->SetSpellId(m_spellInfo->Id);
    m_caster->AddGameObject(pGameObj);
 
    ExecuteLogEffectSummonObject(effIndex, pGameObj);
 
    map->AddToMap(pGameObj, true);
 
    m_caster->m_ObjectSlot[slot] = pGameObj->GetGUID();
}

References Unit::AddGameObject(), Map::AddToMap(), ObjectGuid::Clear(), GameObject::Create(), DEFAULT_WORLD_OBJECT_SIZE, destTarget, effectHandleMode, SpellInfo::Effects, ExecuteLogEffectSummonObject(), GameObject, Map::GenerateLowGuid(), WorldObject::GetClosePoint(), SpellInfo::GetDuration(), Map::GetGameObject(), Object::GetGUID(), WorldObject::GetMap(), Position::GetOrientation(), WorldObject::GetPhaseMask(), Position::GetPosition(), GO_STATE_READY, SpellCastTargets::HasDst(), SpellInfo::Id, IN_MILLISECONDS, m_caster, Unit::m_ObjectSlot, m_spellInfo, m_targets, Unit::RemoveGameObject(), GameObject::SetRespawnTime(), GameObject::SetSpellId(), sObjectMgr, SPELL_EFFECT_HANDLE_HIT, SPELL_EFFECT_SUMMON_OBJECT_SLOT1, SPELL_EFFECT_SUMMON_OBJECT_SLOT2, SPELL_EFFECT_SUMMON_OBJECT_SLOT3, and SPELL_EFFECT_SUMMON_OBJECT_SLOT4.

◆ EffectSummonObjectWild()

void Spell::EffectSummonObjectWild ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
        return;
 
    uint32 gameobject_id = m_spellInfo->Effects[effIndex].MiscValue;
 
    GameObject* pGameObj = sObjectMgr->IsGameObjectStaticTransport(gameobject_id) ? new StaticTransport() : new GameObject();
 
    WorldObject* target = focusObject;
    if (!target)
        target = m_caster;
 
    float x, y, z;
    if (m_targets.HasDst())
        destTarget->GetPosition(x, y, z);
    else
        m_caster->GetClosePoint(x, y, z, DEFAULT_WORLD_OBJECT_SIZE);
 
    Map* map = target->GetMap();
 
    G3D::Quat rotation = G3D::Quat::fromAxisAngleRotation(G3D::Vector3::unitZ(), target->GetOrientation());
    if (!pGameObj->Create(map->GenerateLowGuid<HighGuid::GameObject>(), gameobject_id, map, m_caster->GetPhaseMask(), x, y, z, target->GetOrientation(), rotation, 100, GO_STATE_READY))
    {
        delete pGameObj;
        return;
    }
 
    int32 duration = m_spellInfo->GetDuration();
 
    pGameObj->SetRespawnTime(duration > 0 ? duration / IN_MILLISECONDS : 0);
    pGameObj->SetSpellId(m_spellInfo->Id);
 
    ExecuteLogEffectSummonObject(effIndex, pGameObj);
 
    // Wild object not have owner and check clickable by players
    map->AddToMap(pGameObj, true);
 
    if (pGameObj->GetGoType() == GAMEOBJECT_TYPE_FLAGDROP)
        if (Player* player = m_caster->ToPlayer())
            if (Battleground* bg = player->GetBattleground())
                bg->SetDroppedFlagGUID(pGameObj->GetGUID(), player->GetTeamId() == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE);
 
    if (GameObject* linkedTrap = pGameObj->GetLinkedTrap())
    {
        linkedTrap->SetRespawnTime(duration > 0 ? duration/IN_MILLISECONDS :0);
        linkedTrap->SetSpellId(m_spellInfo->Id);
        ExecuteLogEffectSummonObject(effIndex, linkedTrap);
    }
}

References Map::AddToMap(), GameObject::Create(), DEFAULT_WORLD_OBJECT_SIZE, destTarget, effectHandleMode, SpellInfo::Effects, ExecuteLogEffectSummonObject(), focusObject, GameObject, GAMEOBJECT_TYPE_FLAGDROP, Map::GenerateLowGuid(), WorldObject::GetClosePoint(), SpellInfo::GetDuration(), GameObject::GetGoType(), Object::GetGUID(), GameObject::GetLinkedTrap(), WorldObject::GetMap(), Position::GetOrientation(), WorldObject::GetPhaseMask(), Position::GetPosition(), GO_STATE_READY, SpellCastTargets::HasDst(), SpellInfo::Id, IN_MILLISECONDS, m_caster, m_spellInfo, m_targets, GameObject::SetRespawnTime(), GameObject::SetSpellId(), sObjectMgr, SPELL_EFFECT_HANDLE_HIT, TEAM_ALLIANCE, TEAM_HORDE, and Object::ToPlayer().

◆ EffectSummonPet()

void Spell::EffectSummonPet ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
        return;
 
    if (!m_originalCaster)
        return;
 
    uint32 petentry = m_spellInfo->Effects[effIndex].MiscValue;
    int32 duration = m_spellInfo->GetDuration();
 
    if (Player* modOwner = m_originalCaster->GetSpellModOwner())
        modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_DURATION, duration);
 
    Player* owner = m_originalCaster->ToPlayer();
    if (!owner && m_originalCaster->ToCreature()->IsTotem())
        owner = m_originalCaster->GetCharmerOrOwnerPlayerOrPlayerItself();
 
    if (!owner)
    {
        SummonPropertiesEntry const* properties = sSummonPropertiesStore.LookupEntry(67);
        if (properties)
        {
            // Xinef: unsummon old guardian
            if (Guardian* oldPet = m_originalCaster->GetGuardianPet())
                oldPet->UnSummon();
            SummonGuardian(effIndex, petentry, properties, 1, false);
        }
        return;
    }
 
    Pet* OldSummon = owner->GetPet();
 
    // if pet requested type already exist
    if (OldSummon)
    {
        if (petentry == 0 || OldSummon->GetEntry() == petentry)
        {
            // pet in corpse state can't be summoned
            if (OldSummon->isDead())
                return;
 
            ASSERT(OldSummon->GetMap() == owner->GetMap());
 
            //OldSummon->GetMap()->Remove(OldSummon->ToCreature(), false);
 
            float px, py, pz;
            owner->GetClosePoint(px, py, pz, OldSummon->GetObjectSize());
 
            OldSummon->NearTeleportTo(px, py, pz, OldSummon->GetOrientation());
            OldSummon->UpdateObjectVisibility();
 
            OldSummon->SetHealth(OldSummon->GetMaxHealth());
            OldSummon->SetPower(OldSummon->getPowerType(), OldSummon->GetMaxPower(OldSummon->getPowerType()));
            // notify player
            for (CreatureSpellCooldowns::const_iterator itr = OldSummon->m_CreatureSpellCooldowns.begin(); itr != OldSummon->m_CreatureSpellCooldowns.end(); ++itr)
                owner->SendClearCooldown(itr->first, OldSummon);
 
            // actually clear cooldowns
            OldSummon->m_CreatureSpellCooldowns.clear();
            Unit::AuraApplicationMap& myAuras = OldSummon->GetAppliedAuras();
            for (Unit::AuraApplicationMap::iterator i = myAuras.begin(); i != myAuras.end();)
            {
                Aura const* aura = i->second->GetBase();
                if (!aura->IsPassive() && !OldSummon->IsPetAura(aura) && aura->CanBeSentToClient())
                    OldSummon->RemoveAura(i);
                else
                    ++i;
            }
            return;
        }
 
        if (owner->IsPlayer())
            owner->ToPlayer()->RemovePet(OldSummon, PET_SAVE_NOT_IN_SLOT, false);
        else
            return;
    }
 
    float x, y, z;
    owner->GetClosePoint(x, y, z, owner->GetObjectSize());
    Pet* pet = owner->SummonPet(petentry, x, y, z, owner->GetOrientation(), SUMMON_PET);
    if (!pet)
        return;
 
    if (m_caster->IsCreature())
    {
        if (m_caster->ToCreature()->IsTotem())
            pet->SetReactState(REACT_AGGRESSIVE);
        else
            pet->SetReactState(REACT_DEFENSIVE);
    }
 
    pet->SetUInt32Value(UNIT_CREATED_BY_SPELL, m_spellInfo->Id);
 
    // Reset cooldowns
    if (!owner->IsClass(CLASS_HUNTER, CLASS_CONTEXT_PET))
    {
        pet->m_CreatureSpellCooldowns.clear();
        owner->PetSpellInitialize();
    }
 
    // Set health to max if new pet is summoned
    // in this function old pet is saved with current health eg. 20% and new one is loaded from db with same amount
    // pet should have full health
    pet->SetHealth(pet->GetMaxHealth());
 
    // generate new name for summon pet
    std::string new_name = sObjectMgr->GeneratePetName(petentry);
    if (!new_name.empty())
        pet->SetName(new_name);
 
    // ExecuteLogEffectSummonObject(effectInfo->EffectIndex, pet);
}

References ASSERT, Aura::CanBeSentToClient(), CLASS_CONTEXT_PET, CLASS_HUNTER, effectHandleMode, SpellInfo::Effects, Unit::GetAppliedAuras(), Unit::GetCharmerOrOwnerPlayerOrPlayerItself(), WorldObject::GetClosePoint(), SpellInfo::GetDuration(), Object::GetEntry(), Unit::GetGuardianPet(), WorldObject::GetMap(), Unit::GetMaxHealth(), Unit::GetMaxPower(), WorldObject::GetObjectSize(), Position::GetOrientation(), Player::GetPet(), Unit::getPowerType(), Unit::GetSpellModOwner(), SpellInfo::Id, Player::IsClass(), Object::IsCreature(), Unit::isDead(), Aura::IsPassive(), Unit::IsPetAura(), Object::IsPlayer(), Unit::IsTotem(), m_caster, Creature::m_CreatureSpellCooldowns, m_originalCaster, m_spellInfo, Unit::NearTeleportTo(), PET_SAVE_NOT_IN_SLOT, Player::PetSpellInitialize(), REACT_AGGRESSIVE, REACT_DEFENSIVE, Unit::RemoveAura(), Player::RemovePet(), Player::SendClearCooldown(), Unit::SetHealth(), WorldObject::SetName(), Unit::SetPower(), Creature::SetReactState(), Unit::SetUInt32Value(), sObjectMgr, SPELL_EFFECT_HANDLE_HIT, SPELLMOD_DURATION, sSummonPropertiesStore, SUMMON_PET, SummonGuardian(), Player::SummonPet(), Object::ToCreature(), Object::ToPlayer(), UNIT_CREATED_BY_SPELL, and Unit::UpdateObjectVisibility().

◆ EffectSummonPlayer()

void Spell::EffectSummonPlayer ( SpellEffIndex effIndex )

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

References effectHandleMode, Object::GetGUID(), WorldLocation::GetMapId(), Position::GetPosition(), WorldObject::GetZoneId(), Unit::HasAura(), IN_MILLISECONDS, m_caster, MAX_PLAYER_SUMMON_DELAY, Player::SendDirectMessage(), Player::SetSummonPoint(), SMSG_SUMMON_REQUEST, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectSummonRaFFriend()

void Spell::EffectSummonRaFFriend ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!m_caster->IsPlayer())
        return;
 
    if (!unitTarget)
        return;
 
    Player* player = unitTarget->ToPlayer();
    if (!player)
    {
        return;
    }
 
    float x, y, z;
    m_caster->GetPosition(x, y, z);
    unitTarget->ToPlayer()->SetSummonPoint(m_caster->GetMapId(), x, y, z);
    WorldPacket data(SMSG_SUMMON_REQUEST, 8 + 4 + 4);
    data << m_caster->GetGUID();
    data << uint32(m_caster->GetZoneId());
    data << uint32(MAX_PLAYER_SUMMON_DELAY * IN_MILLISECONDS); // auto decline after msecs
    player->SendDirectMessage(&data);
}

References effectHandleMode, Object::GetGUID(), WorldLocation::GetMapId(), Position::GetPosition(), WorldObject::GetZoneId(), IN_MILLISECONDS, Object::IsPlayer(), m_caster, MAX_PLAYER_SUMMON_DELAY, Player::SendDirectMessage(), Player::SetSummonPoint(), SMSG_SUMMON_REQUEST, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectSummonType()

void Spell::EffectSummonType ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
        return;
 
    uint32 entry = m_spellInfo->Effects[effIndex].MiscValue;
 
    if (m_spellValue->MiscVal[effIndex])
        entry = m_spellValue->MiscVal[effIndex];
 
    if (!entry)
        return;
 
    SummonPropertiesEntry const* properties = sSummonPropertiesStore.LookupEntry(m_spellInfo->Effects[effIndex].MiscValueB);
    if (!properties)
    {
        LOG_ERROR("spells.effect", "EffectSummonType: Unhandled summon type {}", m_spellInfo->Effects[effIndex].MiscValueB);
        return;
    }
 
    if (!m_originalCaster)
        return;
 
    bool personalSpawn = (properties->Flags & SUMMON_PROP_FLAG_ONLY_VISIBLE_TO_SUMMONER) != 0;
    int32 duration = m_spellInfo->GetDuration();
    if (Player* modOwner = m_originalCaster->GetSpellModOwner())
        modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_DURATION, duration);
 
    TempSummon* summon = nullptr;
 
    // determine how many units should be summoned
    uint32 numSummons;
 
    // some spells need to summon many units, for those spells number of summons is stored in effect value
    // however so far noone found a generic check to find all of those (there's no related data in summonproperties.dbc
    // and in spell attributes, possibly we need to add a table for those)
    // so here's a list of MiscValueB values, which is currently most generic check
    switch (properties->Id)
    {
        case 64:
        case 61:
        case 1101:
        case 66:
        case 648:
        case 2301:
        case 1061:
        case 1261:
        case 629:
        case 181:
        case 715:
        case 1562:
        case 833:
        case 1161:
        case 713: // xinef, bloodworms
            numSummons = (damage > 0) ? damage : 1;
            break;
        default:
            numSummons = 1;
            break;
    }
 
    switch (properties->Category)
    {
        case SUMMON_CATEGORY_WILD:
        case SUMMON_CATEGORY_ALLY:
        case SUMMON_CATEGORY_UNK:
            if (properties->Flags & 512)
            {
                SummonGuardian(effIndex, entry, properties, numSummons, personalSpawn);
                break;
            }
            switch (properties->Type)
            {
                case SUMMON_TYPE_PET:
                case SUMMON_TYPE_GUARDIAN:
                case SUMMON_TYPE_GUARDIAN2:
                case SUMMON_TYPE_MINION:
                    SummonGuardian(effIndex, entry, properties, numSummons, personalSpawn);
                    break;
                // Summons a vehicle, but doesn't force anyone to enter it (see SUMMON_CATEGORY_VEHICLE)
                case SUMMON_TYPE_VEHICLE:
                case SUMMON_TYPE_VEHICLE2:
                    summon = m_caster->GetMap()->SummonCreature(entry, *destTarget, properties, duration, m_originalCaster, m_spellInfo->Id, 0, personalSpawn);
                    break;
                case SUMMON_TYPE_LIGHTWELL:
                case SUMMON_TYPE_TOTEM:
                    {
                        // protection code
                        summon = m_caster->GetMap()->SummonCreature(entry, *destTarget, properties, duration, m_originalCaster, m_spellInfo->Id, 0, personalSpawn);
                        if (!summon || !summon->IsTotem())
                            return;
 
                        // Mana Tide Totem
                        if (m_spellInfo->Id == 16190)
                            damage = m_caster->CountPctFromMaxHealth(10);
 
                        if (damage && properties->Type != SUMMON_TYPE_LIGHTWELL) // Health set in script for lightwell
                        {
                            summon->SetMaxHealth(damage);
                            summon->SetHealth(damage);
                        }
                        break;
                    }
                case SUMMON_TYPE_MINIPET:
                    // For companions, recalculate the position to ensure they spawn at the intended π/4 angle.
                    destTarget->Relocate(m_originalCaster->GetNearPosition(
                        m_originalCaster->GetDistance2d(destTarget->GetPositionX(), destTarget->GetPositionY()),
                        MINI_PET_SUMMON_ANGLE
                    ));
                    [[fallthrough]];
                case SUMMON_TYPE_JEEVES:
                    {
                        summon = m_caster->GetMap()->SummonCreature(entry, *destTarget, properties, duration, m_originalCaster, m_spellInfo->Id, 0, personalSpawn);
                        if (!summon || !summon->HasUnitTypeMask(UNIT_MASK_MINION))
                            return;
 
                        summon->SelectLevel();       // some summoned creaters have different from 1 DB data for level/hp
                        summon->ReplaceAllNpcFlags(NPCFlags(summon->GetCreatureTemplate()->npcflag));
 
                        summon->SetImmuneToAll(true);
                        summon->SetReactState(REACT_PASSIVE);
 
                        // Xinef: Pet can have some auras in creature_addon or in scripts, do not remove them instantly
                        //summon->AI()->EnterEvadeMode();
                        if (properties->Type != SUMMON_TYPE_JEEVES)
                        {
                            summon->SetFacingToObject(m_originalCaster);
                            summon->GetMotionMaster()->Clear(false);
                            summon->GetMotionMaster()->MoveFollow(m_originalCaster, PET_FOLLOW_DIST, MINI_PET_FOLLOW_ANGLE, MOTION_SLOT_ACTIVE);
                        }
                        break;
                    }
                default:
                    {
                        float radius = m_spellInfo->Effects[effIndex].CalcRadius();
 
                        TempSummonType summonType = (duration <= 0) ? TEMPSUMMON_DEAD_DESPAWN : TEMPSUMMON_TIMED_DESPAWN;
 
                        Unit* summoner = m_originalCaster;
                        if (summoner->IsPet())
                            if (Unit* owner = summoner->GetOwner())
                                summoner = owner;
 
                        for (uint32 count = 0; count < numSummons; ++count)
                        {
                            Position pos;
                            if (count == 0)
                                pos = *destTarget;
                            else
                                // randomize position for multiple summons
                                pos = m_caster->GetRandomPoint(*destTarget, radius);
 
                            summon = summoner->SummonCreature(entry, pos, summonType, duration, 0, nullptr, personalSpawn);
                            if (!summon)
                                continue;
 
                            summon->SetTempSummonType(summonType);
 
                            if (properties->Category == SUMMON_CATEGORY_ALLY)
                            {
                                summon->SetOwnerGUID(summoner->GetGUID());
                                summon->SetFaction(summoner->GetFaction());
                            }
 
                            ExecuteLogEffectSummonObject(effIndex, summon);
                        }
                        return;
                    }
            }//switch
            break;
        case SUMMON_CATEGORY_PET:
            // Xinef: SummonGuardian function can summon a few npcs of same type, remove old summons with same entry here
            if (m_originalCaster)
                m_originalCaster->RemoveAllMinionsByEntry(entry);
            SummonGuardian(effIndex, entry, properties, numSummons, personalSpawn);
            break;
        case SUMMON_CATEGORY_PUPPET:
            summon = m_caster->GetMap()->SummonCreature(entry, *destTarget, properties, duration, m_originalCaster, m_spellInfo->Id, 0, personalSpawn);
            break;
        case SUMMON_CATEGORY_VEHICLE:
            // Summoning spells (usually triggered by npc_spellclick) that spawn a vehicle and that cause the clicker
            // to cast a ride vehicle spell on the summoned unit.
            //float x, y, z;
            //m_caster->GetClosePoint(x, y, z, DEFAULT_WORLD_OBJECT_SIZE);
            // xinef: vehicles summoned in air, eg. Cold Hearted quest
            if (std::fabs(m_caster->GetPositionZ() - destTarget->GetPositionZ()) > 6.0f)
                destTarget->m_positionZ = m_caster->GetPositionZ();
 
            summon = m_originalCaster->GetMap()->SummonCreature(entry, *destTarget, properties, duration, m_caster, m_spellInfo->Id, 0, personalSpawn);
            if (!summon || !summon->IsVehicle())
                return;
 
            // The spell that this effect will trigger. It has SPELL_AURA_CONTROL_VEHICLE
            uint32 spellId = VEHICLE_SPELL_RIDE_HARDCODED;
            int32 basePoints = m_spellInfo->Effects[effIndex].CalcValue();
            if (basePoints > 1) // xinef: some summoning spells have value 1 - indicates vehicle seat
            {
                SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(basePoints);
                if (spellInfo && spellInfo->HasAura(SPELL_AURA_CONTROL_VEHICLE))
                    spellId = spellInfo->Id;
            }
 
            // xinef: if we have small value, it indicates seat position
            if (basePoints > 0 && basePoints < MAX_VEHICLE_SEATS)
                m_originalCaster->CastCustomSpell(spellId, SPELLVALUE_BASE_POINT0, basePoints, summon, true);
            else
                m_originalCaster->CastSpell(summon, spellId, true);
 
            // xinef: i think this is wrong, found only 2 vehicles with faction override and one of them should inherit caster faction...
            //uint32 faction = properties->Faction;
            //if (!faction)
            uint32 faction = m_originalCaster->GetFaction();
 
            summon->SetFaction(faction);
            break;
    }
 
    if (summon)
    {
        summon->SetCreatorGUID(m_originalCaster->GetGUID());
        ExecuteLogEffectSummonObject(effIndex, summon);
    }
}

References Unit::CastCustomSpell(), Unit::CastSpell(), SummonPropertiesEntry::Category, MotionMaster::Clear(), Unit::CountPctFromMaxHealth(), damage, destTarget, effectHandleMode, SpellInfo::Effects, ExecuteLogEffectSummonObject(), SummonPropertiesEntry::Flags, Creature::GetCreatureTemplate(), WorldObject::GetDistance2d(), SpellInfo::GetDuration(), Unit::GetFaction(), Object::GetGUID(), WorldObject::GetMap(), Unit::GetMotionMaster(), WorldObject::GetNearPosition(), Unit::GetOwner(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), WorldObject::GetRandomPoint(), Unit::GetSpellModOwner(), SpellInfo::HasAura(), Unit::HasUnitTypeMask(), SpellInfo::Id, SummonPropertiesEntry::Id, Unit::IsPet(), Unit::IsTotem(), Unit::IsVehicle(), LOG_ERROR, m_caster, m_originalCaster, Position::m_positionZ, m_spellInfo, m_spellValue, MAX_VEHICLE_SEATS, MINI_PET_FOLLOW_ANGLE, MINI_PET_SUMMON_ANGLE, SpellValue::MiscVal, MOTION_SLOT_ACTIVE, MotionMaster::MoveFollow(), CreatureTemplate::npcflag, PET_FOLLOW_DIST, REACT_PASSIVE, Position::Relocate(), Unit::RemoveAllMinionsByEntry(), Unit::ReplaceAllNpcFlags(), Creature::SelectLevel(), Unit::SetCreatorGUID(), Unit::SetFacingToObject(), Unit::SetFaction(), Unit::SetHealth(), Unit::SetImmuneToAll(), Unit::SetMaxHealth(), Unit::SetOwnerGUID(), Creature::SetReactState(), TempSummon::SetTempSummonType(), SPELL_AURA_CONTROL_VEHICLE, SPELL_EFFECT_HANDLE_HIT, SPELLMOD_DURATION, SPELLVALUE_BASE_POINT0, sSpellMgr, sSummonPropertiesStore, SUMMON_CATEGORY_ALLY, SUMMON_CATEGORY_PET, SUMMON_CATEGORY_PUPPET, SUMMON_CATEGORY_UNK, SUMMON_CATEGORY_VEHICLE, SUMMON_CATEGORY_WILD, SUMMON_PROP_FLAG_ONLY_VISIBLE_TO_SUMMONER, SUMMON_TYPE_GUARDIAN, SUMMON_TYPE_GUARDIAN2, SUMMON_TYPE_JEEVES, SUMMON_TYPE_LIGHTWELL, SUMMON_TYPE_MINION, SUMMON_TYPE_MINIPET, SUMMON_TYPE_PET, SUMMON_TYPE_TOTEM, SUMMON_TYPE_VEHICLE, SUMMON_TYPE_VEHICLE2, Map::SummonCreature(), WorldObject::SummonCreature(), SummonGuardian(), TEMPSUMMON_DEAD_DESPAWN, TEMPSUMMON_TIMED_DESPAWN, SummonPropertiesEntry::Type, UNIT_MASK_MINION, and VEHICLE_SPELL_RIDE_HARDCODED.

◆ EffectTameCreature()

void Spell::EffectTameCreature ( SpellEffIndex effIndex )

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

References Map::AddToMap(), CLASS_CONTEXT_PET, CLASS_HUNTER, Unit::CreateTamedPetFrom(), Creature::DespawnOrUnsummon(), effectHandleMode, finish(), Unit::GetLevel(), WorldObject::GetMap(), Unit::GetPetGUID(), SpellInfo::Id, Pet::InitTalentForLevel(), Unit::IsClass(), Object::IsCreature(), Unit::IsPet(), Object::IsPlayer(), m_caster, m_spellInfo, PET_SAVE_AS_CURRENT, Player::PetSpellInitialize(), Pet::SavePetToDB(), Unit::SetMinion(), Unit::SetUInt32Value(), SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToCreature(), Object::ToPlayer(), UNIT_FIELD_LEVEL, and unitTarget.

◆ EffectTaunt()

void Spell::EffectTaunt ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    // xinef: Hand of Reckoning, cast before checking canhavethreatlist. fixes damage against pets
    if (m_spellInfo->Id == 62124 && unitTarget->GetVictim() != m_caster)
        m_caster->CastSpell(unitTarget, 67485, true);
 
    if (!unitTarget->CanHaveThreatList())
    {
        SendCastResult(SPELL_FAILED_DONT_REPORT);
        return;
    }
 
    ThreatManager& mgr = unitTarget->GetThreatMgr();
    if (mgr.GetCurrentVictim() == m_caster)
    {
        SendCastResult(SPELL_FAILED_DONT_REPORT);
        return;
    }
 
    if (!mgr.IsThreatListEmpty())
        mgr.MatchUnitThreatToHighestThreat(m_caster);
}

References Unit::CanHaveThreatList(), Unit::CastSpell(), effectHandleMode, ThreatManager::GetCurrentVictim(), Unit::GetThreatMgr(), Unit::GetVictim(), SpellInfo::Id, ThreatManager::IsThreatListEmpty(), m_caster, m_spellInfo, ThreatManager::MatchUnitThreatToHighestThreat(), SendCastResult(), SPELL_EFFECT_HANDLE_HIT_TARGET, SPELL_FAILED_DONT_REPORT, and unitTarget.

◆ EffectTeleportUnits()

void Spell::EffectTeleportUnits ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget || unitTarget->IsInFlight())
        return;
 
    if (unitTarget->IsPlayer())
    {
        sScriptMgr->AnticheatSetUnderACKmount(unitTarget->ToPlayer());
    }
 
    // Pre effects
    switch (m_spellInfo->Id)
    {
        case 70746: // Teleport Into Sunwell (for Battered Hilt)
            if (Player* target = unitTarget->ToPlayer())
            {
                uint32 mapid = destTarget->GetMapId();
                float x, y, z, orientation;
                destTarget->GetPosition(x, y, z, orientation);
                target->TeleportTo(mapid, x, y, z, orientation, TELE_TO_GM_MODE); // skip PlayerCannotEnter check
            }
            return;
    }
 
    // If not exist data for dest location - return
    if (!m_targets.HasDst())
    {
        LOG_ERROR("spells.effect", "Spell::EffectTeleportUnits - does not have destination for spell ID {}\n", m_spellInfo->Id);
        return;
    }
 
    // Init dest coordinates
    uint32 mapid = destTarget->GetMapId();
    if (mapid == MAPID_INVALID)
        mapid = unitTarget->GetMapId();
    float x, y, z, orientation;
    destTarget->GetPosition(x, y, z, orientation);
    if (!orientation && m_targets.GetUnitTarget())
        orientation = m_targets.GetUnitTarget()->GetOrientation();
    LOG_DEBUG("spells.aura", "Spell::EffectTeleportUnits - teleport unit to {} {} {} {} {}\n", mapid, x, y, z, orientation);
 
    if (mapid == unitTarget->GetMapId())
    {
        if (unitTarget->GetVehicleKit()) // we are vehicle!
            unitTarget->GetVehicleKit()->TeleportVehicle(x, y, z, orientation);
        else
        {
            bool withPet = unitTarget->IsPlayer() && m_spellInfo->SpellFamilyName == SPELLFAMILY_GENERIC && unitTarget->GetMap()->IsDungeon() && unitTarget->GetExactDist(x, y, z) > 50.0f;
            unitTarget->NearTeleportTo(x, y, z, orientation, unitTarget == m_caster, false, withPet, true);
            if (unitTarget->IsPlayer()) // pussywizard: for units it's done inside NearTeleportTo
                unitTarget->UpdateObjectVisibility(true);
        }
    }
    else if (unitTarget->IsPlayer())
        unitTarget->ToPlayer()->TeleportTo(mapid, x, y, z, orientation, unitTarget == m_caster ? TELE_TO_SPELL : 0);
    else
    {
        LOG_ERROR("spells.effect", "Spell::EffectTeleportUnits - spellId {} attempted to teleport creature to a different map.", m_spellInfo->Id);
        return;
    }
 
    // post effects for TARGET_DEST_DB
    switch (m_spellInfo->Id)
    {
        // Dimensional Ripper - Everlook
        case 23442:
            {
                int32 r = irand(0, 119);
                if (r >= 70)                                  // 7/12 success
                {
                    if (r < 100)                              // 4/12 evil twin
                        m_caster->CastSpell(m_caster, 23445, true);
                    else                                        // 1/12 fire
                        m_caster->CastSpell(m_caster, 23449, true);
                }
                return;
            }
        // Ultrasafe Transporter: Toshley's Station
        case 36941:
            {
                if (roll_chance_i(50))                        // 50% success
                {
                    int32 rand_eff = urand(1, 7);
                    switch (rand_eff)
                    {
                        case 1:
                            // soul split - evil
                            m_caster->CastSpell(m_caster, 36900, true);
                            break;
                        case 2:
                            // soul split - good
                            m_caster->CastSpell(m_caster, 36901, true);
                            break;
                        case 3:
                            // Increase the size
                            m_caster->CastSpell(m_caster, 36895, true);
                            break;
                        case 4:
                            // Decrease the size
                            m_caster->CastSpell(m_caster, 36893, true);
                            break;
                        case 5:
                            // Transform
                            {
                                if (m_caster->ToPlayer()->GetTeamId() == TEAM_ALLIANCE)
                                    m_caster->CastSpell(m_caster, 36897, true);
                                else
                                    m_caster->CastSpell(m_caster, 36899, true);
                                break;
                            }
                        case 6:
                            // chicken
                            m_caster->CastSpell(m_caster, 36940, true);
                            break;
                        case 7:
                            // evil twin
                            m_caster->CastSpell(m_caster, 23445, true);
                            break;
                    }
                }
                return;
            }
    }
}

References Unit::CastSpell(), destTarget, effectHandleMode, Position::GetExactDist(), WorldObject::GetMap(), WorldLocation::GetMapId(), Position::GetOrientation(), Position::GetPosition(), Player::GetTeamId(), SpellCastTargets::GetUnitTarget(), Unit::GetVehicleKit(), SpellCastTargets::HasDst(), SpellInfo::Id, irand(), Map::IsDungeon(), Unit::IsInFlight(), Object::IsPlayer(), LOG_DEBUG, LOG_ERROR, m_caster, m_spellInfo, m_targets, MAPID_INVALID, Unit::NearTeleportTo(), roll_chance_i(), SPELL_EFFECT_HANDLE_HIT_TARGET, SPELLFAMILY_GENERIC, SpellInfo::SpellFamilyName, sScriptMgr, TEAM_ALLIANCE, TELE_TO_GM_MODE, TELE_TO_SPELL, Player::TeleportTo(), Vehicle::TeleportVehicle(), Object::ToPlayer(), unitTarget, Unit::UpdateObjectVisibility(), and urand().

◆ EffectTeleUnitsFaceCaster()

void Spell::EffectTeleUnitsFaceCaster ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget || unitTarget->IsInFlight())
        return;
 
    if (m_targets.HasDst())
    {
        unitTarget->NearTeleportTo(destTarget->GetPositionX(), destTarget->GetPositionY(), destTarget->GetPositionZ(), destTarget->GetAbsoluteAngle(m_caster), unitTarget == m_caster);
    }
}

References destTarget, effectHandleMode, Position::GetAbsoluteAngle(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), SpellCastTargets::HasDst(), Unit::IsInFlight(), m_caster, m_targets, Unit::NearTeleportTo(), SPELL_EFFECT_HANDLE_HIT_TARGET, and unitTarget.

◆ EffectThreat()

void Spell::EffectThreat ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget || !unitTarget->IsAlive() || !m_caster->IsAlive())
        return;
 
    // xinef: skip if target cannot have threat list or caster is friendly (ghoul leap)
    if (!unitTarget->CanHaveThreatList() || m_caster->IsFriendlyTo(unitTarget))
        return;
 
    // SPELL_EFFECT_THREAT adds flat threat that should not be modified by threat reduction
    unitTarget->GetThreatMgr().AddThreat(m_caster, float(damage), m_spellInfo, true);
}

References ThreatManager::AddThreat(), Unit::CanHaveThreatList(), damage, effectHandleMode, Unit::GetThreatMgr(), Unit::IsAlive(), Unit::IsFriendlyTo(), m_caster, m_spellInfo, SPELL_EFFECT_HANDLE_HIT_TARGET, and unitTarget.

◆ EffectTitanGrip()

void Spell::EffectTitanGrip ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
        return;
 
    if (m_caster->IsPlayer())
    {
        if (Aura* aur = m_caster->GetAura(49152))
            aur->RecalculateAmountOfEffects();
        else
            m_caster->CastSpell(unitTarget, 49152, true); // damage reduction
 
        m_caster->ToPlayer()->SetCanTitanGrip(true);
    }
}

References Unit::CastSpell(), effectHandleMode, Unit::GetAura(), Object::IsPlayer(), m_caster, Player::SetCanTitanGrip(), SPELL_EFFECT_HANDLE_HIT, Object::ToPlayer(), and unitTarget.

◆ EffectTradeSkill()

void Spell::EffectTradeSkill ( SpellEffIndex effIndex )

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

References effectHandleMode, Object::IsPlayer(), m_caster, and SPELL_EFFECT_HANDLE_HIT.

◆ EffectTransmitted()

void Spell::EffectTransmitted ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
        return;
 
    uint32 name_id = m_spellInfo->Effects[effIndex].MiscValue;
 
    GameObjectTemplate const* goinfo = sObjectMgr->GetGameObjectTemplate(name_id);
 
    if (!goinfo)
    {
        LOG_ERROR("sql.sql", "Gameobject (Entry: {}) not exist and not created at spell (ID: {}) cast", name_id, m_spellInfo->Id);
        return;
    }
 
    float fx, fy, fz;
 
    if (m_targets.HasDst())
        destTarget->GetPosition(fx, fy, fz);
    //FIXME: this can be better check for most objects but still hack
    else if (m_spellInfo->Effects[effIndex].HasRadius() && m_spellInfo->Speed == 0)
    {
        float dis = m_spellInfo->Effects[effIndex].CalcRadius(m_originalCaster);
        m_caster->GetClosePoint(fx, fy, fz, DEFAULT_WORLD_OBJECT_SIZE, dis);
    }
    else
    {
        //GO is always friendly to it's creator, get range for friends
        float min_dis = m_spellInfo->GetMinRange(true);
        float max_dis = m_spellInfo->GetMaxRange(true);
        float dis = (float)rand_norm() * (max_dis - min_dis) + min_dis;
 
        m_caster->GetClosePoint(fx, fy, fz, DEFAULT_WORLD_OBJECT_SIZE, dis);
    }
 
    // Seaforium charge
    if (m_spellInfo->Id == 52410 || m_spellInfo->Id == 66268 || m_spellInfo->Id == 66674) // SotA / IoC / IoC Huge
    {
        fx = m_caster->GetPositionX();
        fy = m_caster->GetPositionY();
        fz = m_caster->GetPositionZ();
    }
 
    Map* cMap = m_caster->GetMap();
 
    GameObject* pGameObj = sObjectMgr->IsGameObjectStaticTransport(name_id) ? new StaticTransport() : new GameObject();
 
    G3D::Quat rotation = G3D::Quat::fromAxisAngleRotation(G3D::Vector3::unitZ(), m_caster->GetOrientation());
    if (!pGameObj->Create(cMap->GenerateLowGuid<HighGuid::GameObject>(), name_id, cMap, m_caster->GetPhaseMask(), fx, fy, fz, m_caster->GetOrientation(), rotation, 100, GO_STATE_READY))
    {
        delete pGameObj;
        return;
    }
 
    int32 duration = m_spellInfo->GetDuration();
 
    switch (goinfo->type)
    {
        case GAMEOBJECT_TYPE_FISHINGNODE:
            {
                m_caster->SetGuidValue(UNIT_FIELD_CHANNEL_OBJECT, pGameObj->GetGUID());
                m_caster->AddGameObject(pGameObj);              // will removed at spell cancel
 
                // end time of range when possible catch fish (FISHING_BOBBER_READY_TIME..GetDuration(m_spellInfo))
                // start time == fish-FISHING_BOBBER_READY_TIME (0..GetDuration(m_spellInfo)-FISHING_BOBBER_READY_TIME)
                int32 lastSec = 0;
                switch (urand(0, 2))
                {
                    case 0:
                        lastSec =  3;
                        break;
                    case 1:
                        lastSec =  7;
                        break;
                    case 2:
                        lastSec = 13;
                        break;
                }
 
                // Duration of the fishing bobber can't be higher than the Fishing channeling duration
                duration = std::min(duration, duration - lastSec*IN_MILLISECONDS + FISHING_BOBBER_READY_TIME*IN_MILLISECONDS);
 
                break;
            }
        case GAMEOBJECT_TYPE_SUMMONING_RITUAL:
            {
                if (m_caster->IsPlayer())
                {
                    pGameObj->AddUniqueUse(m_caster->ToPlayer());
                    m_caster->AddGameObject(pGameObj);      // will be removed at spell cancel
                }
                break;
            }
        case GAMEOBJECT_TYPE_DUEL_ARBITER: // 52991
            m_caster->AddGameObject(pGameObj);
            break;
        case GAMEOBJECT_TYPE_FISHINGHOLE:
        case GAMEOBJECT_TYPE_CHEST:
        default:
            break;
    }
 
    pGameObj->SetRespawnTime(duration > 0 ? duration / IN_MILLISECONDS : 0);
 
    pGameObj->SetOwnerGUID(m_caster->GetGUID());
 
    //pGameObj->SetUInt32Value(GAMEOBJECT_LEVEL, m_caster->GetLevel());
    pGameObj->SetSpellId(m_spellInfo->Id);
 
    ExecuteLogEffectSummonObject(effIndex, pGameObj);
 
    LOG_DEBUG("spells.effect", "AddObject at SpellEfects.cpp EffectTransmitted");
    //m_caster->AddGameObject(pGameObj);
    //m_ObjToDel.push_back(pGameObj);
 
    cMap->AddToMap(pGameObj, true);
 
    if (GameObject* linkedTrap = pGameObj->GetLinkedTrap())
    {
        linkedTrap->SetRespawnTime(duration > 0 ? duration / IN_MILLISECONDS : 0);
        linkedTrap->SetSpellId(m_spellInfo->Id);
        linkedTrap->SetOwnerGUID(m_caster->GetGUID());
 
        ExecuteLogEffectSummonObject(effIndex, linkedTrap);
    }
 
    if (Player* player = m_caster->ToPlayer())
    {
        player->SetCanTeleport(true);
    }
}

References Unit::AddGameObject(), Map::AddToMap(), GameObject::AddUniqueUse(), GameObject::Create(), DEFAULT_WORLD_OBJECT_SIZE, destTarget, effectHandleMode, SpellInfo::Effects, ExecuteLogEffectSummonObject(), FISHING_BOBBER_READY_TIME, GameObject, GAMEOBJECT_TYPE_CHEST, GAMEOBJECT_TYPE_DUEL_ARBITER, GAMEOBJECT_TYPE_FISHINGHOLE, GAMEOBJECT_TYPE_FISHINGNODE, GAMEOBJECT_TYPE_SUMMONING_RITUAL, Map::GenerateLowGuid(), WorldObject::GetClosePoint(), SpellInfo::GetDuration(), Object::GetGUID(), GameObject::GetLinkedTrap(), WorldObject::GetMap(), SpellInfo::GetMaxRange(), SpellInfo::GetMinRange(), Position::GetOrientation(), WorldObject::GetPhaseMask(), Position::GetPosition(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), GO_STATE_READY, SpellCastTargets::HasDst(), SpellInfo::Id, IN_MILLISECONDS, Object::IsPlayer(), LOG_DEBUG, LOG_ERROR, m_caster, m_originalCaster, m_spellInfo, m_targets, rand_norm(), Object::SetGuidValue(), GameObject::SetOwnerGUID(), GameObject::SetRespawnTime(), GameObject::SetSpellId(), sObjectMgr, SpellInfo::Speed, SPELL_EFFECT_HANDLE_HIT, Object::ToPlayer(), GameObjectTemplate::type, UNIT_FIELD_CHANNEL_OBJECT, and urand().

◆ EffectTriggerMissileSpell()

void Spell::EffectTriggerMissileSpell ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET
            && effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
        return;
 
    uint32 triggered_spell_id = m_spellInfo->Effects[effIndex].TriggerSpell;
 
    // normal case
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(triggered_spell_id);
    if (!spellInfo)
    {
        LOG_DEBUG("spells.aura", "Spell::EffectTriggerMissileSpell spell {} tried to trigger unknown spell {}", m_spellInfo->Id, triggered_spell_id);
        return;
    }
 
    SpellCastTargets targets;
    if (effectHandleMode == SPELL_EFFECT_HANDLE_HIT_TARGET)
    {
        if (!spellInfo->NeedsToBeTriggeredByCaster(m_spellInfo, effIndex))
            return;
        targets.SetUnitTarget(unitTarget);
    }
    else //if (effectHandleMode == SPELL_EFFECT_HANDLE_HIT)
    {
        if (spellInfo->NeedsToBeTriggeredByCaster(m_spellInfo, effIndex) && (m_spellInfo->Effects[effIndex].GetProvidedTargetMask() & TARGET_FLAG_UNIT_MASK))
            return;
 
        if (spellInfo->GetExplicitTargetMask() & TARGET_FLAG_DEST_LOCATION)
            targets.SetDst(m_targets);
 
        targets.SetUnitTarget(m_caster);
    }
 
    CustomSpellValues values;
    // set basepoints for trigger with value effect
    if (m_spellInfo->Effects[effIndex].Effect == SPELL_EFFECT_TRIGGER_MISSILE_SPELL_WITH_VALUE)
    {
        // maybe need to set value only when basepoints == 0?
        values.AddSpellMod(SPELLVALUE_BASE_POINT0, damage);
        values.AddSpellMod(SPELLVALUE_BASE_POINT1, damage);
        values.AddSpellMod(SPELLVALUE_BASE_POINT2, damage);
    }
 
    // Remove spell cooldown (not category) if spell triggering spell with cooldown and same category
    if (m_caster->IsPlayer() && spellInfo->CategoryRecoveryTime && m_spellInfo->GetCategory() == spellInfo->GetCategory())
    {
        m_caster->ToPlayer()->RemoveSpellCooldown(spellInfo->Id);
    }
 
    // original caster guid only for GO cast
    m_caster->CastSpell(targets, spellInfo, &values, TRIGGERED_FULL_MASK, nullptr, nullptr, m_originalCasterGUID);
}

References CustomSpellValues::AddSpellMod(), Unit::CastSpell(), SpellInfo::CategoryRecoveryTime, damage, effectHandleMode, SpellInfo::Effects, SpellInfo::GetCategory(), SpellInfo::GetExplicitTargetMask(), SpellInfo::Id, Object::IsPlayer(), LOG_DEBUG, m_caster, m_originalCasterGUID, m_spellInfo, m_targets, SpellInfo::NeedsToBeTriggeredByCaster(), Player::RemoveSpellCooldown(), SpellCastTargets::SetDst(), SpellCastTargets::SetUnitTarget(), SPELL_EFFECT_HANDLE_HIT, SPELL_EFFECT_HANDLE_HIT_TARGET, SPELL_EFFECT_TRIGGER_MISSILE_SPELL_WITH_VALUE, SPELLVALUE_BASE_POINT0, SPELLVALUE_BASE_POINT1, SPELLVALUE_BASE_POINT2, sSpellMgr, TARGET_FLAG_DEST_LOCATION, TARGET_FLAG_UNIT_MASK, Object::ToPlayer(), TRIGGERED_FULL_MASK, and unitTarget.

◆ EffectTriggerRitualOfSummoning()

void Spell::EffectTriggerRitualOfSummoning ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
        return;
 
    uint32 triggered_spell_id = m_spellInfo->Effects[effIndex].TriggerSpell;
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(triggered_spell_id);
 
    if (!spellInfo)
    {
        LOG_ERROR("spells.effect", "EffectTriggerRitualOfSummoning of spell {}: triggering unknown spell id {}", m_spellInfo->Id, triggered_spell_id);
        return;
    }
 
    finish();
 
    m_caster->CastSpell((Unit*)nullptr, spellInfo, true);
}

References Unit::CastSpell(), effectHandleMode, SpellInfo::Effects, finish(), SpellInfo::Id, LOG_ERROR, m_caster, m_spellInfo, SPELL_EFFECT_HANDLE_HIT, and sSpellMgr.

◆ EffectTriggerSpell()

void Spell::EffectTriggerSpell ( SpellEffIndex effIndex )

Todo:: : move those to spell scripts

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET
            && effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)
        return;
 
    uint32 triggered_spell_id = m_spellInfo->Effects[effIndex].TriggerSpell;
 
    if (m_spellInfo->Effects[effIndex].Effect == SPELL_EFFECT_TRIGGER_SPELL
            && effectHandleMode == SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
    {
        // special cases
        switch (triggered_spell_id)
        {
            // Mirror Image
            case 58832:
                {
                    // Glyph of Mirror Image
                    if (m_caster->HasAura(63093))
                        m_caster->CastSpell(m_caster, 65047, true); // Mirror Image
 
                    break;
                }
            // Demonic Empowerment -- succubus
            case 54437:
                {
                    unitTarget->RemoveMovementImpairingAuras(true);
                    unitTarget->RemoveAurasByType(SPELL_AURA_MOD_STALKED);
                    unitTarget->RemoveAurasByType(SPELL_AURA_MOD_STUN);
 
                    // Cast Lesser Invisibility
                    unitTarget->CastSpell(unitTarget, 7870, true);
                    return;
                }
            // just skip
            case 23770:                                         // Sayge's Dark Fortune of *
                // not exist, common cooldown can be implemented in scripts if need.
                return;
            // Brittle Armor - (need add max stack of 24575 Brittle Armor)
            case 29284:
                {
                    // Brittle Armor
                    SpellInfo const* spell = sSpellMgr->GetSpellInfo(24575);
                    if (!spell)
                        return;
 
                    for (uint32 j = 0; j < spell->StackAmount; ++j)
                        m_caster->CastSpell(unitTarget, spell->Id, true);
                    return;
                }
            // Mercurial Shield - (need add max stack of 26464 Mercurial Shield)
            case 29286:
                {
                    // Mercurial Shield
                    SpellInfo const* spell = sSpellMgr->GetSpellInfo(26464);
                    if (!spell)
                        return;
 
                    for (uint32 j = 0; j < spell->StackAmount; ++j)
                        m_caster->CastSpell(unitTarget, spell->Id, true);
                    return;
                }
            // Cloak of Shadows
            case 35729:
                {
                    uint32 dispelMask = SpellInfo::GetDispelMask(DISPEL_ALL);
                    Unit::AuraApplicationMap& Auras = unitTarget->GetAppliedAuras();
                    for (Unit::AuraApplicationMap::iterator iter = Auras.begin(); iter != Auras.end();)
                    {
                        // remove all harmful spells on you...
                        SpellInfo const* spell = iter->second->GetBase()->GetSpellInfo();
 
                        // Pounce Bleed shouldn't be removed by Cloak of Shadows.
                        if (spell->GetAllEffectsMechanicMask() & (1ULL << MECHANIC_BLEED))
                            return;
 
                        bool dmgClassNone = false;
                        if (spell->DmgClass == SPELL_DAMAGE_CLASS_NONE && spell->SpellFamilyName == SPELLFAMILY_GENERIC)
                            for (uint8 i = EFFECT_0; i < MAX_SPELL_EFFECTS; ++i)
                            {
                                if ((iter->second->GetEffectMask() & (1 << i)) &&
                                        spell->Effects[i].ApplyAuraName != SPELL_AURA_PERIODIC_DAMAGE &&
                                        spell->Effects[i].ApplyAuraName != SPELL_AURA_PERIODIC_TRIGGER_SPELL &&
                                        spell->Effects[i].ApplyAuraName != SPELL_AURA_DUMMY)
                                {
                                    dmgClassNone = false;
                                    break;
                                }
                                dmgClassNone = true;
                            }
 
                        if ((spell->DmgClass == SPELL_DAMAGE_CLASS_MAGIC || (spell->GetDispelMask() & dispelMask) || dmgClassNone) &&
                                // ignore positive and passive auras
                                !iter->second->IsPositive() && !iter->second->GetBase()->IsPassive() &&
                                // Xinef: Ignore NPC spells having INVULNERABILITY attribute
                                (!spell->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES) || spell->SpellFamilyName != SPELLFAMILY_GENERIC))
                        {
                            m_caster->RemoveAura(iter);
                        }
                        else
                            ++iter;
                    }
                    return;
                }
        }
    }
 
    // normal case
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(triggered_spell_id);
    if (!spellInfo)
    {
        LOG_DEBUG("spells.aura", "Spell::EffectTriggerSpell spell {} tried to trigger unknown spell {}", m_spellInfo->Id, triggered_spell_id);
        return;
    }
 
    SpellCastTargets targets;
    if (effectHandleMode == SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
    {
        if (!spellInfo->NeedsToBeTriggeredByCaster(m_spellInfo, effIndex))
            return;
        targets.SetUnitTarget(unitTarget);
    }
    else //if (effectHandleMode == SPELL_EFFECT_HANDLE_LAUNCH)
    {
        if (spellInfo->NeedsToBeTriggeredByCaster(m_spellInfo, effIndex) && (m_spellInfo->Effects[effIndex].GetProvidedTargetMask() & TARGET_FLAG_UNIT_MASK))
            return;
 
        if (spellInfo->GetExplicitTargetMask() & TARGET_FLAG_DEST_LOCATION)
            targets.SetDst(m_targets);
 
        if (Unit* target = m_targets.GetUnitTarget())
            targets.SetUnitTarget(target);
        else
            targets.SetUnitTarget(m_caster);
    }
 
    CustomSpellValues values;
    // set basepoints for trigger with value effect
    if (m_spellInfo->Effects[effIndex].Effect == SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE)
    {
        // maybe need to set value only when basepoints == 0?
        values.AddSpellMod(SPELLVALUE_BASE_POINT0, damage);
        values.AddSpellMod(SPELLVALUE_BASE_POINT1, damage);
        values.AddSpellMod(SPELLVALUE_BASE_POINT2, damage);
    }
 
    // Remove spell cooldown (not category) if spell triggering spell with cooldown and same category
    if (m_caster->IsPlayer() && spellInfo->CategoryRecoveryTime && m_spellInfo->GetCategory() == spellInfo->GetCategory())
    {
        m_caster->ToPlayer()->RemoveSpellCooldown(spellInfo->Id);
    }
 
    // original caster guid only for GO cast
    m_caster->CastSpell(targets, spellInfo, &values, TriggerCastFlags(TRIGGERED_FULL_MASK & ~TRIGGERED_NO_PERIODIC_RESET), nullptr, nullptr, m_originalCasterGUID);
}

References CustomSpellValues::AddSpellMod(), Unit::CastSpell(), SpellInfo::CategoryRecoveryTime, damage, DISPEL_ALL, SpellInfo::DmgClass, EFFECT_0, effectHandleMode, SpellInfo::Effects, SpellInfo::GetAllEffectsMechanicMask(), Unit::GetAppliedAuras(), SpellInfo::GetCategory(), SpellInfo::GetDispelMask(), SpellInfo::GetExplicitTargetMask(), SpellCastTargets::GetUnitTarget(), SpellInfo::HasAttribute(), Unit::HasAura(), SpellInfo::Id, Object::IsPlayer(), LOG_DEBUG, m_caster, m_originalCasterGUID, m_spellInfo, m_targets, MAX_SPELL_EFFECTS, MECHANIC_BLEED, SpellInfo::NeedsToBeTriggeredByCaster(), Unit::RemoveAura(), Unit::RemoveAurasByType(), Unit::RemoveMovementImpairingAuras(), Player::RemoveSpellCooldown(), SpellCastTargets::SetDst(), SpellCastTargets::SetUnitTarget(), SPELL_ATTR0_NO_IMMUNITIES, SPELL_AURA_DUMMY, SPELL_AURA_MOD_STALKED, SPELL_AURA_MOD_STUN, SPELL_AURA_PERIODIC_DAMAGE, SPELL_AURA_PERIODIC_TRIGGER_SPELL, SPELL_DAMAGE_CLASS_MAGIC, SPELL_DAMAGE_CLASS_NONE, SPELL_EFFECT_HANDLE_LAUNCH, SPELL_EFFECT_HANDLE_LAUNCH_TARGET, SPELL_EFFECT_TRIGGER_SPELL, SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE, SPELLFAMILY_GENERIC, SpellInfo::SpellFamilyName, SPELLVALUE_BASE_POINT0, SPELLVALUE_BASE_POINT1, SPELLVALUE_BASE_POINT2, sSpellMgr, SpellInfo::StackAmount, TARGET_FLAG_DEST_LOCATION, TARGET_FLAG_UNIT_MASK, Object::ToPlayer(), TRIGGERED_FULL_MASK, TRIGGERED_NO_PERIODIC_RESET, and unitTarget.

◆ EffectUnlearnSpecialization()

void Spell::EffectUnlearnSpecialization ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget)
        return;
 
    Player* player = unitTarget->ToPlayer();
    if (!player)
    {
        return;
    }
 
    uint32 spellToUnlearn = m_spellInfo->Effects[effIndex].TriggerSpell;
 
    player->removeSpell(spellToUnlearn, SPEC_MASK_ALL, false);
    LOG_DEBUG("spells.aura", "Spell: Player {} has unlearned spell {} from Npc: {}",
        player->GetGUID().ToString(), spellToUnlearn, m_caster->GetGUID().ToString());
}

References effectHandleMode, SpellInfo::Effects, Object::GetGUID(), LOG_DEBUG, m_caster, m_spellInfo, Player::removeSpell(), SPEC_MASK_ALL, SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), ObjectGuid::ToString(), and unitTarget.

◆ EffectUntrainTalents()

void Spell::EffectUntrainTalents ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
        return;
 
    if (!unitTarget || m_caster->IsPlayer())
        return;
 
    if (ObjectGuid guid = m_caster->GetGUID()) // the trainer is the caster
        unitTarget->ToPlayer()->SendTalentWipeConfirm(guid);
}

References effectHandleMode, Object::GetGUID(), Object::IsPlayer(), m_caster, Player::SendTalentWipeConfirm(), SPELL_EFFECT_HANDLE_HIT_TARGET, Object::ToPlayer(), and unitTarget.

◆ EffectUnused()

void Spell::EffectUnused ( SpellEffIndex effIndex )

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

◆ EffectWeaponDmg()

void Spell::EffectWeaponDmg ( SpellEffIndex effIndex )

{
    if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
        return;
 
    if (!unitTarget || !unitTarget->IsAlive())
        return;
 
    // multiple weapon dmg effect workaround
    // execute only the last weapon damage
    // and handle all effects at once
    for (uint32 j = effIndex + 1; j < MAX_SPELL_EFFECTS; ++j)
    {
        switch (m_spellInfo->Effects[j].Effect)
        {
            case SPELL_EFFECT_WEAPON_DAMAGE:
            case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
            case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:
            case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:
                return;     // we must calculate only at last weapon effect
                break;
        }
    }
 
    // some spell specific modifiers
    float totalDamagePercentMod  = 100.0f;                  // applied to final bonus+weapon damage
    int32 spell_bonus = 0;                                  // bonus specific for spell
    bool normalized = false;
 
    switch (m_spellInfo->SpellFamilyName)
    {
        case SPELLFAMILY_GENERIC:
            {
                switch (m_spellInfo->Id)
                {
                    // Trial of the Champion, Black Knight, Obliterate
                    case 67725:
                    case 67883:
                        {
                            AddPct(totalDamagePercentMod, unitTarget->GetDiseasesByCaster(m_caster->GetGUID(), 1) * 30.0f);
                            break;
                        }
                }
                break;
            }
        case SPELLFAMILY_WARRIOR:
            {
                // Devastate (player ones)
                if (m_spellInfo->SpellFamilyFlags[1] & 0x40)
                {
                    m_caster->CastSpell(unitTarget, 58567, true);
 
                    if (Aura* aur = unitTarget->GetAura(58567))
                    {
                        // 58388 - Glyph of Devastate dummy aura.
                        if (m_caster->HasAura(58388))
                            aur->ModStackAmount(1);
 
                        spell_bonus += (aur->GetStackAmount() - 1) * CalculateSpellDamage(2, unitTarget);
                    }
                }
                break;
            }
        case SPELLFAMILY_ROGUE:
            {
                // Fan of Knives, Hemorrhage, Ghostly Strike
                if ((m_spellInfo->SpellFamilyFlags[1] & 0x40000)
                        || (m_spellInfo->SpellFamilyFlags[0] & 0x6000000))
                {
                    // Hemorrhage
                    if (m_spellInfo->SpellFamilyFlags[0] & 0x2000000)
                    {
                        AddComboPointGain(unitTarget, 1);
                    }
                    // 50% more damage with daggers
                    if (m_caster->IsPlayer())
                        if (Item* item = m_caster->ToPlayer()->GetWeaponForAttack(m_attackType, true))
                            if (item->GetTemplate()->SubClass == ITEM_SUBCLASS_WEAPON_DAGGER)
                                AddPct(totalDamagePercentMod, 50.0f);
                }
                // Mutilate (for each hand)
                else if (m_spellInfo->SpellFamilyFlags[1] & 0x6)
                {
                    bool found = false;
                    // fast check
                    if (unitTarget->HasAuraState(AURA_STATE_DEADLY_POISON, m_spellInfo, m_caster))
                        found = true;
                    // full aura scan
                    else
                    {
                        Unit::AuraApplicationMap const& auras = unitTarget->GetAppliedAuras();
                        for (Unit::AuraApplicationMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
                        {
                            if (itr->second->GetBase()->GetSpellInfo()->Dispel == DISPEL_POISON)
                            {
                                found = true;
                                break;
                            }
                        }
                    }
 
                    if (found)
                        AddPct(totalDamagePercentMod, 20.0f);          // 120% if poisoned
                }
                break;
            }
        case SPELLFAMILY_PALADIN:
            {
                switch (m_spellInfo->Id)
                {
                    case 20467: // Seal of Command Unleashed
                        spell_bonus += int32(0.08f * m_caster->GetTotalAttackPowerValue(BASE_ATTACK));
                        spell_bonus += int32(0.13f * m_caster->SpellBaseDamageBonusDone(m_spellInfo->GetSchoolMask()));
                        break;
                    case 53385:  // Divine Storm deals normalized damage
                        normalized = true;
                        break;
                    default:
                        break;
                }
                break;
            }
        case SPELLFAMILY_SHAMAN:
            {
                // Skyshatter Harness item set bonus
                // Stormstrike
                if (AuraEffect* aurEff = m_caster->IsScriptOverriden(m_spellInfo, 5634))
                    m_caster->CastSpell(m_caster, 38430, true, nullptr, aurEff);
                // Lava lash damage increased by Flametongue weapon
                if (m_caster->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_SHAMAN, 688, EFFECT_0))
                    AddPct(totalDamagePercentMod, 25.0f);
                break;
            }
        case SPELLFAMILY_DRUID:
            {
                // Mangle (Cat): CP
                if (m_spellInfo->SpellFamilyFlags[1] & 0x400)
                {
                    AddComboPointGain(unitTarget, 1);
                }
                // Shred, Maul - Rend and Tear
                else if (m_spellInfo->SpellFamilyFlags[0] & 0x00008800 && unitTarget->HasAuraState(AURA_STATE_BLEEDING))
                {
                    if (AuraEffect const* rendAndTear = m_caster->GetDummyAuraEffect(SPELLFAMILY_DRUID, 2859, 0))
                        AddPct(totalDamagePercentMod, rendAndTear->GetAmount());
                }
                break;
            }
        case SPELLFAMILY_HUNTER:
            {
                // Kill Shot
                if (m_spellInfo->SpellFamilyFlags[1] & 0x800000)
                {
                    spell_bonus += int32(m_caster->GetTotalAttackPowerValue(RANGED_ATTACK) * 0.4f);
                }
                break;
            }
        case SPELLFAMILY_DEATHKNIGHT:
            {
                // Plague Strike
                if (m_spellInfo->SpellFamilyFlags[0] & 0x1)
                {
                    // Glyph of Plague Strike
                    if (AuraEffect const* aurEff = m_caster->GetAuraEffect(58657, EFFECT_0))
                        AddPct(totalDamagePercentMod, aurEff->GetAmount());
                    break;
                }
                // Blood Strike
                if (m_spellInfo->SpellFamilyFlags[0] & 0x400000)
                {
                    float disease_amt = m_spellInfo->Effects[EFFECT_2].CalcValue();
                    //Death Knight T8 Melee 4P Bonus
                    if (AuraEffect* aurEff = m_caster->GetAuraEffectDummy(64736))
                        AddPct(disease_amt, aurEff->GetAmount());
 
                    AddPct(totalDamagePercentMod, disease_amt * unitTarget->GetDiseasesByCaster(m_caster->GetGUID()) / 2.0f);
 
                    // Glyph of Blood Strike
                    if (m_caster->GetAuraEffect(59332, EFFECT_0))
                        if (unitTarget->HasDecreaseSpeedAura())
                            AddPct(totalDamagePercentMod, 20.0f);
                    break;
                }
                // Death Strike
                if (m_spellInfo->SpellFamilyFlags[0] & 0x10)
                {
                    // Glyph of Death Strike
                    if (AuraEffect const* aurEff = m_caster->GetAuraEffect(59336, EFFECT_0))
                        if (uint32 runic = std::min<uint32>(m_caster->GetPower(POWER_RUNIC_POWER), aurEff->GetSpellInfo()->Effects[EFFECT_1].CalcValue()))
                            AddPct(totalDamagePercentMod, runic);
                    break;
                }
                // Obliterate (12.5% more damage per disease)
                if (m_spellInfo->SpellFamilyFlags[1] & 0x20000)
                {
                    bool consumeDiseases = true;
                    // Annihilation
                    if (AuraEffect const* aurEff = m_caster->GetDummyAuraEffect(SPELLFAMILY_DEATHKNIGHT, 2710, EFFECT_0))
                        // Do not consume diseases if roll sucesses
                        if (roll_chance_i(aurEff->GetAmount()))
                            consumeDiseases = false;
 
                    float disease_amt = m_spellInfo->Effects[EFFECT_2].CalcValue();
                    //Death Knight T8 Melee 4P Bonus
                    if (AuraEffect* aurEff = m_caster->GetAuraEffectDummy(64736))
                        AddPct(disease_amt, aurEff->GetAmount());
 
                    AddPct(totalDamagePercentMod, disease_amt * unitTarget->GetDiseasesByCaster(m_caster->GetGUID(), consumeDiseases) / 2.0f);
                    break;
                }
                // Blood-Caked Strike - Blood-Caked Blade
                if (m_spellInfo->SpellIconID == 1736)
                {
                    AddPct(totalDamagePercentMod, unitTarget->GetDiseasesByCaster(m_caster->GetGUID()) * 50.0f);
                    break;
                }
                // Heart Strike
                if (m_spellInfo->SpellFamilyFlags[0] & 0x1000000)
                {
                    float disease_amt = m_spellInfo->Effects[EFFECT_2].CalcValue();
                    //Death Knight T8 Melee 4P Bonus
                    if (AuraEffect* aurEff = m_caster->GetAuraEffectDummy(64736))
                        AddPct(disease_amt, aurEff->GetAmount());
 
                    AddPct(totalDamagePercentMod, disease_amt * unitTarget->GetDiseasesByCaster(m_caster->GetGUID()));
                    break;
                }
                // Rune Strike
                if (m_spellInfo->SpellFamilyFlags[1] & 0x20000000)
                {
                    spell_bonus += int32(0.15f * m_caster->GetTotalAttackPowerValue(BASE_ATTACK));
                }
 
                break;
            }
    }
 
    float weaponDamagePercentMod = 100.0f;
    int32 fixed_bonus = 0;
 
    for (int j = 0; j < MAX_SPELL_EFFECTS; ++j)
    {
        switch (m_spellInfo->Effects[j].Effect)
        {
            case SPELL_EFFECT_WEAPON_DAMAGE:
            case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
                fixed_bonus += CalculateSpellDamage(j, unitTarget);
                break;
            case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:
                fixed_bonus += CalculateSpellDamage(j, unitTarget);
                normalized = true;
                break;
            case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:
                ApplyPct(weaponDamagePercentMod, CalculateSpellDamage(j, unitTarget));
                break;
            default:
                break;                                      // not weapon damage effect, just skip
        }
    }
 
    bool const isPhysical = (m_spellSchoolMask & SPELL_SCHOOL_MASK_NORMAL);
    if (isPhysical && (fixed_bonus || spell_bonus))
    {
        UnitMods unitMod;
        switch (m_attackType)
        {
        default:
        case BASE_ATTACK:
            unitMod = UNIT_MOD_DAMAGE_MAINHAND;
            break;
        case OFF_ATTACK:
            unitMod = UNIT_MOD_DAMAGE_OFFHAND;
            break;
        case RANGED_ATTACK:
            unitMod = UNIT_MOD_DAMAGE_RANGED;
            break;
        }
        float weapon_total_pct = m_caster->GetPctModifierValue(unitMod, TOTAL_PCT);
        fixed_bonus = int32(fixed_bonus * weapon_total_pct);
        spell_bonus = int32(spell_bonus * weapon_total_pct);
    }
 
    int32 weaponDamage = 0;
    // Dancing Rune Weapon
    if (m_caster->GetEntry() == 27893)
    {
        if (Unit* owner = m_caster->GetOwner())
            weaponDamage = owner->CalculateDamage(m_attackType, normalized, isPhysical);
    }
    else
    {
        weaponDamage = m_caster->CalculateDamage(m_attackType, normalized, isPhysical);
    }
 
    // Sequence is important
    for (int j = 0; j < MAX_SPELL_EFFECTS; ++j)
    {
        // We assume that a spell have at most one fixed_bonus
        // and at most one weaponDamagePercentMod
        switch (m_spellInfo->Effects[j].Effect)
        {
            case SPELL_EFFECT_WEAPON_DAMAGE:
            case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
            case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:
                weaponDamage += fixed_bonus;
                break;
            case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:
                ApplyPct(weaponDamage, weaponDamagePercentMod);
            default:
                break;                                      // not weapon damage effect, just skip
        }
    }
 
    weaponDamage += spell_bonus;
    ApplyPct(weaponDamage, totalDamagePercentMod);
 
    // prevent negative damage
    uint32 eff_damage(std::max(weaponDamage, 0));
 
    // Add melee damage bonuses (also check for negative)
    eff_damage = m_caster->MeleeDamageBonusDone(unitTarget, eff_damage, m_attackType, m_spellInfo, m_spellSchoolMask);
    eff_damage = unitTarget->MeleeDamageBonusTaken(m_caster, eff_damage, m_attackType, m_spellInfo, m_spellSchoolMask);
 
    // Meteor like spells (divided damage to targets)
    if (m_spellInfo->HasAttribute(SPELL_ATTR0_CU_SHARE_DAMAGE))
    {
        uint32 count = 0;
        for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
            if (ihit->effectMask & (1 << effIndex))
                ++count;
 
        eff_damage /= count;                    // divide to all targets
    }
 
    m_damage += eff_damage;
}

References AddComboPointGain(), AddPct(), ApplyPct(), AURA_STATE_BLEEDING, AURA_STATE_DEADLY_POISON, BASE_ATTACK, Unit::CalculateDamage(), CalculateSpellDamage(), Unit::CastSpell(), DISPEL_POISON, EFFECT_0, EFFECT_1, EFFECT_2, effectHandleMode, SpellInfo::Effects, Unit::GetAppliedAuras(), Unit::GetAura(), Unit::GetAuraEffect(), Unit::GetAuraEffectDummy(), Unit::GetDiseasesByCaster(), Unit::GetDummyAuraEffect(), Object::GetEntry(), Object::GetGUID(), Unit::GetOwner(), Unit::GetPctModifierValue(), Unit::GetPower(), SpellInfo::GetSchoolMask(), Unit::GetTotalAttackPowerValue(), Player::GetWeaponForAttack(), SpellInfo::HasAttribute(), Unit::HasAura(), Unit::HasAuraState(), Unit::HasDecreaseSpeedAura(), SpellInfo::Id, Unit::IsAlive(), Object::IsPlayer(), Unit::IsScriptOverriden(), ITEM_SUBCLASS_WEAPON_DAGGER, m_attackType, m_caster, m_damage, m_spellInfo, m_spellSchoolMask, m_UniqueTargetInfo, MAX_SPELL_EFFECTS, Unit::MeleeDamageBonusDone(), Unit::MeleeDamageBonusTaken(), OFF_ATTACK, POWER_RUNIC_POWER, RANGED_ATTACK, roll_chance_i(), SPELL_ATTR0_CU_SHARE_DAMAGE, SPELL_AURA_DUMMY, SPELL_EFFECT_HANDLE_LAUNCH_TARGET, SPELL_EFFECT_NORMALIZED_WEAPON_DMG, SPELL_EFFECT_WEAPON_DAMAGE, SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL, SPELL_EFFECT_WEAPON_PERCENT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, Unit::SpellBaseDamageBonusDone(), SPELLFAMILY_DEATHKNIGHT, SPELLFAMILY_DRUID, SPELLFAMILY_GENERIC, SPELLFAMILY_HUNTER, SPELLFAMILY_PALADIN, SPELLFAMILY_ROGUE, SPELLFAMILY_SHAMAN, SPELLFAMILY_WARRIOR, SpellInfo::SpellFamilyFlags, SpellInfo::SpellFamilyName, SpellInfo::SpellIconID, Object::ToPlayer(), TOTAL_PCT, UNIT_MOD_DAMAGE_MAINHAND, UNIT_MOD_DAMAGE_OFFHAND, UNIT_MOD_DAMAGE_RANGED, and unitTarget.

◆ ExecuteLogEffectCreateItem()

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

{
    InitEffectExecuteData(effIndex);
    *m_effectExecuteData[effIndex] << uint32(entry);
}

References InitEffectExecuteData(), and m_effectExecuteData.

Referenced by EffectCreateItem().

◆ ExecuteLogEffectDestroyItem()

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

{
    InitEffectExecuteData(effIndex);
    *m_effectExecuteData[effIndex] << uint32(entry);
}

References InitEffectExecuteData(), and m_effectExecuteData.

Referenced by EffectFeedPet().

◆ ExecuteLogEffectDurabilityDamage()

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

{
    InitEffectExecuteData(effIndex);
    *m_effectExecuteData[effIndex] << victim->GetPackGUID();
    *m_effectExecuteData[effIndex] << int32(itemId);
    *m_effectExecuteData[effIndex] << int32(slot);
}

References Object::GetPackGUID(), InitEffectExecuteData(), and m_effectExecuteData.

Referenced by EffectDurabilityDamage().

◆ ExecuteLogEffectExtraAttacks()

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

{
    InitEffectExecuteData(effIndex);
    *m_effectExecuteData[effIndex] << victim->GetPackGUID();
    *m_effectExecuteData[effIndex] << uint32(attCount);
}

References Object::GetPackGUID(), InitEffectExecuteData(), and m_effectExecuteData.

Referenced by EffectAddExtraAttacks().

◆ ExecuteLogEffectInterruptCast()

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

{
    InitEffectExecuteData(effIndex);
    *m_effectExecuteData[effIndex] << victim->GetPackGUID();
    *m_effectExecuteData[effIndex] << uint32(spellId);
}

References Object::GetPackGUID(), InitEffectExecuteData(), and m_effectExecuteData.

Referenced by EffectInterruptCast().

◆ ExecuteLogEffectOpenLock()

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

{
    InitEffectExecuteData(effIndex);
    *m_effectExecuteData[effIndex] << obj->GetPackGUID();
}

References Object::GetPackGUID(), InitEffectExecuteData(), and m_effectExecuteData.

Referenced by EffectOpenLock().

◆ ExecuteLogEffectResurrect()

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

{
    InitEffectExecuteData(effIndex);
    *m_effectExecuteData[effIndex] << target->GetPackGUID();
}

References Object::GetPackGUID(), InitEffectExecuteData(), and m_effectExecuteData.

Referenced by EffectResurrect(), and EffectResurrectNew().

◆ ExecuteLogEffectSummonObject()

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

{
    InitEffectExecuteData(effIndex);
    *m_effectExecuteData[effIndex] << obj->GetPackGUID();
}

References Object::GetPackGUID(), InitEffectExecuteData(), and m_effectExecuteData.

Referenced by EffectDuel(), EffectSummonObject(), EffectSummonObjectWild(), EffectSummonType(), EffectTransmitted(), spell_item_draenic_pale_ale::HandleSummon(), and SummonGuardian().

◆ ExecuteLogEffectTakeTargetPower()

void Spell::ExecuteLogEffectTakeTargetPower	(	uint8	effIndex,
		Unit *	target,
		uint32	PowerType,
		uint32	powerTaken,
		float	gainMultiplier
	)

{
    InitEffectExecuteData(effIndex);
    *m_effectExecuteData[effIndex] << target->GetPackGUID();
    *m_effectExecuteData[effIndex] << uint32(powerTaken);
    *m_effectExecuteData[effIndex] << uint32(PowerType);
    *m_effectExecuteData[effIndex] << float(gainMultiplier);
}

References Object::GetPackGUID(), InitEffectExecuteData(), and m_effectExecuteData.

Referenced by EffectPowerBurn(), EffectPowerDrain(), and spell_mage_burnout_trigger::HandleDummy().

◆ ExecuteLogEffectUnsummonObject()

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

{
    InitEffectExecuteData(effIndex);
    *m_effectExecuteData[effIndex] << obj->GetPackGUID();
}

References Object::GetPackGUID(), InitEffectExecuteData(), and m_effectExecuteData.

Referenced by EffectDismissPet().

◆ finish()

void Spell::finish ( bool ok = true )

{
    if (!m_caster)
        return;
 
    if (m_spellState == SPELL_STATE_FINISHED)
        return;
    m_spellState = SPELL_STATE_FINISHED;
 
    if (m_spellInfo->IsChanneled())
        m_caster->UpdateInterruptMask();
 
    if (m_caster->HasUnitState(UNIT_STATE_CASTING) && !m_caster->IsNonMeleeSpellCast(false, false, true))
        m_caster->ClearUnitState(UNIT_STATE_CASTING);
 
    // Unsummon summon as possessed creatures on spell cancel
    if (m_spellInfo->IsChanneled() && m_caster->IsPlayer())
    {
        if (Unit* charm = m_caster->GetCharm())
            if (charm->IsCreature()
                    && charm->ToCreature()->HasUnitTypeMask(UNIT_MASK_PUPPET)
                    && charm->GetUInt32Value(UNIT_CREATED_BY_SPELL) == m_spellInfo->Id)
                ((Puppet*)charm)->UnSummon();
    }
 
    if (Creature* creatureCaster = m_caster->ToCreature())
        creatureCaster->ReleaseFocus(this);
 
    if (ok)
    {
        if (m_caster->IsPlayer() && m_spellInfo->IsChanneled() && m_spellInfo->IsCooldownStartedOnEvent())
            m_caster->ToPlayer()->RemoveSpellCooldown(m_spellInfo->Id, true);
    }
    else
    {
        if (m_caster->IsPlayer())
        {
            // Xinef: Restore spell mods in case of fail cast
            m_caster->ToPlayer()->RestoreSpellMods(this);
 
            // Xinef: Reset cooldown event in case of fail cast
            if (m_spellInfo->IsCooldownStartedOnEvent())
                m_caster->ToPlayer()->SendCooldownEvent(m_spellInfo, 0, 0, false);
        }
 
        return;
    }
 
    // pussywizard:
    if (m_spellInfo->HasAttribute(SPELL_ATTR0_CU_ENCOUNTER_REWARD) && m_caster->FindMap())
        m_caster->FindMap()->UpdateEncounterState(ENCOUNTER_CREDIT_CAST_SPELL, m_spellInfo->Id, m_caster);
 
    if (m_caster->IsCreature() && m_caster->ToCreature()->IsSummon())
    {
        // Unsummon statue
        uint32 spell = m_caster->GetUInt32Value(UNIT_CREATED_BY_SPELL);
        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell);
        if (spellInfo && spellInfo->SpellIconID == 2056)
        {
            LOG_DEBUG("spells.aura", "Statue {} is unsummoned in spell {} finish", m_caster->GetGUID().ToString(), m_spellInfo->Id);
            m_caster->setDeathState(DeathState::JustDied);
            return;
        }
    }
 
    // potions disabled by client, send event "not in combat" if need
    if (m_caster->IsPlayer() && !m_triggeredByAuraSpell)
        m_caster->ToPlayer()->UpdatePotionCooldown(this);
 
    // Take mods after trigger spell (needed for 14177 to affect 48664)
    // mods are taken only on succesfull cast and independantly from targets of the spell
    if (Player* player = m_caster->GetSpellModOwner())
        player->RemoveSpellMods(this);
 
    // xinef: clear reactive auras states after spell cast
    if (m_spellInfo->CasterAuraState == AURA_STATE_DEFENSE || m_spellInfo->CasterAuraState == AURA_STATE_HUNTER_PARRY)
        m_caster->ModifyAuraState(AuraStateType(m_spellInfo->CasterAuraState), false);
 
    // Stop Attack for some spells
    if (m_spellInfo->HasAttribute(SPELL_ATTR0_CANCELS_AUTO_ATTACK_COMBAT))
        m_caster->AttackStop();
}

References Unit::AttackStop(), AURA_STATE_DEFENSE, AURA_STATE_HUNTER_PARRY, SpellInfo::CasterAuraState, Unit::ClearUnitState(), ENCOUNTER_CREDIT_CAST_SPELL, WorldObject::FindMap(), Unit::GetCharm(), Object::GetGUID(), Unit::GetSpellModOwner(), Object::GetUInt32Value(), SpellInfo::HasAttribute(), Unit::HasUnitState(), SpellInfo::Id, SpellInfo::IsChanneled(), SpellInfo::IsCooldownStartedOnEvent(), Object::IsCreature(), Unit::IsNonMeleeSpellCast(), Object::IsPlayer(), Unit::IsSummon(), JustDied, LOG_DEBUG, m_caster, m_spellInfo, m_spellState, m_triggeredByAuraSpell, Unit::ModifyAuraState(), Player::RemoveSpellCooldown(), Player::RestoreSpellMods(), Player::SendCooldownEvent(), Unit::setDeathState(), SPELL_ATTR0_CANCELS_AUTO_ATTACK_COMBAT, SPELL_ATTR0_CU_ENCOUNTER_REWARD, SPELL_STATE_FINISHED, SpellInfo::SpellIconID, sSpellMgr, Object::ToCreature(), Object::ToPlayer(), ObjectGuid::ToString(), UNIT_CREATED_BY_SPELL, UNIT_MASK_PUPPET, UNIT_STATE_CASTING, Map::UpdateEncounterState(), Unit::UpdateInterruptMask(), and Player::UpdatePotionCooldown().

Referenced by _cast(), Unit::AttackerStateUpdate(), cancel(), EffectInstaKill(), EffectTameCreature(), EffectTriggerRitualOfSummoning(), SpellScript::FinishCast(), Unit::FinishSpell(), handle_delayed(), handle_immediate(), WorldSession::HandleCastSpellOpcode(), WorldSession::HandlePetActionHelper(), WorldSession::HandlePetCastSpellOpcode(), prepare(), SelectImplicitCasterDestTargets(), SelectSpellTargets(), and update().

◆ FinishTargetProcessing()

void Spell::FinishTargetProcessing ( )

protected

{
    SendLogExecute();
}

References SendLogExecute().

Referenced by handle_delayed(), handle_immediate(), and HandleLaunchPhase().

◆ GetCaster()

Unit * Spell::GetCaster ( ) const

inline

590{ return m_caster; }

References m_caster.

Referenced by CanAutoCast(), CheckRange(), SpellEvent::Execute(), SpellScript::GetCaster(), Unit::IsImmunedToSchool(), Unit::IsImmunedToSpell(), and SpellEvent::~SpellEvent().

◆ GetCastTime()

int32 Spell::GetCastTime ( ) const

inline

562{ return m_casttime; }

References m_casttime.

Referenced by AuraEffect::CheckEffectProc(), ChaseMovementGenerator< T >::DoUpdate(), Unit::GetCurrentSpellCastTime(), Unit::InterruptSpell(), and Unit::SetCurrentCastedSpell().

◆ GetCastTimeRemaining()

int32 Spell::GetCastTimeRemaining ( )

inline

566{ return m_timer;}

References m_timer.

◆ GetCurrentContainer()

CurrentSpellTypes Spell::GetCurrentContainer ( ) const

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

References CURRENT_AUTOREPEAT_SPELL, CURRENT_CHANNELED_SPELL, CURRENT_GENERIC_SPELL, CURRENT_MELEE_SPELL, IsAutoRepeat(), SpellInfo::IsChanneled(), IsNextMeleeSwingSpell(), and m_spellInfo.

Referenced by prepare(), and Unit::SetCurrentCastedSpell().

◆ GetDebugInfo()

std::string Spell::GetDebugInfo ( ) const

protected

{
    std::stringstream sstr;
    sstr << std::boolalpha
        << "Id: " << GetSpellInfo()->Id << " OriginalCaster: " << m_originalCasterGUID.ToString()
        << " State: " << getState();
    return sstr.str();
}

References GetSpellInfo(), getState(), SpellInfo::Id, m_originalCasterGUID, and ObjectGuid::ToString().

◆ GetDelayMoment()

uint64 Spell::GetDelayMoment ( ) const

inline

581{ return m_delayMoment; }

References m_delayMoment.

Referenced by SpellEvent::Execute().

◆ GetDelayStart()

uint64 Spell::GetDelayStart ( ) const

inline

579{ return m_delayStart; }

References m_delayStart.

Referenced by SpellEvent::Execute(), and RecalculateDelayMomentForDst().

◆ GetDelayTrajectory()

uint64 Spell::GetDelayTrajectory ( ) const

inline

582{ return m_delayTrajectory; }

References m_delayTrajectory.

◆ GetOriginalCaster()

Unit * Spell::GetOriginalCaster ( ) const

inline

591{ return m_originalCaster; }

References m_originalCaster.

Referenced by DoSpellHitOnUnit(), SpellScript::GetOriginalCaster(), and SelectImplicitChannelTargets().

◆ GetOriginalTarget()

Unit * Spell::GetOriginalTarget ( ) const

{
    return ObjectAccessor::GetUnit(*m_caster, m_originalTargetGUID);
}

References ObjectAccessor::GetUnit(), m_caster, and m_originalTargetGUID.

Referenced by _handle_finish_phase().

◆ GetPowerCost()

int32 Spell::GetPowerCost ( ) const

inline

594{ return m_powerCost; }

References m_powerCost.

◆ GetSearcherTypeMask()

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

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

References GRID_MAP_TYPE_MASK_ALL, GRID_MAP_TYPE_MASK_CORPSE, GRID_MAP_TYPE_MASK_CREATURE, GRID_MAP_TYPE_MASK_GAMEOBJECT, GRID_MAP_TYPE_MASK_PLAYER, SpellInfo::HasAttribute(), m_spellInfo, sConditionMgr, SPELL_ATTR2_ALLOW_DEAD_TARGET, SPELL_ATTR3_ONLY_ON_GHOSTS, SPELL_ATTR3_ONLY_ON_PLAYER, SPELL_ATTR5_NOT_ON_PLAYER, TARGET_OBJECT_TYPE_CORPSE, TARGET_OBJECT_TYPE_CORPSE_ALLY, TARGET_OBJECT_TYPE_CORPSE_ENEMY, TARGET_OBJECT_TYPE_GOBJ, TARGET_OBJECT_TYPE_GOBJ_ITEM, TARGET_OBJECT_TYPE_UNIT, and TARGET_OBJECT_TYPE_UNIT_AND_DEST.

Referenced by SearchAreaTargets(), SearchNearbyTarget(), and SelectImplicitConeTargets().

◆ GetSpellInfo()

SpellInfo const * Spell::GetSpellInfo ( ) const

inline

◆ GetSpellSchoolMask()

SpellSchoolMask Spell::GetSpellSchoolMask ( ) const

inline

612{ return m_spellSchoolMask; }

References m_spellSchoolMask.

Referenced by Unit::IsImmunedToSchool(), and Unit::IsImmunedToSpell().

◆ GetSpellValue()

SpellValue const * Spell::GetSpellValue ( )

inline

601{ return m_spellValue; }

References m_spellValue.

Referenced by DoAllEffectOnTarget().

◆ getState()

uint32 Spell::getState ( ) const

inline

496{ return m_spellState; }

References m_spellState.

Referenced by SpellEvent::Abort(), DelayedChannel(), DoAllEffectOnTarget(), SpellEvent::Execute(), GetDebugInfo(), Unit::InterruptSpell(), Creature::IsMovementPreventedByCasting(), and SpellEvent::~SpellEvent().

◆ GetTriggeredByAuraSpellInfo()

SpellInfo const * Spell::GetTriggeredByAuraSpellInfo ( ) const

inline

608{ return m_triggeredByAuraSpell.spellInfo; }

References m_triggeredByAuraSpell, and TriggeredByAuraSpellData::spellInfo.

◆ GetTriggeredByAuraTickNumber()

uint32 Spell::GetTriggeredByAuraTickNumber ( ) const

inline

607{ return m_triggeredByAuraSpell.tickNumber; }

TriggeredByAuraSpellData::tickNumber

uint32 tickNumber

Definition Spell.h:294

References m_triggeredByAuraSpell, and TriggeredByAuraSpellData::tickNumber.

◆ GetTriggeredCastFlags()

TriggerCastFlags Spell::GetTriggeredCastFlags ( ) const

inline

610{ return _triggeredCastFlags; }

References _triggeredCastFlags.

◆ GetUniqueTargetInfo()

std::list< TargetInfo > * Spell::GetUniqueTargetInfo ( )

inline

605{ return &m_UniqueTargetInfo; }

References m_UniqueTargetInfo.

Referenced by spell_ruby_sanctum_rallying_shout::CountAllies(), spell_illidari_council_empyreal_balance::HandleAfterCast(), spell_illidari_council_empyreal_equivalency::HandleAfterCast(), spell_dk_chains_of_ice::HandleAfterCast(), spell_pet_gen_valkyr_guardian_smite::RecalculateDamage(), and spell_dk_rune_of_the_fallen_crusader::RecalculateDamage().

◆ handle_delayed()

uint64 Spell::handle_delayed ( uint64 t_offset )

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

References _handle_finish_phase(), _handle_immediate_phase(), DoAllEffectOnTarget(), finish(), FinishTargetProcessing(), Unit::GetSpellModOwner(), SpellCastTargets::HasDst(), m_caster, m_delayTrajectory, m_immediateHandled, m_targets, m_UniqueGOTargetInfo, m_UniqueTargetInfo, PrepareTargetProcessing(), Player::SetSpellModTakingSpell(), and UpdatePointers().

Referenced by SpellEvent::Execute().

◆ handle_immediate()

void Spell::handle_immediate ( )

{
    // start channeling if applicable
    if (m_spellInfo->IsChanneled())
    {
        int32 duration = m_spellInfo->GetDuration();
        if (HasTriggeredCastFlag(TRIGGERED_IGNORE_EFFECTS))
            duration = -1;
 
        if (duration > 0)
        {
            // First mod_duration then haste - see Missile Barrage
            // Apply duration mod
            if (Player* modOwner = m_caster->GetSpellModOwner())
                modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_DURATION, duration);
 
            // Apply haste mods
            if (m_caster->HasAuraTypeWithAffectMask(SPELL_AURA_PERIODIC_HASTE, m_spellInfo) || m_spellInfo->HasAttribute(SPELL_ATTR5_SPELL_HASTE_AFFECTS_PERIODIC))
                duration = int32(duration * m_caster->GetFloatValue(UNIT_MOD_CAST_SPEED));
 
            m_spellState = SPELL_STATE_CASTING;
            m_caster->AddInterruptMask(m_spellInfo->ChannelInterruptFlags);
            m_channeledDuration = duration;
            SendChannelStart(duration);
        }
        else if (duration == -1)
        {
            m_spellState = SPELL_STATE_CASTING;
            m_caster->AddInterruptMask(m_spellInfo->ChannelInterruptFlags);
            SendChannelStart(duration);
        }
    }
 
    PrepareTargetProcessing();
 
    // process immediate effects (items, ground, etc.) also initialize some variables
    _handle_immediate_phase();
 
    // Sync persistent area aura duration with hasted channel duration
    if (m_spellInfo->IsChanneled() && m_spellAura && m_channeledDuration > 0
        && m_spellAura->GetType() == DYNOBJ_AURA_TYPE)
    {
        m_spellAura->SetMaxDuration(m_channeledDuration);
        m_spellAura->SetDuration(m_channeledDuration);
    }
 
    for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
        DoAllEffectOnTarget(&(*ihit));
 
    for (std::list<GOTargetInfo>::iterator ihit = m_UniqueGOTargetInfo.begin(); ihit != m_UniqueGOTargetInfo.end(); ++ihit)
        DoAllEffectOnTarget(&(*ihit));
 
    FinishTargetProcessing();
 
    // spell is finished, perform some last features of the spell here
    _handle_finish_phase();
 
    // Remove used for cast item if need (it can be already nullptr after TakeReagents call
    TakeCastItem();
 
    // handle ammo consumption for Hunter's volley spell
    if (m_spellInfo->IsRangedWeaponSpell() && m_spellInfo->IsChanneled())
        TakeAmmo();
 
    if (m_spellState != SPELL_STATE_CASTING)
        finish(true);                                       // successfully finish spell cast (not last in case autorepeat or channel spell)
}

References _handle_finish_phase(), _handle_immediate_phase(), Unit::AddInterruptMask(), SpellInfo::ChannelInterruptFlags, DoAllEffectOnTarget(), DYNOBJ_AURA_TYPE, finish(), FinishTargetProcessing(), SpellInfo::GetDuration(), Object::GetFloatValue(), Unit::GetSpellModOwner(), Aura::GetType(), SpellInfo::HasAttribute(), Unit::HasAuraTypeWithAffectMask(), HasTriggeredCastFlag(), SpellInfo::Id, SpellInfo::IsChanneled(), SpellInfo::IsRangedWeaponSpell(), m_caster, m_channeledDuration, m_spellAura, m_spellInfo, m_spellState, m_UniqueGOTargetInfo, m_UniqueTargetInfo, PrepareTargetProcessing(), SendChannelStart(), Aura::SetDuration(), Aura::SetMaxDuration(), SPELL_ATTR5_SPELL_HASTE_AFFECTS_PERIODIC, SPELL_AURA_PERIODIC_HASTE, SPELL_STATE_CASTING, SPELLMOD_DURATION, TakeAmmo(), TakeCastItem(), TRIGGERED_IGNORE_EFFECTS, and UNIT_MOD_CAST_SPEED.

Referenced by _cast().

◆ HandleEffects()

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

{
    if (HasTriggeredCastFlag(TRIGGERED_IGNORE_EFFECTS))
        return;
 
    effectHandleMode = mode;
    unitTarget = pUnitTarget;
    itemTarget = pItemTarget;
    gameObjTarget = pGOTarget;
    destTarget = &m_destTargets[i]._position;
 
    uint8 eff = m_spellInfo->Effects[i].Effect;
 
    LOG_DEBUG("spells.aura", "Spell: {} Effect : {}", m_spellInfo->Id, eff);
 
    // we do not need DamageMultiplier here.
    damage = CalculateSpellDamage(i, nullptr);
 
    bool preventDefault = CallScriptEffectHandlers((SpellEffIndex)i, mode);
 
    if (!preventDefault && eff < TOTAL_SPELL_EFFECTS)
    {
        (this->*SpellEffects[eff])((SpellEffIndex)i);
    }
}

References SpellDestination::_position, CalculateSpellDamage(), CallScriptEffectHandlers(), damage, destTarget, effectHandleMode, SpellInfo::Effects, gameObjTarget, HasTriggeredCastFlag(), SpellInfo::Id, itemTarget, LOG_DEBUG, m_destTargets, m_spellInfo, TOTAL_SPELL_EFFECTS, TRIGGERED_IGNORE_EFFECTS, and unitTarget.

Referenced by _handle_immediate_phase(), DoAllEffectOnLaunchTarget(), DoAllEffectOnTarget(), DoAllEffectOnTarget(), DoAllEffectOnTarget(), DoSpellHitOnUnit(), and HandleLaunchPhase().

◆ HandleLaunchPhase()

void Spell::HandleLaunchPhase ( )

protected

{
    // handle effects with SPELL_EFFECT_HANDLE_LAUNCH mode
    for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        // don't do anything for empty effect
        if (!m_spellInfo->Effects[i].IsEffect())
            continue;
 
        HandleEffects(nullptr, nullptr, nullptr, i, SPELL_EFFECT_HANDLE_LAUNCH);
    }
 
    float multiplier[MAX_SPELL_EFFECTS];
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (m_applyMultiplierMask & (1 << i))
            multiplier[i] = m_spellInfo->Effects[i].CalcDamageMultiplier(m_originalCaster, this);
 
    bool usesAmmo = m_spellInfo->HasAttribute(SPELL_ATTR0_CU_DIRECT_DAMAGE);
    Unit::AuraEffectList const& Auras = m_caster->GetAuraEffectsByType(SPELL_AURA_ABILITY_CONSUME_NO_AMMO);
    for (Unit::AuraEffectList::const_iterator j = Auras.begin(); j != Auras.end(); ++j)
    {
        if ((*j)->IsAffectedOnSpell(m_spellInfo))
            usesAmmo = false;
    }
 
    PrepareTargetProcessing();
 
    for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
    {
        TargetInfo& target = *ihit;
 
        uint32 mask = target.effectMask;
        if (!mask)
            continue;
 
        // do not consume ammo anymore for Hunter's volley spell
        if (IsTriggered() && m_spellInfo->SpellFamilyName == SPELLFAMILY_HUNTER && m_spellInfo->IsTargetingArea())
            usesAmmo = false;
 
        if (usesAmmo)
        {
            bool ammoTaken = false;
            for (uint8 i = 0; i < MAX_SPELL_EFFECTS; i++)
            {
                if (!(mask & 1 << i))
                    continue;
                switch (m_spellInfo->Effects[i].Effect)
                {
                    case SPELL_EFFECT_SCHOOL_DAMAGE:
                    case SPELL_EFFECT_WEAPON_DAMAGE:
                    case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
                    case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:
                    case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:
                        ammoTaken = true;
                        TakeAmmo();
                }
                if (ammoTaken)
                    break;
            }
        }
 
        if (m_originalCaster && target.missCondition != SPELL_MISS_EVADE)
        {
            Unit* targetUnit = m_caster->GetGUID() == target.targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, target.targetGUID);
            if (targetUnit && !m_originalCaster->IsFriendlyTo(targetUnit) && (!m_spellInfo->IsPositive() || m_spellInfo->HasEffect(SPELL_EFFECT_DISPEL)) && (m_spellInfo->HasInitialAggro() || targetUnit->IsEngaged()))
                m_originalCaster->SetInCombatWith(targetUnit, true);
        }
 
        DoAllEffectOnLaunchTarget(target, multiplier);
    }
 
    FinishTargetProcessing();
}

References DoAllEffectOnLaunchTarget(), TargetInfo::effectMask, SpellInfo::Effects, FinishTargetProcessing(), Unit::GetAuraEffectsByType(), Object::GetGUID(), ObjectAccessor::GetUnit(), HandleEffects(), SpellInfo::HasAttribute(), SpellInfo::HasEffect(), SpellInfo::HasInitialAggro(), Unit::IsEngaged(), Unit::IsFriendlyTo(), SpellInfo::IsPositive(), SpellInfo::IsTargetingArea(), IsTriggered(), m_applyMultiplierMask, m_caster, m_originalCaster, m_spellInfo, m_UniqueTargetInfo, MAX_SPELL_EFFECTS, TargetInfo::missCondition, PrepareTargetProcessing(), Unit::SetInCombatWith(), SPELL_ATTR0_CU_DIRECT_DAMAGE, SPELL_AURA_ABILITY_CONSUME_NO_AMMO, SPELL_EFFECT_DISPEL, SPELL_EFFECT_HANDLE_LAUNCH, SPELL_EFFECT_NORMALIZED_WEAPON_DMG, SPELL_EFFECT_SCHOOL_DAMAGE, SPELL_EFFECT_WEAPON_DAMAGE, SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL, SPELL_EFFECT_WEAPON_PERCENT_DAMAGE, SPELL_MISS_EVADE, SPELLFAMILY_HUNTER, SpellInfo::SpellFamilyName, TakeAmmo(), and TargetInfo::targetGUID.

Referenced by _cast().

◆ HandleThreatSpells()

void Spell::HandleThreatSpells ( )

{
    if (m_UniqueTargetInfo.empty())
        return;
 
    if (m_spellInfo->HasAttribute(SPELL_ATTR1_NO_THREAT) || m_spellInfo->HasAttribute(SPELL_ATTR3_SUPPRESS_TARGET_PROCS))
        return;
 
    Unit* unitCaster = m_originalCaster ? m_originalCaster : m_caster;
 
    float threat = 0.0f;
    if (SpellThreatEntry const* threatEntry = sSpellMgr->GetSpellThreatEntry(m_spellInfo->Id))
    {
        if (threatEntry->apPctMod != 0.0f)
            threat += threatEntry->apPctMod * unitCaster->GetTotalAttackPowerValue(BASE_ATTACK);
 
        threat += threatEntry->flatMod;
    }
    else if (!m_spellInfo->HasAttribute(SPELL_ATTR0_CU_NO_INITIAL_THREAT))
        threat += m_spellInfo->SpellLevel;
 
    // past this point only multiplicative effects occur
    if (threat == 0.0f)
        return;
 
    // since 2.0.1 threat from positive effects also is distributed among all targets, so the overall caused threat is at most the defined bonus
    threat /= m_UniqueTargetInfo.size();
 
    for (auto& ihit : m_UniqueTargetInfo)
    {
        float threatToAdd = threat;
        if (ihit.missCondition != SPELL_MISS_NONE)
            threatToAdd = 0.0f;
 
        Unit* target = ObjectAccessor::GetUnit(*unitCaster, ihit.targetGUID);
        if (!target)
            continue;
 
        // positive spells distribute threat among all units that are in combat with target, like healing
        if (m_spellInfo->_IsPositiveSpell())
            target->GetThreatMgr().ForwardThreatForAssistingMe(unitCaster, threatToAdd, m_spellInfo);
        // for negative spells threat gets distributed among affected targets
        // ignoreModifiers=true because flat SpellThreatEntry threat should not have modifiers applied twice
        else
        {
            if (!target->CanHaveThreatList())
                continue;
            target->GetThreatMgr().AddThreat(unitCaster, threatToAdd, m_spellInfo, true);
        }
    }
    LOG_DEBUG("spells.aura", "Spell {}, added an additional {} threat for {} {} target(s)", m_spellInfo->Id, threat, m_spellInfo->_IsPositiveSpell() ? "assisting" : "harming", uint32(m_UniqueTargetInfo.size()));
}

References SpellInfo::_IsPositiveSpell(), ThreatManager::AddThreat(), BASE_ATTACK, Unit::CanHaveThreatList(), ThreatManager::ForwardThreatForAssistingMe(), Unit::GetThreatMgr(), Unit::GetTotalAttackPowerValue(), ObjectAccessor::GetUnit(), SpellInfo::HasAttribute(), SpellInfo::Id, LOG_DEBUG, m_caster, m_originalCaster, m_spellInfo, m_UniqueTargetInfo, SPELL_ATTR0_CU_NO_INITIAL_THREAT, SPELL_ATTR1_NO_THREAT, SPELL_ATTR3_SUPPRESS_TARGET_PROCS, SPELL_MISS_NONE, SpellInfo::SpellLevel, and sSpellMgr.

Referenced by _handle_immediate_phase().

◆ HasGlobalCooldown()

bool Spell::HasGlobalCooldown ( ) const

protected

{
    // Only player or controlled units have global cooldown
    if (m_caster->GetCharmInfo())
        return m_caster->GetCharmInfo()->GetGlobalCooldownMgr().HasGlobalCooldown(m_spellInfo);
    else if (m_caster->IsPlayer())
        return m_caster->ToPlayer()->GetGlobalCooldownMgr().HasGlobalCooldown(m_spellInfo);
    else
        return false;
}

References Unit::GetCharmInfo(), Player::GetGlobalCooldownMgr(), CharmInfo::GetGlobalCooldownMgr(), GlobalCooldownMgr::HasGlobalCooldown(), Object::IsPlayer(), m_caster, m_spellInfo, and Object::ToPlayer().

Referenced by CheckCast().

◆ HasTriggeredCastFlag()

bool Spell::HasTriggeredCastFlag ( TriggerCastFlags flag ) const

inline

569{ return _triggeredCastFlags & flag; };

References _triggeredCastFlags.

Referenced by _cast(), CheckCast(), CheckItems(), CheckPetCast(), DoSpellHitOnUnit(), handle_immediate(), HandleEffects(), IsIgnoringCooldowns(), IsNeedSendToClient(), IsProcDisabled(), IsTriggered(), prepare(), prepareDataForTriggerSystem(), SendCastResult(), SendSpellCooldown(), and TakeCastItem().

◆ HaveTargetsForEffect()

bool Spell::HaveTargetsForEffect ( uint8 effect ) const

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

References m_UniqueGOTargetInfo, m_UniqueItemInfo, and m_UniqueTargetInfo.

◆ InitEffectExecuteData()

void Spell::InitEffectExecuteData ( uint8 effIndex )

protected

{
    ASSERT(effIndex < MAX_SPELL_EFFECTS);
    if (!m_effectExecuteData[effIndex])
    {
        m_effectExecuteData[effIndex] = new ByteBuffer(0x20);
        // first dword - target counter
        *m_effectExecuteData[effIndex] << uint32(1);
    }
    else
    {
        // increase target counter by one
        uint32 count = (*m_effectExecuteData[effIndex]).read<uint32>(0);
        (*m_effectExecuteData[effIndex]).put<uint32>(0, ++count);
    }
}

References ASSERT, m_effectExecuteData, and MAX_SPELL_EFFECTS.

Referenced by ExecuteLogEffectCreateItem(), ExecuteLogEffectDestroyItem(), ExecuteLogEffectDurabilityDamage(), ExecuteLogEffectExtraAttacks(), ExecuteLogEffectInterruptCast(), ExecuteLogEffectOpenLock(), ExecuteLogEffectResurrect(), ExecuteLogEffectSummonObject(), ExecuteLogEffectTakeTargetPower(), and ExecuteLogEffectUnsummonObject().

◆ InitExplicitTargets()

void Spell::InitExplicitTargets ( SpellCastTargets const & targets )

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

Referenced by Player::CastItemUseSpell(), and prepare().

◆ IsAutoActionResetSpell()

bool Spell::IsAutoActionResetSpell ( ) const

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

{
    if (IsTriggered() || !(m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_INTERRUPT))
    {
        return false;
    }
 
    if (!m_casttime && m_spellInfo->HasAttribute(SPELL_ATTR6_DOESNT_RESET_SWING_TIMER_IF_INSTANT))
    {
        return false;
    }
 
    return true;
}

References SpellInfo::HasAttribute(), SpellInfo::InterruptFlags, IsTriggered(), m_casttime, m_spellInfo, SPELL_ATTR6_DOESNT_RESET_SWING_TIMER_IF_INSTANT, and SPELL_INTERRUPT_FLAG_INTERRUPT.

Referenced by _cast().

◆ IsAutoRepeat()

bool Spell::IsAutoRepeat ( ) const

inline

563{ return m_autoRepeat; }

References m_autoRepeat.

Referenced by _handle_finish_phase(), CheckCast(), GetCurrentContainer(), prepare(), and update().

◆ IsChannelActive()

bool Spell::IsChannelActive ( ) const

inline

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

UNIT_CHANNEL_SPELL

@ UNIT_CHANNEL_SPELL

Definition UpdateFields.h:94

References Object::GetUInt32Value(), m_caster, and UNIT_CHANNEL_SPELL.

Referenced by Creature::IsMovementPreventedByCasting().

◆ isDelayableNoMore()

bool Spell::isDelayableNoMore ( )

inlineprotected

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

References m_delayAtDamageCount.

Referenced by Delayed(), and DelayedChannel().

◆ IsDeletable()

bool Spell::IsDeletable ( ) const

inline

575{ return !m_referencedFromCurrentSpell && !m_executedCurrently; }

References m_executedCurrently, and m_referencedFromCurrentSpell.

Referenced by SpellEvent::Execute(), SpellEvent::IsDeletable(), and SpellEvent::~SpellEvent().

◆ IsIgnoringCooldowns()

bool Spell::IsIgnoringCooldowns ( ) const

{
    return HasTriggeredCastFlag(TRIGGERED_IGNORE_SPELL_AND_CATEGORY_CD) != 0;
}

References HasTriggeredCastFlag(), and TRIGGERED_IGNORE_SPELL_AND_CATEGORY_CD.

Referenced by Player::UpdatePotionCooldown().

◆ IsInterruptable()

bool Spell::IsInterruptable ( ) const

inline

577{ return !m_executedCurrently; }

References m_executedCurrently.

Referenced by Unit::InterruptSpell().

◆ IsNeedSendToClient()

bool Spell::IsNeedSendToClient ( bool go ) const

{
    if (HasTriggeredCastFlag(TRIGGERED_IGNORE_EFFECTS))
        return false;
 
    return m_spellInfo->SpellVisual[0] || m_spellInfo->SpellVisual[1] || m_spellInfo->IsChanneled() ||
           m_spellInfo->Speed > 0.0f || (!m_triggeredByAuraSpell && !IsTriggered()) ||
           (go && m_triggeredByAuraSpell && m_triggeredByAuraSpell.spellInfo->IsChanneled());
}

References HasTriggeredCastFlag(), SpellInfo::IsChanneled(), IsTriggered(), m_spellInfo, m_triggeredByAuraSpell, SpellInfo::Speed, TriggeredByAuraSpellData::spellInfo, SpellInfo::SpellVisual, and TRIGGERED_IGNORE_EFFECTS.

Referenced by SendSpellGo(), and SendSpellStart().

◆ IsNextMeleeSwingSpell()

bool Spell::IsNextMeleeSwingSpell ( ) const

{
    return m_spellInfo->HasAttribute(SPELL_ATTR0_ON_NEXT_SWING_NO_DAMAGE);
}

References SpellInfo::HasAttribute(), m_spellInfo, and SPELL_ATTR0_ON_NEXT_SWING_NO_DAMAGE.

Referenced by _handle_finish_phase(), CheckCast(), GetCurrentContainer(), prepare(), and update().

◆ IsProcDisabled()

bool Spell::IsProcDisabled ( ) const

inline

570{ return HasTriggeredCastFlag(TRIGGERED_DISALLOW_PROC_EVENTS); }

TRIGGERED_DISALLOW_PROC_EVENTS

@ TRIGGERED_DISALLOW_PROC_EVENTS

Will ignore caster aura restrictions or requirements.

Definition SpellDefines.h:148

References HasTriggeredCastFlag(), and TRIGGERED_DISALLOW_PROC_EVENTS.

Referenced by Unit::TriggerAurasProcOnEvent().

◆ IsTriggered()

bool Spell::IsTriggered ( ) const

inline

568{ return HasTriggeredCastFlag(TRIGGERED_FULL_MASK); };

References HasTriggeredCastFlag(), and TRIGGERED_FULL_MASK.

Referenced by _cast(), CheckCast(), CheckEffectTarget(), CheckItems(), DoSpellHitOnUnit(), HandleLaunchPhase(), IsAutoActionResetSpell(), IsNeedSendToClient(), prepare(), SendSpellGo(), SendSpellStart(), and update().

◆ IsValidDeadOrAliveTarget()

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

protected

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

References Unit::IsAlive(), SpellInfo::IsAllowingDeadTarget(), SpellInfo::IsRequiringDeadTarget(), and m_spellInfo.

Referenced by UpdateChanneledTargetList().

◆ LoadScripts()

void Spell::LoadScripts ( )

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

References _scriptsLoaded, SpellInfo::Id, LOG_DEBUG, m_loadedScripts, m_spellInfo, and sScriptMgr.

Referenced by WorldSession::HandlePetActionHelper(), WorldSession::HandlePetCastSpellOpcode(), prepare(), and PetAI::UpdateAI().

◆ OnSpellLaunch()

void Spell::OnSpellLaunch ( )

{
    if (!m_caster || !m_caster->IsInWorld())
        return;
 
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(24390);
 
    // Make sure the player is sending a valid GO target and lock ID. SPELL_EFFECT_OPEN_LOCK
    // can succeed with a lockId of 0
    if (m_spellInfo->Id == 21651)
    {
        if (GameObject* go = m_targets.GetGOTarget())
        {
            LockEntry const* lockInfo = sLockStore.LookupEntry(go->GetGOInfo()->GetLockId());
            if (lockInfo && lockInfo->Index[1] == LOCKTYPE_SLOW_OPEN)
            {
                Spell* visual = new Spell(m_caster, spellInfo, TRIGGERED_NONE);
                visual->prepare(&m_targets);
            }
        }
    }
}

References SpellCastTargets::GetGOTarget(), SpellInfo::Id, LockEntry::Index, Object::IsInWorld(), LOCKTYPE_SLOW_OPEN, m_caster, m_spellInfo, m_targets, prepare(), sLockStore, sSpellMgr, and TRIGGERED_NONE.

Referenced by prepare().

◆ prepare()

SpellCastResult Spell::prepare	(	SpellCastTargets const *	targets,
		AuraEffect const *	triggeredByAura = `nullptr`
	)

m_castItemGUID &&

{
    if (m_CastItem)
    {
        m_castItemGUID = m_CastItem->GetGUID();
    }
    else
    {
        m_castItemGUID = ObjectGuid::Empty;
    }
 
    InitExplicitTargets(*targets);
 
    if (!sScriptMgr->CanPrepare(this, targets, triggeredByAura))
    {
        finish(false);
        return SPELL_FAILED_UNKNOWN;
    }
 
    // Fill aura scaling information
    if (sScriptMgr->CanScalingEverything(this) || m_caster->IsTotem() || (m_caster->IsControlledByPlayer() && !m_spellInfo->IsPassive() && m_spellInfo->SpellLevel && !m_spellInfo->IsChanneled() && !HasTriggeredCastFlag(TRIGGERED_IGNORE_AURA_SCALING)))
    {
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (m_spellInfo->Effects[i].Effect == SPELL_EFFECT_APPLY_AURA ||
                    m_spellInfo->Effects[i].Effect == SPELL_EFFECT_APPLY_AREA_AURA_PARTY ||
                    m_spellInfo->Effects[i].Effect == SPELL_EFFECT_APPLY_AREA_AURA_RAID)
            {
                // Change aura with ranks only if basepoints are taken from spellInfo and aura is positive
                if (m_spellInfo->IsPositiveEffect(i))
                {
                    m_auraScaleMask |= (1 << i);
                    if (m_spellValue->EffectBasePoints[i] != m_spellInfo->Effects[i].BasePoints)
                    {
                        m_auraScaleMask = 0;
                        break;
                    }
                }
            }
        }
    }
 
    m_spellState = SPELL_STATE_PREPARING;
 
    if (triggeredByAura)
    {
        m_triggeredByAuraSpell.Init(triggeredByAura);
    }
 
    // create and add update event for this spell
    _spellEvent = new SpellEvent(this);
    m_caster->m_Events.AddEventAtOffset(_spellEvent, 1ms);
 
    if (sDisableMgr->IsDisabledFor(DISABLE_TYPE_SPELL, m_spellInfo->Id, m_caster))
    {
        SendCastResult(SPELL_FAILED_SPELL_UNAVAILABLE);
        finish(false);
        return SPELL_FAILED_SPELL_UNAVAILABLE;
    }
 
    //Prevent casting at cast another spell (ServerSide check)
    if (!HasTriggeredCastFlag(TRIGGERED_IGNORE_CAST_IN_PROGRESS) && m_caster->IsNonMeleeSpellCast(false, true, true, m_spellInfo->Id == 75) && m_cast_count)
    {
        SendCastResult(SPELL_FAILED_SPELL_IN_PROGRESS);
        finish(false);
        return SPELL_FAILED_SPELL_IN_PROGRESS;
    }
 
    LoadScripts();
 
    OnSpellLaunch();
 
    m_powerCost = m_CastItem ? 0 : m_spellInfo->CalcPowerCost(m_caster, m_spellSchoolMask, this);
 
    // Set combo point requirement
    if (HasTriggeredCastFlag(TRIGGERED_IGNORE_COMBO_POINTS) || m_CastItem)
        m_needComboPoints = false;
 
    SpellCastResult result = CheckCast(true);
    if (result != SPELL_CAST_OK && !IsAutoRepeat())          //always cast autorepeat dummy for triggering
    {
        // Periodic auras should be interrupted when aura triggers a spell which can't be cast
        // for example bladestorm aura should be removed on disarm as of patch 3.3.5
        // channeled periodic spells should be affected by this (arcane missiles, penance, etc)
        // a possible alternative sollution for those would be validating aura target on unit state change
        if (m_caster->IsPlayer() && triggeredByAura && triggeredByAura->IsPeriodic() && !triggeredByAura->GetBase()->IsPassive())
        {
            SendChannelUpdate(0);
            triggeredByAura->GetBase()->SetDuration(0);
        }
 
        // Allows to cast melee attack spell if result is SPELL_FAILED_OUT_OF_RANGE
        if (!IsNextMeleeSwingSpell() || result != SPELL_FAILED_OUT_OF_RANGE)
        {
            SendCastResult(result);
 
            finish(false);
            return result;
        }
    }
 
    // Prepare data for triggers
    prepareDataForTriggerSystem(triggeredByAura);
 
    // calculate cast time (calculated after first CheckCast check to prevent charge counting for first CheckCast fail)
    m_casttime = HasTriggeredCastFlag(TRIGGERED_CAST_DIRECTLY) ? 0 : m_spellInfo->CalcCastTime(m_caster, this);
 
    if (m_caster->IsPlayer())
        if (m_caster->ToPlayer()->GetCommandStatus(CHEAT_CASTTIME))
            m_casttime = 0;
 
    // don't allow channeled spells / spells with cast time to be casted while moving
    // (even if they are interrupted on moving, spells with almost immediate effect get to have their effect processed before movement interrupter kicks in)
    if ((m_spellInfo->IsChanneled() || m_casttime) && m_caster->IsPlayer() && m_caster->isMoving() && m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_MOVEMENT && !IsTriggered())
    {
        // 1. Has casttime, 2. Or doesn't have flag to allow action during channel
        if (m_casttime || !m_spellInfo->IsActionAllowedChannel())
        {
            SendCastResult(SPELL_FAILED_MOVING);
            finish(false);
            return SPELL_FAILED_MOVING;
        }
    }
 
    // xinef: if spell have nearby target entry only, do not allow to cast if no targets are found
    if (m_CastItem)
    {
        bool selectTargets = false;
        bool nearbyDest = false;
 
        for (uint8 i = EFFECT_0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (!m_spellInfo->Effects[i].IsEffect())
                continue;
 
            if (m_spellInfo->Effects[i].TargetA.GetSelectionCategory() != TARGET_SELECT_CATEGORY_NEARBY || m_spellInfo->Effects[i].TargetA.GetCheckType() != TARGET_CHECK_ENTRY)
            {
                selectTargets = false;
                break;
            }
 
            if (m_spellInfo->Effects[i].TargetA.GetObjectType() == TARGET_OBJECT_TYPE_DEST)
            {
                nearbyDest = true;
            }
 
            // xinef: by default set it to false, and to true if any valid target is found
            selectTargets = true;
        }
 
        if (selectTargets)
        {
            SelectSpellTargets();
            _spellTargetsSelected = true;
            bool spellFailed = false;
 
            if (m_UniqueTargetInfo.empty() && m_UniqueGOTargetInfo.empty())
            {
                // no valid nearby target unit or game object found; check if nearby destination type
                if (nearbyDest)
                {
                    if (!m_targets.HasDst())
                    {
                        // no valid target destination
                        spellFailed = true;
                    }
                }
                else
                {
                    spellFailed = true;
                }
            }
 
            if (spellFailed)
            {
                SendCastResult(SPELL_FAILED_CASTER_AURASTATE);
                finish(false);
                return SPELL_FAILED_CASTER_AURASTATE;
            }
        }
    }
 
    // set timer base at cast time
    ReSetTimer();
 
    LOG_DEBUG("spells.aura", "Spell::prepare: spell id {} source {} caster {} customCastFlags {} mask {}", m_spellInfo->Id, m_caster->GetEntry(), m_originalCaster ? m_originalCaster->GetEntry() : -1, _triggeredCastFlags, m_targets.GetTargetMask());
 
    // prevent exploit that allows to cast spell while sitting
    if (!IsTriggered() && !(m_spellInfo->AuraInterruptFlags & AURA_INTERRUPT_FLAG_NOT_SEATED) && !(m_spellInfo->Attributes & SPELL_ATTR0_ALLOW_WHILE_SITTING) && !m_triggeredByAuraSpell && m_caster->IsSitState())
        m_caster->SetStandState(UNIT_STAND_STATE_STAND);
 
    //Containers for channeled spells have to be set
    //TODO:Apply this to all casted spells if needed
    // Why check duration? 29350: channelled triggers channelled
    if (HasTriggeredCastFlag(TRIGGERED_CAST_DIRECTLY) && (!m_spellInfo->IsChanneled() || !m_spellInfo->GetMaxDuration()))
        cast(true);
    else
    {
        // stealth must be removed at cast starting (at show channel bar)
        // skip triggered spell (item equip spell casting and other not explicit character casts/item uses)
        if (!HasTriggeredCastFlag(TRIGGERED_IGNORE_AURA_INTERRUPT_FLAGS) && m_spellInfo->IsBreakingStealth())
        {
            // Farsight spells exception
            uint32 exceptSpellId = 0;
            if (m_spellInfo->HasEffect(SPELL_EFFECT_ADD_FARSIGHT))
            {
                exceptSpellId = m_spellInfo->Id;
            }
 
            m_caster->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_CAST, exceptSpellId, m_spellInfo->Id == 75);
            m_caster->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_SPELL_ATTACK, exceptSpellId, m_spellInfo->Id == 75);
        }
 
        m_caster->SetCurrentCastedSpell(this);
        SendSpellStart();
 
        // Call CreatureAI hook OnSpellStart for spells with cast time or channeled spells
        if (m_casttime > 0 || m_spellInfo->IsChanneled())
            if (Creature* caster = m_caster->ToCreature())
                if (caster->IsAIEnabled)
                    caster->AI()->OnSpellStart(GetSpellInfo());
 
        // set target for proper facing
        if ((m_casttime || m_spellInfo->IsChanneled()) && !HasTriggeredCastFlag(TRIGGERED_IGNORE_SET_FACING))
        {
            if (m_caster->IsCreature() && !m_caster->ToCreature()->IsInEvadeMode() &&
                    ((m_targets.GetObjectTarget() && m_caster != m_targets.GetObjectTarget()) || m_spellInfo->IsPositive()))
            {
                // Xinef: Creature should focus to cast target if there is explicit target or self if casting positive spell
                // Xinef: Creature should not rotate when casting spell... based on halion behavior
                m_caster->ToCreature()->FocusTarget(this, m_targets.GetObjectTarget() != nullptr ? m_targets.GetObjectTarget() : m_caster);
            }
        }
 
        //item: first cast may destroy item and second cast causes crash
        // xinef: removed !m_spellInfo->StartRecoveryTime
        // second los check failed in events
        // xinef: removed itemguid check, currently there is no such item in database
        if (!m_casttime &&  GetCurrentContainer() == CURRENT_GENERIC_SPELL)
            cast(true);
 
        if (!HasTriggeredCastFlag(TRIGGERED_IGNORE_GCD))
            TriggerGlobalCooldown();
    }
 
    sScriptMgr->OnSpellPrepare(this, m_caster, m_spellInfo);
 
    return SPELL_CAST_OK;
}

References _spellEvent, _spellTargetsSelected, _triggeredCastFlags, EventProcessor::AddEventAtOffset(), SpellInfo::Attributes, AURA_INTERRUPT_FLAG_CAST, AURA_INTERRUPT_FLAG_NOT_SEATED, AURA_INTERRUPT_FLAG_SPELL_ATTACK, SpellInfo::AuraInterruptFlags, SpellInfo::CalcCastTime(), SpellInfo::CalcPowerCost(), cast(), CHEAT_CASTTIME, CheckCast(), CURRENT_GENERIC_SPELL, DISABLE_TYPE_SPELL, EFFECT_0, SpellValue::EffectBasePoints, SpellInfo::Effects, ObjectGuid::Empty, finish(), Creature::FocusTarget(), AuraEffect::GetBase(), Player::GetCommandStatus(), GetCurrentContainer(), Object::GetEntry(), Object::GetGUID(), SpellInfo::GetMaxDuration(), SpellCastTargets::GetObjectTarget(), GetSpellInfo(), SpellCastTargets::GetTargetMask(), SpellCastTargets::HasDst(), SpellInfo::HasEffect(), HasTriggeredCastFlag(), SpellInfo::Id, TriggeredByAuraSpellData::Init(), InitExplicitTargets(), SpellInfo::InterruptFlags, SpellInfo::IsActionAllowedChannel(), IsAutoRepeat(), SpellInfo::IsBreakingStealth(), SpellInfo::IsChanneled(), Unit::IsControlledByPlayer(), Object::IsCreature(), Creature::IsInEvadeMode(), Unit::isMoving(), IsNextMeleeSwingSpell(), Unit::IsNonMeleeSpellCast(), Aura::IsPassive(), SpellInfo::IsPassive(), AuraEffect::IsPeriodic(), Object::IsPlayer(), SpellInfo::IsPositive(), SpellInfo::IsPositiveEffect(), Unit::IsSitState(), Unit::IsTotem(), IsTriggered(), LoadScripts(), LOG_DEBUG, m_auraScaleMask, m_cast_count, m_caster, m_CastItem, m_castItemGUID, m_casttime, WorldObject::m_Events, m_needComboPoints, m_originalCaster, m_powerCost, m_spellInfo, m_spellSchoolMask, m_spellState, m_spellValue, m_targets, m_triggeredByAuraSpell, m_UniqueGOTargetInfo, m_UniqueTargetInfo, MAX_SPELL_EFFECTS, OnSpellLaunch(), prepareDataForTriggerSystem(), Unit::RemoveAurasWithInterruptFlags(), ReSetTimer(), sDisableMgr, SelectSpellTargets(), SendCastResult(), SendChannelUpdate(), SendSpellStart(), Unit::SetCurrentCastedSpell(), Aura::SetDuration(), Unit::SetStandState(), SPELL_ATTR0_ALLOW_WHILE_SITTING, SPELL_CAST_OK, SPELL_EFFECT_ADD_FARSIGHT, SPELL_EFFECT_APPLY_AREA_AURA_PARTY, SPELL_EFFECT_APPLY_AREA_AURA_RAID, SPELL_EFFECT_APPLY_AURA, SPELL_FAILED_CASTER_AURASTATE, SPELL_FAILED_MOVING, SPELL_FAILED_OUT_OF_RANGE, SPELL_FAILED_SPELL_IN_PROGRESS, SPELL_FAILED_SPELL_UNAVAILABLE, SPELL_FAILED_UNKNOWN, SPELL_INTERRUPT_FLAG_MOVEMENT, SPELL_STATE_PREPARING, SpellInfo::SpellLevel, sScriptMgr, TARGET_CHECK_ENTRY, TARGET_OBJECT_TYPE_DEST, TARGET_SELECT_CATEGORY_NEARBY, Object::ToCreature(), Object::ToPlayer(), TRIGGERED_CAST_DIRECTLY, TRIGGERED_IGNORE_AURA_INTERRUPT_FLAGS, TRIGGERED_IGNORE_AURA_SCALING, TRIGGERED_IGNORE_CAST_IN_PROGRESS, TRIGGERED_IGNORE_COMBO_POINTS, TRIGGERED_IGNORE_GCD, TRIGGERED_IGNORE_SET_FACING, TriggerGlobalCooldown(), and UNIT_STAND_STATE_STAND.

Referenced by Unit::_UpdateAutoRepeatSpell(), Player::CastItemUseSpell(), Unit::CastSpell(), EffectEnchantItemTmp(), WorldSession::HandleAcceptTradeOpcode(), WorldSession::HandleCastSpellOpcode(), WorldSession::HandlePetActionHelper(), WorldSession::HandlePetCastSpellOpcode(), OnSpellLaunch(), and PetAI::UpdateAI().

◆ prepareDataForTriggerSystem()

void Spell::prepareDataForTriggerSystem ( AuraEffect const * triggeredByAura )

protected

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

References SpellInfo::DmgClass, SpellInfo::EquippedItemClass, SpellInfo::EquippedItemSubClassMask, SpellInfo::HasAttribute(), HasTriggeredCastFlag(), SpellInfo::Id, Unit::IsControlledByPlayer(), Object::IsCreature(), Unit::IsTotem(), ITEM_CLASS_WEAPON, ITEM_SUBCLASS_WEAPON_WAND, m_attackType, m_caster, m_originalCaster, m_procAttacker, m_procEx, m_procVictim, m_spellInfo, OFF_ATTACK, PROC_EX_INTERNAL_CANT_PROC, PROC_EX_INTERNAL_REQ_FAMILY, PROC_EX_INTERNAL_TRIGGERED, PROC_EX_NONE, PROC_FLAG_DONE_MAINHAND_ATTACK, PROC_FLAG_DONE_OFFHAND_ATTACK, PROC_FLAG_DONE_PERIODIC, PROC_FLAG_DONE_RANGED_AUTO_ATTACK, PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS, PROC_FLAG_DONE_SPELL_RANGED_DMG_CLASS, PROC_FLAG_DONE_TRAP_ACTIVATION, PROC_FLAG_TAKEN_PERIODIC, PROC_FLAG_TAKEN_RANGED_AUTO_ATTACK, PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG, PROC_FLAG_TAKEN_SPELL_MELEE_DMG_CLASS, PROC_FLAG_TAKEN_SPELL_RANGED_DMG_CLASS, SPELL_ATTR2_ACTIVE_THREAT, SPELL_ATTR2_AUTO_REPEAT, SPELL_ATTR3_NOT_A_PROC, SPELL_DAMAGE_CLASS_MELEE, SPELL_DAMAGE_CLASS_RANGED, SPELLFAMILY_HUNTER, SPELLFAMILY_WARLOCK, SpellInfo::SpellFamilyFlags, SpellInfo::SpellFamilyName, Object::ToCreature(), and TRIGGERED_DISALLOW_PROC_EVENTS.

Referenced by prepare().

◆ PrepareScriptHitHandlers()

void Spell::PrepareScriptHitHandlers ( )

protected

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

References m_loadedScripts.

Referenced by _cast(), _handle_immediate_phase(), DoAllEffectOnTarget(), DoAllEffectOnTarget(), and DoAllEffectOnTarget().

◆ PrepareTargetProcessing()

void Spell::PrepareTargetProcessing ( )

protected

{
    CheckEffectExecuteData();
}

References CheckEffectExecuteData().

Referenced by handle_delayed(), handle_immediate(), and HandleLaunchPhase().

◆ PrepareTriggersExecutedOnHit()

void Spell::PrepareTriggersExecutedOnHit ( )

protected

Todo:: : move this to scripts

Todo:: : move this to scripts

{
    if (m_spellInfo->SpellFamilyName)
    {
        SpellInfo const* excludeCasterSpellInfo = sSpellMgr->GetSpellInfo(m_spellInfo->ExcludeCasterAuraSpell);
        if (excludeCasterSpellInfo && !excludeCasterSpellInfo->IsPositive())
            m_preCastSpell = m_spellInfo->ExcludeCasterAuraSpell;
        SpellInfo const* excludeTargetSpellInfo = sSpellMgr->GetSpellInfo(m_spellInfo->ExcludeTargetAuraSpell);
        if (excludeTargetSpellInfo && !excludeTargetSpellInfo->IsPositive())
            m_preCastSpell = m_spellInfo->ExcludeTargetAuraSpell;
    }
 
    switch (m_spellInfo->SpellFamilyName)
    {
        case SPELLFAMILY_PALADIN:
            {
                if (m_spellInfo->SpellFamilyFlags[1] & 0x40000000)
                {
                    Unit::AuraEffectList const& mVindication = m_caster->GetAuraEffectsByType(SPELL_AURA_PROC_TRIGGER_SPELL);
                    for(Unit::AuraEffectList::const_iterator itr = mVindication.begin(); itr != mVindication.end(); ++itr)
                    {
                        if ((*itr)->GetSpellInfo()->Effects[EFFECT_0].TriggerSpell == 26017 )
                        {
                            m_preCastSpell = 26017;
                            break;
                        }
                        else if ((*itr)->GetSpellInfo()->Effects[EFFECT_0].TriggerSpell == 67 )
                            m_preCastSpell = 67;
                    }
                }
                break;
            }
        case SPELLFAMILY_DRUID:
            {
                // Faerie Fire (Feral)
                if (m_spellInfo->Id == 16857 && (m_caster->GetShapeshiftForm() == FORM_BEAR || m_caster->GetShapeshiftForm() == FORM_DIREBEAR))
                    m_preCastSpell = 60089;
 
                break;
            }
    }
 
    // handle SPELL_AURA_ADD_TARGET_TRIGGER auras:
    // save auras which were present on spell caster on cast, to prevent triggered auras from affecting caster
    // and to correctly calculate proc chance when combopoints are present
    Unit::AuraEffectList const& targetTriggers = m_caster->GetAuraEffectsByType(SPELL_AURA_ADD_TARGET_TRIGGER);
    for (Unit::AuraEffectList::const_iterator i = targetTriggers.begin(); i != targetTriggers.end(); ++i)
    {
        if (!(*i)->IsAffectedOnSpell(m_spellInfo))
            continue;
        SpellInfo const* auraSpellInfo = (*i)->GetSpellInfo();
        uint32 auraSpellIdx = (*i)->GetEffIndex();
        if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(auraSpellInfo->Effects[auraSpellIdx].TriggerSpell))
        {
            // calculate the chance using spell base amount, because aura amount is not updated on combo-points change
            // this possibly needs fixing
            int32 auraBaseAmount = (*i)->GetBaseAmount();
            // proc chance is stored in effect amount
            int32 chance = m_caster->CalculateSpellDamage(nullptr, auraSpellInfo, auraSpellIdx, &auraBaseAmount);
            // build trigger and add to the list
            HitTriggerSpell spellTriggerInfo;
            spellTriggerInfo.triggeredSpell = spellInfo;
            spellTriggerInfo.triggeredByAura = auraSpellInfo;
            spellTriggerInfo.triggeredByEffIdx = (*i)->GetEffIndex();
            spellTriggerInfo.chance = chance * (*i)->GetBase()->GetStackAmount();
            m_hitTriggerSpells.push_back(spellTriggerInfo);
        }
    }
}

References Unit::CalculateSpellDamage(), Spell::HitTriggerSpell::chance, EFFECT_0, SpellInfo::Effects, SpellInfo::ExcludeCasterAuraSpell, SpellInfo::ExcludeTargetAuraSpell, FORM_BEAR, FORM_DIREBEAR, Unit::GetAuraEffectsByType(), Unit::GetShapeshiftForm(), SpellInfo::Id, SpellInfo::IsPositive(), m_caster, m_hitTriggerSpells, m_preCastSpell, m_spellInfo, SPELL_AURA_ADD_TARGET_TRIGGER, SPELL_AURA_PROC_TRIGGER_SPELL, SPELLFAMILY_DRUID, SPELLFAMILY_PALADIN, SpellInfo::SpellFamilyFlags, SpellInfo::SpellFamilyName, sSpellMgr, Spell::HitTriggerSpell::triggeredByAura, Spell::HitTriggerSpell::triggeredByEffIdx, and Spell::HitTriggerSpell::triggeredSpell.

Referenced by _cast().

◆ RecalculateDelayMomentForDst()

void Spell::RecalculateDelayMomentForDst ( )

{
    m_delayMoment = CalculateDelayMomentForDst();
    m_caster->m_Events.ModifyEventTime(_spellEvent, Milliseconds(GetDelayStart() + m_delayMoment));
}

References _spellEvent, CalculateDelayMomentForDst(), GetDelayStart(), m_caster, m_delayMoment, WorldObject::m_Events, and EventProcessor::ModifyEventTime().

Referenced by WorldSession::HandleUpdateProjectilePosition().

◆ ReSetTimer()

void Spell::ReSetTimer ( )

inline

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

References m_casttime, and m_timer.

Referenced by prepare().

◆ SearchAreaTargets()

void Spell::SearchAreaTargets	(	std::list< WorldObject * > &	targets,
		float	range,
		Position const *	position,
		Unit *	referer,
		SpellTargetObjectTypes	objectType,
		SpellTargetCheckTypes	selectionType,
		ConditionList *	condList,
		Acore::WorldObjectSpellAreaTargetSearchReason	searchReason = `Acore::WorldObjectSpellAreaTargetSearchReason::Area`
	)

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

References GetSearcherTypeMask(), m_caster, and m_spellInfo.

Referenced by SearchChainTargets(), and SelectImplicitAreaTargets().

◆ SearchChainTargets()

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

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

References Acore::Chain, SpellInfo::DmgClass, WorldObject::GetDistanceOrder(), SpellInfo::HasAttribute(), Position::HasInArc(), WorldObject::IsWithinDist(), WorldObject::IsWithinLOSInMap(), SpellInfo::JumpDistance, VMAP::M2, m_caster, m_spellInfo, SearchAreaTargets(), SPELL_ATTR2_CHAIN_FROM_CASTER, SPELL_ATTR4_BOUNCY_CHAIN_MISSILES, SPELL_DAMAGE_CLASS_MAGIC, SPELL_DAMAGE_CLASS_MELEE, SPELL_DAMAGE_CLASS_NONE, SPELL_DAMAGE_CLASS_RANGED, and Object::ToUnit().

Referenced by SelectImplicitChainTargets().

◆ SearchNearbyTarget()

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

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

References GetSearcherTypeMask(), m_caster, and m_spellInfo.

Referenced by SelectImplicitNearbyTargets().

◆ SearchTargets()

template<class SEARCHER >

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

{
    if (!containerMask)
        return;
 
    Cell::VisitObjects(pos->GetPositionX(), pos->GetPositionY(), referer->GetMap(), searcher, radius);
}

References WorldObject::GetMap(), Position::GetPositionX(), Position::GetPositionY(), and Cell::VisitObjects().

◆ SelectEffectImplicitTargets()

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

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

References ASSERT, CheckDst(), CheckScriptEffectImplicitTargets(), SpellInfo::Effects, SpellImplicitTargetInfo::GetObjectType(), SpellImplicitTargetInfo::GetReferenceType(), SpellImplicitTargetInfo::GetSelectionCategory(), GetSpellInfo(), SpellImplicitTargetInfo::GetTarget(), SpellInfo::Id, LOG_DEBUG, m_caster, m_spellInfo, m_targets, MAX_SPELL_EFFECTS, SelectImplicitAreaTargets(), SelectImplicitCasterDestTargets(), SelectImplicitCasterObjectTargets(), SelectImplicitChannelTargets(), SelectImplicitConeTargets(), SelectImplicitDestDestTargets(), SelectImplicitNearbyTargets(), SelectImplicitTargetDestTargets(), SelectImplicitTargetObjectTargets(), SelectImplicitTrajTargets(), SpellCastTargets::SetSrc(), TARGET_OBJECT_TYPE_DEST, TARGET_OBJECT_TYPE_SRC, TARGET_REFERENCE_TYPE_CASTER, TARGET_REFERENCE_TYPE_DEST, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_AREA, TARGET_SELECT_CATEGORY_CHANNEL, TARGET_SELECT_CATEGORY_CONE, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_SELECT_CATEGORY_NEARBY, TARGET_SELECT_CATEGORY_NYI, and TARGET_SELECT_CATEGORY_TRAJ.

Referenced by SelectSpellTargets().

◆ SelectEffectTypeImplicitTargets()

void Spell::SelectEffectTypeImplicitTargets ( uint8 effIndex )

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

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

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

References AddGOTarget(), AddItemTarget(), AddUnitTarget(), CallScriptObjectTargetSelectHandlers(), EFFECT_IMPLICIT_TARGET_CASTER, EFFECT_IMPLICIT_TARGET_EXPLICIT, SpellInfo::Effects, ObjectAccessor::FindPlayer(), SpellCastTargets::GetCorpseTarget(), SpellCastTargets::GetGOTarget(), SpellCastTargets::GetItemTarget(), Unit::GetTarget(), SpellCastTargets::GetUnitTarget(), Object::IsPlayer(), itemTarget, m_caster, m_spellInfo, m_targets, SPELL_EFFECT_SUMMON_PLAYER, SPELL_EFFECT_SUMMON_RAF_FRIEND, TARGET_FLAG_CORPSE_MASK, TARGET_FLAG_GAMEOBJECT_MASK, TARGET_FLAG_ITEM_MASK, TARGET_FLAG_UNIT_MASK, Object::ToGameObject(), Object::ToPlayer(), Object::ToUnit(), and unitTarget.

Referenced by SelectSpellTargets().

◆ SelectExplicitTargets()

void Spell::SelectExplicitTargets ( )

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

References SpellInfo::DmgClass, SpellInfo::GetExplicitTargetMask(), Unit::GetMagicHitRedirectTarget(), Unit::GetMeleeHitRedirectTarget(), SpellCastTargets::GetUnitTarget(), SpellInfo::HasEffect(), Unit::IsFriendlyTo(), SpellInfo::IsPositive(), m_caster, m_spellFlags, m_spellInfo, m_targets, SpellCastTargets::SetUnitTarget(), SPELL_DAMAGE_CLASS_MAGIC, SPELL_DAMAGE_CLASS_MELEE, SPELL_DAMAGE_CLASS_RANGED, SPELL_EFFECT_DISPEL, SPELL_FLAG_REDIRECTED, TARGET_FLAG_UNIT, and TARGET_FLAG_UNIT_ENEMY.

Referenced by SelectSpellTargets().

◆ SelectImplicitAreaTargets()

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

{
    Unit* referer = nullptr;
    switch (targetType.GetReferenceType())
    {
        case TARGET_REFERENCE_TYPE_SRC:
        case TARGET_REFERENCE_TYPE_DEST:
        case TARGET_REFERENCE_TYPE_CASTER:
            referer = m_caster;
            break;
        case TARGET_REFERENCE_TYPE_TARGET:
            referer = m_targets.GetUnitTarget();
            break;
        case TARGET_REFERENCE_TYPE_LAST:
            {
                // find last added target for this effect
                for (std::list<TargetInfo>::reverse_iterator ihit = m_UniqueTargetInfo.rbegin(); ihit != m_UniqueTargetInfo.rend(); ++ihit)
                {
                    if (ihit->effectMask & (1 << effIndex))
                    {
                        referer = ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID);
                        break;
                    }
                }
                break;
            }
        default:
            ASSERT(false && "Spell::SelectImplicitAreaTargets: received not implemented target reference type");
            return;
    }
    if (!referer)
        return;
 
    Position const* center = nullptr;
    switch (targetType.GetReferenceType())
    {
        case TARGET_REFERENCE_TYPE_SRC:
            center = m_targets.GetSrcPos();
            break;
        case TARGET_REFERENCE_TYPE_DEST:
            center = m_targets.GetDstPos();
            break;
        case TARGET_REFERENCE_TYPE_CASTER:
        case TARGET_REFERENCE_TYPE_TARGET:
        case TARGET_REFERENCE_TYPE_LAST:
            center = referer;
            break;
        default:
            ASSERT(false && "Spell::SelectImplicitAreaTargets: received not implemented target reference type");
            return;
    }
 
    // Xinef: the distance should be increased by caster size, it is neglected in latter calculations
    std::list<WorldObject*> targets;
    float radius = m_spellInfo->Effects[effIndex].CalcRadius(m_caster) * m_spellValue->RadiusMod;
    SearchAreaTargets(targets, radius, center, referer, targetType.GetObjectType(), targetType.GetCheckType(), m_spellInfo->Effects[effIndex].ImplicitTargetConditions, Acore::WorldObjectSpellAreaTargetSearchReason::Area);
 
    CallScriptObjectAreaTargetSelectHandlers(targets, effIndex, targetType);
 
    if (!targets.empty())
    {
        // Other special target selection goes here
        if (uint32 maxTargets = m_spellValue->MaxAffectedTargets)
        {
            maxTargets += m_caster->GetTotalAuraModifierByAffectMask(SPELL_AURA_MOD_MAX_AFFECTED_TARGETS, m_spellInfo);
            Acore::Containers::RandomResize(targets, maxTargets);
        }
 
        for (std::list<WorldObject*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
        {
            if (Unit* unitTarget = (*itr)->ToUnit())
                AddUnitTarget(unitTarget, effMask, false);
            else if (GameObject* gObjTarget = (*itr)->ToGameObject())
                AddGOTarget(gObjTarget, effMask);
        }
    }
}

References AddGOTarget(), AddUnitTarget(), Acore::Area, ASSERT, CallScriptObjectAreaTargetSelectHandlers(), SpellInfo::Effects, SpellImplicitTargetInfo::GetCheckType(), SpellCastTargets::GetDstPos(), SpellImplicitTargetInfo::GetObjectType(), SpellImplicitTargetInfo::GetReferenceType(), SpellCastTargets::GetSrcPos(), Unit::GetTotalAuraModifierByAffectMask(), ObjectAccessor::GetUnit(), SpellCastTargets::GetUnitTarget(), m_caster, m_spellInfo, m_spellValue, m_targets, m_UniqueTargetInfo, SpellValue::MaxAffectedTargets, SpellValue::RadiusMod, Acore::Containers::RandomResize(), SearchAreaTargets(), SPELL_AURA_MOD_MAX_AFFECTED_TARGETS, TARGET_REFERENCE_TYPE_CASTER, TARGET_REFERENCE_TYPE_DEST, TARGET_REFERENCE_TYPE_LAST, TARGET_REFERENCE_TYPE_SRC, TARGET_REFERENCE_TYPE_TARGET, Object::ToGameObject(), Object::ToUnit(), and unitTarget.

Referenced by SelectEffectImplicitTargets().

◆ SelectImplicitCasterDestTargets()

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

Todo:: fix this check

{
    SpellDestination dest(*m_caster);
 
    switch (targetType.GetTarget())
    {
        case TARGET_DEST_CASTER:
        case TARGET_DEST_CASTER_36:
            break;
        case TARGET_DEST_HOME:
            if (Player* playerCaster = m_caster->ToPlayer())
                dest = SpellDestination(playerCaster->m_homebindX, playerCaster->m_homebindY, playerCaster->m_homebindZ, playerCaster->GetOrientation(), playerCaster->m_homebindMapId);
            break;
        case TARGET_DEST_DB:
            if (SpellTargetPosition const* st = sSpellMgr->GetSpellTargetPosition(m_spellInfo->Id, effIndex))
            {
                if (m_spellInfo->HasEffect(SPELL_EFFECT_TELEPORT_UNITS) || m_spellInfo->HasEffect(SPELL_EFFECT_BIND))
                    dest = SpellDestination(st->target_X, st->target_Y, st->target_Z, st->target_Orientation, (int32)st->target_mapId);
                else if (st->target_mapId == m_caster->GetMapId())
                    dest = SpellDestination(st->target_X, st->target_Y, st->target_Z, st->target_Orientation);
            }
            else
            {
                LOG_DEBUG("spells.aura", "SPELL: unknown target coordinates for spell ID {}", m_spellInfo->Id);
                if (WorldObject* target = m_targets.GetObjectTarget())
                    dest = SpellDestination(*target);
            }
            break;
        case TARGET_DEST_CASTER_FISHING:
            {
                float min_dis = m_spellInfo->GetMinRange(true);
                float max_dis = m_spellInfo->GetMaxRange(true);
                float dis = (float)rand_norm() * (max_dis - min_dis) + min_dis;
                float x, y, z, angle;
                angle = (float)rand_norm() * static_cast<float>(M_PI * 35.0f / 180.0f) - static_cast<float>(M_PI * 17.5f / 180.0f);
                //m_caster->GetClosePoint(x, y, z, DEFAULT_WORLD_OBJECT_SIZE, dis, angle); this contains extra code that breaks fishing
                m_caster->GetNearPoint(m_caster, x, y, z, DEFAULT_WORLD_OBJECT_SIZE, dis, m_caster->GetOrientation() + angle);
 
                float ground = m_caster->GetMapHeight(x, y, z, true);
                float liquidLevel = VMAP_INVALID_HEIGHT_VALUE;
                LiquidData const& liquidData = m_caster->GetMap()->GetLiquidData(m_caster->GetPhaseMask(), x, y, z, m_caster->GetCollisionHeight(), {});
                if (liquidData.Status)
                    liquidLevel = liquidData.Level;
 
                if (liquidLevel <= ground) // When there is no liquid Map::GetWaterOrGroundLevel returns ground level
                {
                    SendCastResult(SPELL_FAILED_NOT_HERE);
                    SendChannelUpdate(0);
                    finish(false);
                    return;
                }
 
                if (ground + 0.75 > liquidLevel)
                {
                    SendCastResult(SPELL_FAILED_TOO_SHALLOW);
                    SendChannelUpdate(0);
                    finish(false);
                    return;
                }
 
                if (!m_caster->IsWithinLOS(x, y, z))
                {
                    SendCastResult(SPELL_FAILED_LINE_OF_SIGHT);
                    SendChannelUpdate(0);
                    finish(false);
                    return;
                }
 
                dest = SpellDestination(x, y, liquidLevel, m_caster->GetOrientation());
                break;
            }
        case TARGET_DEST_CASTER_FRONT_LEAP:
            {
                float distance = m_spellInfo->Effects[effIndex].CalcRadius(m_caster);
                Map* map = m_caster->GetMap();
                uint32 phasemask = m_caster->GetPhaseMask();
                float collisionHeight = m_caster->GetCollisionHeight();
                float destz = 0.0f, startx = 0.0f, starty = 0.0f, startz = 0.0f, starto = 0.0f;
 
                Position pos;
                Position lastpos;
                m_caster->GetPosition(startx, starty, startz, starto);
                pos.Relocate(startx, starty, startz, starto);
                float destx = pos.GetPositionX() + distance * cos(pos.GetOrientation());
                float desty = pos.GetPositionY() + distance * sin(pos.GetOrientation());
 
                // Added GROUND_HEIGHT_TOLERANCE to account for cases where, during a jump,
                // the Z position may be slightly below the vmap ground level.
                // Without this tolerance, a ray trace might incorrectly attempt to find ground
                // beneath the actual surface.
                //
                // Example:
                //    actual vmap ground: -56.342392
                //    Z position:         -56.347195
                float searchGroundZPos = pos.GetPositionZ()+GROUND_HEIGHT_TOLERANCE;
                float ground = map->GetHeight(phasemask, pos.GetPositionX(), pos.GetPositionY(), searchGroundZPos);
 
                bool isCasterInWater = m_caster->IsInWater();
                if (!m_caster->HasUnitMovementFlag(MOVEMENTFLAG_FALLING) || (pos.GetPositionZ() - ground < distance))
                {
                    float tstX = 0.0f, tstY = 0.0f, tstZ = 0.0f, prevX = 0.0f, prevY = 0.0f, prevZ = 0.0f;
                    float tstZ1 = 0.0f, tstZ2 = 0.0f, tstZ3 = 0.0f, destz1 = 0.0f, destz2 = 0.0f, destz3 = 0.0f, srange = 0.0f, srange1 = 0.0f, srange2 = 0.0f, srange3 = 0.0f;
                    float maxtravelDistZ = 2.65f;
                    float overdistance = 0.0f;
                    float totalpath = 0.0f;
                    float beforewaterz = 0.0f;
                    bool inwater = false;
                    bool wcol = false;
                    const float  step = 2.0f;
                    const uint8 numChecks = std::ceil(std::fabs(distance / step));
                    const float DELTA_X = (destx - pos.GetPositionX()) / numChecks;
                    const float DELTA_Y = (desty - pos.GetPositionY()) / numChecks;
                    int j = 1;
                    for (; j < (numChecks + 1); j++)
                    {
                        prevX = pos.GetPositionX() + (float(j - 1) * DELTA_X);
                        prevY = pos.GetPositionY() + (float(j - 1) * DELTA_Y);
                        tstX = pos.GetPositionX() + (float(j) * DELTA_X);
                        tstY = pos.GetPositionY() + (float(j) * DELTA_Y);
 
                        if (j < 2)
                        {
                            prevZ = pos.GetPositionZ();
                        }
                        else
                        {
                            prevZ = tstZ;
                        }
 
                        tstZ = map->GetHeight(phasemask, tstX, tstY, prevZ + maxtravelDistZ, true);
                        ground = tstZ;
 
                        if (!isCasterInWater)
                        {
                            if (map->IsInWater(phasemask, tstX, tstY, tstZ, collisionHeight))
                            {
                                if (!(beforewaterz != 0.0f))
                                {
                                    beforewaterz = prevZ;
                                }
                                tstZ = beforewaterz;
                                srange = sqrt((tstY - prevY) * (tstY - prevY) + (tstX - prevX) * (tstX - prevX));
                                //LOG_ERROR("spells", "(start was from land) step in water , number of cycle = {} , distance of step = {}, total path = {}, Z = {}", j, srange, totalpath, tstZ);
                            }
                        }
                        else if (map->IsInWater(phasemask, tstX, tstY, tstZ, collisionHeight))
                        {
                            prevZ = pos.GetPositionZ();
                            tstZ = pos.GetPositionZ();
                            srange = sqrt((tstY - prevY) * (tstY - prevY) + (tstX - prevX) * (tstX - prevX));
 
                            inwater = true;
                            if (inwater && (fabs(tstZ - ground) < 2.0f))
                            {
                                wcol = true;
                                //LOG_ERROR("spells", "step in water with collide and use standart check (for continue way after possible collide), number of cycle = {} ", j);
                            }
 
                            // if (j < 2)
                            //    LOG_ERROR("spells", "(start in water) step in water, number of cycle = {} , distance of step = {}, total path = {}", j, srange, totalpath);
                            // else
                            //    LOG_ERROR("spells", "step in water, number of cycle = {} , distance of step = {}, total path = {}", j, srange, totalpath);
                        }
 
                        bool IsInWater = map->IsInWater(phasemask, tstX, tstY, tstZ, collisionHeight);
                        if ((!IsInWater && tstZ != beforewaterz) || wcol)  // second safety check z for blink way if on the ground
                        {
                            if (inwater && !IsInWater)
                                inwater = false;
 
                            // highest available point
                            tstZ1 = map->GetHeight(phasemask, tstX, tstY, prevZ + maxtravelDistZ, true, 25.0f);
                            // upper or floor
                            tstZ2 = map->GetHeight(phasemask, tstX, tstY, prevZ, true, 25.0f);
                            //lower than floor
                            tstZ3 = map->GetHeight(phasemask, tstX, tstY, prevZ - maxtravelDistZ / 2, true, 25.0f);
 
                            //distance of rays, will select the shortest in 3D
                            srange1 = sqrt((tstY - prevY) * (tstY - prevY) + (tstX - prevX) * (tstX - prevX) + (tstZ1 - prevZ) * (tstZ1 - prevZ));
                            //LOG_ERROR("spells", "step = {}, distance of ray1 = {}", j, srange1);
                            srange2 = sqrt((tstY - prevY) * (tstY - prevY) + (tstX - prevX) * (tstX - prevX) + (tstZ2 - prevZ) * (tstZ2 - prevZ));
                            //LOG_ERROR("spells", "step = {}, distance of ray2 = {}", j, srange2);
                            srange3 = sqrt((tstY - prevY) * (tstY - prevY) + (tstX - prevX) * (tstX - prevX) + (tstZ3 - prevZ) * (tstZ3 - prevZ));
                            //LOG_ERROR("spells", "step = {}, distance of ray3 = {}", j, srange3);
 
                            if (srange1 < srange2)
                            {
                                tstZ = tstZ1;
                                srange = srange1;
                            }
                            else if (srange3 < srange2)
                            {
                                tstZ = tstZ3;
                                srange = srange3;
                            }
                            else
                            {
                                tstZ = tstZ2;
                                srange = srange2;
                            }
 
                            //LOG_ERROR("spells", "step on ground, number of cycle = {} , distance of step = {}, total path = {}", j, srange, totalpath);
                        }
 
                        destx = tstX;
                        desty = tstY;
                        destz = tstZ;
 
                        totalpath += srange;
 
                        if (totalpath > distance)
                        {
                            overdistance = totalpath - distance;
                            //LOG_ERROR("spells", "total path > than distance in 3D , need to move back a bit for save distance, total path = {}, overdistance = {}", totalpath, overdistance);
                        }
 
                        bool col = m_caster->GetMap()->GetMapCollisionData().GetStaticTree().GetObjectHitPos(prevX, prevY, prevZ + 0.5f, tstX, tstY, tstZ + 0.5f, tstX, tstY, tstZ, -0.5f);
                        // check dynamic collision
                        bool dcol = m_caster->GetMap()->GetMapCollisionData().GetDynamicTree().GetObjectHitPos(phasemask, prevX, prevY, prevZ + 0.5f, tstX, tstY, tstZ + 0.5f, tstX, tstY, tstZ, -0.5f);
 
                        // collision occured
                        if (col || dcol || (overdistance > 0.0f && !map->IsInWater(phasemask, tstX, tstY, ground, collisionHeight)) || (fabs(prevZ - tstZ) > maxtravelDistZ && (tstZ > prevZ)))
                        {
                            if ((overdistance > 0.0f) && (overdistance < 1.f))
                            {
                                destx = prevX + overdistance * cos(pos.GetOrientation());
                                desty = prevY + overdistance * sin(pos.GetOrientation());
                                //LOG_ERROR("spells", "(collision) collision occured 1");
                            }
                            else
                            {
                                // move back a bit
                                destx = tstX - (0.6 * cos(pos.GetOrientation()));
                                desty = tstY - (0.6 * sin(pos.GetOrientation()));
                                //LOG_ERROR("spells", "(collision) collision occured 2");
                            }
 
                            // highest available point
                            destz1 = map->GetHeight(phasemask, destx, desty, prevZ + maxtravelDistZ, true, 25.0f);
                            // upper or floor
                            destz2 = map->GetHeight(phasemask, destx, desty, prevZ, true, 25.0f);
                            //lower than floor
                            destz3 = map->GetHeight(phasemask, destx, desty, prevZ - maxtravelDistZ / 2, true, 25.0f);
 
                            //distance of rays, will select the shortest in 3D
                            srange1 = sqrt((desty - prevY) * (desty - prevY) + (destx - prevX) * (destx - prevX) + (destz1 - prevZ) * (destz1 - prevZ));
                            srange2 = sqrt((desty - prevY) * (desty - prevY) + (destx - prevX) * (destx - prevX) + (destz2 - prevZ) * (destz2 - prevZ));
                            srange3 = sqrt((desty - prevY) * (desty - prevY) + (destx - prevX) * (destx - prevX) + (destz3 - prevZ) * (destz3 - prevZ));
 
                            if (srange1 < srange2)
                                destz = destz1;
                            else if (srange3 < srange2)
                                destz = destz3;
                            else
                                destz = destz2;
 
                            if (inwater && destz < prevZ && !wcol)
                                destz = prevZ;
                            //LOG_ERROR("spells", "(collision) destZ rewrited in prevZ");
 
                            // Don't make the player move backward from the xy adjustments by collisions.
                            if ((DELTA_X > 0 && startx > destx) || (DELTA_X < 0 && startx < destx) ||
                                (DELTA_Y > 0 && starty > desty) || (DELTA_Y < 0 && starty < desty))
                            {
                                destx = startx;
                                desty = starty;
                                destz = startz;
                            }
 
                            break;
                        }
                        // we have correct destz now
                    }
 
                    lastpos.Relocate(destx, desty, destz, pos.GetOrientation());
                    dest = SpellDestination(lastpos);
                }
                else
                {
                    float z = pos.GetPositionZ();
                    bool col = m_caster->GetMap()->GetMapCollisionData().GetStaticTree().GetObjectHitPos(pos.GetPositionX(), pos.GetPositionY(), z, destx, desty, z, destx, desty, z, -0.5f);
                    // check dynamic collision
                    bool dcol = m_caster->GetMap()->GetMapCollisionData().GetDynamicTree().GetObjectHitPos(phasemask, pos.GetPositionX(), pos.GetPositionY(), z, destx, desty, z, destx, desty, z, -0.5f);
 
                    // collision occured
                    if (col || dcol)
                    {
                        // move back a bit
                        destx = destx - (0.6 * cos(pos.GetOrientation()));
                        desty = desty - (0.6 * sin(pos.GetOrientation()));
                    }
 
                    lastpos.Relocate(destx, desty, z, pos.GetOrientation());
                    dest = SpellDestination(lastpos);
                    //float range = sqrt((desty - pos.GetPositionY())*(desty - pos.GetPositionY()) + (destx - pos.GetPositionX())*(destx - pos.GetPositionX()));
                    //LOG_ERROR("spells", "Blink number 2, in falling but at a hight, distance of blink = {}", range);
                }
                break;
            }
        default:
            {
                float dist = m_spellInfo->Effects[effIndex].CalcRadius(m_caster);
                float angle = targetType.CalcDirectionAngle();
                float objSize = m_caster->GetCombatReach();
 
                switch (targetType.GetTarget())
                {
                case TARGET_DEST_CASTER_SUMMON:
                    dist = PET_FOLLOW_DIST;
                    break;
                case TARGET_DEST_CASTER_RANDOM:
                    if (dist > objSize)
                        dist = objSize + (dist - objSize) * float(rand_norm());
                    break;
                case TARGET_DEST_CASTER_FRONT_LEFT:
                case TARGET_DEST_CASTER_BACK_LEFT:
                case TARGET_DEST_CASTER_FRONT_RIGHT:
                case TARGET_DEST_CASTER_BACK_RIGHT:
                {
                    static float const DefaultTotemDistance = 3.0f;
                    if (!m_spellInfo->Effects[effIndex].HasRadius())
                        dist = DefaultTotemDistance;
                    break;
                }
                default:
                    break;
                }
 
                if (dist < objSize)
                {
                    dist = objSize;
                }
 
                Position pos = dest._position;
                m_caster->MovePositionToFirstCollision(pos, dist, angle);
 
                dest.Relocate(pos);
                break;
            }
    }
 
    CallScriptDestinationTargetSelectHandlers(dest, effIndex, targetType);
    m_targets.SetDst(dest);
}

Referenced by SelectEffectImplicitTargets().

◆ SelectImplicitCasterObjectTargets()

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

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

Referenced by SelectEffectImplicitTargets().

◆ SelectImplicitChainTargets()

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

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

References AddUnitTarget(), CallScriptObjectAreaTargetSelectHandlers(), SpellInfo::Effects, SpellImplicitTargetInfo::GetCheckType(), SpellImplicitTargetInfo::GetObjectType(), SpellImplicitTargetInfo::GetSelectionCategory(), Unit::GetSpellModOwner(), SpellImplicitTargetInfo::GetTarget(), SpellInfo::Id, m_applyMultiplierMask, m_caster, m_damageMultipliers, m_spellInfo, MAX_SPELL_EFFECTS, SearchChainTargets(), SPELLMOD_JUMP_TARGETS, TARGET_UNIT_TARGET_CHAINHEAL_ALLY, Object::ToUnit(), and unitTarget.

Referenced by SelectImplicitNearbyTargets(), and SelectImplicitTargetObjectTargets().

◆ SelectImplicitChannelTargets()

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

{
    if (targetType.GetReferenceType() != TARGET_REFERENCE_TYPE_CASTER)
    {
        ASSERT(false && "Spell::SelectImplicitChannelTargets: received not implemented target reference type");
        return;
    }
 
    switch (targetType.GetTarget())
    {
        case TARGET_UNIT_CHANNEL_TARGET:
            {
                // Xinef: All channel selectors have needed data passed in m_targets structure
                WorldObject* target = m_targets.GetObjectTargetChannel(m_caster);
                if (target)
                {
                    CallScriptObjectTargetSelectHandlers(target, effIndex, targetType);
                    // unit target may be no longer avalible - teleported out of map for example
                    if (target && target->ToUnit())
                        AddUnitTarget(target->ToUnit(), 1 << effIndex);
                }
                else
                {
                    LOG_DEBUG("spells.aura", "SPELL: cannot find channel spell target for spell ID {}, effect {}", m_spellInfo->Id, effIndex);
                }
                break;
            }
        case TARGET_DEST_CHANNEL_TARGET:
            if (m_targets.HasDstChannel())
                m_targets.SetDst(*m_targets.GetDstChannel());
            else if (WorldObject* target = m_targets.GetObjectTargetChannel(m_caster))
            {
                CallScriptObjectTargetSelectHandlers(target, effIndex, targetType);
                if (target)
                    m_targets.SetDst(*target);
            }
            else if (Spell* channeledSpell = m_originalCaster->GetCurrentSpell(CURRENT_CHANNELED_SPELL))
            {
                if (channeledSpell->m_targets.GetUnitTarget())
                    m_targets.SetDst(*channeledSpell->m_targets.GetUnitTarget());
            }
            else //if (!m_targets.HasDst())
            {
                LOG_DEBUG("spells.aura", "SPELL: cannot find channel spell destination for spell ID {}, effect {}", m_spellInfo->Id, effIndex);
            }
            break;
        case TARGET_DEST_CHANNEL_CASTER:
            if (GetOriginalCaster())
                m_targets.SetDst(*GetOriginalCaster());
            break;
        default:
            ASSERT(false && "Spell::SelectImplicitChannelTargets: received not implemented target type");
            break;
    }
}

References AddUnitTarget(), ASSERT, CallScriptObjectTargetSelectHandlers(), CURRENT_CHANNELED_SPELL, Unit::GetCurrentSpell(), SpellCastTargets::GetDstChannel(), SpellCastTargets::GetObjectTargetChannel(), GetOriginalCaster(), SpellImplicitTargetInfo::GetReferenceType(), SpellImplicitTargetInfo::GetTarget(), SpellCastTargets::HasDstChannel(), SpellInfo::Id, LOG_DEBUG, m_caster, m_originalCaster, m_spellInfo, m_targets, SpellCastTargets::SetDst(), TARGET_DEST_CHANNEL_CASTER, TARGET_DEST_CHANNEL_TARGET, TARGET_REFERENCE_TYPE_CASTER, TARGET_UNIT_CHANNEL_TARGET, and Object::ToUnit().

Referenced by SelectEffectImplicitTargets().

◆ SelectImplicitConeTargets()

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

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

References AddGOTarget(), AddUnitTarget(), ASSERT, CallScriptObjectAreaTargetSelectHandlers(), SpellInfo::Effects, SpellImplicitTargetInfo::GetCheckType(), SpellImplicitTargetInfo::GetObjectType(), SpellImplicitTargetInfo::GetReferenceType(), GetSearcherTypeMask(), Unit::GetTotalAuraModifierByAffectMask(), m_caster, m_spellInfo, m_spellValue, SpellValue::MaxAffectedTargets, SpellValue::RadiusMod, Acore::Containers::RandomResize(), SPELL_AURA_MOD_MAX_AFFECTED_TARGETS, TARGET_REFERENCE_TYPE_CASTER, Object::ToGameObject(), and Object::ToUnit().

Referenced by SelectEffectImplicitTargets().

◆ SelectImplicitDestDestTargets()

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

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

References SpellDestination::_position, SpellImplicitTargetInfo::CalcDirectionAngle(), CallScriptDestinationTargetSelectHandlers(), CheckDst(), SpellInfo::Effects, SpellCastTargets::GetDst(), SpellImplicitTargetInfo::GetTarget(), m_caster, m_spellInfo, m_targets, SpellCastTargets::ModDst(), WorldObject::MovePosition(), rand_norm(), SpellDestination::Relocate(), TARGET_DEST_DEST, TARGET_DEST_DEST_RANDOM, TARGET_DEST_DYNOBJ_ALLY, TARGET_DEST_DYNOBJ_ENEMY, and TARGET_DEST_DYNOBJ_NONE.

Referenced by SelectEffectImplicitTargets().

◆ SelectImplicitNearbyTargets()

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

{
    if (targetType.GetReferenceType() != TARGET_REFERENCE_TYPE_CASTER)
    {
        ASSERT(false && "Spell::SelectImplicitNearbyTargets: received not implemented target reference type");
        return;
    }
 
    float range = 0.0f;
    switch (targetType.GetCheckType())
    {
        case TARGET_CHECK_ENEMY:
            range = m_spellInfo->GetMaxRange(false, m_caster, this);
            break;
        case TARGET_CHECK_ALLY:
        case TARGET_CHECK_PARTY:
        case TARGET_CHECK_RAID:
        case TARGET_CHECK_RAID_CLASS:
            range = m_spellInfo->GetMaxRange(true, m_caster, this);
            break;
        case TARGET_CHECK_ENTRY:
        case TARGET_CHECK_DEFAULT:
            range = m_spellInfo->GetMaxRange(m_spellInfo->IsPositive(), m_caster, this);
            break;
        default:
            ASSERT(false && "Spell::SelectImplicitNearbyTargets: received not implemented selection check type");
            break;
    }
 
    ConditionList* condList = m_spellInfo->Effects[effIndex].ImplicitTargetConditions;
 
    // handle emergency case - try to use other provided targets if no conditions provided
    if (targetType.GetCheckType() == TARGET_CHECK_ENTRY && (!condList || condList->empty()))
    {
        LOG_DEBUG("spells.aura", "Spell::SelectImplicitNearbyTargets: no conditions entry for target with TARGET_CHECK_ENTRY of spell ID {}, effect {} - selecting default targets", m_spellInfo->Id, effIndex);
        switch (targetType.GetObjectType())
        {
            case TARGET_OBJECT_TYPE_GOBJ:
                if (m_spellInfo->RequiresSpellFocus)
                {
                    if (focusObject)
                        AddGOTarget(focusObject, effMask);
                    return;
                }
                break;
            case TARGET_OBJECT_TYPE_DEST:
                if (m_spellInfo->RequiresSpellFocus)
                {
                    if (focusObject)
                        m_targets.SetDst(*focusObject);
                    return;
                }
                break;
            default:
                break;
        }
    }
 
    WorldObject* target = SearchNearbyTarget(range, targetType.GetObjectType(), targetType.GetCheckType(), condList);
    if (!target)
    {
        LOG_DEBUG("spells.aura", "Spell::SelectImplicitNearbyTargets: cannot find nearby target for spell ID {}, effect {}", m_spellInfo->Id, effIndex);
        return;
    }
 
    CallScriptObjectTargetSelectHandlers(target, effIndex, targetType);
    if (!target)
    {
        //LOG_DEBUG("spells", "Spell::SelectImplicitNearbyTargets: OnObjectTargetSelect script hook for spell Id {} set nullptr target, effect {}", m_spellInfo->Id, effIndex);
        return;
    }
 
    switch (targetType.GetObjectType())
    {
        case TARGET_OBJECT_TYPE_UNIT:
            {
                if (Unit* unit = target->ToUnit())
                {
                    AddUnitTarget(unit, effMask, true, false);
                    // xinef: important! if channeling spell have nearby entry, it has no unitTarget by default
                    // and if channeled spell has target 77, it requires unitTarget, set it here!
                    // xinef: if we have NO unit target
                    if (!m_targets.GetUnitTarget())
                    {
                        m_targets.SetUnitTarget(unit);
                    }
                }
                else
                {
                    //LOG_DEBUG("spells", "Spell::SelectImplicitNearbyTargets: OnObjectTargetSelect script hook for spell Id {} set object of wrong type, expected unit, got {}, effect {}", m_spellInfo->Id, target->GetGUID().GetTypeName(), effMask);
                    return;
                }
                break;
            }
        case TARGET_OBJECT_TYPE_GOBJ:
            if (GameObject* gobjTarget = target->ToGameObject())
                AddGOTarget(gobjTarget, effMask);
            else
            {
                //LOG_DEBUG("spells", "Spell::SelectImplicitNearbyTargets: OnObjectTargetSelect script hook for spell Id {} set object of wrong type, expected gameobject, got {}, effect {}", m_spellInfo->Id, target->GetGUID().GetTypeName(), effMask);
                return;
            }
            break;
        case TARGET_OBJECT_TYPE_DEST:
            m_targets.SetDst(*target);
            break;
        default:
            ASSERT(false && "Spell::SelectImplicitNearbyTargets: received not implemented target object type");
            break;
    }
 
    SelectImplicitChainTargets(effIndex, targetType, target, effMask);
}

References AddGOTarget(), AddUnitTarget(), ASSERT, CallScriptObjectTargetSelectHandlers(), SpellInfo::Effects, focusObject, SpellImplicitTargetInfo::GetCheckType(), SpellInfo::GetMaxRange(), SpellImplicitTargetInfo::GetObjectType(), SpellImplicitTargetInfo::GetReferenceType(), SpellCastTargets::GetUnitTarget(), SpellInfo::Id, SpellInfo::IsPositive(), LOG_DEBUG, m_caster, m_spellInfo, m_targets, SpellInfo::RequiresSpellFocus, SearchNearbyTarget(), SelectImplicitChainTargets(), SpellCastTargets::SetDst(), SpellCastTargets::SetUnitTarget(), TARGET_CHECK_ALLY, TARGET_CHECK_DEFAULT, TARGET_CHECK_ENEMY, TARGET_CHECK_ENTRY, TARGET_CHECK_PARTY, TARGET_CHECK_RAID, TARGET_CHECK_RAID_CLASS, TARGET_OBJECT_TYPE_DEST, TARGET_OBJECT_TYPE_GOBJ, TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, Object::ToGameObject(), and Object::ToUnit().

Referenced by SelectEffectImplicitTargets().

◆ SelectImplicitTargetDestTargets()

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

{
    WorldObject* target = m_targets.GetObjectTarget();
 
    SpellDestination dest(*target);
 
    switch (targetType.GetTarget())
    {
        case TARGET_DEST_TARGET_ENEMY:
        case TARGET_DEST_TARGET_ANY:
            break;
        default:
        {
            float angle = targetType.CalcDirectionAngle();
            float dist = m_spellInfo->Effects[effIndex].CalcRadius(nullptr);
            if (targetType.GetTarget() == TARGET_DEST_TARGET_RANDOM)
            {
                dist *= float(rand_norm());
            }
 
            if (targetType.GetTarget() == TARGET_DEST_TARGET_BACK)
            {
                dist += target->GetFloatValue(UNIT_FIELD_BOUNDINGRADIUS);
            }
 
            Position pos = dest._position;
            target->MovePositionToFirstCollision(pos, dist, angle);
 
            dest.Relocate(pos);
            break;
        }
    }
 
    CallScriptDestinationTargetSelectHandlers(dest, effIndex, targetType);
    m_targets.SetDst(dest);
}

References SpellDestination::_position, SpellImplicitTargetInfo::CalcDirectionAngle(), CallScriptDestinationTargetSelectHandlers(), SpellInfo::Effects, Object::GetFloatValue(), SpellCastTargets::GetObjectTarget(), SpellImplicitTargetInfo::GetTarget(), m_spellInfo, m_targets, WorldObject::MovePositionToFirstCollision(), rand_norm(), SpellDestination::Relocate(), SpellCastTargets::SetDst(), TARGET_DEST_TARGET_ANY, TARGET_DEST_TARGET_BACK, TARGET_DEST_TARGET_ENEMY, TARGET_DEST_TARGET_RANDOM, and UNIT_FIELD_BOUNDINGRADIUS.

Referenced by SelectEffectImplicitTargets().

◆ SelectImplicitTargetObjectTargets()

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

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

References AddGOTarget(), AddItemTarget(), AddUnitTarget(), ASSERT, CallScriptObjectTargetSelectHandlers(), SpellCastTargets::GetItemTarget(), SpellCastTargets::GetObjectTarget(), m_targets, SelectImplicitChainTargets(), Object::ToGameObject(), and Object::ToUnit().

Referenced by SelectEffectImplicitTargets().

◆ SelectImplicitTrajTargets()

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

{
    if (!m_targets.HasTraj())
        return;
 
    float dist2d = m_targets.GetDist2d();
    if (!dist2d)
        return;
 
    Position srcPos = *m_targets.GetSrcPos();
    srcPos.SetOrientation(m_caster->GetOrientation());
    float srcToDestDelta = m_targets.GetDstPos()->m_positionZ - srcPos.m_positionZ;
 
    std::list<WorldObject*> targets;
    Acore::WorldObjectSpellTrajTargetCheck check(dist2d, &srcPos, m_caster, m_spellInfo, targetType.GetCheckType(), m_spellInfo->Effects[effIndex].ImplicitTargetConditions);
    Acore::WorldObjectListSearcher<Acore::WorldObjectSpellTrajTargetCheck> searcher(m_caster, targets, check, GRID_MAP_TYPE_MASK_ALL);
    SearchTargets<Acore::WorldObjectListSearcher<Acore::WorldObjectSpellTrajTargetCheck> > (searcher, GRID_MAP_TYPE_MASK_ALL, m_caster, &srcPos, dist2d);
    if (targets.empty())
        return;
 
    targets.sort(Acore::ObjectDistanceOrderPred(m_caster));
 
    float b = tangent(m_targets.GetElevation());
    float a = (srcToDestDelta - dist2d * b) / (dist2d * dist2d);
    if (a > -0.0001f)
        a = 0.f;
 
    // We should check if triggered spell has greater range (which is true in many cases, and initial spell has too short max range)
    // limit max range to 300 yards, sometimes triggered spells can have 50000yds
    float bestDist = m_spellInfo->GetMaxRange(false);
    if (SpellInfo const* triggerSpellInfo = sSpellMgr->GetSpellInfo(m_spellInfo->Effects[effIndex].TriggerSpell))
        bestDist = std::min(std::max(bestDist, triggerSpellInfo->GetMaxRange(false)), std::min(dist2d, 300.0f));
 
    // GameObjects don't cast traj
    Unit* unitCaster = ASSERT_NOTNULL(m_caster->ToUnit());
    for (auto itr = targets.begin(); itr != targets.end(); ++itr)
    {
        if (m_spellInfo->CheckTarget(unitCaster, *itr, true) != SPELL_CAST_OK)
            continue;
 
        if (Unit* unit = (*itr)->ToUnit())
        {
            if (unitCaster == *itr || unitCaster->IsOnVehicle(unit) || unit->GetVehicle())
                continue;
 
            if (Creature* creatureTarget = unit->ToCreature())
            {
                if (!(creatureTarget->GetCreatureTemplate()->type_flags & CREATURE_TYPE_FLAG_COLLIDE_WITH_MISSILES))
                    continue;
            }
        }
 
        float const size = std::max((*itr)->GetCombatReach(), 1.0f);
        float const objDist2d = srcPos.GetExactDist2d(*itr);
        float const dz = (*itr)->GetPositionZ() - srcPos.m_positionZ;
 
        float const horizontalDistToTraj = std::fabs(objDist2d * std::sin(srcPos.GetRelativeAngle(*itr)));
        float const sizeFactor = std::cos((horizontalDistToTraj / size) * (M_PI / 2.0f));
        float const distToHitPoint = std::max(objDist2d * std::cos(srcPos.GetRelativeAngle(*itr)) - size * sizeFactor, 0.0f);
        float const height = distToHitPoint * (a * distToHitPoint + b);
 
        if (fabs(dz - height) > size + b / 2.0f + TRAJECTORY_MISSILE_SIZE)
            continue;
 
        if (distToHitPoint < bestDist)
        {
            bestDist = distToHitPoint;
            break;
        }
    }
 
    if (dist2d > bestDist)
    {
        float x = m_targets.GetSrcPos()->m_positionX + std::cos(unitCaster->GetOrientation()) * bestDist;
        float y = m_targets.GetSrcPos()->m_positionY + std::sin(unitCaster->GetOrientation()) * bestDist;
        float z = m_targets.GetSrcPos()->m_positionZ + bestDist * (a * bestDist + b);
 
        SpellDestination dest(x, y, z, unitCaster->GetOrientation());
        CallScriptDestinationTargetSelectHandlers(dest, effIndex, targetType);
        m_targets.ModDst(dest);
    }
}

References ASSERT_NOTNULL, CallScriptDestinationTargetSelectHandlers(), SpellInfo::CheckTarget(), CREATURE_TYPE_FLAG_COLLIDE_WITH_MISSILES, SpellInfo::Effects, SpellImplicitTargetInfo::GetCheckType(), SpellCastTargets::GetDist2d(), SpellCastTargets::GetDstPos(), SpellCastTargets::GetElevation(), Position::GetExactDist2d(), SpellInfo::GetMaxRange(), Position::GetOrientation(), Position::GetRelativeAngle(), SpellCastTargets::GetSrcPos(), GRID_MAP_TYPE_MASK_ALL, SpellCastTargets::HasTraj(), Unit::IsOnVehicle(), m_caster, Position::m_positionX, Position::m_positionY, Position::m_positionZ, m_spellInfo, m_targets, SpellCastTargets::ModDst(), Position::SetOrientation(), SPELL_CAST_OK, sSpellMgr, tangent(), Object::ToCreature(), Object::ToUnit(), and TRAJECTORY_MISSILE_SIZE.

Referenced by SelectEffectImplicitTargets().

◆ SelectSpellTargets()

void Spell::SelectSpellTargets ( )

{
    // select targets for cast phase
    SelectExplicitTargets();
 
    uint32 processedAreaEffectsMask = 0;
    for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        // not call for empty effect.
        // Also some spells use not used effect targets for store targets for dummy effect in triggered spells
        if (!m_spellInfo->Effects[i].IsEffect())
            continue;
 
        // set expected type of implicit targets to be sent to client
        uint32 implicitTargetMask = GetTargetFlagMask(m_spellInfo->Effects[i].TargetA.GetObjectType()) | GetTargetFlagMask(m_spellInfo->Effects[i].TargetB.GetObjectType());
        if (implicitTargetMask & TARGET_FLAG_UNIT)
            m_targets.SetTargetFlag(TARGET_FLAG_UNIT);
        if (implicitTargetMask & (TARGET_FLAG_GAMEOBJECT | TARGET_FLAG_GAMEOBJECT_ITEM))
            m_targets.SetTargetFlag(TARGET_FLAG_GAMEOBJECT);
 
        SelectEffectImplicitTargets(SpellEffIndex(i), m_spellInfo->Effects[i].TargetA, processedAreaEffectsMask);
        SelectEffectImplicitTargets(SpellEffIndex(i), m_spellInfo->Effects[i].TargetB, processedAreaEffectsMask);
 
        // Select targets of effect based on effect type
        // those are used when no valid target could be added for spell effect based on spell target type
        // some spell effects use explicit target as a default target added to target map (like SPELL_EFFECT_LEARN_SPELL)
        // some spell effects add target to target map only when target type specified (like SPELL_EFFECT_WEAPON)
        // some spell effects don't add anything to target map (confirmed with sniffs) (like SPELL_EFFECT_DESTROY_ALL_TOTEMS)
        SelectEffectTypeImplicitTargets(i);
 
        if (m_targets.HasDst())
            AddDestTarget(*m_targets.GetDst(), i);
 
        if (m_spellInfo->IsChanneled())
        {
            // maybe do this for all spells?
            if (!focusObject && m_UniqueTargetInfo.empty() && m_UniqueGOTargetInfo.empty() && m_UniqueItemInfo.empty() && !m_targets.HasDst())
            {
                SendCastResult(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
                finish(false);
                return;
            }
 
            uint8 mask = (1 << i);
            for (auto ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
            {
                if (ihit->effectMask & mask)
                {
                    m_channelTargetEffectMask |= mask;
                    break;
                }
            }
        }
        else if (m_auraScaleMask)
        {
            bool checkLvl = !m_UniqueTargetInfo.empty();
            m_UniqueTargetInfo.erase(std::remove_if(std::begin(m_UniqueTargetInfo), std::end(m_UniqueTargetInfo), [&](TargetInfo const& targetInfo) -> bool
            {
                // remove targets which did not pass min level check
                if (m_auraScaleMask && targetInfo.effectMask == m_auraScaleMask)
                {
                    if (!targetInfo.scaleAura && targetInfo.targetGUID != m_caster->GetGUID())
                        return true;
                }
 
                return false;
            }), std::end(m_UniqueTargetInfo));
 
            if (checkLvl && m_UniqueTargetInfo.empty())
            {
                SendCastResult(SPELL_FAILED_LOWLEVEL);
                finish(false);
            }
        }
    }
 
    if (uint64 dstDelay = CalculateDelayMomentForDst())
        m_delayMoment = dstDelay;
}

References AddDestTarget(), CalculateDelayMomentForDst(), TargetInfo::effectMask, SpellInfo::Effects, finish(), focusObject, SpellCastTargets::GetDst(), GetTargetFlagMask(), SpellCastTargets::HasDst(), SpellInfo::IsChanneled(), m_auraScaleMask, m_channelTargetEffectMask, m_delayMoment, m_spellInfo, m_targets, m_UniqueGOTargetInfo, m_UniqueItemInfo, m_UniqueTargetInfo, MAX_SPELL_EFFECTS, SelectEffectImplicitTargets(), SelectEffectTypeImplicitTargets(), SelectExplicitTargets(), SendCastResult(), SpellCastTargets::SetTargetFlag(), SPELL_FAILED_BAD_IMPLICIT_TARGETS, SPELL_FAILED_LOWLEVEL, TARGET_FLAG_GAMEOBJECT, TARGET_FLAG_GAMEOBJECT_ITEM, and TARGET_FLAG_UNIT.

Referenced by _cast(), CanAutoCast(), spell_dk_raise_dead::CheckCast(), and prepare().

◆ SendCastResult() [1/2]

void Spell::SendCastResult	(	Player *	caster,
		SpellInfo const *	spellInfo,
		uint8	castCount,
		SpellCastResult	result,
		SpellCustomErrors	customError = `SPELL_CUSTOM_ERROR_NONE`
	)

static

{
    if (result == SPELL_CAST_OK)
        return;
 
    WorldPacket data(SMSG_CAST_FAILED, 1 + 4 + 1);
    WriteCastResultInfo(data, caster, spellInfo, castCount, result, customError);
 
    caster->SendDirectMessage(&data);
}

References Player::SendDirectMessage(), SMSG_CAST_FAILED, SPELL_CAST_OK, and WriteCastResultInfo().

Referenced by _cast(), Unit::AttackerStateUpdate(), cancel(), Player::CastItemUseSpell(), spell_q12237_rescue_villager::CheckCast(), spell_q12237_drop_off_villager::CheckCast(), spell_the_cleansing_shrine_cast::CheckCast(), spell_dk_raise_dead::CheckReagents(), spell_putricide_mutation_init::CheckRequirement(), spell_ulduar_teleporter::CheckRequirement(), EffectApplyGlyph(), EffectDuel(), EffectOpenLock(), EffectTaunt(), SpellScript::FinishCast(), go_soulwell::go_soulwellAI::GossipHello(), WorldSession::HandleAcceptTradeOpcode(), WorldSession::HandleCastSpellOpcode(), spell_the_flag_of_ownership::HandleFinish(), WorldSession::HandlePetActionHelper(), spell_putricide_mutated_transformation::HandleSummon(), misc_commandscript::HandleUnstuckCommand(), icecrown_citadel_teleport::OnGossipSelect(), at_frozen_throne_teleport::OnTrigger(), item_petrov_cluster_bombs::OnUse(), item_only_for_flight::OnUse(), prepare(), SelectImplicitCasterDestTargets(), SelectSpellTargets(), and SendCastResult().

◆ SendCastResult() [2/2]

void Spell::SendCastResult ( SpellCastResult result )

{
    if (result == SPELL_CAST_OK)
        return;
 
    if (!m_caster->IsPlayer() || m_caster->IsCharmed())
        return;
 
    if (m_caster->ToPlayer()->GetSession()->PlayerLoading())  // don't send cast results at loading time
        return;
 
    // Xinef: override every possible result, except for gm fail result... breaks many things and goes unnoticed because of this and makes me rage when i find this out
    if (HasTriggeredCastFlag(TRIGGERED_DONT_REPORT_CAST_ERROR) && result != SPELL_FAILED_BM_OR_INVISGOD)
        result = SPELL_FAILED_DONT_REPORT;
 
    SendCastResult(m_caster->ToPlayer(), m_spellInfo, m_cast_count, result, m_customError);
}

References Player::GetSession(), HasTriggeredCastFlag(), Unit::IsCharmed(), Object::IsPlayer(), m_cast_count, m_caster, m_customError, m_spellInfo, WorldSession::PlayerLoading(), SendCastResult(), SPELL_CAST_OK, SPELL_FAILED_BM_OR_INVISGOD, SPELL_FAILED_DONT_REPORT, Object::ToPlayer(), and TRIGGERED_DONT_REPORT_CAST_ERROR.

◆ SendChannelStart()

void Spell::SendChannelStart ( uint32 duration )

{
    ObjectGuid channelTarget = m_targets.GetObjectTargetGUID();
    if (!channelTarget && !m_spellInfo->NeedsExplicitUnitTarget())
        if (m_UniqueTargetInfo.size() + m_UniqueGOTargetInfo.size() == 1)   // this is for TARGET_SELECT_CATEGORY_NEARBY
            channelTarget = !m_UniqueTargetInfo.empty() ? m_UniqueTargetInfo.front().targetGUID : m_UniqueGOTargetInfo.front().targetGUID;
 
    WorldPacket data(MSG_CHANNEL_START, (8 + 4 + 4));
    data << m_caster->GetPackGUID();
    data << uint32(m_spellInfo->Id);
    data << uint32(duration);
 
    m_caster->SendMessageToSet(&data, true);
 
    if (m_caster->IsPlayer() && m_caster->ToPlayer()->NeedSendSpectatorData())
        ArenaSpectator::SendCommand_Spell(m_caster->FindMap(), m_caster->GetGUID(), "SPE", m_spellInfo->Id, -((int32)duration));
 
    m_timer = duration;
    if (channelTarget)
        m_caster->SetGuidValue(UNIT_FIELD_CHANNEL_OBJECT, channelTarget);
 
    m_caster->SetUInt32Value(UNIT_CHANNEL_SPELL, m_spellInfo->Id);
}

References WorldObject::FindMap(), Object::GetGUID(), SpellCastTargets::GetObjectTargetGUID(), Object::GetPackGUID(), SpellInfo::Id, Object::IsPlayer(), m_caster, m_spellInfo, m_targets, m_timer, m_UniqueGOTargetInfo, m_UniqueTargetInfo, MSG_CHANNEL_START, Player::NeedSendSpectatorData(), SpellInfo::NeedsExplicitUnitTarget(), ArenaSpectator::SendCommand_Spell(), WorldObject::SendMessageToSet(), Object::SetGuidValue(), Unit::SetUInt32Value(), Object::ToPlayer(), UNIT_CHANNEL_SPELL, and UNIT_FIELD_CHANNEL_OBJECT.

Referenced by handle_immediate().

◆ SendChannelUpdate()

void Spell::SendChannelUpdate ( uint32 time )

{
    if (time == 0)
    {
        m_caster->SetGuidValue(UNIT_FIELD_CHANNEL_OBJECT, ObjectGuid::Empty);
        m_caster->SetUInt32Value(UNIT_CHANNEL_SPELL, 0);
    }
 
    WorldPacket data(MSG_CHANNEL_UPDATE, 8 + 4);
    data << m_caster->GetPackGUID();
    data << uint32(time);
 
    m_caster->SendMessageToSet(&data, true);
}

References ObjectGuid::Empty, Object::GetPackGUID(), m_caster, MSG_CHANNEL_UPDATE, WorldObject::SendMessageToSet(), Object::SetGuidValue(), Unit::SetUInt32Value(), UNIT_CHANNEL_SPELL, and UNIT_FIELD_CHANNEL_OBJECT.

Referenced by cancel(), DelayedChannel(), Unit::FinishSpell(), prepare(), SelectImplicitCasterDestTargets(), and update().

◆ SendInterrupted()

void Spell::SendInterrupted ( uint8 result )

{
    WorldPacket data(SMSG_SPELL_FAILURE, (8 + 1 + 4 + 1));
    data << m_caster->GetPackGUID();
    data << uint8(m_cast_count);
    data << uint32(m_spellInfo->Id);
    data << uint8(result);
    m_caster->SendMessageToSet(&data, true);
 
    data.Initialize(SMSG_SPELL_FAILED_OTHER, (8 + 1 + 4 + 1));
    data << m_caster->GetPackGUID();
    data << uint8(m_cast_count);
    data << uint32(m_spellInfo->Id);
    data << uint8(result);
    m_caster->SendMessageToSet(&data, true);
}

References Object::GetPackGUID(), SpellInfo::Id, WorldPacket::Initialize(), m_cast_count, m_caster, m_spellInfo, WorldObject::SendMessageToSet(), SMSG_SPELL_FAILED_OTHER, and SMSG_SPELL_FAILURE.

Referenced by _cast(), Unit::AttackerStateUpdate(), and cancel().

◆ SendLogExecute()

void Spell::SendLogExecute ( )

{
    WorldPacket data(SMSG_SPELLLOGEXECUTE, (8 + 4 + 4 + 4 + 4 + 8));
 
    data << m_caster->GetPackGUID();
 
    data << uint32(m_spellInfo->Id);
 
    uint8 effCount = 0;
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (m_effectExecuteData[i])
            ++effCount;
    }
 
    if (!effCount)
        return;
 
    data << uint32(effCount);
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (!m_effectExecuteData[i])
            continue;
 
        data << uint32(m_spellInfo->Effects[i].Effect);             // spell effect
 
        data.append(*m_effectExecuteData[i]);
 
        delete m_effectExecuteData[i];
        m_effectExecuteData[i] = nullptr;
    }
    m_caster->SendMessageToSet(&data, true);
}

References ByteBuffer::append(), SpellInfo::Effects, Object::GetPackGUID(), SpellInfo::Id, m_caster, m_effectExecuteData, m_spellInfo, MAX_SPELL_EFFECTS, WorldObject::SendMessageToSet(), and SMSG_SPELLLOGEXECUTE.

Referenced by FinishTargetProcessing().

◆ SendLoot()

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

protected

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

References GameObject::AI(), GameObjectTemplate::button, GameObjectTemplate::chest, GAMEOBJECT_TYPE_BUTTON, GAMEOBJECT_TYPE_CHEST, GAMEOBJECT_TYPE_DOOR, GAMEOBJECT_TYPE_GOOBER, GAMEOBJECT_TYPE_QUESTGIVER, GAMEOBJECT_TYPE_SPELL_FOCUS, gameObjTarget, GameObject::GetGOInfo(), GameObject::GetGoType(), Object::GetGUID(), WorldObject::GetName(), GameObjectAI::GossipHello(), GameObjectTemplate::gossipID, Player::IsGameMaster(), GameObject::isSpawned(), GameObjectTemplate::linkedTrap, GameObjectTemplate::linkedTrapId, LOG_ERROR, m_caster, Player::PrepareGossipMenu(), GameObjectTemplate::questgiver, Player::SendLoot(), Player::SendPreparedGossip(), GameObjectTemplate::spellFocus, sScriptMgr, Object::ToPlayer(), ObjectGuid::ToString(), GameObject::TriggeringLinkedGameObject(), GameObject::Use(), and GameObject::UseDoorOrButton().

Referenced by EffectOpenLock().

◆ SendPetCastResult()

void Spell::SendPetCastResult ( SpellCastResult result )

{
    if (result == SPELL_CAST_OK)
        return;
 
    Unit* owner = m_caster->GetCharmerOrOwner();
    if (!owner)
        return;
 
    Player* player = owner->ToPlayer();
    if (!player)
        return;
 
    WorldPacket data(SMSG_PET_CAST_FAILED, 1 + 4 + 1);
    WriteCastResultInfo(data, player, m_spellInfo, m_cast_count, result, m_customError);
 
    player->SendDirectMessage(&data);
}

References Unit::GetCharmerOrOwner(), m_cast_count, m_caster, m_customError, m_spellInfo, Player::SendDirectMessage(), SMSG_PET_CAST_FAILED, SPELL_CAST_OK, Object::ToPlayer(), and WriteCastResultInfo().

Referenced by WorldSession::HandlePetActionHelper(), and WorldSession::HandlePetCastSpellOpcode().

◆ SendResurrectRequest()

void Spell::SendResurrectRequest ( Player * target )

{
    // get resurrector name for creature resurrections, otherwise packet will be not accepted
    // for player resurrections the name is looked up by guid
    std::string const sentName(m_caster->IsPlayer()
                               ? ""
                               : m_caster->GetNameForLocaleIdx(target->GetSession()->GetSessionDbLocaleIndex()));
 
    WorldPacket data(SMSG_RESURRECT_REQUEST, (8 + 4 + sentName.size() + 1 + 1 + 1 + 4));
    data << m_caster->GetGUID();
    data << uint32(sentName.size() + 1);
 
    data << sentName;
    data << uint8(0); // null terminator
 
    data << uint8(m_caster->IsPlayer() ? 0 : 1); // "you'll be afflicted with resurrection sickness"
    // override delay sent with SMSG_CORPSE_RECLAIM_DELAY, set instant resurrection for spells with this attribute
    if (m_spellInfo->HasAttribute(SPELL_ATTR3_NO_RES_TIMER))
        data << uint32(0);
    target->SendDirectMessage(&data);
}

References Object::GetGUID(), WorldObject::GetNameForLocaleIdx(), Player::GetSession(), WorldSession::GetSessionDbLocaleIndex(), SpellInfo::HasAttribute(), Object::IsPlayer(), m_caster, m_spellInfo, Player::SendDirectMessage(), SMSG_RESURRECT_REQUEST, and SPELL_ATTR3_NO_RES_TIMER.

Referenced by EffectResurrect(), and EffectResurrectNew().

◆ SendSpellCooldown()

void Spell::SendSpellCooldown ( )

{
    // xinef: properly add creature cooldowns
    if (!m_caster->IsPlayer())
    {
        if (!HasTriggeredCastFlag(TRIGGERED_IGNORE_SPELL_AND_CATEGORY_CD))
        {
            // xinef: this should be added here
            //m_caster->AddSpellCooldown(m_spellInfo->Id, 0, 0);
 
            // xinef: this adds cooldowns to vehicle spells which misses them client-side (when we overwrote dbc info in eg.)
            if (m_spellInfo->RequireCooldownInfo())
                if (Player* player = m_caster->GetCharmerOrOwnerPlayerOrPlayerItself())
                {
                    WorldPacket data(SMSG_SPELL_COOLDOWN, 8 + 1 + 4 + 4);
                    data << m_caster->GetGUID();
                    data << uint8(SPELL_COOLDOWN_FLAG_INCLUDE_GCD);
                    data << uint32(m_spellInfo->Id);
                    data << uint32(m_spellInfo->RecoveryTime);
                    player->SendDirectMessage(&data);
                }
        }
        return;
    }
 
    Player* _player = m_caster->ToPlayer();
 
    // mana/health/etc potions, disabled by client (until combat out as declarate)
    if (m_CastItem && (m_CastItem->IsPotion() || m_spellInfo->IsCooldownStartedOnEvent()))
    {
        // need in some way provided data for Spell::finish SendCooldownEvent
        _player->SetLastPotionId(m_CastItem->GetEntry());
        return;
    }
 
    // have infinity cooldown but set at aura apply
    // do not set cooldown for triggered spells (needed by reincarnation)
    if (m_spellInfo->IsCooldownStartedOnEvent()
        || m_spellInfo->IsPassive()
        || (HasTriggeredCastFlag(TRIGGERED_IGNORE_SPELL_AND_CATEGORY_CD) && !m_CastItem)
        || HasTriggeredCastFlag(TRIGGERED_IGNORE_EFFECTS))
        return;
 
    _player->AddSpellAndCategoryCooldowns(m_spellInfo, m_CastItem ? m_CastItem->GetEntry() : 0, this);
}

References Player::AddSpellAndCategoryCooldowns(), Unit::GetCharmerOrOwnerPlayerOrPlayerItself(), Object::GetEntry(), Object::GetGUID(), HasTriggeredCastFlag(), SpellInfo::Id, SpellInfo::IsCooldownStartedOnEvent(), SpellInfo::IsPassive(), Object::IsPlayer(), Item::IsPotion(), m_caster, m_CastItem, m_spellInfo, SpellInfo::RecoveryTime, SpellInfo::RequireCooldownInfo(), Player::SetLastPotionId(), SMSG_SPELL_COOLDOWN, SPELL_COOLDOWN_FLAG_INCLUDE_GCD, Object::ToPlayer(), TRIGGERED_IGNORE_EFFECTS, and TRIGGERED_IGNORE_SPELL_AND_CATEGORY_CD.

Referenced by _cast().

◆ SendSpellGo()

void Spell::SendSpellGo ( )

{
    // not send invisible spell casting
    if (!IsNeedSendToClient(true))
        return;
 
    //LOG_DEBUG("spells.aura", "Sending SMSG_SPELL_GO id={}", m_spellInfo->Id);
 
    uint32 castFlags = CAST_FLAG_UNKNOWN_9;
 
    // triggered spells with spell visual != 0
    if (((IsTriggered() && !m_spellInfo->IsAutoRepeatRangedSpell()) || m_triggeredByAuraSpell) && !m_cast_count && !(m_spellInfo->IsChanneled() || (m_spellInfo->CastTimeEntry && m_spellInfo->CastTimeEntry->CastTime > 0)))
        castFlags |= CAST_FLAG_PENDING;
 
    if (m_spellInfo->HasAttribute(SPELL_ATTR0_USES_RANGED_SLOT) || m_spellInfo->HasAttribute(SPELL_ATTR0_CU_NEEDS_AMMO_DATA))
        castFlags |= CAST_FLAG_PROJECTILE;                        // arrows/bullets visual
 
    // should only be sent to self, but the current messaging doesn't make that possible
    if (m_caster->IsPlayer() || m_caster->IsPet())
    {
        switch (m_spellInfo->PowerType)
        {
            case POWER_HEALTH:
                break;
            case POWER_RUNE:
                castFlags |= CAST_FLAG_POWER_LEFT_SELF;
                break;
            default:
                if (m_powerCost != 0)
                {
                    castFlags |= CAST_FLAG_POWER_LEFT_SELF;
                }
                break;
        }
    }
 
    if ((m_caster->IsPlayer())
            && (m_caster->IsClass(CLASS_DEATH_KNIGHT, CLASS_CONTEXT_ABILITY))
            && m_spellInfo->RuneCostID
            && m_spellInfo->PowerType == POWER_RUNE)
    {
        castFlags |= CAST_FLAG_NO_GCD;                       // not needed, but Blizzard sends it
        castFlags |= CAST_FLAG_RUNE_LIST;                    // rune cooldowns list
    }
 
    if (m_spellInfo->HasEffect(SPELL_EFFECT_ACTIVATE_RUNE))
        castFlags |= CAST_FLAG_RUNE_LIST;                    // rune cooldowns list
 
    if (m_targets.HasTraj())
        castFlags |= CAST_FLAG_ADJUST_MISSILE;
 
    if (!m_spellInfo->StartRecoveryTime)
        castFlags |= CAST_FLAG_NO_GCD;
 
    PackedGuid realCasterGUID = m_caster->GetPackGUID();
    if (TempSummon const* tempSummon = m_caster->ToTempSummon())
    {
        if (tempSummon->GetEntry() == WORLD_TRIGGER)
        {
            if (GameObject* casterGameobject = tempSummon->GetSummonerGameObject())
            {
                realCasterGUID = casterGameobject->GetPackGUID();
            }
        }
    }
 
    WorldPacket data(SMSG_SPELL_GO, 150);                    // guess size
 
    if (m_CastItem)
        data << m_CastItem->GetPackGUID();
    else
        data << realCasterGUID;
 
    data << realCasterGUID;
    data << uint8(m_cast_count);                            // pending spell cast?
    data << uint32(m_spellInfo->Id);                        // spellId
    data << uint32(castFlags);                              // cast flags
    data << uint32(GameTime::GetGameTimeMS().count());                 // timestamp
 
    WriteSpellGoTargets(&data);
 
    m_targets.Write(data);
 
    if (castFlags & CAST_FLAG_POWER_LEFT_SELF)
        data << uint32(m_caster->GetPower((Powers)m_spellInfo->PowerType));
 
    if (castFlags & CAST_FLAG_RUNE_LIST)                   // rune cooldowns list
    {
        //TODO: There is a crash caused by a spell with CAST_FLAG_RUNE_LIST casted by a creature
        //The creature is the mover of a player, so HandleCastSpellOpcode uses it as the caster
        if (Player* player = m_caster->ToPlayer())
        {
            uint8 runeMaskInitial = m_runesState;
            uint8 runeMaskAfterCast = player->GetRunesState();
            data << uint8(runeMaskInitial);                     // runes state before
            data << uint8(runeMaskAfterCast);                   // runes state after
            for (uint8 i = 0; i < MAX_RUNES; ++i)
            {
                uint8 mask = (1 << i);
                if (mask & runeMaskInitial && !(mask & runeMaskAfterCast))  // usable before andon cooldown now...
                {
                    // float casts ensure the division is performed on floats as we need float result
                    float baseCd = float(player->GetRuneBaseCooldown(i, true));
                    data << uint8((baseCd - float(player->GetRuneCooldown(i))) / baseCd * 255); // rune cooldown passed
                }
            }
        }
    }
    if (castFlags & CAST_FLAG_ADJUST_MISSILE)
    {
        data << m_targets.GetElevation();
        data << uint32(m_delayTrajectory ? m_delayTrajectory : m_delayMoment);
    }
 
    if (castFlags & CAST_FLAG_PROJECTILE)
        WriteAmmoToPacket(&data);
 
    if (castFlags & CAST_FLAG_VISUAL_CHAIN)
    {
        data << uint32(0);
        data << uint32(0);
    }
 
    if (m_targets.GetTargetMask() & TARGET_FLAG_DEST_LOCATION)
    {
        data << uint8(0);
    }
 
    m_caster->SendMessageToSet(&data, true);
}

References CAST_FLAG_ADJUST_MISSILE, CAST_FLAG_NO_GCD, CAST_FLAG_PENDING, CAST_FLAG_POWER_LEFT_SELF, CAST_FLAG_PROJECTILE, CAST_FLAG_RUNE_LIST, CAST_FLAG_UNKNOWN_9, CAST_FLAG_VISUAL_CHAIN, SpellCastTimesEntry::CastTime, SpellInfo::CastTimeEntry, CLASS_CONTEXT_ABILITY, CLASS_DEATH_KNIGHT, SpellCastTargets::GetElevation(), GameTime::GetGameTimeMS(), Object::GetPackGUID(), Unit::GetPower(), SpellCastTargets::GetTargetMask(), SpellInfo::HasAttribute(), SpellInfo::HasEffect(), SpellCastTargets::HasTraj(), SpellInfo::Id, SpellInfo::IsAutoRepeatRangedSpell(), SpellInfo::IsChanneled(), Unit::IsClass(), IsNeedSendToClient(), Unit::IsPet(), Object::IsPlayer(), IsTriggered(), m_cast_count, m_caster, m_CastItem, m_delayMoment, m_delayTrajectory, m_powerCost, m_runesState, m_spellInfo, m_targets, m_triggeredByAuraSpell, MAX_RUNES, POWER_HEALTH, POWER_RUNE, SpellInfo::PowerType, SpellInfo::RuneCostID, WorldObject::SendMessageToSet(), SMSG_SPELL_GO, SPELL_ATTR0_CU_NEEDS_AMMO_DATA, SPELL_ATTR0_USES_RANGED_SLOT, SPELL_EFFECT_ACTIVATE_RUNE, SpellInfo::StartRecoveryTime, TARGET_FLAG_DEST_LOCATION, Object::ToPlayer(), Unit::ToTempSummon(), WORLD_TRIGGER, SpellCastTargets::Write(), WriteAmmoToPacket(), and WriteSpellGoTargets().

Referenced by _cast().

◆ SendSpellStart()

void Spell::SendSpellStart ( )

{
    if (!IsNeedSendToClient(false))
        return;
 
    //LOG_DEBUG("spells.aura", "Sending SMSG_SPELL_START id={}", m_spellInfo->Id);
 
    uint32 castFlags = CAST_FLAG_HAS_TRAJECTORY;
 
    if (((IsTriggered() && !m_spellInfo->IsAutoRepeatRangedSpell()) || m_triggeredByAuraSpell) && !m_cast_count && !(m_spellInfo->IsChanneled() || (m_spellInfo->CastTimeEntry && m_spellInfo->CastTimeEntry->CastTime > 0)))
        castFlags |= CAST_FLAG_PENDING;
 
    if (m_spellInfo->HasAttribute(SPELL_ATTR0_USES_RANGED_SLOT) || m_spellInfo->HasAttribute(SPELL_ATTR0_CU_NEEDS_AMMO_DATA))
        castFlags |= CAST_FLAG_PROJECTILE;
 
    if (m_caster->IsPlayer() || m_caster->IsPet())
    {
        switch (m_spellInfo->PowerType)
        {
            case POWER_HEALTH:
                break;
            case POWER_RUNE:
                castFlags |= CAST_FLAG_POWER_LEFT_SELF;
                break;
            default:
                if (m_powerCost != 0)
                {
                    castFlags |= CAST_FLAG_POWER_LEFT_SELF;
                }
                break;
        }
    }
 
    if (m_spellInfo->RuneCostID && m_spellInfo->PowerType == POWER_RUNE)
        castFlags |= CAST_FLAG_NO_GCD; // not needed, but Blizzard sends it
 
    PackedGuid realCasterGUID = m_caster->GetPackGUID();
    if (TempSummon const* tempSummon = m_caster->ToTempSummon())
    {
        if (tempSummon->GetEntry() == WORLD_TRIGGER)
        {
            if (GameObject* casterGameobject = tempSummon->GetSummonerGameObject())
            {
                realCasterGUID = casterGameobject->GetPackGUID();
            }
        }
    }
 
    WorldPacket data(SMSG_SPELL_START, (8 + 8 + 4 + 4 + 2));
    if (m_CastItem)
        data << m_CastItem->GetPackGUID();
    else
        data << realCasterGUID;
 
    data << realCasterGUID;
    data << uint8(m_cast_count);                            // pending spell cast?
    data << uint32(m_spellInfo->Id);                        // spellId
    data << uint32(castFlags);                              // cast flags
    data << int32(m_timer);                                 // delay?
 
    m_targets.Write(data);
 
    if (castFlags & CAST_FLAG_POWER_LEFT_SELF)
        data << uint32(m_caster->GetPower((Powers)m_spellInfo->PowerType));
 
    if (castFlags & CAST_FLAG_PROJECTILE)
        WriteAmmoToPacket(&data);
 
    if (castFlags & CAST_FLAG_UNKNOWN_23)
    {
        data << uint32(0);
        data << uint32(0);
    }
 
    m_caster->SendMessageToSet(&data, true);
 
    if (!m_spellInfo->IsChanneled() && m_caster->IsPlayer() && m_caster->ToPlayer()->NeedSendSpectatorData())
        ArenaSpectator::SendCommand_Spell(m_caster->FindMap(), m_caster->GetGUID(), "SPE", m_spellInfo->Id, m_timer);
}

References CAST_FLAG_HAS_TRAJECTORY, CAST_FLAG_NO_GCD, CAST_FLAG_PENDING, CAST_FLAG_POWER_LEFT_SELF, CAST_FLAG_PROJECTILE, CAST_FLAG_UNKNOWN_23, SpellCastTimesEntry::CastTime, SpellInfo::CastTimeEntry, WorldObject::FindMap(), Object::GetGUID(), Object::GetPackGUID(), Unit::GetPower(), SpellInfo::HasAttribute(), SpellInfo::Id, SpellInfo::IsAutoRepeatRangedSpell(), SpellInfo::IsChanneled(), IsNeedSendToClient(), Unit::IsPet(), Object::IsPlayer(), IsTriggered(), m_cast_count, m_caster, m_CastItem, m_powerCost, m_spellInfo, m_targets, m_timer, m_triggeredByAuraSpell, Player::NeedSendSpectatorData(), POWER_HEALTH, POWER_RUNE, SpellInfo::PowerType, SpellInfo::RuneCostID, ArenaSpectator::SendCommand_Spell(), WorldObject::SendMessageToSet(), SMSG_SPELL_START, SPELL_ATTR0_CU_NEEDS_AMMO_DATA, SPELL_ATTR0_USES_RANGED_SLOT, Object::ToPlayer(), Unit::ToTempSummon(), WORLD_TRIGGER, SpellCastTargets::Write(), and WriteAmmoToPacket().

Referenced by prepare().

◆ SetAutoRepeat()

void Spell::SetAutoRepeat ( bool rep )

inline

564{ m_autoRepeat = rep; }

References m_autoRepeat.

◆ SetDelayStart()

void Spell::SetDelayStart ( uint64 m_time )

inline

580{ m_delayStart = m_time; }

References m_delayStart.

Referenced by _cast(), and SpellEvent::Execute().

◆ SetExecutedCurrently()

void Spell::SetExecutedCurrently ( bool yes )

inline

578{m_executedCurrently = yes;}

References m_executedCurrently.

Referenced by _cast(), and Unit::AttackerStateUpdate().

◆ SetReferencedFromCurrent()

void Spell::SetReferencedFromCurrent ( bool yes )

inline

576{ m_referencedFromCurrentSpell = yes; }

References m_referencedFromCurrentSpell.

Referenced by Unit::_UpdateSpells(), cancel(), Unit::InterruptSpell(), Unit::SetCurrentCastedSpell(), and Unit::~Unit().

◆ SetSpellValue()

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

{
    switch (mod)
    {
        case SPELLVALUE_BASE_POINT0:
            m_spellValue->EffectBasePoints[0] = m_spellInfo->Effects[EFFECT_0].CalcBaseValue(value);
            break;
        case SPELLVALUE_BASE_POINT1:
            m_spellValue->EffectBasePoints[1] = m_spellInfo->Effects[EFFECT_1].CalcBaseValue(value);
            break;
        case SPELLVALUE_BASE_POINT2:
            m_spellValue->EffectBasePoints[2] = m_spellInfo->Effects[EFFECT_2].CalcBaseValue(value);
            break;
        case SPELLVALUE_RADIUS_MOD:
            m_spellValue->RadiusMod = (float)value / 10000;
            break;
        case SPELLVALUE_MAX_TARGETS:
            m_spellValue->MaxAffectedTargets = (uint32)value;
            break;
        case SPELLVALUE_AURA_STACK:
            m_spellValue->AuraStackAmount = uint8(value);
            break;
        case SPELLVALUE_AURA_DURATION:
            m_spellValue->AuraDuration = value;
            break;
        case SPELLVALUE_FORCED_CRIT_RESULT:
            m_spellValue->ForcedCritResult = (bool)value;
            break;
        case SPELLVALUE_MISCVALUE0:
            m_spellValue->MiscVal[0] = value;
            break;
        case SPELLVALUE_MISCVALUE1:
            m_spellValue->MiscVal[1] = value;
            break;
        case SPELLVALUE_MISCVALUE2:
            m_spellValue->MiscVal[2] = value;
            break;
    }
}

References SpellValue::AuraDuration, SpellValue::AuraStackAmount, EFFECT_0, EFFECT_1, EFFECT_2, SpellValue::EffectBasePoints, SpellInfo::Effects, SpellValue::ForcedCritResult, m_spellInfo, m_spellValue, SpellValue::MaxAffectedTargets, SpellValue::MiscVal, SpellValue::RadiusMod, SPELLVALUE_AURA_DURATION, SPELLVALUE_AURA_STACK, SPELLVALUE_BASE_POINT0, SPELLVALUE_BASE_POINT1, SPELLVALUE_BASE_POINT2, SPELLVALUE_FORCED_CRIT_RESULT, SPELLVALUE_MAX_TARGETS, SPELLVALUE_MISCVALUE0, SPELLVALUE_MISCVALUE1, SPELLVALUE_MISCVALUE2, and SPELLVALUE_RADIUS_MOD.

Referenced by Player::CastItemUseSpell(), Unit::CastSpell(), and spell_gen_mod_radius_by_caster_scale::PrepareSpellScript().

◆ setState()

void Spell::setState ( uint32 state )

inline

497{ m_spellState = state; }

References m_spellState.

◆ SummonGuardian()

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

protected

{
    Unit* caster = m_originalCaster;
    if (!caster)
        return;
 
    if (caster->IsTotem())
        caster = caster->ToTotem()->GetOwner();
    else if (caster->IsPet())
        if (Unit* owner = caster->GetOwner())
            caster = owner;
 
    // in another case summon new
    uint8 summonLevel = caster->GetLevel();
 
    // level of pet summoned using engineering item based at engineering skill level
    if (m_CastItem && caster->IsPlayer())
        if (ItemTemplate const* proto = m_CastItem->GetTemplate())
        {
            // xinef: few special cases
            if (proto->RequiredSkill == SKILL_ENGINEERING)
            {
                if (uint16 skill202 = caster->ToPlayer()->GetSkillValue(SKILL_ENGINEERING))
                    summonLevel = skill202 / 5;
            }
 
            switch (m_spellInfo->Id)
            {
                // Dragon's Call
                case 13049:
                    summonLevel = 55;
                    break;
 
                // Cleansed Timberling Heart: Summon Timberling
                case 5666:
                    summonLevel = 7;
                    break;
 
                // Glowing Cat Figurine: Summon Ghost Saber
                case 6084:
                    // minLevel 19, maxLevel 20
                    summonLevel = 20;
                    break;
 
                // Spiked Collar: Summon Felhunter
                case 8176:
                    summonLevel = 30;
                    break;
 
                // Dog Whistle: Summon Tracking Hound
                case 9515:
                    summonLevel = 30;
                    break;
 
                // Barov Peasant Caller: Death by Peasant
                case 18307:
                case 18308:
                    summonLevel = 60;
                    break;
 
                // Thornling Seed: Plant Thornling
                case 22792:
                    summonLevel = 60;
                    break;
 
                // Cannonball Runner: Summon Crimson Cannon
                case 6251:
                    summonLevel = 61;
                    break;
            }
        }
 
    summonLevel = std::min<uint8>(sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL) + sWorld->getIntConfig(CONFIG_WORLD_BOSS_LEVEL_DIFF), std::max<uint8>(1U, summonLevel));
 
    float radius = 5.0f;
    int32 duration = m_spellInfo->GetDuration();
 
    if (Player* modOwner = m_originalCaster->GetSpellModOwner())
        modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_DURATION, duration);
 
    //TempSummonType summonType = (duration == 0) ? TEMPSUMMON_DEAD_DESPAWN : TEMPSUMMON_TIMED_DESPAWN;
    Map* map = caster->GetMap();
    TempSummon* summon = nullptr;
 
    uint32 currMinionsCount = m_caster->m_Controlled.size();
    uint32 totalNumGuardians = numGuardians + currMinionsCount;
 
    for (uint32 count = 0; count < numGuardians; ++count)
    {
        Position pos;
 
        // xinef: do not use precalculated position for effect summon pet in this function
        // it means it was cast by NPC and should have its position overridden unless the
        // target position is specified in the DB AND the effect has no or zero radius
        if ((totalNumGuardians == 1 && GetSpellInfo()->Effects[i].Effect != SPELL_EFFECT_SUMMON_PET) ||
            (GetSpellInfo()->Effects[i].TargetA.GetTarget() == TARGET_DEST_DB &&
            (!GetSpellInfo()->Effects[i].HasRadius() || GetSpellInfo()->Effects[i].RadiusEntry->RadiusMax == 0)))
        {
            pos = *destTarget;
        }
        else
        {
            // randomize position
            pos = m_caster->GetRandomPoint(*destTarget, radius);
        }
 
        summon = map->SummonCreature(entry, pos, properties, duration, caster, m_spellInfo->Id, 0, personalSpawn);
        if (!summon)
            return;
 
        // xinef: set calculated level
        summon->SetLevel(summonLevel);
 
        // if summonLevel changed, set stats for calculated level
        if (summonLevel != caster->GetLevel())
        {
            ((Guardian*)summon)->InitStatsForLevel(summonLevel);
        }
 
        // xinef: if we have more than one guardian, change follow angle
        if (summon->HasUnitTypeMask(UNIT_MASK_MINION) && totalNumGuardians > 1)
            ((Minion*)summon)->SetFollowAngle(m_caster->GetAbsoluteAngle(pos.GetPositionX(), pos.GetPositionY()));
        //else if (summon->HasUnitTypeMask(UNIT_MASK_MINION) && m_targets.HasDst())
        //    ((Minion*)summon)->SetFollowAngle(m_caster->GetAngle(summon));
 
        // xinef: move this here, some auras are added in initstatsforlevel!
        if (!summon->IsInCombat() && !summon->IsTrigger())
        {
            //  summon->AI()->EnterEvadeMode();
            summon->GetMotionMaster()->Clear(false);
            summon->GetMotionMaster()->MoveFollow(caster, PET_FOLLOW_DIST, summon->GetFollowAngle(), MOTION_SLOT_ACTIVE);
        }
 
        if (properties && properties->Category == SUMMON_CATEGORY_ALLY)
            summon->SetFaction(caster->GetFaction());
 
        ExecuteLogEffectSummonObject(i, summon);
    }
}

References SummonPropertiesEntry::Category, MotionMaster::Clear(), CONFIG_MAX_PLAYER_LEVEL, CONFIG_WORLD_BOSS_LEVEL_DIFF, destTarget, ExecuteLogEffectSummonObject(), Position::GetAbsoluteAngle(), SpellInfo::GetDuration(), Unit::GetFaction(), Unit::GetFollowAngle(), Unit::GetLevel(), WorldObject::GetMap(), Unit::GetMotionMaster(), Minion::GetOwner(), Unit::GetOwner(), Position::GetPositionX(), Position::GetPositionY(), WorldObject::GetRandomPoint(), Player::GetSkillValue(), GetSpellInfo(), Unit::GetSpellModOwner(), Item::GetTemplate(), Unit::HasUnitTypeMask(), SpellInfo::Id, Unit::IsInCombat(), Unit::IsPet(), Object::IsPlayer(), Unit::IsTotem(), Creature::IsTrigger(), m_caster, m_CastItem, Unit::m_Controlled, m_originalCaster, m_spellInfo, MOTION_SLOT_ACTIVE, MotionMaster::MoveFollow(), PET_FOLLOW_DIST, Unit::SetFaction(), Unit::SetLevel(), SKILL_ENGINEERING, SPELL_EFFECT_SUMMON_PET, SPELLMOD_DURATION, SUMMON_CATEGORY_ALLY, Map::SummonCreature(), sWorld, TARGET_DEST_DB, Object::ToPlayer(), Unit::ToTotem(), and UNIT_MASK_MINION.

Referenced by EffectSummonPet(), and EffectSummonType().

◆ TakeAmmo()

void Spell::TakeAmmo ( )

{
    if (m_attackType == RANGED_ATTACK && m_caster->IsPlayer() && !m_spellInfo->HasAttribute(SPELL_ATTR6_DO_NOT_CONSUME_RESOURCES))
    {
        Item* pItem = m_caster->ToPlayer()->GetWeaponForAttack(RANGED_ATTACK);
 
        // wands don't have ammo
        if (!pItem  || pItem->IsBroken() || pItem->GetTemplate()->SubClass == ITEM_SUBCLASS_WEAPON_WAND)
            return;
 
        if (pItem->GetTemplate()->InventoryType == INVTYPE_THROWN)
        {
            if (pItem->GetMaxStackCount() == 1)
            {
                // decrease durability for non-stackable throw weapon
                m_caster->ToPlayer()->DurabilityPointLossForEquipSlot(EQUIPMENT_SLOT_RANGED);
            }
            else if (!sWorld->getBoolConfig(CONFIG_ENABLE_INFINITEAMMO))
            {
                // decrease items amount for stackable throw weapon
                uint32 count = 1;
                m_caster->ToPlayer()->DestroyItemCount(pItem, count, true);
            }
        }
        else if (!sWorld->getBoolConfig(CONFIG_ENABLE_INFINITEAMMO))
            if (uint32 ammo = m_caster->ToPlayer()->GetUInt32Value(PLAYER_AMMO_ID))
                m_caster->ToPlayer()->DestroyItemCount(ammo, 1, true);
    }
}

References CONFIG_ENABLE_INFINITEAMMO, Player::DestroyItemCount(), Player::DurabilityPointLossForEquipSlot(), EQUIPMENT_SLOT_RANGED, Item::GetMaxStackCount(), Item::GetTemplate(), Object::GetUInt32Value(), Player::GetWeaponForAttack(), SpellInfo::HasAttribute(), ItemTemplate::InventoryType, INVTYPE_THROWN, Item::IsBroken(), Object::IsPlayer(), ITEM_SUBCLASS_WEAPON_WAND, m_attackType, m_caster, m_spellInfo, PLAYER_AMMO_ID, RANGED_ATTACK, SPELL_ATTR6_DO_NOT_CONSUME_RESOURCES, ItemTemplate::SubClass, sWorld, and Object::ToPlayer().

Referenced by handle_immediate(), spell_hun_explosive_shot::HandleFinish(), and HandleLaunchPhase().

◆ TakeCastItem()

void Spell::TakeCastItem ( )

{
    if (!m_CastItem || !m_caster->IsPlayer())
        return;
 
    // not remove cast item at triggered spell (equipping, weapon damage, etc)
    if (HasTriggeredCastFlag(TRIGGERED_IGNORE_CAST_ITEM))
        return;
 
    ItemTemplate const* proto = m_CastItem->GetTemplate();
 
    if (!proto)
    {
        // This code is to avoid a crash
        // I'm not sure, if this is really an error, but I guess every item needs a prototype
        LOG_ERROR("spells", "Cast item has no item prototype {}", m_CastItem->GetGUID().ToString());
        return;
    }
 
    bool expendable = false;
    bool withoutCharges = false;
 
    for (int i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
    {
        if (proto->Spells[i].SpellId)
        {
            // item has limited charges
            if (proto->Spells[i].SpellCharges)
            {
                if (proto->Spells[i].SpellCharges < 0)
                    expendable = true;
 
                int32 charges = m_CastItem->GetSpellCharges(i);
 
                // item has charges left
                if (charges)
                {
                    (charges > 0) ? --charges : ++charges;  // std::abs(charges) less at 1 after use
                    if (proto->Stackable == 1)
                        m_CastItem->SetSpellCharges(i, charges);
                    m_CastItem->SetState(ITEM_CHANGED, m_caster->ToPlayer());
                }
 
                // all charges used
                withoutCharges = (charges == 0);
            }
        }
    }
 
    if (expendable && withoutCharges)
    {
        uint32 count = 1;
        m_caster->ToPlayer()->DestroyItemCount(m_CastItem, count, true);
 
        // prevent crash at access to deleted m_targets.GetItemTarget
        if (m_CastItem == m_targets.GetItemTarget())
            m_targets.SetItemTarget(nullptr);
 
        m_CastItem = nullptr;
        m_castItemGUID.Clear();
    }
}

References ObjectGuid::Clear(), Player::DestroyItemCount(), Object::GetGUID(), SpellCastTargets::GetItemTarget(), Item::GetSpellCharges(), Item::GetTemplate(), HasTriggeredCastFlag(), Object::IsPlayer(), ITEM_CHANGED, LOG_ERROR, m_caster, m_CastItem, m_castItemGUID, m_targets, MAX_ITEM_PROTO_SPELLS, SpellCastTargets::SetItemTarget(), Item::SetSpellCharges(), Item::SetState(), _Spell::SpellCharges, _Spell::SpellId, ItemTemplate::Spells, ItemTemplate::Stackable, Object::ToPlayer(), ObjectGuid::ToString(), and TRIGGERED_IGNORE_CAST_ITEM.

Referenced by _cast(), and handle_immediate().

◆ TakePower()

void Spell::TakePower ( )

{
    if (m_CastItem || m_triggeredByAuraSpell)
        return;
 
    //Don't take power if the spell is cast while .cheat power is enabled.
    if (m_caster->IsPlayer())
        if (m_caster->ToPlayer()->GetCommandStatus(CHEAT_POWER))
            return;
 
    Powers PowerType = Powers(m_spellInfo->PowerType);
    bool hit = true;
    if (m_caster->IsPlayer())
    {
        if (PowerType == POWER_RAGE || PowerType == POWER_ENERGY || PowerType == POWER_RUNE || PowerType == POWER_RUNIC_POWER)
            if (ObjectGuid targetGUID = m_targets.GetUnitTargetGUID())
                for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
                    if (ihit->targetGUID == targetGUID)
                    {
                        if (ihit->missCondition != SPELL_MISS_NONE && ihit->missCondition != SPELL_MISS_BLOCK && ihit->missCondition != SPELL_MISS_ABSORB && ihit->missCondition != SPELL_MISS_REFLECT)
                        {
                            hit = false;
                            //lower spell cost on fail (by talent aura)
                            if (Player* modOwner = m_caster->ToPlayer()->GetSpellModOwner())
                                modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_SPELL_COST_REFUND_ON_FAIL, m_powerCost, this);
                        }
                        break;
                    }
    }
 
    if (PowerType == POWER_RUNE)
    {
        TakeRunePower(hit);
        return;
    }
 
    if (!m_powerCost)
        return;
 
    // health as power used
    if (PowerType == POWER_HEALTH)
    {
        m_caster->ModifyHealth(-(int32)m_powerCost);
        return;
    }
 
    if (PowerType >= MAX_POWERS)
    {
        LOG_ERROR("spells", "Spell::TakePower: Unknown power type '{}'", PowerType);
        return;
    }
 
    if (hit)
        m_caster->ModifyPower(PowerType, -m_powerCost);
    else
        m_caster->ModifyPower(PowerType, -irand(0, m_powerCost / 4));
 
    // Set the five second timer
    if (PowerType == POWER_MANA && m_powerCost > 0)
    {
        m_caster->SetLastManaUse(GameTime::GetGameTimeMS().count());
    }
}

References CHEAT_POWER, Player::GetCommandStatus(), GameTime::GetGameTimeMS(), Unit::GetSpellModOwner(), SpellCastTargets::GetUnitTargetGUID(), SpellInfo::Id, irand(), Object::IsPlayer(), LOG_ERROR, m_caster, m_CastItem, m_powerCost, m_spellInfo, m_targets, m_triggeredByAuraSpell, m_UniqueTargetInfo, MAX_POWERS, Unit::ModifyHealth(), Unit::ModifyPower(), POWER_ENERGY, POWER_HEALTH, POWER_MANA, POWER_RAGE, POWER_RUNE, POWER_RUNIC_POWER, SpellInfo::PowerType, Unit::SetLastManaUse(), SPELL_MISS_ABSORB, SPELL_MISS_BLOCK, SPELL_MISS_NONE, SPELL_MISS_REFLECT, SPELLMOD_SPELL_COST_REFUND_ON_FAIL, TakeRunePower(), and Object::ToPlayer().

Referenced by _cast().

◆ TakeReagents()

void Spell::TakeReagents ( )

{
    if (!m_caster->IsPlayer())
        return;
 
    ItemTemplate const* castItemTemplate = m_CastItem ? m_CastItem->GetTemplate() : nullptr;
 
    // do not take reagents for these item casts
    if (castItemTemplate && castItemTemplate->HasFlag(ITEM_FLAG_NO_REAGENT_COST))
        return;
 
    Player* p_caster = m_caster->ToPlayer();
    if (p_caster->CanNoReagentCast(m_spellInfo))
        return;
 
    for (uint32 x = 0; x < MAX_SPELL_REAGENTS; ++x)
    {
        if (m_spellInfo->Reagent[x] <= 0)
            continue;
 
        uint32 itemid = m_spellInfo->Reagent[x];
        uint32 itemcount = m_spellInfo->ReagentCount[x];
 
        // if CastItem is also spell reagent
        if (castItemTemplate && castItemTemplate->ItemId == itemid)
        {
            for (int s = 0; s < MAX_ITEM_PROTO_SPELLS; ++s)
            {
                // CastItem will be used up and does not count as reagent
                int32 charges = m_CastItem->GetSpellCharges(s);
                if (castItemTemplate->Spells[s].SpellCharges < 0 && std::abs(charges) < 2)
                {
                    ++itemcount;
                    break;
                }
            }
 
            m_CastItem = nullptr;
            m_castItemGUID.Clear();
        }
 
        // if GetItemTarget is also spell reagent
        if (m_targets.GetItemTargetEntry() == itemid)
            m_targets.SetItemTarget(nullptr);
 
        p_caster->DestroyItemCount(itemid, itemcount, true);
    }
}

References Player::CanNoReagentCast(), ObjectGuid::Clear(), Player::DestroyItemCount(), SpellCastTargets::GetItemTargetEntry(), Item::GetSpellCharges(), Item::GetTemplate(), ItemTemplate::HasFlag(), Object::IsPlayer(), ITEM_FLAG_NO_REAGENT_COST, ItemTemplate::ItemId, m_caster, m_CastItem, m_castItemGUID, m_spellInfo, m_targets, MAX_ITEM_PROTO_SPELLS, MAX_SPELL_REAGENTS, SpellInfo::Reagent, SpellInfo::ReagentCount, SpellCastTargets::SetItemTarget(), _Spell::SpellCharges, ItemTemplate::Spells, and Object::ToPlayer().

Referenced by _cast().

◆ TakeRunePower()

void Spell::TakeRunePower ( bool didHit )

{
    if (!m_caster->IsPlayer() || !m_caster->IsClass(CLASS_DEATH_KNIGHT, CLASS_CONTEXT_ABILITY))
        return;
 
    SpellRuneCostEntry const* runeCostData = sSpellRuneCostStore.LookupEntry(m_spellInfo->RuneCostID);
    if (!runeCostData || (runeCostData->NoRuneCost() && runeCostData->NoRunicPowerGain()))
        return;
 
    Player* player = m_caster->ToPlayer();
    m_runesState = player->GetRunesState();                 // store previous state
 
    int32 runeCost[NUM_RUNE_TYPES];                         // blood, frost, unholy, death
 
    for (uint32 i = 0; i < RUNE_DEATH; ++i)
    {
        runeCost[i] = runeCostData->RuneCost[i];
        if (Player* modOwner = m_caster->GetSpellModOwner())
            modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_COST, runeCost[i], this);
    }
 
    runeCost[RUNE_DEATH] = 0;                               // calculated later
 
    for (uint32 i = 0; i < MAX_RUNES; ++i)
    {
        RuneType rune = player->GetCurrentRune(i);
        if (!player->GetRuneCooldown(i) && runeCost[rune] > 0)
        {
            player->SetRuneCooldown(i, didHit ? player->GetRuneBaseCooldown(i, false) : uint32(RUNE_MISS_COOLDOWN));
            player->SetLastUsedRune(rune);
            runeCost[rune]--;
        }
    }
 
    // Xinef: firstly consume death runes of base type
    // Xinef: in second loop consume all available
    for (uint8 loop = 0; loop < 2; ++loop)
    {
        runeCost[RUNE_DEATH] = runeCost[RUNE_BLOOD] + runeCost[RUNE_UNHOLY] + runeCost[RUNE_FROST];
        if (runeCost[RUNE_DEATH] > 0)
        {
            for (uint8 i = 0; i < MAX_RUNES; ++i)
            {
                RuneType rune = player->GetCurrentRune(i);
                if (!player->GetRuneCooldown(i) && rune == RUNE_DEATH && (loop ? true : (runeCost[player->GetBaseRune(i)] > 0)))
                {
                    player->SetRuneCooldown(i, didHit ? player->GetRuneBaseCooldown(i, false) : uint32(RUNE_MISS_COOLDOWN));
                    player->SetLastUsedRune(rune);
                    runeCost[rune]--;
                    if (!loop)
                        runeCost[player->GetBaseRune(i)]--;
 
                    // keep Death Rune type if missed
                    if (didHit)
                        player->RestoreBaseRune(i);
 
                    if (runeCost[RUNE_DEATH] == 0)
                        break;
                }
            }
        }
    }
 
    // you can gain some runic power when use runes
    if (didHit)
        if (int32 rp = int32(runeCostData->runePowerGain * sWorld->getRate(RATE_POWER_RUNICPOWER_INCOME)))
            player->ModifyPower(POWER_RUNIC_POWER, int32(rp));
}

References CLASS_CONTEXT_ABILITY, CLASS_DEATH_KNIGHT, Player::GetBaseRune(), Player::GetCurrentRune(), Player::GetRuneBaseCooldown(), Player::GetRuneCooldown(), Player::GetRunesState(), Unit::GetSpellModOwner(), SpellInfo::Id, Unit::IsClass(), Object::IsPlayer(), m_caster, m_runesState, m_spellInfo, MAX_RUNES, Unit::ModifyPower(), SpellRuneCostEntry::NoRuneCost(), SpellRuneCostEntry::NoRunicPowerGain(), NUM_RUNE_TYPES, POWER_RUNIC_POWER, RATE_POWER_RUNICPOWER_INCOME, Player::RestoreBaseRune(), RUNE_BLOOD, RUNE_DEATH, RUNE_FROST, RUNE_MISS_COOLDOWN, RUNE_UNHOLY, SpellRuneCostEntry::RuneCost, SpellInfo::RuneCostID, SpellRuneCostEntry::runePowerGain, Player::SetLastUsedRune(), Player::SetRuneCooldown(), SPELLMOD_COST, sSpellRuneCostStore, sWorld, and Object::ToPlayer().

Referenced by TakePower().

◆ TriggerGlobalCooldown()

void Spell::TriggerGlobalCooldown ( )

protected

{
    int32 gcd = m_spellInfo->StartRecoveryTime;
    if (!gcd)
    {
        // Xinef: fix for charmed pet spells with no cooldown info
        if (m_spellInfo->RecoveryTime == 0 && m_spellInfo->CategoryRecoveryTime == 0 && m_caster->GetCharmInfo())
            gcd = MIN_GCD;
        else
            return;
    }
 
    if (m_caster->IsPlayer())
        if (m_caster->ToPlayer()->GetCommandStatus(CHEAT_COOLDOWN))
            return;
 
    // Global cooldown can't leave range 1..1.5 secs
    // There are some spells (mostly not casted directly by player) that have < 1 sec and > 1.5 sec global cooldowns
    // but as tests show are not affected by any spell mods.
    if (m_spellInfo->StartRecoveryTime >= MIN_GCD && m_spellInfo->StartRecoveryTime <= MAX_GCD)
    {
        // gcd modifier auras are applied only to own spells and only players have such mods
        if (m_caster->IsPlayer())
            m_caster->ToPlayer()->ApplySpellMod(m_spellInfo->Id, SPELLMOD_GLOBAL_COOLDOWN, gcd, this);
 
        // Apply haste rating
        if (m_spellInfo->StartRecoveryCategory == 133 && m_spellInfo->StartRecoveryTime == 1500 && m_spellInfo->DmgClass != SPELL_DAMAGE_CLASS_MELEE &&
            m_spellInfo->DmgClass != SPELL_DAMAGE_CLASS_RANGED && !m_spellInfo->HasAttribute(SPELL_ATTR0_USES_RANGED_SLOT) && !m_spellInfo->HasAttribute(SPELL_ATTR0_IS_ABILITY))
        {
            gcd = int32(float(gcd) * m_caster->GetFloatValue(UNIT_MOD_CAST_SPEED));
        }
 
        if (gcd < MIN_GCD)
            gcd = MIN_GCD;
        else if (gcd > MAX_GCD)
            gcd = MAX_GCD;
    }
 
    // Only players or controlled units have global cooldown
    if (m_caster->GetCharmInfo())
        m_caster->GetCharmInfo()->GetGlobalCooldownMgr().AddGlobalCooldown(m_spellInfo, gcd);
    else if (m_caster->IsPlayer())
        m_caster->ToPlayer()->GetGlobalCooldownMgr().AddGlobalCooldown(m_spellInfo, gcd);
}

References GlobalCooldownMgr::AddGlobalCooldown(), Player::ApplySpellMod(), SpellInfo::CategoryRecoveryTime, CHEAT_COOLDOWN, SpellInfo::DmgClass, Unit::GetCharmInfo(), Player::GetCommandStatus(), Object::GetFloatValue(), Player::GetGlobalCooldownMgr(), CharmInfo::GetGlobalCooldownMgr(), SpellInfo::HasAttribute(), SpellInfo::Id, Object::IsPlayer(), m_caster, m_spellInfo, MAX_GCD, MIN_GCD, SpellInfo::RecoveryTime, SPELL_ATTR0_IS_ABILITY, SPELL_ATTR0_USES_RANGED_SLOT, SPELL_DAMAGE_CLASS_MELEE, SPELL_DAMAGE_CLASS_RANGED, SPELLMOD_GLOBAL_COOLDOWN, SpellInfo::StartRecoveryCategory, SpellInfo::StartRecoveryTime, Object::ToPlayer(), and UNIT_MOD_CAST_SPEED.

Referenced by prepare().

◆ update()

void Spell::update ( uint32 difftime )

{
    // update pointers based at it's GUIDs
    if (!UpdatePointers())
    {
        // cancel the spell if UpdatePointers() returned false, something wrong happened there
        cancel();
        return;
    }
 
    if (m_targets.GetUnitTargetGUID() && !m_targets.GetUnitTarget())
    {
        LOG_DEBUG("spells.aura", "Spell {} is cancelled due to removal of target.", m_spellInfo->Id);
        cancel();
        return;
    }
 
    // check if the player caster has moved before the spell finished
    // xinef: added preparing state (real cast, skip channels as they have other flags for this)
    if ((m_caster->IsPlayer() && m_timer != 0) &&
            m_caster->isMoving() && (m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_MOVEMENT) && m_spellState == SPELL_STATE_PREPARING &&
            (m_spellInfo->Effects[0].Effect != SPELL_EFFECT_STUCK || !m_caster->HasUnitMovementFlag(MOVEMENTFLAG_FALLING_FAR)))
    {
        // don't cancel for melee, autorepeat, triggered and instant spells
        if (!IsNextMeleeSwingSpell() && !IsAutoRepeat() && !IsTriggered())
            cancel(true);
    }
 
    switch (m_spellState)
    {
        case SPELL_STATE_PREPARING:
            {
                if (m_timer > 0)
                {
                    if (difftime >= (uint32)m_timer)
                        m_timer = 0;
                    else
                        m_timer -= difftime;
                }
 
                if (m_timer == 0 && !IsNextMeleeSwingSpell() && !IsAutoRepeat())
                    // don't CheckCast for instant spells - done in spell::prepare, skip duplicate checks, needed for range checks for example
                    cast(!m_casttime);
                break;
            }
        case SPELL_STATE_CASTING:
            {
                if (m_timer)
                {
                    if (m_timer > 0)
                    {
                        if (difftime >= (uint32)m_timer)
                            m_timer = 0;
                        else
                            m_timer -= difftime;
                    }
                }
 
                if (m_timer == 0)
                {
                    SendChannelUpdate(0);
 
                    finish();
 
                    // We call the hook here instead of in Spell::finish because we only want to call it for completed channeling. Everything else is handled by interrupts
                    if (Creature* creatureCaster = m_caster->ToCreature())
                        if (creatureCaster->IsAIEnabled)
                            creatureCaster->AI()->OnChannelFinished(m_spellInfo);
                }
                // Xinef: Dont update channeled target list on last tick, allow auras to update duration properly
                // Xinef: Added this strange check because of diffrent update routines for players / creatures
                // Xinef: If creature gets new aura in 800ms and in 840ms its updated with diff 270, not 40 is removed from duration but 270
                // Xinef: so the aura can be removed in different updates for all units
                else if ((m_timer < 0 || m_timer > 300) && !UpdateChanneledTargetList())
                {
                    LOG_DEBUG("spells.aura", "Channeled spell {} is removed due to lack of targets", m_spellInfo->Id);
                    SendChannelUpdate(0);
                    finish();
                }
                break;
            }
        default:
            break;
    }
}

References cancel(), cast(), SpellInfo::Effects, finish(), SpellCastTargets::GetUnitTarget(), SpellCastTargets::GetUnitTargetGUID(), Unit::HasUnitMovementFlag(), SpellInfo::Id, SpellInfo::InterruptFlags, IsAutoRepeat(), Unit::isMoving(), IsNextMeleeSwingSpell(), Object::IsPlayer(), IsTriggered(), LOG_DEBUG, m_caster, m_casttime, m_spellInfo, m_spellState, m_targets, m_timer, MOVEMENTFLAG_FALLING_FAR, SendChannelUpdate(), SPELL_EFFECT_STUCK, SPELL_INTERRUPT_FLAG_MOVEMENT, SPELL_STATE_CASTING, SPELL_STATE_PREPARING, Object::ToCreature(), UpdateChanneledTargetList(), and UpdatePointers().

Referenced by SpellEvent::Execute().

◆ UpdateChanneledTargetList()

bool Spell::UpdateChanneledTargetList ( )

protected

{
    // Not need check return true
    if (m_channelTargetEffectMask == 0)
        return true;
 
    uint8 channelTargetEffectMask = m_channelTargetEffectMask;
    uint8 channelAuraMask = 0;
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (m_spellInfo->Effects[i].Effect == SPELL_EFFECT_APPLY_AURA)
            channelAuraMask |= 1 << i;
 
    channelAuraMask &= channelTargetEffectMask;
 
    float range = 0;
    if (channelAuraMask)
    {
        range = m_spellInfo->GetMaxRange(m_spellInfo->IsPositive());
        if (range == 0)
            for(int i = EFFECT_0; i <= EFFECT_2; ++i)
                if (channelAuraMask & (1 << i) && m_spellInfo->Effects[i].RadiusEntry)
                {
                    range = m_spellInfo->Effects[i].CalcRadius(nullptr, nullptr);
                    break;
                }
 
        if (Player* modOwner = m_caster->GetSpellModOwner())
            modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_RANGE, range, this);
 
        // xinef: add little tolerance level
        range += std::min(3.0f, range * 0.1f); // 10% but no more than 3yd
    }
 
    for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
    {
        if (ihit->missCondition == SPELL_MISS_NONE && (channelTargetEffectMask & ihit->effectMask))
        {
            Unit* unit = m_caster->GetGUID() == ihit->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID);
 
            if (!unit)
                continue;
 
            if (IsValidDeadOrAliveTarget(unit))
            {
                if (channelAuraMask & ihit->effectMask)
                {
                    if (AuraApplication* aurApp = unit->GetAuraApplication(m_spellInfo->Id, m_originalCasterGUID))
                    {
                        if (m_caster != unit)
                        {
                            if (!m_caster->IsWithinDistInMap(unit, range))
                            {
                                ihit->effectMask &= ~aurApp->GetEffectMask();
                                unit->RemoveAura(aurApp);
                                continue;
                            }
                            // Xinef: Update Orientation server side (non players wont sent appropriate packets)
                            else if (!m_caster->IsPlayer() && m_spellInfo->HasAttribute(SPELL_ATTR1_TRACK_TARGET_IN_CHANNEL))
                                m_caster->UpdateOrientation(m_caster->GetAngle(unit));
                        }
                    }
                    else // aura is dispelled
                        continue;
                }
 
                channelTargetEffectMask &= ~ihit->effectMask;   // remove from need alive mask effect that have alive target
            }
        }
    }
 
    // Xinef: not all effects are covered, remove applications from all targets
    if (channelTargetEffectMask != 0)
    {
        for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
            if (ihit->missCondition == SPELL_MISS_NONE && (channelAuraMask & ihit->effectMask))
                if (Unit* unit = m_caster->GetGUID() == ihit->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID))
                    if (IsValidDeadOrAliveTarget(unit))
                        if (AuraApplication* aurApp = unit->GetAuraApplication(m_spellInfo->Id, m_originalCasterGUID))
                        {
                            ihit->effectMask &= ~aurApp->GetEffectMask();
                            unit->RemoveAura(aurApp);
                        }
    }
 
    // is all effects from m_needAliveTargetMask have alive targets
    return channelTargetEffectMask == 0;
}

References EFFECT_0, EFFECT_2, SpellInfo::Effects, Position::GetAngle(), Unit::GetAuraApplication(), Object::GetGUID(), SpellInfo::GetMaxRange(), Unit::GetSpellModOwner(), ObjectAccessor::GetUnit(), SpellInfo::HasAttribute(), SpellInfo::Id, Object::IsPlayer(), SpellInfo::IsPositive(), IsValidDeadOrAliveTarget(), WorldObject::IsWithinDistInMap(), m_caster, m_channelTargetEffectMask, m_originalCasterGUID, m_spellInfo, m_UniqueTargetInfo, MAX_SPELL_EFFECTS, Unit::RemoveAura(), SPELL_ATTR1_TRACK_TARGET_IN_CHANNEL, SPELL_EFFECT_APPLY_AURA, SPELL_MISS_NONE, SPELLMOD_RANGE, and Unit::UpdateOrientation().

Referenced by update().

◆ UpdatePointers()

bool Spell::UpdatePointers ( )

{
    if (m_originalCasterGUID == m_caster->GetGUID())
        m_originalCaster = m_caster;
    else
    {
        m_originalCaster = ObjectAccessor::GetUnit(*m_caster, m_originalCasterGUID);
        if (m_originalCaster && !m_originalCaster->IsInWorld())
            m_originalCaster = nullptr;
    }
 
    if (m_castItemGUID && m_caster->IsPlayer())
    {
        m_CastItem = m_caster->ToPlayer()->GetItemByGuid(m_castItemGUID);
        // cast item not found, somehow the item is no longer where we expected
        if (!m_CastItem)
            return false;
    }
    else
        m_CastItem = nullptr;
 
    m_targets.Update(m_caster);
 
    // further actions done only for dest targets
    if (!m_targets.HasDst())
        return true;
 
    // cache last transport
    WorldObject* transport = nullptr;
 
    // update effect destinations (in case of moved transport dest target)
    for (uint8 effIndex = 0; effIndex < MAX_SPELL_EFFECTS; ++effIndex)
    {
        SpellDestination& dest = m_destTargets[effIndex];
        if (!dest._transportGUID)
            continue;
 
        if (!transport || transport->GetGUID() != dest._transportGUID)
            transport = ObjectAccessor::GetWorldObject(*m_caster, dest._transportGUID);
 
        if (transport)
        {
            dest._position.Relocate(transport);
            dest._position.RelocateOffset(dest._transportOffset);
        }
    }
 
    return true;
}

References SpellDestination::_position, SpellDestination::_transportGUID, SpellDestination::_transportOffset, Object::GetGUID(), Player::GetItemByGuid(), ObjectAccessor::GetUnit(), ObjectAccessor::GetWorldObject(), SpellCastTargets::HasDst(), Object::IsInWorld(), Object::IsPlayer(), m_caster, m_CastItem, m_castItemGUID, m_destTargets, m_originalCaster, m_originalCasterGUID, m_targets, MAX_SPELL_EFFECTS, Position::Relocate(), Position::RelocateOffset(), Object::ToPlayer(), and SpellCastTargets::Update().

Referenced by _cast(), handle_delayed(), and update().

◆ WriteAmmoToPacket()

void Spell::WriteAmmoToPacket ( WorldPacket * data )

{
    uint32 ammoInventoryType = 0;
    uint32 ammoDisplayID = 0;
 
    if (m_caster->IsPlayer())
    {
        Item* pItem = m_caster->ToPlayer()->GetWeaponForAttack(RANGED_ATTACK);
        if (pItem)
        {
            ammoInventoryType = pItem->GetTemplate()->InventoryType;
            if (ammoInventoryType == INVTYPE_THROWN)
                ammoDisplayID = pItem->GetTemplate()->DisplayInfoID;
            else
            {
                uint32 ammoID = m_caster->ToPlayer()->GetUInt32Value(PLAYER_AMMO_ID);
                if (ammoID)
                {
                    ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(ammoID);
                    if (pProto)
                    {
                        ammoDisplayID = pProto->DisplayInfoID;
                        ammoInventoryType = pProto->InventoryType;
                    }
                }
                else if (m_caster->HasAura(46699))      // Requires No Ammo
                {
                    ammoDisplayID = 5996;                   // normal arrow
                    ammoInventoryType = INVTYPE_AMMO;
                }
            }
        }
    }
    else
    {
        uint32 nonRangedAmmoDisplayID = 0;
        uint32 nonRangedAmmoInventoryType = 0;
        for (uint8 i = 0; i < 3; ++i)
        {
            if (uint32 item_id = m_caster->GetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + i))
            {
                if (ItemEntry const* itemEntry = sItemStore.LookupEntry(item_id))
                {
                    if (itemEntry->ClassID == ITEM_CLASS_WEAPON)
                    {
                        switch (itemEntry->SubclassID)
                        {
                            case ITEM_SUBCLASS_WEAPON_THROWN:
                                ammoDisplayID = itemEntry->DisplayInfoID;
                                ammoInventoryType = itemEntry->InventoryType;
                                break;
                            case ITEM_SUBCLASS_WEAPON_BOW:
                            case ITEM_SUBCLASS_WEAPON_CROSSBOW:
                                ammoDisplayID = 5996;       // is this need fixing?
                                ammoInventoryType = INVTYPE_AMMO;
                                break;
                            case ITEM_SUBCLASS_WEAPON_GUN:
                                ammoDisplayID = 5998;       // is this need fixing?
                                ammoInventoryType = INVTYPE_AMMO;
                                break;
                            default:
                                nonRangedAmmoDisplayID = itemEntry->DisplayInfoID;
                                nonRangedAmmoInventoryType = itemEntry->InventoryType;
                                break;
                        }
 
                        if (ammoDisplayID)
                            break;
                    }
                }
            }
        }
 
        if (!ammoDisplayID && !ammoInventoryType)
        {
            ammoDisplayID = nonRangedAmmoDisplayID;
            ammoInventoryType = nonRangedAmmoInventoryType;
        }
    }
 
    *data << uint32(ammoDisplayID);
    *data << uint32(ammoInventoryType);
}

References ItemTemplate::DisplayInfoID, Item::GetTemplate(), Object::GetUInt32Value(), Player::GetWeaponForAttack(), Unit::HasAura(), ItemTemplate::InventoryType, INVTYPE_AMMO, INVTYPE_THROWN, Object::IsPlayer(), ITEM_CLASS_WEAPON, ITEM_SUBCLASS_WEAPON_BOW, ITEM_SUBCLASS_WEAPON_CROSSBOW, ITEM_SUBCLASS_WEAPON_GUN, ITEM_SUBCLASS_WEAPON_THROWN, m_caster, PLAYER_AMMO_ID, RANGED_ATTACK, sItemStore, sObjectMgr, Object::ToPlayer(), and UNIT_VIRTUAL_ITEM_SLOT_ID.

Referenced by SendSpellGo(), and SendSpellStart().

◆ WriteCastResultInfo()

void Spell::WriteCastResultInfo	(	WorldPacket &	data,
		Player *	caster,
		SpellInfo const *	spellInfo,
		uint8	castCount,
		SpellCastResult	result,
		SpellCustomErrors	customError
	)

static

{
    data << uint8(castCount);                               // single cast or multi 2.3 (0/1)
    data << uint32(spellInfo->Id);
    data << uint8(result);                                  // problem
    switch (result)
    {
        case SPELL_FAILED_REQUIRES_SPELL_FOCUS:
            data << uint32(spellInfo->RequiresSpellFocus);  // SpellFocusObject.dbc id
            break;
        case SPELL_FAILED_REQUIRES_AREA:                    // AreaTable.dbc id
            // hardcode areas limitation case
            switch (spellInfo->Id)
            {
                case 41617:                                 // Cenarion Mana Salve
                case 41619:                                 // Cenarion Healing Salve
                    data << uint32(3905);
                    break;
                case 41618:                                 // Bottled Nethergon Energy
                case 41620:                                 // Bottled Nethergon Vapor
                    data << uint32(3842);
                    break;
                case 45373:                                 // Bloodberry Elixir
                    data << uint32(4075);
                    break;
                default:                                    // default case (don't must be)
                    data << uint32(0);
                    break;
            }
            break;
        case SPELL_FAILED_TOTEMS:
            if (spellInfo->Totem[0])
                data << uint32(spellInfo->Totem[0]);
            if (spellInfo->Totem[1])
                data << uint32(spellInfo->Totem[1]);
            break;
        case SPELL_FAILED_TOTEM_CATEGORY:
            if (spellInfo->TotemCategory[0])
                data << uint32(spellInfo->TotemCategory[0]);
            if (spellInfo->TotemCategory[1])
                data << uint32(spellInfo->TotemCategory[1]);
            break;
        case SPELL_FAILED_EQUIPPED_ITEM_CLASS:
        case SPELL_FAILED_EQUIPPED_ITEM_CLASS_MAINHAND:
        case SPELL_FAILED_EQUIPPED_ITEM_CLASS_OFFHAND:
            data << uint32(spellInfo->EquippedItemClass);
            data << uint32(spellInfo->EquippedItemSubClassMask);
            break;
        case SPELL_FAILED_TOO_MANY_OF_ITEM:
            {
                uint32 item = 0;
                for (int8 eff = 0; eff < MAX_SPELL_EFFECTS; eff++)
                    if (spellInfo->Effects[eff].ItemType)
                        item = spellInfo->Effects[eff].ItemType;
                ItemTemplate const* proto = sObjectMgr->GetItemTemplate(item);
                if (proto && proto->ItemLimitCategory)
                    data << uint32(proto->ItemLimitCategory);
                break;
            }
        case SPELL_FAILED_CUSTOM_ERROR:
            data << uint32(customError);
            break;
        case SPELL_FAILED_REAGENTS:
            {
                uint32 missingItem = 0;
                for (uint32 i = 0; i < MAX_SPELL_REAGENTS; i++)
                {
                    if (spellInfo->Reagent[i] <= 0)
                        continue;
 
                    uint32 itemid    = spellInfo->Reagent[i];
                    uint32 itemcount = spellInfo->ReagentCount[i];
 
                    if (!caster->HasItemCount(itemid, itemcount))
                    {
                        missingItem = itemid;
                        break;
                    }
                }
 
                data << uint32(missingItem);  // first missing item
                break;
            }
        case SPELL_FAILED_PREVENTED_BY_MECHANIC:
            data << uint32(spellInfo->Mechanic);
            break;
        case SPELL_FAILED_NEED_EXOTIC_AMMO:
            data << uint32(spellInfo->EquippedItemSubClassMask);
            break;
        case SPELL_FAILED_NEED_MORE_ITEMS:
            data << uint32(0); // Item entry
            data << uint32(0); // Count
            break;
        case SPELL_FAILED_MIN_SKILL:
            data << uint32(0); // SkillLine.dbc Id
            data << uint32(0); // Amount
            break;
        case SPELL_FAILED_FISHING_TOO_LOW:
            data << uint32(0); // Skill level
            break;
        default:
            break;
    }
}

References SpellInfo::Effects, SpellInfo::EquippedItemClass, SpellInfo::EquippedItemSubClassMask, Player::HasItemCount(), SpellInfo::Id, ItemTemplate::ItemLimitCategory, MAX_SPELL_EFFECTS, MAX_SPELL_REAGENTS, SpellInfo::Mechanic, SpellInfo::Reagent, SpellInfo::ReagentCount, SpellInfo::RequiresSpellFocus, sObjectMgr, SPELL_FAILED_CUSTOM_ERROR, SPELL_FAILED_EQUIPPED_ITEM_CLASS, SPELL_FAILED_EQUIPPED_ITEM_CLASS_MAINHAND, SPELL_FAILED_EQUIPPED_ITEM_CLASS_OFFHAND, SPELL_FAILED_FISHING_TOO_LOW, SPELL_FAILED_MIN_SKILL, SPELL_FAILED_NEED_EXOTIC_AMMO, SPELL_FAILED_NEED_MORE_ITEMS, SPELL_FAILED_PREVENTED_BY_MECHANIC, SPELL_FAILED_REAGENTS, SPELL_FAILED_REQUIRES_AREA, SPELL_FAILED_REQUIRES_SPELL_FOCUS, SPELL_FAILED_TOO_MANY_OF_ITEM, SPELL_FAILED_TOTEM_CATEGORY, SPELL_FAILED_TOTEMS, SpellInfo::Totem, and SpellInfo::TotemCategory.

Referenced by SendCastResult(), and SendPetCastResult().

◆ WriteSpellGoTargets()

void Spell::WriteSpellGoTargets ( WorldPacket * data )

Writes miss and hit targets for a SMSG_SPELL_GO packet.

{
    // This function also fill data for channeled spells:
    // m_needAliveTargetMask req for stop channelig if one target die
    for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
    {
        if ((*ihit).effectMask == 0)                  // No effect apply - all immuned add state
            // possibly SPELL_MISS_IMMUNE2 for this??
            ihit->missCondition = SPELL_MISS_IMMUNE2;
    }
 
    // Hit and miss target counts are both uint8, that limits us to 255 targets for each
    // sending more than 255 targets crashes the client (since count sent would be wrong)
    // Spells like 40647 (with a huge radius) can easily reach this limit (spell might need
    // target conditions but we still need to limit the number of targets sent and keeping
    // correct count for both hit and miss).
 
    uint32 hit = 0;
    std::size_t hitPos = data->wpos();
    *data << (uint8)0; // placeholder
    for (std::list<TargetInfo>::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end() && hit < 255; ++ihit)
    {
        if ((*ihit).missCondition == SPELL_MISS_NONE)       // Add only hits
        {
            *data << ihit->targetGUID;
            // Xinef: No channeled spell checked, no anything
            //m_channelTargetEffectMask |=ihit->effectMask;
            ++hit;
        }
    }
 
    for (std::list<GOTargetInfo>::const_iterator ighit = m_UniqueGOTargetInfo.begin(); ighit != m_UniqueGOTargetInfo.end() && hit < 255; ++ighit)
    {
        *data << ighit->targetGUID;                 // Always hits
        ++hit;
    }
 
    uint32 miss = 0;
    std::size_t missPos = data->wpos();
    *data << (uint8)0; // placeholder
    for (std::list<TargetInfo>::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end() && miss < 255; ++ihit)
    {
        if (ihit->missCondition != SPELL_MISS_NONE)        // Add only miss
        {
            *data << ihit->targetGUID;
            *data << uint8(ihit->missCondition);
            if (ihit->missCondition == SPELL_MISS_REFLECT)
                *data << uint8(ihit->reflectResult);
            ++miss;
        }
    }
    // Reset m_needAliveTargetMask for non channeled spell
    // Xinef: Why do we reset something that is not set??????
    //if (!m_spellInfo->IsChanneled())
    //    m_channelTargetEffectMask = 0;
 
    data->put<uint8>(hitPos, (uint8)hit);
    data->put<uint8>(missPos, (uint8)miss);
}