Spell.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "Spell.h"
#include "AzeriteEmpoweredItem.h"
#include "Battlefield.h"
#include "BattlefieldMgr.h"
#include "Battleground.h"
#include "BattlePetMgr.h"
#include "CellImpl.h"
#include "CharmInfo.h"
#include "CollectionMgr.h"
#include "CombatLogPackets.h"
#include "Common.h"
#include "ConditionMgr.h"
#include "Containers.h"
#include "CreatureAI.h"
#include "DB2Stores.h"
#include "DatabaseEnv.h"
#include "DisableMgr.h"
#include "DynamicObject.h"
#include "G3DPosition.hpp"
#include "GameObjectAI.h"
#include "GridNotifiersImpl.h"
#include "Guild.h"
#include "InstanceLockMgr.h"
#include "InstanceScript.h"
#include "Item.h"
#include "Log.h"
#include "Loot.h"
#include "LootMgr.h"
#include "MotionMaster.h"
#include "ObjectAccessor.h"
#include "ObjectMgr.h"
#include "PathGenerator.h"
#include "Pet.h"
#include "PhasingHandler.h"
#include "Player.h"
#include "ScriptMgr.h"
#include "SharedDefines.h"
#include "SpellAuraEffects.h"
#include "SpellHistory.h"
#include "SpellInfo.h"
#include "SpellMgr.h"
#include "SpellPackets.h"
#include "SpellScript.h"
#include "TemporarySummon.h"
#include "TradeData.h"
#include "TraitPackets.h"
#include "UniqueTrackablePtr.h"
#include "Util.h"
#include "VMapFactory.h"
#include "Vehicle.h"
#include "VMapManager2.h"
#include "World.h"
#include "WorldSession.h"
#include <numeric>
#include <sstream>
 
extern NonDefaultConstructible<SpellEffectHandlerFn> SpellEffectHandlers[TOTAL_SPELL_EFFECTS];
 
SpellDestination::SpellDestination()
{
 _position.Relocate(0, 0, 0, 0);
 _transportGUID.Clear();
 _transportOffset.Relocate(0, 0, 0, 0);
}
 
SpellDestination::SpellDestination(float x, float y, float z, float orientation, uint32 mapId)
{
 _position.Relocate(x, y, z, orientation);
 _transportGUID.Clear();
 _position.m_mapId = mapId;
 _transportOffset.Relocate(0, 0, 0, 0);
}
 
SpellDestination::SpellDestination(Position const& pos)
{
 _position.Relocate(pos);
 _transportGUID.Clear();
 _transportOffset.Relocate(0, 0, 0, 0);
}
 
SpellDestination::SpellDestination(WorldLocation const& loc)
{
 _position.WorldRelocate(loc);
 _transportGUID.Clear();
 _transportOffset.Relocate(0, 0, 0, 0);
}
 
SpellDestination::SpellDestination(WorldObject const& wObj)
{
 _transportGUID = wObj.GetTransGUID();
 _transportOffset.Relocate(wObj.GetTransOffsetX(), wObj.GetTransOffsetY(), wObj.GetTransOffsetZ(), wObj.GetTransOffsetO());
 _position.Relocate(wObj);
}
 
void SpellDestination::Relocate(Position const& pos)
{
 if (!_transportGUID.IsEmpty())
 {
 Position offset;
 _position.GetPositionOffsetTo(pos, offset);
 _transportOffset.RelocateOffset(offset);
 }
 _position.Relocate(pos);
}
 
void SpellDestination::RelocateOffset(Position const& offset)
{
 if (!_transportGUID.IsEmpty())
 _transportOffset.RelocateOffset(offset);
 
 _position.RelocateOffset(offset);
}
 
SpellCastTargets::SpellCastTargets() : m_targetMask(0), m_objectTarget(nullptr), m_itemTarget(nullptr),
 m_itemTargetEntry(0), m_pitch(0.0f), m_speed(0.0f)
{
}
 
SpellCastTargets::SpellCastTargets(Unit* caster, WorldPackets::Spells::SpellCastRequest const& spellCastRequest) :
 m_targetMask(spellCastRequest.Target.Flags), m_objectTarget(nullptr), m_itemTarget(nullptr),
 m_objectTargetGUID(spellCastRequest.Target.Unit), m_itemTargetGUID(spellCastRequest.Target.Item),
 m_itemTargetEntry(0), m_pitch(0.0f), m_speed(0.0f), m_strTarget(spellCastRequest.Target.Name)
{
 if (spellCastRequest.Target.SrcLocation)
 {
 m_src._transportGUID = spellCastRequest.Target.SrcLocation->Transport;
 Position* pos;
 if (!m_src._transportGUID.IsEmpty())
 pos = &m_src._transportOffset;
 else
 pos = &m_src._position;
 
 pos->Relocate(spellCastRequest.Target.SrcLocation->Location.Pos);
 if (spellCastRequest.Target.Orientation)
 pos->SetOrientation(*spellCastRequest.Target.Orientation);
 }
 
 if (spellCastRequest.Target.DstLocation)
 {
 m_dst._transportGUID = spellCastRequest.Target.DstLocation->Transport;
 Position* pos;
 if (!m_dst._transportGUID.IsEmpty())
 pos = &m_dst._transportOffset;
 else
 pos = &m_dst._position;
 
 pos->Relocate(spellCastRequest.Target.DstLocation->Location.Pos);
 if (spellCastRequest.Target.Orientation)
 pos->SetOrientation(*spellCastRequest.Target.Orientation);
 }
 
 SetPitch(spellCastRequest.MissileTrajectory.Pitch);
 SetSpeed(spellCastRequest.MissileTrajectory.Speed);
 
 Update(caster);
}
 
SpellCastTargets::~SpellCastTargets() { }
 
void SpellCastTargets::Write(WorldPackets::Spells::SpellTargetData& data)
{
 data.Flags = m_targetMask;
 
 if (m_targetMask & (TARGET_FLAG_UNIT | TARGET_FLAG_CORPSE_ALLY | TARGET_FLAG_GAMEOBJECT | TARGET_FLAG_CORPSE_ENEMY | TARGET_FLAG_UNIT_MINIPET))
 data.Unit = m_objectTargetGUID;
 
 if (m_targetMask & (TARGET_FLAG_ITEM | TARGET_FLAG_TRADE_ITEM) && m_itemTarget)
 data.Item = m_itemTarget->GetGUID();
 
 if (m_targetMask & TARGET_FLAG_SOURCE_LOCATION)
 {
 data.SrcLocation.emplace();
 data.SrcLocation->Transport = m_src._transportGUID; // relative position guid here - transport for example
 if (!m_src._transportGUID.IsEmpty())
 data.SrcLocation->Location = m_src._transportOffset;
 else
 data.SrcLocation->Location = m_src._position;
 }
 
 if (m_targetMask & TARGET_FLAG_DEST_LOCATION)
 {
 data.DstLocation.emplace();
 data.DstLocation->Transport = m_dst._transportGUID; // relative position guid here - transport for example
 if (!m_dst._transportGUID.IsEmpty())
 data.DstLocation->Location = m_dst._transportOffset;
 else
 data.DstLocation->Location = m_dst._position;
 }
 
 if (m_targetMask & TARGET_FLAG_STRING)
 data.Name = m_strTarget;
}
 
ObjectGuid SpellCastTargets::GetUnitTargetGUID() const
{
 if (m_objectTargetGUID.IsUnit())
 return m_objectTargetGUID;
 
 return ObjectGuid::Empty;
}
 
Unit* SpellCastTargets::GetUnitTarget() const
{
 if (m_objectTarget)
 return m_objectTarget->ToUnit();
 
 return nullptr;
}
 
void SpellCastTargets::SetUnitTarget(Unit* target)
{
 if (!target)
 return;
 
 m_objectTarget = target;
 m_objectTargetGUID = target->GetGUID();
 m_targetMask |= TARGET_FLAG_UNIT;
}
 
ObjectGuid SpellCastTargets::GetGOTargetGUID() const
{
 if (m_objectTargetGUID.IsAnyTypeGameObject())
 return m_objectTargetGUID;
 
 return ObjectGuid::Empty;
}
 
GameObject* SpellCastTargets::GetGOTarget() const
{
 if (m_objectTarget)
 return m_objectTarget->ToGameObject();
 
 return nullptr;
}
 
void SpellCastTargets::SetGOTarget(GameObject* target)
{
 if (!target)
 return;
 
 m_objectTarget = target;
 m_objectTargetGUID = target->GetGUID();
 m_targetMask |= TARGET_FLAG_GAMEOBJECT;
}
 
ObjectGuid SpellCastTargets::GetCorpseTargetGUID() const
{
 if (m_objectTargetGUID.IsCorpse())
 return m_objectTargetGUID;
 
 return ObjectGuid::Empty;
}
 
Corpse* SpellCastTargets::GetCorpseTarget() const
{
 if (m_objectTarget)
 return m_objectTarget->ToCorpse();
 
 return nullptr;
}
 
WorldObject* SpellCastTargets::GetObjectTarget() const
{
 return m_objectTarget;
}
 
ObjectGuid SpellCastTargets::GetObjectTargetGUID() const
{
 return m_objectTargetGUID;
}
 
void SpellCastTargets::RemoveObjectTarget()
{
 m_objectTarget = nullptr;
 m_objectTargetGUID.Clear();
 m_targetMask &= ~(TARGET_FLAG_UNIT_MASK | TARGET_FLAG_CORPSE_MASK | TARGET_FLAG_GAMEOBJECT_MASK);
}
 
void SpellCastTargets::SetItemTarget(Item* item)
{
 if (!item)
 return;
 
 m_itemTarget = item;
 m_itemTargetGUID = item->GetGUID();
 m_itemTargetEntry = item->GetEntry();
 m_targetMask |= TARGET_FLAG_ITEM;
}
 
void SpellCastTargets::SetTradeItemTarget(Player* caster)
{
 m_itemTargetGUID = ObjectGuid::TradeItem;
 m_itemTargetEntry = 0;
 m_targetMask |= TARGET_FLAG_TRADE_ITEM;
 
 Update(caster);
}
 
void SpellCastTargets::UpdateTradeSlotItem()
{
 if (m_itemTarget && (m_targetMask & TARGET_FLAG_TRADE_ITEM))
 {
 m_itemTargetGUID = m_itemTarget->GetGUID();
 m_itemTargetEntry = m_itemTarget->GetEntry();
 }
}
 
SpellDestination const* SpellCastTargets::GetSrc() const
{
 return &m_src;
}
 
Position const* SpellCastTargets::GetSrcPos() const
{
 return &m_src._position;
}
 
void SpellCastTargets::SetSrc(float x, float y, float z)
{
 m_src = SpellDestination(x, y, z);
 m_targetMask |= TARGET_FLAG_SOURCE_LOCATION;
}
 
void SpellCastTargets::SetSrc(Position const& pos)
{
 m_src = SpellDestination(pos);
 m_targetMask |= TARGET_FLAG_SOURCE_LOCATION;
}
 
void SpellCastTargets::SetSrc(WorldObject const& wObj)
{
 m_src = SpellDestination(wObj);
 m_targetMask |= TARGET_FLAG_SOURCE_LOCATION;
}
 
void SpellCastTargets::ModSrc(Position const& pos)
{
 ASSERT(m_targetMask & TARGET_FLAG_SOURCE_LOCATION);
 m_src.Relocate(pos);
}
 
void SpellCastTargets::RemoveSrc()
{
 m_targetMask &= ~(TARGET_FLAG_SOURCE_LOCATION);
}
 
SpellDestination const* SpellCastTargets::GetDst() const
{
 return &m_dst;
}
 
WorldLocation const* SpellCastTargets::GetDstPos() const
{
 return &m_dst._position;
}
 
void SpellCastTargets::SetDst(float x, float y, float z, float orientation, uint32 mapId)
{
 m_dst = SpellDestination(x, y, z, orientation, mapId);
 m_targetMask |= TARGET_FLAG_DEST_LOCATION;
}
 
void SpellCastTargets::SetDst(Position const& pos)
{
 m_dst = SpellDestination(pos);
 m_targetMask |= TARGET_FLAG_DEST_LOCATION;
}
 
void SpellCastTargets::SetDst(WorldObject const& wObj)
{
 m_dst = SpellDestination(wObj);
 m_targetMask |= TARGET_FLAG_DEST_LOCATION;
}
 
void SpellCastTargets::SetDst(SpellDestination const& spellDest)
{
 m_dst = spellDest;
 m_targetMask |= TARGET_FLAG_DEST_LOCATION;
}
 
void SpellCastTargets::SetDst(SpellCastTargets const& spellTargets)
{
 m_dst = spellTargets.m_dst;
 m_targetMask |= TARGET_FLAG_DEST_LOCATION;
}
 
void SpellCastTargets::ModDst(Position const& pos)
{
 ASSERT(m_targetMask & TARGET_FLAG_DEST_LOCATION);
 m_dst.Relocate(pos);
}
 
void SpellCastTargets::ModDst(SpellDestination const& spellDest)
{
 ASSERT(m_targetMask & TARGET_FLAG_DEST_LOCATION);
 m_dst = spellDest;
}
 
void SpellCastTargets::RemoveDst()
{
 m_targetMask &= ~(TARGET_FLAG_DEST_LOCATION);
}
 
bool SpellCastTargets::HasSrc() const
{
 return (GetTargetMask() & TARGET_FLAG_SOURCE_LOCATION) != 0;
}
 
bool SpellCastTargets::HasDst() const
{
 return (GetTargetMask() & TARGET_FLAG_DEST_LOCATION) != 0;
}
 
void SpellCastTargets::Update(WorldObject* caster)
{
 m_objectTarget = (m_objectTargetGUID == caster->GetGUID()) ? caster : ObjectAccessor::GetWorldObject(*caster, m_objectTargetGUID);
 
 m_itemTarget = nullptr;
 if (caster->GetTypeId() == TYPEID_PLAYER)
 {
 Player* player = caster->ToPlayer();
 if (m_targetMask & TARGET_FLAG_ITEM)
 m_itemTarget = player->GetItemByGuid(m_itemTargetGUID);
 else if (m_targetMask & TARGET_FLAG_TRADE_ITEM)
 {
 if (m_itemTargetGUID == ObjectGuid::TradeItem)
 if (TradeData* pTrade = player->GetTradeData())
 m_itemTarget = pTrade->GetTraderData()->GetItem(TRADE_SLOT_NONTRADED);
 }
 
 if (m_itemTarget)
 m_itemTargetEntry = m_itemTarget->GetEntry();
 }
 
 // update positions by transport move
 if (HasSrc() && !m_src._transportGUID.IsEmpty())
 {
 if (WorldObject* transport = ObjectAccessor::GetWorldObject(*caster, m_src._transportGUID))
 {
 m_src._position.Relocate(transport);
 m_src._position.RelocateOffset(m_src._transportOffset);
 }
 }
 
 if (HasDst() && !m_dst._transportGUID.IsEmpty())
 {
 if (WorldObject* transport = ObjectAccessor::GetWorldObject(*caster, m_dst._transportGUID))
 {
 m_dst._position.Relocate(transport);
 m_dst._position.RelocateOffset(m_dst._transportOffset);
 }
 }
}
 
SpellValue::SpellValue(SpellInfo const* proto, WorldObject const* caster)
{
 memset(EffectBasePoints, 0, sizeof(EffectBasePoints));
 for (SpellEffectInfo const& spellEffectInfo : proto->GetEffects())
 EffectBasePoints[spellEffectInfo.EffectIndex] = spellEffectInfo.CalcBaseValue(caster, nullptr, 0, -1);
 
 CustomBasePointsMask = 0;
 MaxAffectedTargets = proto->MaxAffectedTargets;
 RadiusMod = 1.0f;
 AuraStackAmount = 1;
 CriticalChance = 0.0f;
 DurationMul = 1;
}
 
class TC_GAME_API SpellEvent : public BasicEvent
{
public:
 explicit SpellEvent(Spell* spell);
 ~SpellEvent();
 
 bool Execute(uint64 e_time, uint32 p_time) override;
 void Abort(uint64 e_time) override;
 bool IsDeletable() const override;
 Spell const* GetSpell() const { return m_Spell.get(); }
 Trinity::unique_weak_ptr<Spell> GetSpellWeakPtr() const { return m_Spell; }
 
 std::string GetDebugInfo() const { return m_Spell->GetDebugInfo(); }
 
protected:
 Trinity::unique_trackable_ptr<Spell> m_Spell;
};
 
Spell::Spell(WorldObject* caster, SpellInfo const* info, TriggerCastFlags triggerFlags, ObjectGuid originalCasterGUID /*= ObjectGuid::Empty*/,
 ObjectGuid originalCastId /*= ObjectGuid::Empty*/) :
m_spellInfo(info), m_caster((info->HasAttribute(SPELL_ATTR6_ORIGINATE_FROM_CONTROLLER) && caster->GetCharmerOrOwner()) ? caster->GetCharmerOrOwner() : caster),
m_spellValue(new SpellValue(m_spellInfo, caster)), _spellEvent(nullptr)
{
 m_customError = SPELL_CUSTOM_ERROR_NONE;
 m_fromClient = false;
 m_selfContainer = nullptr;
 m_referencedFromCurrentSpell = false;
 m_executedCurrently = false;
 m_delayStart = 0;
 m_delayMoment = 0;
 m_delayAtDamageCount = 0;
 
 m_applyMultiplierMask = 0;
 memset(m_damageMultipliers, 0, sizeof(m_damageMultipliers));
 
 // Get data for type of attack
 m_attackType = info->GetAttackType();
 
 m_spellSchoolMask = info->GetSchoolMask(); // Can be override for some spell (wand shoot for example)
 
 if (Player const* playerCaster = m_caster->ToPlayer())
 {
 // wand case
 if (m_attackType == RANGED_ATTACK)
 if ((playerCaster->GetClassMask() & CLASSMASK_WAND_USERS) != 0)
 if (Item* pItem = playerCaster->GetWeaponForAttack(RANGED_ATTACK))
 m_spellSchoolMask = SpellSchoolMask(1 << pItem->GetTemplate()->GetDamageType());
 }
 
 if (Player const* modOwner = caster->GetSpellModOwner())
 modOwner->ApplySpellMod(info, SpellModOp::Doses, m_spellValue->AuraStackAmount, this);
 
 if (!originalCasterGUID.IsEmpty())
 m_originalCasterGUID = originalCasterGUID;
 else
 m_originalCasterGUID = m_caster->GetGUID();
 
 if (m_originalCasterGUID == m_caster->GetGUID())
 m_originalCaster = m_caster->ToUnit();
 else
 {
 m_originalCaster = ObjectAccessor::GetUnit(*m_caster, m_originalCasterGUID);
 if (m_originalCaster && !m_originalCaster->IsInWorld())
 m_originalCaster = nullptr;
 }
 
 m_spellState = SPELL_STATE_NULL;
 _triggeredCastFlags = triggerFlags;
 
 if (info->HasAttribute(SPELL_ATTR2_DO_NOT_REPORT_SPELL_FAILURE))
 _triggeredCastFlags |= TRIGGERED_DONT_REPORT_CAST_ERROR;
 
 if (info->HasAttribute(SPELL_ATTR4_ALLOW_CAST_WHILE_CASTING))
 _triggeredCastFlags |= TRIGGERED_IGNORE_CAST_IN_PROGRESS;
 
 m_CastItem = nullptr;
 m_castItemGUID.Clear();
 m_castItemEntry = 0;
 m_castItemLevel = -1;
 m_castFlagsEx = 0;
 
 if (IsIgnoringCooldowns())
 m_castFlagsEx |= CAST_FLAG_EX_IGNORE_COOLDOWN;
 
 unitTarget = nullptr;
 itemTarget = nullptr;
 gameObjTarget = nullptr;
 m_corpseTarget = nullptr;
 destTarget = nullptr;
 damage = 0;
 targetMissInfo = SPELL_MISS_NONE;
 variance = 0.0f;
 effectHandleMode = SPELL_EFFECT_HANDLE_LAUNCH;
 effectInfo = nullptr;
 m_damage = 0;
 m_healing = 0;
 m_hitMask = PROC_HIT_NONE;
 m_procSpellType = PROC_SPELL_TYPE_NONE;
 focusObject = nullptr;
 m_castId = ObjectGuid::Create<HighGuid::Cast>(SPELL_CAST_SOURCE_NORMAL, m_caster->GetMapId(), m_spellInfo->Id, m_caster->GetMap()->GenerateLowGuid<HighGuid::Cast>());
 m_originalCastId = originalCastId;
 memset(m_misc.Raw.Data, 0, sizeof(m_misc.Raw.Data));
 m_SpellVisual.SpellXSpellVisualID = caster->GetCastSpellXSpellVisualId(m_spellInfo);
 m_triggeredByAuraSpell = nullptr;
 m_procChainLength = caster->IsUnit() ? caster->ToUnit()->GetProcChainLength() : 0;
 _spellAura = nullptr;
 _dynObjAura = nullptr;
 
 //Auto Shot & Shoot (wand)
 m_autoRepeat = m_spellInfo->IsAutoRepeatRangedSpell();
 
 m_runesState = 0;
 m_casttime = 0; // setup to correct value in Spell::prepare, must not be used before.
 m_timer = 0; // will set to castime in prepare
 m_channeledDuration = 0; // will be setup in Spell::handle_immediate
 m_launchHandled = false;
 m_immediateHandled = false;
 
 m_channelTargetEffectMask = 0;
 
 if (m_spellInfo->IsEmpowerSpell())
 m_empower = std::make_unique<EmpowerData>();
 
 // Determine if spell can be reflected back to the caster
 // Patch 1.2 notes: Spell Reflection no longer reflects abilities
 m_canReflect = caster->IsUnit()
 && ((m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MAGIC && !m_spellInfo->HasAttribute(SPELL_ATTR0_IS_ABILITY)) || m_spellInfo->HasAttribute(SPELL_ATTR7_ALLOW_SPELL_REFLECTION))
 && !m_spellInfo->HasAttribute(SPELL_ATTR1_NO_REFLECTION) && !m_spellInfo->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES)
 && !m_spellInfo->IsPassive();
 
 for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
 m_destTargets[i] = SpellDestination(*m_caster);
}
 
Spell::~Spell()
{
 // unload scripts
 for (auto itr = m_loadedScripts.begin(); itr != m_loadedScripts.end(); ++itr)
 {
 (*itr)->_Unload();
 delete (*itr);
 }
 
 if (m_referencedFromCurrentSpell && m_selfContainer && *m_selfContainer == this)
 {
 // Clean the reference to avoid later crash.
 // If this error is repeating, we may have to add an ASSERT to better track down how we get into this case.
 TC_LOG_ERROR("spells", "SPELL: deleting spell for spell ID {}. However, spell still referenced.", m_spellInfo->Id);
 *m_selfContainer = nullptr;
 }
 
 if (m_caster && m_caster->GetTypeId() == TYPEID_PLAYER)
 ASSERT(m_caster->ToPlayer()->m_spellModTakingSpell != this);
 
 delete m_spellValue;
}
 
void Spell::InitExplicitTargets(SpellCastTargets const& targets)
{
 m_targets = targets;
 
 // 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->GetTypeId() == TYPEID_UNIT) && neededTargets & (TARGET_FLAG_UNIT_ENEMY | TARGET_FLAG_UNIT))
 unit = m_caster->ToUnit()->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->ToUnit();
 
 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();
}
 
void Spell::SelectExplicitTargets()
{
 // here go all explicit target changes made to explicit targets after spell prepare phase is finished
 if (Unit* target = m_targets.GetUnitTarget())
 {
 // check for explicit target redirection, for Grounding Totem for example
 if ((m_spellInfo->GetExplicitTargetMask() & TARGET_FLAG_UNIT_ENEMY) ||
 ((m_spellInfo->GetExplicitTargetMask() & TARGET_FLAG_UNIT) && !m_caster->IsFriendlyTo(target)))
 {
 Unit* redirect = nullptr;
 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:
 // should gameobjects cast damagetype melee/ranged spells this needs to be changed
 redirect = ASSERT_NOTNULL(m_caster->ToUnit())->GetMeleeHitRedirectTarget(target, m_spellInfo);
 break;
 default:
 break;
 }
 if (redirect && (redirect != target))
 m_targets.SetUnitTarget(redirect);
 }
 }
}
 
void Spell::SelectSpellTargets()
{
 // select targets for cast phase
 SelectExplicitTargets();
 
 uint32 processedAreaEffectsMask = 0;
 
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 {
 // not call for empty effect.
 // Also some spells use not used effect targets for store targets for dummy effect in triggered spells
 if (!spellEffectInfo.IsEffect())
 continue;
 
 // set expected type of implicit targets to be sent to client
 uint32 implicitTargetMask = GetTargetFlagMask(spellEffectInfo.TargetA.GetObjectType()) | GetTargetFlagMask(spellEffectInfo.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(spellEffectInfo, spellEffectInfo.TargetA, SpellTargetIndex::TargetA, processedAreaEffectsMask);
 SelectEffectImplicitTargets(spellEffectInfo, spellEffectInfo.TargetB, SpellTargetIndex::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(spellEffectInfo);
 
 if (m_targets.HasDst())
 AddDestTarget(*m_targets.GetDst(), spellEffectInfo.EffectIndex);
 
 if (spellEffectInfo.TargetA.GetObjectType() == TARGET_OBJECT_TYPE_UNIT
 || spellEffectInfo.TargetA.GetObjectType() == TARGET_OBJECT_TYPE_UNIT_AND_DEST
 || spellEffectInfo.TargetB.GetObjectType() == TARGET_OBJECT_TYPE_UNIT
 || spellEffectInfo.TargetB.GetObjectType() == TARGET_OBJECT_TYPE_UNIT_AND_DEST)
 {
 if (m_spellInfo->HasAttribute(SPELL_ATTR1_REQUIRE_ALL_TARGETS))
 {
 bool noTargetFound = std::none_of(m_UniqueTargetInfo.begin(), m_UniqueTargetInfo.end(), [effectMask = 1u << spellEffectInfo.EffectIndex](TargetInfo const& target)
 {
 return target.EffectMask & effectMask;
 });
 
 if (noTargetFound)
 {
 SendCastResult(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 finish(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 return;
 }
 }
 if (m_spellInfo->HasAttribute(SPELL_ATTR2_FAIL_ON_ALL_TARGETS_IMMUNE))
 {
 bool anyNonImmuneTargetFound = std::any_of(m_UniqueTargetInfo.begin(), m_UniqueTargetInfo.end(), [effectMask = 1u << spellEffectInfo.EffectIndex](TargetInfo const& target)
 {
 return target.EffectMask & effectMask && target.MissCondition != SPELL_MISS_IMMUNE && target.MissCondition != SPELL_MISS_IMMUNE2;
 });
 
 if (!anyNonImmuneTargetFound)
 {
 SendCastResult(SPELL_FAILED_IMMUNE);
 finish(SPELL_FAILED_IMMUNE);
 return;
 }
 }
 }
 
 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(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 return;
 }
 
 uint32 mask = (1 << spellEffectInfo.EffectIndex);
 for (auto ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
 {
 if (ihit->EffectMask & mask)
 {
 m_channelTargetEffectMask |= mask;
 break;
 }
 }
 }
 }
 
 if (m_targets.HasDst())
 {
 if (m_spellInfo->HasAttribute(SPELL_ATTR8_REQUIRES_LOCATION_TO_BE_ON_LIQUID_SURFACE))
 {
 ZLiquidStatus status = m_caster->GetMap()->GetLiquidStatus(m_caster->GetPhaseShift(),
 m_targets.GetDstPos()->GetPositionX(), m_targets.GetDstPos()->GetPositionY(), m_targets.GetDstPos()->GetPositionZ());
 if (!(status & (LIQUID_MAP_WATER_WALK | LIQUID_MAP_IN_WATER)))
 {
 SendCastResult(SPELL_FAILED_NO_LIQUID);
 finish(SPELL_FAILED_NO_LIQUID);
 return;
 }
 }
 }
 
 if (uint64 dstDelay = CalculateDelayMomentForDst(m_spellInfo->LaunchDelay))
 m_delayMoment = dstDelay;
}
 
uint64 Spell::CalculateDelayMomentForDst(float launchDelay) const
{
 if (m_targets.HasDst())
 {
 if (m_targets.HasTraj())
 {
 float speed = m_targets.GetSpeedXY();
 if (speed > 0.0f)
 return uint64(std::floor((m_targets.GetDist2d() / speed + launchDelay) * 1000.0f));
 }
 else if (m_spellInfo->HasAttribute(SPELL_ATTR9_MISSILE_SPEED_IS_DELAY_IN_SEC))
 return uint64(std::floor((m_spellInfo->Speed + launchDelay) * 1000.0f));
 else if (m_spellInfo->Speed > 0.0f)
 {
 // We should not subtract caster size from dist calculation (fixes execution time desync with animation on client, eg. Malleable Goo cast by PP)
 float dist = m_caster->GetExactDist(*m_targets.GetDstPos());
 return uint64(std::floor((dist / m_spellInfo->Speed + launchDelay) * 1000.0f));
 }
 
 return uint64(std::floor(launchDelay * 1000.0f));
 }
 
 return 0;
}
 
void Spell::RecalculateDelayMomentForDst()
{
 UpdateDelayMomentForDst(CalculateDelayMomentForDst(0.0f));
}
 
void Spell::UpdateDelayMomentForDst(uint64 hitDelay)
{
 m_delayMoment = hitDelay;
 
 if (GetDelayStart())
 m_caster->m_Events.ModifyEventTime(_spellEvent, Milliseconds(GetDelayStart() + m_delayMoment));
}
 
void Spell::UpdateDelayMomentForUnitTarget(Unit* unit, uint64 hitDelay)
{
 auto itr = std::find_if(m_UniqueTargetInfo.begin(), m_UniqueTargetInfo.end(), [unit](Spell::TargetInfo const& targetInfo)
 {
 return targetInfo.TargetGUID == unit->GetGUID();
 });
 
 uint64 oldDelay = itr->TimeDelay;
 itr->TimeDelay = hitDelay;
 
 if (hitDelay && (!m_delayMoment || m_delayMoment > hitDelay))
 m_delayMoment = hitDelay;
 else if (m_delayMoment && oldDelay < hitDelay)
 {
 // if new hit delay is greater than old delay for this target we must check all other spell targets to see if m_delayMoment can be increased
 auto minDelayTargetItr = std::min_element(m_UniqueTargetInfo.begin(), m_UniqueTargetInfo.end(), [](Spell::TargetInfo const& itr, Spell::TargetInfo const& smallest)
 {
 return itr.TimeDelay && itr.TimeDelay < smallest.TimeDelay;
 });
 
 m_delayMoment = minDelayTargetItr->TimeDelay;
 }
 
 if (GetDelayStart())
 m_caster->m_Events.ModifyEventTime(_spellEvent, Milliseconds(GetDelayStart() + m_delayMoment));
}
 
void Spell::SelectEffectImplicitTargets(SpellEffectInfo const& spellEffectInfo, SpellImplicitTargetInfo const& targetType, SpellTargetIndex targetIndex, uint32& processedEffectMask)
{
 if (!targetType.GetTarget())
 return;
 
 uint32 effectMask = 1 << spellEffectInfo.EffectIndex;
 // 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:
 case TARGET_SELECT_CATEGORY_LINE:
 {
 // targets for effect already selected
 if (effectMask & processedEffectMask)
 return;
 std::vector<SpellEffectInfo> const& effects = GetSpellInfo()->GetEffects();
 // choose which targets we can select at once
 for (uint32 j = spellEffectInfo.EffectIndex + 1; j < effects.size(); ++j)
 {
 if (effects[j].IsEffect() &&
 spellEffectInfo.TargetA.GetTarget() == effects[j].TargetA.GetTarget() &&
 spellEffectInfo.TargetB.GetTarget() == effects[j].TargetB.GetTarget() &&
 spellEffectInfo.ImplicitTargetConditions == effects[j].ImplicitTargetConditions &&
 spellEffectInfo.CalcRadius(m_caster, SpellTargetIndex::TargetA) == effects[j].CalcRadius(m_caster, SpellTargetIndex::TargetA) &&
 spellEffectInfo.CalcRadius(m_caster, SpellTargetIndex::TargetB) == effects[j].CalcRadius(m_caster, SpellTargetIndex::TargetB) &&
 spellEffectInfo.EffectAttributes.HasFlag(SpellEffectAttributes::PlayersOnly) == effects[j].EffectAttributes.HasFlag(SpellEffectAttributes::PlayersOnly) &&
 CheckScriptEffectImplicitTargets(spellEffectInfo.EffectIndex, j))
 {
 effectMask |= 1 << j;
 }
 }
 processedEffectMask |= effectMask;
 break;
 }
 default:
 break;
 }
 
 switch (targetType.GetSelectionCategory())
 {
 case TARGET_SELECT_CATEGORY_CHANNEL:
 SelectImplicitChannelTargets(spellEffectInfo, targetType);
 break;
 case TARGET_SELECT_CATEGORY_NEARBY:
 SelectImplicitNearbyTargets(spellEffectInfo, targetType, targetIndex, effectMask);
 break;
 case TARGET_SELECT_CATEGORY_CONE:
 SelectImplicitConeTargets(spellEffectInfo, targetType, targetIndex, effectMask);
 break;
 case TARGET_SELECT_CATEGORY_AREA:
 SelectImplicitAreaTargets(spellEffectInfo, targetType, targetIndex, effectMask);
 break;
 case TARGET_SELECT_CATEGORY_TRAJ:
 // just in case there is no dest, explanation in SelectImplicitDestDestTargets
 CheckDst();
 
 SelectImplicitTrajTargets(spellEffectInfo, targetType);
 break;
 case TARGET_SELECT_CATEGORY_LINE:
 SelectImplicitLineTargets(spellEffectInfo, targetType, targetIndex, effectMask);
 break;
 case TARGET_SELECT_CATEGORY_DEFAULT:
 switch (targetType.GetObjectType())
 {
 case TARGET_OBJECT_TYPE_SRC:
 switch (targetType.GetReferenceType())
 {
 case TARGET_REFERENCE_TYPE_CASTER:
 m_targets.SetSrc(*m_caster);
 break;
 default:
 ABORT_MSG("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(spellEffectInfo, targetType, targetIndex);
 break;
 case TARGET_REFERENCE_TYPE_TARGET:
 SelectImplicitTargetDestTargets(spellEffectInfo, targetType, targetIndex);
 break;
 case TARGET_REFERENCE_TYPE_DEST:
 SelectImplicitDestDestTargets(spellEffectInfo, targetType, targetIndex);
 break;
 default:
 ABORT_MSG("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(spellEffectInfo, targetType);
 break;
 case TARGET_REFERENCE_TYPE_TARGET:
 SelectImplicitTargetObjectTargets(spellEffectInfo, targetType);
 break;
 default:
 ABORT_MSG("Spell::SelectEffectImplicitTargets: received not implemented select target reference type for TARGET_TYPE_OBJECT");
 break;
 }
 break;
 }
 break;
 case TARGET_SELECT_CATEGORY_NYI:
 TC_LOG_DEBUG("spells", "SPELL: target type {}, found in spellID {}, effect {} is not implemented yet!", m_spellInfo->Id, uint32(spellEffectInfo.EffectIndex), targetType.GetTarget());
 break;
 default:
 ABORT_MSG("Spell::SelectEffectImplicitTargets: received not implemented select target category");
 break;
 }
}
 
void Spell::SelectImplicitChannelTargets(SpellEffectInfo const& spellEffectInfo, SpellImplicitTargetInfo const& targetType)
{
 if (targetType.GetReferenceType() != TARGET_REFERENCE_TYPE_CASTER)
 {
 ABORT_MSG("Spell::SelectImplicitChannelTargets: received not implemented target reference type");
 return;
 }
 
 Spell* channeledSpell = m_originalCaster->GetCurrentSpell(CURRENT_CHANNELED_SPELL);
 if (!channeledSpell)
 {
 TC_LOG_DEBUG("spells", "Spell::SelectImplicitChannelTargets: cannot find channel spell for spell ID {}, effect {}", m_spellInfo->Id, uint32(spellEffectInfo.EffectIndex));
 return;
 }
 switch (targetType.GetTarget())
 {
 case TARGET_UNIT_CHANNEL_TARGET:
 {
 for (ObjectGuid const& channelTarget : m_originalCaster->m_unitData->ChannelObjects)
 {
 WorldObject* target = ObjectAccessor::GetUnit(*m_caster, channelTarget);
 CallScriptObjectTargetSelectHandlers(target, spellEffectInfo.EffectIndex, targetType);
 // unit target may be no longer avalible - teleported out of map for example
 Unit* unitTarget = target ? target->ToUnit() : nullptr;
 if (unitTarget)
 AddUnitTarget(unitTarget, 1 << spellEffectInfo.EffectIndex);
 else
 TC_LOG_DEBUG("spells", "SPELL: cannot find channel spell target for spell ID {}, effect {}", m_spellInfo->Id, uint32(spellEffectInfo.EffectIndex));
 }
 break;
 }
 case TARGET_DEST_CHANNEL_TARGET:
 if (channeledSpell->m_targets.HasDst())
 m_targets.SetDst(channeledSpell->m_targets);
 else
 {
 auto const& channelObjects = m_originalCaster->m_unitData->ChannelObjects;
 WorldObject* target = !channelObjects.empty() ? ObjectAccessor::GetWorldObject(*m_caster, *channelObjects.begin()) : nullptr;
 if (target)
 {
 CallScriptObjectTargetSelectHandlers(target, spellEffectInfo.EffectIndex, targetType);
 if (target)
 {
 SpellDestination dest(*target);
 if (m_spellInfo->HasAttribute(SPELL_ATTR4_USE_FACING_FROM_SPELL))
 dest._position.SetOrientation(spellEffectInfo.PositionFacing);
 
 CallScriptDestinationTargetSelectHandlers(dest, spellEffectInfo.EffectIndex, targetType);
 m_targets.SetDst(dest);
 }
 }
 else
 TC_LOG_DEBUG("spells", "SPELL: cannot find channel spell destination for spell ID {}, effect {}", m_spellInfo->Id, uint32(spellEffectInfo.EffectIndex));
 }
 break;
 case TARGET_DEST_CHANNEL_CASTER:
 {
 SpellDestination dest(*channeledSpell->GetCaster());
 if (m_spellInfo->HasAttribute(SPELL_ATTR4_USE_FACING_FROM_SPELL))
 dest._position.SetOrientation(spellEffectInfo.PositionFacing);
 
 CallScriptDestinationTargetSelectHandlers(dest, spellEffectInfo.EffectIndex, targetType);
 m_targets.SetDst(dest);
 break;
 }
 default:
 ABORT_MSG("Spell::SelectImplicitChannelTargets: received not implemented target type");
 break;
 }
}
 
void Spell::SelectImplicitNearbyTargets(SpellEffectInfo const& spellEffectInfo, SpellImplicitTargetInfo const& targetType, SpellTargetIndex targetIndex, uint32 effMask)
{
 if (targetType.GetReferenceType() != TARGET_REFERENCE_TYPE_CASTER)
 {
 ABORT_MSG("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(IsPositive(), m_caster, this);
 break;
 default:
 ABORT_MSG("Spell::SelectImplicitNearbyTargets: received not implemented selection check type");
 break;
 }
 
 ConditionContainer* condList = spellEffectInfo.ImplicitTargetConditions.get();
 
 // handle emergency case - try to use other provided targets if no conditions provided
 if (targetType.GetCheckType() == TARGET_CHECK_ENTRY && (!condList || condList->empty()))
 {
 TC_LOG_DEBUG("spells", "Spell::SelectImplicitNearbyTargets: no conditions entry for target with TARGET_CHECK_ENTRY of spell ID {}, effect {} - selecting default targets", m_spellInfo->Id, uint32(spellEffectInfo.EffectIndex));
 switch (targetType.GetObjectType())
 {
 case TARGET_OBJECT_TYPE_GOBJ:
 if (m_spellInfo->RequiresSpellFocus)
 {
 if (focusObject)
 AddGOTarget(focusObject, effMask);
 else
 {
 SendCastResult(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 finish(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 }
 return;
 }
 break;
 case TARGET_OBJECT_TYPE_DEST:
 if (m_spellInfo->RequiresSpellFocus)
 {
 if (focusObject)
 {
 SpellDestination dest(*focusObject);
 if (m_spellInfo->HasAttribute(SPELL_ATTR4_USE_FACING_FROM_SPELL))
 dest._position.SetOrientation(spellEffectInfo.PositionFacing);
 
 CallScriptDestinationTargetSelectHandlers(dest, spellEffectInfo.EffectIndex, targetType);
 m_targets.SetDst(dest);
 }
 else
 {
 SendCastResult(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 finish(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 }
 return;
 }
 if (targetType.GetTarget() == TARGET_DEST_NEARBY_ENTRY_OR_DB)
 {
 if (SpellTargetPosition const* st = sSpellMgr->GetSpellTargetPosition(m_spellInfo->Id, spellEffectInfo.EffectIndex))
 {
 SpellDestination dest(*m_caster);
 if (st->target_mapId == m_caster->GetMapId() && m_caster->IsInDist(st->target_X, st->target_Y, st->target_Z, range))
 dest = SpellDestination(st->target_X, st->target_Y, st->target_Z, st->target_Orientation);
 else
 {
 float randomRadius = spellEffectInfo.CalcRadius(m_caster, targetIndex);
 if (randomRadius > 0.0f)
 MovePosition(dest._position, m_caster, randomRadius, targetType.CalcDirectionAngle());
 }
 
 CallScriptDestinationTargetSelectHandlers(dest, spellEffectInfo.EffectIndex, targetType);
 m_targets.SetDst(dest);
 return;
 }
 }
 break;
 default:
 break;
 }
 }
 
 WorldObject* target = SearchNearbyTarget(spellEffectInfo, range, targetType.GetObjectType(), targetType.GetCheckType(), condList);
 float randomRadius = 0.0f;
 switch (targetType.GetTarget())
 {
 case TARGET_DEST_NEARBY_ENTRY_OR_DB:
 // if we are here then there was no db target
 if (!target)
 {
 target = m_caster;
 // radius is only meant to be randomized when using caster fallback
 randomRadius = spellEffectInfo.CalcRadius(m_caster, targetIndex);
 }
 break;
 default:
 break;
 }
 
 if (!target)
 {
 TC_LOG_DEBUG("spells", "Spell::SelectImplicitNearbyTargets: cannot find nearby target for spell ID {}, effect {}", m_spellInfo->Id, uint32(spellEffectInfo.EffectIndex));
 SendCastResult(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 finish(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 return;
 }
 
 CallScriptObjectTargetSelectHandlers(target, spellEffectInfo.EffectIndex, targetType);
 if (!target)
 {
 TC_LOG_DEBUG("spells", "Spell::SelectImplicitNearbyTargets: OnObjectTargetSelect script hook for spell Id {} set NULL target, effect {}", m_spellInfo->Id, uint32(spellEffectInfo.EffectIndex));
 SendCastResult(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 finish(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 return;
 }
 
 switch (targetType.GetObjectType())
 {
 case TARGET_OBJECT_TYPE_UNIT:
 if (Unit* unit = target->ToUnit())
 AddUnitTarget(unit, effMask, true, false);
 else
 {
 TC_LOG_DEBUG("spells", "Spell::SelectImplicitNearbyTargets: OnObjectTargetSelect script hook for spell Id {} set object of wrong type, expected unit, got {}, effect {}", m_spellInfo->Id, target->GetGUID().GetTypeName(), effMask);
 SendCastResult(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 finish(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 return;
 }
 break;
 case TARGET_OBJECT_TYPE_GOBJ:
 if (GameObject* gobjTarget = target->ToGameObject())
 AddGOTarget(gobjTarget, effMask);
 else
 {
 TC_LOG_DEBUG("spells", "Spell::SelectImplicitNearbyTargets: OnObjectTargetSelect script hook for spell Id {} set object of wrong type, expected gameobject, got {}, effect {}", m_spellInfo->Id, target->GetGUID().GetTypeName(), effMask);
 SendCastResult(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 finish(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 return;
 }
 break;
 case TARGET_OBJECT_TYPE_CORPSE:
 if (Corpse* corpseTarget = target->ToCorpse())
 AddCorpseTarget(corpseTarget, effMask);
 else
 {
 TC_LOG_DEBUG("spells", "Spell::SelectImplicitNearbyTargets: OnObjectTargetSelect script hook for spell Id {} set object of wrong type, expected corpse, got {}, effect {}", m_spellInfo->Id, target->GetGUID().GetTypeName(), effMask);
 SendCastResult(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 finish(SPELL_FAILED_BAD_IMPLICIT_TARGETS);
 return;
 }
 break;
 case TARGET_OBJECT_TYPE_DEST:
 {
 SpellDestination dest(*target);
 if (randomRadius > 0.0f)
 MovePosition(dest._position, target, randomRadius, targetType.CalcDirectionAngle());
 
 if (m_spellInfo->HasAttribute(SPELL_ATTR4_USE_FACING_FROM_SPELL))
 dest._position.SetOrientation(spellEffectInfo.PositionFacing);
 
 CallScriptDestinationTargetSelectHandlers(dest, spellEffectInfo.EffectIndex, targetType);
 m_targets.SetDst(dest);
 break;
 }
 default:
 ABORT_MSG("Spell::SelectImplicitNearbyTargets: received not implemented target object type");
 break;
 }
 
 SelectImplicitChainTargets(spellEffectInfo, targetType, target, effMask);
}
 
void Spell::SelectImplicitConeTargets(SpellEffectInfo const& spellEffectInfo, SpellImplicitTargetInfo const& targetType, SpellTargetIndex targetIndex, uint32 effMask)
{
 Position coneSrc(*m_caster);
 float coneAngle = m_spellInfo->ConeAngle;
 switch (targetType.GetReferenceType())
 {
 case TARGET_REFERENCE_TYPE_CASTER:
 break;
 case TARGET_REFERENCE_TYPE_DEST:
 if (m_caster->GetExactDist2d(m_targets.GetDstPos()) > 0.1f)
 coneSrc.SetOrientation(m_caster->GetAbsoluteAngle(m_targets.GetDstPos()));
 break;
 default:
 break;
 }
 
 switch (targetType.GetTarget())
 {
 case TARGET_UNIT_CONE_180_DEG_ENEMY:
 if (coneAngle == 0.0f)
 coneAngle = 180.0f;
 break;
 default:
 break;
 }
 
 std::list<WorldObject*> targets;
 SpellTargetObjectTypes objectType = targetType.GetObjectType();
 SpellTargetCheckTypes selectionType = targetType.GetCheckType();
 ConditionContainer* condList = spellEffectInfo.ImplicitTargetConditions.get();
 float radius = spellEffectInfo.CalcRadius(m_caster, targetIndex) * m_spellValue->RadiusMod;
 
 if (uint32 containerTypeMask = GetSearcherTypeMask(m_spellInfo, spellEffectInfo, objectType, condList))
 {
 float extraSearchRadius = radius > 0.0f ? EXTRA_CELL_SEARCH_RADIUS : 0.0f;
 Trinity::WorldObjectSpellConeTargetCheck check(coneSrc, DegToRad(coneAngle), m_spellInfo->Width ? m_spellInfo->Width : m_caster->GetCombatReach(), radius, m_caster, m_spellInfo, selectionType, condList, objectType);
 Trinity::WorldObjectListSearcher<Trinity::WorldObjectSpellConeTargetCheck> searcher(m_caster, targets, check, containerTypeMask);
 SearchTargets<Trinity::WorldObjectListSearcher<Trinity::WorldObjectSpellConeTargetCheck> >(searcher, containerTypeMask, m_caster, m_caster, radius + extraSearchRadius);
 
 CallScriptObjectAreaTargetSelectHandlers(targets, spellEffectInfo.EffectIndex, targetType);
 
 if (!targets.empty())
 {
 // Other special target selection goes here
 if (uint32 maxTargets = m_spellValue->MaxAffectedTargets)
 Trinity::Containers::RandomResize(targets, maxTargets);
 
 for (WorldObject* itr : targets)
 {
 if (Unit* unit = itr->ToUnit())
 AddUnitTarget(unit, effMask, false);
 else if (GameObject* gObjTarget = itr->ToGameObject())
 AddGOTarget(gObjTarget, effMask);
 else if (Corpse* corpse = itr->ToCorpse())
 AddCorpseTarget(corpse, effMask);
 }
 }
 }
}
 
void Spell::SelectImplicitAreaTargets(SpellEffectInfo const& spellEffectInfo, SpellImplicitTargetInfo const& targetType, SpellTargetIndex targetIndex, uint32 effMask)
{
 WorldObject* 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:
 {
 referer = m_caster;
 
 // find last added target for this effect
 for (auto ihit = m_UniqueTargetInfo.rbegin(); ihit != m_UniqueTargetInfo.rend(); ++ihit)
 {
 if (ihit->EffectMask & (1 << spellEffectInfo.EffectIndex))
 {
 referer = ObjectAccessor::GetUnit(*m_caster, ihit->TargetGUID);
 break;
 }
 }
 break;
 }
 default:
 ABORT_MSG("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:
 ABORT_MSG("Spell::SelectImplicitAreaTargets: received not implemented target reference type");
 return;
 }
 
 float radius = spellEffectInfo.CalcRadius(m_caster, targetIndex) * m_spellValue->RadiusMod;
 std::list<WorldObject*> targets;
 switch (targetType.GetTarget())
 {
 case TARGET_UNIT_CASTER_AND_PASSENGERS:
 targets.push_back(m_caster);
 if (Unit* unit = m_caster->ToUnit())
 if (Vehicle const* vehicleKit = unit->GetVehicleKit())
 for (int8 seat = 0; seat < MAX_VEHICLE_SEATS; ++seat)
 if (Unit* passenger = vehicleKit->GetPassenger(seat))
 targets.push_back(passenger);
 break;
 case TARGET_UNIT_TARGET_ALLY_OR_RAID:
 if (Unit* targetedUnit = m_targets.GetUnitTarget())
 {
 if (!m_caster->IsUnit() || !m_caster->ToUnit()->IsInRaidWith(targetedUnit))
 targets.push_back(m_targets.GetUnitTarget());
 else
 SearchAreaTargets(targets, spellEffectInfo, radius, targetedUnit, referer, targetType.GetObjectType(), targetType.GetCheckType(),
 spellEffectInfo.ImplicitTargetConditions.get(), Trinity::WorldObjectSpellAreaTargetSearchReason::Area);
 }
 break;
 case TARGET_UNIT_CASTER_AND_SUMMONS:
 targets.push_back(m_caster);
 SearchAreaTargets(targets, spellEffectInfo, radius, center, referer, targetType.GetObjectType(), targetType.GetCheckType(),
 spellEffectInfo.ImplicitTargetConditions.get(), Trinity::WorldObjectSpellAreaTargetSearchReason::Area);
 break;
 case TARGET_UNIT_AREA_THREAT_LIST:
 if (Unit* unit = m_caster->ToUnit())
 for (ThreatReference const* threatRef : unit->GetThreatManager().GetUnsortedThreatList())
 if (Unit* threateningUnit = threatRef->GetVictim())
 targets.push_back(threateningUnit);
 break;
 case TARGET_UNIT_AREA_TAP_LIST:
 if (Creature* creature = m_caster->ToCreature())
 for (ObjectGuid const& tapperGuid : creature->GetTapList())
 if (Player* tapper = ObjectAccessor::GetPlayer(*m_caster, tapperGuid))
 targets.push_back(tapper);
 break;
 default:
 SearchAreaTargets(targets, spellEffectInfo, radius, center, referer, targetType.GetObjectType(), targetType.GetCheckType(),
 spellEffectInfo.ImplicitTargetConditions.get(), Trinity::WorldObjectSpellAreaTargetSearchReason::Area);
 break;
 }
 
 if (targetType.GetObjectType() == TARGET_OBJECT_TYPE_UNIT_AND_DEST)
 {
 SpellDestination dest(*referer);
 if (m_spellInfo->HasAttribute(SPELL_ATTR4_USE_FACING_FROM_SPELL))
 dest._position.SetOrientation(spellEffectInfo.PositionFacing);
 
 CallScriptDestinationTargetSelectHandlers(dest, spellEffectInfo.EffectIndex, targetType);
 
 m_targets.ModDst(dest);
 }
 
 CallScriptObjectAreaTargetSelectHandlers(targets, spellEffectInfo.EffectIndex, targetType);
 
 if (targetType.GetTarget() == TARGET_UNIT_SRC_AREA_FURTHEST_ENEMY)
 targets.sort(Trinity::ObjectDistanceOrderPred(referer, false));
 
 if (!targets.empty())
 {
 // Other special target selection goes here
 if (uint32 maxTargets = m_spellValue->MaxAffectedTargets)
 {
 if (targetType.GetTarget() != TARGET_UNIT_SRC_AREA_FURTHEST_ENEMY)
 Trinity::Containers::RandomResize(targets, maxTargets);
 else if (targets.size() > maxTargets)
 targets.resize(maxTargets);
 }
 
 for (WorldObject* itr : targets)
 {
 if (Unit* unit = itr->ToUnit())
 AddUnitTarget(unit, effMask, false, true, center);
 else if (GameObject* gObjTarget = itr->ToGameObject())
 AddGOTarget(gObjTarget, effMask);
 else if (Corpse* corpse = itr->ToCorpse())
 AddCorpseTarget(corpse, effMask);
 }
 }
}
 
void Spell::SelectImplicitCasterDestTargets(SpellEffectInfo const& spellEffectInfo, SpellImplicitTargetInfo const& targetType, SpellTargetIndex targetIndex)
{
 SpellDestination dest(*m_caster);
 
 switch (targetType.GetTarget())
 {
 case TARGET_DEST_CASTER:
 break;
 case TARGET_DEST_HOME:
 if (Player* playerCaster = m_caster->ToPlayer())
 dest = SpellDestination(playerCaster->m_homebind);
 break;
 case TARGET_DEST_DB:
 if (SpellTargetPosition const* st = sSpellMgr->GetSpellTargetPosition(m_spellInfo->Id, spellEffectInfo.EffectIndex))
 {
 if (m_spellInfo->HasEffect(SPELL_EFFECT_TELEPORT_UNITS) || m_spellInfo->HasEffect(SPELL_EFFECT_TELEPORT_WITH_SPELL_VISUAL_KIT_LOADING_SCREEN) || 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
 {
 TC_LOG_DEBUG("spells", "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 minDist = m_spellInfo->GetMinRange(true);
 float maxDist = m_spellInfo->GetMaxRange(true);
 float dist = frand(minDist, maxDist);
 float x, y, z;
 float angle = 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_PLAYER_BOUNDING_RADIUS, dist, angle);
 
 float ground = m_caster->GetMapHeight(x, y, z);
 float liquidLevel = VMAP_INVALID_HEIGHT_VALUE;
 LiquidData liquidData;
 if (m_caster->GetMap()->GetLiquidStatus(m_caster->GetPhaseShift(), x, y, z, {}, &liquidData, m_caster->GetCollisionHeight()))
 liquidLevel = liquidData.level;
 
 if (liquidLevel <= ground) // When there is no liquid Map::GetWaterOrGroundLevel returns ground level
 {
 SendCastResult(SPELL_FAILED_NOT_HERE);
 SendChannelUpdate(0, SPELL_FAILED_NOT_HERE);
 finish(SPELL_FAILED_NOT_HERE);
 return;
 }
 
 if (ground + 0.75 > liquidLevel)
 {
 SendCastResult(SPELL_FAILED_TOO_SHALLOW);
 SendChannelUpdate(0, SPELL_FAILED_TOO_SHALLOW);
 finish(SPELL_FAILED_TOO_SHALLOW);
 return;
 }
 
 dest = SpellDestination(x, y, liquidLevel, m_caster->GetOrientation());
 break;
 }
 case TARGET_DEST_CASTER_FRONT_LEAP:
 case TARGET_DEST_CASTER_MOVEMENT_DIRECTION:
 {
 Unit* unitCaster = m_caster->ToUnit();
 if (!unitCaster)
 break;
 
 float dist = spellEffectInfo.CalcRadius(unitCaster, targetIndex);
 float angle = targetType.CalcDirectionAngle();
 if (targetType.GetTarget() == TARGET_DEST_CASTER_MOVEMENT_DIRECTION)
 {
 angle = [&]()
 {
 switch (m_caster->m_movementInfo.GetMovementFlags() & (MOVEMENTFLAG_FORWARD | MOVEMENTFLAG_BACKWARD | MOVEMENTFLAG_STRAFE_LEFT | MOVEMENTFLAG_STRAFE_RIGHT))
 {
 case MOVEMENTFLAG_NONE:
 case MOVEMENTFLAG_FORWARD:
 case MOVEMENTFLAG_FORWARD | MOVEMENTFLAG_BACKWARD:
 case MOVEMENTFLAG_STRAFE_LEFT | MOVEMENTFLAG_STRAFE_RIGHT:
 case MOVEMENTFLAG_FORWARD | MOVEMENTFLAG_STRAFE_LEFT | MOVEMENTFLAG_STRAFE_RIGHT:
 case MOVEMENTFLAG_FORWARD | MOVEMENTFLAG_BACKWARD | MOVEMENTFLAG_STRAFE_LEFT | MOVEMENTFLAG_STRAFE_RIGHT:
 return 0.0f;
 case MOVEMENTFLAG_BACKWARD:
 case MOVEMENTFLAG_BACKWARD | MOVEMENTFLAG_STRAFE_LEFT | MOVEMENTFLAG_STRAFE_RIGHT:
 return static_cast<float>(M_PI);
 case MOVEMENTFLAG_STRAFE_LEFT:
 case MOVEMENTFLAG_FORWARD | MOVEMENTFLAG_BACKWARD | MOVEMENTFLAG_STRAFE_LEFT:
 return static_cast<float>(M_PI / 2);
 case MOVEMENTFLAG_FORWARD | MOVEMENTFLAG_STRAFE_LEFT:
 return static_cast<float>(M_PI / 4);
 case MOVEMENTFLAG_BACKWARD | MOVEMENTFLAG_STRAFE_LEFT:
 return static_cast<float>(3 * M_PI / 4);
 case MOVEMENTFLAG_STRAFE_RIGHT:
 case MOVEMENTFLAG_FORWARD | MOVEMENTFLAG_BACKWARD | MOVEMENTFLAG_STRAFE_RIGHT:
 return static_cast<float>(-M_PI / 2);
 case MOVEMENTFLAG_FORWARD | MOVEMENTFLAG_STRAFE_RIGHT:
 return static_cast<float>(-M_PI / 4);
 case MOVEMENTFLAG_BACKWARD | MOVEMENTFLAG_STRAFE_RIGHT:
 return static_cast<float>(-3 * M_PI / 4);
 default:
 return 0.0f;
 }
 }();
 }
 
 Position pos = dest._position;
 
 MovePosition(pos, unitCaster, dist, angle);
 dest.Relocate(pos);
 break;
 }
 case TARGET_DEST_CASTER_GROUND:
 case TARGET_DEST_CASTER_GROUND_2:
 dest._position.m_positionZ = m_caster->GetMapWaterOrGroundLevel(dest._position.GetPositionX(), dest._position.GetPositionY(), dest._position.GetPositionZ());
 break;
 case TARGET_DEST_SUMMONER:
 if (Unit const* unitCaster = m_caster->ToUnit())
 if (TempSummon const* casterSummon = unitCaster->ToTempSummon())
 if (WorldObject const* summoner = casterSummon->GetSummoner())
 dest = SpellDestination(*summoner);
 break;
 default:
 {
 float dist = spellEffectInfo.CalcRadius(m_caster, targetIndex);
 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);
 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 (!spellEffectInfo.HasRadius(targetIndex))
 dist = DefaultTotemDistance;
 break;
 }
 default:
 break;
 }
 
 if (dist < objSize)
 dist = objSize;
 
 Position pos = dest._position;
 MovePosition(pos, m_caster, dist, angle);
 
 dest.Relocate(pos);
 break;
 }
 }
 
 if (m_spellInfo->HasAttribute(SPELL_ATTR4_USE_FACING_FROM_SPELL))
 dest._position.SetOrientation(spellEffectInfo.PositionFacing);
 
 CallScriptDestinationTargetSelectHandlers(dest, spellEffectInfo.EffectIndex, targetType);
 m_targets.SetDst(dest);
}
 
void Spell::SelectImplicitTargetDestTargets(SpellEffectInfo const& spellEffectInfo, SpellImplicitTargetInfo const& targetType, SpellTargetIndex targetIndex)
{
 ASSERT(m_targets.GetObjectTarget() && "Spell::SelectImplicitTargetDestTargets - no explicit object target available!");
 WorldObject* target = m_targets.GetObjectTarget();
 
 SpellDestination dest(*target);
 
 switch (targetType.GetTarget())
 {
 case TARGET_DEST_TARGET_ENEMY:
 case TARGET_DEST_TARGET_ANY:
 case TARGET_DEST_TARGET_ALLY:
 break;
 default:
 {
 float angle = targetType.CalcDirectionAngle();
 float dist = spellEffectInfo.CalcRadius(nullptr, targetIndex);
 
 Position pos = dest._position;
 MovePosition(pos, target, dist, angle);
 
 dest.Relocate(pos);
 break;
 }
 }
 
 if (m_spellInfo->HasAttribute(SPELL_ATTR4_USE_FACING_FROM_SPELL))
 dest._position.SetOrientation(spellEffectInfo.PositionFacing);
 
 CallScriptDestinationTargetSelectHandlers(dest, spellEffectInfo.EffectIndex, targetType);
 m_targets.SetDst(dest);
}
 
void Spell::SelectImplicitDestDestTargets(SpellEffectInfo const& spellEffectInfo, SpellImplicitTargetInfo const& targetType, SpellTargetIndex targetIndex)
{
 // 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:
 break;
 case TARGET_DEST_DEST_GROUND:
 dest._position.m_positionZ = m_caster->GetMapHeight(dest._position.GetPositionX(), dest._position.GetPositionY(), dest._position.GetPositionZ());
 break;
 case TARGET_DEST_DEST_TARGET_TOWARDS_CASTER:
 {
 float dist = spellEffectInfo.CalcRadius(m_caster, targetIndex);
 Position pos = dest._position;
 float angle = pos.GetAbsoluteAngle(m_caster) - m_caster->GetOrientation();
 
 MovePosition(pos, m_caster, dist, angle);
 pos.SetOrientation(m_caster->GetAbsoluteAngle(dest._position));
 
 dest.Relocate(pos);
 break;
 }
 default:
 {
 float angle = targetType.CalcDirectionAngle();
 float dist = spellEffectInfo.CalcRadius(m_caster, targetIndex);
 
 Position pos = dest._position;
 MovePosition(pos, m_caster, dist, angle);
 
 dest.Relocate(pos);
 break;
 }
 }
 
 if (m_spellInfo->HasAttribute(SPELL_ATTR4_USE_FACING_FROM_SPELL))
 dest._position.SetOrientation(spellEffectInfo.PositionFacing);
 
 CallScriptDestinationTargetSelectHandlers(dest, spellEffectInfo.EffectIndex, targetType);
 m_targets.ModDst(dest);
}
 
void Spell::SelectImplicitCasterObjectTargets(SpellEffectInfo const& spellEffectInfo, 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:
 if (Unit* unitCaster = m_caster->ToUnit())
 target = unitCaster->GetGuardianPet();
 break;
 case TARGET_UNIT_SUMMONER:
 if (Unit* unitCaster = m_caster->ToUnit())
 if (unitCaster->IsSummon())
 target = unitCaster->ToTempSummon()->GetSummonerUnit();
 break;
 case TARGET_UNIT_VEHICLE:
 if (Unit* unitCaster = m_caster->ToUnit())
 target = unitCaster->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 (Creature* vehicleBase = m_caster->ToCreature())
 if (vehicleBase->IsVehicle())
 target = vehicleBase->GetVehicleKit()->GetPassenger(targetType.GetTarget() - TARGET_UNIT_PASSENGER_0);
 break;
 case TARGET_UNIT_TARGET_TAP_LIST:
 if (Creature* creatureCaster = m_caster->ToCreature())
 if (!creatureCaster->GetTapList().empty())
 target = ObjectAccessor::GetWorldObject(*creatureCaster, Trinity::Containers::SelectRandomContainerElement(creatureCaster->GetTapList()));
 break;
 case TARGET_UNIT_OWN_CRITTER:
 if (Unit const* unitCaster = m_caster->ToUnit())
 target = ObjectAccessor::GetCreatureOrPetOrVehicle(*m_caster, unitCaster->GetCritterGUID());
 break;
 default:
 break;
 }
 
 CallScriptObjectTargetSelectHandlers(target, spellEffectInfo.EffectIndex, targetType);
 
 if (target)
 {
 if (Unit* unit = target->ToUnit())
 AddUnitTarget(unit, 1 << spellEffectInfo.EffectIndex, checkIfValid);
 else if (GameObject* go = target->ToGameObject())
 AddGOTarget(go, 1 << spellEffectInfo.EffectIndex);
 else if (Corpse* corpse = target->ToCorpse())
 AddCorpseTarget(corpse, 1 << spellEffectInfo.EffectIndex);
 }
}
 
void Spell::SelectImplicitTargetObjectTargets(SpellEffectInfo const& spellEffectInfo, 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, spellEffectInfo.EffectIndex, targetType);
 
 if (target)
 {
 if (Unit* unit = target->ToUnit())
 AddUnitTarget(unit, 1 << spellEffectInfo.EffectIndex, true, false);
 else if (GameObject* gobj = target->ToGameObject())
 AddGOTarget(gobj, 1 << spellEffectInfo.EffectIndex);
 else if (Corpse* corpse = target->ToCorpse())
 AddCorpseTarget(corpse, 1 << spellEffectInfo.EffectIndex);
 
 SelectImplicitChainTargets(spellEffectInfo, targetType, target, 1 << spellEffectInfo.EffectIndex);
 }
 // Script hook can remove object target and we would wrongly land here
 else if (Item* item = m_targets.GetItemTarget())
 AddItemTarget(item, 1 << spellEffectInfo.EffectIndex);
}
 
void Spell::SelectImplicitChainTargets(SpellEffectInfo const& spellEffectInfo, SpellImplicitTargetInfo const& targetType, WorldObject* target, uint32 effMask)
{
 int32 maxTargets = spellEffectInfo.ChainTargets;
 if (Player* modOwner = m_caster->GetSpellModOwner())
 modOwner->ApplySpellMod(m_spellInfo, SpellModOp::ChainTargets, maxTargets, this);
 
 if (maxTargets > 1)
 {
 // mark damage multipliers as used
 for (size_t k = spellEffectInfo.EffectIndex; k < m_spellInfo->GetEffects().size(); ++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()
 , spellEffectInfo, targetType.GetTarget() == TARGET_UNIT_TARGET_CHAINHEAL_ALLY);
 
 // Chain primary target is added earlier
 CallScriptObjectAreaTargetSelectHandlers(targets, spellEffectInfo.EffectIndex, targetType);
 
 Position const* losPosition = m_spellInfo->HasAttribute(SPELL_ATTR2_CHAIN_FROM_CASTER) ? m_caster : target;
 
 for (std::list<WorldObject*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
 {
 if (Unit* unit = (*itr)->ToUnit())
 AddUnitTarget(unit, effMask, false, true, losPosition);
 
 if (!m_spellInfo->HasAttribute(SPELL_ATTR2_CHAIN_FROM_CASTER) && !spellEffectInfo.EffectAttributes.HasFlag(SpellEffectAttributes::ChainFromInitialTarget))
 losPosition = *itr;
 }
 }
}
 
float tangent(float x)
{
 x = std::tan(x);
 //if (x < std::numeric_limits<float>::max() && x > -std::numeric_limits<float>::max()) return x;
 //if (x >= std::numeric_limits<float>::max()) return std::numeric_limits<float>::max();
 //if (x <= -std::numeric_limits<float>::max()) return -std::numeric_limits<float>::max();
 if (x < 100000.0f && x > -100000.0f) return x;
 if (x >= 100000.0f) return 100000.0f;
 if (x <= 100000.0f) return -100000.0f;
 return 0.0f;
}
 
void Spell::SelectImplicitTrajTargets(SpellEffectInfo const& spellEffectInfo, 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;
 Trinity::WorldObjectSpellTrajTargetCheck check(dist2d, &srcPos, m_caster, m_spellInfo, targetType.GetCheckType(), spellEffectInfo.ImplicitTargetConditions.get(), TARGET_OBJECT_TYPE_NONE);
 Trinity::WorldObjectListSearcher<Trinity::WorldObjectSpellTrajTargetCheck> searcher(m_caster, targets, check, GRID_MAP_TYPE_MASK_ALL);
 SearchTargets<Trinity::WorldObjectListSearcher<Trinity::WorldObjectSpellTrajTargetCheck> > (searcher, GRID_MAP_TYPE_MASK_ALL, m_caster, &srcPos, dist2d);
 if (targets.empty())
 return;
 
 targets.sort(Trinity::ObjectDistanceOrderPred(m_caster));
 
 float b = tangent(m_targets.GetPitch());
 float a = (srcToDestDelta - dist2d * b) / (dist2d * dist2d);
 if (a > -0.0001f)
 a = 0.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(spellEffectInfo.TriggerSpell, GetCastDifficulty()))
 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->GetCreatureDifficulty()->TypeFlags & 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());
 if (m_spellInfo->HasAttribute(SPELL_ATTR4_USE_FACING_FROM_SPELL))
 dest._position.SetOrientation(spellEffectInfo.PositionFacing);
 
 CallScriptDestinationTargetSelectHandlers(dest, spellEffectInfo.EffectIndex, targetType);
 m_targets.ModDst(dest);
 }
}
 
void Spell::SelectImplicitLineTargets(SpellEffectInfo const& spellEffectInfo, SpellImplicitTargetInfo const& targetType, SpellTargetIndex targetIndex, uint32 effMask)
{
 std::list<WorldObject*> targets;
 SpellTargetObjectTypes objectType = targetType.GetObjectType();
 SpellTargetCheckTypes selectionType = targetType.GetCheckType();
 Position const* dst = nullptr;
 switch (targetType.GetReferenceType())
 {
 case TARGET_REFERENCE_TYPE_SRC:
 dst = m_targets.GetSrcPos();
 break;
 case TARGET_REFERENCE_TYPE_DEST:
 dst = m_targets.GetDstPos();
 break;
 case TARGET_REFERENCE_TYPE_CASTER:
 dst = m_caster;
 break;
 case TARGET_REFERENCE_TYPE_TARGET:
 dst = m_targets.GetUnitTarget();
 break;
 default:
 ABORT_MSG("Spell::SelectImplicitLineTargets: received not implemented target reference type");
 return;
 }
 
 ConditionContainer* condList = spellEffectInfo.ImplicitTargetConditions.get();
 float radius = spellEffectInfo.CalcRadius(m_caster, targetIndex) * m_spellValue->RadiusMod;
 
 if (uint32 containerTypeMask = GetSearcherTypeMask(m_spellInfo, spellEffectInfo, objectType, condList))
 {
 Trinity::WorldObjectSpellLineTargetCheck check(m_caster, dst, m_spellInfo->Width ? m_spellInfo->Width : m_caster->GetCombatReach(), radius, m_caster, m_spellInfo, selectionType, condList, objectType);
 Trinity::WorldObjectListSearcher<Trinity::WorldObjectSpellLineTargetCheck> searcher(m_caster, targets, check, containerTypeMask);
 SearchTargets<Trinity::WorldObjectListSearcher<Trinity::WorldObjectSpellLineTargetCheck>>(searcher, containerTypeMask, m_caster, m_caster, radius);
 
 CallScriptObjectAreaTargetSelectHandlers(targets, spellEffectInfo.EffectIndex, targetType);
 
 if (!targets.empty())
 {
 // Other special target selection goes here
 if (uint32 maxTargets = m_spellValue->MaxAffectedTargets)
 {
 if (maxTargets < targets.size())
 {
 targets.sort(Trinity::ObjectDistanceOrderPred(m_caster));
 targets.resize(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);
 else if (Corpse* corpse = (*itr)->ToCorpse())
 AddCorpseTarget(corpse, 1 << spellEffectInfo.EffectIndex);
 }
 }
 }
}
 
void Spell::SelectEffectTypeImplicitTargets(SpellEffectInfo const& spellEffectInfo)
{
 // special case for SPELL_EFFECT_SUMMON_RAF_FRIEND and SPELL_EFFECT_SUMMON_PLAYER, queue them on map for later execution
 switch (spellEffectInfo.Effect)
 {
 case SPELL_EFFECT_SUMMON_RAF_FRIEND:
 case SPELL_EFFECT_SUMMON_PLAYER:
 if (m_caster->GetTypeId() == TYPEID_PLAYER && !m_caster->ToPlayer()->GetTarget().IsEmpty())
 {
 WorldObject* target = ObjectAccessor::FindPlayer(m_caster->ToPlayer()->GetTarget());
 CallScriptObjectTargetSelectHandlers(target, spellEffectInfo.EffectIndex, SpellImplicitTargetInfo());
 
 // scripts may modify the target - recheck
 if (target && target->GetTypeId() == TYPEID_PLAYER)
 {
 // target is not stored in target map for those spells
 // since we're completely skipping AddUnitTarget logic, we need to check immunity manually
 // eg. aura 21546 makes target immune to summons
 Player* player = target->ToPlayer();
 if (player->IsImmunedToSpellEffect(m_spellInfo, spellEffectInfo, nullptr))
 return;
 
 target->GetMap()->AddFarSpellCallback([spell = this, &spellEffectInfo, targetGuid = target->GetGUID()](Map* map)
 {
 Player* player = ObjectAccessor::GetPlayer(map, targetGuid);
 if (!player)
 return;
 
 // check immunity again in case it changed during update
 if (player->IsImmunedToSpellEffect(spell->GetSpellInfo(), spellEffectInfo, nullptr))
 return;
 
 spell->HandleEffects(player, nullptr, nullptr, nullptr, spellEffectInfo, SPELL_EFFECT_HANDLE_HIT_TARGET);
 });
 }
 }
 return;
 default:
 break;
 }
 
 // select spell implicit targets based on effect type
 if (!spellEffectInfo.GetImplicitTargetType())
 return;
 
 uint32 targetMask = spellEffectInfo.GetMissingTargetMask();
 
 if (!targetMask)
 return;
 
 WorldObject* target = nullptr;
 
 switch (spellEffectInfo.GetImplicitTargetType())
 {
 // add explicit object target or self to the target map
 case EFFECT_IMPLICIT_TARGET_EXPLICIT:
 // player which not released his spirit is Unit, but target flag for it is TARGET_FLAG_CORPSE_MASK
 if (targetMask & (TARGET_FLAG_UNIT_MASK | TARGET_FLAG_CORPSE_MASK))
 {
 if (Unit* unit = m_targets.GetUnitTarget())
 target = unit;
 else if (targetMask & TARGET_FLAG_CORPSE_MASK)
 {
 if (Corpse* corpseTarget = m_targets.GetCorpseTarget())
 target = corpseTarget;
 }
 else //if (targetMask & TARGET_FLAG_UNIT_MASK)
 target = m_caster;
 }
 if (targetMask & TARGET_FLAG_ITEM_MASK)
 {
 if (Item* item = m_targets.GetItemTarget())
 AddItemTarget(item, 1 << spellEffectInfo.EffectIndex);
 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, spellEffectInfo.EffectIndex, SpellImplicitTargetInfo());
 
 if (target)
 {
 if (target->ToUnit())
 AddUnitTarget(target->ToUnit(), 1 << spellEffectInfo.EffectIndex, false);
 else if (target->ToGameObject())
 AddGOTarget(target->ToGameObject(), 1 << spellEffectInfo.EffectIndex);
 else if (target->ToCorpse())
 AddCorpseTarget(target->ToCorpse(), 1 << spellEffectInfo.EffectIndex);
 }
}
 
uint32 Spell::GetSearcherTypeMask(SpellInfo const* spellInfo, SpellEffectInfo const& spellEffectInfo, SpellTargetObjectTypes objType, ConditionContainer const* 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:
 retMask &= GRID_MAP_TYPE_MASK_PLAYER | GRID_MAP_TYPE_MASK_CREATURE;
 break;
 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 (spellInfo->HasAttribute(SPELL_ATTR3_ONLY_ON_PLAYER) || spellEffectInfo.EffectAttributes.HasFlag(SpellEffectAttributes::PlayersOnly))
 retMask &= GRID_MAP_TYPE_MASK_CORPSE | GRID_MAP_TYPE_MASK_PLAYER;
 if (spellInfo->HasAttribute(SPELL_ATTR3_ONLY_ON_GHOSTS))
 retMask &= GRID_MAP_TYPE_MASK_PLAYER;
 if (spellInfo->HasAttribute(SPELL_ATTR5_NOT_ON_PLAYER))
 retMask &= ~GRID_MAP_TYPE_MASK_PLAYER;
 
 if (condList)
 retMask &= sConditionMgr->GetSearcherTypeMaskForConditionList(*condList);
 return retMask;
}
 
template<class SEARCHER>
void Spell::SearchTargets(SEARCHER& searcher, uint32 containerMask, WorldObject* referer, Position const* pos, float radius)
{
 if (!containerMask)
 return;
 
 // search world and grid for possible targets
 bool searchInGrid = (containerMask & (GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_GAMEOBJECT)) != 0;
 bool searchInWorld = (containerMask & (GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER | GRID_MAP_TYPE_MASK_CORPSE)) != 0;
 if (searchInGrid || searchInWorld)
 {
 float x, y;
 x = pos->GetPositionX();
 y = pos->GetPositionY();
 
 CellCoord p(Trinity::ComputeCellCoord(x, y));
 Cell cell(p);
 cell.SetNoCreate();
 
 Map* map = referer->GetMap();
 
 if (searchInWorld)
 Cell::VisitWorldObjects(x, y, map, searcher, radius);
 
 if (searchInGrid)
 Cell::VisitGridObjects(x, y, map, searcher, radius);
 }
}
 
template TC_GAME_API void Spell::SearchTargets<Trinity::WorldObjectListSearcher<Trinity::WorldObjectSpellAreaTargetCheck>>(Trinity::WorldObjectListSearcher<Trinity::WorldObjectSpellAreaTargetCheck>& searcher, uint32 containerMask, WorldObject* referer, Position const* pos, float radius);
 
WorldObject* Spell::SearchNearbyTarget(SpellEffectInfo const& spellEffectInfo, float range, SpellTargetObjectTypes objectType, SpellTargetCheckTypes selectionType, ConditionContainer const* condList)
{
 WorldObject* target = nullptr;
 uint32 containerTypeMask = GetSearcherTypeMask(m_spellInfo, spellEffectInfo, objectType, condList);
 if (!containerTypeMask)
 return nullptr;
 
 Trinity::WorldObjectSpellNearbyTargetCheck check(range, m_caster, m_spellInfo, selectionType, condList, objectType);
 Trinity::WorldObjectLastSearcher<Trinity::WorldObjectSpellNearbyTargetCheck> searcher(m_caster, target, check, containerTypeMask);
 searcher.i_phaseShift = &PhasingHandler::GetAlwaysVisiblePhaseShift();
 SearchTargets<Trinity::WorldObjectLastSearcher<Trinity::WorldObjectSpellNearbyTargetCheck>>(searcher, containerTypeMask, m_caster, m_caster, range);
 return target;
}
 
void Spell::SearchAreaTargets(std::list<WorldObject*>& targets, SpellEffectInfo const& spellEffectInfo, float range, Position const* position, WorldObject* referer,
 SpellTargetObjectTypes objectType, SpellTargetCheckTypes selectionType, ConditionContainer const* condList,
 Trinity::WorldObjectSpellAreaTargetSearchReason searchReason)
{
 uint32 containerTypeMask = GetSearcherTypeMask(m_spellInfo, spellEffectInfo, objectType, condList);
 if (!containerTypeMask)
 return;
 
 float extraSearchRadius = range > 0.0f ? EXTRA_CELL_SEARCH_RADIUS : 0.0f;
 Trinity::WorldObjectSpellAreaTargetCheck check(range, position, m_caster, referer, m_spellInfo, selectionType, condList, objectType, searchReason);
 Trinity::WorldObjectListSearcher<Trinity::WorldObjectSpellAreaTargetCheck> searcher(m_caster, targets, check, containerTypeMask);
 searcher.i_phaseShift = &PhasingHandler::GetAlwaysVisiblePhaseShift();
 SearchTargets<Trinity::WorldObjectListSearcher<Trinity::WorldObjectSpellAreaTargetCheck>>(searcher, containerTypeMask, m_caster, position, range + extraSearchRadius);
}
 
void Spell::SearchChainTargets(std::list<WorldObject*>& targets, uint32 chainTargets, WorldObject* target, SpellTargetObjectTypes objectType,
 SpellTargetCheckTypes selectType, SpellEffectInfo const& spellEffectInfo, bool isChainHeal)
{
 // max dist for jump target selection
 float jumpRadius = 0.0f;
 switch (m_spellInfo->DmgClass)
 {
 case SPELL_DAMAGE_CLASS_RANGED:
 // 7.5y for multi shot
 jumpRadius = 7.5f;
 break;
 case SPELL_DAMAGE_CLASS_MELEE:
 // 5y for swipe, cleave and similar
 jumpRadius = 5.0f;
 break;
 case SPELL_DAMAGE_CLASS_NONE:
 case SPELL_DAMAGE_CLASS_MAGIC:
 // 12.5y for chain heal spell since 3.2 patch
 if (isChainHeal)
 jumpRadius = 12.5f;
 // 10y as default for magic chain spells
 else
 jumpRadius = 10.0f;
 break;
 }
 
 if (Player* modOwner = m_caster->GetSpellModOwner())
 modOwner->ApplySpellMod(m_spellInfo, SpellModOp::ChainJumpDistance, jumpRadius, this);
 
 // max dist which spell can reach
 float searchRadius = [&]()
 {
 if (m_spellInfo->HasAttribute(SPELL_ATTR2_CHAIN_FROM_CASTER))
 return GetMinMaxRange(false).second;
 
 if (spellEffectInfo.EffectAttributes.HasFlag(SpellEffectAttributes::ChainFromInitialTarget))
 return jumpRadius;
 
 return jumpRadius * chainTargets;
 }();
 
 WorldObject* chainSource = m_spellInfo->HasAttribute(SPELL_ATTR2_CHAIN_FROM_CASTER) ? m_caster : target;
 std::list<WorldObject*> tempTargets;
 SearchAreaTargets(tempTargets, spellEffectInfo, searchRadius, chainSource, m_caster, objectType, selectType, spellEffectInfo.ImplicitTargetConditions.get(),
 Trinity::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 (m_spellInfo->HasAttribute(SPELL_ATTR5_MELEE_CHAIN_TARGETING))
 {
 tempTargets.remove_if([&](WorldObject* object)
 {
 return !m_caster->HasInArc(static_cast<float>(M_PI), object);
 });
 }
 
 while (chainTargets)
 {
 // try to get unit for next chain jump
 std::list<WorldObject*>::iterator foundItr = tempTargets.end();
 // get unit with highest hp deficit in dist
 if (isChainHeal)
 {
 uint32 maxHPDeficit = 0;
 for (std::list<WorldObject*>::iterator itr = tempTargets.begin(); itr != tempTargets.end(); ++itr)
 {
 if (Unit* unit = (*itr)->ToUnit())
 {
 uint32 deficit = unit->GetMaxHealth() - unit->GetHealth();
 if ((deficit > maxHPDeficit || foundItr == tempTargets.end()) && chainSource->IsWithinDist(unit, jumpRadius) && IsWithinLOS(chainSource, unit, false, VMAP::ModelIgnoreFlags::M2))
 {
 foundItr = itr;
 maxHPDeficit = deficit;
 }
 }
 }
 }
 // get closest object
 else
 {
 for (std::list<WorldObject*>::iterator itr = tempTargets.begin(); itr != tempTargets.end(); ++itr)
 {
 bool isBestDistanceMatch = foundItr != tempTargets.end() ? chainSource->GetDistanceOrder(*itr, *foundItr) : chainSource->IsWithinDist(*itr, jumpRadius);
 if (!isBestDistanceMatch)
 continue;
 
 if (!IsWithinLOS(chainSource, *itr, false, VMAP::ModelIgnoreFlags::M2))
 continue;
 
 if (spellEffectInfo.EffectAttributes.HasFlag(SpellEffectAttributes::EnforceLineOfSightToChainTargets) && !IsWithinLOS(m_caster, *itr, false, VMAP::ModelIgnoreFlags::M2))
 continue;
 
 foundItr = itr;
 }
 }
 // not found any valid target - chain ends
 if (foundItr == tempTargets.end())
 break;
 
 if (!m_spellInfo->HasAttribute(SPELL_ATTR2_CHAIN_FROM_CASTER) && !spellEffectInfo.EffectAttributes.HasFlag(SpellEffectAttributes::ChainFromInitialTarget))
 chainSource = *foundItr;
 
 targets.push_back(*foundItr);
 tempTargets.erase(foundItr);
 --chainTargets;
 }
}
 
GameObject* Spell::SearchSpellFocus()
{
 GameObject* focus = nullptr;
 Trinity::GameObjectFocusCheck check(m_caster, m_spellInfo->RequiresSpellFocus);
 Trinity::GameObjectSearcher<Trinity::GameObjectFocusCheck> searcher(m_caster, focus, check);
 SearchTargets(searcher, GRID_MAP_TYPE_MASK_GAMEOBJECT, m_caster, m_caster, m_caster->GetVisibilityRange());
 return focus;
}
 
void Spell::prepareDataForTriggerSystem()
{
 //==========================================================================================
 // Now fill data for trigger system, need know:
 // Create base triggers flags for Attacker and Victim (m_procAttacker, m_procVictim and m_hitMask)
 //==========================================================================================
 
 m_procVictim = m_procAttacker = PROC_FLAG_NONE;
 // 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_DEAL_MELEE_ABILITY;
 if (m_attackType == OFF_ATTACK)
 m_procAttacker |= PROC_FLAG_OFF_HAND_WEAPON_SWING;
 else
 m_procAttacker |= PROC_FLAG_MAIN_HAND_WEAPON_SWING;
 m_procVictim = PROC_FLAG_TAKE_MELEE_ABILITY;
 break;
 case SPELL_DAMAGE_CLASS_RANGED:
 // Auto attack
 if (m_spellInfo->HasAttribute(SPELL_ATTR2_AUTO_REPEAT))
 {
 m_procAttacker = PROC_FLAG_DEAL_RANGED_ATTACK;
 m_procVictim = PROC_FLAG_TAKE_RANGED_ATTACK;
 }
 else // Ranged spell attack
 {
 m_procAttacker = PROC_FLAG_DEAL_RANGED_ABILITY;
 m_procVictim = PROC_FLAG_TAKE_RANGED_ABILITY;
 }
 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_DEAL_RANGED_ATTACK;
 m_procVictim = PROC_FLAG_TAKE_RANGED_ATTACK;
 }
 // For other spells trigger procflags are set in Spell::TargetInfo::DoDamageAndTriggers
 // Because spell positivity is dependant on target
 }
}
 
void Spell::CleanupTargetList()
{
 m_UniqueTargetInfo.clear();
 m_UniqueGOTargetInfo.clear();
 m_UniqueItemInfo.clear();
 m_delayMoment = 0;
}
 
class ProcReflectDelayed : public BasicEvent
{
 public:
 ProcReflectDelayed(Unit* owner, ObjectGuid casterGuid) : _victim(owner), _casterGuid(casterGuid) { }
 
 bool Execute(uint64 /*e_time*/, uint32 /*p_time*/) override
 {
 Unit* caster = ObjectAccessor::GetUnit(*_victim, _casterGuid);
 if (!caster)
 return true;
 
 ProcFlags const typeMaskActor = PROC_FLAG_NONE;
 ProcFlags const typeMaskActionTarget = PROC_FLAG_TAKE_HARMFUL_SPELL | PROC_FLAG_TAKE_HARMFUL_ABILITY;
 ProcFlagsSpellType const spellTypeMask = PROC_SPELL_TYPE_DAMAGE | PROC_SPELL_TYPE_NO_DMG_HEAL;
 ProcFlagsSpellPhase const spellPhaseMask = PROC_SPELL_PHASE_NONE;
 ProcFlagsHit const hitMask = PROC_HIT_REFLECT;
 
 Unit::ProcSkillsAndAuras(caster, _victim, typeMaskActor, typeMaskActionTarget, spellTypeMask, spellPhaseMask, hitMask, nullptr, nullptr, nullptr);
 return true;
 }
 
 private:
 Unit* _victim;
 ObjectGuid _casterGuid;
};
 
void Spell::AddUnitTarget(Unit* target, uint32 effectMask, bool checkIfValid /*= true*/, bool implicit /*= true*/, Position const* losPosition /*= nullptr*/)
{
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 if (!spellEffectInfo.IsEffect() || !CheckEffectTarget(target, spellEffectInfo, losPosition))
 effectMask &= ~(1 << spellEffectInfo.EffectIndex);
 
 // no effects left
 if (!effectMask)
 return;
 
 if (checkIfValid)
 if (m_spellInfo->CheckTarget(m_caster, target, implicit) != SPELL_CAST_OK) // skip stealth checks for AOE
 return;
 
 // Check for effect immune skip if immuned
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 if (target->IsImmunedToSpellEffect(m_spellInfo, spellEffectInfo, m_caster))
 effectMask &= ~(1 << spellEffectInfo.EffectIndex);
 
 ObjectGuid targetGUID = target->GetGUID();
 
 // Lookup target in already in list
 auto ihit = std::find_if(std::begin(m_UniqueTargetInfo), std::end(m_UniqueTargetInfo), [targetGUID](TargetInfo const& target) { return target.TargetGUID == targetGUID; });
 if (ihit != std::end(m_UniqueTargetInfo)) // Found in list
 {
 // Immune effects removed from mask
 ihit->EffectMask |= effectMask;
 return;
 }
 
 // This is new target calculate data for him
 
 // Get spell hit result on target
 TargetInfo targetInfo;
 targetInfo.TargetGUID = targetGUID; // Store target GUID
 targetInfo.EffectMask = effectMask; // Store all effects not immune
 targetInfo.IsAlive = target->IsAlive();
 targetInfo.Damage = 0;
 targetInfo.Healing = 0;
 targetInfo.IsCrit = false;
 
 // Calculate hit result
 WorldObject* caster = m_originalCaster ? m_originalCaster : m_caster;
 targetInfo.MissCondition = caster->SpellHitResult(target, m_spellInfo, m_canReflect && !(IsPositive() && m_caster->IsFriendlyTo(target)));
 
 // Spell have speed - need calculate incoming time
 // Incoming time is zero for self casts. At least I think so.
 if (m_caster != target)
 {
 float hitDelay = m_spellInfo->LaunchDelay;
 WorldObject const* missileSource = m_caster;
 if (m_spellInfo->HasAttribute(SPELL_ATTR4_BOUNCY_CHAIN_MISSILES))
 {
 auto previousTargetItr = std::find_if(m_UniqueTargetInfo.rbegin(), m_UniqueTargetInfo.rend(), [effectMask](TargetInfo const& target)
 {
 return (target.EffectMask & effectMask) != 0;
 });
 if (previousTargetItr != std::rend(m_UniqueTargetInfo))
 {
 hitDelay = 0.0f; // this is not the first target in chain, LaunchDelay was already included
 
 if (WorldObject* previousTarget = ObjectAccessor::GetWorldObject(*m_caster, previousTargetItr->TargetGUID))
 missileSource = previousTarget;
 
 targetInfo.TimeDelay += previousTargetItr->TimeDelay;
 }
 }
 
 if (m_spellInfo->HasAttribute(SPELL_ATTR9_MISSILE_SPEED_IS_DELAY_IN_SEC))
 hitDelay += m_spellInfo->Speed;
 else if (m_spellInfo->Speed > 0.0f)
 {
 // calculate spell incoming interval
 float dist = std::max(missileSource->GetDistance(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ()), 5.0f);
 hitDelay += dist / m_spellInfo->Speed;
 }
 
 targetInfo.TimeDelay += uint64(std::floor(hitDelay * 1000.0f));
 }
 else
 targetInfo.TimeDelay = 0ULL;
 
 // If target reflect spell back to caster
 if (targetInfo.MissCondition == SPELL_MISS_REFLECT)
 {
 // Calculate reflected spell result on caster (shouldn't be able to reflect gameobject spells)
 Unit* unitCaster = ASSERT_NOTNULL(m_caster->ToUnit());
 targetInfo.ReflectResult = unitCaster->SpellHitResult(unitCaster, m_spellInfo, false); // can't reflect twice
 
 // Proc spell reflect aura when missile hits the original target
 target->m_Events.AddEvent(new ProcReflectDelayed(target, m_originalCasterGUID), target->m_Events.CalculateTime(Milliseconds(targetInfo.TimeDelay)));
 
 // Increase time interval for reflected spells by 1.5
 targetInfo.TimeDelay += targetInfo.TimeDelay >> 1;
 }
 else
 targetInfo.ReflectResult = SPELL_MISS_NONE;
 
 // Calculate minimum incoming time
 if (targetInfo.TimeDelay && (!m_delayMoment || m_delayMoment > targetInfo.TimeDelay))
 m_delayMoment = targetInfo.TimeDelay;
 
 // Add target to list
 m_UniqueTargetInfo.emplace_back(std::move(targetInfo));
}
 
void Spell::AddGOTarget(GameObject* go, uint32 effectMask)
{
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 if (!spellEffectInfo.IsEffect() || !CheckEffectTarget(go, spellEffectInfo))
 effectMask &= ~(1 << spellEffectInfo.EffectIndex);
 
 // no effects left
 if (!effectMask)
 return;
 
 ObjectGuid targetGUID = go->GetGUID();
 
 // Lookup target in already in list
 auto ihit = std::find_if(std::begin(m_UniqueGOTargetInfo), std::end(m_UniqueGOTargetInfo), [targetGUID](GOTargetInfo const& target) { return target.TargetGUID == targetGUID; });
 if (ihit != std::end(m_UniqueGOTargetInfo)) // Found in list
 {
 // Add only effect mask
 ihit->EffectMask |= effectMask;
 return;
 }
 
 // This is new target calculate data for him
 
 GOTargetInfo target;
 target.TargetGUID = targetGUID;
 target.EffectMask = effectMask;
 
 // Spell have speed - need calculate incoming time
 if (static_cast<WorldObject*>(m_caster) != go)
 {
 float hitDelay = m_spellInfo->LaunchDelay;
 if (m_spellInfo->HasAttribute(SPELL_ATTR9_MISSILE_SPEED_IS_DELAY_IN_SEC))
 hitDelay += m_spellInfo->Speed;
 else if (m_spellInfo->Speed > 0.0f)
 {
 // calculate spell incoming interval
 float dist = std::max(m_caster->GetDistance(go->GetPositionX(), go->GetPositionY(), go->GetPositionZ()), 5.0f);
 hitDelay += dist / m_spellInfo->Speed;
 }
 
 target.TimeDelay = uint64(std::floor(hitDelay * 1000.0f));
 }
 else
 target.TimeDelay = 0ULL;
 
 // Calculate minimum incoming time
 if (target.TimeDelay && (!m_delayMoment || m_delayMoment > target.TimeDelay))
 m_delayMoment = target.TimeDelay;
 
 // Add target to list
 m_UniqueGOTargetInfo.emplace_back(std::move(target));
}
 
void Spell::AddItemTarget(Item* item, uint32 effectMask)
{
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 if (!spellEffectInfo.IsEffect() || !CheckEffectTarget(item, spellEffectInfo))
 effectMask &= ~(1 << spellEffectInfo.EffectIndex);
 
 // no effects left
 if (!effectMask)
 return;
 
 // Lookup target in already in list
 auto ihit = std::find_if(std::begin(m_UniqueItemInfo), std::end(m_UniqueItemInfo), [item](ItemTargetInfo const& target) { return target.TargetItem == item; });
 if (ihit != std::end(m_UniqueItemInfo)) // Found in list
 {
 // Add only effect mask
 ihit->EffectMask |= effectMask;
 return;
 }
 
 // This is new target add data
 
 ItemTargetInfo target;
 target.TargetItem = item;
 target.EffectMask = effectMask;
 
 m_UniqueItemInfo.emplace_back(std::move(target));
}
 
void Spell::AddCorpseTarget(Corpse* corpse, uint32 effectMask)
{
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 if (!spellEffectInfo.IsEffect())
 effectMask &= ~(1 << spellEffectInfo.EffectIndex);
 
 // no effects left
 if (!effectMask)
 return;
 
 ObjectGuid targetGUID = corpse->GetGUID();
 
 // Lookup target in already in list
 auto ihit = std::find_if(std::begin(m_UniqueCorpseTargetInfo), std::end(m_UniqueCorpseTargetInfo), [targetGUID](CorpseTargetInfo const& target) { return target.TargetGUID == targetGUID; });
 if (ihit != std::end(m_UniqueCorpseTargetInfo)) // Found in list
 {
 // Add only effect mask
 ihit->EffectMask |= effectMask;
 return;
 }
 
 // This is new target calculate data for him
 CorpseTargetInfo target;
 target.TargetGUID = targetGUID;
 target.EffectMask = effectMask;
 
 // Spell have speed - need calculate incoming time
 if (m_caster != corpse)
 {
 float hitDelay = m_spellInfo->LaunchDelay;
 if (m_spellInfo->HasAttribute(SPELL_ATTR9_MISSILE_SPEED_IS_DELAY_IN_SEC))
 hitDelay += m_spellInfo->Speed;
 else if (m_spellInfo->Speed > 0.0f)
 {
 // calculate spell incoming interval
 float dist = std::max(m_caster->GetDistance(corpse->GetPositionX(), corpse->GetPositionY(), corpse->GetPositionZ()), 5.0f);
 hitDelay += dist / m_spellInfo->Speed;
 }
 
 target.TimeDelay = uint64(std::floor(hitDelay * 1000.0f));
 }
 else
 target.TimeDelay = 0LL;
 
 // Calculate minimum incoming time
 if (target.TimeDelay && (!m_delayMoment || m_delayMoment > target.TimeDelay))
 m_delayMoment = target.TimeDelay;
 
 // Add target to list
 m_UniqueCorpseTargetInfo.emplace_back(std::move(target));
}
 
void Spell::AddDestTarget(SpellDestination const& dest, uint32 effIndex)
{
 m_destTargets[effIndex] = dest;
}
 
int32 Spell::GetUnitTargetIndexForEffect(ObjectGuid const& target, SpellEffIndex effect) const
{
 int32 index = 0;
 for (TargetInfo const& uniqueTargetInfo : m_UniqueTargetInfo)
 {
 if (uniqueTargetInfo.MissCondition == SPELL_MISS_NONE && uniqueTargetInfo.EffectMask & (1 << effect))
 {
 if (uniqueTargetInfo.TargetGUID == target)
 break;
 
 ++index;
 }
 }
 
 return index;
}
 
int64 Spell::GetUnitTargetCountForEffect(SpellEffIndex effect) const
{
 return std::count_if(m_UniqueTargetInfo.begin(), m_UniqueTargetInfo.end(), [effect](TargetInfo const& targetInfo)
 {
 return targetInfo.MissCondition == SPELL_MISS_NONE && targetInfo.EffectMask & (1 << effect);
 });
}
 
int64 Spell::GetGameObjectTargetCountForEffect(SpellEffIndex effect) const
{
 return std::count_if(m_UniqueGOTargetInfo.begin(), m_UniqueGOTargetInfo.end(), [effect](GOTargetInfo const& targetInfo)
 {
 return targetInfo.EffectMask & (1 << effect);
 });
}
 
int64 Spell::GetItemTargetCountForEffect(SpellEffIndex effect) const
{
 return std::count_if(m_UniqueItemInfo.begin(), m_UniqueItemInfo.end(), [effect](ItemTargetInfo const& targetInfo)
 {
 return targetInfo.EffectMask & (1 << effect);
 });
}
 
int64 Spell::GetCorpseTargetCountForEffect(SpellEffIndex effect) const
{
 return std::count_if(m_UniqueCorpseTargetInfo.begin(), m_UniqueCorpseTargetInfo.end(), [effect](CorpseTargetInfo const& targetInfo)
 {
 return targetInfo.EffectMask & (1 << effect);
 });
}
 
void Spell::TargetInfo::PreprocessTarget(Spell* spell)
{
 Unit* unit = spell->m_caster->GetGUID() == TargetGUID ? spell->m_caster->ToUnit() : ObjectAccessor::GetUnit(*spell->m_caster, TargetGUID);
 if (!unit)
 return;
 
 // Need init unitTarget by default unit (can changed in code on reflect)
 spell->unitTarget = unit;
 
 // Reset damage/healing counter
 spell->m_damage = Damage;
 spell->m_healing = Healing;
 
 _spellHitTarget = nullptr;
 if (MissCondition == SPELL_MISS_NONE || (MissCondition == SPELL_MISS_BLOCK && !spell->GetSpellInfo()->HasAttribute(SPELL_ATTR3_COMPLETELY_BLOCKED)))
 _spellHitTarget = unit;
 else if (MissCondition == SPELL_MISS_REFLECT && ReflectResult == SPELL_MISS_NONE)
 _spellHitTarget = spell->m_caster->ToUnit();
 
 if (spell->m_originalCaster && MissCondition != SPELL_MISS_EVADE && !spell->m_originalCaster->IsFriendlyTo(unit) && (!spell->m_spellInfo->IsPositive() || spell->m_spellInfo->HasEffect(SPELL_EFFECT_DISPEL)) && (spell->m_spellInfo->HasInitialAggro() || unit->IsEngaged()))
 unit->SetInCombatWith(spell->m_originalCaster);
 
 // if target is flagged for pvp also flag caster if a player
 // but respect current pvp rules (buffing/healing npcs flagged for pvp only flags you if they are in combat)
 _enablePVP = (MissCondition == SPELL_MISS_NONE || spell->m_spellInfo->HasAttribute(SPELL_ATTR3_PVP_ENABLING))
 && unit->IsPvP() && (unit->IsInCombat() || unit->IsCharmedOwnedByPlayerOrPlayer()) && spell->m_caster->GetTypeId() == TYPEID_PLAYER; // need to check PvP state before spell effects, but act on it afterwards
 
 if (_spellHitTarget)
 {
 SpellMissInfo missInfo = spell->PreprocessSpellHit(_spellHitTarget, *this);
 if (missInfo != SPELL_MISS_NONE)
 {
 if (missInfo != SPELL_MISS_MISS)
 spell->m_caster->SendSpellMiss(unit, spell->m_spellInfo->Id, missInfo);
 spell->m_damage = 0;
 spell->m_healing = 0;
 _spellHitTarget = nullptr;
 }
 }
 
 spell->CallScriptOnHitHandlers();
 
 // scripts can modify damage/healing for current target, save them
 Damage = spell->m_damage;
 Healing = spell->m_healing;
}
 
void Spell::TargetInfo::DoTargetSpellHit(Spell* spell, SpellEffectInfo const& spellEffectInfo)
{
 Unit* unit = spell->m_caster->GetGUID() == TargetGUID ? spell->m_caster->ToUnit() : ObjectAccessor::GetUnit(*spell->m_caster, TargetGUID);
 if (!unit)
 return;
 
 // 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)
 spell->unitTarget = unit;
 spell->targetMissInfo = MissCondition;
 
 // Reset damage/healing counter
 spell->m_damage = Damage;
 spell->m_healing = Healing;
 
 if (unit->IsAlive() != IsAlive && !spell->m_spellInfo->HasAttribute(SPELL_ATTR9_FORCE_CORPSE_TARGET))
 return;
 
 if (!spell->m_spellInfo->HasAttribute(SPELL_ATTR8_IGNORE_SANCTUARY) && spell->getState() == SPELL_STATE_DELAYED && !spell->IsPositive() && (GameTime::GetGameTimeMS() - TimeDelay) <= unit->m_lastSanctuaryTime)
 return; // No missinfo in that case
 
 if (_spellHitTarget)
 spell->DoSpellEffectHit(_spellHitTarget, spellEffectInfo, *this);
 
 // scripts can modify damage/healing for current target, save them
 Damage = spell->m_damage;
 Healing = spell->m_healing;
}
 
void Spell::TargetInfo::DoDamageAndTriggers(Spell* spell)
{
 Unit* unit = spell->m_caster->GetGUID() == TargetGUID ? spell->m_caster->ToUnit() : ObjectAccessor::GetUnit(*spell->m_caster, TargetGUID);
 if (!unit)
 return;
 
 // other targets executed before this one changed pointer
 spell->unitTarget = unit;
 if (_spellHitTarget)
 spell->unitTarget = _spellHitTarget;
 
 // Reset damage/healing counter
 spell->m_damage = Damage;
 spell->m_healing = Healing;
 
 // Get original caster (if exist) and calculate damage/healing from him data
 // Skip if m_originalCaster not available
 Unit* caster = spell->m_originalCaster ? spell->m_originalCaster : spell->m_caster->ToUnit();
 if (caster)
 {
 // Fill base trigger info
 ProcFlagsInit procAttacker = spell->m_procAttacker;
 ProcFlagsInit procVictim = spell->m_procVictim;
 ProcFlagsSpellType procSpellType = PROC_SPELL_TYPE_NONE;
 ProcFlagsHit hitMask = PROC_HIT_NONE;
 
 // Spells with this flag cannot trigger if effect is cast on self
 bool const canEffectTrigger = spell->unitTarget->CanProc();
 
 // Trigger info was not filled in Spell::prepareDataForTriggerSystem - we do it now
 if (canEffectTrigger && !procAttacker && !procVictim)
 {
 bool positive = true;
 if (spell->m_damage > 0)
 positive = false;
 else if (!spell->m_healing)
 {
 for (uint8 i = 0; i < spell->m_spellInfo->GetEffects().size(); ++i)
 {
 // in case of immunity, check all effects to choose correct procFlags, as none has technically hit
 if (EffectMask && !(EffectMask & (1 << i)))
 continue;
 
 if (!spell->m_spellInfo->IsPositiveEffect(i))
 {
 positive = false;
 break;
 }
 }
 }
 
 switch (spell->m_spellInfo->DmgClass)
 {
 case SPELL_DAMAGE_CLASS_NONE:
 case SPELL_DAMAGE_CLASS_MAGIC:
 if (spell->m_spellInfo->HasAttribute(SPELL_ATTR3_TREAT_AS_PERIODIC))
 {
 if (positive)
 {
 procAttacker |= PROC_FLAG_DEAL_HELPFUL_PERIODIC;
 procVictim |= PROC_FLAG_TAKE_HELPFUL_PERIODIC;
 }
 else
 {
 procAttacker |= PROC_FLAG_DEAL_HARMFUL_PERIODIC;
 procVictim |= PROC_FLAG_TAKE_HARMFUL_PERIODIC;
 }
 }
 else if (spell->m_spellInfo->HasAttribute(SPELL_ATTR0_IS_ABILITY))
 {
 if (positive)
 {
 procAttacker |= PROC_FLAG_DEAL_HELPFUL_ABILITY;
 procVictim |= PROC_FLAG_TAKE_HELPFUL_ABILITY;
 }
 else
 {
 procAttacker |= PROC_FLAG_DEAL_HARMFUL_ABILITY;
 procVictim |= PROC_FLAG_TAKE_HARMFUL_ABILITY;
 }
 }
 else
 {
 if (positive)
 {
 procAttacker |= PROC_FLAG_DEAL_HELPFUL_SPELL;
 procVictim |= PROC_FLAG_TAKE_HELPFUL_SPELL;
 }
 else
 {
 procAttacker |= PROC_FLAG_DEAL_HARMFUL_SPELL;
 procVictim |= PROC_FLAG_TAKE_HARMFUL_SPELL;
 }
 }
 break;
 }
 }
 
 // All calculated do it!
 // Do healing
 bool hasHealing = false;
 std::unique_ptr<DamageInfo> spellDamageInfo;
 std::unique_ptr<HealInfo> healInfo;
 if (spell->m_healing > 0)
 {
 hasHealing = true;
 uint32 addhealth = spell->m_healing;
 if (IsCrit)
 {
 hitMask |= PROC_HIT_CRITICAL;
 addhealth = Unit::SpellCriticalHealingBonus(caster, spell->m_spellInfo, addhealth, nullptr);
 }
 else
 hitMask |= PROC_HIT_NORMAL;
 
 healInfo = std::make_unique<HealInfo>(caster, spell->unitTarget, addhealth, spell->m_spellInfo, spell->m_spellInfo->GetSchoolMask());
 caster->HealBySpell(*healInfo, IsCrit);
 spell->unitTarget->GetThreatManager().ForwardThreatForAssistingMe(caster, float(healInfo->GetEffectiveHeal()) * 0.5f, spell->m_spellInfo);
 spell->m_healing = healInfo->GetEffectiveHeal();
 
 procSpellType |= PROC_SPELL_TYPE_HEAL;
 }
 
 // Do damage
 bool hasDamage = false;
 if (spell->m_damage > 0)
 {
 hasDamage = true;
 // Fill base damage struct (unitTarget - is real spell target)
 SpellNonMeleeDamage damageInfo(caster, spell->unitTarget, spell->m_spellInfo, spell->m_SpellVisual, spell->m_spellSchoolMask, spell->m_castId);
 // Check damage immunity
 if (spell->unitTarget->IsImmunedToDamage(caster, spell->m_spellInfo))
 {
 hitMask = PROC_HIT_IMMUNE;
 spell->m_damage = 0;
 
 // no packet found in sniffs
 }
 else
 {
 caster->SetLastDamagedTargetGuid(spell->unitTarget->GetGUID());
 
 // Add bonuses and fill damageInfo struct
 caster->CalculateSpellDamageTaken(&damageInfo, spell->m_damage, spell->m_spellInfo, spell->m_attackType, IsCrit, MissCondition == SPELL_MISS_BLOCK, spell);
 Unit::DealDamageMods(damageInfo.attacker, damageInfo.target, damageInfo.damage, &damageInfo.absorb);
 
 hitMask |= createProcHitMask(&damageInfo, MissCondition);
 procVictim |= PROC_FLAG_TAKE_ANY_DAMAGE;
 
 // sparring
 if (damageInfo.target != damageInfo.attacker)
 {
 if (Creature* victimCreature = damageInfo.target->ToCreature())
 damageInfo.damage = victimCreature->CalculateDamageForSparring(damageInfo.attacker, damageInfo.damage);
 }
 spell->m_damage = damageInfo.damage;
 
 caster->DealSpellDamage(&damageInfo, true);
 
 // Send log damage message to client
 caster->SendSpellNonMeleeDamageLog(&damageInfo);
 }
 
 // Do triggers for unit
 if (canEffectTrigger)
 {
 spellDamageInfo = std::make_unique<DamageInfo>(damageInfo, SPELL_DIRECT_DAMAGE, spell->m_attackType, hitMask);
 procSpellType |= PROC_SPELL_TYPE_DAMAGE;
 }
 }
 
 // Passive spell hits/misses or active spells only misses (only triggers)
 if (!hasHealing && !hasDamage)
 {
 // Fill base damage struct (unitTarget - is real spell target)
 SpellNonMeleeDamage damageInfo(caster, spell->unitTarget, spell->m_spellInfo, spell->m_SpellVisual, spell->m_spellSchoolMask);
 hitMask |= createProcHitMask(&damageInfo, MissCondition);
 // Do triggers for unit
 if (canEffectTrigger)
 {
 spellDamageInfo = std::make_unique<DamageInfo>(damageInfo, NODAMAGE, spell->m_attackType, hitMask);
 procSpellType |= PROC_SPELL_TYPE_NO_DMG_HEAL;
 }
 
 // Failed Pickpocket, reveal rogue
 if (MissCondition == SPELL_MISS_RESIST && spell->m_spellInfo->HasAttribute(SPELL_ATTR1_FAILURE_BREAKS_STEALTH) && spell->unitTarget->GetTypeId() == TYPEID_UNIT)
 {
 Unit* unitCaster = ASSERT_NOTNULL(spell->m_caster->ToUnit());
 unitCaster->RemoveAurasWithInterruptFlags(SpellAuraInterruptFlags::Interacting);
 spell->unitTarget->ToCreature()->EngageWithTarget(unitCaster);
 }
 }
 
 // Do triggers for unit
 if (canEffectTrigger)
 {
 Unit::ProcSkillsAndAuras(caster, spell->unitTarget, procAttacker, procVictim, procSpellType, PROC_SPELL_PHASE_HIT, hitMask, spell, spellDamageInfo.get(), healInfo.get());
 
 // item spells (spell hit of non-damage spell may also activate items, for example seal of corruption hidden hit)
 if (caster->GetTypeId() == TYPEID_PLAYER && (procSpellType & (PROC_SPELL_TYPE_DAMAGE | PROC_SPELL_TYPE_NO_DMG_HEAL)))
 {
 if (spell->m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MELEE || spell->m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_RANGED)
 if (!spell->m_spellInfo->HasAttribute(SPELL_ATTR0_CANCELS_AUTO_ATTACK_COMBAT) && !spell->m_spellInfo->HasAttribute(SPELL_ATTR4_SUPPRESS_WEAPON_PROCS))
 caster->ToPlayer()->CastItemCombatSpell(*spellDamageInfo);
 }
 }
 
 // set hitmask for finish procs
 spell->m_hitMask |= hitMask;
 spell->m_procSpellType |= procSpellType;
 
 // _spellHitTarget can be null if spell is missed in DoSpellHitOnUnit
 if (MissCondition != SPELL_MISS_EVADE && _spellHitTarget && !spell->m_caster->IsFriendlyTo(unit) && (!spell->IsPositive() || spell->m_spellInfo->HasEffect(SPELL_EFFECT_DISPEL)))
 {
 if (Unit* unitCaster = spell->m_caster->ToUnit())
 {
 unitCaster->AtTargetAttacked(unit, spell->m_spellInfo->HasInitialAggro());
 
 if (spell->m_spellInfo->HasAttribute(SPELL_ATTR6_TAPS_IMMEDIATELY))
 if (Creature* targetCreature = unit->ToCreature())
 if (unitCaster->IsPlayer())
 targetCreature->SetTappedBy(unitCaster);
 }
 
 if (!spell->m_spellInfo->HasAttribute(SPELL_ATTR3_DO_NOT_TRIGGER_TARGET_STAND) && !unit->IsStandState())
 unit->SetStandState(UNIT_STAND_STATE_STAND);
 }
 
 // Check for SPELL_ATTR7_INTERRUPT_ONLY_NONPLAYER
 if (MissCondition == SPELL_MISS_NONE && spell->m_spellInfo->HasAttribute(SPELL_ATTR7_CAN_CAUSE_INTERRUPT) && unit->GetTypeId() != TYPEID_PLAYER)
 caster->CastSpell(unit, SPELL_INTERRUPT_NONPLAYER, spell);
 }
 
 if (_spellHitTarget)
 {
 //AI functions
 if (Creature* cHitTarget = _spellHitTarget->ToCreature())
 if (CreatureAI* hitTargetAI = cHitTarget->AI())
 hitTargetAI->SpellHit(spell->m_caster, spell->m_spellInfo);
 
 if (spell->m_caster->GetTypeId() == TYPEID_UNIT && spell->m_caster->ToCreature()->IsAIEnabled())
 spell->m_caster->ToCreature()->AI()->SpellHitTarget(_spellHitTarget, spell->m_spellInfo);
 else if (spell->m_caster->GetTypeId() == TYPEID_GAMEOBJECT && spell->m_caster->ToGameObject()->AI())
 spell->m_caster->ToGameObject()->AI()->SpellHitTarget(_spellHitTarget, spell->m_spellInfo);
 
 if (HitAura)
 {
 if (AuraApplication* aurApp = HitAura->GetApplicationOfTarget(_spellHitTarget->GetGUID()))
 {
 // only apply unapplied effects (for reapply case)
 uint32 effMask = EffectMask & aurApp->GetEffectsToApply();
 for (uint8 i = 0; i < spell->m_spellInfo->GetEffects().size(); ++i)
 if ((effMask & (1 << i)) && aurApp->HasEffect(i))
 effMask &= ~(1 << i);
 
 if (effMask)
 _spellHitTarget->_ApplyAura(aurApp, effMask);
 
 if (aurApp->IsNeedClientUpdate() && aurApp->GetRemoveMode() == AURA_REMOVE_NONE)
 {
 aurApp->ClientUpdate(false);
 _spellHitTarget->RemoveVisibleAuraUpdate(aurApp);
 }
 }
 }
 
 // Needs to be called after dealing damage/healing to not remove breaking on damage auras
 spell->DoTriggersOnSpellHit(_spellHitTarget);
 }
 
 if (_enablePVP)
 spell->m_caster->ToPlayer()->UpdatePvP(true);
 
 spell->_spellAura = HitAura;
 spell->CallScriptAfterHitHandlers();
 spell->_spellAura = nullptr;
}
 
void Spell::GOTargetInfo::DoTargetSpellHit(Spell* spell, SpellEffectInfo const& spellEffectInfo)
{
 GameObject* go = spell->m_caster->GetGUID() == TargetGUID ? spell->m_caster->ToGameObject() : ObjectAccessor::GetGameObject(*spell->m_caster, TargetGUID);
 if (!go)
 return;
 
 spell->CallScriptBeforeHitHandlers(SPELL_MISS_NONE);
 
 spell->HandleEffects(nullptr, nullptr, go, nullptr, spellEffectInfo, SPELL_EFFECT_HANDLE_HIT_TARGET);
 
 // AI functions
 if (go->AI())
 go->AI()->SpellHit(spell->m_caster, spell->m_spellInfo);
 
 if (spell->m_caster->GetTypeId() == TYPEID_UNIT && spell->m_caster->ToCreature()->IsAIEnabled())
 spell->m_caster->ToCreature()->AI()->SpellHitTarget(go, spell->m_spellInfo);
 else if (spell->m_caster->GetTypeId() == TYPEID_GAMEOBJECT && spell->m_caster->ToGameObject()->AI())
 spell->m_caster->ToGameObject()->AI()->SpellHitTarget(go, spell->m_spellInfo);
 
 spell->CallScriptOnHitHandlers();
 spell->CallScriptAfterHitHandlers();
}
 
void Spell::ItemTargetInfo::DoTargetSpellHit(Spell* spell, SpellEffectInfo const& spellEffectInfo)
{
 spell->CallScriptBeforeHitHandlers(SPELL_MISS_NONE);
 
 spell->HandleEffects(nullptr, TargetItem, nullptr, nullptr, spellEffectInfo, SPELL_EFFECT_HANDLE_HIT_TARGET);
 
 spell->CallScriptOnHitHandlers();
 spell->CallScriptAfterHitHandlers();
}
 
void Spell::CorpseTargetInfo::DoTargetSpellHit(Spell* spell, SpellEffectInfo const& spellEffectInfo)
{
 Corpse* corpse = ObjectAccessor::GetCorpse(*spell->m_caster, TargetGUID);
 if (!corpse)
 return;
 
 spell->CallScriptBeforeHitHandlers(SPELL_MISS_NONE);
 
 spell->HandleEffects(nullptr, nullptr, nullptr, corpse, spellEffectInfo, SPELL_EFFECT_HANDLE_HIT_TARGET);
 
 spell->CallScriptOnHitHandlers();
 spell->CallScriptAfterHitHandlers();
}
 
SpellMissInfo Spell::PreprocessSpellHit(Unit* unit, TargetInfo& hitInfo)
{
 if (!unit)
 return SPELL_MISS_EVADE;
 
 // Target may have begun evading between launch and hit phases - re-check now
 if (Creature* creatureTarget = unit->ToCreature())
 if (creatureTarget->IsEvadingAttacks())
 return SPELL_MISS_EVADE;
 
 // For delayed spells immunity may be applied between missile launch and hit - check immunity for that case
 if (m_spellInfo->HasHitDelay() && unit->IsImmunedToSpell(m_spellInfo, m_caster))
 return SPELL_MISS_IMMUNE;
 
 CallScriptBeforeHitHandlers(hitInfo.MissCondition);
 
 if (Player* player = unit->ToPlayer())
 {
 player->FailCriteria(CriteriaFailEvent::BeSpellTarget, m_spellInfo->Id);
 player->StartCriteria(CriteriaStartEvent::BeSpellTarget, m_spellInfo->Id);
 player->UpdateCriteria(CriteriaType::BeSpellTarget, m_spellInfo->Id, 0, 0, m_caster);
 }
 
 if (Player* player = m_caster->ToPlayer())
 player->UpdateCriteria(CriteriaType::LandTargetedSpellOnTarget, m_spellInfo->Id, 0, 0, unit);
 
 if (m_caster != unit)
 {
 // Recheck UNIT_FLAG_NON_ATTACKABLE for delayed spells
 if (m_spellInfo->HasHitDelay() && unit->HasUnitFlag(UNIT_FLAG_NON_ATTACKABLE) && unit->GetCharmerOrOwnerGUID() != m_caster->GetGUID())
 return SPELL_MISS_EVADE;
 
 if (m_caster->IsValidAttackTarget(unit, m_spellInfo))
 unit->RemoveAurasWithInterruptFlags(SpellAuraInterruptFlags::HostileActionReceived);
 else if (m_caster->IsFriendlyTo(unit))
 {
 // for delayed spells ignore negative spells (after duel end) for friendly targets
 if (m_spellInfo->HasHitDelay() && unit->GetTypeId() == TYPEID_PLAYER && !IsPositive() && !m_caster->IsValidAssistTarget(unit, m_spellInfo))
 return SPELL_MISS_EVADE;
 
 // assisting case, healing and resurrection
 if (unit->HasUnitState(UNIT_STATE_ATTACK_PLAYER))
 {
 if (Player* playerOwner = m_caster->GetCharmerOrOwnerPlayerOrPlayerItself())
 {
 playerOwner->SetContestedPvP();
 playerOwner->UpdatePvP(true);
 }
 }
 
 if (m_originalCaster && unit->IsInCombat() && m_spellInfo->HasInitialAggro())
 {
 if (m_originalCaster->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED)) // only do explicit combat forwarding for PvP enabled units
 m_originalCaster->GetCombatManager().InheritCombatStatesFrom(unit); // for creature v creature combat, the threat forward does it for us
 unit->GetThreatManager().ForwardThreatForAssistingMe(m_originalCaster, 0.0f, nullptr, true);
 }
 }
 }
 
 // original caster for auras
 WorldObject* origCaster = m_caster;
 if (m_originalCaster)
 origCaster = m_originalCaster;
 
 // check immunity due to diminishing returns
 if (Aura::BuildEffectMaskForOwner(m_spellInfo, MAX_EFFECT_MASK, unit))
 {
 for (SpellEffectInfo const& auraSpellEffect : m_spellInfo->GetEffects())
 hitInfo.AuraBasePoints[auraSpellEffect.EffectIndex] = (m_spellValue->CustomBasePointsMask & (1 << auraSpellEffect.EffectIndex))
 ? m_spellValue->EffectBasePoints[auraSpellEffect.EffectIndex]
 : auraSpellEffect.CalcBaseValue(m_originalCaster, unit, m_castItemEntry, m_castItemLevel);
 
 // Get Data Needed for Diminishing Returns, some effects may have multiple auras, so this must be done on spell hit, not aura add
 hitInfo.DRGroup = m_spellInfo->GetDiminishingReturnsGroupForSpell();
 
 DiminishingLevels diminishLevel = DIMINISHING_LEVEL_1;
 if (hitInfo.DRGroup)
 {
 diminishLevel = unit->GetDiminishing(hitInfo.DRGroup);
 DiminishingReturnsType type = m_spellInfo->GetDiminishingReturnsGroupType();
 // Increase Diminishing on unit, current informations for actually casts will use values above
 if (type == DRTYPE_ALL || (type == DRTYPE_PLAYER && unit->IsAffectedByDiminishingReturns()))
 unit->IncrDiminishing(m_spellInfo);
 }
 
 // Now Reduce spell duration using data received at spell hit
 // check whatever effects we're going to apply, diminishing returns only apply to negative aura effects
 hitInfo.Positive = true;
 if (origCaster == unit || !origCaster->IsFriendlyTo(unit))
 {
 for (SpellEffectInfo const& auraSpellEffect : m_spellInfo->GetEffects())
 {
 // mod duration only for effects applying aura!
 if (hitInfo.EffectMask & (1 << auraSpellEffect.EffectIndex) &&
 auraSpellEffect.IsUnitOwnedAuraEffect() &&
 !m_spellInfo->IsPositiveEffect(auraSpellEffect.EffectIndex))
 {
 hitInfo.Positive = false;
 break;
 }
 }
 }
 
 hitInfo.AuraDuration = Aura::CalcMaxDuration(m_spellInfo, origCaster, &m_powerCost);
 
 // unit is immune to aura if it was diminished to 0 duration
 if (!hitInfo.Positive && !unit->ApplyDiminishingToDuration(m_spellInfo, hitInfo.AuraDuration, origCaster, diminishLevel))
 if (std::all_of(std::begin(m_spellInfo->GetEffects()), std::end(m_spellInfo->GetEffects()), [](SpellEffectInfo const& effInfo) { return !effInfo.IsEffect() || effInfo.Effect == SPELL_EFFECT_APPLY_AURA; }))
 return SPELL_MISS_IMMUNE;
 }
 
 return SPELL_MISS_NONE;
}
 
void Spell::DoSpellEffectHit(Unit* unit, SpellEffectInfo const& spellEffectInfo, TargetInfo& hitInfo)
{
 if (uint32 aura_effmask = Aura::BuildEffectMaskForOwner(m_spellInfo, 1 << spellEffectInfo.EffectIndex, unit))
 {
 WorldObject* caster = m_caster;
 if (m_originalCaster)
 caster = m_originalCaster;
 
 if (caster)
 {
 bool refresh = false;
 
 if (!hitInfo.HitAura)
 {
 bool const resetPeriodicTimer = (m_spellInfo->StackAmount < 2) && !(_triggeredCastFlags & TRIGGERED_DONT_RESET_PERIODIC_TIMER);
 uint32 const allAuraEffectMask = Aura::BuildEffectMaskForOwner(m_spellInfo, MAX_EFFECT_MASK, unit);
 
 AuraCreateInfo createInfo(m_castId, m_spellInfo, GetCastDifficulty(), allAuraEffectMask, unit);
 createInfo
 .SetCasterGUID(caster->GetGUID())
 .SetBaseAmount(&hitInfo.AuraBasePoints[0])
 .SetCastItem(m_castItemGUID, m_castItemEntry, m_castItemLevel)
 .SetPeriodicReset(resetPeriodicTimer)
 .SetOwnerEffectMask(aura_effmask)
 .IsRefresh = &refresh;
 
 if (Aura* aura = Aura::TryRefreshStackOrCreate(createInfo, false))
 {
 hitInfo.HitAura = aura->ToUnitAura();
 
 // Set aura stack amount to desired value
 if (m_spellValue->AuraStackAmount > 1)
 {
 if (!refresh)
 hitInfo.HitAura->SetStackAmount(m_spellValue->AuraStackAmount);
 else
 hitInfo.HitAura->ModStackAmount(m_spellValue->AuraStackAmount);
 }
 
 hitInfo.HitAura->SetDiminishGroup(hitInfo.DRGroup);
 
 if (!m_spellValue->Duration)
 {
 hitInfo.AuraDuration = caster->ModSpellDuration(m_spellInfo, unit, hitInfo.AuraDuration, hitInfo.Positive, hitInfo.HitAura->GetEffectMask());
 
 if (hitInfo.AuraDuration > 0)
 {
 hitInfo.AuraDuration *= m_spellValue->DurationMul;
 
 // Haste modifies duration of channeled spells
 if (m_spellInfo->IsChanneled())
 caster->ModSpellDurationTime(m_spellInfo, hitInfo.AuraDuration, this);
 else if (m_spellInfo->HasAttribute(SPELL_ATTR8_HASTE_AFFECTS_DURATION))
 {
 int32 origDuration = hitInfo.AuraDuration;
 hitInfo.AuraDuration = 0;
 for (AuraEffect const* auraEff : hitInfo.HitAura->GetAuraEffects())
 if (auraEff)
 if (int32 period = auraEff->GetPeriod()) // period is hastened by UNIT_MOD_CAST_SPEED
 hitInfo.AuraDuration = std::max(std::max(origDuration / period, 1) * period, hitInfo.AuraDuration);
 
 // if there is no periodic effect
 if (!hitInfo.AuraDuration)
 hitInfo.AuraDuration = int32(origDuration * m_originalCaster->m_unitData->ModCastingSpeed);
 }
 }
 }
 else
 hitInfo.AuraDuration = *m_spellValue->Duration;
 
 if (hitInfo.AuraDuration != hitInfo.HitAura->GetMaxDuration())
 {
 hitInfo.HitAura->SetMaxDuration(hitInfo.AuraDuration);
 hitInfo.HitAura->SetDuration(hitInfo.AuraDuration);
 }
 
 if (refresh)
 hitInfo.HitAura->AddStaticApplication(unit, aura_effmask);
 }
 }
 else
 hitInfo.HitAura->AddStaticApplication(unit, aura_effmask);
 }
 }
 
 _spellAura = hitInfo.HitAura;
 HandleEffects(unit, nullptr, nullptr, nullptr, spellEffectInfo, SPELL_EFFECT_HANDLE_HIT_TARGET);
 _spellAura = nullptr;
}
 
void Spell::DoTriggersOnSpellHit(Unit* 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())
 {
 int32 _duration = 0;
 for (auto i = m_hitTriggerSpells.begin(); i != m_hitTriggerSpells.end(); ++i)
 {
 if (CanExecuteTriggersOnHit(unit, i->triggeredByAura) && roll_chance_i(i->chance))
 {
 m_caster->CastSpell(unit, i->triggeredSpell->Id, CastSpellExtraArgs(TRIGGERED_FULL_MASK)
 .SetTriggeringSpell(this)
 .SetCastDifficulty(i->triggeredSpell->Difficulty));
 TC_LOG_DEBUG("spells", "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(_duration);
 }
 }
 }
 }
 }
 
 // trigger linked auras remove/apply
 if (std::vector<int32> const* spellTriggered = sSpellMgr->GetSpellLinked(SPELL_LINK_HIT, m_spellInfo->Id))
 {
 for (std::vector<int32>::const_iterator i = spellTriggered->begin(); i != spellTriggered->end(); ++i)
 {
 if (*i < 0)
 unit->RemoveAurasDueToSpell(-(*i));
 else
 unit->CastSpell(unit, *i, CastSpellExtraArgs(TRIGGERED_FULL_MASK)
 .SetOriginalCaster(m_caster->GetGUID())
 .SetTriggeringSpell(this));
 }
 }
}
 
bool Spell::UpdateChanneledTargetList()
{
 // Not need check return true
 if (m_channelTargetEffectMask == 0)
 return true;
 
 uint32 channelTargetEffectMask = m_channelTargetEffectMask;
 uint32 channelAuraMask = 0;
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 if (spellEffectInfo.IsEffect(SPELL_EFFECT_APPLY_AURA))
 channelAuraMask |= 1 << spellEffectInfo.EffectIndex;
 
 channelAuraMask &= channelTargetEffectMask;
 
 float range = 0;
 if (channelAuraMask)
 {
 range = m_spellInfo->GetMaxRange(IsPositive());
 if (Player* modOwner = m_caster->GetSpellModOwner())
 modOwner->ApplySpellMod(m_spellInfo, SpellModOp::Range, range, this);
 
 // add little tolerance level
 range += std::min(MAX_SPELL_RANGE_TOLERANCE, range*0.1f); // 10% but no more than MAX_SPELL_RANGE_TOLERANCE
 }
 
 for (TargetInfo& targetInfo : m_UniqueTargetInfo)
 {
 if (targetInfo.MissCondition == SPELL_MISS_NONE && (channelTargetEffectMask & targetInfo.EffectMask))
 {
 Unit* unit = m_caster->GetGUID() == targetInfo.TargetGUID ? m_caster->ToUnit() : ObjectAccessor::GetUnit(*m_caster, targetInfo.TargetGUID);
 if (!unit)
 {
 if (Unit* unitCaster =m_caster->ToUnit())
 unitCaster->RemoveChannelObject(targetInfo.TargetGUID);
 continue;
 }
 
 if (IsValidDeadOrAliveTarget(unit))
 {
 if (channelAuraMask & targetInfo.EffectMask)
 {
 if (AuraApplication* aurApp = unit->GetAuraApplication(m_spellInfo->Id, m_originalCasterGUID))
 {
 if (m_caster != unit && !m_caster->IsWithinDistInMap(unit, range))
 {
 targetInfo.EffectMask &= ~aurApp->GetEffectMask();
 unit->RemoveAura(aurApp);
 if (Unit* unitCaster = m_caster->ToUnit())
 unitCaster->RemoveChannelObject(targetInfo.TargetGUID);
 continue;
 }
 }
 else // aura is dispelled
 {
 if (Unit* unitCaster = m_caster->ToUnit())
 unitCaster->RemoveChannelObject(targetInfo.TargetGUID);
 continue;
 }
 }
 
 channelTargetEffectMask &= ~targetInfo.EffectMask; // remove from need alive mask effect that have alive target
 }
 }
 }
 
 // is all effects from m_needAliveTargetMask have alive targets
 return channelTargetEffectMask == 0;
}
 
SpellCastResult Spell::prepare(SpellCastTargets const& targets, AuraEffect const* triggeredByAura)
{
 if (m_CastItem)
 {
 m_castItemGUID = m_CastItem->GetGUID();
 m_castItemEntry = m_CastItem->GetEntry();
 
 if (Player* owner = m_CastItem->GetOwner())
 m_castItemLevel = int32(m_CastItem->GetItemLevel(owner));
 else if (m_CastItem->GetOwnerGUID() == m_caster->GetGUID())
 m_castItemLevel = int32(m_CastItem->GetItemLevel(m_caster->ToPlayer()));
 else
 {
 SendCastResult(SPELL_FAILED_EQUIPPED_ITEM);
 finish(SPELL_FAILED_EQUIPPED_ITEM);
 return SPELL_FAILED_EQUIPPED_ITEM;
 }
 }
 
 InitExplicitTargets(targets);
 
 m_spellState = SPELL_STATE_PREPARING;
 
 if (triggeredByAura)
 {
 m_triggeredByAuraSpell = triggeredByAura->GetSpellInfo();
 m_castItemLevel = triggeredByAura->GetBase()->GetCastItemLevel();
 }
 
 // create and add update event for this spell
 _spellEvent = new SpellEvent(this);
 m_caster->m_Events.AddEvent(_spellEvent, m_caster->m_Events.CalculateTime(1ms));
 
 // check disables
 if (DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, m_spellInfo->Id, m_caster))
 {
 SendCastResult(SPELL_FAILED_SPELL_UNAVAILABLE);
 finish(SPELL_FAILED_SPELL_UNAVAILABLE);
 return SPELL_FAILED_SPELL_UNAVAILABLE;
 }
 
 // Prevent casting at cast another spell (ServerSide check)
 if (!(_triggeredCastFlags & TRIGGERED_IGNORE_CAST_IN_PROGRESS) && m_caster->ToUnit() && m_caster->ToUnit()->IsNonMeleeSpellCast(false, true, true, m_spellInfo->Id == 75))
 {
 SendCastResult(SPELL_FAILED_SPELL_IN_PROGRESS);
 finish(SPELL_FAILED_SPELL_IN_PROGRESS);
 return SPELL_FAILED_SPELL_IN_PROGRESS;
 }
 
 LoadScripts();
 
 // Fill cost data (do not use power for item casts)
 if (!m_CastItem)
 m_powerCost = m_spellInfo->CalcPowerCost(m_caster, m_spellSchoolMask, this);
 
 int32 param1 = 0, param2 = 0;
 SpellCastResult result = CheckCast(true, &param1, &param2);
 // target is checked in too many locations and with different results to handle each of them
 // handle just the general SPELL_FAILED_BAD_TARGETS result which is the default result for most DBC target checks
 if (_triggeredCastFlags & TRIGGERED_IGNORE_TARGET_CHECK && result == SPELL_FAILED_BAD_TARGETS)
 result = SPELL_CAST_OK;
 if (result != SPELL_CAST_OK)
 {
 // Periodic auras should be interrupted when aura triggers a spell which can't be cast
 // for example bladestorm aura should be removed on disarm as of patch 3.3.5
 // channeled periodic spells should be affected by this (arcane missiles, penance, etc)
 // a possible alternative sollution for those would be validating aura target on unit state change
 if (triggeredByAura && triggeredByAura->IsPeriodic() && !triggeredByAura->GetBase()->IsPassive())
 {
 SendChannelUpdate(0, result);
 triggeredByAura->GetBase()->SetDuration(0);
 }
 
 if (param1 || param2)
 SendCastResult(result, &param1, &param2);
 else
 SendCastResult(result);
 
 // queue autorepeat spells for future repeating
 if (GetCurrentContainer() == CURRENT_AUTOREPEAT_SPELL && m_caster->IsUnit())
 m_caster->ToUnit()->SetCurrentCastSpell(this);
 
 finish(result);
 return result;
 }
 
 // Prepare data for triggers
 prepareDataForTriggerSystem();
 
 if (!(_triggeredCastFlags & TRIGGERED_IGNORE_CAST_TIME))
 m_casttime = m_spellInfo->CalcCastTime(this);
 m_casttime = CallScriptCalcCastTimeHandlers(m_casttime);
 
 SpellCastResult movementResult = SPELL_CAST_OK;
 if (m_caster->IsUnit() && m_caster->ToUnit()->isMoving())
 movementResult = CheckMovement();
 
 // Creatures focus their target when possible
 if (m_casttime && m_caster->IsCreature() && !m_spellInfo->IsNextMeleeSwingSpell() && !IsAutoRepeat() && !m_caster->ToUnit()->HasUnitFlag(UNIT_FLAG_POSSESSED))
 {
 // Channeled spells and some triggered spells do not focus a cast target. They face their target later on via channel object guid and via spell attribute or not at all
 bool const focusTarget = !m_spellInfo->IsChanneled() && !(_triggeredCastFlags & TRIGGERED_IGNORE_SET_FACING);
 if (focusTarget && m_targets.GetObjectTarget() && m_caster != m_targets.GetObjectTarget())
 m_caster->ToCreature()->SetSpellFocus(this, m_targets.GetObjectTarget());
 else
 m_caster->ToCreature()->SetSpellFocus(this, nullptr);
 }
 
 if (movementResult != SPELL_CAST_OK)
 {
 if (m_caster->ToUnit()->IsControlledByPlayer() || !CanStopMovementForSpellCasting(m_caster->ToUnit()->GetMotionMaster()->GetCurrentMovementGeneratorType()))
 {
 SendCastResult(movementResult);
 finish(movementResult);
 return movementResult;
 }
 else
 {
 // Creatures (not controlled) give priority to spell casting over movement.
 // We assume that the casting is always valid and the current movement
 // is stopped immediately (because spells are updated before movement, so next Unit::Update would cancel the spell before stopping movement)
 // and future attempts are stopped by by Unit::IsMovementPreventedByCasting in movement generators to prevent casting interruption.
 m_caster->ToUnit()->StopMoving();
 }
 }
 
 CallScriptOnPrecastHandler();
 
 // set timer base at cast time
 ReSetTimer();
 
 TC_LOG_DEBUG("spells", "Spell::prepare: spell id {} source {} caster {} customCastFlags {} mask {}", m_spellInfo->Id, m_caster->GetEntry(), m_originalCaster ? m_originalCaster->GetEntry() : -1, _triggeredCastFlags, m_targets.GetTargetMask());
 
 if (m_spellInfo->HasAttribute(SPELL_ATTR12_START_COOLDOWN_ON_CAST_START))
 SendSpellCooldown();
 
 if (m_spellInfo->HasAttribute(SPELL_ATTR7_RESET_SWING_TIMER_AT_SPELL_START) && IsAutoActionResetSpell())
 ResetCombatTimers();
 
 //Containers for channeled spells have to be set
 // Why check duration? 29350: channelled triggers channelled
 if ((_triggeredCastFlags & TRIGGERED_CAST_DIRECTLY) && (!m_spellInfo->IsChanneled() || !m_spellInfo->GetMaxDuration()))
 cast(true);
 else
 {
 // commented out !m_spellInfo->StartRecoveryTime, it forces instant spells with global cooldown to be processed in spell::update
 // as a result a spell that passed CheckCast and should be processed instantly may suffer from this delayed process
 // the easiest bug to observe is LoS check in AddUnitTarget, even if spell passed the CheckCast LoS check the situation can change in spell::update
 // because target could be relocated in the meantime, making the spell fly to the air (no targets can be registered, so no effects processed, nothing in combat log)
 bool willCastDirectly = !m_casttime && GetCurrentContainer() == CURRENT_GENERIC_SPELL;
 
 if (Unit* unitCaster = m_caster->ToUnit())
 {
 // stealth must be removed at cast starting (at show channel bar)
 // skip triggered spell (item equip spell casting and other not explicit character casts/item uses)
 if (!(_triggeredCastFlags & TRIGGERED_IGNORE_CAST_IN_PROGRESS) && !m_spellInfo->HasAttribute(SPELL_ATTR2_NOT_AN_ACTION))
 unitCaster->RemoveAurasWithInterruptFlags(SpellAuraInterruptFlags::Action, m_spellInfo);
 
 // Do not register as current spell when requested to ignore cast in progress
 // We don't want to interrupt that other spell with cast time
 if (!willCastDirectly || !(_triggeredCastFlags & TRIGGERED_IGNORE_CAST_IN_PROGRESS))
 unitCaster->SetCurrentCastSpell(this);
 }
 SendSpellStart();
 
 if (!(_triggeredCastFlags & TRIGGERED_IGNORE_GCD))
 TriggerGlobalCooldown();
 
 // Call CreatureAI hook OnSpellStart
 if (Creature* caster = m_caster->ToCreature())
 if (caster->IsAIEnabled())
 caster->AI()->OnSpellStart(GetSpellInfo());
 
 if (willCastDirectly)
 cast(true);
 }
 
 return SPELL_CAST_OK;
}
 
void Spell::cancel()
{
 if (m_spellState == SPELL_STATE_FINISHED)
 return;
 
 uint32 oldState = m_spellState;
 m_spellState = SPELL_STATE_FINISHED;
 
 m_autoRepeat = false;
 switch (oldState)
 {
 case SPELL_STATE_PREPARING:
 CancelGlobalCooldown();
 [[fallthrough]];
 case SPELL_STATE_DELAYED:
 SendInterrupted(0);
 SendCastResult(SPELL_FAILED_INTERRUPTED);
 break;
 
 case SPELL_STATE_CASTING:
 for (TargetInfo const& targetInfo : m_UniqueTargetInfo)
 if (targetInfo.MissCondition == SPELL_MISS_NONE)
 if (Unit* unit = m_caster->GetGUID() == targetInfo.TargetGUID ? m_caster->ToUnit() : ObjectAccessor::GetUnit(*m_caster, targetInfo.TargetGUID))
 unit->RemoveOwnedAura(m_spellInfo->Id, m_originalCasterGUID, 0, AURA_REMOVE_BY_CANCEL);
 
 SendChannelUpdate(0, SPELL_FAILED_INTERRUPTED);
 SendInterrupted(0);
 SendCastResult(SPELL_FAILED_INTERRUPTED);
 
 m_appliedMods.clear();
 break;
 
 default:
 break;
 }
 
 SetReferencedFromCurrent(false);
 if (m_selfContainer && *m_selfContainer == this)
 *m_selfContainer = nullptr;
 
 // originalcaster handles gameobjects/dynobjects for gob caster
 if (m_originalCaster)
 {
 m_originalCaster->RemoveDynObject(m_spellInfo->Id);
 if (m_spellInfo->IsChanneled()) // if not channeled then the object for the current cast wasn't summoned yet
 m_originalCaster->RemoveGameObject(m_spellInfo->Id, true);
 }
 
 //set state back so finish will be processed
 m_spellState = oldState;
 
 finish(SPELL_FAILED_INTERRUPTED);
}
 
void Spell::cast(bool skipCheck)
{
 Player* modOwner = m_caster->GetSpellModOwner();
 Spell* lastSpellMod = nullptr;
 if (modOwner)
 {
 lastSpellMod = modOwner->m_spellModTakingSpell;
 if (lastSpellMod)
 modOwner->SetSpellModTakingSpell(lastSpellMod, false);
 }
 
 _cast(skipCheck);
 
 if (lastSpellMod)
 modOwner->SetSpellModTakingSpell(lastSpellMod, true);
}
 
void Spell::_cast(bool skipCheck)
{
 // update pointers base at GUIDs to prevent access to non-existed already object
 if (!UpdatePointers())
 {
 // cancel the spell if UpdatePointers() returned false, something wrong happened there
 cancel();
 return;
 }
 
 // cancel at lost explicit target during cast
 if (!m_targets.GetObjectTargetGUID().IsEmpty() && !m_targets.GetObjectTarget())
 {
 cancel();
 return;
 }
 
 if (Player* playerCaster = m_caster->ToPlayer())
 {
 // now that we've done the basic check, now run the scripts
 // should be done before the spell is actually executed
 sScriptMgr->OnPlayerSpellCast(playerCaster, this, skipCheck);
 
 // As of 3.0.2 pets begin attacking their owner's target immediately
 // Let any pets know we've attacked something. Check DmgClass for harmful spells only
 // This prevents spells such as Hunter's Mark from triggering pet attack
 if (GetSpellInfo()->DmgClass != SPELL_DAMAGE_CLASS_NONE)
 if (Unit* target = m_targets.GetUnitTarget())
 for (Unit* controlled : playerCaster->m_Controlled)
 if (Creature* cControlled = controlled->ToCreature())
 if (CreatureAI* controlledAI = cControlled->AI())
 controlledAI->OwnerAttacked(target);
 }
 
 SetExecutedCurrently(true);
 
 // Should this be done for original caster?
 Player* modOwner = m_caster->GetSpellModOwner();
 if (modOwner)
 {
 // Set spell which will drop charges for triggered cast spells
 // if not successfully cast, will be remove in finish(false)
 modOwner->SetSpellModTakingSpell(this, true);
 }
 
 CallScriptBeforeCastHandlers();
 
 // skip check if done already (for instant cast spells for example)
 if (!skipCheck)
 {
 auto cleanupSpell = [this, modOwner](SpellCastResult res, int32* p1 = nullptr, int32* p2 = nullptr)
 {
 SendCastResult(res, p1, p2);
 SendInterrupted(0);
 
 if (modOwner)
 modOwner->SetSpellModTakingSpell(this, false);
 
 finish(res);
 SetExecutedCurrently(false);
 };
 
 int32 param1 = 0, param2 = 0;
 SpellCastResult castResult = CheckCast(false, &param1, &param2);
 if (castResult != SPELL_CAST_OK)
 {
 cleanupSpell(castResult, &param1, &param2);
 return;
 }
 
 // additional check after cast bar completes (must not be in CheckCast)
 // if trade not complete then remember it in trade data
 if (m_targets.GetTargetMask() & TARGET_FLAG_TRADE_ITEM)
 {
 if (modOwner)
 {
 if (TradeData* my_trade = modOwner->GetTradeData())
 {
 if (!my_trade->IsInAcceptProcess())
 {
 // Spell will be cast after completing the trade. Silently ignore at this place
 my_trade->SetSpell(m_spellInfo->Id, m_CastItem);
 cleanupSpell(SPELL_FAILED_DONT_REPORT);
 return;
 }
 }
 }
 }
 
 // check diminishing returns (again, only after finish cast bar, tested on retail)
 if (Unit* target = m_targets.GetUnitTarget())
 {
 uint32 aura_effmask = 0;
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 if (spellEffectInfo.IsUnitOwnedAuraEffect())
 aura_effmask |= 1 << spellEffectInfo.EffectIndex;
 
 if (aura_effmask)
 {
 if (m_spellInfo->GetDiminishingReturnsGroupForSpell())
 {
 DiminishingReturnsType type = m_spellInfo->GetDiminishingReturnsGroupType();
 if (type == DRTYPE_ALL || (type == DRTYPE_PLAYER && target->IsAffectedByDiminishingReturns()))
 {
 if (Unit* caster = m_originalCaster ? m_originalCaster : m_caster->ToUnit())
 {
 if (target->HasStrongerAuraWithDR(m_spellInfo, caster))
 {
 cleanupSpell(SPELL_FAILED_AURA_BOUNCED);
 return;
 }
 }
 }
 }
 }
 }
 }
 // The spell focusing is making sure that we have a valid cast target guid when we need it so only check for a guid value here.
 if (Creature* creatureCaster = m_caster->ToCreature())
 if (!creatureCaster->GetTarget().IsEmpty() && !creatureCaster->HasUnitFlag(UNIT_FLAG_POSSESSED))
 if (WorldObject const* target = ObjectAccessor::GetUnit(*creatureCaster, creatureCaster->GetTarget()))
 creatureCaster->SetInFront(target);
 
 SelectSpellTargets();
 
 // Spell may be finished after target map check
 if (m_spellState == SPELL_STATE_FINISHED)
 {
 SendInterrupted(0);
 
 // cleanup after mod system
 // triggered spell pointer can be not removed in some cases
 if (m_caster->GetTypeId() == TYPEID_PLAYER)
 m_caster->ToPlayer()->SetSpellModTakingSpell(this, false);
 
 finish(SPELL_FAILED_INTERRUPTED);
 SetExecutedCurrently(false);
 return;
 }
 
 if (Unit* unitCaster = m_caster->ToUnit())
 if (m_spellInfo->HasAttribute(SPELL_ATTR1_DISMISS_PET_FIRST))
 if (Creature* pet = ObjectAccessor::GetCreature(*m_caster, unitCaster->GetPetGUID()))
 pet->DespawnOrUnsummon();
 
 PrepareTriggersExecutedOnHit();
 
 CallScriptOnCastHandlers();
 
 // traded items have trade slot instead of guid in m_itemTargetGUID
 // set to real guid to be sent later to the client
 m_targets.UpdateTradeSlotItem();
 
 if (Player* player = m_caster->ToPlayer())
 {
 if (!(_triggeredCastFlags & TRIGGERED_IGNORE_CAST_ITEM) && m_CastItem)
 {
 player->StartCriteria(CriteriaStartEvent::UseItem, m_CastItem->GetEntry());
 player->UpdateCriteria(CriteriaType::UseItem, m_CastItem->GetEntry());
 }
 
 player->FailCriteria(CriteriaFailEvent::CastSpell, m_spellInfo->Id);
 player->StartCriteria(CriteriaStartEvent::CastSpell, m_spellInfo->Id);
 player->UpdateCriteria(CriteriaType::CastSpell, m_spellInfo->Id);
 }
 
 // Spells that don't create items can have this attribute - handle here
 if (m_CastItem && m_spellInfo->HasAttribute(SPELL_ATTR9_ITEM_CAST_GRANTS_SKILL_GAIN))
 if (Player* playerCaster = m_caster->ToPlayer())
 playerCaster->UpdateCraftSkill(m_spellInfo);
 
 if (!(_triggeredCastFlags & TRIGGERED_IGNORE_POWER_AND_REAGENT_COST))
 {
 // Powers have to be taken before SendSpellGo
 TakePower();
 TakeReagents(); // we must remove reagents before HandleEffects to allow place crafted item in same slot
 }
 else if (Item* targetItem = m_targets.GetItemTarget())
 {
 if (targetItem->GetOwnerGUID() != m_caster->GetGUID())
 TakeReagents();
 }
 
 // CAST SPELL
 if (!m_spellInfo->HasAttribute(SPELL_ATTR12_START_COOLDOWN_ON_CAST_START))
 SendSpellCooldown();
 
 if (!m_spellInfo->LaunchDelay)
 {
 HandleLaunchPhase();
 m_launchHandled = true;
 }
 
 if (!m_spellInfo->HasAttribute(SPELL_ATTR7_RESET_SWING_TIMER_AT_SPELL_START) && IsAutoActionResetSpell())
 ResetCombatTimers();
 
 // we must send smsg_spell_go packet before m_castItem delete in TakeCastItem()...
 SendSpellGo();
 
 if (!m_spellInfo->IsChanneled())
 if (Creature* creatureCaster = m_caster->ToCreature())
 creatureCaster->ReleaseSpellFocus(this);
 
 // Okay, everything is prepared. Now we need to distinguish between immediate and evented delayed spells
 if (m_spellInfo->HasHitDelay() && !m_spellInfo->IsChanneled())
 {
 // Remove used for cast item if need (it can be already NULL after TakeReagents call
 // in case delayed spell remove item at cast delay start
 TakeCastItem();
 
 // Okay, maps created, now prepare flags
 m_immediateHandled = false;
 m_spellState = SPELL_STATE_DELAYED;
 SetDelayStart(0);
 
 if (Unit* unitCaster = m_caster->ToUnit())
 if (unitCaster->HasUnitState(UNIT_STATE_CASTING) && !unitCaster->IsNonMeleeSpellCast(false, false, true))
 unitCaster->ClearUnitState(UNIT_STATE_CASTING);
 }
 else
 {
 // Immediate spell, no big deal
 handle_immediate();
 }
 
 if (m_scriptResult && !m_scriptWaitsForSpellHit)
 m_scriptResult->SetResult(SPELL_CAST_OK);
 
 CallScriptAfterCastHandlers();
 
 if (std::vector<int32> const* spell_triggered = sSpellMgr->GetSpellLinked(SPELL_LINK_CAST, m_spellInfo->Id))
 {
 for (int32 id : *spell_triggered)
 {
 if (id < 0)
 {
 if (Unit* unitCaster = m_caster->ToUnit())
 unitCaster->RemoveAurasDueToSpell(-id);
 }
 else
 m_caster->CastSpell(m_targets.GetUnitTarget() ? m_targets.GetUnitTarget() : m_caster, id, CastSpellExtraArgs(TRIGGERED_FULL_MASK)
 .SetTriggeringSpell(this));
 }
 }
 
 if (modOwner)
 {
 modOwner->SetSpellModTakingSpell(this, false);
 
 //Clear spell cooldowns after every spell is cast if .cheat cooldown is enabled.
 if (m_originalCaster && modOwner->GetCommandStatus(CHEAT_COOLDOWN))
 {
 m_originalCaster->GetSpellHistory()->ResetCooldown(m_spellInfo->Id, true);
 m_originalCaster->GetSpellHistory()->RestoreCharge(m_spellInfo->ChargeCategoryId);
 }
 }
 
 SetExecutedCurrently(false);
 
 if (!m_originalCaster)
 return;
 
 // Handle procs on cast
 ProcFlagsInit procAttacker = m_procAttacker;
 if (!procAttacker)
 {
 if (m_spellInfo->HasAttribute(SPELL_ATTR3_TREAT_AS_PERIODIC))
 {
 if (IsPositive())
 procAttacker |= PROC_FLAG_DEAL_HELPFUL_PERIODIC;
 else
 procAttacker |= PROC_FLAG_DEAL_HARMFUL_PERIODIC;
 }
 else if (m_spellInfo->HasAttribute(SPELL_ATTR0_IS_ABILITY))
 {
 if (IsPositive())
 procAttacker |= PROC_FLAG_DEAL_HELPFUL_ABILITY;
 else
 procAttacker |= PROC_FLAG_DEAL_HARMFUL_ABILITY;
 }
 else
 {
 if (IsPositive())
 procAttacker |= PROC_FLAG_DEAL_HELPFUL_SPELL;
 else
 procAttacker |= PROC_FLAG_DEAL_HARMFUL_SPELL;
 }
 }
 
 procAttacker |= PROC_FLAG_2_CAST_SUCCESSFUL;
 
 ProcFlagsHit hitMask = m_hitMask;
 if (!(hitMask & PROC_HIT_CRITICAL))
 hitMask |= PROC_HIT_NORMAL;
 
 if (!(_triggeredCastFlags & TRIGGERED_IGNORE_CAST_IN_PROGRESS) && !m_spellInfo->HasAttribute(SPELL_ATTR2_NOT_AN_ACTION))
 m_originalCaster->RemoveAurasWithInterruptFlags(SpellAuraInterruptFlags::ActionDelayed, m_spellInfo);
 
 Unit::ProcSkillsAndAuras(m_originalCaster, nullptr, procAttacker, PROC_FLAG_NONE, PROC_SPELL_TYPE_MASK_ALL, PROC_SPELL_PHASE_CAST, hitMask, this, nullptr, nullptr);
 
 // Call CreatureAI hook OnSpellCast
 if (Creature* caster = m_originalCaster->ToCreature())
 if (caster->IsAIEnabled())
 caster->AI()->OnSpellCast(GetSpellInfo());
}
 
template <class Container>
void Spell::DoProcessTargetContainer(Container& targetContainer)
{
 for (TargetInfoBase& target : targetContainer)
 target.PreprocessTarget(this);
 
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 for (TargetInfoBase& target : targetContainer)
 if (target.EffectMask & (1 << spellEffectInfo.EffectIndex))
 target.DoTargetSpellHit(this, spellEffectInfo);
 
 for (TargetInfoBase& target : targetContainer)
 target.DoDamageAndTriggers(this);
}
 
void Spell::handle_immediate()
{
 // start channeling if applicable
 if (m_spellInfo->IsChanneled())
 {
 int32 duration = m_spellInfo->GetDuration();
 if (duration > 0 || m_spellValue->Duration > 0)
 {
 if (!m_spellValue->Duration)
 {
 int32 originalDuration = duration;
 
 // First mod_duration then haste - see Missile Barrage
 // Apply duration mod
 if (Player* modOwner = m_caster->GetSpellModOwner())
 modOwner->ApplySpellMod(m_spellInfo, SpellModOp::Duration, duration);
 
 duration *= m_spellValue->DurationMul;
 
 // Apply haste mods
 m_caster->ModSpellDurationTime(m_spellInfo, duration, this);
 
 if (IsEmpowerSpell())
 {
 float ratio = float(duration) / float(originalDuration);
 m_empower->StageDurations.resize(m_spellInfo->EmpowerStageThresholds.size());
 Milliseconds totalExceptLastStage = 0ms;
 for (std::size_t i = 0; i < m_empower->StageDurations.size() - 1; ++i)
 {
 m_empower->StageDurations[i] = Milliseconds(int64(m_spellInfo->EmpowerStageThresholds[i].count() * ratio));
 totalExceptLastStage += m_empower->StageDurations[i];
 }
 
 m_empower->StageDurations.back() = Milliseconds(duration) - totalExceptLastStage;
 
 if (Player const* playerCaster = m_caster->ToPlayer())
 m_empower->MinHoldTime = Milliseconds(int64(m_empower->StageDurations[0].count() * playerCaster->GetEmpowerMinHoldStagePercent()));
 else
 m_empower->MinHoldTime = m_empower->StageDurations[0];
 
 duration += SPELL_EMPOWER_HOLD_TIME_AT_MAX;
 }
 }
 else
 duration = *m_spellValue->Duration;
 
 m_channeledDuration = duration;
 SendChannelStart(duration);
 }
 else if (duration == -1)
 SendChannelStart(duration);
 
 if (duration != 0)
 {
 m_spellState = SPELL_STATE_CASTING;
 // GameObjects shouldn't cast channeled spells
 ASSERT_NOTNULL(m_caster->ToUnit())->AddInterruptMask(m_spellInfo->ChannelInterruptFlags, m_spellInfo->ChannelInterruptFlags2);
 }
 }
 
 PrepareTargetProcessing();
 
 // process immediate effects (items, ground, etc.) also initialize some variables
 _handle_immediate_phase();
 
 // consider spell hit for some spells without target, so they may proc on finish phase correctly
 if (m_UniqueTargetInfo.empty())
 {
 m_hitMask = PROC_HIT_NORMAL;
 m_procSpellType = PROC_SPELL_TYPE_NO_DMG_HEAL;
 }
 else
 DoProcessTargetContainer(m_UniqueTargetInfo);
 
 DoProcessTargetContainer(m_UniqueGOTargetInfo);
 
 DoProcessTargetContainer(m_UniqueCorpseTargetInfo);
 
 FinishTargetProcessing();
 
 // spell is finished, perform some last features of the spell here
 _handle_finish_phase();
 
 // Remove used for cast item if need (it can be already NULL after TakeReagents call
 TakeCastItem();
 
 if (m_spellState != SPELL_STATE_CASTING)
 finish(); // successfully finish spell cast (not last in case autorepeat or channel spell)
}
 
uint64 Spell::handle_delayed(uint64 t_offset)
{
 if (!UpdatePointers())
 {
 // finish the spell if UpdatePointers() returned false, something wrong happened there
 finish(SPELL_FAILED_NO_VALID_TARGETS);
 return 0;
 }
 
 // when spell has a single missile we hit all targets (except caster) at the same time
 bool single_missile = m_targets.HasDst();
 bool ignoreTargetInfoTimeDelay = single_missile;
 uint64 next_time = 0;
 
 if (!m_launchHandled)
 {
 uint64 launchMoment = uint64(std::floor(m_spellInfo->LaunchDelay * 1000.0f));
 if (launchMoment > t_offset)
 return launchMoment;
 
 HandleLaunchPhase();
 m_launchHandled = true;
 }
 
 if (m_delayMoment > t_offset)
 {
 ignoreTargetInfoTimeDelay = false;
 next_time = m_delayMoment;
 }
 
 Player* modOwner = m_caster->GetSpellModOwner();
 if (modOwner)
 modOwner->SetSpellModTakingSpell(this, true);
 
 PrepareTargetProcessing();
 
 if (!m_immediateHandled && m_delayMoment <= t_offset)
 {
 _handle_immediate_phase();
 m_immediateHandled = true;
 }
 
 // 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)
 {
 std::vector<TargetInfo> delayedTargets;
 m_UniqueTargetInfo.erase(std::remove_if(m_UniqueTargetInfo.begin(), m_UniqueTargetInfo.end(), [&](TargetInfo& target) -> bool
 {
 if (ignoreTargetInfoTimeDelay || target.TimeDelay <= t_offset)
 {
 target.TimeDelay = t_offset;
 delayedTargets.emplace_back(std::move(target));
 return true;
 }
 else if (!single_missile && (next_time == 0 || target.TimeDelay < next_time))
 next_time = target.TimeDelay;
 
 return false;
 }), m_UniqueTargetInfo.end());
 
 DoProcessTargetContainer(delayedTargets);
 }
 
 // now recheck gameobject targeting correctness
 {
 std::vector<GOTargetInfo> delayedGOTargets;
 m_UniqueGOTargetInfo.erase(std::remove_if(m_UniqueGOTargetInfo.begin(), m_UniqueGOTargetInfo.end(), [&](GOTargetInfo& goTarget) -> bool
 {
 if (ignoreTargetInfoTimeDelay || goTarget.TimeDelay <= t_offset)
 {
 goTarget.TimeDelay = t_offset;
 delayedGOTargets.emplace_back(std::move(goTarget));
 return true;
 }
 else if (!single_missile && (next_time == 0 || goTarget.TimeDelay < next_time))
 next_time = goTarget.TimeDelay;
 
 return false;
 }), m_UniqueGOTargetInfo.end());
 
 DoProcessTargetContainer(delayedGOTargets);
 }
 
 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(); // successfully finish spell cast
 
 // return zero, spell is finished now
 return 0;
 }
 else
 {
 // spell is unfinished, return next execution time
 return next_time;
 }
}
 
void Spell::_handle_immediate_phase()
{
 // handle some immediate features of the spell here
 HandleThreatSpells();
 
 // handle effects with SPELL_EFFECT_HANDLE_HIT mode
 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())
 {
 // don't do anything for empty effect
 if (!spellEffectInfo.IsEffect())
 continue;
 
 // call effect handlers to handle destination hit
 HandleEffects(nullptr, nullptr, nullptr, nullptr, spellEffectInfo, SPELL_EFFECT_HANDLE_HIT);
 }
 
 // process items
 DoProcessTargetContainer(m_UniqueItemInfo);
}
 
void Spell::_handle_finish_phase()
{
 if (Unit* unitCaster = m_caster->ToUnit())
 if (m_spellInfo->HasEffect(SPELL_EFFECT_ADD_EXTRA_ATTACKS))
 unitCaster->SetLastExtraAttackSpell(m_spellInfo->Id);
 
 // Handle procs on finish
 if (!m_originalCaster)
 return;
 
 ProcFlagsInit procAttacker = m_procAttacker;
 if (!procAttacker)
 {
 if (m_spellInfo->HasAttribute(SPELL_ATTR3_TREAT_AS_PERIODIC))
 {
 if (IsPositive())
 procAttacker |= PROC_FLAG_DEAL_HELPFUL_PERIODIC;
 else
 procAttacker |= PROC_FLAG_DEAL_HARMFUL_PERIODIC;
 }
 else if (m_spellInfo->HasAttribute(SPELL_ATTR0_IS_ABILITY))
 {
 if (IsPositive())
 procAttacker |= PROC_FLAG_DEAL_HELPFUL_ABILITY;
 else
 procAttacker |= PROC_FLAG_DEAL_HARMFUL_ABILITY;
 }
 else
 {
 if (IsPositive())
 procAttacker |= PROC_FLAG_DEAL_HELPFUL_SPELL;
 else
 procAttacker |= PROC_FLAG_DEAL_HARMFUL_SPELL;
 }
 }
 
 Unit::ProcSkillsAndAuras(m_originalCaster, nullptr, procAttacker, PROC_FLAG_NONE, m_procSpellType, PROC_SPELL_PHASE_FINISH, m_hitMask, this, nullptr, nullptr);
}
 
void Spell::SendSpellCooldown()
{
 if (!m_caster->IsUnit())
 return;
 
 if (m_CastItem)
 m_caster->ToUnit()->GetSpellHistory()->HandleCooldowns(m_spellInfo, m_CastItem, this);
 else
 m_caster->ToUnit()->GetSpellHistory()->HandleCooldowns(m_spellInfo, m_castItemEntry, this);
 
 if (IsAutoRepeat())
 m_caster->ToUnit()->resetAttackTimer(RANGED_ATTACK);
}
 
void Spell::update(uint32 difftime)
{
 // update pointers based at it's GUIDs
 if (!UpdatePointers())
 {
 // cancel the spell if UpdatePointers() returned false, something wrong happened there
 cancel();
 return;
 }
 
 if (!m_targets.GetUnitTargetGUID().IsEmpty() && !m_targets.GetUnitTarget())
 {
 TC_LOG_DEBUG("spells", "Spell {} is cancelled due to removal of target.", m_spellInfo->Id);
 cancel();
 return;
 }
 
 // check if the unit caster has moved before the spell finished
 if (m_timer != 0 && m_caster->IsUnit() && m_caster->ToUnit()->isMoving() && CheckMovement() != SPELL_CAST_OK)
 cancel();
 
 switch (m_spellState)
 {
 case SPELL_STATE_PREPARING:
 {
 if (m_timer > 0)
 {
 if (difftime >= (uint32)m_timer)
 m_timer = 0;
 else
 m_timer -= difftime;
 }
 
 if (m_timer == 0 && !m_spellInfo->IsNextMeleeSwingSpell())
 // don't CheckCast for instant spells - done in spell::prepare, skip duplicate checks, needed for range checks for example
 cast(!m_casttime);
 break;
 }
 case SPELL_STATE_CASTING:
 {
 if (m_timer)
 {
 // check if there are alive targets left
 if (!UpdateChanneledTargetList())
 {
 TC_LOG_DEBUG("spells", "Channeled spell {} is removed due to lack of targets", m_spellInfo->Id);
 m_timer = 0;
 
 // Also remove applied auras
 for (TargetInfo const& target : m_UniqueTargetInfo)
 if (Unit* unit = m_caster->GetGUID() == target.TargetGUID ? m_caster->ToUnit() : ObjectAccessor::GetUnit(*m_caster, target.TargetGUID))
 unit->RemoveOwnedAura(m_spellInfo->Id, m_originalCasterGUID, 0, AURA_REMOVE_BY_CANCEL);
 }
 
 if (m_timer > 0)
 {
 if (difftime >= (uint32)m_timer)
 m_timer = 0;
 else
 m_timer -= difftime;
 }
 }
 
 if (IsEmpowerSpell())
 {
 int32 completedStages = [&]() -> int32
 {
 Milliseconds passed(m_channeledDuration - m_timer);
 for (std::size_t i = 0; i < m_empower->StageDurations.size(); ++i)
 {
 passed -= m_empower->StageDurations[i];
 if (passed < 0ms)
 return i;
 }
 
 return m_empower->StageDurations.size();
 }();
 
 if (completedStages != m_empower->CompletedStages)
 {
 WorldPackets::Spells::SpellEmpowerSetStage empowerSetStage;
 empowerSetStage.CastID = m_castId;
 empowerSetStage.CasterGUID = m_caster->GetGUID();
 empowerSetStage.Stage = m_empower->CompletedStages;
 m_caster->SendMessageToSet(empowerSetStage.Write(), true);
 
 m_empower->CompletedStages = completedStages;
 m_caster->ToUnit()->SetSpellEmpowerStage(completedStages);
 
 CallScriptEmpowerStageCompletedHandlers(completedStages);
 }
 
 if (CanReleaseEmpowerSpell())
 {
 m_empower->IsReleased = true;
 m_timer = 0;
 CallScriptEmpowerCompletedHandlers(m_empower->CompletedStages);
 m_caster->ToUnit()->RemoveAurasWithInterruptFlags(SpellAuraInterruptFlags2::ReleaseEmpower, m_spellInfo);
 }
 }
 
 if (m_timer == 0)
 {
 SendChannelUpdate(0, SPELL_CAST_OK);
 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);
 }
 break;
 }
 default:
 break;
 }
}
 
void Spell::finish(SpellCastResult result)
{
 if (m_spellState == SPELL_STATE_FINISHED)
 return;
 m_spellState = SPELL_STATE_FINISHED;
 
 if (m_scriptResult && (m_scriptWaitsForSpellHit || result != SPELL_CAST_OK))
 m_scriptResult->SetResult(result);
 
 if (!m_caster)
 return;
 
 Unit* unitCaster = m_caster->ToUnit();
 if (!unitCaster)
 return;
 
 // successful cast of the initial autorepeat spell is moved to idle state so that it is not deleted as long as autorepeat is active
 if (IsAutoRepeat() && unitCaster->GetCurrentSpell(CURRENT_AUTOREPEAT_SPELL) == this)
 m_spellState = SPELL_STATE_IDLE;
 
 if (m_spellInfo->IsChanneled())
 unitCaster->UpdateInterruptMask();
 
 if (unitCaster->HasUnitState(UNIT_STATE_CASTING) && !unitCaster->IsNonMeleeSpellCast(false, false, true))
 unitCaster->ClearUnitState(UNIT_STATE_CASTING);
 
 // Unsummon summon as possessed creatures on spell cancel
 if (m_spellInfo->IsChanneled() && unitCaster->GetTypeId() == TYPEID_PLAYER)
 {
 if (Unit* charm = unitCaster->GetCharmed())
 if (charm->GetTypeId() == TYPEID_UNIT
 && charm->ToCreature()->HasUnitTypeMask(UNIT_MASK_PUPPET)
 && charm->m_unitData->CreatedBySpell == int32(m_spellInfo->Id))
 ((Puppet*)charm)->UnSummon();
 }
 
 if (Creature* creatureCaster = u