TrinityCore: server/game/Spells/SpellEffects.cpp Source 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 "AccountMgr.h"

#include "AreaTrigger.h"

#include "AzeriteEmpoweredItem.h"

#include "AzeriteItem.h"

#include "Battleground.h"

#include "BattlegroundMgr.h"

#include "BattlePetMgr.h"

#include "CellImpl.h"

#include "CharmInfo.h"

#include "CombatLogPackets.h"

#include "CombatPackets.h"

#include "Common.h"

#include "Conversation.h"

#include "Creature.h"

#include "CreatureAI.h"

#include "CreatureTextMgr.h"

#include "DatabaseEnv.h"

#include "DB2Stores.h"

#include "DuelPackets.h"

#include "DynamicObject.h"

#include "GameEventSender.h"

#include "GameObject.h"

#include "GameObjectAI.h"

#include "GameTime.h"

#include "Garrison.h"

#include "GossipDef.h"

#include "GridNotifiers.h"

#include "GridNotifiersImpl.h"

#include "Group.h"

#include "Guild.h"

#include "InstanceScript.h"

#include "Item.h"

#include "Language.h"

#include "Log.h"

#include "Loot.h"

#include "LootMgr.h"

#include "Map.h"

#include "MiscPackets.h"

#include "MotionMaster.h"

#include "MoveSpline.h"

#include "ObjectAccessor.h"

#include "ObjectMgr.h"

#include "OutdoorPvPMgr.h"

#include "PathGenerator.h"

#include "Pet.h"

#include "PhasingHandler.h"

#include "Player.h"

#include "ReputationMgr.h"

#include "RestMgr.h"

#include "SceneObject.h"

#include "ScriptMgr.h"

#include "SharedDefines.h"

#include "SkillExtraItems.h"

#include "SocialMgr.h"

#include "SpellAuraEffects.h"

#include "SpellAuras.h"

#include "SpellHistory.h"

#include "SpellMgr.h"

#include "SpellPackets.h"

#include "TalentPackets.h"

#include "TemporarySummon.h"

#include "Totem.h"

#include "TraitMgr.h"

#include "TraitPacketsCommon.h"

#include "Unit.h"

#include "Util.h"

#include "World.h"

#include "WorldPacket.h"

#include "WorldSession.h"


NonDefaultConstructible<SpellEffectHandlerFn> SpellEffectHandlers[TOTAL_SPELL_EFFECTS] =

{

 &Spell::EffectNULL, // 0

 &Spell::EffectInstaKill, // 1 SPELL_EFFECT_INSTAKILL

 &Spell::EffectSchoolDMG, // 2 SPELL_EFFECT_SCHOOL_DAMAGE

 &Spell::EffectDummy, // 3 SPELL_EFFECT_DUMMY

 &Spell::EffectUnused, // 4 SPELL_EFFECT_PORTAL_TELEPORT unused

 &Spell::EffectNULL, // 5 SPELL_EFFECT_5

 &Spell::EffectApplyAura, // 6 SPELL_EFFECT_APPLY_AURA

 &Spell::EffectEnvironmentalDMG, // 7 SPELL_EFFECT_ENVIRONMENTAL_DAMAGE

 &Spell::EffectPowerDrain, // 8 SPELL_EFFECT_POWER_DRAIN

 &Spell::EffectHealthLeech, // 9 SPELL_EFFECT_HEALTH_LEECH

 &Spell::EffectHeal, // 10 SPELL_EFFECT_HEAL

 &Spell::EffectBind, // 11 SPELL_EFFECT_BIND

 &Spell::EffectNULL, // 12 SPELL_EFFECT_PORTAL

 &Spell::EffectTeleportToReturnPoint, // 13 SPELL_EFFECT_TELEPORT_TO_RETURN_POINT

 &Spell::EffectIncreaseCurrencyCap, // 14 SPELL_EFFECT_INCREASE_CURRENCY_CAP

 &Spell::EffectTeleportUnitsWithVisualLoadingScreen, // 15 SPELL_EFFECT_TELEPORT_WITH_SPELL_VISUAL_KIT_LOADING_SCREEN

 &Spell::EffectQuestComplete, // 16 SPELL_EFFECT_QUEST_COMPLETE

 &Spell::EffectWeaponDmg, // 17 SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL

 &Spell::EffectResurrect, // 18 SPELL_EFFECT_RESURRECT

 &Spell::EffectAddExtraAttacks, // 19 SPELL_EFFECT_ADD_EXTRA_ATTACKS

 &Spell::EffectUnused, // 20 SPELL_EFFECT_DODGE one spell: Dodge

 &Spell::EffectUnused, // 21 SPELL_EFFECT_EVADE one spell: Evade (DND)

 &Spell::EffectParry, // 22 SPELL_EFFECT_PARRY

 &Spell::EffectBlock, // 23 SPELL_EFFECT_BLOCK one spell: Block

 &Spell::EffectCreateItem, // 24 SPELL_EFFECT_CREATE_ITEM

 &Spell::EffectUnused, // 25 SPELL_EFFECT_WEAPON

 &Spell::EffectUnused, // 26 SPELL_EFFECT_DEFENSE one spell: Defense

 &Spell::EffectPersistentAA, // 27 SPELL_EFFECT_PERSISTENT_AREA_AURA

 &Spell::EffectSummonType, // 28 SPELL_EFFECT_SUMMON

 &Spell::EffectLeap, // 29 SPELL_EFFECT_LEAP

 &Spell::EffectEnergize, // 30 SPELL_EFFECT_ENERGIZE

 &Spell::EffectWeaponDmg, // 31 SPELL_EFFECT_WEAPON_PERCENT_DAMAGE

 &Spell::EffectTriggerMissileSpell, // 32 SPELL_EFFECT_TRIGGER_MISSILE

 &Spell::EffectOpenLock, // 33 SPELL_EFFECT_OPEN_LOCK

 &Spell::EffectSummonChangeItem, // 34 SPELL_EFFECT_SUMMON_CHANGE_ITEM

 &Spell::EffectUnused, // 35 SPELL_EFFECT_APPLY_AREA_AURA_PARTY

 &Spell::EffectLearnSpell, // 36 SPELL_EFFECT_LEARN_SPELL

 &Spell::EffectUnused, // 37 SPELL_EFFECT_SPELL_DEFENSE one spell: SPELLDEFENSE (DND)

 &Spell::EffectDispel, // 38 SPELL_EFFECT_DISPEL

 &Spell::EffectUnused, // 39 SPELL_EFFECT_LANGUAGE

 &Spell::EffectDualWield, // 40 SPELL_EFFECT_DUAL_WIELD

 &Spell::EffectJump, // 41 SPELL_EFFECT_JUMP

 &Spell::EffectJumpDest, // 42 SPELL_EFFECT_JUMP_DEST

 &Spell::EffectTeleUnitsFaceCaster, // 43 SPELL_EFFECT_TELEPORT_UNITS_FACE_CASTER

 &Spell::EffectLearnSkill, // 44 SPELL_EFFECT_SKILL_STEP

 &Spell::EffectPlayMovie, // 45 SPELL_EFFECT_PLAY_MOVIE

 &Spell::EffectUnused, // 46 SPELL_EFFECT_SPAWN clientside, unit appears as if it was just spawned

 &Spell::EffectTradeSkill, // 47 SPELL_EFFECT_TRADE_SKILL

 &Spell::EffectUnused, // 48 SPELL_EFFECT_STEALTH one spell: Base Stealth

 &Spell::EffectUnused, // 49 SPELL_EFFECT_DETECT one spell: Detect

 &Spell::EffectTransmitted, // 50 SPELL_EFFECT_TRANS_DOOR

 &Spell::EffectUnused, // 51 SPELL_EFFECT_FORCE_CRITICAL_HIT unused

 &Spell::EffectNULL, // 52 SPELL_EFFECT_SET_MAX_BATTLE_PET_COUNT

 &Spell::EffectEnchantItemPerm, // 53 SPELL_EFFECT_ENCHANT_ITEM

 &Spell::EffectEnchantItemTmp, // 54 SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY

 &Spell::EffectTameCreature, // 55 SPELL_EFFECT_TAMECREATURE

 &Spell::EffectSummonPet, // 56 SPELL_EFFECT_SUMMON_PET

 &Spell::EffectLearnPetSpell, // 57 SPELL_EFFECT_LEARN_PET_SPELL

 &Spell::EffectWeaponDmg, // 58 SPELL_EFFECT_WEAPON_DAMAGE

 &Spell::EffectCreateRandomItem, // 59 SPELL_EFFECT_CREATE_RANDOM_ITEM create item base at spell specific loot

 &Spell::EffectProficiency, // 60 SPELL_EFFECT_PROFICIENCY

 &Spell::EffectSendEvent, // 61 SPELL_EFFECT_SEND_EVENT

 &Spell::EffectPowerBurn, // 62 SPELL_EFFECT_POWER_BURN

 &Spell::EffectThreat, // 63 SPELL_EFFECT_THREAT

 &Spell::EffectTriggerSpell, // 64 SPELL_EFFECT_TRIGGER_SPELL

 &Spell::EffectUnused, // 65 SPELL_EFFECT_APPLY_AREA_AURA_RAID

 &Spell::EffectRechargeItem, // 66 SPELL_EFFECT_RECHARGE_ITEM

 &Spell::EffectHealMaxHealth, // 67 SPELL_EFFECT_HEAL_MAX_HEALTH

 &Spell::EffectInterruptCast, // 68 SPELL_EFFECT_INTERRUPT_CAST

 &Spell::EffectDistract, // 69 SPELL_EFFECT_DISTRACT

 &Spell::EffectNULL, // 70 SPELL_EFFECT_COMPLETE_AND_REWARD_WORLD_QUEST

 &Spell::EffectPickPocket, // 71 SPELL_EFFECT_PICKPOCKET

 &Spell::EffectAddFarsight, // 72 SPELL_EFFECT_ADD_FARSIGHT

 &Spell::EffectUntrainTalents, // 73 SPELL_EFFECT_UNTRAIN_TALENTS

 &Spell::EffectApplyGlyph, // 74 SPELL_EFFECT_APPLY_GLYPH

 &Spell::EffectHealMechanical, // 75 SPELL_EFFECT_HEAL_MECHANICAL one spell: Mechanical Patch Kit

 &Spell::EffectSummonObjectWild, // 76 SPELL_EFFECT_SUMMON_OBJECT_WILD

 &Spell::EffectScriptEffect, // 77 SPELL_EFFECT_SCRIPT_EFFECT

 &Spell::EffectUnused, // 78 SPELL_EFFECT_ATTACK

 &Spell::EffectSanctuary, // 79 SPELL_EFFECT_SANCTUARY

 &Spell::EffectNULL, // 80 SPELL_EFFECT_MODIFY_FOLLOWER_ITEM_LEVEL

 &Spell::EffectNULL, // 81 SPELL_EFFECT_PUSH_ABILITY_TO_ACTION_BAR

 &Spell::EffectNULL, // 82 SPELL_EFFECT_BIND_SIGHT

 &Spell::EffectDuel, // 83 SPELL_EFFECT_DUEL

 &Spell::EffectStuck, // 84 SPELL_EFFECT_STUCK

 &Spell::EffectSummonPlayer, // 85 SPELL_EFFECT_SUMMON_PLAYER

 &Spell::EffectActivateObject, // 86 SPELL_EFFECT_ACTIVATE_OBJECT

 &Spell::EffectGameObjectDamage, // 87 SPELL_EFFECT_GAMEOBJECT_DAMAGE

 &Spell::EffectGameObjectRepair, // 88 SPELL_EFFECT_GAMEOBJECT_REPAIR

 &Spell::EffectGameObjectSetDestructionState, // 89 SPELL_EFFECT_GAMEOBJECT_SET_DESTRUCTION_STATE

 &Spell::EffectKillCreditPersonal, // 90 SPELL_EFFECT_KILL_CREDIT Kill credit but only for single person

 &Spell::EffectNULL, // 91 SPELL_EFFECT_THREAT_ALL

 &Spell::EffectEnchantHeldItem, // 92 SPELL_EFFECT_ENCHANT_HELD_ITEM

 &Spell::EffectForceDeselect, // 93 SPELL_EFFECT_FORCE_DESELECT

 &Spell::EffectSelfResurrect, // 94 SPELL_EFFECT_SELF_RESURRECT

 &Spell::EffectSkinning, // 95 SPELL_EFFECT_SKINNING

 &Spell::EffectCharge, // 96 SPELL_EFFECT_CHARGE

 &Spell::EffectCastButtons, // 97 SPELL_EFFECT_CAST_BUTTON (totem bar since 3.2.2a)

 &Spell::EffectKnockBack, // 98 SPELL_EFFECT_KNOCK_BACK

 &Spell::EffectDisEnchant, // 99 SPELL_EFFECT_DISENCHANT

 &Spell::EffectInebriate, //100 SPELL_EFFECT_INEBRIATE

 &Spell::EffectFeedPet, //101 SPELL_EFFECT_FEED_PET

 &Spell::EffectDismissPet, //102 SPELL_EFFECT_DISMISS_PET

 &Spell::EffectReputation, //103 SPELL_EFFECT_REPUTATION

 &Spell::EffectSummonObject, //104 SPELL_EFFECT_SUMMON_OBJECT_SLOT1

 &Spell::EffectNULL, //105 SPELL_EFFECT_SURVEY

 &Spell::EffectChangeRaidMarker, //106 SPELL_EFFECT_CHANGE_RAID_MARKER

 &Spell::EffectNULL, //107 SPELL_EFFECT_SHOW_CORPSE_LOOT

 &Spell::EffectDispelMechanic, //108 SPELL_EFFECT_DISPEL_MECHANIC

 &Spell::EffectResurrectPet, //109 SPELL_EFFECT_RESURRECT_PET

 &Spell::EffectDestroyAllTotems, //110 SPELL_EFFECT_DESTROY_ALL_TOTEMS

 &Spell::EffectDurabilityDamage, //111 SPELL_EFFECT_DURABILITY_DAMAGE

 &Spell::EffectNULL, //112 SPELL_EFFECT_112

 &Spell::EffectCancelConversation, //113 SPELL_EFFECT_CANCEL_CONVERSATION

 &Spell::EffectTaunt, //114 SPELL_EFFECT_ATTACK_ME

 &Spell::EffectDurabilityDamagePCT, //115 SPELL_EFFECT_DURABILITY_DAMAGE_PCT

 &Spell::EffectSkinPlayerCorpse, //116 SPELL_EFFECT_SKIN_PLAYER_CORPSE one spell: Remove Insignia, bg usage, required special corpse flags...

 &Spell::EffectSpiritHeal, //117 SPELL_EFFECT_SPIRIT_HEAL one spell: Spirit Heal

 &Spell::EffectSkill, //118 SPELL_EFFECT_SKILL professions and more

 &Spell::EffectUnused, //119 SPELL_EFFECT_APPLY_AREA_AURA_PET

 &Spell::EffectTeleportGraveyard, //120 SPELL_EFFECT_TELEPORT_GRAVEYARD

 &Spell::EffectWeaponDmg, //121 SPELL_EFFECT_NORMALIZED_WEAPON_DMG

 &Spell::EffectUnused, //122 SPELL_EFFECT_122 unused

 &Spell::EffectSendTaxi, //123 SPELL_EFFECT_SEND_TAXI taxi/flight related (misc value is taxi path id)

 &Spell::EffectPullTowards, //124 SPELL_EFFECT_PULL_TOWARDS

 &Spell::EffectModifyThreatPercent, //125 SPELL_EFFECT_MODIFY_THREAT_PERCENT

 &Spell::EffectStealBeneficialBuff, //126 SPELL_EFFECT_STEAL_BENEFICIAL_BUFF spell steal effect?

 &Spell::EffectProspecting, //127 SPELL_EFFECT_PROSPECTING Prospecting spell

 &Spell::EffectUnused, //128 SPELL_EFFECT_APPLY_AREA_AURA_FRIEND

 &Spell::EffectUnused, //129 SPELL_EFFECT_APPLY_AREA_AURA_ENEMY

 &Spell::EffectRedirectThreat, //130 SPELL_EFFECT_REDIRECT_THREAT

 &Spell::EffectPlaySound, //131 SPELL_EFFECT_PLAY_SOUND sound id in misc value (SoundEntries.dbc)

 &Spell::EffectPlayMusic, //132 SPELL_EFFECT_PLAY_MUSIC sound id in misc value (SoundEntries.dbc)

 &Spell::EffectUnlearnSpecialization, //133 SPELL_EFFECT_UNLEARN_SPECIALIZATION unlearn profession specialization

 &Spell::EffectKillCredit, //134 SPELL_EFFECT_KILL_CREDIT misc value is creature entry

 &Spell::EffectNULL, //135 SPELL_EFFECT_CALL_PET

 &Spell::EffectHealPct, //136 SPELL_EFFECT_HEAL_PCT

 &Spell::EffectEnergizePct, //137 SPELL_EFFECT_ENERGIZE_PCT

 &Spell::EffectLeapBack, //138 SPELL_EFFECT_LEAP_BACK Leap back

 &Spell::EffectQuestClear, //139 SPELL_EFFECT_CLEAR_QUEST Reset quest status (miscValue - quest ID)

 &Spell::EffectForceCast, //140 SPELL_EFFECT_FORCE_CAST

 &Spell::EffectForceCast, //141 SPELL_EFFECT_FORCE_CAST_WITH_VALUE

 &Spell::EffectTriggerSpell, //142 SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE

 &Spell::EffectUnused, //143 SPELL_EFFECT_APPLY_AREA_AURA_OWNER

 &Spell::EffectKnockBack, //144 SPELL_EFFECT_KNOCK_BACK_DEST

 &Spell::EffectPullTowardsDest, //145 SPELL_EFFECT_PULL_TOWARDS_DEST Black Hole Effect

 &Spell::EffectNULL, //146 SPELL_EFFECT_RESTORE_GARRISON_TROOP_VITALITY

 &Spell::EffectQuestFail, //147 SPELL_EFFECT_QUEST_FAIL quest fail

 &Spell::EffectTriggerMissileSpell, //148 SPELL_EFFECT_TRIGGER_MISSILE_SPELL_WITH_VALUE

 &Spell::EffectChargeDest, //149 SPELL_EFFECT_CHARGE_DEST

 &Spell::EffectQuestStart, //150 SPELL_EFFECT_QUEST_START

 &Spell::EffectTriggerRitualOfSummoning, //151 SPELL_EFFECT_TRIGGER_SPELL_2

 &Spell::EffectSummonRaFFriend, //152 SPELL_EFFECT_SUMMON_RAF_FRIEND summon Refer-a-Friend

 &Spell::EffectCreateTamedPet, //153 SPELL_EFFECT_CREATE_TAMED_PET misc value is creature entry

 &Spell::EffectDiscoverTaxi, //154 SPELL_EFFECT_DISCOVER_TAXI

 &Spell::EffectTitanGrip, //155 SPELL_EFFECT_TITAN_GRIP Allows you to equip two-handed axes, maces and swords in one hand, but you attack $49152s1% slower than normal.

 &Spell::EffectEnchantItemPrismatic, //156 SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC

 &Spell::EffectCreateItem2, //157 SPELL_EFFECT_CREATE_ITEM_2 create item or create item template and replace by some randon spell loot item

 &Spell::EffectMilling, //158 SPELL_EFFECT_MILLING milling

 &Spell::EffectRenamePet, //159 SPELL_EFFECT_ALLOW_RENAME_PET allow rename pet once again

 &Spell::EffectForceCast, //160 SPELL_EFFECT_FORCE_CAST_2

 &Spell::EffectNULL, //161 SPELL_EFFECT_TALENT_SPEC_COUNT second talent spec (learn/revert)

 &Spell::EffectActivateSpec, //162 SPELL_EFFECT_TALENT_SPEC_SELECT activate primary/secondary spec

 &Spell::EffectNULL, //163 SPELL_EFFECT_OBLITERATE_ITEM

 &Spell::EffectRemoveAura, //164 SPELL_EFFECT_REMOVE_AURA

 &Spell::EffectDamageFromMaxHealthPCT, //165 SPELL_EFFECT_DAMAGE_FROM_MAX_HEALTH_PCT

 &Spell::EffectGiveCurrency, //166 SPELL_EFFECT_GIVE_CURRENCY

 &Spell::EffectUpdatePlayerPhase, //167 SPELL_EFFECT_UPDATE_PLAYER_PHASE

 &Spell::EffectNULL, //168 SPELL_EFFECT_ALLOW_CONTROL_PET

 &Spell::EffectDestroyItem, //169 SPELL_EFFECT_DESTROY_ITEM

 &Spell::EffectUpdateZoneAurasAndPhases, //170 SPELL_EFFECT_UPDATE_ZONE_AURAS_AND_PHASES

 &Spell::EffectSummonPersonalGameObject, //171 SPELL_EFFECT_SUMMON_PERSONAL_GAMEOBJECT

 &Spell::EffectResurrectWithAura, //172 SPELL_EFFECT_RESURRECT_WITH_AURA

 &Spell::EffectUnlockGuildVaultTab, //173 SPELL_EFFECT_UNLOCK_GUILD_VAULT_TAB

 &Spell::EffectApplyAura, //174 SPELL_EFFECT_APPLY_AURA_ON_PET

 &Spell::EffectNULL, //175 SPELL_EFFECT_175

 &Spell::EffectSanctuary, //176 SPELL_EFFECT_SANCTUARY_2

 &Spell::EffectNULL, //177 SPELL_EFFECT_DESPAWN_PERSISTENT_AREA_AURA

 &Spell::EffectUnused, //178 SPELL_EFFECT_178 unused

 &Spell::EffectCreateAreaTrigger, //179 SPELL_EFFECT_CREATE_AREATRIGGER

 &Spell::EffectNULL, //180 SPELL_EFFECT_UPDATE_AREATRIGGER

 &Spell::EffectRemoveTalent, //181 SPELL_EFFECT_REMOVE_TALENT

 &Spell::EffectNULL, //182 SPELL_EFFECT_DESPAWN_AREATRIGGER

 &Spell::EffectNULL, //183 SPELL_EFFECT_183

 &Spell::EffectNULL, //184 SPELL_EFFECT_REPUTATION

 &Spell::EffectNULL, //185 SPELL_EFFECT_185

 &Spell::EffectNULL, //186 SPELL_EFFECT_186

 &Spell::EffectNULL, //187 SPELL_EFFECT_RANDOMIZE_ARCHAEOLOGY_DIGSITES

 &Spell::EffectNULL, //188 SPELL_EFFECT_SUMMON_STABLED_PET_AS_GUARDIAN

 &Spell::EffectNULL, //189 SPELL_EFFECT_LOOT

 &Spell::EffectNULL, //190 SPELL_EFFECT_CHANGE_PARTY_MEMBERS

 &Spell::EffectNULL, //191 SPELL_EFFECT_TELEPORT_TO_DIGSITE

 &Spell::EffectUncageBattlePet, //192 SPELL_EFFECT_UNCAGE_BATTLEPET

 &Spell::EffectNULL, //193 SPELL_EFFECT_START_PET_BATTLE

 &Spell::EffectUnused, //194 SPELL_EFFECT_194

 &Spell::EffectPlaySceneScriptPackage, //195 SPELL_EFFECT_PLAY_SCENE_SCRIPT_PACKAGE

 &Spell::EffectCreateSceneObject, //196 SPELL_EFFECT_CREATE_SCENE_OBJECT

 &Spell::EffectCreatePrivateSceneObject, //197 SPELL_EFFECT_CREATE_PERSONAL_SCENE_OBJECT

 &Spell::EffectPlayScene, //198 SPELL_EFFECT_PLAY_SCENE

 &Spell::EffectNULL, //199 SPELL_EFFECT_DESPAWN_SUMMON

 &Spell::EffectHealBattlePetPct, //200 SPELL_EFFECT_HEAL_BATTLEPET_PCT

 &Spell::EffectEnableBattlePets, //201 SPELL_EFFECT_ENABLE_BATTLE_PETS

 &Spell::EffectUnused, //202 SPELL_EFFECT_APPLY_AREA_AURA_SUMMONS

 &Spell::EffectRemoveAura, //203 SPELL_EFFECT_REMOVE_AURA_2

 &Spell::EffectChangeBattlePetQuality, //204 SPELL_EFFECT_CHANGE_BATTLEPET_QUALITY

 &Spell::EffectLaunchQuestChoice, //205 SPELL_EFFECT_LAUNCH_QUEST_CHOICE

 &Spell::EffectNULL, //206 SPELL_EFFECT_ALTER_ITEM

 &Spell::EffectNULL, //207 SPELL_EFFECT_LAUNCH_QUEST_TASK

 &Spell::EffectNULL, //208 SPELL_EFFECT_SET_REPUTATION

 &Spell::EffectUnused, //209 SPELL_EFFECT_209

 &Spell::EffectLearnGarrisonBuilding, //210 SPELL_EFFECT_LEARN_GARRISON_BUILDING

 &Spell::EffectNULL, //211 SPELL_EFFECT_LEARN_GARRISON_SPECIALIZATION

 &Spell::EffectRemoveAuraBySpellLabel, //212 SPELL_EFFECT_REMOVE_AURA_BY_SPELL_LABEL

 &Spell::EffectJumpDest, //213 SPELL_EFFECT_JUMP_DEST_2

 &Spell::EffectCreateGarrison, //214 SPELL_EFFECT_CREATE_GARRISON

 &Spell::EffectNULL, //215 SPELL_EFFECT_UPGRADE_CHARACTER_SPELLS

 &Spell::EffectNULL, //216 SPELL_EFFECT_CREATE_SHIPMENT

 &Spell::EffectNULL, //217 SPELL_EFFECT_UPGRADE_GARRISON

 &Spell::EffectNULL, //218 SPELL_EFFECT_218

 &Spell::EffectCreateConversation, //219 SPELL_EFFECT_CREATE_CONVERSATION

 &Spell::EffectAddGarrisonFollower, //220 SPELL_EFFECT_ADD_GARRISON_FOLLOWER

 &Spell::EffectNULL, //221 SPELL_EFFECT_ADD_GARRISON_MISSION

 &Spell::EffectCreateHeirloomItem, //222 SPELL_EFFECT_CREATE_HEIRLOOM_ITEM

 &Spell::EffectNULL, //223 SPELL_EFFECT_CHANGE_ITEM_BONUSES

 &Spell::EffectActivateGarrisonBuilding, //224 SPELL_EFFECT_ACTIVATE_GARRISON_BUILDING

 &Spell::EffectGrantBattlePetLevel, //225 SPELL_EFFECT_GRANT_BATTLEPET_LEVEL

 &Spell::EffectNULL, //226 SPELL_EFFECT_TRIGGER_ACTION_SET

 &Spell::EffectNULL, //227 SPELL_EFFECT_TELEPORT_TO_LFG_DUNGEON

 &Spell::EffectNULL, //228 SPELL_EFFECT_228

 &Spell::EffectNULL, //229 SPELL_EFFECT_SET_FOLLOWER_QUALITY

 &Spell::EffectNULL, //230 SPELL_EFFECT_230

 &Spell::EffectNULL, //231 SPELL_EFFECT_INCREASE_FOLLOWER_EXPERIENCE

 &Spell::EffectNULL, //232 SPELL_EFFECT_REMOVE_PHASE

 &Spell::EffectNULL, //233 SPELL_EFFECT_RANDOMIZE_FOLLOWER_ABILITIES

 &Spell::EffectNULL, //234 SPELL_EFFECT_234

 &Spell::EffectUnused, //235 SPELL_EFFECT_235

 &Spell::EffectGiveExperience, //236 SPELL_EFFECT_GIVE_EXPERIENCE

 &Spell::EffectGiveRestedExperience, //237 SPELL_EFFECT_GIVE_RESTED_EXPERIENCE_BONUS

 &Spell::EffectNULL, //238 SPELL_EFFECT_INCREASE_SKILL

 &Spell::EffectNULL, //239 SPELL_EFFECT_END_GARRISON_BUILDING_CONSTRUCTION

 &Spell::EffectGiveArtifactPower, //240 SPELL_EFFECT_GIVE_ARTIFACT_POWER

 &Spell::EffectUnused, //241 SPELL_EFFECT_241

 &Spell::EffectGiveArtifactPowerNoBonus, //242 SPELL_EFFECT_GIVE_ARTIFACT_POWER_NO_BONUS

 &Spell::EffectApplyEnchantIllusion, //243 SPELL_EFFECT_APPLY_ENCHANT_ILLUSION

 &Spell::EffectNULL, //244 SPELL_EFFECT_LEARN_FOLLOWER_ABILITY

 &Spell::EffectUpgradeHeirloom, //245 SPELL_EFFECT_UPGRADE_HEIRLOOM

 &Spell::EffectNULL, //246 SPELL_EFFECT_FINISH_GARRISON_MISSION

 &Spell::EffectNULL, //247 SPELL_EFFECT_ADD_GARRISON_MISSION_SET

 &Spell::EffectNULL, //248 SPELL_EFFECT_FINISH_SHIPMENT

 &Spell::EffectNULL, //249 SPELL_EFFECT_FORCE_EQUIP_ITEM

 &Spell::EffectNULL, //250 SPELL_EFFECT_TAKE_SCREENSHOT

 &Spell::EffectNULL, //251 SPELL_EFFECT_SET_GARRISON_CACHE_SIZE

 &Spell::EffectTeleportUnits, //252 SPELL_EFFECT_TELEPORT_UNITS

 &Spell::EffectGiveHonor, //253 SPELL_EFFECT_GIVE_HONOR

 &Spell::EffectJumpCharge, //254 SPELL_EFFECT_JUMP_CHARGE

 &Spell::EffectLearnTransmogSet, //255 SPELL_EFFECT_LEARN_TRANSMOG_SET

 &Spell::EffectUnused, //256 SPELL_EFFECT_256

 &Spell::EffectUnused, //257 SPELL_EFFECT_257

 &Spell::EffectNULL, //258 SPELL_EFFECT_MODIFY_KEYSTONE

 &Spell::EffectRespecAzeriteEmpoweredItem, //259 SPELL_EFFECT_RESPEC_AZERITE_EMPOWERED_ITEM

 &Spell::EffectNULL, //260 SPELL_EFFECT_SUMMON_STABLED_PET

 &Spell::EffectNULL, //261 SPELL_EFFECT_SCRAP_ITEM

 &Spell::EffectUnused, //262 SPELL_EFFECT_262

 &Spell::EffectNULL, //263 SPELL_EFFECT_REPAIR_ITEM

 &Spell::EffectNULL, //264 SPELL_EFFECT_REMOVE_GEM

 &Spell::EffectLearnAzeriteEssencePower, //265 SPELL_EFFECT_LEARN_AZERITE_ESSENCE_POWER

 &Spell::EffectNULL, //266 SPELL_EFFECT_SET_ITEM_BONUS_LIST_GROUP_ENTRY

 &Spell::EffectCreatePrivateConversation, //267 SPELL_EFFECT_CREATE_PRIVATE_CONVERSATION

 &Spell::EffectNULL, //268 SPELL_EFFECT_APPLY_MOUNT_EQUIPMENT

 &Spell::EffectNULL, //269 SPELL_EFFECT_INCREASE_ITEM_BONUS_LIST_GROUP_STEP

 &Spell::EffectNULL, //270 SPELL_EFFECT_270

 &Spell::EffectUnused, //271 SPELL_EFFECT_APPLY_AREA_AURA_PARTY_NONRANDOM

 &Spell::EffectNULL, //272 SPELL_EFFECT_SET_COVENANT

 &Spell::EffectNULL, //273 SPELL_EFFECT_CRAFT_RUNEFORGE_LEGENDARY

 &Spell::EffectUnused, //274 SPELL_EFFECT_274

 &Spell::EffectUnused, //275 SPELL_EFFECT_275

 &Spell::EffectLearnTransmogIllusion, //276 SPELL_EFFECT_LEARN_TRANSMOG_ILLUSION

 &Spell::EffectNULL, //277 SPELL_EFFECT_SET_CHROMIE_TIME

 &Spell::EffectNULL, //278 SPELL_EFFECT_278

 &Spell::EffectNULL, //279 SPELL_EFFECT_LEARN_GARR_TALENT

 &Spell::EffectUnused, //280 SPELL_EFFECT_280

 &Spell::EffectNULL, //281 SPELL_EFFECT_LEARN_SOULBIND_CONDUIT

 &Spell::EffectNULL, //282 SPELL_EFFECT_CONVERT_ITEMS_TO_CURRENCY

 &Spell::EffectNULL, //283 SPELL_EFFECT_COMPLETE_CAMPAIGN

 &Spell::EffectSendChatMessage, //284 SPELL_EFFECT_SEND_CHAT_MESSAGE

 &Spell::EffectNULL, //285 SPELL_EFFECT_MODIFY_KEYSTONE_2

 &Spell::EffectGrantBattlePetExperience, //286 SPELL_EFFECT_GRANT_BATTLEPET_EXPERIENCE

 &Spell::EffectNULL, //287 SPELL_EFFECT_SET_GARRISON_FOLLOWER_LEVEL

 &Spell::EffectNULL, //288 SPELL_EFFECT_CRAFT_ITEM

 &Spell::EffectModifyAuraStacks, //289 SPELL_EFFECT_MODIFY_AURA_STACKS

 &Spell::EffectModifyCooldown, //290 SPELL_EFFECT_MODIFY_COOLDOWN

 &Spell::EffectModifyCooldowns, //291 SPELL_EFFECT_MODIFY_COOLDOWNS

 &Spell::EffectModifyCooldownsByCategory, //292 SPELL_EFFECT_MODIFY_COOLDOWNS_BY_CATEGORY

 &Spell::EffectModifySpellCharges, //293 SPELL_EFFECT_MODIFY_CHARGES

 &Spell::EffectNULL, //294 SPELL_EFFECT_CRAFT_LOOT

 &Spell::EffectNULL, //295 SPELL_EFFECT_SALVAGE_ITEM

 &Spell::EffectNULL, //296 SPELL_EFFECT_CRAFT_SALVAGE_ITEM

 &Spell::EffectNULL, //297 SPELL_EFFECT_RECRAFT_ITEM

 &Spell::EffectNULL, //298 SPELL_EFFECT_CANCEL_ALL_PRIVATE_CONVERSATIONS

 &Spell::EffectNULL, //299 SPELL_EFFECT_299

 &Spell::EffectUnused, //300 SPELL_EFFECT_300

 &Spell::EffectNULL, //301 SPELL_EFFECT_CRAFT_ENCHANT

 &Spell::EffectNULL, //302 SPELL_EFFECT_GATHERING

 &Spell::EffectCreateTraitTreeConfig, //303 SPELL_EFFECT_CREATE_TRAIT_TREE_CONFIG

 &Spell::EffectChangeActiveCombatTraitConfig, //304 SPELL_EFFECT_CHANGE_ACTIVE_COMBAT_TRAIT_CONFIG

 &Spell::EffectNULL, //305 SPELL_EFFECT_305

 &Spell::EffectNULL, //306 SPELL_EFFECT_UPDATE_INTERACTIONS

 &Spell::EffectNULL, //307 SPELL_EFFECT_307

 &Spell::EffectNULL, //308 SPELL_EFFECT_CANCEL_PRELOAD_WORLD

 &Spell::EffectNULL, //309 SPELL_EFFECT_PRELOAD_WORLD

 &Spell::EffectNULL, //310 SPELL_EFFECT_310

 &Spell::EffectNULL, //311 SPELL_EFFECT_ENSURE_WORLD_LOADED

 &Spell::EffectNULL, //312 SPELL_EFFECT_312

 &Spell::EffectNULL, //313 SPELL_EFFECT_CHANGE_ITEM_BONUSES_2

 &Spell::EffectNULL, //314 SPELL_EFFECT_ADD_SOCKET_BONUS

 &Spell::EffectNULL, //315 SPELL_EFFECT_LEARN_TRANSMOG_APPEARANCE_FROM_ITEM_MOD_APPEARANCE_GROUP

};


void Spell::EffectNULL()

{

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

}


void Spell::EffectUnused()

{

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

}


void Spell::EffectResurrectNew()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!m_corpseTarget && !unitTarget)

 return;


 Player* player = nullptr;


 if (m_corpseTarget)

 player = ObjectAccessor::FindPlayer(m_corpseTarget->GetOwnerGUID());

 else if (unitTarget)

 player = unitTarget->ToPlayer();


 if (!player || player->IsAlive() || !player->IsInWorld())

 return;


 if (player->IsResurrectRequested()) // already have one active request

 return;


 uint32 health = damage;

 uint32 mana = effectInfo->MiscValue;

 ExecuteLogEffectResurrect(SpellEffectName(effectInfo->Effect), player);

 player->SetResurrectRequestData(m_caster, health, mana, 0);

 SendResurrectRequest(player);

}


void Spell::EffectInstaKill()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || !unitTarget->IsAlive())

 return;


 if (unitTarget->GetTypeId() == TYPEID_PLAYER)

 if (unitTarget->ToPlayer()->GetCommandStatus(CHEAT_GOD))

 return;


 if (m_caster == unitTarget) // prevent interrupt message

 finish();


 WorldPackets::CombatLog::SpellInstakillLog data;

 data.Target = unitTarget->GetGUID();

 data.Caster = m_caster->GetGUID();

 data.SpellID = m_spellInfo->Id;

 m_caster->SendMessageToSet(data.Write(), true);


 Unit::Kill(GetUnitCasterForEffectHandlers(), unitTarget, false);

}


void Spell::EffectEnvironmentalDMG()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || !unitTarget->IsAlive())

 return;


 // CalcAbsorbResist already in Player::EnvironmentalDamage

 if (unitTarget->GetTypeId() == TYPEID_PLAYER)

 unitTarget->ToPlayer()->EnvironmentalDamage(DAMAGE_FIRE, damage);

 else

 {

 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 DamageInfo damageInfo(unitCaster, unitTarget, damage, m_spellInfo, m_spellInfo->GetSchoolMask(), SPELL_DIRECT_DAMAGE, BASE_ATTACK);

 Unit::CalcAbsorbResist(damageInfo);


 SpellNonMeleeDamage log(unitCaster, unitTarget, m_spellInfo, m_SpellVisual, m_spellInfo->GetSchoolMask(), m_castId);

 log.damage = damageInfo.GetDamage();

 log.originalDamage = damage;

 log.absorb = damageInfo.GetAbsorb();

 log.resist = damageInfo.GetResist();


 if (unitCaster)

 unitCaster->SendSpellNonMeleeDamageLog(&log);

 }

}


void Spell::EffectSchoolDMG()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)

 return;


 if (unitTarget && unitTarget->IsAlive())

 {

 bool apply_direct_bonus = true;


 // Meteor like spells (divided damage to targets)

 if (m_spellInfo->HasAttribute(SPELL_ATTR0_CU_SHARE_DAMAGE))

 {

 // divide to all targets

 if (int64 count = GetUnitTargetCountForEffect(SpellEffIndex(effectInfo->EffectIndex)))

 damage /= count;

 }


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 switch (m_spellInfo->SpellFamilyName)

 {

 case SPELLFAMILY_GENERIC:

 {

 break;

 }

 case SPELLFAMILY_WARRIOR:

 {

 break;

 }

 case SPELLFAMILY_WARLOCK:

 {

 break;

 }

 case SPELLFAMILY_PRIEST:

 {

 break;

 }

 case SPELLFAMILY_DRUID:

 {

 break;

 }

 case SPELLFAMILY_DEATHKNIGHT:

 {

 break;

 }

 }


 if (unitCaster && apply_direct_bonus)

 {

 uint32 bonus = unitCaster->SpellDamageBonusDone(unitTarget, m_spellInfo, (uint32)damage, SPELL_DIRECT_DAMAGE, *effectInfo, 1, this);

 damage = bonus + uint32(bonus * variance);

 damage = unitTarget->SpellDamageBonusTaken(unitCaster, m_spellInfo, (uint32)damage, SPELL_DIRECT_DAMAGE);

 }


 m_damage += damage;

 }

}


void Spell::EffectDummy()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget && !gameObjTarget && !itemTarget && !m_corpseTarget)

 return;


 // pet auras

 if (m_caster->GetTypeId() == TYPEID_PLAYER)

 {

 if (PetAura const* petSpell = sSpellMgr->GetPetAura(m_spellInfo->Id, effectInfo->EffectIndex))

 {

 m_caster->ToPlayer()->AddPetAura(petSpell);

 return;

 }

 }


 // normal DB scripted effect

 TC_LOG_DEBUG("spells", "Spell ScriptStart spellid {} in EffectDummy({})", m_spellInfo->Id, effectInfo->EffectIndex);

 m_caster->GetMap()->ScriptsStart(sSpellScripts, uint32(m_spellInfo->Id | (effectInfo->EffectIndex << 24)), m_caster, unitTarget);

}


void Spell::EffectTriggerSpell()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET

 && effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)

 return;


 uint32 triggered_spell_id = effectInfo->TriggerSpell;


 if (effectInfo->Effect == SPELL_EFFECT_TRIGGER_SPELL

 && effectHandleMode == SPELL_EFFECT_HANDLE_LAUNCH_TARGET)

 {

 // special cases

 switch (triggered_spell_id)

 {

 // Demonic Empowerment -- succubus

 case 54437:

 {

 unitTarget->RemoveMovementImpairingAuras(true);

 unitTarget->RemoveAurasByType(SPELL_AURA_MOD_STALKED);

 unitTarget->RemoveAurasByType(SPELL_AURA_MOD_STUN);


 // Cast Lesser Invisibility

 unitTarget->CastSpell(unitTarget, 7870, this);

 return;

 }

 // Brittle Armor - (need add max stack of 24575 Brittle Armor)

 case 29284:

 {

 // Brittle Armor

 SpellInfo const* spell = sSpellMgr->GetSpellInfo(24575, GetCastDifficulty());

 if (!spell)

 return;


 for (uint32 j = 0; j < spell->StackAmount; ++j)

 m_caster->CastSpell(unitTarget, spell->Id, this);

 return;

 }

 // Mercurial Shield - (need add max stack of 26464 Mercurial Shield)

 case 29286:

 {

 // Mercurial Shield

 SpellInfo const* spell = sSpellMgr->GetSpellInfo(26464, GetCastDifficulty());

 if (!spell)

 return;


 for (uint32 j = 0; j < spell->StackAmount; ++j)

 m_caster->CastSpell(unitTarget, spell->Id, this);

 return;

 }

 }

 }


 if (triggered_spell_id == 0)

 {

 TC_LOG_WARN("spells.effect.nospell", "Spell::EffectTriggerSpell: Spell {} [EffectIndex: {}] does not have triggered spell.", m_spellInfo->Id, effectInfo->EffectIndex);

 return;

 }


 // normal case

 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(triggered_spell_id, GetCastDifficulty());

 if (!spellInfo)

 {

 TC_LOG_ERROR("spells.effect.nospell", "Spell::EffectTriggerSpell spell {} tried to trigger unknown spell {}", m_spellInfo->Id, triggered_spell_id);

 return;

 }


 SpellCastTargets targets;

 Optional<int32> targetCount;

 Optional<int32> targetIndex;

 if (effectHandleMode == SPELL_EFFECT_HANDLE_LAUNCH_TARGET)

 {

 if (!spellInfo->NeedsToBeTriggeredByCaster(m_spellInfo))

 return;

 targets.SetUnitTarget(unitTarget);

 targetCount = GetUnitTargetCountForEffect(effectInfo->EffectIndex);

 targetIndex = GetUnitTargetIndexForEffect(unitTarget->GetGUID(), effectInfo->EffectIndex);

 }

 else //if (effectHandleMode == SPELL_EFFECT_HANDLE_LAUNCH)

 {

 if (spellInfo->NeedsToBeTriggeredByCaster(m_spellInfo) && (effectInfo->GetProvidedTargetMask() & TARGET_FLAG_UNIT_MASK))

 return;


 if (spellInfo->GetExplicitTargetMask() & TARGET_FLAG_DEST_LOCATION && m_targets.HasDst())

 targets.SetDst(m_targets);


 if (Unit* target = m_targets.GetUnitTarget())

 targets.SetUnitTarget(target);

 else

 {

 if (Unit* unit = m_caster->ToUnit())

 targets.SetUnitTarget(unit);

 else if (GameObject* go = m_caster->ToGameObject())

 targets.SetGOTarget(go);

 }

 }


 Milliseconds delay = 0ms;

 if (effectInfo->Effect == SPELL_EFFECT_TRIGGER_SPELL)

 delay = Milliseconds(effectInfo->MiscValue);


 m_caster->m_Events.AddEventAtOffset([caster = m_caster, targets, originalCaster = m_originalCasterGUID, castItemGuid = m_castItemGUID, originalCastId = m_castId,

 spellEffectInfo = effectInfo, value = damage, itemLevel = m_castItemLevel, targetCount, targetIndex]() mutable

 {

 targets.Update(caster); // refresh pointers stored in targets


 // original caster guid only for GO cast

 CastSpellExtraArgs args(TRIGGERED_FULL_MASK);

 args.SetOriginalCaster(originalCaster);

 args.OriginalCastId = originalCastId;

 args.OriginalCastItemLevel = itemLevel;

 if (!castItemGuid.IsEmpty() && sSpellMgr->AssertSpellInfo(spellEffectInfo->TriggerSpell, caster->GetMap()->GetDifficultyID())->HasAttribute(SPELL_ATTR2_RETAIN_ITEM_CAST))

 if (Player const* triggeringAuraCaster = Object::ToPlayer(caster))

 args.CastItem = triggeringAuraCaster->GetItemByGuid(castItemGuid);


 // set basepoints for trigger with value effect

 if (spellEffectInfo->Effect == SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE)

 for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)

 args.AddSpellMod(SpellValueMod(SPELLVALUE_BASE_POINT0 + i), value);


 if (targetCount)

 args.AddSpellMod(SPELLVALUE_PARENT_SPELL_TARGET_COUNT, *targetCount);


 if (targetIndex)

 args.AddSpellMod(SPELLVALUE_PARENT_SPELL_TARGET_INDEX, *targetIndex);


 caster->CastSpell(std::move(targets), spellEffectInfo->TriggerSpell, args);

 }, delay);

}


void Spell::EffectTriggerMissileSpell()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET

 && effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 uint32 triggered_spell_id = effectInfo->TriggerSpell;

 if (triggered_spell_id == 0)

 {

 TC_LOG_WARN("spells.effect.nospell", "Spell::EffectTriggerMissileSpell: Spell {} [EffectIndex: {}] does not have triggered spell.", m_spellInfo->Id, effectInfo->EffectIndex);

 return;

 }


 // normal case

 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(triggered_spell_id, GetCastDifficulty());

 if (!spellInfo)

 {

 TC_LOG_ERROR("spells.effect.nospell", "Spell::EffectTriggerMissileSpell spell {} tried to trigger unknown spell {}.", m_spellInfo->Id, triggered_spell_id);

 return;

 }


 SpellCastTargets targets;

 Optional<int32> targetCount;

 Optional<int32> targetIndex;

 if (effectHandleMode == SPELL_EFFECT_HANDLE_HIT_TARGET)

 {

 if (!spellInfo->NeedsToBeTriggeredByCaster(m_spellInfo))

 return;

 targets.SetUnitTarget(unitTarget);

 targetCount = GetUnitTargetCountForEffect(effectInfo->EffectIndex);

 targetIndex = GetUnitTargetIndexForEffect(unitTarget->GetGUID(), effectInfo->EffectIndex);

 }

 else //if (effectHandleMode == SPELL_EFFECT_HANDLE_HIT)

 {

 if (spellInfo->NeedsToBeTriggeredByCaster(m_spellInfo) && (effectInfo->GetProvidedTargetMask() & TARGET_FLAG_UNIT_MASK))

 return;


 if (spellInfo->GetExplicitTargetMask() & TARGET_FLAG_DEST_LOCATION)

 targets.SetDst(m_targets);


 if (Unit* unit = m_caster->ToUnit())

 targets.SetUnitTarget(unit);

 else if (GameObject* go = m_caster->ToGameObject())

 targets.SetGOTarget(go);

 }


 CastSpellExtraArgs args(TRIGGERED_FULL_MASK);

 args.SetOriginalCaster(m_originalCasterGUID);

 args.SetTriggeringSpell(this);

 args.SetCustomArg(m_customArg);


 // set basepoints for trigger with value effect

 if (effectInfo->Effect == SPELL_EFFECT_TRIGGER_MISSILE_SPELL_WITH_VALUE)

 for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)

 args.AddSpellMod(SpellValueMod(SPELLVALUE_BASE_POINT0 + i), damage);


 if (targetCount)

 args.AddSpellMod(SPELLVALUE_PARENT_SPELL_TARGET_COUNT, *targetCount);


 if (targetIndex)

 args.AddSpellMod(SPELLVALUE_PARENT_SPELL_TARGET_INDEX, *targetIndex);


 // original caster guid only for GO cast

 m_caster->CastSpell(std::move(targets), spellInfo->Id, args);

}


void Spell::EffectForceCast()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 uint32 triggered_spell_id = effectInfo->TriggerSpell;

 if (triggered_spell_id == 0)

 {

 TC_LOG_WARN("spells.effect.nospell", "Spell::EffectForceCast: Spell {} [EffectIndex: {}] does not have triggered spell.", m_spellInfo->Id, effectInfo->EffectIndex);

 return;

 }


 // normal case

 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(triggered_spell_id, GetCastDifficulty());


 if (!spellInfo)

 {

 TC_LOG_ERROR("spells.effect.nospell", "Spell::EffectForceCast of spell {}: triggering unknown spell id {}.", m_spellInfo->Id, triggered_spell_id);

 return;

 }


 if (effectInfo->Effect == SPELL_EFFECT_FORCE_CAST && damage)

 {

 switch (m_spellInfo->Id)

 {

 case 52588: // Skeletal Gryphon Escape

 case 48598: // Ride Flamebringer Cue

 unitTarget->RemoveAura(damage);

 break;

 case 52463: // Hide In Mine Car

 case 52349: // Overtake

 {

 CastSpellExtraArgs args(TRIGGERED_FULL_MASK);

 args.SetOriginalCaster(m_originalCasterGUID);

 args.SetTriggeringSpell(this);

 args.AddSpellMod(SPELLVALUE_BASE_POINT0, damage);

 unitTarget->CastSpell(unitTarget, spellInfo->Id, args);

 return;

 }

 }

 }


 switch (spellInfo->Id)

 {

 case 72298: // Malleable Goo Summon

 unitTarget->CastSpell(unitTarget, spellInfo->Id, CastSpellExtraArgs(TRIGGERED_FULL_MASK)

 .SetOriginalCaster(m_originalCasterGUID)

 .SetTriggeringSpell(this));

 return;

 }


 CastSpellExtraArgs args(TRIGGERED_FULL_MASK);

 args.SetTriggeringSpell(this);

 if (effectInfo->Effect == SPELL_EFFECT_FORCE_CAST_WITH_VALUE)

 for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)

 args.AddSpellMod(SpellValueMod(SPELLVALUE_BASE_POINT0 + i), damage);


 unitTarget->CastSpell(m_caster, spellInfo->Id, args);

}


void Spell::EffectTriggerRitualOfSummoning()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 uint32 triggered_spell_id = effectInfo->TriggerSpell;

 if (triggered_spell_id == 0)

 {

 TC_LOG_WARN("spells.effect.nospell", "Spell::EffectTriggerRitualOfSummoning: Spell {} [EffectIndex: {}] does not have triggered spell.", m_spellInfo->Id, effectInfo->EffectIndex);

 return;

 }


 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(triggered_spell_id, GetCastDifficulty());


 if (!spellInfo)

 {

 TC_LOG_ERROR("spells.effect.nospell", "EffectTriggerRitualOfSummoning of spell {}: triggering unknown spell id {}.", m_spellInfo->Id, triggered_spell_id);

 return;

 }


 finish();


 m_caster->CastSpell(nullptr, spellInfo->Id, CastSpellExtraArgs()

 .SetTriggeringSpell(this));

}


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

{

 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 ASSERT(unitCaster);


 float multiplier = effInfo->Amplitude;

 if (multiplier <= 0.0f)

 multiplier = 1.0f;


 float minHeight = effInfo->MiscValue ? effInfo->MiscValue / 10.0f : 0.5f; // Lower bound is blizzlike

 float maxHeight = effInfo->MiscValueB ? effInfo->MiscValueB / 10.0f : 1000.0f; // Upper bound is unknown


 unitCaster->GetMotionMaster()->CalculateJumpSpeeds(dist, MOVE_RUN, multiplier, minHeight, maxHeight, speedXY, speedZ);

}


void Spell::EffectJump()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 if (unitCaster->IsInFlight())

 return;


 if (!unitTarget)

 return;


 float speedXY, speedZ;

 CalculateJumpSpeeds(effectInfo, unitCaster->GetExactDist2d(unitTarget), speedXY, speedZ);

 JumpArrivalCastArgs arrivalCast;

 arrivalCast.SpellId = effectInfo->TriggerSpell;

 arrivalCast.Target = unitTarget->GetGUID();

 unitCaster->GetMotionMaster()->MoveJump(*unitTarget, speedXY, speedZ, EVENT_JUMP, false, &arrivalCast);

}


void Spell::EffectJumpDest()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 if (unitCaster->IsInFlight())

 return;


 if (!m_targets.HasDst())

 return;


 float speedXY, speedZ;

 CalculateJumpSpeeds(effectInfo, unitCaster->GetExactDist2d(destTarget), speedXY, speedZ);

 JumpArrivalCastArgs arrivalCast;

 arrivalCast.SpellId = effectInfo->TriggerSpell;

 unitCaster->GetMotionMaster()->MoveJump(*destTarget, speedXY, speedZ, EVENT_JUMP, !m_targets.GetObjectTargetGUID().IsEmpty(), &arrivalCast);

}


TeleportToOptions GetTeleportOptions(WorldObject const* caster, Unit const* unitTarget, SpellDestination const& targetDest)

{

 TeleportToOptions options = TELE_TO_NONE;

 if (caster == unitTarget)

 options |= TELE_TO_SPELL;


 if (targetDest._position.GetMapId() == unitTarget->GetMapId())

 {

 options |= TELE_TO_NOT_LEAVE_COMBAT | TELE_TO_NOT_UNSUMMON_PET;


 if (unitTarget->GetTransGUID() == targetDest._transportGUID)

 options |= TELE_TO_NOT_LEAVE_TRANSPORT;

 }


 return options;

}


void Spell::EffectTeleportUnits()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->IsInFlight())

 return;


 // If not exist data for dest location - return

 if (!m_targets.HasDst())

 {

 TC_LOG_ERROR("spells", "Spell::EffectTeleportUnits - does not have a destination for spellId {}.", m_spellInfo->Id);

 return;

 }


 // Init dest coordinates

 WorldLocation targetDest(*destTarget);

 if (targetDest.GetMapId() == MAPID_INVALID)

 targetDest.m_mapId = unitTarget->GetMapId();


 if (!targetDest.GetOrientation() && m_targets.GetUnitTarget())

 targetDest.SetOrientation(m_targets.GetUnitTarget()->GetOrientation());


 Player* player = unitTarget->ToPlayer();


 // Custom loading screen

 if (player)

 {

 if (uint32 customLoadingScreenId = effectInfo->MiscValue)

 player->SendDirectMessage(WorldPackets::Spells::CustomLoadScreen(m_spellInfo->Id, customLoadingScreenId).Write());


 TeleportToOptions options = GetTeleportOptions(m_caster, unitTarget, m_destTargets[effectInfo->EffectIndex]);


 player->TeleportTo(targetDest, options);


 }

 else if (targetDest.GetMapId() == unitTarget->GetMapId())

 unitTarget->NearTeleportTo(targetDest, unitTarget == m_caster);

 else

 TC_LOG_ERROR("spells", "Spell::EffectTeleportUnits - spellId {} attempted to teleport creature to a different map.", m_spellInfo->Id);

}


class DelayedSpellTeleportEvent : public BasicEvent

{

public:

 explicit DelayedSpellTeleportEvent(Unit* target, WorldLocation const& targetDest, TeleportToOptions options, uint32 spellId)

 : _target(target), _targetDest(targetDest), _options(options), _spellId(spellId){ }


 bool Execute(uint64 /*e_time*/, uint32 /*p_time*/) override

 {

 if (Player* player = _target->ToPlayer())

 player->TeleportTo(_targetDest, _options);

 else if (_targetDest.GetMapId() == _target->GetMapId())

 _target->NearTeleportTo(_targetDest, (_options & TELE_TO_SPELL) != TELE_TO_NONE);

 else

 TC_LOG_ERROR("spells", "Spell::EffectTeleportUnitsWithVisualLoadingScreen - spellId {} attempted to teleport creature to a different map.", _spellId);


 return true;

 }


private:

 Unit* _target;

 WorldLocation _targetDest;

 TeleportToOptions _options;

 uint32 _spellId;

};


void Spell::EffectTeleportUnitsWithVisualLoadingScreen()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 // If not exist data for dest location - return

 if (!m_targets.HasDst())

 {

 TC_LOG_ERROR("spells", "Spell::EffectTeleportUnitsWithVisualLoadingScreen - does not have a destination for spellId {}.", m_spellInfo->Id);

 return;

 }


 // Init dest coordinates

 WorldLocation targetDest(*destTarget);

 if (targetDest.GetMapId() == MAPID_INVALID)

 targetDest.m_mapId = unitTarget->GetMapId();


 if (!targetDest.GetOrientation() && m_targets.GetUnitTarget())

 targetDest.SetOrientation(m_targets.GetUnitTarget()->GetOrientation());


 if (effectInfo->MiscValueB)

 if (Player* playerTarget = unitTarget->ToPlayer())

 playerTarget->SendDirectMessage(WorldPackets::Spells::SpellVisualLoadScreen(effectInfo->MiscValueB, effectInfo->MiscValue).Write());


 TeleportToOptions options = GetTeleportOptions(m_caster, unitTarget, m_destTargets[effectInfo->EffectIndex]);

 unitTarget->m_Events.AddEventAtOffset(new DelayedSpellTeleportEvent(unitTarget, targetDest, options, m_spellInfo->Id),

 Milliseconds(effectInfo->MiscValue));

}


void Spell::EffectApplyAura()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!_spellAura || !unitTarget)

 return;


 // register target/effect on aura

 AuraApplication* aurApp = _spellAura->GetApplicationOfTarget(unitTarget->GetGUID());

 if (!aurApp)

 aurApp = unitTarget->_CreateAuraApplication(_spellAura, 1 << effectInfo->EffectIndex);

 else

 aurApp->UpdateApplyEffectMask(aurApp->GetEffectsToApply() | 1 << effectInfo->EffectIndex, false);

}


void Spell::EffectUnlearnSpecialization()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 Player* player = unitTarget->ToPlayer();

 uint32 spellToUnlearn = effectInfo->TriggerSpell;


 player->RemoveSpell(spellToUnlearn);


 TC_LOG_DEBUG("spells", "Spell: Player {} has unlearned spell {} from Npc {}", player->GetGUID().ToString(), spellToUnlearn, m_caster->GetGUID().ToString());

}


void Spell::EffectPowerDrain()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (effectInfo->MiscValue < 0 || effectInfo->MiscValue >= int8(MAX_POWERS))

 return;


 Powers powerType = Powers(effectInfo->MiscValue);

 if (!unitTarget || !unitTarget->IsAlive() || unitTarget->GetPowerType() != powerType || damage < 0)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 // add spell damage bonus

 if (unitCaster)

 {

 uint32 bonus = unitCaster->SpellDamageBonusDone(unitTarget, m_spellInfo, uint32(damage), SPELL_DIRECT_DAMAGE, *effectInfo, 1, this);

 damage = bonus + uint32(bonus * variance);

 damage = unitTarget->SpellDamageBonusTaken(unitCaster, m_spellInfo, uint32(damage), SPELL_DIRECT_DAMAGE);

 }


 int32 newDamage = -(unitTarget->ModifyPower(powerType, -damage));


 // Don't restore from self drain

 float gainMultiplier = 0.f;

 if (unitCaster && unitCaster != unitTarget)

 {

 gainMultiplier = effectInfo->CalcValueMultiplier(unitCaster, this);

 int32 const gain = int32(newDamage * gainMultiplier);


 unitCaster->EnergizeBySpell(unitCaster, m_spellInfo, gain, powerType);

 }

 ExecuteLogEffectTakeTargetPower(SpellEffectName(effectInfo->Effect), unitTarget, powerType, newDamage, gainMultiplier);

}


void Spell::EffectSendEvent()

{

 // we do not handle a flag dropping or clicking on flag in battleground by sendevent system

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET

 && effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 WorldObject* target = nullptr;


 // call events for object target if present

 if (effectHandleMode == SPELL_EFFECT_HANDLE_HIT_TARGET)

 {

 if (unitTarget)

 target = unitTarget;

 else if (gameObjTarget)

 target = gameObjTarget;

 else if (m_corpseTarget)

 target = m_corpseTarget;

 }

 else // if (effectHandleMode == SPELL_EFFECT_HANDLE_HIT)

 {

 // let's prevent executing effect handler twice in case when spell effect is capable of targeting an object

 // this check was requested by scripters, but it has some downsides:

 // now it's impossible to script (using sEventScripts) a cast which misses all targets

 // or to have an ability to script the moment spell hits dest (in a case when there are object targets present)

 if (effectInfo->GetProvidedTargetMask() & (TARGET_FLAG_UNIT_MASK | TARGET_FLAG_GAMEOBJECT_MASK))

 return;

 // some spells have no target entries in dbc and they use focus target

 if (focusObject)

 target = focusObject;

 }


 TC_LOG_DEBUG("spells", "Spell ScriptStart {} for spellid {} in EffectSendEvent ", effectInfo->MiscValue, m_spellInfo->Id);


 GameEvents::Trigger(effectInfo->MiscValue, m_caster, target);

}


void Spell::EffectPowerBurn()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (effectInfo->MiscValue < 0 || effectInfo->MiscValue >= int8(MAX_POWERS))

 return;


 Powers powerType = Powers(effectInfo->MiscValue);

 if (!unitTarget || !unitTarget->IsAlive() || unitTarget->GetPowerType() != powerType || damage < 0)

 return;


 int32 newDamage = -(unitTarget->ModifyPower(powerType, -damage));


 // NO - Not a typo - EffectPowerBurn uses effect value multiplier - not effect damage multiplier

 float dmgMultiplier = effectInfo->CalcValueMultiplier(GetUnitCasterForEffectHandlers(), this);


 // add log data before multiplication (need power amount, not damage)

 ExecuteLogEffectTakeTargetPower(SpellEffectName(effectInfo->Effect), unitTarget, powerType, newDamage, 0.0f);


 newDamage = int32(newDamage * dmgMultiplier);


 m_damage += newDamage;

}


void Spell::EffectHeal()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)

 return;


 if (!unitTarget || !unitTarget->IsAlive() || damage < 0)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();


 // Skip if m_originalCaster not available

 if (!unitCaster)

 return;


 int32 addhealth = damage;


 // Vessel of the Naaru (Vial of the Sunwell trinket)

 if (m_spellInfo->Id == 45064)

 {

 // Amount of heal - depends from stacked Holy Energy

 int32 damageAmount = 0;

 if (AuraEffect const* aurEff = unitCaster->GetAuraEffect(45062, 0))

 {

 damageAmount += aurEff->GetAmount();

 unitCaster->RemoveAurasDueToSpell(45062);

 }


 addhealth += damageAmount;

 }

 // Death Pact - return pct of max health to caster

 else if (m_spellInfo->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT && m_spellInfo->SpellFamilyFlags[0] & 0x00080000)

 addhealth = unitCaster->SpellHealingBonusDone(unitTarget, m_spellInfo, int32(unitCaster->CountPctFromMaxHealth(damage)), HEAL, *effectInfo, 1, this);

 else

 {

 uint32 bonus = unitCaster->SpellHealingBonusDone(unitTarget, m_spellInfo, addhealth, HEAL, *effectInfo, 1, this);

 addhealth = bonus + uint32(bonus * variance);

 }


 addhealth = unitTarget->SpellHealingBonusTaken(unitCaster, m_spellInfo, addhealth, HEAL);


 // Remove Grievious bite if fully healed

 if (unitTarget->HasAura(48920) && (unitTarget->GetHealth() + addhealth >= unitTarget->GetMaxHealth()))

 unitTarget->RemoveAura(48920);


 m_healing += addhealth;

}


void Spell::EffectHealPct()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || !unitTarget->IsAlive() || damage < 0)

 return;


 uint32 heal = unitTarget->CountPctFromMaxHealth(damage);

 if (Unit* unitCaster = GetUnitCasterForEffectHandlers())

 {

 heal = unitCaster->SpellHealingBonusDone(unitTarget, m_spellInfo, heal, HEAL, *effectInfo, 1, this);

 heal = unitTarget->SpellHealingBonusTaken(unitCaster, m_spellInfo, heal, HEAL);

 }


 m_healing += heal;

}


void Spell::EffectHealMechanical()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || !unitTarget->IsAlive() || damage < 0)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 uint32 heal = damage;

 if (unitCaster)

 heal = unitCaster->SpellHealingBonusDone(unitTarget, m_spellInfo, heal, HEAL, *effectInfo, 1, this);


 heal += uint32(heal * variance);

 if (unitCaster)

 heal = unitTarget->SpellHealingBonusTaken(unitCaster, m_spellInfo, heal, HEAL);


 m_healing += heal;

}


void Spell::EffectHealthLeech()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || !unitTarget->IsAlive() || damage < 0)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 uint32 bonus = 0;

 if (unitCaster)

 bonus = unitCaster->SpellDamageBonusDone(unitTarget, m_spellInfo, uint32(damage), SPELL_DIRECT_DAMAGE, *effectInfo, 1, this);


 damage = bonus + uint32(bonus * variance);


 if (unitCaster)

 damage = unitTarget->SpellDamageBonusTaken(unitCaster, m_spellInfo, uint32(damage), SPELL_DIRECT_DAMAGE);


 TC_LOG_DEBUG("spells", "HealthLeech :{}", damage);


 float healMultiplier = effectInfo->CalcValueMultiplier(unitCaster, this);


 m_damage += damage;


 DamageInfo damageInfo(unitCaster, unitTarget, damage, m_spellInfo, m_spellInfo->GetSchoolMask(), SPELL_DIRECT_DAMAGE, BASE_ATTACK);

 Unit::CalcAbsorbResist(damageInfo);

 uint32 const absorb = damageInfo.GetAbsorb();

 damage -= absorb;


 // get max possible damage, don't count overkill for heal

 uint32 healthGain = uint32(-unitTarget->GetHealthGain(-damage) * healMultiplier);


 if (unitCaster && unitCaster->IsAlive())

 {

 healthGain = unitCaster->SpellHealingBonusDone(unitCaster, m_spellInfo, healthGain, HEAL, *effectInfo, 1, this);

 healthGain = unitCaster->SpellHealingBonusTaken(unitCaster, m_spellInfo, healthGain, HEAL);


 HealInfo healInfo(unitCaster, unitCaster, healthGain, m_spellInfo, m_spellSchoolMask);

 unitCaster->HealBySpell(healInfo);

 }

}


void Spell::DoCreateItem(uint32 itemId, ItemContext context /*= ItemContext::NONE*/, std::vector<int32> const* bonusListIDs /*= nullptr*/)

{

 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 Player* player = unitTarget->ToPlayer();


 uint32 newitemid = itemId;

 ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(newitemid);

 if (!pProto)

 {

 player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, nullptr, nullptr);

 return;

 }


 uint32 num_to_add = damage;


 if (num_to_add < 1)

 num_to_add = 1;

 if (num_to_add > pProto->GetMaxStackSize())

 num_to_add = pProto->GetMaxStackSize();


 /* == gem perfection handling == */

 // this is bad, should be done using spell_loot_template (and conditions)


 // the chance of getting a perfect result

 float perfectCreateChance = 0.0f;

 // the resulting perfect item if successful

 uint32 perfectItemType = itemId;

 // get perfection capability and chance

 if (CanCreatePerfectItem(player, m_spellInfo->Id, perfectCreateChance, perfectItemType))

 if (roll_chance_f(perfectCreateChance)) // if the roll succeeds...

 newitemid = perfectItemType; // the perfect item replaces the regular one


 /* == gem perfection handling over == */


 /* == profession specialization handling == */


 // init items_count to 1, since 1 item will be created regardless of specialization

 int items_count=1;

 // the chance to create additional items

 float additionalCreateChance=0.0f;

 // the maximum number of created additional items

 uint8 additionalMaxNum=0;

 // get the chance and maximum number for creating extra items

 if (CanCreateExtraItems(player, m_spellInfo->Id, additionalCreateChance, additionalMaxNum))

 // roll with this chance till we roll not to create or we create the max num

 while (roll_chance_f(additionalCreateChance) && items_count <= additionalMaxNum)

 ++items_count;


 // really will be created more items

 num_to_add *= items_count;


 /* == profession specialization handling over == */


 // can the player store the new item?

 ItemPosCountVec dest;

 uint32 no_space = 0;

 InventoryResult msg = player->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, newitemid, num_to_add, &no_space);

 if (msg != EQUIP_ERR_OK)

 {

 // convert to possible store amount

 if (msg == EQUIP_ERR_INV_FULL || msg == EQUIP_ERR_ITEM_MAX_COUNT)

 num_to_add -= no_space;

 else

 {

 // if not created by another reason from full inventory or unique items amount limitation

 player->SendEquipError(msg, nullptr, nullptr, newitemid);

 return;

 }

 }


 if (num_to_add)

 {

 // create the new item and store it

 if (Item* pItem = player->StoreNewItem(dest, newitemid, true, GenerateItemRandomBonusListId(newitemid), GuidSet(), context, bonusListIDs))

 {

 // set the "Crafted by ..." property of the item

 if (pItem->GetTemplate()->HasSignature())

 pItem->SetCreator(player->GetGUID());


 // send info to the client

 player->SendNewItem(pItem, num_to_add, true, true);


 if (pItem->GetQuality() > ITEM_QUALITY_EPIC || (pItem->GetQuality() == ITEM_QUALITY_EPIC && pItem->GetItemLevel(player) >= MinNewsItemLevel))

 if (Guild* guild = player->GetGuild())

 guild->AddGuildNews(GUILD_NEWS_ITEM_CRAFTED, player->GetGUID(), 0, pProto->GetId());

 }


 // we succeeded in creating at least one item, so a levelup is possible

 player->UpdateCraftSkill(m_spellInfo);

 }

}


void Spell::EffectCreateItem()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 DoCreateItem(effectInfo->ItemType, m_spellInfo->HasAttribute(SPELL_ATTR0_IS_TRADESKILL) ? ItemContext::Trade_Skill : ItemContext::NONE);

 ExecuteLogEffectCreateItem(SpellEffectName(effectInfo->Effect), effectInfo->ItemType);

}


void Spell::EffectCreateItem2()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 Player* player = unitTarget->ToPlayer();


 ItemContext context = m_spellInfo->HasAttribute(SPELL_ATTR0_IS_TRADESKILL) ? ItemContext::Trade_Skill : ItemContext::NONE;


 // Pick a random item from spell_loot_template

 if (m_spellInfo->IsLootCrafting())

 {

 player->AutoStoreLoot(m_spellInfo->Id, LootTemplates_Spell, context, false, true);

 player->UpdateCraftSkill(m_spellInfo);

 }

 else // If there's no random loot entries for this spell, pick the item associated with this spell

 {

 uint32 item_id = effectInfo->ItemType;


 if (item_id)

 DoCreateItem(item_id, context);

 }


}


void Spell::EffectCreateRandomItem()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;

 Player* player = unitTarget->ToPlayer();


 // create some random items

 player->AutoStoreLoot(m_spellInfo->Id, LootTemplates_Spell, m_spellInfo->HasAttribute(SPELL_ATTR0_IS_TRADESKILL) ? ItemContext::Trade_Skill : ItemContext::NONE);

}


void Spell::EffectPersistentAA()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 // only handle at last effect

 for (size_t i = effectInfo->EffectIndex + 1; i < m_spellInfo->GetEffects().size(); ++i)

 if (m_spellInfo->GetEffect(SpellEffIndex(i)).IsEffect(SPELL_EFFECT_PERSISTENT_AREA_AURA))

 return;


 ASSERT(!_dynObjAura);


 float radius = effectInfo->CalcRadius(unitCaster);


 // Caster not in world, might be spell triggered from aura removal

 if (!unitCaster->IsInWorld())

 return;


 DynamicObject* dynObj = new DynamicObject(false);

 if (!dynObj->CreateDynamicObject(unitCaster->GetMap()->GenerateLowGuid<HighGuid::DynamicObject>(), unitCaster, m_spellInfo, *destTarget, radius, DYNAMIC_OBJECT_AREA_SPELL, m_SpellVisual))

 {

 delete dynObj;

 return;

 }


 AuraCreateInfo createInfo(m_castId, m_spellInfo, GetCastDifficulty(), MAX_EFFECT_MASK, dynObj);

 createInfo

 .SetCaster(unitCaster)

 .SetBaseAmount(m_spellValue->EffectBasePoints)

 .SetCastItem(m_castItemGUID, m_castItemEntry, m_castItemLevel);


 if (Aura* aura = Aura::TryCreate(createInfo))

 {

 _dynObjAura = aura->ToDynObjAura();

 _dynObjAura->_RegisterForTargets();

 }

 else

 return;


 ASSERT(_dynObjAura->GetDynobjOwner());

 _dynObjAura->_ApplyEffectForTargets(effectInfo->EffectIndex);

}


void Spell::EffectEnergize()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster || !unitTarget)

 return;


 if (!unitTarget->IsAlive())

 return;


 if (effectInfo->MiscValue < 0 || effectInfo->MiscValue >= int8(MAX_POWERS))

 return;


 Powers power = Powers(effectInfo->MiscValue);

 if (unitTarget->GetMaxPower(power) == 0)

 return;


 // Some level depends spells

 switch (m_spellInfo->Id)

 {

 case 24571: // Blood Fury

 // Instantly increases your rage by ${(300-10*$max(0,$PL-60))/10}.

 damage -= 10 * std::max(0, std::min(30, unitCaster->GetLevel() - 60));

 break;

 case 24532: // Burst of Energy

 // Instantly increases your energy by ${60-4*$max(0,$min(15,$PL-60))}.

 damage -= 4 * std::max(0, std::min(15, unitCaster->GetLevel() - 60));

 break;

 case 67490: // Runic Mana Injector (mana gain increased by 25% for engineers - 3.2.0 patch change)

 {

 if (Player* player = unitCaster->ToPlayer())

 if (player->HasSkill(SKILL_ENGINEERING))

 AddPct(damage, 25);

 break;

 }

 default:

 break;

 }


 unitCaster->EnergizeBySpell(unitTarget, m_spellInfo, damage, power);

}


void Spell::EffectEnergizePct()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster || !unitTarget)

 return;


 if (!unitTarget->IsAlive())

 return;


 if (effectInfo->MiscValue < 0 || effectInfo->MiscValue >= int8(MAX_POWERS))

 return;


 Powers power = Powers(effectInfo->MiscValue);

 uint32 maxPower = unitTarget->GetMaxPower(power);

 if (!maxPower)

 return;


 uint32 const gain = CalculatePct(maxPower, damage);

 unitCaster->EnergizeBySpell(unitTarget, m_spellInfo, gain, power);

}


void Spell::EffectOpenLock()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (m_caster->GetTypeId() != TYPEID_PLAYER)

 {

 TC_LOG_DEBUG("spells", "WORLD: Open Lock - No Player Caster!");

 return;

 }


 Player* player = m_caster->ToPlayer();


 uint32 lockId = 0;

 ObjectGuid guid;


 // Get lockId

 if (gameObjTarget)

 {

 GameObjectTemplate const* goInfo = gameObjTarget->GetGOInfo();


 if (goInfo->GetNoDamageImmune() && player->HasUnitFlag(UNIT_FLAG_IMMUNE))

 return;


 if (goInfo->type == GAMEOBJECT_TYPE_FLAGSTAND)

 {

 //CanUseBattlegroundObject() already called in CheckCast()

 // in battleground check

 if (Battleground* bg = player->GetBattleground())

 {

 if (bg->GetTypeID() == BATTLEGROUND_EY)

 bg->EventPlayerClickedOnFlag(player, gameObjTarget);

 return;

 }

 }

 else if (m_spellInfo->Id == 1842 && gameObjTarget->GetGOInfo()->type == GAMEOBJECT_TYPE_TRAP && gameObjTarget->GetOwner())

 {

 gameObjTarget->SetLootState(GO_JUST_DEACTIVATED);

 return;

 }

 // handle outdoor pvp object opening, return true if go was registered for handling

 // these objects must have been spawned by outdoorpvp!

 else if (gameObjTarget->GetGOInfo()->type == GAMEOBJECT_TYPE_GOOBER && sOutdoorPvPMgr->HandleOpenGo(player, gameObjTarget))

 return;

 lockId = goInfo->GetLockId();

 guid = gameObjTarget->GetGUID();

 }

 else if (itemTarget)

 {

 lockId = itemTarget->GetTemplate()->GetLockID();

 guid = itemTarget->GetGUID();

 }

 else

 {

 TC_LOG_DEBUG("spells", "WORLD: Open Lock - No GameObject/Item Target!");

 return;

 }


 SkillType skillId = SKILL_NONE;

 int32 reqSkillValue = 0;

 int32 skillValue;


 SpellCastResult res = CanOpenLock(*effectInfo, lockId, skillId, reqSkillValue, skillValue);

 if (res != SPELL_CAST_OK)

 {

 SendCastResult(res);

 return;

 }


 if (gameObjTarget)

 gameObjTarget->Use(player);

 else if (itemTarget)

 {

 itemTarget->SetItemFlag(ITEM_FIELD_FLAG_UNLOCKED);

 itemTarget->SetState(ITEM_CHANGED, itemTarget->GetOwner());

 }


 // not allow use skill grow at item base open

 if (!m_CastItem && skillId != SKILL_NONE)

 {

 // update skill if really known

 if (uint32 pureSkillValue = player->GetPureSkillValue(skillId))

 {

 if (gameObjTarget)

 {

 // Allow one skill-up until respawned

 if (!gameObjTarget->IsInSkillupList(player->GetGUID()))

 {

 player->UpdateGatherSkill(skillId, pureSkillValue, reqSkillValue, 1, gameObjTarget);

 gameObjTarget->AddToSkillupList(player->GetGUID());

 }

 }

 else if (itemTarget)

 {

 // Do one skill-up

 player->UpdateGatherSkill(skillId, pureSkillValue, reqSkillValue);

 }

 }

 }

 ExecuteLogEffectOpenLock(SpellEffectName(effectInfo->Effect), gameObjTarget ? (Object*)gameObjTarget : (Object*)itemTarget);

}


void Spell::EffectSummonChangeItem()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 if (m_caster->GetTypeId() != TYPEID_PLAYER)

 return;


 Player* player = m_caster->ToPlayer();


 // applied only to using item

 if (!m_CastItem)

 return;


 // ... only to item in own inventory/bank/equip_slot

 if (m_CastItem->GetOwnerGUID() != player->GetGUID())

 return;


 uint32 newitemid = effectInfo->ItemType;

 if (!newitemid)

 return;


 uint16 pos = m_CastItem->GetPos();


 Item* pNewItem = Item::CreateItem(newitemid, 1, m_CastItem->GetContext(), player);

 if (!pNewItem)

 return;


 for (uint8 j = PERM_ENCHANTMENT_SLOT; j <= TEMP_ENCHANTMENT_SLOT; ++j)

 if (m_CastItem->GetEnchantmentId(EnchantmentSlot(j)))

 pNewItem->SetEnchantment(EnchantmentSlot(j), m_CastItem->GetEnchantmentId(EnchantmentSlot(j)), m_CastItem->GetEnchantmentDuration(EnchantmentSlot(j)), m_CastItem->GetEnchantmentCharges(EnchantmentSlot(j)));


 if (*m_CastItem->m_itemData->Durability < *m_CastItem->m_itemData->MaxDurability)

 {

 double lossPercent = 1 - *m_CastItem->m_itemData->Durability / double(m_CastItem->m_itemData->MaxDurability);

 player->DurabilityLoss(pNewItem, lossPercent);

 }


 if (player->IsInventoryPos(pos))

 {

 ItemPosCountVec dest;

 InventoryResult msg = player->CanStoreItem(m_CastItem->GetBagSlot(), m_CastItem->GetSlot(), dest, pNewItem, true);

 if (msg == EQUIP_ERR_OK)

 {

 player->DestroyItem(m_CastItem->GetBagSlot(), m_CastItem->GetSlot(), true);


 // prevent crash at access and unexpected charges counting with item update queue corrupt

 if (m_CastItem == m_targets.GetItemTarget())

 m_targets.SetItemTarget(nullptr);


 m_CastItem = nullptr;

 m_castItemGUID.Clear();

 m_castItemEntry = 0;

 m_castItemLevel = -1;


 player->StoreItem(dest, pNewItem, true);

 player->SendNewItem(pNewItem, 1, true, false);

 player->ItemAddedQuestCheck(newitemid, 1);

 return;

 }

 }

 else if (player->IsBankPos(pos))

 {

 ItemPosCountVec dest;

 if (player->CanBankItem(m_CastItem->GetBagSlot(), m_CastItem->GetSlot(), dest, pNewItem, true) == EQUIP_ERR_OK)

 {

 player->DestroyItem(m_CastItem->GetBagSlot(), m_CastItem->GetSlot(), true);


 // prevent crash at access and unexpected charges counting with item update queue corrupt

 if (m_CastItem == m_targets.GetItemTarget())

 m_targets.SetItemTarget(nullptr);


 m_CastItem = nullptr;

 m_castItemGUID.Clear();

 m_castItemEntry = 0;

 m_castItemLevel = -1;


 player->BankItem(dest, pNewItem, true);

 return;

 }

 }

 else if (player->IsEquipmentPos(pos))

 {

 uint16 dest;


 player->DestroyItem(m_CastItem->GetBagSlot(), m_CastItem->GetSlot(), true);


 InventoryResult msg = player->CanEquipItem(m_CastItem->GetSlot(), dest, pNewItem, true);


 if (msg == EQUIP_ERR_OK || msg == EQUIP_ERR_CLIENT_LOCKED_OUT)

 {

 if (msg == EQUIP_ERR_CLIENT_LOCKED_OUT) dest = EQUIPMENT_SLOT_MAINHAND;


 // prevent crash at access and unexpected charges counting with item update queue corrupt

 if (m_CastItem == m_targets.GetItemTarget())

 m_targets.SetItemTarget(nullptr);


 m_CastItem = nullptr;

 m_castItemGUID.Clear();

 m_castItemEntry = 0;

 m_castItemLevel = -1;


 player->EquipItem(dest, pNewItem, true);

 player->AutoUnequipOffhandIfNeed();

 player->SendNewItem(pNewItem, 1, true, false);

 player->ItemAddedQuestCheck(newitemid, 1);

 return;

 }

 }


 // fail

 delete pNewItem;

}


void Spell::EffectProficiency()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 if (m_caster->GetTypeId() != TYPEID_PLAYER)

 return;

 Player* p_target = m_caster->ToPlayer();


 uint32 subClassMask = m_spellInfo->EquippedItemSubClassMask;

 if (m_spellInfo->EquippedItemClass == ITEM_CLASS_WEAPON && !(p_target->GetWeaponProficiency() & subClassMask))

 {

 p_target->AddWeaponProficiency(subClassMask);

 p_target->SendProficiency(ITEM_CLASS_WEAPON, p_target->GetWeaponProficiency());

 }

 if (m_spellInfo->EquippedItemClass == ITEM_CLASS_ARMOR && !(p_target->GetArmorProficiency() & subClassMask))

 {

 p_target->AddArmorProficiency(subClassMask);

 p_target->SendProficiency(ITEM_CLASS_ARMOR, p_target->GetArmorProficiency());

 }

}


void Spell::EffectSummonType()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)

 return;


 uint32 entry = effectInfo->MiscValue;

 if (!entry)

 return;


 SummonPropertiesEntry const* properties = sSummonPropertiesStore.LookupEntry(effectInfo->MiscValueB);

 if (!properties)

 {

 TC_LOG_ERROR("spells", "EffectSummonType: Unhandled summon type {}.", effectInfo->MiscValueB);

 return;

 }


 WorldObject* caster = m_caster;

 if (m_originalCaster)

 caster = m_originalCaster;


 ObjectGuid privateObjectOwner = [&]()

 {

 if (!(properties->GetFlags().HasFlag(SummonPropertiesFlags::OnlyVisibleToSummoner | SummonPropertiesFlags::OnlyVisibleToSummonerGroup)))

 return ObjectGuid::Empty;


 if (caster->IsPrivateObject())

 return caster->GetPrivateObjectOwner();


 if (properties->GetFlags().HasFlag(SummonPropertiesFlags::OnlyVisibleToSummonerGroup))

 if (caster->IsPlayer() && m_originalCaster->ToPlayer()->GetGroup())

 return caster->ToPlayer()->GetGroup()->GetGUID();


 return caster->GetGUID();

 }();


 Milliseconds duration = Milliseconds(m_spellInfo->CalcDuration(caster));


 Unit* unitCaster = GetUnitCasterForEffectHandlers();


 TempSummon* summon = nullptr;


 // determine how many units should be summoned

 uint32 numSummons;


 // some spells need to summon many units, for those spells number of summons is stored in effect value

 // however so far noone found a generic check to find all of those (there's no related data in summonproperties.dbc

 // and in spell attributes, possibly we need to add a table for those)

 // so here's a list of MiscValueB values, which is currently most generic check

 switch (effectInfo->MiscValueB)

 {

 case 64:

 case 61:

 case 1101:

 case 66:

 case 648:

 case 2301:

 case 1061:

 case 1261:

 case 629:

 case 181:

 case 715:

 case 1562:

 case 833:

 case 1161:

 case 713:

 numSummons = (damage > 0) ? damage : 1;

 break;

 default:

 numSummons = 1;

 break;

 }


 switch (properties->Control)

 {

 case SUMMON_CATEGORY_WILD:

 case SUMMON_CATEGORY_ALLY:

 case SUMMON_CATEGORY_UNK:

 {

 if (properties->GetFlags().HasFlag(SummonPropertiesFlags::JoinSummonerSpawnGroup))

 {

 SummonGuardian(effectInfo, entry, properties, numSummons, privateObjectOwner);

 break;

 }


 switch (SummonTitle(properties->Title))

 {

 case SummonTitle::Pet:

 case SummonTitle::Guardian:

 case SummonTitle::Runeblade:

 case SummonTitle::Minion:

 SummonGuardian(effectInfo, entry, properties, numSummons, privateObjectOwner);

 break;

 // Summons a vehicle, but doesn't force anyone to enter it (see SUMMON_CATEGORY_VEHICLE)

 case SummonTitle::Vehicle:

 case SummonTitle::Mount:

 {

 if (!unitCaster)

 return;


 summon = unitCaster->GetMap()->SummonCreature(entry, *destTarget, properties, duration, unitCaster, m_spellInfo->Id);

 break;

 }

 case SummonTitle::Lightwell:

 case SummonTitle::Totem:

 {

 if (!unitCaster)

 return;


 summon = unitCaster->GetMap()->SummonCreature(entry, *destTarget, properties, duration, unitCaster, m_spellInfo->Id, 0, privateObjectOwner);

 if (!summon || !summon->IsTotem())

 return;


 if (damage) // if not spell info, DB values used

 {

 summon->SetMaxHealth(damage);

 summon->SetHealth(damage);

 }

 break;

 }

 case SummonTitle::Companion:

 {

 if (!unitCaster)

 return;


 summon = unitCaster->GetMap()->SummonCreature(entry, *destTarget, properties, duration, unitCaster, m_spellInfo->Id, 0, privateObjectOwner);

 if (!summon || !summon->HasUnitTypeMask(UNIT_MASK_MINION))

 return;


 summon->SetImmuneToAll(true);

 break;

 }

 default:

 {

 float radius = effectInfo->CalcRadius();


 TempSummonType summonType = TEMPSUMMON_TIMED_DESPAWN;

 if (duration == 0ms)

 summonType = TEMPSUMMON_DEAD_DESPAWN;

 else if (duration == -1ms)

 summonType = TEMPSUMMON_MANUAL_DESPAWN;


 for (uint32 count = 0; count < numSummons; ++count)

 {

 Position pos;

 if (count == 0)

 pos = *destTarget;

 else

 // randomize position for multiple summons

 pos = caster->GetRandomPoint(*destTarget, radius);


 summon = caster->GetMap()->SummonCreature(entry, pos, properties, duration, unitCaster, m_spellInfo->Id, 0, privateObjectOwner);

 if (!summon)

 continue;


 summon->SetTempSummonType(summonType);

 if (properties->Control == SUMMON_CATEGORY_ALLY)

 summon->SetOwnerGUID(caster->GetGUID());

 else if (properties->Control == SUMMON_CATEGORY_WILD && caster->IsPlayer()) // there might be more conditions involved

 summon->SetDemonCreatorGUID(caster->GetGUID());


 ExecuteLogEffectSummonObject(SpellEffectName(effectInfo->Effect), summon);

 }

 return;

 }

 }

 break;

 }

 case SUMMON_CATEGORY_PET:

 SummonGuardian(effectInfo, entry, properties, numSummons, privateObjectOwner);

 break;

 case SUMMON_CATEGORY_PUPPET:

 {

 if (!unitCaster)

 return;


 summon = unitCaster->GetMap()->SummonCreature(entry, *destTarget, properties, duration, unitCaster, m_spellInfo->Id, 0, privateObjectOwner);

 break;

 }

 case SUMMON_CATEGORY_VEHICLE:

 {

 if (!unitCaster)

 return;


 // Summoning spells (usually triggered by npc_spellclick) that spawn a vehicle and that cause the clicker

 // to cast a ride vehicle spell on the summoned unit.

 summon = unitCaster->GetMap()->SummonCreature(entry, *destTarget, properties, duration, unitCaster, m_spellInfo->Id);

 if (!summon || !summon->IsVehicle())

 return;


 // The spell that this effect will trigger. It has SPELL_AURA_CONTROL_VEHICLE

 uint32 spellId = VEHICLE_SPELL_RIDE_HARDCODED;

 int32 basePoints = effectInfo->CalcValue();

 if (basePoints > MAX_VEHICLE_SEATS)

 {

 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(basePoints, GetCastDifficulty());

 if (spellInfo && spellInfo->HasAura(SPELL_AURA_CONTROL_VEHICLE))

 spellId = spellInfo->Id;

 }


 CastSpellExtraArgs args(TRIGGERED_FULL_MASK);

 args.SetTriggeringSpell(this);


 // if we have small value, it indicates seat position

 if (basePoints > 0 && basePoints < MAX_VEHICLE_SEATS)

 args.AddSpellMod(SPELLVALUE_BASE_POINT0, basePoints);


 unitCaster->CastSpell(summon, spellId, args);

 break;

 }

 }


 if (summon)

 {

 summon->SetCreatorGUID(caster->GetGUID());

 ExecuteLogEffectSummonObject(SpellEffectName(effectInfo->Effect), summon);

 }

}


void Spell::EffectLearnSpell()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 if (unitTarget->GetTypeId() != TYPEID_PLAYER)

 {

 if (unitTarget->ToPet())

 EffectLearnPetSpell();

 return;

 }


 Player* player = unitTarget->ToPlayer();


 if (m_CastItem && !effectInfo->TriggerSpell)

 {

 for (ItemEffectEntry const* itemEffect : m_CastItem->GetEffects())

 {

 if (itemEffect->TriggerType != ITEM_SPELLTRIGGER_ON_LEARN)

 continue;


 bool dependent = false;


 if (BattlePetSpeciesEntry const* speciesEntry = BattlePets::BattlePetMgr::GetBattlePetSpeciesBySpell(uint32(itemEffect->SpellID)))

 {

 player->GetSession()->GetBattlePetMgr()->AddPet(speciesEntry->ID, BattlePets::BattlePetMgr::SelectPetDisplay(speciesEntry),

 BattlePets::BattlePetMgr::RollPetBreed(speciesEntry->ID), BattlePets::BattlePetMgr::GetDefaultPetQuality(speciesEntry->ID));

 // If the spell summons a battle pet, we fake that it has been learned and the battle pet is added

 // marking as dependent prevents saving the spell to database (intended)

 dependent = true;

 }


 player->LearnSpell(itemEffect->SpellID, dependent);

 }

 }


 if (effectInfo->TriggerSpell)

 {

 player->LearnSpell(effectInfo->TriggerSpell, false);

 TC_LOG_DEBUG("spells", "Spell: Player {} has learned spell {} from Npc {}", player->GetGUID().ToString(), effectInfo->TriggerSpell, m_caster->GetGUID().ToString());

 }

}


void Spell::EffectDispel()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 // Create dispel mask by dispel type

 uint32 dispel_type = effectInfo->MiscValue;

 uint32 dispelMask = SpellInfo::GetDispelMask(DispelType(dispel_type));


 DispelChargesList dispelList;

 unitTarget->GetDispellableAuraList(m_caster, dispelMask, dispelList, targetMissInfo == SPELL_MISS_REFLECT);

 if (dispelList.empty())

 return;


 size_t remaining = dispelList.size();


 // Ok if exist some buffs for dispel try dispel it

 DispelChargesList successList;

 successList.reserve(damage);


 WorldPackets::Spells::DispelFailed dispelFailed;

 dispelFailed.CasterGUID = m_caster->GetGUID();

 dispelFailed.VictimGUID = unitTarget->GetGUID();

 dispelFailed.SpellID = m_spellInfo->Id;


 // dispel N = damage buffs (or while exist buffs for dispel)

 for (int32 count = 0; count < damage && remaining > 0;)

 {

 // Random select buff for dispel

 auto itr = dispelList.begin();

 std::advance(itr, urand(0, remaining - 1));


 if (itr->RollDispel())

 {

 auto successItr = std::find_if(successList.begin(), successList.end(), [&itr](DispelableAura& dispelAura) -> bool

 {

 if (dispelAura.GetAura()->GetId() == itr->GetAura()->GetId() && dispelAura.GetAura()->GetCaster() == itr->GetAura()->GetCaster())

 return true;


 return false;

 });


 uint8 dispelledCharges = 1;

 if (itr->GetAura()->GetSpellInfo()->HasAttribute(SPELL_ATTR1_DISPEL_ALL_STACKS))

 dispelledCharges = itr->GetDispelCharges();


 if (successItr == successList.end())

 successList.emplace_back(itr->GetAura(), 0, dispelledCharges);

 else

 successItr->IncrementCharges();


 if (!itr->DecrementCharge(dispelledCharges))

 {

 --remaining;

 std::swap(*itr, dispelList[remaining]);

 }

 }

 else

 {

 dispelFailed.FailedSpells.push_back(int32(itr->GetAura()->GetId()));

 }

 ++count;

 }


 if (!dispelFailed.FailedSpells.empty())

 m_caster->SendMessageToSet(dispelFailed.Write(), true);


 if (successList.empty())

 return;


 WorldPackets::CombatLog::SpellDispellLog spellDispellLog;

 spellDispellLog.IsBreak = false; // TODO: use me

 spellDispellLog.IsSteal = false;


 spellDispellLog.TargetGUID = unitTarget->GetGUID();

 spellDispellLog.CasterGUID = m_caster->GetGUID();

 spellDispellLog.DispelledBySpellID = m_spellInfo->Id;


 for (DispelableAura const& dispelableAura : successList)

 {

 WorldPackets::CombatLog::SpellDispellData dispellData;

 dispellData.SpellID = dispelableAura.GetAura()->GetId();

 dispellData.Harmful = false; // TODO: use me


 unitTarget->RemoveAurasDueToSpellByDispel(dispelableAura.GetAura()->GetId(), m_spellInfo->Id, dispelableAura.GetAura()->GetCasterGUID(), m_caster, dispelableAura.GetDispelCharges());


 spellDispellLog.DispellData.emplace_back(dispellData);

 }


 m_caster->SendMessageToSet(spellDispellLog.Write(), true);


 CallScriptSuccessfulDispel(SpellEffIndex(effectInfo->EffectIndex));


 m_hitMask |= PROC_HIT_DISPEL;

}


void Spell::EffectDualWield()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 unitTarget->SetCanDualWield(true);

}


void Spell::EffectDistract()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 // Check for possible target

 if (!unitTarget || unitTarget->IsEngaged())

 return;


 // target must be OK to do this

 if (unitTarget->HasUnitState(UNIT_STATE_CONFUSED | UNIT_STATE_STUNNED | UNIT_STATE_FLEEING))

 return;


 unitTarget->GetMotionMaster()->MoveDistract(damage * IN_MILLISECONDS, unitTarget->GetAbsoluteAngle(destTarget));

}


void Spell::EffectPickPocket()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Player* player = m_caster->ToPlayer();

 if (m_caster->GetTypeId() != TYPEID_PLAYER)

 return;


 Creature* creature = Object::ToCreature(unitTarget);

 if (!creature)

 return;


 if (creature->CanGeneratePickPocketLoot())

 {

 creature->StartPickPocketRefillTimer();


 creature->m_loot.reset(new Loot(creature->GetMap(), creature->GetGUID(), LOOT_PICKPOCKETING, nullptr));

 if (uint32 lootid = creature->GetCreatureDifficulty()->PickPocketLootID)

 creature->m_loot->FillLoot(lootid, LootTemplates_Pickpocketing, player, true);


 // Generate extra money for pick pocket loot

 const uint32 a = urand(0, creature->GetLevel() / 2);

 const uint32 b = urand(0, player->GetLevel() / 2);

 creature->m_loot->gold = uint32(10 * (a + b) * sWorld->getRate(RATE_DROP_MONEY));

 }

 else if (creature->m_loot)

 {

 if (creature->m_loot->loot_type == LOOT_PICKPOCKETING && creature->m_loot->isLooted())

 player->SendLootError(creature->m_loot->GetGUID(), creature->GetGUID(), LOOT_ERROR_ALREADY_PICKPOCKETED);


 return;

 }


 player->SendLoot(*creature->m_loot);

}


void Spell::EffectAddFarsight()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 Player* player = m_caster->ToPlayer();

 if (!player)

 return;


 float radius = effectInfo->CalcRadius();

 int32 duration = m_spellInfo->CalcDuration(m_caster);

 // Caster not in world, might be spell triggered from aura removal

 if (!player->IsInWorld())

 return;


 DynamicObject* dynObj = new DynamicObject(true);

 if (!dynObj->CreateDynamicObject(player->GetMap()->GenerateLowGuid<HighGuid::DynamicObject>(), player, m_spellInfo, *destTarget, radius, DYNAMIC_OBJECT_FARSIGHT_FOCUS, m_SpellVisual))

 {

 delete dynObj;

 return;

 }


 dynObj->SetDuration(duration);

 dynObj->SetCasterViewpoint();

}


void Spell::EffectUntrainTalents()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || m_caster->GetTypeId() == TYPEID_PLAYER)

 return;


 unitTarget->ToPlayer()->SendRespecWipeConfirm(m_caster->GetGUID(), sWorld->getBoolConfig(CONFIG_NO_RESET_TALENT_COST) ? 0 : unitTarget->ToPlayer()->GetNextResetTalentsCost(), SPEC_RESET_TALENTS);

}


void Spell::EffectTeleUnitsFaceCaster()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 if (unitTarget->IsInFlight())

 return;


 if (m_targets.HasDst())

 unitTarget->NearTeleportTo(destTarget->GetPositionX(), destTarget->GetPositionY(), destTarget->GetPositionZ(), destTarget->GetAbsoluteAngle(m_caster), unitTarget == m_caster);

}


void Spell::EffectLearnSkill()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Player* playerTarget = Object::ToPlayer(unitTarget);

 if (!playerTarget)

 return;


 if (damage < 1)

 return;


 uint32 skillid = effectInfo->MiscValue;

 SkillRaceClassInfoEntry const* rcEntry = sDB2Manager.GetSkillRaceClassInfo(skillid, playerTarget->GetRace(), playerTarget->GetClass());

 if (!rcEntry)

 return;


 SkillTiersEntry const* tier = sObjectMgr->GetSkillTier(rcEntry->SkillTierID);

 if (!tier)

 return;


 uint16 skillval = std::max<uint16>(1, playerTarget->GetPureSkillValue(skillid));

 uint16 maxSkillVal = tier->GetValueForTierIndex(damage - 1);


 if (rcEntry->Flags & SKILL_FLAG_ALWAYS_MAX_VALUE)

 skillval = maxSkillVal;


 playerTarget->SetSkill(skillid, damage, skillval, maxSkillVal);

}


void Spell::EffectPlayMovie()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 uint32 movieId = effectInfo->MiscValue;

 if (!sMovieStore.LookupEntry(movieId))

 return;


 unitTarget->ToPlayer()->SendMovieStart(movieId);

}


void Spell::EffectTradeSkill()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 if (m_caster->GetTypeId() != TYPEID_PLAYER)

 return;

 // uint32 skillid = m_spellInfo->Effects[i].MiscValue;

 // uint16 skillmax = unitTarget->ToPlayer()->(skillid);

 // m_caster->ToPlayer()->SetSkill(skillid, skillval?skillval:1, skillmax+75);

}


void Spell::EffectEnchantItemPerm()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!itemTarget)

 return;


 Player* player = m_caster->ToPlayer();

 if (!player)

 return;


 // Handle vellums

 if (itemTarget->IsVellum())

 {

 // destroy one vellum from stack

 uint32 count = 1;

 player->DestroyItemCount(itemTarget, count, true);

 unitTarget = player;

 // and add a scroll

 damage = 1;

 DoCreateItem(effectInfo->ItemType, m_spellInfo->HasAttribute(SPELL_ATTR0_IS_TRADESKILL) ? ItemContext::Trade_Skill : ItemContext::NONE);

 itemTarget = nullptr;

 m_targets.SetItemTarget(nullptr);

 }

 else

 {

 // do not increase skill if vellum used

 if (!(m_CastItem && m_CastItem->GetTemplate()->HasFlag(ITEM_FLAG_NO_REAGENT_COST)))

 player->UpdateCraftSkill(m_spellInfo);


 uint32 enchant_id = effectInfo->MiscValue;

 if (!enchant_id)

 return;


 SpellItemEnchantmentEntry const* pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);

 if (!pEnchant)

 return;


 // item can be in trade slot and have owner diff. from caster

 Player* item_owner = itemTarget->GetOwner();

 if (!item_owner)

 return;


 if (item_owner != player && player->GetSession()->HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))

 {

 sLog->OutCommand(player->GetSession()->GetAccountId(), "GM {} (Account: {}) enchanting(perm): {} (Entry: {}) for player: {} (Account: {})",

 player->GetName(), player->GetSession()->GetAccountId(),

 itemTarget->GetTemplate()->GetDefaultLocaleName(), itemTarget->GetEntry(),

 item_owner->GetName(), item_owner->GetSession()->GetAccountId());

 }


 // remove old enchanting before applying new if equipped

 item_owner->ApplyEnchantment(itemTarget, PERM_ENCHANTMENT_SLOT, false);


 itemTarget->SetEnchantment(PERM_ENCHANTMENT_SLOT, enchant_id, 0, 0, m_caster->GetGUID());


 // add new enchanting if equipped

 item_owner->ApplyEnchantment(itemTarget, PERM_ENCHANTMENT_SLOT, true);


 item_owner->RemoveTradeableItem(itemTarget);

 itemTarget->ClearSoulboundTradeable(item_owner);

 }

}


void Spell::EffectEnchantItemPrismatic()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!itemTarget)

 return;


 Player* player = m_caster->ToPlayer();

 if (!player)

 return;


 uint32 enchantId = effectInfo->MiscValue;

 if (!enchantId)

 return;


 SpellItemEnchantmentEntry const* enchant = sSpellItemEnchantmentStore.LookupEntry(enchantId);

 if (!enchant)

 return;


 // support only enchantings with add socket in this slot

 {

 bool add_socket = false;

 for (uint8 i = 0; i < MAX_ITEM_ENCHANTMENT_EFFECTS; ++i)

 {

 if (enchant->Effect[i] == ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET)

 {

 add_socket = true;

 break;

 }

 }

 if (!add_socket)

 {

 TC_LOG_ERROR("spells", "Spell::EffectEnchantItemPrismatic: attempt to apply the enchant spell {} with SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC ({}), but without ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET ({}), not supported yet.",

 m_spellInfo->Id, SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC, ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET);

 return;

 }

 }


 // item can be in trade slot and have owner diff. from caster

 Player* item_owner = itemTarget->GetOwner();

 if (!item_owner)

 return;


 if (item_owner != player && player->GetSession()->HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))

 {

 sLog->OutCommand(player->GetSession()->GetAccountId(), "GM {} (Account: {}) enchanting(perm): {} (Entry: {}) for player: {} (Account: {})",

 player->GetName(), player->GetSession()->GetAccountId(),

 itemTarget->GetTemplate()->GetDefaultLocaleName(), itemTarget->GetEntry(),

 item_owner->GetName(), item_owner->GetSession()->GetAccountId());

 }


 // remove old enchanting before applying new if equipped

 item_owner->ApplyEnchantment(itemTarget, PRISMATIC_ENCHANTMENT_SLOT, false);


 itemTarget->SetEnchantment(PRISMATIC_ENCHANTMENT_SLOT, enchantId, 0, 0, m_caster->GetGUID());


 // add new enchanting if equipped

 item_owner->ApplyEnchantment(itemTarget, PRISMATIC_ENCHANTMENT_SLOT, true);


 item_owner->RemoveTradeableItem(itemTarget);

 itemTarget->ClearSoulboundTradeable(item_owner);

}


void Spell::EffectEnchantItemTmp()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!itemTarget)

 return;


 Player* player = m_caster->ToPlayer();

 if (!player)

 return;


 uint32 enchant_id = effectInfo->MiscValue;


 if (!enchant_id)

 {

 TC_LOG_ERROR("spells", "Spell {} Effect {} (SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY) has enchanting id 0.", m_spellInfo->Id, effectInfo->EffectIndex);

 return;

 }


 SpellItemEnchantmentEntry const* pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);

 if (!pEnchant)

 {

 TC_LOG_ERROR("spells", "Spell {} Effect {} (SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY) has a non-existing enchanting id {} ", m_spellInfo->Id, effectInfo->EffectIndex, enchant_id);

 return;

 }


 // select enchantment duration

 uint32 duration = pEnchant->Duration;


 // item can be in trade slot and have owner diff. from caster

 Player* item_owner = itemTarget->GetOwner();

 if (!item_owner)

 return;


 if (item_owner != player && player->GetSession()->HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))

 {

 sLog->OutCommand(player->GetSession()->GetAccountId(), "GM {} (Account: {}) enchanting(temp): {} (Entry: {}) for player: {} (Account: {})",

 player->GetName(), player->GetSession()->GetAccountId(),

 itemTarget->GetTemplate()->GetDefaultLocaleName(), itemTarget->GetEntry(),

 item_owner->GetName(), item_owner->GetSession()->GetAccountId());

 }


 // remove old enchanting before applying new if equipped

 item_owner->ApplyEnchantment(itemTarget, TEMP_ENCHANTMENT_SLOT, false);


 itemTarget->SetEnchantment(TEMP_ENCHANTMENT_SLOT, enchant_id, duration * 1000, 0, m_caster->GetGUID());


 // add new enchanting if equipped

 item_owner->ApplyEnchantment(itemTarget, TEMP_ENCHANTMENT_SLOT, true);

}


void Spell::EffectTameCreature()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster || !unitCaster->GetPetGUID().IsEmpty())

 return;


 if (!unitTarget)

 return;


 if (unitTarget->GetTypeId() != TYPEID_UNIT)

 return;


 Creature* creatureTarget = unitTarget->ToCreature();


 if (creatureTarget->IsPet())

 return;


 if (unitCaster->GetClass() != CLASS_HUNTER)

 return;


 // cast finish successfully

 //SendChannelUpdate(0);

 finish();


 Pet* pet = unitCaster->CreateTamedPetFrom(creatureTarget, m_spellInfo->Id);

 if (!pet) // in very specific state like near world end/etc.

 return;


 // "kill" original creature

 creatureTarget->DespawnOrUnsummon();


 uint8 level = (creatureTarget->GetLevelForTarget(m_caster) < (m_caster->GetLevelForTarget(creatureTarget) - 5)) ? (m_caster->GetLevelForTarget(creatureTarget) - 5) : creatureTarget->GetLevelForTarget(m_caster);


 // prepare visual effect for levelup

 pet->SetLevel(level - 1);


 // add to world

 pet->GetMap()->AddToMap(pet->ToCreature());


 // visual effect for levelup

 pet->SetLevel(level);


 // caster have pet now

 unitCaster->SetMinion(pet, true);


 if (unitCaster->GetTypeId() == TYPEID_PLAYER)

 {

 pet->SavePetToDB(PET_SAVE_AS_CURRENT);

 unitCaster->ToPlayer()->PetSpellInitialize();

 }

}


void Spell::EffectSummonPet()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 Player* owner = nullptr;

 if (Unit* unitCaster = GetUnitCasterForEffectHandlers())

 {

 owner = unitCaster->ToPlayer();

 if (!owner && unitCaster->IsTotem())

 owner = unitCaster->GetCharmerOrOwnerPlayerOrPlayerItself();

 }


 uint32 petentry = effectInfo->MiscValue;


 if (!owner)

 {

 SummonPropertiesEntry const* properties = sSummonPropertiesStore.LookupEntry(67);

 if (properties)

 SummonGuardian(effectInfo, petentry, properties, 1, ObjectGuid::Empty);

 return;

 }


 Pet* OldSummon = owner->GetPet();


 // if pet requested type already exist

 if (OldSummon)

 {

 if (petentry == 0 || OldSummon->GetEntry() == petentry)

 {

 // pet in corpse state can't be summoned

 if (OldSummon->isDead())

 return;


 ASSERT(OldSummon->GetMap() == owner->GetMap());


 //OldSummon->GetMap()->Remove(OldSummon->ToCreature(), false);


 float px, py, pz;

 owner->GetClosePoint(px, py, pz, OldSummon->GetCombatReach());


 OldSummon->NearTeleportTo(px, py, pz, OldSummon->GetOrientation());

 //OldSummon->Relocate(px, py, pz, OldSummon->GetOrientation());

 //OldSummon->SetMap(owner->GetMap());

 //owner->GetMap()->Add(OldSummon->ToCreature());


 if (owner->GetTypeId() == TYPEID_PLAYER && OldSummon->isControlled())

 owner->ToPlayer()->PetSpellInitialize();


 return;

 }


 if (owner->GetTypeId() == TYPEID_PLAYER)

 owner->ToPlayer()->RemovePet(OldSummon, PET_SAVE_NOT_IN_SLOT, false);

 else

 return;

 }


 Optional<PetSaveMode> petSlot;

 if (!petentry)

 petSlot = PetSaveMode(damage);


 float x, y, z;

 owner->GetClosePoint(x, y, z, owner->GetCombatReach());

 bool isNew = false;

 Pet* pet = owner->SummonPet(petentry, petSlot, x, y, z, owner->GetOrientation(), 0, &isNew);

 if (!pet)

 return;


 if (isNew)

 {

 if (m_caster->GetTypeId() == TYPEID_UNIT)

 {

 if (m_caster->ToCreature()->IsTotem())

 pet->SetReactState(REACT_AGGRESSIVE);

 else

 pet->SetReactState(REACT_DEFENSIVE);

 }


 pet->SetCreatedBySpell(m_spellInfo->Id);


 // generate new name for summon pet

 std::string new_name = sObjectMgr->GeneratePetName(petentry);

 if (!new_name.empty())

 pet->SetName(new_name);

 }


 ExecuteLogEffectSummonObject(SpellEffectName(effectInfo->Effect), pet);

}


void Spell::EffectLearnPetSpell()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 if (unitTarget->ToPlayer())

 {

 EffectLearnSpell();

 return;

 }

 Pet* pet = unitTarget->ToPet();

 if (!pet)

 return;


 SpellInfo const* learn_spellproto = sSpellMgr->GetSpellInfo(effectInfo->TriggerSpell, DIFFICULTY_NONE);

 if (!learn_spellproto)

 return;


 pet->learnSpell(learn_spellproto->Id);

 pet->SavePetToDB(PET_SAVE_AS_CURRENT);

 pet->GetOwner()->PetSpellInitialize();

}


void Spell::EffectTaunt()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 // this effect use before aura Taunt apply for prevent taunt already attacking target

 // for spell as marked "non effective at already attacking target"

 if (!unitTarget || unitTarget->IsTotem())

 {

 SendCastResult(SPELL_FAILED_DONT_REPORT);

 return;

 }


 // Hand of Reckoning can hit some entities that can't have a threat list (including players' pets)

 if (m_spellInfo->Id == 62124)

 if (unitTarget->GetTypeId() != TYPEID_PLAYER && unitTarget->GetTarget() != unitCaster->GetGUID())

 unitCaster->CastSpell(unitTarget, 67485, true);


 if (!unitTarget->CanHaveThreatList())

 {

 SendCastResult(SPELL_FAILED_DONT_REPORT);

 return;

 }


 ThreatManager& mgr = unitTarget->GetThreatManager();

 if (mgr.GetCurrentVictim() == unitCaster)

 {

 SendCastResult(SPELL_FAILED_DONT_REPORT);

 return;

 }


 if (!mgr.IsThreatListEmpty())

 // Set threat equal to highest threat currently on target

 mgr.MatchUnitThreatToHighestThreat(unitCaster);

}


void Spell::EffectWeaponDmg()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 if (!unitTarget || !unitTarget->IsAlive())

 return;


 // multiple weapon dmg effect workaround

 // execute only the last weapon damage

 // and handle all effects at once

 for (size_t j = effectInfo->EffectIndex + 1; j < m_spellInfo->GetEffects().size(); ++j)

 {

 switch (m_spellInfo->GetEffect(SpellEffIndex(j)).Effect)

 {

 case SPELL_EFFECT_WEAPON_DAMAGE:

 case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:

 case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:

 case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:

 return; // we must calculate only at last weapon effect

 default:

 break;

 }

 }


 // some spell specific modifiers

 float totalDamagePercentMod = 1.0f; // applied to final bonus+weapon damage

 int32 fixed_bonus = 0;

 int32 spell_bonus = 0; // bonus specific for spell


 switch (m_spellInfo->SpellFamilyName)

 {

 case SPELLFAMILY_SHAMAN:

 {

 // Skyshatter Harness item set bonus

 // Stormstrike

 if (AuraEffect* aurEff = unitCaster->IsScriptOverriden(m_spellInfo, 5634))

 unitCaster->CastSpell(nullptr, 38430, aurEff);

 break;

 }

 }


 bool normalized = false;

 float weaponDamagePercentMod = 1.0f;

 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())

 {

 switch (spellEffectInfo.Effect)

 {

 case SPELL_EFFECT_WEAPON_DAMAGE:

 case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:

 fixed_bonus += CalculateDamage(spellEffectInfo, unitTarget);

 break;

 case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:

 fixed_bonus += CalculateDamage(spellEffectInfo, unitTarget);

 normalized = true;

 break;

 case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:

 ApplyPct(weaponDamagePercentMod, CalculateDamage(spellEffectInfo, unitTarget));

 break;

 default:

 break; // not weapon damage effect, just skip

 }

 }


 // if (addPctMods) { percent mods are added in Unit::CalculateDamage } else { percent mods are added in Unit::MeleeDamageBonusDone }

 // this distinction is neccessary to properly inform the client about his autoattack damage values from Script_UnitDamage

 bool const addPctMods = !m_spellInfo->HasAttribute(SPELL_ATTR6_IGNORE_CASTER_DAMAGE_MODIFIERS) && (m_spellSchoolMask & SPELL_SCHOOL_MASK_NORMAL);

 if (addPctMods)

 {

 UnitMods unitMod;

 switch (m_attackType)

 {

 default:

 case BASE_ATTACK: unitMod = UNIT_MOD_DAMAGE_MAINHAND; break;

 case OFF_ATTACK: unitMod = UNIT_MOD_DAMAGE_OFFHAND; break;

 case RANGED_ATTACK: unitMod = UNIT_MOD_DAMAGE_RANGED; break;

 }


 float weapon_total_pct = unitCaster->GetPctModifierValue(unitMod, TOTAL_PCT);

 if (fixed_bonus)

 fixed_bonus = int32(fixed_bonus * weapon_total_pct);

 if (spell_bonus)

 spell_bonus = int32(spell_bonus * weapon_total_pct);

 }


 int32 weaponDamage = unitCaster->CalculateDamage(m_attackType, normalized, addPctMods);

 Mechanics mechanic = MECHANIC_NONE;


 // Sequence is important

 for (SpellEffectInfo const& spellEffectInfo : m_spellInfo->GetEffects())

 {

 // We assume that a spell have at most one fixed_bonus

 // and at most one weaponDamagePercentMod

 switch (spellEffectInfo.Effect)

 {

 case SPELL_EFFECT_WEAPON_DAMAGE:

 case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:

 case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:

 weaponDamage += fixed_bonus;

 break;

 case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:

 weaponDamage = int32(weaponDamage * weaponDamagePercentMod);

 break;

 default:

 continue; // not weapon damage effect, just skip

 }


 if (spellEffectInfo.Mechanic != MECHANIC_NONE && mechanic == MECHANIC_NONE)

 mechanic = spellEffectInfo.Mechanic;

 }


 weaponDamage += spell_bonus;

 weaponDamage = int32(weaponDamage * totalDamagePercentMod);


 // prevent negative damage

 weaponDamage = std::max(weaponDamage, 0);


 // Add melee damage bonuses (also check for negative)

 weaponDamage = unitCaster->MeleeDamageBonusDone(unitTarget, weaponDamage, m_attackType, SPELL_DIRECT_DAMAGE, m_spellInfo, mechanic, m_spellSchoolMask, this);

 m_damage += unitTarget->MeleeDamageBonusTaken(unitCaster, weaponDamage, m_attackType, SPELL_DIRECT_DAMAGE, m_spellInfo);

}


void Spell::EffectThreat()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster || !unitCaster->IsAlive())

 return;


 if (!unitTarget)

 return;


 if (!unitTarget->CanHaveThreatList())

 return;


 unitTarget->GetThreatManager().AddThreat(unitCaster, float(damage), m_spellInfo, true);

}


void Spell::EffectHealMaxHealth()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 if (!unitTarget || !unitTarget->IsAlive())

 return;


 int32 addhealth = 0;


 // damage == 0 - heal for caster max health

 if (damage == 0)

 addhealth = unitCaster->GetMaxHealth();

 else

 addhealth = unitTarget->GetMaxHealth() - unitTarget->GetHealth();


 m_healing += addhealth;

}


void Spell::EffectInterruptCast()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)

 return;


 if (!unitTarget || !unitTarget->IsAlive())

 return;


 // also exist case: apply cooldown to interrupted cast only and to all spells

 // there is no CURRENT_AUTOREPEAT_SPELL spells that can be interrupted

 for (uint32 i = CURRENT_FIRST_NON_MELEE_SPELL; i < CURRENT_AUTOREPEAT_SPELL; ++i)

 {

 if (Spell* spell = unitTarget->GetCurrentSpell(CurrentSpellTypes(i)))

 {

 SpellInfo const* curSpellInfo = spell->m_spellInfo;

 // check if we can interrupt spell

 if ((spell->getState() == SPELL_STATE_CASTING

 || (spell->getState() == SPELL_STATE_PREPARING && spell->GetCastTime() > 0.0f))

 && curSpellInfo->CanBeInterrupted(m_caster, unitTarget))

 {

 int32 duration = m_spellInfo->GetDuration();

 duration = unitTarget->ModSpellDuration(m_spellInfo, unitTarget, duration, false, 1 << effectInfo->EffectIndex);

 unitTarget->GetSpellHistory()->LockSpellSchool(curSpellInfo->GetSchoolMask(), Milliseconds(duration));

 m_hitMask |= PROC_HIT_INTERRUPT;

 SendSpellInterruptLog(unitTarget, curSpellInfo->Id);

 unitTarget->InterruptSpell(CurrentSpellTypes(i), false);

 }

 }

 }

}


void Spell::EffectSummonObjectWild()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)

 return;


 WorldObject* target = focusObject;

 if (!target)

 target = m_caster;


 float x, y, z, o;

 if (m_targets.HasDst())

 destTarget->GetPosition(x, y, z, o);

 else

 {

 m_caster->GetClosePoint(x, y, z, DEFAULT_PLAYER_BOUNDING_RADIUS);

 o = target->GetOrientation();

 }


 Map* map = target->GetMap();

 Position pos = Position(x, y, z, o);

 QuaternionData rot = QuaternionData::fromEulerAnglesZYX(o, 0.f, 0.f);

 GameObject* go = GameObject::CreateGameObject(effectInfo->MiscValue, map, pos, rot, 255, GO_STATE_READY);

 if (!go)

 return;


 PhasingHandler::InheritPhaseShift(go, m_caster);


 int32 duration = m_spellInfo->CalcDuration(m_caster);


 go->SetRespawnTime(duration > 0 ? duration/IN_MILLISECONDS : 0);

 go->SetSpellId(m_spellInfo->Id);


 ExecuteLogEffectSummonObject(SpellEffectName(effectInfo->Effect), go);


 // Wild object not have owner and check clickable by players

 map->AddToMap(go);


 if (go->GetGoType() == GAMEOBJECT_TYPE_FLAGDROP)

 if (Player* player = m_caster->ToPlayer())

 if (Battleground* bg = player->GetBattleground())

 bg->SetDroppedFlagGUID(go->GetGUID(), bg->GetPlayerTeam(player->GetGUID()) == ALLIANCE ? TEAM_HORDE: TEAM_ALLIANCE);


 if (GameObject* linkedTrap = go->GetLinkedTrap())

 {

 PhasingHandler::InheritPhaseShift(linkedTrap , m_caster);


 linkedTrap->SetRespawnTime(duration > 0 ? duration / IN_MILLISECONDS : 0);

 linkedTrap->SetSpellId(m_spellInfo->Id);


 ExecuteLogEffectSummonObject(SpellEffectName(effectInfo->Effect), linkedTrap);

 }

}


void Spell::EffectScriptEffect()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();


 switch (m_spellInfo->SpellFamilyName)

 {

 case SPELLFAMILY_GENERIC:

 {

 switch (m_spellInfo->Id)

 {

 // Shadow Flame (All script effects, not just end ones to prevent player from dodging the last triggered spell)

 case 22539:

 case 22972:

 case 22975:

 case 22976:

 case 22977:

 case 22978:

 case 22979:

 case 22980:

 case 22981:

 case 22982:

 case 22983:

 case 22984:

 case 22985:

 {

 if (!unitTarget || !unitTarget->IsAlive())

 return;


 // Onyxia Scale Cloak

 if (unitTarget->HasAura(22683))

 return;


 // Shadow Flame

 m_caster->CastSpell(unitTarget, 22682, this);

 return;

 }

 // Mug Transformation

 case 41931:

 {

 if (m_caster->GetTypeId() != TYPEID_PLAYER)

 return;


 uint8 bag = 19;

 uint8 slot = 0;

 Item* item = nullptr;


 while (bag) // 256 = 0 due to var type

 {

 item = m_caster->ToPlayer()->GetItemByPos(bag, slot);

 if (item && item->GetEntry() == 38587)

 break;


 ++slot;

 if (slot == 39)

 {

 slot = 0;

 ++bag;

 }

 }

 if (bag)

 {

 if (m_caster->ToPlayer()->GetItemByPos(bag, slot)->GetCount() == 1) m_caster->ToPlayer()->RemoveItem(bag, slot, true);

 else m_caster->ToPlayer()->GetItemByPos(bag, slot)->SetCount(m_caster->ToPlayer()->GetItemByPos(bag, slot)->GetCount()-1);

 // Spell 42518 (Braufest - Gratisprobe des Braufest herstellen)

 m_caster->CastSpell(m_caster, 42518, this);

 return;

 }

 break;

 }

 // Brutallus - Burn

 case 45141:

 case 45151:

 {

 //Workaround for Range ... should be global for every ScriptEffect

 float radius = effectInfo->CalcRadius(nullptr, SpellTargetIndex::TargetB);

 if (unitTarget && unitTarget->GetTypeId() == TYPEID_PLAYER && unitTarget->GetDistance(m_caster) >= radius && !unitTarget->HasAura(46394) && unitTarget != m_caster)

 unitTarget->CastSpell(unitTarget, 46394, this);


 break;

 }

 // Summon Ghouls On Scarlet Crusade

 case 51904:

 {

 if (!m_targets.HasDst())

 return;


 float radius = effectInfo->CalcRadius();

 for (uint8 i = 0; i < 15; ++i)

 m_caster->CastSpell(m_caster->GetRandomPoint(*destTarget, radius), 54522, this);

 break;

 }

 case 52173: // Coyote Spirit Despawn

 case 60243: // Blood Parrot Despawn

 if (unitTarget->GetTypeId() == TYPEID_UNIT && unitTarget->IsSummon())

 unitTarget->ToTempSummon()->UnSummon();

 return;

 case 57347: // Retrieving (Wintergrasp RP-GG pickup spell)

 {

 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_UNIT || m_caster->GetTypeId() != TYPEID_PLAYER)

 return;


 unitTarget->ToCreature()->DespawnOrUnsummon();


 return;

 }

 case 57349: // Drop RP-GG (Wintergrasp RP-GG at death drop spell)

 {

 if (m_caster->GetTypeId() != TYPEID_PLAYER)

 return;


 // Delete item from inventory at death

 m_caster->ToPlayer()->DestroyItemCount(damage, 5, true);


 return;

 }

 case 62482: // Grab Crate

 {

 if (!unitCaster)

 return;


 if (unitTarget)

 {

 if (Unit* seat = unitCaster->GetVehicleBase())

 {

 if (Unit* parent = seat->GetVehicleBase())

 {

 unitCaster->CastSpell(parent, 62496, this);

 unitTarget->CastSpell(parent, damage, CastSpellExtraArgs()

 .SetTriggeringSpell(this)); // DIFFICULTY_NONE, so effect always valid

 }

 }

 }

 return;

 }

 }

 break;

 }

 }


 // normal DB scripted effect

 TC_LOG_DEBUG("spells", "Spell ScriptStart spellid {} in EffectScriptEffect({})", m_spellInfo->Id, effectInfo->EffectIndex);

 m_caster->GetMap()->ScriptsStart(sSpellScripts, uint32(m_spellInfo->Id | (effectInfo->EffectIndex << 24)), m_caster, unitTarget);

}


void Spell::EffectSanctuary()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 auto isAffectedBySanctuary = [](Unit const* attacker)

 {

 Creature const* attackerCreature = attacker->ToCreature();

 return !attackerCreature || !attackerCreature->IsIgnoringSanctuarySpellEffect();

 };


 if (unitTarget->GetTypeId() == TYPEID_PLAYER && !unitTarget->GetMap()->IsDungeon())

 {

 // stop all pve combat for players outside dungeons, suppress pvp combat

 unitTarget->CombatStop(false, false, isAffectedBySanctuary);

 }

 else

 {

 // in dungeons (or for nonplayers), reset this unit on all enemies' threat lists

 for (auto const& [guid, ref] : unitTarget->GetThreatManager().GetThreatenedByMeList())

 if (isAffectedBySanctuary(ref->GetOwner()))

 ref->ScaleThreat(0.0f);

 }


 // makes spells cast before this time fizzle

 unitTarget->m_lastSanctuaryTime = GameTime::GetGameTimeMS();

}


void Spell::EffectDuel()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || m_caster->GetTypeId() != TYPEID_PLAYER || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 Player* caster = m_caster->ToPlayer();

 Player* target = unitTarget->ToPlayer();


 // caster or target already have requested duel

 if (caster->duel || target->duel || !target->GetSocial() || target->GetSocial()->HasIgnore(caster->GetGUID(), caster->GetSession()->GetAccountGUID()))

 return;


 // Players can only fight a duel in zones with this flag

 AreaTableEntry const* casterAreaEntry = sAreaTableStore.LookupEntry(caster->GetAreaId());

 if (casterAreaEntry && !(casterAreaEntry->GetFlags().HasFlag(AreaFlags::AllowDueling)))

 {

 SendCastResult(SPELL_FAILED_NO_DUELING); // Dueling isn't allowed here

 return;

 }


 AreaTableEntry const* targetAreaEntry = sAreaTableStore.LookupEntry(target->GetAreaId());

 if (targetAreaEntry && !(targetAreaEntry->GetFlags().HasFlag(AreaFlags::AllowDueling)))

 {

 SendCastResult(SPELL_FAILED_NO_DUELING); // Dueling isn't allowed here

 return;

 }


 //CREATE DUEL FLAG OBJECT

 Map* map = caster->GetMap();

 Position const pos =

 {

 caster->GetPositionX() + (unitTarget->GetPositionX() - caster->GetPositionX()) / 2,

 caster->GetPositionY() + (unitTarget->GetPositionY() - caster->GetPositionY()) / 2,

 caster->GetPositionZ(),

 caster->GetOrientation()

 };

 QuaternionData rot = QuaternionData::fromEulerAnglesZYX(pos.GetOrientation(), 0.f, 0.f);


 GameObject* go = GameObject::CreateGameObject(effectInfo->MiscValue, map, pos, rot, 0, GO_STATE_READY);

 if (!go)

 return;


 PhasingHandler::InheritPhaseShift(go, caster);


 go->SetFaction(caster->GetFaction());

 go->SetLevel(caster->GetLevel() + 1);

 int32 duration = m_spellInfo->CalcDuration(caster);

 go->SetRespawnTime(duration > 0 ? duration/IN_MILLISECONDS : 0);

 go->SetSpellId(m_spellInfo->Id);


 ExecuteLogEffectSummonObject(SpellEffectName(effectInfo->Effect), go);


 caster->AddGameObject(go);

 map->AddToMap(go);

 //END


 // Send request

 WorldPackets::Duel::DuelRequested packet;

 packet.ArbiterGUID = go->GetGUID();

 packet.RequestedByGUID = caster->GetGUID();

 packet.RequestedByWowAccount = caster->GetSession()->GetAccountGUID();


 WorldPacket const* worldPacket = packet.Write();

 caster->SendDirectMessage(worldPacket);

 target->SendDirectMessage(worldPacket);


 // create duel-info

 bool isMounted = (GetSpellInfo()->Id == 62875);

 caster->duel = std::make_unique<DuelInfo>(target, caster, isMounted);

 target->duel = std::make_unique<DuelInfo>(caster, caster, isMounted);


 caster->SetDuelArbiter(go->GetGUID());

 target->SetDuelArbiter(go->GetGUID());


 sScriptMgr->OnPlayerDuelRequest(target, caster);

}


void Spell::EffectStuck()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 if (!sWorld->getBoolConfig(CONFIG_CAST_UNSTUCK))

 return;


 Player* player = m_caster->ToPlayer();

 if (!player)

 return;


 TC_LOG_DEBUG("spells", "Spell Effect: Stuck");

 TC_LOG_DEBUG("spells", "Player {} {} used the auto-unstuck feature at map {} ({}, {}, {}).", player->GetName(), player->GetGUID().ToString(), player->GetMapId(), player->GetPositionX(), player->GetPositionY(), player->GetPositionZ());


 if (player->IsInFlight())

 return;


 // if player is dead without death timer is teleported to graveyard, otherwise not apply the effect

 if (player->isDead())

 {

 if (!player->GetDeathTimer())

 player->RepopAtGraveyard();


 return;

 }


 // the player dies if hearthstone is in cooldown, else the player is teleported to home

 if (player->GetSpellHistory()->HasCooldown(8690))

 {

 player->KillSelf();

 return;

 }


 player->TeleportTo(player->m_homebind, TELE_TO_SPELL);


 // Stuck spell trigger Hearthstone cooldown

 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(8690, GetCastDifficulty());

 if (!spellInfo)

 return;

 Spell spell(player, spellInfo, TRIGGERED_FULL_MASK);

 spell.SendSpellCooldown();

}


void Spell::EffectSummonPlayer()

{

 // workaround - this effect should not use target map

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 unitTarget->ToPlayer()->SendSummonRequestFrom(unitCaster);

}


void Spell::EffectActivateObject()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!gameObjTarget)

 return;


 GameObjectActions action = GameObjectActions(effectInfo->MiscValue);


 gameObjTarget->ActivateObject(action, effectInfo->MiscValueB, m_caster, m_spellInfo->Id, int32(effectInfo->EffectIndex));

}


void Spell::EffectApplyGlyph()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 Player* player = m_caster->ToPlayer();

 if (!player)

 return;


 std::vector<uint32>& glyphs = player->GetGlyphs(player->GetActiveTalentGroup());

 std::size_t replacedGlyph = glyphs.size();

 for (std::size_t i = 0; i < glyphs.size(); ++i)

 {

 if (std::vector<uint32> const* activeGlyphBindableSpells = sDB2Manager.GetGlyphBindableSpells(glyphs[i]))

 {

 if (std::find(activeGlyphBindableSpells->begin(), activeGlyphBindableSpells->end(), m_misc.SpellId) != activeGlyphBindableSpells->end())

 {

 replacedGlyph = i;

 player->RemoveAurasDueToSpell(sGlyphPropertiesStore.AssertEntry(glyphs[i])->SpellID);

 break;

 }

 }

 }


 uint32 glyphId = effectInfo->MiscValue;

 if (replacedGlyph < glyphs.size())

 {

 if (glyphId)

 glyphs[replacedGlyph] = glyphId;

 else

 glyphs.erase(glyphs.begin() + replacedGlyph);

 }

 else if (glyphId)

 glyphs.push_back(glyphId);


 player->RemoveAurasWithInterruptFlags(SpellAuraInterruptFlags2::ChangeGlyph);


 if (GlyphPropertiesEntry const* glyphProperties = sGlyphPropertiesStore.LookupEntry(glyphId))

 player->CastSpell(player, glyphProperties->SpellID, this);


 WorldPackets::Talent::ActiveGlyphs activeGlyphs;

 activeGlyphs.Glyphs.emplace_back(m_misc.SpellId, uint16(glyphId));

 activeGlyphs.IsFullUpdate = false;

 player->SendDirectMessage(activeGlyphs.Write());

}


void Spell::EffectEnchantHeldItem()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 // this is only item spell effect applied to main-hand weapon of target player (players in area)

 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 Player* item_owner = unitTarget->ToPlayer();

 Item* item = item_owner->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);


 if (!item)

 return;


 // must be equipped

 if (!item->IsEquipped())

 return;


 if (effectInfo->MiscValue)

 {

 uint32 enchant_id = effectInfo->MiscValue;

 int32 duration = m_spellInfo->GetDuration(); //Try duration index first ..

 if (!duration)

 duration = damage;//+1; //Base points after ..

 if (!duration)

 duration = 10 * IN_MILLISECONDS; //10 seconds for enchants which don't have listed duration


 if (m_spellInfo->Id == 14792) // Venomhide Poison

 duration = 5 * MINUTE * IN_MILLISECONDS;


 SpellItemEnchantmentEntry const* pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);

 if (!pEnchant)

 return;


 // Always go to temp enchantment slot

 EnchantmentSlot slot = TEMP_ENCHANTMENT_SLOT;


 // Enchantment will not be applied if a different one already exists

 if (item->GetEnchantmentId(slot) && item->GetEnchantmentId(slot) != enchant_id)

 return;


 // Apply the temporary enchantment

 item->SetEnchantment(slot, enchant_id, duration, 0, m_caster->GetGUID());

 item_owner->ApplyEnchantment(item, slot, true);

 }

}


void Spell::EffectDisEnchant()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (Player* caster = m_caster->ToPlayer())

 {

 caster->UpdateCraftSkill(m_spellInfo);

 itemTarget->m_loot.reset(new Loot(caster->GetMap(), itemTarget->GetGUID(), LOOT_DISENCHANTING, nullptr));

 itemTarget->m_loot->FillLoot(ASSERT_NOTNULL(itemTarget->GetDisenchantLoot(caster))->ID, LootTemplates_Disenchant, caster, true);

 caster->SendLoot(*itemTarget->m_loot);

 }


 // item will be removed at disenchanting end

}


void Spell::EffectInebriate()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || !unitTarget->IsPlayer())

 return;


 Player* player = unitTarget->ToPlayer();


 uint8 currentDrunkValue = player->GetDrunkValue();

 uint8 drunkValue = std::clamp<int32>(damage + currentDrunkValue, 0, 100);

 if (currentDrunkValue == 100 && currentDrunkValue == drunkValue)

 if (roll_chance_f(25.0f))

 player->CastSpell(player, 67468, CastSpellExtraArgs()

 .SetTriggeringSpell(this)); // Drunken Vomit


 player->SetDrunkValue(drunkValue, m_CastItem ? m_CastItem->GetEntry() : 0);

}


void Spell::EffectFeedPet()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Player* player = m_caster->ToPlayer();

 if (!player)

 return;


 Item* foodItem = itemTarget;

 if (!foodItem)

 return;


 Pet* pet = player->GetPet();

 if (!pet)

 return;


 if (!pet->IsAlive())

 return;


 ExecuteLogEffectDestroyItem(SpellEffectName(effectInfo->Effect), foodItem->GetEntry());


 int32 pct;

 int32 levelDiff = int32(pet->GetLevel()) - int32(foodItem->GetTemplate()->GetBaseItemLevel());

 if (levelDiff >= 30)

 return;

 else if (levelDiff >= 20)

 pct = int32(12.5); // we can't pass double so keeping the cast here for future references

 else if (levelDiff >= 10)

 pct = 25;

 else

 pct = 50;


 uint32 count = 1;

 player->DestroyItemCount(foodItem, count, true);


 CastSpellExtraArgs args(TRIGGERED_FULL_MASK);

 args.SetTriggeringSpell(this);

 args.AddSpellMod(SPELLVALUE_BASE_POINT0, pct);

 m_caster->CastSpell(pet, effectInfo->TriggerSpell, args);

}


void Spell::EffectDismissPet()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || !unitTarget->IsPet())

 return;


 Pet* pet = unitTarget->ToPet();


 ExecuteLogEffectUnsummonObject(SpellEffectName(effectInfo->Effect), pet);

 pet->Remove(PET_SAVE_NOT_IN_SLOT);

}


void Spell::EffectSummonObject()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 uint8 slot = effectInfo->Effect - SPELL_EFFECT_SUMMON_OBJECT_SLOT1;

 ObjectGuid guid = unitCaster->m_ObjectSlot[slot];

 if (!guid.IsEmpty())

 {

 if (GameObject* obj = unitCaster->GetMap()->GetGameObject(guid))

 {

 // Recast case - null spell id to make auras not be removed on object remove from world

 if (m_spellInfo->Id == obj->GetSpellId())

 obj->SetSpellId(0);

 unitCaster->RemoveGameObject(obj, true);

 }

 unitCaster->m_ObjectSlot[slot].Clear();

 }


 float x, y, z, o;

 // If dest location if present

 if (m_targets.HasDst())

 destTarget->GetPosition(x, y, z, o);

 // Summon in random point all other units if location present

 else

 {

 unitCaster->GetClosePoint(x, y, z, DEFAULT_PLAYER_BOUNDING_RADIUS);

 o = unitCaster->GetOrientation();

 }


 Map* map = m_caster->GetMap();

 Position pos = Position(x, y, z, o);

 QuaternionData rot = QuaternionData::fromEulerAnglesZYX(o, 0.f, 0.f);


 GameObject* go = GameObject::CreateGameObject(effectInfo->MiscValue, map, pos, rot, 255, GO_STATE_READY);

 if (!go)

 return;


 PhasingHandler::InheritPhaseShift(go, m_caster);


 go->SetFaction(unitCaster->GetFaction());

 go->SetLevel(unitCaster->GetLevel());

 int32 duration = m_spellInfo->CalcDuration(m_caster);

 go->SetRespawnTime(duration > 0 ? duration / IN_MILLISECONDS : 0);

 go->SetSpellId(m_spellInfo->Id);

 unitCaster->AddGameObject(go);


 ExecuteLogEffectSummonObject(SpellEffectName(effectInfo->Effect), go);


 map->AddToMap(go);


 unitCaster->m_ObjectSlot[slot] = go->GetGUID();

}


void Spell::EffectResurrect()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!m_corpseTarget && !unitTarget)

 return;


 Player* player = nullptr;


 if (m_corpseTarget)

 player = ObjectAccessor::FindPlayer(m_corpseTarget->GetOwnerGUID());

 else if (unitTarget)

 player = unitTarget->ToPlayer();


 if (!player || player->IsAlive() || !player->IsInWorld())

 return;


 if (player->IsResurrectRequested()) // already have one active request

 return;


 uint32 health = player->CountPctFromMaxHealth(damage);

 uint32 mana = CalculatePct(player->GetMaxPower(POWER_MANA), damage);


 ExecuteLogEffectResurrect(SpellEffectName(effectInfo->Effect), player);


 player->SetResurrectRequestData(m_caster, health, mana, 0);

 SendResurrectRequest(player);

}


void Spell::EffectAddExtraAttacks()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || !unitTarget->IsAlive())

 return;


 unitTarget->AddExtraAttacks(damage);


 ExecuteLogEffectExtraAttacks(SpellEffectName(effectInfo->Effect), unitTarget, damage);

}


void Spell::EffectParry()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 if (m_caster->GetTypeId() == TYPEID_PLAYER)

 m_caster->ToPlayer()->SetCanParry(true);

}


void Spell::EffectBlock()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 if (m_caster->GetTypeId() == TYPEID_PLAYER)

 m_caster->ToPlayer()->SetCanBlock(true);

}


void Spell::EffectLeap()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->IsInFlight())

 return;


 if (!m_targets.HasDst())

 return;


 Position pos = destTarget->GetPosition();

 unitTarget->NearTeleportTo(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation(), unitTarget == m_caster);

}


void Spell::EffectReputation()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 Player* player = unitTarget->ToPlayer();


 int32 repChange = damage;


 uint32 factionId = effectInfo->MiscValue;


 FactionEntry const* factionEntry = sFactionStore.LookupEntry(factionId);

 if (!factionEntry)

 return;


 repChange = player->CalculateReputationGain(REPUTATION_SOURCE_SPELL, 0, repChange, factionId);


 player->GetReputationMgr().ModifyReputation(factionEntry, repChange);

}


void Spell::EffectQuestComplete()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;

 Player* player = unitTarget->ToPlayer();


 uint32 questId = effectInfo->MiscValue;

 if (questId)

 {

 Quest const* quest = sObjectMgr->GetQuestTemplate(questId);

 if (!quest)

 return;


 uint16 logSlot = player->FindQuestSlot(questId);

 if (logSlot < MAX_QUEST_LOG_SIZE)

 player->AreaExploredOrEventHappens(questId);

 else if (quest->HasFlag(QUEST_FLAGS_TRACKING_EVENT)) // Check if the quest is used as a serverside flag.

 player->SetRewardedQuest(questId); // If so, set status to rewarded without broadcasting it to client.

 }

}


void Spell::EffectForceDeselect()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 float dist = unitCaster->GetVisibilityRange();


 // clear focus

 Trinity::PacketSenderOwning<WorldPackets::Combat::BreakTarget> breakTarget;

 breakTarget.Data.UnitGUID = m_caster->GetGUID();

 breakTarget.Data.Write();

 Trinity::MessageDistDelivererToHostile<Trinity::PacketSenderOwning<WorldPackets::Combat::BreakTarget>> notifierBreak(unitCaster, breakTarget, dist);

 Cell::VisitWorldObjects(m_caster, notifierBreak, dist);


 // and selection

 Trinity::PacketSenderOwning<WorldPackets::Spells::ClearTarget> clearTarget;

 clearTarget.Data.Guid = m_caster->GetGUID();

 clearTarget.Data.Write();

 Trinity::MessageDistDelivererToHostile<Trinity::PacketSenderOwning<WorldPackets::Spells::ClearTarget>> notifierClear(unitCaster, clearTarget, dist);

 Cell::VisitWorldObjects(m_caster, notifierClear, dist);


 // we should also force pets to remove us from current target

 Unit::AttackerSet attackerSet;

 for (Unit::AttackerSet::const_iterator itr = unitCaster->getAttackers().begin(); itr != unitCaster->getAttackers().end(); ++itr)

 if ((*itr)->GetTypeId() == TYPEID_UNIT && !(*itr)->CanHaveThreatList())

 attackerSet.insert(*itr);


 for (Unit::AttackerSet::const_iterator itr = attackerSet.begin(); itr != attackerSet.end(); ++itr)

 (*itr)->AttackStop();

}


void Spell::EffectSelfResurrect()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 Player* player = m_caster->ToPlayer();

 if (!player || !player->IsInWorld() || player->IsAlive())

 return;


 uint32 health = 0;

 uint32 mana = 0;


 // flat case

 if (damage < 0)

 {

 health = uint32(-damage);

 mana = effectInfo->MiscValue;

 }

 // percent case

 else

 {

 health = player->CountPctFromMaxHealth(damage);

 if (player->GetMaxPower(POWER_MANA) > 0)

 mana = CalculatePct(player->GetMaxPower(POWER_MANA), damage);

 }


 player->ResurrectPlayer(0.0f);


 player->SetHealth(health);

 player->SetPower(POWER_MANA, mana);

 player->SetPower(POWER_RAGE, 0);

 player->SetFullPower(POWER_ENERGY);

 player->SetPower(POWER_FOCUS, 0);


 player->SpawnCorpseBones();

}


void Spell::EffectSkinning()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (unitTarget->GetTypeId() != TYPEID_UNIT)

 return;


 Player* player = m_caster->ToPlayer();

 if (!player)

 return;


 Creature* creature = unitTarget->ToCreature();

 int32 targetLevel = creature->GetLevelForTarget(m_caster);


 uint32 skill = creature->GetCreatureDifficulty()->GetRequiredLootSkill();


 creature->SetUnitFlag3(UNIT_FLAG3_ALREADY_SKINNED);

 creature->SetDynamicFlag(UNIT_DYNFLAG_LOOTABLE);

 Loot* loot = new Loot(creature->GetMap(), creature->GetGUID(), LOOT_SKINNING, nullptr);

 creature->m_personalLoot[player->GetGUID()].reset(loot);

 loot->FillLoot(creature->GetCreatureDifficulty()->SkinLootID, LootTemplates_Skinning, player, true);

 player->SendLoot(*loot);


 if (!IsPartOfSkillLine(skill, m_spellInfo->Id))

 return;


 // Skill gain for skinning

 // This formula is still used (10.0.5.48526)

 if (skill == SKILL_SKINNING)

 {

 int32 reqValue;

 if (targetLevel <= 10)

 reqValue = 1;

 else if (targetLevel < 20)

 reqValue = (targetLevel - 10) * 10;

 else if (targetLevel <= 73)

 reqValue = targetLevel * 5;

 else if (targetLevel < 80)

 reqValue = targetLevel * 10 - 365;

 else if (targetLevel <= 84)

 reqValue = targetLevel * 5 + 35;

 else if (targetLevel <= 87)

 reqValue = targetLevel * 15 - 805;

 else if (targetLevel <= 92)

 reqValue = (targetLevel - 62) * 20;

 else if (targetLevel <= 104)

 reqValue = targetLevel * 5 + 175;

 else if (targetLevel <= 107)

 reqValue = targetLevel * 15 - 905;

 else if (targetLevel <= 112)

 reqValue = (targetLevel - 72) * 20;

 else if (targetLevel <= 122)

 reqValue = (targetLevel - 32) * 10;

 else

 reqValue = 900;


 ContentTuningEntry const* contentTuning = sContentTuningStore.LookupEntry(creature->GetContentTuning());

 if (!contentTuning)

 return;


 uint32 skinningSkill = player->GetProfessionSkillForExp(skill, contentTuning->ExpansionID);

 if (!skinningSkill)

 return;


 if (uint32 pureSkillValue = player->GetPureSkillValue(skinningSkill))

 {

 // Double chances for elites

 player->UpdateGatherSkill(skinningSkill, pureSkillValue, reqValue, creature->IsElite() ? 2 : 1);

 }

 }

}


void Spell::EffectCharge()

{

 if (!unitTarget)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 if (effectHandleMode == SPELL_EFFECT_HANDLE_LAUNCH_TARGET)

 {

 // charge changes fall time

 if (unitCaster->GetTypeId() == TYPEID_PLAYER)

 unitCaster->ToPlayer()->SetFallInformation(0, unitCaster->GetPositionZ());


 float speed = G3D::fuzzyGt(m_spellInfo->Speed, 0.0f) ? m_spellInfo->Speed : SPEED_CHARGE;


 Optional<Movement::SpellEffectExtraData> spellEffectExtraData;

 if (effectInfo->MiscValueB)

 {

 spellEffectExtraData.emplace();

 spellEffectExtraData->Target = unitTarget->GetGUID();

 spellEffectExtraData->SpellVisualId = effectInfo->MiscValueB;

 }

 // Spell is not using explicit target - no generated path

 if (!m_preGeneratedPath)

 {

 Position pos = unitTarget->GetFirstCollisionPosition(unitTarget->GetCombatReach(), unitTarget->GetRelativeAngle(m_caster));


 m_preGeneratedPath = std::make_unique<PathGenerator>(unitCaster);

 m_preGeneratedPath->CalculatePath(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), false);

 }


 if (G3D::fuzzyGt(m_spellInfo->Speed, 0.0f) && m_spellInfo->HasAttribute(SPELL_ATTR9_SPECIAL_DELAY_CALCULATION))

 speed = m_preGeneratedPath->GetPathLength() / speed;


 unitCaster->GetMotionMaster()->MoveCharge(*m_preGeneratedPath, speed, unitTarget, spellEffectExtraData ? &*spellEffectExtraData : nullptr);


 // abuse implementation detail of MoveCharge accepting PathGenerator argument (instantly started spline)

 UpdateDelayMomentForUnitTarget(unitTarget, unitCaster->movespline->Duration());

 }


 if (effectHandleMode == SPELL_EFFECT_HANDLE_HIT_TARGET)

 {

 // not all charge effects used in negative spells

 if (m_spellInfo->HasAttribute(SPELL_ATTR7_ATTACK_ON_CHARGE_TO_UNIT))

 unitCaster->Attack(unitTarget, true);


 if (effectInfo->TriggerSpell)

 m_caster->CastSpell(unitTarget, effectInfo->TriggerSpell, CastSpellExtraArgs(TRIGGERED_FULL_MASK)

 .SetOriginalCaster(m_originalCasterGUID)

 .SetTriggeringSpell(this));

 }

}


void Spell::EffectChargeDest()

{

 if (!destTarget)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 if (effectHandleMode == SPELL_EFFECT_HANDLE_LAUNCH)

 {

 Position pos = destTarget->GetPosition();


 if (!unitCaster->IsWithinLOS(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ()))

 {

 float angle = unitCaster->GetRelativeAngle(pos.GetPositionX(), pos.GetPositionY());

 float dist = unitCaster->GetDistance(pos);

 pos = unitCaster->GetFirstCollisionPosition(dist, angle);

 }


 PathGenerator path(unitCaster);

 path.CalculatePath(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), false);


 float speed = G3D::fuzzyGt(m_spellInfo->Speed, 0.0f) ? m_spellInfo->Speed : SPEED_CHARGE;


 if (G3D::fuzzyGt(m_spellInfo->Speed, 0.0f) && m_spellInfo->HasAttribute(SPELL_ATTR9_SPECIAL_DELAY_CALCULATION))

 speed = path.GetPathLength() / speed;


 unitCaster->GetMotionMaster()->MoveCharge(path, speed);


 // abuse implementation detail of MoveCharge accepting PathGenerator argument (instantly started spline)

 UpdateDelayMomentForDst(unitCaster->movespline->Duration());

 }

 else if (effectHandleMode == SPELL_EFFECT_HANDLE_HIT)

 {

 if (effectInfo->TriggerSpell)

 m_caster->CastSpell(*destTarget, effectInfo->TriggerSpell, CastSpellExtraArgs(TRIGGERED_FULL_MASK)

 .SetOriginalCaster(m_originalCasterGUID)

 .SetTriggeringSpell(this));

 }

}


void Spell::EffectKnockBack()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 if (m_caster->GetAffectingPlayer())

 if (Creature* creatureTarget = unitTarget->ToCreature())

 if (creatureTarget->isWorldBoss() || creatureTarget->IsDungeonBoss())

 return;


 // Spells with SPELL_EFFECT_KNOCK_BACK (like Thunderstorm) can't knockback target if target has ROOT/STUN

 if (unitTarget->HasUnitState(UNIT_STATE_ROOT | UNIT_STATE_STUNNED))

 return;


 // Instantly interrupt non melee spells being cast

 if (unitTarget->IsNonMeleeSpellCast(true))

 unitTarget->InterruptNonMeleeSpells(true);


 float ratio = 0.1f;

 float speedxy = float(effectInfo->MiscValue) * ratio;

 float speedz = float(damage) * ratio;

 if (speedxy < 0.01f && speedz < 0.01f)

 return;


 Position origin;

 if (effectInfo->Effect == SPELL_EFFECT_KNOCK_BACK_DEST)

 {

 if (m_targets.HasDst())

 origin = destTarget->GetPosition();

 else

 return;

 }

 else //if (effectInfo->Effect == SPELL_EFFECT_KNOCK_BACK)

 origin = m_caster->GetPosition();


 unitTarget->KnockbackFrom(origin, speedxy, speedz);


 Unit::ProcSkillsAndAuras(GetUnitCasterForEffectHandlers(), unitTarget, PROC_FLAG_NONE, { PROC_FLAG_NONE, PROC_FLAG_2_KNOCKBACK },

 PROC_SPELL_TYPE_MASK_ALL, PROC_SPELL_PHASE_HIT, PROC_HIT_NONE, nullptr, nullptr, nullptr);

}


void Spell::EffectLeapBack()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)

 return;


 if (!unitTarget)

 return;


 float speedxy = effectInfo->MiscValue / 10.f;

 float speedz = damage / 10.f;

 // Disengage

 unitTarget->JumpTo(speedxy, speedz, effectInfo->PositionFacing);


 // changes fall time

 if (m_caster->GetTypeId() == TYPEID_PLAYER)

 m_caster->ToPlayer()->SetFallInformation(0, m_caster->GetPositionZ());

}


void Spell::EffectQuestClear()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;

 Player* player = unitTarget->ToPlayer();


 uint32 quest_id = effectInfo->MiscValue;


 Quest const* quest = sObjectMgr->GetQuestTemplate(quest_id);


 if (!quest)

 return;


 QuestStatus oldStatus = player->GetQuestStatus(quest_id);


 // Player has never done this quest

 if (oldStatus == QUEST_STATUS_NONE)

 return;


 // remove all quest entries for 'entry' from quest log

 for (uint8 slot = 0; slot < MAX_QUEST_LOG_SIZE; ++slot)

 {

 uint32 logQuest = player->GetQuestSlotQuestId(slot);

 if (logQuest == quest_id)

 {

 player->SetQuestSlot(slot, 0);


 // we ignore unequippable quest items in this case, it's still be equipped

 player->TakeQuestSourceItem(logQuest, false);


 if (quest->HasFlag(QUEST_FLAGS_FLAGS_PVP))

 {

 player->pvpInfo.IsHostile = player->pvpInfo.IsInHostileArea || player->HasPvPForcingQuest();

 player->UpdatePvPState();

 }

 }

 }


 player->RemoveActiveQuest(quest_id, false);

 player->RemoveRewardedQuest(quest_id);

 player->DespawnPersonalSummonsForQuest(quest_id);


 sScriptMgr->OnQuestStatusChange(player, quest_id);

 sScriptMgr->OnQuestStatusChange(player, quest, oldStatus, QUEST_STATUS_NONE);

}


void Spell::EffectSendTaxi()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 unitTarget->ToPlayer()->ActivateTaxiPathTo(effectInfo->MiscValue, m_spellInfo->Id);

}


void Spell::EffectPullTowards()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 Position pos = m_caster->GetFirstCollisionPosition(m_caster->GetCombatReach(), m_caster->GetRelativeAngle(unitTarget));


 // This is a blizzlike mistake: this should be 2D distance according to projectile motion formulas, but Blizzard erroneously used 3D distance.

 float distXY = unitTarget->GetExactDist(pos);


 // Avoid division by 0

 if (distXY < 0.001)

 return;


 float distZ = pos.GetPositionZ() - unitTarget->GetPositionZ();

 float speedXY = effectInfo->MiscValue ? effectInfo->MiscValue / 10.0f : 30.0f;

 float speedZ = (2 * speedXY * speedXY * distZ + Movement::gravity * distXY * distXY) / (2 * speedXY * distXY);


 if (!std::isfinite(speedZ))

 {

 TC_LOG_ERROR("spells", "Spell {} with SPELL_EFFECT_PULL_TOWARDS called with invalid speedZ. {}", m_spellInfo->Id, GetDebugInfo());

 return;

 }


 unitTarget->JumpTo(speedXY, speedZ, 0.0f, pos);

}


void Spell::EffectPullTowardsDest()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 if (!m_targets.HasDst())

 {

 TC_LOG_ERROR("spells", "Spell {} with SPELL_EFFECT_PULL_TOWARDS_DEST has no dest target", m_spellInfo->Id);

 return;

 }


 Position const* pos = m_targets.GetDstPos();

 // This is a blizzlike mistake: this should be 2D distance according to projectile motion formulas, but Blizzard erroneously used 3D distance

 float distXY = unitTarget->GetExactDist(pos);


 // Avoid division by 0

 if (distXY < 0.001)

 return;


 float distZ = pos->GetPositionZ() - unitTarget->GetPositionZ();


 float speedXY = effectInfo->MiscValue ? effectInfo->MiscValue / 10.0f : 30.0f;

 float speedZ = (2 * speedXY * speedXY * distZ + Movement::gravity * distXY * distXY) / (2 * speedXY * distXY);


 if (!std::isfinite(speedZ))

 {

 TC_LOG_ERROR("spells", "Spell {} with SPELL_EFFECT_PULL_TOWARDS_DEST called with invalid speedZ. {}", m_spellInfo->Id, GetDebugInfo());

 return;

 }


 unitTarget->JumpTo(speedXY, speedZ, 0.0f, *pos);

}


void Spell::EffectChangeRaidMarker()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 Player* player = m_caster->ToPlayer();

 if (!player || !m_targets.HasDst())

 return;


 Group* group = player->GetGroup();

 if (!group || (group->isRaidGroup() && !group->IsLeader(player->GetGUID()) && !group->IsAssistant(player->GetGUID())))

 return;


 float x, y, z;

 destTarget->GetPosition(x, y, z);


 group->AddRaidMarker(damage, player->GetMapId(), x, y, z);

}


void Spell::EffectDispelMechanic()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 uint32 mechanic = effectInfo->MiscValue;

 DispelList dispel_list;

 Unit::AuraMap const& auras = unitTarget->GetOwnedAuras();

 for (Unit::AuraMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)

 {

 Aura* aura = itr->second;

 if (!aura->GetApplicationOfTarget(unitTarget->GetGUID()))

 continue;

 if (roll_chance_i(aura->CalcDispelChance(unitTarget, !unitTarget->IsFriendlyTo(m_caster))))

 if ((aura->GetSpellInfo()->GetAllEffectsMechanicMask() & (UI64LIT(1) << mechanic)))

 dispel_list.emplace_back(aura->GetId(), aura->GetCasterGUID());

 }


 if (dispel_list.empty())

 return;


 for (auto itr = dispel_list.begin(); itr != dispel_list.end(); ++itr)

 unitTarget->RemoveAura(itr->first, itr->second, 0, AURA_REMOVE_BY_ENEMY_SPELL);


 m_hitMask |= PROC_HIT_DISPEL;

}


void Spell::EffectResurrectPet()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 if (damage < 0)

 return;


 Player* player = m_caster->ToPlayer();

 if (!player)

 return;


 // Maybe player dismissed dead pet or pet despawned?

 bool hadPet = true;


 if (!player->GetPet())

 {

 PetStable const* petStable = player->GetPetStable();

 auto deadPetItr = std::find_if(petStable->ActivePets.begin(), petStable->ActivePets.end(), [](Optional<PetStable::PetInfo> const& petInfo)

 {

 return petInfo && !petInfo->Health;

 });


 PetSaveMode slot = PetSaveMode(std::distance(petStable->ActivePets.begin(), deadPetItr));


 // Position passed to SummonPet is irrelevant with current implementation,

 // pet will be relocated without using these coords in Pet::LoadPetFromDB

 player->SummonPet(0, slot, 0.0f, 0.0f, 0.0f, 0.0f, 0);

 hadPet = false;

 }


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

 Pet* pet = player->GetPet(); // Attempt to get current pet

 if (!pet || pet->IsAlive())

 return;


 // If player did have a pet before reviving, teleport it

 if (hadPet)

 {

 // Reposition the pet's corpse before reviving so as not to grab aggro

 // We can use a different, more accurate version of GetClosePoint() since we have a pet

 float x, y, z; // Will be used later to reposition the pet if we have one

 player->GetClosePoint(x, y, z, pet->GetCombatReach(), PET_FOLLOW_DIST, pet->GetFollowAngle());

 pet->NearTeleportTo(x, y, z, player->GetOrientation());

 pet->Relocate(x, y, z, player->GetOrientation()); // This is needed so SaveStayPosition() will get the proper coords.

 }


 pet->ReplaceAllDynamicFlags(UNIT_DYNFLAG_NONE);

 pet->RemoveUnitFlag(UNIT_FLAG_SKINNABLE);

 pet->setDeathState(ALIVE);

 pet->ClearUnitState(UNIT_STATE_ALL_ERASABLE);

 pet->SetHealth(pet->CountPctFromMaxHealth(damage));


 // Reset things for when the AI to takes over

 CharmInfo *ci = pet->GetCharmInfo();

 if (ci)

 {

 // In case the pet was at stay, we don't want it running back

 ci->SaveStayPosition();

 ci->SetIsAtStay(ci->HasCommandState(COMMAND_STAY));


 ci->SetIsFollowing(false);

 ci->SetIsCommandAttack(false);

 ci->SetIsCommandFollow(false);

 ci->SetIsReturning(false);

 }


 pet->SavePetToDB(PET_SAVE_AS_CURRENT);

}


void Spell::EffectDestroyAllTotems()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 int32 mana = 0;

 for (uint8 slot = SUMMON_SLOT_TOTEM; slot < MAX_TOTEM_SLOT; ++slot)

 {

 if (!unitCaster->m_SummonSlot[slot])

 continue;


 Creature* totem = unitCaster->GetMap()->GetCreature(unitCaster->m_SummonSlot[slot]);

 if (totem && totem->IsTotem())

 {

 uint32 spell_id = totem->m_unitData->CreatedBySpell;

 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell_id, GetCastDifficulty());

 if (spellInfo)

 {

 std::vector<SpellPowerCost> costs = spellInfo->CalcPowerCost(unitCaster, spellInfo->GetSchoolMask());

 auto m = std::find_if(costs.begin(), costs.end(), [](SpellPowerCost const& cost) { return cost.Power == POWER_MANA; });

 if (m != costs.end())

 mana += m->Amount;

 }


 totem->ToTotem()->UnSummon();

 }

 }


 ApplyPct(mana, damage);


 if (mana)

 {

 CastSpellExtraArgs args(TRIGGERED_FULL_MASK);

 args.SetTriggeringSpell(this);

 args.AddSpellMod(SPELLVALUE_BASE_POINT0, mana);

 unitCaster->CastSpell(unitCaster, 39104, args);

 }

}


void Spell::EffectDurabilityDamage()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 int32 slot = effectInfo->MiscValue;


 // -1 means all player equipped items and -2 all items

 if (slot < 0)

 {

 unitTarget->ToPlayer()->DurabilityPointsLossAll(damage, (slot < -1));

 ExecuteLogEffectDurabilityDamage(SpellEffectName(effectInfo->Effect), unitTarget, -1, -1);

 return;

 }


 // invalid slot value

 if (slot >= INVENTORY_SLOT_BAG_END)

 return;


 if (Item* item = unitTarget->ToPlayer()->GetItemByPos(INVENTORY_SLOT_BAG_0, slot))

 {

 unitTarget->ToPlayer()->DurabilityPointsLoss(item, damage);

 ExecuteLogEffectDurabilityDamage(SpellEffectName(effectInfo->Effect), unitTarget, item->GetEntry(), slot);

 }

}


void Spell::EffectDurabilityDamagePCT()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 int32 slot = effectInfo->MiscValue;


 // FIXME: some spells effects have value -1/-2

 // Possibly its mean -1 all player equipped items and -2 all items

 if (slot < 0)

 {

 unitTarget->ToPlayer()->DurabilityLossAll(float(damage) / 100.0f, (slot < -1));

 return;

 }


 // invalid slot value

 if (slot >= INVENTORY_SLOT_BAG_END)

 return;


 if (damage <= 0)

 return;


 if (Item* item = unitTarget->ToPlayer()->GetItemByPos(INVENTORY_SLOT_BAG_0, slot))

 unitTarget->ToPlayer()->DurabilityLoss(item, float(damage) / 100.0f);

}


void Spell::EffectModifyThreatPercent()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster || !unitTarget)

 return;


 unitTarget->GetThreatManager().ModifyThreatByPercent(unitCaster, damage);

}


void Spell::EffectTransmitted()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 uint32 name_id = effectInfo->MiscValue;

 Unit::AuraEffectList const& overrideSummonedGameObjects = unitCaster->GetAuraEffectsByType(SPELL_AURA_OVERRIDE_SUMMONED_OBJECT);

 for (AuraEffect const* aurEff : overrideSummonedGameObjects)

 {

 if (uint32(aurEff->GetMiscValue()) == name_id)

 {

 name_id = uint32(aurEff->GetMiscValueB());

 break;

 }

 }


 GameObjectTemplate const* goinfo = sObjectMgr->GetGameObjectTemplate(name_id);

 if (!goinfo)

 {

 TC_LOG_ERROR("sql.sql", "Gameobject (Entry: {}) does not exist and is not created by spell (ID: {}) cast.", name_id, m_spellInfo->Id);

 return;

 }


 float fx, fy, fz, fo;


 if (m_targets.HasDst())

 destTarget->GetPosition(fx, fy, fz, fo);

 //FIXME: this can be better check for most objects but still hack

 else if (effectInfo->HasRadius(SpellTargetIndex::TargetA) && m_spellInfo->Speed == 0)

 {

 float dis = effectInfo->CalcRadius(unitCaster);

 unitCaster->GetClosePoint(fx, fy, fz, DEFAULT_PLAYER_BOUNDING_RADIUS, dis);

 fo = unitCaster->GetOrientation();

 }

 else

 {

 //GO is always friendly to it's creator, get range for friends

 float min_dis = m_spellInfo->GetMinRange(true);

 float max_dis = m_spellInfo->GetMaxRange(true);

 float dis = rand_norm() * (max_dis - min_dis) + min_dis;


 unitCaster->GetClosePoint(fx, fy, fz, DEFAULT_PLAYER_BOUNDING_RADIUS, dis);

 fo = unitCaster->GetOrientation();

 }


 Map* cMap = unitCaster->GetMap();

 // if gameobject is summoning object, it should be spawned right on caster's position

 if (goinfo->type == GAMEOBJECT_TYPE_RITUAL)

 unitCaster->GetPosition(fx, fy, fz, fo);


 Position pos = { fx, fy, fz, fo };

 QuaternionData rot = QuaternionData::fromEulerAnglesZYX(fo, 0.f, 0.f);


 GameObject* go = GameObject::CreateGameObject(name_id, cMap, pos, rot, 255, GO_STATE_READY);

 if (!go)

 return;


 PhasingHandler::InheritPhaseShift(go, m_caster);

 int32 duration = m_spellInfo->CalcDuration(m_caster);


 switch (goinfo->type)

 {

 case GAMEOBJECT_TYPE_FISHINGNODE:

 {

 go->SetFaction(unitCaster->GetFaction());

 ObjectGuid bobberGuid = go->GetGUID();

 // client requires fishing bobber guid in channel object slot 0 to be usable

 unitCaster->SetChannelObject(0, bobberGuid);

 unitCaster->AddGameObject(go); // will removed at spell cancel


 // end time of range when possible catch fish (FISHING_BOBBER_READY_TIME..GetDuration(m_spellInfo))

 // start time == fish-FISHING_BOBBER_READY_TIME (0..GetDuration(m_spellInfo)-FISHING_BOBBER_READY_TIME)

 int32 lastSec = 0;

 switch (urand(0, 2))

 {

 case 0: lastSec = 3; break;

 case 1: lastSec = 7; break;

 case 2: lastSec = 13; break;

 }


 // Duration of the fishing bobber can't be higher than the Fishing channeling duration

 duration = std::min(duration, duration - lastSec*IN_MILLISECONDS + FISHING_BOBBER_READY_TIME*IN_MILLISECONDS);

 break;

 }

 case GAMEOBJECT_TYPE_RITUAL:

 {

 if (unitCaster->GetTypeId() == TYPEID_PLAYER)

 {

 go->AddUniqueUse(unitCaster->ToPlayer());

 unitCaster->AddGameObject(go); // will be removed at spell cancel

 }

 break;

 }

 case GAMEOBJECT_TYPE_DUEL_ARBITER: // 52991

 unitCaster->AddGameObject(go);

 break;

 case GAMEOBJECT_TYPE_FISHINGHOLE:

 case GAMEOBJECT_TYPE_CHEST:

 default:

 break;

 }


 go->SetRespawnTime(duration > 0 ? duration/IN_MILLISECONDS : 0);


 go->SetOwnerGUID(unitCaster->GetGUID());


 //go->SetLevel(unitCaster->getLevel());

 go->SetSpellId(m_spellInfo->Id);


 ExecuteLogEffectSummonObject(SpellEffectName(effectInfo->Effect), go);


 TC_LOG_DEBUG("spells", "AddObject at SpellEfects.cpp EffectTransmitted");

 //unitCaster->AddGameObject(go);

 //m_ObjToDel.push_back(go);


 cMap->AddToMap(go);


 if (GameObject* linkedTrap = go->GetLinkedTrap())

 {

 PhasingHandler::InheritPhaseShift(linkedTrap, m_caster);


 linkedTrap->SetRespawnTime(duration > 0 ? duration / IN_MILLISECONDS : 0);

 //linkedTrap->SetLevel(unitCaster->getLevel());

 linkedTrap->SetSpellId(m_spellInfo->Id);

 linkedTrap->SetOwnerGUID(unitCaster->GetGUID());


 ExecuteLogEffectSummonObject(SpellEffectName(effectInfo->Effect), linkedTrap);

 }

}


void Spell::EffectProspecting()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Player* player = m_caster->ToPlayer();

 if (!player)

 return;


 if (!itemTarget || !itemTarget->GetTemplate()->HasFlag(ITEM_FLAG_IS_PROSPECTABLE))

 return;


 if (itemTarget->GetCount() < 5)

 return;


 if (sWorld->getBoolConfig(CONFIG_SKILL_PROSPECTING))

 {

 uint32 SkillValue = player->GetPureSkillValue(SKILL_JEWELCRAFTING);

 uint32 reqSkillValue = itemTarget->GetTemplate()->GetRequiredSkillRank();

 player->UpdateGatherSkill(SKILL_JEWELCRAFTING, SkillValue, reqSkillValue);

 }


 itemTarget->m_loot.reset(new Loot(player->GetMap(), itemTarget->GetGUID(), LOOT_PROSPECTING, nullptr));

 itemTarget->m_loot->FillLoot(itemTarget->GetEntry(), LootTemplates_Prospecting, player, true);

 player->SendLoot(*itemTarget->m_loot);

}


void Spell::EffectMilling()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Player* player = m_caster->ToPlayer();

 if (!player)

 return;


 if (!itemTarget || !itemTarget->GetTemplate()->HasFlag(ITEM_FLAG_IS_MILLABLE))

 return;


 if (itemTarget->GetCount() < 5)

 return;


 if (sWorld->getBoolConfig(CONFIG_SKILL_MILLING))

 {

 uint32 SkillValue = player->GetPureSkillValue(SKILL_INSCRIPTION);

 uint32 reqSkillValue = itemTarget->GetTemplate()->GetRequiredSkillRank();

 player->UpdateGatherSkill(SKILL_INSCRIPTION, SkillValue, reqSkillValue);

 }


 itemTarget->m_loot.reset(new Loot(player->GetMap(), itemTarget->GetGUID(), LOOT_MILLING, nullptr));

 itemTarget->m_loot->FillLoot(itemTarget->GetEntry(), LootTemplates_Milling, player, true);

 player->SendLoot(*itemTarget->m_loot);

}


void Spell::EffectSkill()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 Player* playerTarget = Object::ToPlayer(GetUnitCasterForEffectHandlers());

 if (!playerTarget)

 return;


 if (damage < 1)

 return;


 uint32 skillid = effectInfo->MiscValue;

 if (playerTarget->GetSkillStep(skillid) >= damage)

 return;


 SkillRaceClassInfoEntry const* rcEntry = sDB2Manager.GetSkillRaceClassInfo(skillid, playerTarget->GetRace(), playerTarget->GetClass());

 if (!rcEntry)

 return;


 SkillTiersEntry const* tier = sObjectMgr->GetSkillTier(rcEntry->SkillTierID);

 if (!tier)

 return;


 uint16 skillval = std::max<uint16>(1, playerTarget->GetPureSkillValue(skillid));

 uint16 maxSkillVal = tier->GetValueForTierIndex(damage - 1);


 if (rcEntry->Flags & SKILL_FLAG_ALWAYS_MAX_VALUE)

 skillval = maxSkillVal;


 playerTarget->SetSkill(skillid, damage, skillval, maxSkillVal);

}


void Spell::EffectSpiritHeal()

{

 Unit* caster = GetCaster()->ToUnit();

 if (effectHandleMode == SPELL_EFFECT_HANDLE_HIT)

 caster->CastSpell(nullptr, SPELL_RESURRECTION_VISUAL, true);


 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (Player* playerTarget = unitTarget->ToPlayer())

 {

 if (!playerTarget->IsInWorld())

 return;


 // skip if player does not want to live

 if (!playerTarget->CanAcceptAreaSpiritHealFrom(caster))

 return;


 playerTarget->ResurrectPlayer(1.0f);

 playerTarget->CastSpell(playerTarget, SPELL_PET_SUMMONED, true);

 playerTarget->CastSpell(playerTarget, SPELL_SPIRIT_HEAL_MANA, true);

 playerTarget->SpawnCorpseBones(false);

 }

}


// remove insignia spell effect

void Spell::EffectSkinPlayerCorpse()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 TC_LOG_DEBUG("spells", "Effect: SkinPlayerCorpse");


 Player* player = m_caster->ToPlayer();


 Player* target = nullptr;

 if (unitTarget)

 target = unitTarget->ToPlayer();

 else if (m_corpseTarget)

 target = ObjectAccessor::FindPlayer(m_corpseTarget->GetOwnerGUID());


 if (!player || !target || target->IsAlive())

 return;


 target->RemovedInsignia(player);

}


void Spell::EffectStealBeneficialBuff()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 TC_LOG_DEBUG("spells", "Effect: StealBeneficialBuff");


 if (!unitTarget || unitTarget == m_caster) // can't steal from self

 return;


 DispelChargesList stealList;


 // Create dispel mask by dispel type

 uint32 dispelMask = SpellInfo::GetDispelMask(DispelType(effectInfo->MiscValue));

 Unit::AuraMap const& auras = unitTarget->GetOwnedAuras();

 for (Unit::AuraMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)

 {

 Aura* aura = itr->second;

 AuraApplication const* aurApp = aura->GetApplicationOfTarget(unitTarget->GetGUID());

 if (!aurApp)

 continue;


 if ((aura->GetSpellInfo()->GetDispelMask()) & dispelMask)

 {

 // Need check for passive? this

 if (!aurApp->IsPositive() || aura->IsPassive() || aura->GetSpellInfo()->HasAttribute(SPELL_ATTR4_CANNOT_BE_STOLEN))

 continue;


 // 2.4.3 Patch Notes: "Dispel effects will no longer attempt to remove effects that have 100% dispel resistance."

 int32 chance = aura->CalcDispelChance(unitTarget, !unitTarget->IsFriendlyTo(m_caster));

 if (!chance)

 continue;


 // The charges / stack amounts don't count towards the total number of auras that can be dispelled.

 // Ie: A dispel on a target with 5 stacks of Winters Chill and a Polymorph has 1 / (1 + 1) -> 50% chance to dispell

 // Polymorph instead of 1 / (5 + 1) -> 16%.

 bool dispelCharges = aura->GetSpellInfo()->HasAttribute(SPELL_ATTR7_DISPEL_REMOVES_CHARGES);

 uint8 charges = dispelCharges ? aura->GetCharges() : aura->GetStackAmount();

 if (charges > 0)

 stealList.emplace_back(aura, chance, charges);

 }

 }


 if (stealList.empty())

 return;


 size_t remaining = stealList.size();


 // Ok if exist some buffs for dispel try dispel it

 std::vector<std::tuple<uint32, ObjectGuid, int32>> successList;

 successList.reserve(damage);


 WorldPackets::Spells::DispelFailed dispelFailed;

 dispelFailed.CasterGUID = m_caster->GetGUID();

 dispelFailed.VictimGUID = unitTarget->GetGUID();

 dispelFailed.SpellID = m_spellInfo->Id;


 // dispel N = damage buffs (or while exist buffs for dispel)

 for (int32 count = 0; count < damage && remaining > 0;)

 {

 // Random select buff for dispel

 DispelChargesList::iterator itr = stealList.begin();

 std::advance(itr, urand(0, remaining - 1));


 if (itr->RollDispel())

 {

 uint8 stolenCharges = 1;

 if (itr->GetAura()->GetSpellInfo()->HasAttribute(SPELL_ATTR1_DISPEL_ALL_STACKS))

 stolenCharges = itr->GetDispelCharges();


 successList.emplace_back(itr->GetAura()->GetId(), itr->GetAura()->GetCasterGUID(), int32(stolenCharges));

 if (!itr->DecrementCharge(stolenCharges))

 {

 --remaining;

 std::swap(*itr, stealList[remaining]);

 }

 }

 else

 {

 dispelFailed.FailedSpells.push_back(int32(itr->GetAura()->GetId()));

 }

 ++count;

 }


 if (!dispelFailed.FailedSpells.empty())

 m_caster->SendMessageToSet(dispelFailed.Write(), true);


 if (successList.empty())

 return;


 WorldPackets::CombatLog::SpellDispellLog spellDispellLog;

 spellDispellLog.IsBreak = false; // TODO: use me

 spellDispellLog.IsSteal = true;


 spellDispellLog.TargetGUID = unitTarget->GetGUID();

 spellDispellLog.CasterGUID = m_caster->GetGUID();

 spellDispellLog.DispelledBySpellID = m_spellInfo->Id;


 for (auto const& [spellId, auraCaster, stolenCharges] : successList)

 {

 WorldPackets::CombatLog::SpellDispellData dispellData;

 dispellData.SpellID = spellId;

 dispellData.Harmful = false; // TODO: use me


 unitTarget->RemoveAurasDueToSpellBySteal(spellId, auraCaster, m_caster, stolenCharges);


 spellDispellLog.DispellData.emplace_back(dispellData);

 }


 m_caster->SendMessageToSet(spellDispellLog.Write(), true);


 m_hitMask |= PROC_HIT_DISPEL;

}


void Spell::EffectKillCreditPersonal()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 unitTarget->ToPlayer()->KilledMonsterCredit(effectInfo->MiscValue);

}


void Spell::EffectKillCredit()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 if (int32 creatureEntry = effectInfo->MiscValue)

 unitTarget->ToPlayer()->RewardPlayerAndGroupAtEvent(creatureEntry, unitTarget);

}


void Spell::EffectQuestFail()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 unitTarget->ToPlayer()->FailQuest(effectInfo->MiscValue);

}


void Spell::EffectQuestStart()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 Player* player = unitTarget->ToPlayer();

 if (!player)

 return;


 if (Quest const* quest = sObjectMgr->GetQuestTemplate(effectInfo->MiscValue))

 {

 if (!player->CanTakeQuest(quest, false))

 return;


 if (quest->IsAutoAccept() && player->CanAddQuest(quest, false))

 {

 player->AddQuestAndCheckCompletion(quest, player);

 player->PlayerTalkClass->SendQuestGiverQuestDetails(quest, player->GetGUID(), true, true);

 }

 else

 player->PlayerTalkClass->SendQuestGiverQuestDetails(quest, player->GetGUID(), true, false);

 }

}


void Spell::EffectCreateTamedPet()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER || !unitTarget->GetPetGUID().IsEmpty() || unitTarget->GetClass() != CLASS_HUNTER)

 return;


 uint32 creatureEntry = effectInfo->MiscValue;

 Pet* pet = unitTarget->CreateTamedPetFrom(creatureEntry, m_spellInfo->Id);

 if (!pet)

 return;


 // relocate

 float px, py, pz;

 unitTarget->GetClosePoint(px, py, pz, pet->GetCombatReach(), PET_FOLLOW_DIST, pet->GetFollowAngle());

 pet->Relocate(px, py, pz, unitTarget->GetOrientation());


 // add to world

 pet->GetMap()->AddToMap(pet->ToCreature());


 // unitTarget has pet now

 unitTarget->SetMinion(pet, true);


 if (unitTarget->GetTypeId() == TYPEID_PLAYER)

 {

 pet->SavePetToDB(PET_SAVE_AS_CURRENT);

 unitTarget->ToPlayer()->PetSpellInitialize();

 }

}


void Spell::EffectDiscoverTaxi()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;

 uint32 nodeid = effectInfo->MiscValue;

 if (sTaxiNodesStore.LookupEntry(nodeid))

 unitTarget->ToPlayer()->GetSession()->SendDiscoverNewTaxiNode(nodeid);

}


void Spell::EffectTitanGrip()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 if (m_caster->GetTypeId() == TYPEID_PLAYER)

 m_caster->ToPlayer()->SetCanTitanGrip(true, uint32(effectInfo->MiscValue));

}


void Spell::EffectRedirectThreat()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 if (unitTarget)

 unitCaster->GetThreatManager().RegisterRedirectThreat(m_spellInfo->Id, unitTarget->GetGUID(), uint32(damage));

}


void Spell::EffectGameObjectDamage()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!gameObjTarget)

 return;


 FactionTemplateEntry const* casterFaction = m_caster->GetFactionTemplateEntry();

 FactionTemplateEntry const* targetFaction = sFactionTemplateStore.LookupEntry(gameObjTarget->GetFaction());

 // Do not allow to damage GO's of friendly factions (ie: Wintergrasp Walls/Ulduar Storm Beacons)

 if (!targetFaction || (casterFaction && !casterFaction->IsFriendlyTo(targetFaction)))

 gameObjTarget->ModifyHealth(-damage, m_caster, GetSpellInfo()->Id);

}


void Spell::EffectGameObjectRepair()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!gameObjTarget)

 return;


 gameObjTarget->ModifyHealth(damage, m_caster);

}


void Spell::EffectGameObjectSetDestructionState()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!gameObjTarget)

 return;


 gameObjTarget->SetDestructibleState(GameObjectDestructibleState(effectInfo->MiscValue), m_caster, true);

}


void Spell::SummonGuardian(SpellEffectInfo const* effect, uint32 entry, SummonPropertiesEntry const* properties, uint32 numGuardians, ObjectGuid privateObjectOwner)

{

 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 if (unitCaster->IsTotem())

 unitCaster = unitCaster->ToTotem()->GetOwner();


 // in another case summon new

 float radius = 5.0f;

 Milliseconds duration = Milliseconds(m_spellInfo->CalcDuration(m_originalCaster));


 //TempSummonType summonType = (duration == 0) ? TEMPSUMMON_DEAD_DESPAWN : TEMPSUMMON_TIMED_DESPAWN;

 Map* map = unitCaster->GetMap();

 for (uint32 count = 0; count < numGuardians; ++count)

 {

 Position pos;

 if (count == 0)

 pos = destTarget->GetPosition();

 else

 // randomize position for multiple summons

 pos = unitCaster->GetRandomPoint(*destTarget, radius);


 TempSummon* summon = map->SummonCreature(entry, pos, properties, duration, unitCaster, m_spellInfo->Id, 0, privateObjectOwner);

 if (!summon)

 return;


 if (summon->IsGuardian())

 {

 // level of pet summoned using engineering item based at engineering skill level

 if (m_CastItem && unitCaster->GetTypeId() == TYPEID_PLAYER)

 if (ItemTemplate const* proto = m_CastItem->GetTemplate())

 if (proto->GetRequiredSkill() == SKILL_ENGINEERING)

 if (uint16 skill202 = unitCaster->ToPlayer()->GetSkillValue(SKILL_ENGINEERING))

 static_cast<Guardian*>(summon)->InitStatsForLevel(skill202 / 5);

 }


 if (summon->HasUnitTypeMask(UNIT_MASK_MINION) && m_targets.HasDst())

 ((Minion*)summon)->SetFollowAngle(unitCaster->GetAbsoluteAngle(summon));


 if (summon->GetEntry() == 27893)

 {

 UF::VisibleItem const& weapon = m_caster->ToPlayer()->m_playerData->VisibleItems[EQUIPMENT_SLOT_MAINHAND];

 if (weapon.ItemID)

 {

 summon->SetDisplayId(11686); // modelid2

 summon->SetVirtualItem(0, weapon.ItemID, weapon.ItemAppearanceModID, weapon.ItemVisual);

 }

 else

 summon->SetDisplayId(1126); // modelid1

 }


 ExecuteLogEffectSummonObject(SpellEffectName(effect->Effect), summon);

 }

}


void Spell::EffectRenamePet()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_UNIT ||

 !unitTarget->IsPet() || ((Pet*)unitTarget)->getPetType() != HUNTER_PET)

 return;


 unitTarget->SetPetFlag(UNIT_PET_FLAG_CAN_BE_RENAMED);

}


void Spell::EffectPlayMusic()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 uint32 soundid = effectInfo->MiscValue;


 if (!sSoundKitStore.LookupEntry(soundid))

 {

 TC_LOG_ERROR("spells", "EffectPlayMusic: Sound (Id: {}) does not exist in spell {}.", soundid, m_spellInfo->Id);

 return;

 }


 unitTarget->ToPlayer()->SendDirectMessage(WorldPackets::Misc::PlayMusic(soundid).Write());

}


void Spell::EffectActivateSpec()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 Player* player = unitTarget->ToPlayer();

 uint32 specID = m_misc.SpecializationId;

 ChrSpecializationEntry const* spec = sChrSpecializationStore.AssertEntry(specID);


 // Safety checks done in Spell::CheckCast

 if (!spec->IsPetSpecialization())

 player->ActivateTalentGroup(spec);

 else

 player->GetPet()->SetSpecialization(specID);

}


void Spell::EffectPlaySound()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 Player* player = unitTarget->ToPlayer();

 if (!player)

 return;


 switch (m_spellInfo->Id)

 {

 case 91604: // Restricted Flight Area

 player->GetSession()->SendNotification(LANG_ZONE_NOFLYZONE);

 break;

 default:

 break;

 }


 uint32 soundId = effectInfo->MiscValue;


 if (!sSoundKitStore.LookupEntry(soundId))

 {

 TC_LOG_ERROR("spells", "EffectPlaySound: Sound (Id: {}) does not exist in spell {}.", soundId, m_spellInfo->Id);

 return;

 }


 player->PlayDirectSound(soundId, player);

}


void Spell::EffectRemoveAura()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;

 // there may be need of specifying casterguid of removed auras

 unitTarget->RemoveAurasDueToSpell(effectInfo->TriggerSpell);

}


void Spell::EffectDamageFromMaxHealthPCT()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 m_damage += unitTarget->CountPctFromMaxHealth(damage);

}


void Spell::EffectGiveCurrency()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 if (!sCurrencyTypesStore.LookupEntry(effectInfo->MiscValue))

 return;


 unitTarget->ToPlayer()->ModifyCurrency(effectInfo->MiscValue, damage, CurrencyGainSource::Spell, CurrencyDestroyReason::Spell);

}


void Spell::EffectCastButtons()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 Player* player = m_caster->ToPlayer();

 if (!player)

 return;


 uint32 button_id = effectInfo->MiscValue + 132;

 uint32 n_buttons = effectInfo->MiscValueB;


 for (; n_buttons; --n_buttons, ++button_id)

 {

 ActionButton const* ab = player->GetActionButton(button_id);

 if (!ab || ab->GetType() != ACTION_BUTTON_SPELL)

 continue;


 uint32 spell_id = ab->GetAction();

 if (!spell_id)

 continue;


 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell_id, GetCastDifficulty());

 if (!spellInfo)

 continue;


 if (!player->HasSpell(spell_id) || player->GetSpellHistory()->HasCooldown(spell_id))

 continue;


 if (!spellInfo->HasAttribute(SPELL_ATTR7_CAN_BE_MULTI_CAST))

 continue;


 CastSpellExtraArgs args;

 args.TriggerFlags = TRIGGERED_IGNORE_GCD | TRIGGERED_IGNORE_CAST_IN_PROGRESS | TRIGGERED_CAST_DIRECTLY | TRIGGERED_DONT_REPORT_CAST_ERROR;

 args.OriginalCastId = m_castId;

 args.CastDifficulty = GetCastDifficulty();

 m_caster->CastSpell(m_caster, spellInfo->Id, args);

 }

}


void Spell::EffectRechargeItem()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 Player* player = unitTarget->ToPlayer();

 if (!player)

 return;


 if (Item* item = player->GetItemByEntry(effectInfo->ItemType))

 {

 for (ItemEffectEntry const* itemEffect : item->GetEffects())

 if (itemEffect->LegacySlotIndex <= item->m_itemData->SpellCharges.size())

 item->SetSpellCharges(itemEffect->LegacySlotIndex, itemEffect->Charges);


 item->SetState(ITEM_CHANGED, player);

 }

}


void Spell::EffectBind()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 Player* player = unitTarget->ToPlayer();


 WorldLocation homeLoc;

 uint32 areaId = player->GetAreaId();


 if (effectInfo->MiscValue)

 areaId = effectInfo->MiscValue;


 if (m_targets.HasDst())

 homeLoc.WorldRelocate(*destTarget);

 else

 homeLoc = player->GetWorldLocation();


 player->SetHomebind(homeLoc, areaId);

 player->SendBindPointUpdate();


 TC_LOG_DEBUG("spells", "EffectBind: New homebind X: {}, Y: {}, Z: {} O: {}, MapId: {}, AreaId: {}",

 homeLoc.GetPositionX(), homeLoc.GetPositionY(), homeLoc.GetPositionZ(), homeLoc.GetOrientation(), homeLoc.GetMapId(), areaId);


 // zone update

 player->SendPlayerBound(m_caster->GetGUID(), areaId);

}


void Spell::EffectTeleportToReturnPoint()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (Player* player = unitTarget->ToPlayer())

 if (WorldLocation const* dest = player->GetStoredAuraTeleportLocation(effectInfo->MiscValue))

 player->TeleportTo(*dest, unitTarget == m_caster ? TELE_TO_SPELL | TELE_TO_NOT_LEAVE_COMBAT : TELE_TO_NONE);

}


void Spell::EffectIncreaseCurrencyCap()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (damage <= 0)

 return;


 if (Player* player = unitTarget->ToPlayer())

 player->IncreaseCurrencyCap(effectInfo->MiscValue, damage);

}


void Spell::EffectSummonRaFFriend()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (m_caster->GetTypeId() != TYPEID_PLAYER || !unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 m_caster->CastSpell(unitTarget, effectInfo->TriggerSpell, this);

}


void Spell::EffectUnlockGuildVaultTab()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 // Safety checks done in Spell::CheckCast

 Player* caster = m_caster->ToPlayer();

 if (Guild* guild = caster->GetGuild())

 guild->HandleBuyBankTab(caster->GetSession(), damage - 1); // Bank tabs start at zero internally

}


void Spell::EffectSummonPersonalGameObject()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)

 return;


 uint32 goId = effectInfo->MiscValue;

 if (!goId)

 return;


 float x, y, z, o;

 if (m_targets.HasDst())

 destTarget->GetPosition(x, y, z, o);

 else

 {

 m_caster->GetClosePoint(x, y, z, DEFAULT_PLAYER_BOUNDING_RADIUS);

 o = m_caster->GetOrientation();

 }


 Map* map = m_caster->GetMap();

 Position pos = Position(x, y, z, o);

 QuaternionData rot = QuaternionData::fromEulerAnglesZYX(o, 0.f, 0.f);

 GameObject* go = GameObject::CreateGameObject(goId, map, pos, rot, 255, GO_STATE_READY);


 if (!go)

 {

 TC_LOG_WARN("spells", "SpellEffect Failed to summon personal gameobject. SpellId {}, effect {}", m_spellInfo->Id, effectInfo->EffectIndex);

 return;

 }


 PhasingHandler::InheritPhaseShift(go, m_caster);


 int32 duration = m_spellInfo->CalcDuration(m_caster);


 go->SetRespawnTime(duration > 0 ? duration / IN_MILLISECONDS : 0);

 go->SetSpellId(m_spellInfo->Id);

 go->SetPrivateObjectOwner(m_caster->GetGUID());


 ExecuteLogEffectSummonObject(SpellEffectName(effectInfo->Effect), go);


 map->AddToMap(go);


 if (GameObject* linkedTrap = go->GetLinkedTrap())

 {

 PhasingHandler::InheritPhaseShift(linkedTrap, m_caster);


 linkedTrap->SetRespawnTime(duration > 0 ? duration / IN_MILLISECONDS : 0);

 linkedTrap->SetSpellId(m_spellInfo->Id);


 ExecuteLogEffectSummonObject(SpellEffectName(effectInfo->Effect), linkedTrap);

 }

}


void Spell::EffectResurrectWithAura()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || !unitTarget->IsInWorld())

 return;


 Player* target = unitTarget->ToPlayer();

 if (!target)

 return;


 if (unitTarget->IsAlive())

 return;


 if (target->IsResurrectRequested()) // already have one active request

 return;


 uint32 health = target->CountPctFromMaxHealth(damage);

 uint32 mana = CalculatePct(target->GetMaxPower(POWER_MANA), damage);

 uint32 resurrectAura = 0;

 if (sSpellMgr->GetSpellInfo(effectInfo->TriggerSpell, DIFFICULTY_NONE))

 resurrectAura = effectInfo->TriggerSpell;


 if (resurrectAura && target->HasAura(resurrectAura))

 return;


 ExecuteLogEffectResurrect(SpellEffectName(effectInfo->Effect), target);

 target->SetResurrectRequestData(m_caster, health, mana, resurrectAura);

 SendResurrectRequest(target);

}


void Spell::EffectCreateAreaTrigger()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster || !m_targets.HasDst())

 return;


 AreaTriggerCreatePropertiesId createPropertiesId = { uint32(effectInfo->MiscValue), false };

 int32 duration = GetSpellInfo()->CalcDuration(GetCaster());


 AreaTrigger::CreateAreaTrigger(createPropertiesId, destTarget->GetPosition(), duration, unitCaster, nullptr, m_SpellVisual, GetSpellInfo(), this);

}


void Spell::EffectRemoveTalent()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 TalentEntry const* talent = sTalentStore.LookupEntry(m_misc.TalentId);

 if (!talent)

 return;


 Player* player = unitTarget ? unitTarget->ToPlayer() : nullptr;

 if (!player)

 return;


 player->RemoveTalent(talent);

 player->SendTalentsInfoData();

}


void Spell::EffectDestroyItem()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 Player* player = unitTarget->ToPlayer();

 if (Item* item = player->GetItemByEntry(effectInfo->ItemType))

 player->DestroyItem(item->GetBagSlot(), item->GetSlot(), true);

}


void Spell::EffectLearnGarrisonBuilding()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 if (Garrison* garrison = unitTarget->ToPlayer()->GetGarrison())

 garrison->LearnBlueprint(effectInfo->MiscValue);

}


void Spell::EffectRemoveAuraBySpellLabel()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 unitTarget->RemoveAppliedAuras([&](AuraApplication const* aurApp)

 {

 return aurApp->GetBase()->GetSpellInfo()->HasLabel(effectInfo->MiscValue);

 });

}


void Spell::EffectCreateGarrison()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 unitTarget->ToPlayer()->CreateGarrison(effectInfo->MiscValue);

}


void Spell::EffectCreateConversation()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster || !m_targets.HasDst())

 return;


 Conversation::CreateConversation(effectInfo->MiscValue, unitCaster, destTarget->GetPosition(), ObjectGuid::Empty, GetSpellInfo());

}


void Spell::EffectCancelConversation()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget)

 return;


 std::vector<WorldObject*> objs;

 Trinity::ObjectEntryAndPrivateOwnerIfExistsCheck check(unitTarget->GetGUID(), effectInfo->MiscValue);

 Trinity::WorldObjectListSearcher<Trinity::ObjectEntryAndPrivateOwnerIfExistsCheck> checker(unitTarget, objs, check, GRID_MAP_TYPE_MASK_CONVERSATION);

 Cell::VisitGridObjects(unitTarget, checker, 100.0f);


 for (WorldObject* obj : objs)

 {

 if (Conversation* convo = obj->ToConversation())

 convo->Remove();

 }

}


void Spell::EffectAddGarrisonFollower()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 if (Garrison* garrison = unitTarget->ToPlayer()->GetGarrison())

 garrison->AddFollower(effectInfo->MiscValue);

}


void Spell::EffectCreateHeirloomItem()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Player* player = m_caster->ToPlayer();

 if (!player)

 return;


 CollectionMgr* collectionMgr = player->GetSession()->GetCollectionMgr();

 if (!collectionMgr)

 return;


 std::vector<int32> bonusList;

 bonusList.push_back(collectionMgr->GetHeirloomBonus(m_misc.Raw.Data[0]));


 DoCreateItem(m_misc.Raw.Data[0], ItemContext::NONE, &bonusList);

 ExecuteLogEffectCreateItem(SpellEffectName(effectInfo->Effect), m_misc.Raw.Data[0]);

}


void Spell::EffectActivateGarrisonBuilding()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 if (Garrison* garrison = unitTarget->ToPlayer()->GetGarrison())

 garrison->ActivateBuilding(effectInfo->MiscValue);

}


void Spell::EffectGrantBattlePetLevel()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Player* playerCaster = m_caster->ToPlayer();

 if (!playerCaster)

 return;


 if (!unitTarget || !unitTarget->IsCreature())

 return;


 playerCaster->GetSession()->GetBattlePetMgr()->GrantBattlePetLevel(unitTarget->GetBattlePetCompanionGUID(), damage);

}


void Spell::EffectGiveExperience()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Player* playerTarget = Object::ToPlayer(unitTarget);

 if (!playerTarget)

 return;


 uint32 xp = Quest::XPValue(playerTarget, effectInfo->MiscValue, effectInfo->MiscValueB);

 playerTarget->GiveXP(xp, nullptr);

}


void Spell::EffectGiveRestedExperience()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Player* playerTarget = Object::ToPlayer(unitTarget);

 if (!playerTarget)

 return;


 // effect value is number of resting hours

 playerTarget->GetRestMgr().AddRestBonus(REST_TYPE_XP, damage * HOUR * playerTarget->GetRestMgr().CalcExtraPerSec(REST_TYPE_XP, 0.125f));

}


void Spell::EffectHealBattlePetPct()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 if (BattlePets::BattlePetMgr* battlePetMgr = unitTarget->ToPlayer()->GetSession()->GetBattlePetMgr())

 battlePetMgr->HealBattlePetsPct(damage);

}


void Spell::EffectEnableBattlePets()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || !unitTarget->IsPlayer())

 return;


 Player* player = unitTarget->ToPlayer();

 player->SetPlayerFlag(PLAYER_FLAGS_PET_BATTLES_UNLOCKED);

 player->GetSession()->GetBattlePetMgr()->UnlockSlot(BattlePets::BattlePetSlot::Slot0);

}


void Spell::EffectChangeBattlePetQuality()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Player* playerCaster = m_caster->ToPlayer();

 if (!playerCaster)

 return;


 if (!unitTarget || !unitTarget->IsCreature())

 return;


 auto qualityItr = std::lower_bound(sBattlePetBreedQualityStore.begin(), sBattlePetBreedQualityStore.end(), damage, [](BattlePetBreedQualityEntry const* a1, int32 selector)

 {

 return a1->MaxQualityRoll < selector;

 });


 BattlePets::BattlePetBreedQuality quality = BattlePets::BattlePetBreedQuality::Poor;

 if (qualityItr != sBattlePetBreedQualityStore.end())

 quality = BattlePets::BattlePetBreedQuality(qualityItr->QualityEnum);


 playerCaster->GetSession()->GetBattlePetMgr()->ChangeBattlePetQuality(unitTarget->GetBattlePetCompanionGUID(), quality);

}


void Spell::EffectLaunchQuestChoice()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || !unitTarget->IsPlayer())

 return;


 unitTarget->ToPlayer()->SendPlayerChoice(GetCaster()->GetGUID(), effectInfo->MiscValue);

}


void Spell::EffectUncageBattlePet()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 if (!m_CastItem || !m_caster || m_caster->GetTypeId() != TYPEID_PLAYER)

 return;


 uint32 speciesId = m_CastItem->GetModifier(ITEM_MODIFIER_BATTLE_PET_SPECIES_ID);

 uint16 breed = m_CastItem->GetModifier(ITEM_MODIFIER_BATTLE_PET_BREED_DATA) & 0xFFFFFF;

 uint8 quality = (m_CastItem->GetModifier(ITEM_MODIFIER_BATTLE_PET_BREED_DATA) >> 24) & 0xFF;

 uint16 level = m_CastItem->GetModifier(ITEM_MODIFIER_BATTLE_PET_LEVEL);

 uint32 displayId = m_CastItem->GetModifier(ITEM_MODIFIER_BATTLE_PET_DISPLAY_ID);


 BattlePetSpeciesEntry const* speciesEntry = sBattlePetSpeciesStore.LookupEntry(speciesId);

 if (!speciesEntry)

 return;


 Player* player = m_caster->ToPlayer();

 BattlePets::BattlePetMgr* battlePetMgr = player->GetSession()->GetBattlePetMgr();

 if (!battlePetMgr)

 return;


 if (battlePetMgr->GetMaxPetLevel() < level)

 {

 battlePetMgr->SendError(BattlePets::BattlePetError::TooHighLevelToUncage, speciesEntry->CreatureID);

 SendCastResult(SPELL_FAILED_CANT_ADD_BATTLE_PET);

 return;

 }


 if (battlePetMgr->HasMaxPetCount(speciesEntry, player->GetGUID()))

 {

 battlePetMgr->SendError(BattlePets::BattlePetError::CantHaveMorePetsOfType, speciesEntry->CreatureID);

 SendCastResult(SPELL_FAILED_CANT_ADD_BATTLE_PET);

 return;

 }


 battlePetMgr->AddPet(speciesId, displayId, breed, BattlePets::BattlePetBreedQuality(quality), level);


 player->SendPlaySpellVisual(player, BattlePets::SPELL_VISUAL_UNCAGE_PET, 0, 0, 0.f, false);


 player->DestroyItem(m_CastItem->GetBagSlot(), m_CastItem->GetSlot(), true);

 m_CastItem = nullptr;

}


void Spell::EffectUpgradeHeirloom()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 if (Player* player = m_caster->ToPlayer())

 if (CollectionMgr* collectionMgr = player->GetSession()->GetCollectionMgr())

 collectionMgr->UpgradeHeirloom(m_misc.Raw.Data[0], int32(m_castItemEntry));

}


void Spell::EffectApplyEnchantIllusion()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!itemTarget)

 return;


 Player* player = m_caster->ToPlayer();

 if (!player || player->GetGUID() != itemTarget->GetOwnerGUID())

 return;


 itemTarget->SetState(ITEM_CHANGED, player);

 itemTarget->SetModifier(ITEM_MODIFIER_ENCHANT_ILLUSION_ALL_SPECS, effectInfo->MiscValue);

 if (itemTarget->IsEquipped())

 player->SetVisibleItemSlot(itemTarget->GetSlot(), itemTarget);


 player->RemoveTradeableItem(itemTarget);

 itemTarget->ClearSoulboundTradeable(player);

}


void Spell::EffectUpdatePlayerPhase()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 PhasingHandler::OnConditionChange(unitTarget);

}


void Spell::EffectUpdateZoneAurasAndPhases()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 unitTarget->ToPlayer()->UpdateAreaDependentAuras(unitTarget->GetAreaId());

}


void Spell::EffectGiveArtifactPower()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)

 return;


 Player* playerCaster = m_caster->ToPlayer();

 if (!playerCaster)

 return;


 if (Aura* artifactAura = playerCaster->GetAura(ARTIFACTS_ALL_WEAPONS_GENERAL_WEAPON_EQUIPPED_PASSIVE))

 if (Item* artifact = playerCaster->GetItemByGuid(artifactAura->GetCastItemGUID()))

 artifact->GiveArtifactXp(damage, m_CastItem, uint32(effectInfo->MiscValue));

}


void Spell::EffectGiveArtifactPowerNoBonus()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 if (Aura* artifactAura = unitTarget->GetAura(ARTIFACTS_ALL_WEAPONS_GENERAL_WEAPON_EQUIPPED_PASSIVE))

 if (Item* artifact = unitTarget->ToPlayer()->GetItemByGuid(artifactAura->GetCastItemGUID()))

 artifact->GiveArtifactXp(damage, m_CastItem, 0);

}


void Spell::EffectPlaySceneScriptPackage()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 if (m_caster->GetTypeId() != TYPEID_PLAYER)

 return;


 m_caster->ToPlayer()->GetSceneMgr().PlaySceneByPackageId(effectInfo->MiscValue, SceneFlag::PlayerNonInteractablePhased, destTarget);

}


template<typename TargetInfo>

bool IsUnitTargetSceneObjectAura(Spell const* spell, TargetInfo const& target)

{

 if (target.TargetGUID != spell->GetCaster()->GetGUID())

 return false;


 for (SpellEffectInfo const& spellEffectInfo : spell->GetSpellInfo()->GetEffects())

 if (target.EffectMask & (1 << spellEffectInfo.EffectIndex) && spellEffectInfo.IsUnitOwnedAuraEffect())

 return true;


 return false;

}


void Spell::EffectCreateSceneObject()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster || !m_targets.HasDst())

 return;


 if (SceneObject* sceneObject = SceneObject::CreateSceneObject(effectInfo->MiscValue, unitCaster, destTarget->GetPosition(), ObjectGuid::Empty))

 {

 bool hasAuraTargetingCaster = std::find_if(m_UniqueTargetInfo.begin(), m_UniqueTargetInfo.end(), [this](TargetInfo const& target)

 {

 return IsUnitTargetSceneObjectAura(this, target);

 }) != m_UniqueTargetInfo.end();


 if (hasAuraTargetingCaster)

 sceneObject->SetCreatedBySpellCast(m_castId);

 }

}


void Spell::EffectCreatePrivateSceneObject()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster || !m_targets.HasDst())

 return;


 if (SceneObject* sceneObject = SceneObject::CreateSceneObject(effectInfo->MiscValue, unitCaster, destTarget->GetPosition(), unitCaster->GetGUID()))

 {

 bool hasAuraTargetingCaster = std::find_if(m_UniqueTargetInfo.begin(), m_UniqueTargetInfo.end(), [this](TargetInfo const& target)

 {

 return IsUnitTargetSceneObjectAura(this, target);

 }) != m_UniqueTargetInfo.end();


 if (hasAuraTargetingCaster)

 sceneObject->SetCreatedBySpellCast(m_castId);

 }

}


void Spell::EffectPlayScene()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

 return;


 if (m_caster->GetTypeId() != TYPEID_PLAYER)

 return;


 m_caster->ToPlayer()->GetSceneMgr().PlayScene(effectInfo->MiscValue, destTarget);

}


void Spell::EffectGiveHonor()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 WorldPackets::Combat::PvPCredit packet;

 packet.Honor = damage;

 packet.OriginalHonor = damage;


 Player* playerTarget = unitTarget->ToPlayer();

 playerTarget->AddHonorXP(damage);

 playerTarget->SendDirectMessage(packet.Write());

}


void Spell::EffectJumpCharge()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 if (unitCaster->IsInFlight())

 return;


 JumpChargeParams const* params = sObjectMgr->GetJumpChargeParams(effectInfo->MiscValue);

 if (!params)

 return;


 float speed = params->Speed;

 if (params->TreatSpeedAsMoveTimeSeconds)

 speed = unitCaster->GetExactDist(destTarget) / params->MoveTimeInSec;


 Optional<JumpArrivalCastArgs> arrivalCast;

 if (effectInfo->TriggerSpell)

 {

 arrivalCast.emplace();

 arrivalCast->SpellId = effectInfo->TriggerSpell;

 }


 Optional<Movement::SpellEffectExtraData> effectExtra;

 if (params->SpellVisualId || params->ProgressCurveId || params->ParabolicCurveId)

 {

 effectExtra.emplace();

 if (params->SpellVisualId)

 effectExtra->SpellVisualId = *params->SpellVisualId;


 if (params->ProgressCurveId)

 effectExtra->ProgressCurveId = *params->ProgressCurveId;


 if (params->ParabolicCurveId)

 effectExtra->ParabolicCurveId = *params->ParabolicCurveId;

 }


 unitCaster->GetMotionMaster()->MoveJumpWithGravity(*destTarget, speed, params->JumpGravity, EVENT_JUMP, false,

 arrivalCast ? &*arrivalCast : nullptr,

 effectExtra ? &*effectExtra : nullptr);

}


void Spell::EffectLearnTransmogSet()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 unitTarget->ToPlayer()->GetSession()->GetCollectionMgr()->AddTransmogSet(effectInfo->MiscValue);

}


void Spell::EffectRespecAzeriteEmpoweredItem()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 if (!itemTarget || !itemTarget->IsAzeriteEmpoweredItem())

 return;


 Player* owner = m_caster->ToPlayer();

 if (!owner)

 return;


 AzeriteEmpoweredItem* azeriteEmpoweredItem = itemTarget->ToAzeriteEmpoweredItem();

 owner->ModifyMoney(-azeriteEmpoweredItem->GetRespecCost());


 // reapply all item mods - item level change affects stats and auras

 if (azeriteEmpoweredItem->IsEquipped())

 owner->_ApplyItemMods(azeriteEmpoweredItem, azeriteEmpoweredItem->GetSlot(), false);


 azeriteEmpoweredItem->ClearSelectedAzeritePowers();


 if (azeriteEmpoweredItem->IsEquipped())

 owner->_ApplyItemMods(azeriteEmpoweredItem, azeriteEmpoweredItem->GetSlot(), true);


 azeriteEmpoweredItem->SetState(ITEM_CHANGED, owner);

 owner->SetNumRespecs(owner->GetNumRespecs() + 1);

}


void Spell::EffectLearnAzeriteEssencePower()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Player* playerTarget = unitTarget ? unitTarget->ToPlayer() : nullptr;

 if (!playerTarget)

 return;


 Item* heartOfAzeroth = playerTarget->GetItemByEntry(ITEM_ID_HEART_OF_AZEROTH, ItemSearchLocation::Everywhere);

 if (!heartOfAzeroth)

 return;


 AzeriteItem* azeriteItem = heartOfAzeroth->ToAzeriteItem();

 if (!azeriteItem)

 return;


 // remove old rank and apply new one

 if (azeriteItem->IsEquipped())

 {

 if (UF::SelectedAzeriteEssences const* selectedEssences = azeriteItem->GetSelectedAzeriteEssences())

 {

 for (int32 slot = 0; slot < MAX_AZERITE_ESSENCE_SLOT; ++slot)

 {

 if (selectedEssences->AzeriteEssenceID[slot] == uint32(effectInfo->MiscValue))

 {

 bool major = AzeriteItemMilestoneType(sDB2Manager.GetAzeriteItemMilestonePower(slot)->Type) == AzeriteItemMilestoneType::MajorEssence;

 playerTarget->ApplyAzeriteEssence(azeriteItem, effectInfo->MiscValue, MAX_AZERITE_ESSENCE_RANK, major, false);

 playerTarget->ApplyAzeriteEssence(azeriteItem, effectInfo->MiscValue, effectInfo->MiscValueB, major, false);

 break;

 }

 }

 }

 }


 azeriteItem->SetEssenceRank(effectInfo->MiscValue, effectInfo->MiscValueB);

 azeriteItem->SetState(ITEM_CHANGED, playerTarget);

}


void Spell::EffectCreatePrivateConversation()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)

 return;


 if (unitTarget->GetTypeId() != TYPEID_PLAYER)

 return;


 Conversation::CreateConversation(effectInfo->MiscValue, unitTarget, destTarget->GetPosition(), unitTarget->GetGUID(), GetSpellInfo());

}


void Spell::EffectSendChatMessage()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Unit* unitCaster = GetUnitCasterForEffectHandlers();

 if (!unitCaster)

 return;


 uint32 broadcastTextId = effectInfo->MiscValue;

 if (!sBroadcastTextStore.LookupEntry(broadcastTextId))

 return;


 ChatMsg chatType = ChatMsg(effectInfo->MiscValueB);

 unitCaster->Talk(broadcastTextId, chatType, CreatureTextMgr::GetRangeForChatType(chatType), unitTarget);

}


void Spell::EffectGrantBattlePetExperience()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Player* playerCaster = m_caster->ToPlayer();

 if (!playerCaster)

 return;


 if (!unitTarget || !unitTarget->IsCreature())

 return;


 playerCaster->GetSession()->GetBattlePetMgr()->GrantBattlePetExperience(unitTarget->GetBattlePetCompanionGUID(), damage, BattlePets::BattlePetXpSource::SpellEffect);

}


void Spell::EffectLearnTransmogIllusion()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Player* player = Object::ToPlayer(unitTarget);

 if (!player)

 return;


 uint32 illusionId = effectInfo->MiscValue;

 if (!sTransmogIllusionStore.LookupEntry(illusionId))

 return;


 player->GetSession()->GetCollectionMgr()->AddTransmogIllusion(illusionId);

}


void Spell::EffectModifyAuraStacks()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Aura* targetAura = unitTarget->GetAura(effectInfo->TriggerSpell);

 if (!targetAura)

 return;


 switch (effectInfo->MiscValue)

 {

 case 0:

 targetAura->ModStackAmount(damage);

 break;

 case 1:

 targetAura->SetStackAmount(damage);

 break;

 default:

 break;

 }

}


void Spell::EffectModifyCooldown()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 unitTarget->GetSpellHistory()->ModifyCooldown(effectInfo->TriggerSpell, Milliseconds(damage));

}


void Spell::EffectModifyCooldowns()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 unitTarget->GetSpellHistory()->ModifyCoooldowns([this](SpellHistory::CooldownStorageType::iterator itr)

 {

 SpellInfo const* spellOnCooldown = sSpellMgr->AssertSpellInfo(itr->first, DIFFICULTY_NONE);

 if (spellOnCooldown->SpellFamilyName != uint32(effectInfo->MiscValue))

 return false;


 int32 bitIndex = effectInfo->MiscValueB - 1;

 if (bitIndex < 0 || uint32(bitIndex) >= sizeof(flag128) * 8)

 return false;


 flag128 reqFlag;

 reqFlag[bitIndex / 32] = 1u << (bitIndex % 32);

 return bool(spellOnCooldown->SpellFamilyFlags & reqFlag);

 }, Milliseconds(damage));

}


void Spell::EffectModifyCooldownsByCategory()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 unitTarget->GetSpellHistory()->ModifyCoooldowns([this](SpellHistory::CooldownStorageType::iterator itr)

 {

 return sSpellMgr->AssertSpellInfo(itr->first, DIFFICULTY_NONE)->CategoryId == uint32(effectInfo->MiscValue);

 }, Milliseconds(damage));

}


void Spell::EffectModifySpellCharges()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 for (int32 i = 0; i < damage; ++i)

 unitTarget->GetSpellHistory()->RestoreCharge(effectInfo->MiscValue);

}


void Spell::EffectCreateTraitTreeConfig()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Player* target = Object::ToPlayer(unitTarget);

 if (!target)

 return;


 WorldPackets::Traits::TraitConfig newConfig;

 newConfig.Type = TraitMgr::GetConfigTypeForTree(effectInfo->MiscValue);

 if (newConfig.Type != TraitConfigType::Generic)

 return;


 newConfig.TraitSystemID = sTraitTreeStore.AssertEntry(effectInfo->MiscValue)->TraitSystemID;

 int32 existingConfigForSystem = target->m_activePlayerData->TraitConfigs.FindIndexIf([&](UF::TraitConfig const& config)

 {

 return static_cast<TraitConfigType>(*config.Type) == TraitConfigType::Generic

 && config.TraitSystemID == newConfig.TraitSystemID;

 });


 if (existingConfigForSystem < 0)

 target->CreateTraitConfig(newConfig);

}


void Spell::EffectChangeActiveCombatTraitConfig()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Player* target = Object::ToPlayer(unitTarget);

 if (!target)

 return;


 WorldPackets::Traits::TraitConfig* traitConfig = std::any_cast<WorldPackets::Traits::TraitConfig>(&m_customArg);

 if (!traitConfig)

 return;


 target->UpdateTraitConfig(std::move(*traitConfig), damage, false);

}


void Spell::EffectTeleportGraveyard()

{

 if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

 return;


 Player* target = Object::ToPlayer(unitTarget);

 if (!target)

 return;


 target->RepopAtGraveyard();

}

AccountMgr.h

AreaTrigger.h

AzeriteEmpoweredItem.h

AzeriteItem.h

ITEM_ID_HEART_OF_AZEROTH
constexpr uint32 ITEM_ID_HEART_OF_AZEROTH
Definition: AzeriteItem.h:23

BattlePetMgr.h

BattlegroundMgr.h

Battleground.h

SPELL_PET_SUMMONED
@ SPELL_PET_SUMMONED
Definition: Battleground.h:124

SPELL_SPIRIT_HEAL_MANA
@ SPELL_SPIRIT_HEAL_MANA
Definition: Battleground.h:110

SPELL_RESURRECTION_VISUAL
@ SPELL_RESURRECTION_VISUAL
Definition: Battleground.h:107

CellImpl.h

CharmInfo.h

CombatLogPackets.h

CombatPackets.h

Common.h

IN_MILLISECONDS
@ IN_MILLISECONDS
Definition: Common.h:35

MINUTE
@ MINUTE
Definition: Common.h:29

HOUR
@ HOUR
Definition: Common.h:30

Conversation.h

CreatureAI.h

CreatureTextMgr.h

Creature.h

sBattlePetBreedQualityStore
DB2Storage< BattlePetBreedQualityEntry > sBattlePetBreedQualityStore("BattlePetBreedQuality.db2", &BattlePetBreedQualityLoadInfo::Instance)

sTaxiNodesStore
DB2Storage< TaxiNodesEntry > sTaxiNodesStore("TaxiNodes.db2", &TaxiNodesLoadInfo::Instance)

sTransmogIllusionStore
DB2Storage< TransmogIllusionEntry > sTransmogIllusionStore("TransmogIllusion.db2", &TransmogIllusionLoadInfo::Instance)

sTraitTreeStore
DB2Storage< TraitTreeEntry > sTraitTreeStore("TraitTree.db2", &TraitTreeLoadInfo::Instance)

sChrSpecializationStore
DB2Storage< ChrSpecializationEntry > sChrSpecializationStore("ChrSpecialization.db2", &ChrSpecializationLoadInfo::Instance)

sBattlePetSpeciesStore
DB2Storage< BattlePetSpeciesEntry > sBattlePetSpeciesStore("BattlePetSpecies.db2", &BattlePetSpeciesLoadInfo::Instance)

sSummonPropertiesStore
DB2Storage< SummonPropertiesEntry > sSummonPropertiesStore("SummonProperties.db2", &SummonPropertiesLoadInfo::Instance)

sBroadcastTextStore
DB2Storage< BroadcastTextEntry > sBroadcastTextStore("BroadcastText.db2", &BroadcastTextLoadInfo::Instance)

sCurrencyTypesStore
DB2Storage< CurrencyTypesEntry > sCurrencyTypesStore("CurrencyTypes.db2", &CurrencyTypesLoadInfo::Instance)

sGlyphPropertiesStore
DB2Storage< GlyphPropertiesEntry > sGlyphPropertiesStore("GlyphProperties.db2", &GlyphPropertiesLoadInfo::Instance)

sContentTuningStore
DB2Storage< ContentTuningEntry > sContentTuningStore("ContentTuning.db2", &ContentTuningLoadInfo::Instance)

sSpellItemEnchantmentStore
DB2Storage< SpellItemEnchantmentEntry > sSpellItemEnchantmentStore("SpellItemEnchantment.db2", &SpellItemEnchantmentLoadInfo::Instance)

sTalentStore
DB2Storage< TalentEntry > sTalentStore("Talent.db2", &TalentLoadInfo::Instance)

sMovieStore
DB2Storage< MovieEntry > sMovieStore("Movie.db2", &MovieLoadInfo::Instance)

sFactionTemplateStore
DB2Storage< FactionTemplateEntry > sFactionTemplateStore("FactionTemplate.db2", &FactionTemplateLoadInfo::Instance)

sSoundKitStore
DB2Storage< SoundKitEntry > sSoundKitStore("SoundKit.db2", &SoundKitLoadInfo::Instance)

sAreaTableStore
DB2Storage< AreaTableEntry > sAreaTableStore("AreaTable.db2", &AreaTableLoadInfo::Instance)

sFactionStore
DB2Storage< FactionEntry > sFactionStore("Faction.db2", &FactionLoadInfo::Instance)

DB2Stores.h

sDB2Manager
#define sDB2Manager
Definition: DB2Stores.h:538

MAX_VEHICLE_SEATS
#define MAX_VEHICLE_SEATS
Definition: DB2Structure.h:4471

MAX_ITEM_ENCHANTMENT_EFFECTS
#define MAX_ITEM_ENCHANTMENT_EFFECTS
Definition: DB2Structure.h:3633

TraitConfigType
TraitConfigType
Definition: DBCEnums.h:2185

TraitConfigType::Generic
@ Generic

SKILL_FLAG_ALWAYS_MAX_VALUE
@ SKILL_FLAG_ALWAYS_MAX_VALUE
Definition: DBCEnums.h:1910

ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET
@ ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET
Definition: DBCEnums.h:1009

DIFFICULTY_NONE
@ DIFFICULTY_NONE
Definition: DBCEnums.h:874

MAX_EFFECT_MASK
#define MAX_EFFECT_MASK
Definition: DBCEnums.h:1954

AzeriteItemMilestoneType
AzeriteItemMilestoneType
Definition: DBCEnums.h:206

AzeriteItemMilestoneType::MajorEssence
@ MajorEssence

AreaFlags::AllowDueling
@ AllowDueling

ItemContext
ItemContext
Definition: DBCEnums.h:1063

ItemContext::NONE
@ NONE

ItemContext::Trade_Skill
@ Trade_Skill

MAX_AZERITE_ESSENCE_RANK
#define MAX_AZERITE_ESSENCE_RANK
Definition: DBCEnums.h:203

MAX_SPELL_EFFECTS
#define MAX_SPELL_EFFECTS
Definition: DBCEnums.h:1953

MAX_AZERITE_ESSENCE_SLOT
#define MAX_AZERITE_ESSENCE_SLOT
Definition: DBCEnums.h:202

SummonPropertiesFlags::OnlyVisibleToSummonerGroup
@ OnlyVisibleToSummonerGroup

SummonPropertiesFlags::JoinSummonerSpawnGroup
@ JoinSummonerSpawnGroup

SummonPropertiesFlags::OnlyVisibleToSummoner
@ OnlyVisibleToSummoner

DatabaseEnv.h

uint8
uint8_t uint8
Definition: Define.h:144

int64
int64_t int64
Definition: Define.h:137

int8
int8_t int8
Definition: Define.h:140

int32
int32_t int32
Definition: Define.h:138

uint64
uint64_t uint64
Definition: Define.h:141

UI64LIT
#define UI64LIT(N)
Definition: Define.h:127

uint16
uint16_t uint16
Definition: Define.h:143

uint32
uint32_t uint32
Definition: Define.h:142

params
std::unordered_set< uint32 > params[2]
Definition: DisableMgr.cpp:50

DuelPackets.h

Milliseconds
std::chrono::milliseconds Milliseconds
Milliseconds shorthand typedef.
Definition: Duration.h:29

DynamicObject.h

DYNAMIC_OBJECT_FARSIGHT_FOCUS
@ DYNAMIC_OBJECT_FARSIGHT_FOCUS
Definition: DynamicObject.h:33

DYNAMIC_OBJECT_AREA_SPELL
@ DYNAMIC_OBJECT_AREA_SPELL
Definition: DynamicObject.h:32

ASSERT_NOTNULL
#define ASSERT_NOTNULL(pointer)
Definition: Errors.h:84

ASSERT
#define ASSERT
Definition: Errors.h:68

GameEventSender.h

GameObjectAI.h

GameObjectActions
GameObjectActions
Definition: GameObjectData.h:1385

GameObject.h

GO_JUST_DEACTIVATED
@ GO_JUST_DEACTIVATED
Definition: GameObject.h:159

FISHING_BOBBER_READY_TIME
#define FISHING_BOBBER_READY_TIME
Definition: GameObject.h:163

GameTime.h

Garrison.h

GossipDef.h

GRID_MAP_TYPE_MASK_CONVERSATION
@ GRID_MAP_TYPE_MASK_CONVERSATION
Definition: GridDefines.h:88

GridNotifiersImpl.h

GridNotifiers.h

Group.h

Guild.h

MinNewsItemLevel
uint32 const MinNewsItemLevel
Definition: Guild.h:260

GUILD_NEWS_ITEM_CRAFTED
@ GUILD_NEWS_ITEM_CRAFTED
Definition: Guild.h:244

InstanceScript.h

EnchantmentSlot
EnchantmentSlot
Definition: ItemDefines.h:178

PERM_ENCHANTMENT_SLOT
@ PERM_ENCHANTMENT_SLOT
Definition: ItemDefines.h:179

TEMP_ENCHANTMENT_SLOT
@ TEMP_ENCHANTMENT_SLOT
Definition: ItemDefines.h:180

PRISMATIC_ENCHANTMENT_SLOT
@ PRISMATIC_ENCHANTMENT_SLOT
Definition: ItemDefines.h:185

InventoryResult
InventoryResult
Definition: ItemDefines.h:25

EQUIP_ERR_CLIENT_LOCKED_OUT
@ EQUIP_ERR_CLIENT_LOCKED_OUT
Definition: ItemDefines.h:66

EQUIP_ERR_ITEM_NOT_FOUND
@ EQUIP_ERR_ITEM_NOT_FOUND
Definition: ItemDefines.h:49

EQUIP_ERR_OK
@ EQUIP_ERR_OK
Definition: ItemDefines.h:26

EQUIP_ERR_INV_FULL
@ EQUIP_ERR_INV_FULL
Definition: ItemDefines.h:77

EQUIP_ERR_ITEM_MAX_COUNT
@ EQUIP_ERR_ITEM_MAX_COUNT
Definition: ItemDefines.h:43

ITEM_MODIFIER_ENCHANT_ILLUSION_ALL_SPECS
@ ITEM_MODIFIER_ENCHANT_ILLUSION_ALL_SPECS
Definition: ItemDefines.h:218

ITEM_MODIFIER_BATTLE_PET_DISPLAY_ID
@ ITEM_MODIFIER_BATTLE_PET_DISPLAY_ID
Definition: ItemDefines.h:217

ITEM_MODIFIER_BATTLE_PET_BREED_DATA
@ ITEM_MODIFIER_BATTLE_PET_BREED_DATA
Definition: ItemDefines.h:215

ITEM_MODIFIER_BATTLE_PET_SPECIES_ID
@ ITEM_MODIFIER_BATTLE_PET_SPECIES_ID
Definition: ItemDefines.h:214

ITEM_MODIFIER_BATTLE_PET_LEVEL
@ ITEM_MODIFIER_BATTLE_PET_LEVEL
Definition: ItemDefines.h:216

GenerateItemRandomBonusListId
ItemRandomBonusListId GenerateItemRandomBonusListId(uint32 item_id)
Definition: ItemEnchantmentMgr.cpp:87

ITEM_CLASS_ARMOR
@ ITEM_CLASS_ARMOR
Definition: ItemTemplate.h:424

ITEM_CLASS_WEAPON
@ ITEM_CLASS_WEAPON
Definition: ItemTemplate.h:422

ITEM_FIELD_FLAG_UNLOCKED
@ ITEM_FIELD_FLAG_UNLOCKED
Definition: ItemTemplate.h:133

ITEM_SPELLTRIGGER_ON_LEARN
@ ITEM_SPELLTRIGGER_ON_LEARN
Definition: ItemTemplate.h:110

ITEM_FLAG_IS_MILLABLE
@ ITEM_FLAG_IS_MILLABLE
Definition: ItemTemplate.h:205

ITEM_FLAG_NO_REAGENT_COST
@ ITEM_FLAG_NO_REAGENT_COST
Definition: ItemTemplate.h:204

ITEM_FLAG_IS_PROSPECTABLE
@ ITEM_FLAG_IS_PROSPECTABLE
Definition: ItemTemplate.h:194

Item.h

ITEM_CHANGED
@ ITEM_CHANGED
Definition: Item.h:55

Language.h

LANG_ZONE_NOFLYZONE
@ LANG_ZONE_NOFLYZONE
Definition: Language.h:768

Log.h

TC_LOG_WARN
#define TC_LOG_WARN(filterType__,...)
Definition: Log.h:162

TC_LOG_DEBUG
#define TC_LOG_DEBUG(filterType__,...)
Definition: Log.h:156

TC_LOG_ERROR
#define TC_LOG_ERROR(filterType__,...)
Definition: Log.h:165

sLog
#define sLog
Definition: Log.h:130

LootTemplates_Spell
LootStore LootTemplates_Spell("spell_loot_template", "spell id (random item creating)", false)

LootTemplates_Skinning
LootStore LootTemplates_Skinning("skinning_loot_template", "creature skinning id", true)

LootTemplates_Milling
LootStore LootTemplates_Milling("milling_loot_template", "item entry (herb)", true)

LootTemplates_Disenchant
LootStore LootTemplates_Disenchant("disenchant_loot_template", "item disenchant id", true)

LootTemplates_Prospecting
LootStore LootTemplates_Prospecting("prospecting_loot_template", "item entry (ore)", true)

LootTemplates_Pickpocketing
LootStore LootTemplates_Pickpocketing("pickpocketing_loot_template", "creature pickpocket lootid", true)

LootMgr.h

Loot.h

LOOT_PICKPOCKETING
@ LOOT_PICKPOCKETING
Definition: Loot.h:102

LOOT_MILLING
@ LOOT_MILLING
Definition: Loot.h:115

LOOT_DISENCHANTING
@ LOOT_DISENCHANTING
Definition: Loot.h:104

LOOT_SKINNING
@ LOOT_SKINNING
Definition: Loot.h:106

LOOT_PROSPECTING
@ LOOT_PROSPECTING
Definition: Loot.h:114

LOOT_ERROR_ALREADY_PICKPOCKETED
@ LOOT_ERROR_ALREADY_PICKPOCKETED
Definition: Loot.h:149

Map.h

MiscPackets.h

MotionMaster.h

MoveSpline.h

SPEED_CHARGE
#define SPEED_CHARGE
Definition: MovementDefines.h:25

ObjectAccessor.h

TempSummonType
TempSummonType
Definition: ObjectDefines.h:62

TEMPSUMMON_DEAD_DESPAWN
@ TEMPSUMMON_DEAD_DESPAWN
Definition: ObjectDefines.h:69

TEMPSUMMON_MANUAL_DESPAWN
@ TEMPSUMMON_MANUAL_DESPAWN
Definition: ObjectDefines.h:70

TEMPSUMMON_TIMED_DESPAWN
@ TEMPSUMMON_TIMED_DESPAWN
Definition: ObjectDefines.h:65

DEFAULT_PLAYER_BOUNDING_RADIUS
#define DEFAULT_PLAYER_BOUNDING_RADIUS
Definition: ObjectDefines.h:39

TYPEID_UNIT
@ TYPEID_UNIT
Definition: ObjectGuid.h:40

TYPEID_PLAYER
@ TYPEID_PLAYER
Definition: ObjectGuid.h:41

GuidSet
std::set< ObjectGuid > GuidSet
Definition: ObjectGuid.h:393

HighGuid::DynamicObject
@ DynamicObject

sSpellScripts
ScriptMapMap sSpellScripts
Definition: ObjectMgr.cpp:78

ObjectMgr.h

sObjectMgr
#define sObjectMgr
Definition: ObjectMgr.h:1946

Optional
std::optional< T > Optional
Optional helper class to wrap optional values within.
Definition: Optional.h:25

OutdoorPvPMgr.h

sOutdoorPvPMgr
#define sOutdoorPvPMgr
Definition: OutdoorPvPMgr.h:110

PathGenerator.h

PET_FOLLOW_DIST
#define PET_FOLLOW_DIST
Definition: PetDefines.h:97

HUNTER_PET
@ HUNTER_PET
Definition: PetDefines.h:32

PetSaveMode
PetSaveMode
Definition: PetDefines.h:41

PET_SAVE_NOT_IN_SLOT
@ PET_SAVE_NOT_IN_SLOT
Definition: PetDefines.h:48

PET_SAVE_AS_CURRENT
@ PET_SAVE_AS_CURRENT
Definition: PetDefines.h:43

Pet.h

PhasingHandler.h

Player.h

EQUIPMENT_SLOT_MAINHAND
@ EQUIPMENT_SLOT_MAINHAND
Definition: Player.h:646

ItemPosCountVec
std::vector< ItemPosCount > ItemPosCountVec
Definition: Player.h:750

DAMAGE_FIRE
@ DAMAGE_FIRE
Definition: Player.h:822

INVENTORY_SLOT_BAG_END
@ INVENTORY_SLOT_BAG_END
Definition: Player.h:676

TeleportToOptions
TeleportToOptions
Definition: Player.h:800

TELE_TO_SPELL
@ TELE_TO_SPELL
Definition: Player.h:806

TELE_TO_NOT_LEAVE_COMBAT
@ TELE_TO_NOT_LEAVE_COMBAT
Definition: Player.h:804

TELE_TO_NOT_UNSUMMON_PET
@ TELE_TO_NOT_UNSUMMON_PET
Definition: Player.h:805

TELE_TO_NONE
@ TELE_TO_NONE
Definition: Player.h:801

TELE_TO_NOT_LEAVE_TRANSPORT
@ TELE_TO_NOT_LEAVE_TRANSPORT
Definition: Player.h:803

PLAYER_FLAGS_PET_BATTLES_UNLOCKED
@ PLAYER_FLAGS_PET_BATTLES_UNLOCKED
Definition: Player.h:452

CHEAT_GOD
@ CHEAT_GOD
Definition: Player.h:949

ItemSearchLocation::Everywhere
@ Everywhere

ACTION_BUTTON_SPELL
@ ACTION_BUTTON_SPELL
Definition: Player.h:292

SPEC_RESET_TALENTS
@ SPEC_RESET_TALENTS
Definition: Player.h:217

DisplayToastMethod::Loot
@ Loot

INVENTORY_SLOT_BAG_0
#define INVENTORY_SLOT_BAG_0
Definition: Player.h:625

REPUTATION_SOURCE_SPELL
@ REPUTATION_SOURCE_SPELL
Definition: Player.h:311

MAPID_INVALID
#define MAPID_INVALID
Definition: Position.h:176

MAX_QUEST_LOG_SIZE
#define MAX_QUEST_LOG_SIZE
Definition: QuestDef.h:44

QuestStatus
QuestStatus
Definition: QuestDef.h:141

QUEST_STATUS_NONE
@ QUEST_STATUS_NONE
Definition: QuestDef.h:142

QUEST_FLAGS_FLAGS_PVP
@ QUEST_FLAGS_FLAGS_PVP
Definition: QuestDef.h:207

QUEST_FLAGS_TRACKING_EVENT
@ QUEST_FLAGS_TRACKING_EVENT
Definition: QuestDef.h:204

rand_norm
float rand_norm()
Definition: Random.cpp:75

urand
uint32 urand(uint32 min, uint32 max)
Definition: Random.cpp:42

roll_chance_f
bool roll_chance_f(float chance)
Definition: Random.h:53

roll_chance_i
bool roll_chance_i(int chance)
Definition: Random.h:59

ReputationMgr.h

RestMgr.h

REST_TYPE_XP
@ REST_TYPE_XP
Definition: RestMgr.h:28

if
if(posix_memalign(&__mallocedMemory, __align, __size)) return NULL

SceneFlag::PlayerNonInteractablePhased
@ PlayerNonInteractablePhased

SceneObject.h

ScriptMgr.h

sScriptMgr
#define sScriptMgr
Definition: ScriptMgr.h:1418

SharedDefines.h

SpellEffIndex
SpellEffIndex
Definition: SharedDefines.h:29

SPELL_ATTR9_SPECIAL_DELAY_CALCULATION
@ SPELL_ATTR9_SPECIAL_DELAY_CALCULATION
Definition: SharedDefines.h:766

SPELL_ATTR7_DISPEL_REMOVES_CHARGES
@ SPELL_ATTR7_DISPEL_REMOVES_CHARGES
Definition: SharedDefines.h:698

SPELL_ATTR7_CAN_BE_MULTI_CAST
@ SPELL_ATTR7_CAN_BE_MULTI_CAST
Definition: SharedDefines.h:693

SPELL_ATTR7_ATTACK_ON_CHARGE_TO_UNIT
@ SPELL_ATTR7_ATTACK_ON_CHARGE_TO_UNIT
Definition: SharedDefines.h:706

CLASS_HUNTER
@ CLASS_HUNTER
Definition: SharedDefines.h:152

GAMEOBJECT_TYPE_DUEL_ARBITER
@ GAMEOBJECT_TYPE_DUEL_ARBITER
Definition: SharedDefines.h:2844

GAMEOBJECT_TYPE_TRAP
@ GAMEOBJECT_TYPE_TRAP
Definition: SharedDefines.h:2834

GAMEOBJECT_TYPE_CHEST
@ GAMEOBJECT_TYPE_CHEST
Definition: SharedDefines.h:2831

GAMEOBJECT_TYPE_FISHINGHOLE
@ GAMEOBJECT_TYPE_FISHINGHOLE
Definition: SharedDefines.h:2853

GAMEOBJECT_TYPE_FLAGDROP
@ GAMEOBJECT_TYPE_FLAGDROP
Definition: SharedDefines.h:2854

GAMEOBJECT_TYPE_FLAGSTAND
@ GAMEOBJECT_TYPE_FLAGSTAND
Definition: SharedDefines.h:2852

GAMEOBJECT_TYPE_GOOBER
@ GAMEOBJECT_TYPE_GOOBER
Definition: SharedDefines.h:2838

GAMEOBJECT_TYPE_FISHINGNODE
@ GAMEOBJECT_TYPE_FISHINGNODE
Definition: SharedDefines.h:2845

GAMEOBJECT_TYPE_RITUAL
@ GAMEOBJECT_TYPE_RITUAL
Definition: SharedDefines.h:2846

SpellTargetIndex::TargetA
@ TargetA

SpellTargetIndex::TargetB
@ TargetB

SPELL_MISS_REFLECT
@ SPELL_MISS_REFLECT
Definition: SharedDefines.h:2793

SPELL_SCHOOL_MASK_NORMAL
@ SPELL_SCHOOL_MASK_NORMAL
Definition: SharedDefines.h:335

EVENT_JUMP
@ EVENT_JUMP
Definition: SharedDefines.h:6142

SPELL_ATTR2_RETAIN_ITEM_CAST
@ SPELL_ATTR2_RETAIN_ITEM_CAST
Definition: SharedDefines.h:534

SummonTitle
SummonTitle
Definition: SharedDefines.h:6076

SummonTitle::Guardian
@ Guardian

SummonTitle::Pet
@ Pet

SummonTitle::Totem
@ Totem

SummonTitle::Companion
@ Companion

SummonTitle::Minion
@ Minion

SummonTitle::Runeblade
@ Runeblade

SummonTitle::Vehicle
@ Vehicle

SummonTitle::Mount
@ Mount

SummonTitle::Lightwell
@ Lightwell

SPELL_ATTR1_DISPEL_ALL_STACKS
@ SPELL_ATTR1_DISPEL_ALL_STACKS
Definition: SharedDefines.h:496

UNIT_DYNFLAG_LOOTABLE
@ UNIT_DYNFLAG_LOOTABLE
Definition: SharedDefines.h:5847

UNIT_DYNFLAG_NONE
@ UNIT_DYNFLAG_NONE
Definition: SharedDefines.h:5845

ITEM_QUALITY_EPIC
@ ITEM_QUALITY_EPIC
Definition: SharedDefines.h:379

TEAM_ALLIANCE
@ TEAM_ALLIANCE
Definition: SharedDefines.h:1125

TEAM_HORDE
@ TEAM_HORDE
Definition: SharedDefines.h:1126

SpellEffectName
SpellEffectName
Definition: SharedDefines.h:1143

SPELL_EFFECT_TRIGGER_MISSILE_SPELL_WITH_VALUE
@ SPELL_EFFECT_TRIGGER_MISSILE_SPELL_WITH_VALUE
Definition: SharedDefines.h:1292

SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE
@ SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE
Definition: SharedDefines.h:1286

SPELL_EFFECT_SUMMON_OBJECT_SLOT1
@ SPELL_EFFECT_SUMMON_OBJECT_SLOT1
Definition: SharedDefines.h:1248

SPELL_EFFECT_WEAPON_DAMAGE
@ SPELL_EFFECT_WEAPON_DAMAGE
Definition: SharedDefines.h:1202

SPELL_EFFECT_NORMALIZED_WEAPON_DMG
@ SPELL_EFFECT_NORMALIZED_WEAPON_DMG
Definition: SharedDefines.h:1265

SPELL_EFFECT_TRIGGER_SPELL
@ SPELL_EFFECT_TRIGGER_SPELL
Definition: SharedDefines.h:1208

SPELL_EFFECT_WEAPON_PERCENT_DAMAGE
@ SPELL_EFFECT_WEAPON_PERCENT_DAMAGE
Definition: SharedDefines.h:1175

SPELL_EFFECT_KNOCK_BACK_DEST
@ SPELL_EFFECT_KNOCK_BACK_DEST
Definition: SharedDefines.h:1288

SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL
@ SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL
Definition: SharedDefines.h:1161

SPELL_EFFECT_PERSISTENT_AREA_AURA
@ SPELL_EFFECT_PERSISTENT_AREA_AURA
Definition: SharedDefines.h:1171

TOTAL_SPELL_EFFECTS
@ TOTAL_SPELL_EFFECTS
Definition: SharedDefines.h:1460

SPELL_EFFECT_FORCE_CAST
@ SPELL_EFFECT_FORCE_CAST
Definition: SharedDefines.h:1284

SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC
@ SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC
Definition: SharedDefines.h:1300

SPELL_EFFECT_FORCE_CAST_WITH_VALUE
@ SPELL_EFFECT_FORCE_CAST_WITH_VALUE
Definition: SharedDefines.h:1285

SUMMON_SLOT_TOTEM
@ SUMMON_SLOT_TOTEM
Definition: SharedDefines.h:6126

OFF_ATTACK
@ OFF_ATTACK
Definition: SharedDefines.h:6858

BASE_ATTACK
@ BASE_ATTACK
Definition: SharedDefines.h:6857

RANGED_ATTACK
@ RANGED_ATTACK
Definition: SharedDefines.h:6859

Mechanics
Mechanics
Definition: SharedDefines.h:2537

MECHANIC_NONE
@ MECHANIC_NONE
Definition: SharedDefines.h:2538

GameObjectDestructibleState
GameObjectDestructibleState
Definition: SharedDefines.h:2949

ALLIANCE
@ ALLIANCE
Definition: SharedDefines.h:1133

Powers
Powers
Definition: SharedDefines.h:285

MAX_POWERS
@ MAX_POWERS
Definition: SharedDefines.h:313

POWER_RAGE
@ POWER_RAGE
Definition: SharedDefines.h:288

POWER_ENERGY
@ POWER_ENERGY
Definition: SharedDefines.h:290

POWER_MANA
@ POWER_MANA
Definition: SharedDefines.h:287

POWER_FOCUS
@ POWER_FOCUS
Definition: SharedDefines.h:289

SPELL_ATTR0_IS_TRADESKILL
@ SPELL_ATTR0_IS_TRADESKILL
Definition: SharedDefines.h:434

MAX_TOTEM_SLOT
#define MAX_TOTEM_SLOT
Definition: SharedDefines.h:6136

CurrencyDestroyReason::Spell
@ Spell

BATTLEGROUND_EY
@ BATTLEGROUND_EY
Definition: SharedDefines.h:6329

SpellCastResult
SpellCastResult
Definition: SharedDefines.h:1465

SPELL_FAILED_DONT_REPORT
@ SPELL_FAILED_DONT_REPORT
Definition: SharedDefines.h:1498

SPELL_FAILED_NO_DUELING
@ SPELL_FAILED_NO_DUELING
Definition: SharedDefines.h:1568

SPELL_CAST_OK
@ SPELL_CAST_OK
Definition: SharedDefines.h:1790

SPELL_FAILED_CANT_ADD_BATTLE_PET
@ SPELL_FAILED_CANT_ADD_BATTLE_PET
Definition: SharedDefines.h:1716

SPELLFAMILY_PRIEST
@ SPELLFAMILY_PRIEST
Definition: SharedDefines.h:6466

SPELLFAMILY_WARLOCK
@ SPELLFAMILY_WARLOCK
Definition: SharedDefines.h:6465

SPELLFAMILY_GENERIC
@ SPELLFAMILY_GENERIC
Definition: SharedDefines.h:6460

SPELLFAMILY_WARRIOR
@ SPELLFAMILY_WARRIOR
Definition: SharedDefines.h:6464

SPELLFAMILY_SHAMAN
@ SPELLFAMILY_SHAMAN
Definition: SharedDefines.h:6471

SPELLFAMILY_DRUID
@ SPELLFAMILY_DRUID
Definition: SharedDefines.h:6467

SPELLFAMILY_DEATHKNIGHT
@ SPELLFAMILY_DEATHKNIGHT
Definition: SharedDefines.h:6475

DispelType
DispelType
Definition: SharedDefines.h:2589

CurrencyGainSource::Spell
@ Spell

ChatMsg
ChatMsg
Definition: SharedDefines.h:5879

GO_STATE_READY
@ GO_STATE_READY
Definition: SharedDefines.h:2939

SPELL_ATTR4_CANNOT_BE_STOLEN
@ SPELL_ATTR4_CANNOT_BE_STOLEN
Definition: SharedDefines.h:583

SUMMON_CATEGORY_PET
@ SUMMON_CATEGORY_PET
Definition: SharedDefines.h:6068

SUMMON_CATEGORY_VEHICLE
@ SUMMON_CATEGORY_VEHICLE
Definition: SharedDefines.h:6070

SUMMON_CATEGORY_ALLY
@ SUMMON_CATEGORY_ALLY
Definition: SharedDefines.h:6067

SUMMON_CATEGORY_PUPPET
@ SUMMON_CATEGORY_PUPPET
Definition: SharedDefines.h:6069

SUMMON_CATEGORY_WILD
@ SUMMON_CATEGORY_WILD
Definition: SharedDefines.h:6066

SUMMON_CATEGORY_UNK
@ SUMMON_CATEGORY_UNK
Definition: SharedDefines.h:6071

SkillType
SkillType
Definition: SharedDefines.h:5343

SKILL_INSCRIPTION
@ SKILL_INSCRIPTION
Definition: SharedDefines.h:5449

SKILL_ENGINEERING
@ SKILL_ENGINEERING
Definition: SharedDefines.h:5389

SKILL_NONE
@ SKILL_NONE
Definition: SharedDefines.h:5344

SKILL_SKINNING
@ SKILL_SKINNING
Definition: SharedDefines.h:5417

SKILL_JEWELCRAFTING
@ SKILL_JEWELCRAFTING
Definition: SharedDefines.h:5435

SPELL_ATTR6_IGNORE_CASTER_DAMAGE_MODIFIERS
@ SPELL_ATTR6_IGNORE_CASTER_DAMAGE_MODIFIERS
Definition: SharedDefines.h:680

CanCreateExtraItems
bool CanCreateExtraItems(Player *player, uint32 spellId, float &additionalChance, uint8 &additionalMax)
Definition: SkillExtraItems.cpp:222

CanCreatePerfectItem
bool CanCreatePerfectItem(Player *player, uint32 spellId, float &perfectCreateChance, uint32 &perfectItemType)
Definition: SkillExtraItems.cpp:201

SkillExtraItems.h

SocialMgr.h

AURA_REMOVE_BY_ENEMY_SPELL
@ AURA_REMOVE_BY_ENEMY_SPELL
Definition: SpellAuraDefines.h:68

SPELL_AURA_CONTROL_VEHICLE
@ SPELL_AURA_CONTROL_VEHICLE
Definition: SpellAuraDefines.h:330

SPELL_AURA_MOD_STALKED
@ SPELL_AURA_MOD_STALKED
Definition: SpellAuraDefines.h:162

SPELL_AURA_OVERRIDE_SUMMONED_OBJECT
@ SPELL_AURA_OVERRIDE_SUMMONED_OBJECT
Definition: SpellAuraDefines.h:352

SPELL_AURA_MOD_STUN
@ SPELL_AURA_MOD_STUN
Definition: SpellAuraDefines.h:106

SpellAuraEffects.h

SpellAuras.h

SpellAuraInterruptFlags2::ChangeGlyph
@ ChangeGlyph

TARGET_FLAG_DEST_LOCATION
@ TARGET_FLAG_DEST_LOCATION
Definition: SpellDefines.h:286

TARGET_FLAG_UNIT_MASK
@ TARGET_FLAG_UNIT_MASK
Definition: SpellDefines.h:307

TARGET_FLAG_GAMEOBJECT_MASK
@ TARGET_FLAG_GAMEOBJECT_MASK
Definition: SpellDefines.h:309

TRIGGERED_FULL_MASK
@ TRIGGERED_FULL_MASK
Used when doing CastSpell with triggered == true.
Definition: SpellDefines.h:266

TRIGGERED_CAST_DIRECTLY
@ TRIGGERED_CAST_DIRECTLY
In Spell::prepare, will be cast directly without setting containers for executed spell.
Definition: SpellDefines.h:254

TRIGGERED_IGNORE_CAST_IN_PROGRESS
@ TRIGGERED_IGNORE_CAST_IN_PROGRESS
Will not check if a current cast is in progress.
Definition: SpellDefines.h:252

TRIGGERED_IGNORE_GCD
@ TRIGGERED_IGNORE_GCD
Will ignore GCD.
Definition: SpellDefines.h:247

TRIGGERED_DONT_REPORT_CAST_ERROR
@ TRIGGERED_DONT_REPORT_CAST_ERROR
Will return SPELL_FAILED_DONT_REPORT in CheckCast functions.
Definition: SpellDefines.h:265

SpellValueMod
SpellValueMod
Definition: SpellDefines.h:195

SPELLVALUE_PARENT_SPELL_TARGET_COUNT
@ SPELLVALUE_PARENT_SPELL_TARGET_COUNT
Definition: SpellDefines.h:235

SPELLVALUE_PARENT_SPELL_TARGET_INDEX
@ SPELLVALUE_PARENT_SPELL_TARGET_INDEX
Definition: SpellDefines.h:236

SPELLVALUE_BASE_POINT0
@ SPELLVALUE_BASE_POINT0
Definition: SpellDefines.h:196

GetTeleportOptions
TeleportToOptions GetTeleportOptions(WorldObject const *caster, Unit const *unitTarget, SpellDestination const &targetDest)
Definition: SpellEffects.cpp:924

IsUnitTargetSceneObjectAura
bool IsUnitTargetSceneObjectAura(Spell const *spell, TargetInfo const &target)
Definition: SpellEffects.cpp:5678

SpellEffectHandlers
NonDefaultConstructible< SpellEffectHandlerFn > SpellEffectHandlers[TOTAL_SPELL_EFFECTS]
Definition: SpellEffects.cpp:89

SpellHistory.h

SPELL_ATTR0_CU_SHARE_DAMAGE
@ SPELL_ATTR0_CU_SHARE_DAMAGE
Definition: SpellInfo.h:151

IsPartOfSkillLine
bool IsPartOfSkillLine(uint32 skillId, uint32 spellId)
Definition: SpellMgr.cpp:118

SpellMgr.h

PROC_SPELL_PHASE_HIT
@ PROC_SPELL_PHASE_HIT
Definition: SpellMgr.h:264

sSpellMgr
#define sSpellMgr
Definition: SpellMgr.h:849

PROC_SPELL_TYPE_MASK_ALL
@ PROC_SPELL_TYPE_MASK_ALL
Definition: SpellMgr.h:255

PROC_FLAG_NONE
@ PROC_FLAG_NONE
Definition: SpellMgr.h:135

PROC_FLAG_2_KNOCKBACK
@ PROC_FLAG_2_KNOCKBACK
Definition: SpellMgr.h:234

PROC_HIT_DISPEL
@ PROC_HIT_DISPEL
Definition: SpellMgr.h:288

PROC_HIT_INTERRUPT
@ PROC_HIT_INTERRUPT
Definition: SpellMgr.h:286

PROC_HIT_NONE
@ PROC_HIT_NONE
Definition: SpellMgr.h:273

SpellPackets.h

Spell.h

DispelList
std::vector< std::pair< uint32, ObjectGuid > > DispelList
Definition: Spell.h:250

SPELL_EFFECT_HANDLE_LAUNCH_TARGET
@ SPELL_EFFECT_HANDLE_LAUNCH_TARGET
Definition: Spell.h:245

SPELL_EFFECT_HANDLE_LAUNCH
@ SPELL_EFFECT_HANDLE_LAUNCH
Definition: Spell.h:244

SPELL_EFFECT_HANDLE_HIT
@ SPELL_EFFECT_HANDLE_HIT
Definition: Spell.h:246

SPELL_EFFECT_HANDLE_HIT_TARGET
@ SPELL_EFFECT_HANDLE_HIT_TARGET
Definition: Spell.h:247

SPELL_STATE_PREPARING
@ SPELL_STATE_PREPARING
Definition: Spell.h:235

SPELL_STATE_CASTING
@ SPELL_STATE_CASTING
Definition: Spell.h:236

TalentPackets.h

TemporarySummon.h

Totem.h

TraitMgr.h

TraitPacketsCommon.h

MOVE_RUN
@ MOVE_RUN
Definition: UnitDefines.h:118

UNIT_PET_FLAG_CAN_BE_RENAMED
@ UNIT_PET_FLAG_CAN_BE_RENAMED
Definition: UnitDefines.h:109

REACT_DEFENSIVE
@ REACT_DEFENSIVE
Definition: UnitDefines.h:507

REACT_AGGRESSIVE
@ REACT_AGGRESSIVE
Definition: UnitDefines.h:508

SPELL_DIRECT_DAMAGE
@ SPELL_DIRECT_DAMAGE
Definition: UnitDefines.h:133

HEAL
@ HEAL
Definition: UnitDefines.h:135

UNIT_FLAG3_ALREADY_SKINNED
@ UNIT_FLAG3_ALREADY_SKINNED
Definition: UnitDefines.h:263

COMMAND_STAY
@ COMMAND_STAY
Definition: UnitDefines.h:526

UNIT_FLAG_IMMUNE
@ UNIT_FLAG_IMMUNE
Definition: UnitDefines.h:175

UNIT_FLAG_SKINNABLE
@ UNIT_FLAG_SKINNABLE
Definition: UnitDefines.h:170

Unit.h

UNIT_MASK_MINION
@ UNIT_MASK_MINION
Definition: Unit.h:351

UnitMods
UnitMods
Definition: Unit.h:172

UNIT_MOD_DAMAGE_OFFHAND
@ UNIT_MOD_DAMAGE_OFFHAND
Definition: Unit.h:214

UNIT_MOD_DAMAGE_RANGED
@ UNIT_MOD_DAMAGE_RANGED
Definition: Unit.h:215

UNIT_MOD_DAMAGE_MAINHAND
@ UNIT_MOD_DAMAGE_MAINHAND
Definition: Unit.h:213

ALIVE
@ ALIVE
Definition: Unit.h:246

CURRENT_FIRST_NON_MELEE_SPELL
#define CURRENT_FIRST_NON_MELEE_SPELL
Definition: Unit.h:595

CurrentSpellTypes
CurrentSpellTypes
Definition: Unit.h:588

CURRENT_AUTOREPEAT_SPELL
@ CURRENT_AUTOREPEAT_SPELL
Definition: Unit.h:592

UNIT_STATE_CONFUSED
@ UNIT_STATE_CONFUSED
Definition: Unit.h:266

UNIT_STATE_ROOT
@ UNIT_STATE_ROOT
Definition: Unit.h:265

UNIT_STATE_FLEEING
@ UNIT_STATE_FLEEING
Definition: Unit.h:262

UNIT_STATE_ALL_ERASABLE
@ UNIT_STATE_ALL_ERASABLE
Definition: Unit.h:302

UNIT_STATE_STUNNED
@ UNIT_STATE_STUNNED
Definition: Unit.h:258

DispelChargesList
std::vector< DispelableAura > DispelChargesList
Definition: Unit.h:146

NULL_BAG
@ NULL_BAG
Definition: Unit.h:62

NULL_SLOT
@ NULL_SLOT
Definition: Unit.h:63

ARTIFACTS_ALL_WEAPONS_GENERAL_WEAPON_EQUIPPED_PASSIVE
#define ARTIFACTS_ALL_WEAPONS_GENERAL_WEAPON_EQUIPPED_PASSIVE
Definition: Unit.h:37

TOTAL_PCT
@ TOTAL_PCT
Definition: Unit.h:161

Util.h

AddPct
T AddPct(T &base, U pct)
Definition: Util.h:85

ApplyPct
T ApplyPct(T &base, U pct)
Definition: Util.h:91

CalculatePct
T CalculatePct(T base, U pct)
Definition: Util.h:72

VEHICLE_SPELL_RIDE_HARDCODED
@ VEHICLE_SPELL_RIDE_HARDCODED
Definition: VehicleDefines.h:77

WorldPacket.h

WorldSession.h

World.h

AreaTrigger::CreateAreaTrigger
static AreaTrigger * CreateAreaTrigger(AreaTriggerCreatePropertiesId areaTriggerCreatePropertiesId, Position const &pos, int32 duration, Unit *caster, Unit *target, SpellCastVisual spellVisual={ 0, 0 }, SpellInfo const *spellInfo=nullptr, Spell *spell=nullptr, AuraEffect const *aurEff=nullptr)
Definition: AreaTrigger.cpp:256

AuraApplication
Definition: SpellAuras.h:57

AuraApplication::IsPositive
bool IsPositive() const
Definition: SpellAuras.h:84

AuraApplication::GetBase
Aura * GetBase() const
Definition: SpellAuras.h:78

AuraApplication::GetEffectsToApply
uint32 GetEffectsToApply() const
Definition: SpellAuras.h:87

AuraApplication::UpdateApplyEffectMask
void UpdateApplyEffectMask(uint32 newEffMask, bool canHandleNewEffects)
Definition: SpellAuras.cpp:185

AuraEffect
Definition: SpellAuraEffects.h:30

Aura
Definition: SpellAuras.h:119

Aura::TryCreate
static Aura * TryCreate(AuraCreateInfo &createInfo)
Definition: SpellAuras.cpp:377

Aura::SetStackAmount
void SetStackAmount(uint8 num)
Definition: SpellAuras.cpp:1016

Aura::GetApplicationOfTarget
AuraApplication const * GetApplicationOfTarget(ObjectGuid guid) const
Definition: SpellAuras.cpp:1320

Aura::GetDynobjOwner
DynamicObject * GetDynobjOwner() const
Definition: SpellAuras.h:148

Aura::_RegisterForTargets
void _RegisterForTargets()
Definition: SpellAuras.h:160

Aura::GetCasterGUID
ObjectGuid GetCasterGUID() const
Definition: SpellAuras.h:139

Aura::GetId
uint32 GetId() const
Definition: SpellAuras.h:135

Aura::CalcDispelChance
int32 CalcDispelChance(Unit const *auraTarget, bool offensive) const
Definition: SpellAuras.cpp:1198

Aura::ToDynObjAura
DynObjAura * ToDynObjAura()
Definition: SpellAuras.h:297

Aura::ModStackAmount
bool ModStackAmount(int32 num, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT, bool resetPeriodicTimer=true)
Definition: SpellAuras.cpp:1054

Aura::GetStackAmount
uint8 GetStackAmount() const
Definition: SpellAuras.h:189

Aura::_ApplyEffectForTargets
void _ApplyEffectForTargets(uint8 effIndex)
Definition: SpellAuras.cpp:752

Aura::GetCharges
uint8 GetCharges() const
Definition: SpellAuras.h:180

Aura::GetSpellInfo
SpellInfo const * GetSpellInfo() const
Definition: SpellAuras.h:134

Aura::IsPassive
bool IsPassive() const
Definition: SpellAuras.cpp:1111

AzeriteEmpoweredItem
Definition: AzeriteEmpoweredItem.h:24

AzeriteEmpoweredItem::ClearSelectedAzeritePowers
void ClearSelectedAzeritePowers()
Definition: AzeriteEmpoweredItem.cpp:139

AzeriteEmpoweredItem::GetRespecCost
int64 GetRespecCost() const
Definition: AzeriteEmpoweredItem.cpp:149

AzeriteItem
Definition: AzeriteItem.h:30

AzeriteItem::GetSelectedAzeriteEssences
UF::SelectedAzeriteEssences const * GetSelectedAzeriteEssences() const
Definition: AzeriteItem.cpp:351

AzeriteItem::SetEssenceRank
void SetEssenceRank(uint32 azeriteEssenceId, uint32 rank)
Definition: AzeriteItem.cpp:323

BasicEvent
Definition: EventProcessor.h:32

BattlePets::BattlePetMgr
Definition: BattlePetMgr.h:147

BattlePets::BattlePetMgr::GrantBattlePetExperience
void GrantBattlePetExperience(ObjectGuid guid, uint16 xp, BattlePetXpSource xpSource)
Definition: BattlePetMgr.cpp:700

BattlePets::BattlePetMgr::RollPetBreed
static uint16 RollPetBreed(uint32 species)
Definition: BattlePetMgr.cpp:201

BattlePets::BattlePetMgr::GetMaxPetLevel
uint16 GetMaxPetLevel() const
Definition: BattlePetMgr.cpp:602

BattlePets::BattlePetMgr::SelectPetDisplay
static uint32 SelectPetDisplay(BattlePetSpeciesEntry const *speciesEntry)
Definition: BattlePetMgr.cpp:219

BattlePets::BattlePetMgr::UnlockSlot
void UnlockSlot(BattlePetSlot slot)
Definition: BattlePetMgr.cpp:584

BattlePets::BattlePetMgr::GetBattlePetSpeciesBySpell
static BattlePetSpeciesEntry const * GetBattlePetSpeciesBySpell(uint32 spellId)
Definition: BattlePetMgr.cpp:196

BattlePets::BattlePetMgr::AddPet
void AddPet(uint32 species, uint32 display, uint16 breed, BattlePetBreedQuality quality, uint16 level=1)
Definition: BattlePetMgr.cpp:449

BattlePets::BattlePetMgr::GrantBattlePetLevel
void GrantBattlePetLevel(ObjectGuid guid, uint16 grantedLevels)
Definition: BattlePetMgr.cpp:760

BattlePets::BattlePetMgr::HasMaxPetCount
bool HasMaxPetCount(BattlePetSpeciesEntry const *battlePetSpecies, ObjectGuid ownerGuid) const
Definition: BattlePetMgr.cpp:567

BattlePets::BattlePetMgr::SendError
void SendError(BattlePetError error, uint32 creatureId)
Definition: BattlePetMgr.cpp:900

BattlePets::BattlePetMgr::ChangeBattlePetQuality
void ChangeBattlePetQuality(ObjectGuid guid, BattlePetBreedQuality quality)
Definition: BattlePetMgr.cpp:665

BattlePets::BattlePetMgr::GetDefaultPetQuality
static BattlePetBreedQuality GetDefaultPetQuality(uint32 species)
Definition: BattlePetMgr.cpp:210

Battleground
Definition: Battleground.h:256

CollectionMgr
Definition: CollectionMgr.h:83

CollectionMgr::AddTransmogSet
void AddTransmogSet(uint32 transmogSetId)
Definition: CollectionMgr.cpp:618

CollectionMgr::GetHeirloomBonus
uint32 GetHeirloomBonus(uint32 itemId) const
Definition: CollectionMgr.cpp:222

CollectionMgr::AddTransmogIllusion
void AddTransmogIllusion(uint32 transmogIllusionId)
Definition: CollectionMgr.cpp:948

Conversation
Definition: Conversation.h:30

Conversation::CreateConversation
static Conversation * CreateConversation(uint32 conversationEntry, Unit *creator, Position const &pos, ObjectGuid privateObjectOwner, SpellInfo const *spellInfo=nullptr, bool autoStart=true)
Definition: Conversation.cpp:98

Corpse::GetOwnerGUID
ObjectGuid GetOwnerGUID() const override
Definition: Corpse.h:98

CreatureTextMgr::GetRangeForChatType
static float GetRangeForChatType(ChatMsg msgType)
Definition: CreatureTextMgr.cpp:253

Creature
Definition: Creature.h:70

Creature::m_loot
std::unique_ptr< Loot > m_loot
Definition: Creature.h:277

Creature::GetCreatureDifficulty
CreatureDifficulty const * GetCreatureDifficulty() const
Definition: Creature.h:252

Creature::m_personalLoot
std::unordered_map< ObjectGuid, std::unique_ptr< Loot > > m_personalLoot
Definition: Creature.h:278

Creature::GetLevelForTarget
uint8 GetLevelForTarget(WorldObject const *target) const override
Definition: Creature.cpp:3104

Creature::StartPickPocketRefillTimer
void StartPickPocketRefillTimer()
Definition: Creature.cpp:3559

Creature::SetReactState
void SetReactState(ReactStates st)
Definition: Creature.h:160

Creature::DespawnOrUnsummon
void DespawnOrUnsummon(Milliseconds timeToDespawn=0s, Seconds forceRespawnTime=0s)
Definition: Creature.cpp:2415

Creature::CanGeneratePickPocketLoot
bool CanGeneratePickPocketLoot() const
Definition: Creature.cpp:3564

Creature::IsElite
bool IsElite() const
Definition: Creature.cpp:2476

Creature::SetImmuneToAll
void SetImmuneToAll(bool apply) override
Definition: Creature.h:167

Creature::IsIgnoringSanctuarySpellEffect
bool IsIgnoringSanctuarySpellEffect() const
Definition: Creature.h:324

Creature::SetDisplayId
void SetDisplayId(uint32 displayId, bool setNative=false) override
Definition: Creature.cpp:3402

DamageInfo
Definition: Unit.h:416

DamageInfo::GetResist
uint32 GetResist() const
Definition: Unit.h:449

DamageInfo::GetDamage
uint32 GetDamage() const
Definition: Unit.h:446

DamageInfo::GetAbsorb
uint32 GetAbsorb() const
Definition: Unit.h:448

DelayedSpellTeleportEvent
Definition: SpellEffects.cpp:984

DelayedSpellTeleportEvent::_targetDest
WorldLocation _targetDest
Definition: SpellEffects.cpp:1003

DelayedSpellTeleportEvent::_target
Unit * _target
Definition: SpellEffects.cpp:1002

DelayedSpellTeleportEvent::_options
TeleportToOptions _options
Definition: SpellEffects.cpp:1004

DelayedSpellTeleportEvent::DelayedSpellTeleportEvent
DelayedSpellTeleportEvent(Unit *target, WorldLocation const &targetDest, TeleportToOptions options, uint32 spellId)
Definition: SpellEffects.cpp:986

DelayedSpellTeleportEvent::_spellId
uint32 _spellId
Definition: SpellEffects.cpp:1005

DelayedSpellTeleportEvent::Execute
bool Execute(uint64, uint32) override
Definition: SpellEffects.cpp:989

DispelableAura
Definition: Unit.h:122

DynamicObject
Definition: DynamicObject.h:37

DynamicObject::SetCasterViewpoint
void SetCasterViewpoint()
Definition: DynamicObject.cpp:210

DynamicObject::SetDuration
void SetDuration(int32 newDuration)
Definition: DynamicObject.cpp:182

DynamicObject::CreateDynamicObject
bool CreateDynamicObject(ObjectGuid::LowType guidlow, Unit *caster, SpellInfo const *spell, Position const &pos, float radius, DynamicObjectType type, SpellCastVisual spellVisual)
Definition: DynamicObject.cpp:84

EventProcessor::AddEventAtOffset
void AddEventAtOffset(BasicEvent *event, Milliseconds offset)
Definition: EventProcessor.h:105

GameObject
Definition: GameObject.h:166

GameObject::GetGOInfo
GameObjectTemplate const * GetGOInfo() const
Definition: GameObject.h:202

GameObject::GetFaction
uint32 GetFaction() const override
Definition: GameObject.h:388

GameObject::CreateGameObject
static GameObject * CreateGameObject(uint32 entry, Map *map, Position const &pos, QuaternionData const &rotation, uint32 animProgress, GOState goState, uint32 artKit=0)
Definition: GameObject.cpp:1195

GameObject::SetOwnerGUID
void SetOwnerGUID(ObjectGuid owner)
Definition: GameObject.h:232

GameObject::SetDestructibleState
void SetDestructibleState(GameObjectDestructibleState state, WorldObject *attackerOrHealer=nullptr, bool setHealth=false)
Definition: GameObject.cpp:3656

GameObject::AddToSkillupList
void AddToSkillupList(ObjectGuid const &PlayerGuidLow)
Definition: GameObject.h:312

GameObject::SetLootState
void SetLootState(LootState s, Unit *unit=nullptr)
Definition: GameObject.cpp:3750

GameObject::GetLinkedTrap
GameObject * GetLinkedTrap()
Definition: GameObject.cpp:3976

GameObject::SetRespawnTime
void SetRespawnTime(int32 respawn)
Definition: GameObject.cpp:2211

GameObject::IsInSkillupList
bool IsInSkillupList(ObjectGuid const &playerGuid) const
Definition: GameObject.h:313

GameObject::GetGoType
GameobjectTypes GetGoType() const
Definition: GameObject.h:279

GameObject::SetLevel
void SetLevel(uint32 level)
Definition: GameObject.h:278

GameObject::ModifyHealth
void ModifyHealth(int32 change, WorldObject *attackerOrHealer=nullptr, uint32 spellId=0)
Definition: GameObject.cpp:3607

GameObject::Use
void Use(Unit *user)
Definition: GameObject.cpp:2511

GameObject::ActivateObject
void ActivateObject(GameObjectActions action, int32 param, WorldObject *spellCaster=nullptr, uint32 spellId=0, int32 effectIndex=-1)
Definition: GameObject.cpp:2332

GameObject::AddUniqueUse
void AddUniqueUse(Player *player)
Definition: GameObject.cpp:1713

GameObject::SetSpellId
void SetSpellId(uint32 id)
Definition: GameObject.h:244

GameObject::SetFaction
void SetFaction(uint32 faction) override
Definition: GameObject.h:389

Garrison
Definition: Garrison.h:184

Group
Definition: Group.h:197

Group::IsAssistant
bool IsAssistant(ObjectGuid guid) const
Definition: Group.h:311

Group::AddRaidMarker
void AddRaidMarker(uint8 markerId, uint32 mapId, float positionX, float positionY, float positionZ, ObjectGuid transportGuid=ObjectGuid::Empty)
Definition: Group.cpp:1586

Group::IsLeader
bool IsLeader(ObjectGuid guid) const
Definition: Group.cpp:1700

Group::GetGUID
ObjectGuid GetGUID() const
Definition: Group.cpp:1663

Group::isRaidGroup
bool isRaidGroup() const
Definition: Group.cpp:1638

Guardian
Definition: TemporarySummon.h:132

Guild
Definition: Guild.h:329

HealInfo
Definition: Unit.h:456

Item
Definition: Item.h:170

Item::SetState
void SetState(ItemUpdateState state, Player *forplayer=nullptr)
Definition: Item.cpp:1166

Item::GetSlot
uint8 GetSlot() const
Definition: Item.h:280

Item::SetItemFlag
void SetItemFlag(ItemFieldFlags flags)
Definition: Item.h:209

Item::GetEffects
Trinity::IteratorPair< ItemEffectEntry const *const * > GetEffects() const
Definition: Item.h:354

Item::GetEnchantmentId
uint32 GetEnchantmentId(EnchantmentSlot slot) const
Definition: Item.h:298

Item::IsVellum
bool IsVellum() const
Definition: Item.h:334

Item::IsAzeriteEmpoweredItem
bool IsAzeriteEmpoweredItem() const
Definition: Item.h:254

Item::ToAzeriteItem
AzeriteItem * ToAzeriteItem()
Definition: Item.h:243

Item::GetEnchantmentDuration
uint32 GetEnchantmentDuration(EnchantmentSlot slot) const
Definition: Item.h:299

Item::SetCount
void SetCount(uint32 value)
Definition: Item.cpp:1275

Item::SetModifier
void SetModifier(ItemModifier modifier, uint32 value)
Definition: Item.cpp:2436

Item::GetTemplate
ItemTemplate const * GetTemplate() const
Definition: Item.cpp:1141

Item::GetContext
ItemContext GetContext() const
Definition: Item.h:441

Item::IsEquipped
bool IsEquipped() const
Definition: Item.cpp:1244

Item::GetOwner
Player * GetOwner() const
Definition: Item.cpp:1146

Item::GetOwnerGUID
ObjectGuid GetOwnerGUID() const
Definition: Item.h:188

Item::GetPos
uint16 GetPos() const
Definition: Item.h:284

Item::GetDisenchantLoot
ItemDisenchantLootEntry const * GetDisenchantLoot(Player const *owner) const
Definition: Item.cpp:2360

Item::m_loot
std::unique_ptr< Loot > m_loot
Definition: Item.h:317

Item::GetEnchantmentCharges
uint32 GetEnchantmentCharges(EnchantmentSlot slot) const
Definition: Item.h:300

Item::ClearSoulboundTradeable
void ClearSoulboundTradeable(Player *currentOwner)
Definition: Item.cpp:1913

Item::GetCount
uint32 GetCount() const
Definition: Item.h:273

Item::ToAzeriteEmpoweredItem
AzeriteEmpoweredItem * ToAzeriteEmpoweredItem()
Definition: Item.h:245

Item::GetBagSlot
uint8 GetBagSlot() const
Definition: Item.cpp:1239

Item::GetModifier
uint32 GetModifier(ItemModifier modifier) const
Definition: Item.cpp:2423

Item::SetEnchantment
void SetEnchantment(EnchantmentSlot slot, uint32 id, uint32 duration, uint32 charges, ObjectGuid caster=ObjectGuid::Empty)
Definition: Item.cpp:1421

Item::m_itemData
UF::UpdateField< UF::ItemData, 0, TYPEID_ITEM > m_itemData
Definition: Item.h:449

Item::CreateItem
static Item * CreateItem(uint32 itemEntry, uint32 count, ItemContext context, Player const *player=nullptr, bool addDefaultBonuses=true)
Definition: Item.cpp:1625

Map
Definition: Map.h:189

Map::IsDungeon
bool IsDungeon() const
Definition: Map.cpp:3238

Map::ScriptsStart
void ScriptsStart(std::map< uint32, std::multimap< uint32, ScriptInfo > > const &scripts, uint32 id, Object *source, Object *target)
Put scripts in the execution queue.
Definition: MapScripts.cpp:34

Map::AddToMap
bool AddToMap(T *)
Definition: Map.cpp:550

Map::SummonCreature
TempSummon * SummonCreature(uint32 entry, Position const &pos, SummonPropertiesEntry const *properties=nullptr, Milliseconds duration=0ms, WorldObject *summoner=nullptr, uint32 spellId=0, uint32 vehId=0, ObjectGuid privateObjectOwner=ObjectGuid::Empty, SmoothPhasingInfo const *smoothPhasingInfo=nullptr)
Definition: Object.cpp:1836

Map::GenerateLowGuid
ObjectGuid::LowType GenerateLowGuid()
Definition: Map.h:519

Map::GetGameObject
GameObject * GetGameObject(ObjectGuid const &guid)
Definition: Map.cpp:3489

Map::GetCreature
Creature * GetCreature(ObjectGuid const &guid)
Definition: Map.cpp:3479

Minion
Definition: TemporarySummon.h:97

Minion::GetOwner
Unit * GetOwner() const
Definition: TemporarySummon.h:103

Minion::GetFollowAngle
float GetFollowAngle() const override
Definition: TemporarySummon.h:104

MotionMaster::MoveJumpWithGravity
void MoveJumpWithGravity(Position const &pos, float speedXY, float gravity, uint32 id=EVENT_JUMP, bool hasOrientation=false, JumpArrivalCastArgs const *arrivalCast=nullptr, Movement::SpellEffectExtraData const *spellEffectExtraData=nullptr)
Definition: MotionMaster.cpp:870

MotionMaster::MoveJump
void MoveJump(Position const &pos, float speedXY, float speedZ, uint32 id=EVENT_JUMP, bool hasOrientation=false, JumpArrivalCastArgs const *arrivalCast=nullptr, Movement::SpellEffectExtraData const *spellEffectExtraData=nullptr)
Definition: MotionMaster.cpp:828

MotionMaster::CalculateJumpSpeeds
void CalculateJumpSpeeds(float dist, UnitMoveType moveType, float speedMultiplier, float minHeight, float maxHeight, float &speedXY, float &speedZ) const
Definition: MotionMaster.cpp:1171

MotionMaster::MoveCharge
void MoveCharge(float x, float y, float z, float speed=SPEED_CHARGE, uint32 id=EVENT_CHARGE, bool generatePath=false, Unit const *target=nullptr, Movement::SpellEffectExtraData const *spellEffectExtraData=nullptr)
Definition: MotionMaster.cpp:744

MotionMaster::MoveDistract
void MoveDistract(uint32 time, float orientation)
Definition: MotionMaster.cpp:1105

ObjectGuid
Definition: ObjectGuid.h:268

ObjectGuid::Empty
static ObjectGuid const Empty
Definition: ObjectGuid.h:274

ObjectGuid::IsEmpty
bool IsEmpty() const
Definition: ObjectGuid.h:319

ObjectGuid::ToString
std::string ToString() const
Definition: ObjectGuid.cpp:554

ObjectGuid::Clear
void Clear()
Definition: ObjectGuid.h:286

Object
Definition: Object.h:150

Object::SetDynamicFlag
void SetDynamicFlag(uint32 flag)
Definition: Object.h:169

Object::ToCreature
static Creature * ToCreature(Object *o)
Definition: Object.h:219

Object::IsPlayer
bool IsPlayer() const
Definition: Object.h:212

Object::ToUnit
static Unit * ToUnit(Object *o)
Definition: Object.h:225

Object::ToPlayer
Player * ToPlayer()
Definition: Object.h:215

Object::ToGameObject
static GameObject * ToGameObject(Object *o)
Definition: Object.h:231

Object::IsInWorld
bool IsInWorld() const
Definition: Object.h:154

Object::ToConversation
static Conversation * ToConversation(Object *o)
Definition: Object.h:261

Object::GetTypeId
TypeID GetTypeId() const
Definition: Object.h:173

Object::ReplaceAllDynamicFlags
void ReplaceAllDynamicFlags(uint32 flag)
Definition: Object.h:171

Object::GetEntry
uint32 GetEntry() const
Definition: Object.h:161

Object::IsCreature
bool IsCreature() const
Definition: Object.h:218

Object::ToCreature
Creature * ToCreature()
Definition: Object.h:221

Object::GetGUID
static ObjectGuid GetGUID(Object const *o)
Definition: Object.h:159

Object::ToPlayer
static Player * ToPlayer(Object *o)
Definition: Object.h:213

PathGenerator
Definition: PathGenerator.h:56

PathGenerator::GetPathLength
float GetPathLength() const
Definition: PathGenerator.cpp:969

PathGenerator::CalculatePath
bool CalculatePath(float destX, float destY, float destZ, bool forceDest=false)
Definition: PathGenerator.cpp:57

PetAura
Definition: SpellMgr.h:480

PetStable
Definition: PetDefines.h:134

PetStable::ActivePets
std::array< Optional< PetInfo >, MAX_ACTIVE_PETS > ActivePets
Definition: PetDefines.h:158

Pet
Definition: Pet.h:40

Pet::SetSpecialization
void SetSpecialization(uint16 spec)
Definition: Pet.cpp:1898

Pet::GetOwner
Player * GetOwner() const
Definition: Pet.cpp:1794

Pet::SavePetToDB
void SavePetToDB(PetSaveMode mode)
Definition: Pet.cpp:452

Pet::isControlled
bool isControlled() const
Definition: Pet.h:53

Pet::setDeathState
void setDeathState(DeathState s) override
Definition: Pet.cpp:599

Pet::Remove
void Remove(PetSaveMode mode, bool returnreagent=false)
Definition: Pet.cpp:712

Pet::learnSpell
bool learnSpell(uint32 spell_id)
Definition: Pet.cpp:1446

PhasingHandler::InheritPhaseShift
static void InheritPhaseShift(WorldObject *target, WorldObject const *source)
Definition: PhasingHandler.cpp:262

PhasingHandler::OnConditionChange
static bool OnConditionChange(WorldObject *object, bool updateVisibility=true)
Definition: PhasingHandler.cpp:369

PlayerSocial::HasIgnore
bool HasIgnore(ObjectGuid const &ignoreGuid, ObjectGuid const &ignoreAccountGuid)
Definition: SocialMgr.cpp:189

Player
Definition: Player.h:1109

Player::LearnSpell
void LearnSpell(uint32 spell_id, bool dependent, int32 fromSkill=0, bool suppressMessaging=false, Optional< int32 > traitDefinitionId={})
Definition: Player.cpp:3216

Player::AutoStoreLoot
void AutoStoreLoot(uint8 bag, uint8 slot, uint32 loot_id, LootStore const &store, ItemContext context=ItemContext::NONE, bool broadcast=false, bool createdByPlayer=false)
Definition: Player.cpp:26395

Player::SendMovieStart
void SendMovieStart(uint32 movieId)
Definition: Player.cpp:6338

Player::SendLootError
void SendLootError(ObjectGuid const &lootObj, ObjectGuid const &owner, LootError error) const
Definition: Player.cpp:9148

Player::SendEquipError
void SendEquipError(InventoryResult msg, Item const *item1=nullptr, Item const *item2=nullptr, uint32 itemId=0) const
Definition: Player.cpp:13254

Player::KilledMonsterCredit
void KilledMonsterCredit(uint32 entry, ObjectGuid guid=ObjectGuid::Empty)
Definition: Player.cpp:16680

Player::SendPlayerBound
void SendPlayerBound(ObjectGuid const &binderGuid, uint32 areaId) const
Definition: Player.cpp:17607

Player::GetArmorProficiency
uint32 GetArmorProficiency() const
Definition: Player.h:1485

Player::IsEquipmentPos
static bool IsEquipmentPos(uint16 pos)
Definition: Player.h:1365

Player::ApplyAzeriteEssence
void ApplyAzeriteEssence(AzeriteItem *item, uint32 azeriteEssenceId, uint32 rank, bool major, bool apply)
Definition: Player.cpp:8557

Player::GetNumRespecs
uint8 GetNumRespecs() const
Definition: Player.h:2837

Player::StoreNewItem
Item * StoreNewItem(ItemPosCountVec const &pos, uint32 itemId, bool update, ItemRandomBonusListId randomBonusListId=0, GuidSet const &allowedLooters=GuidSet(), ItemContext context=ItemContext::NONE, std::vector< int32 > const *bonusListIDs=nullptr, bool addToCollection=true)
Definition: Player.cpp:11537

Player::HasPvPForcingQuest
bool HasPvPForcingQuest() const
Definition: Player.cpp:17391

Player::GetNextResetTalentsCost
uint32 GetNextResetTalentsCost() const
Definition: Player.cpp:3496

Player::ModifyMoney
bool ModifyMoney(int64 amount, bool sendError=true)
Definition: Player.cpp:24098

Player::CanEquipItem
InventoryResult CanEquipItem(uint8 slot, uint16 &dest, Item *pItem, bool swap, bool not_loading=true) const
Definition: Player.cpp:10896

Player::SetPlayerFlag
void SetPlayerFlag(PlayerFlags flags)
Definition: Player.h:2738

Player::GetSocial
PlayerSocial * GetSocial() const
Definition: Player.h:1163

Player::m_playerData
UF::UpdateField< UF::PlayerData, 0, TYPEID_PLAYER > m_playerData
Definition: Player.h:2863

Player::SendBindPointUpdate
void SendBindPointUpdate() const
Definition: Player.cpp:17598

Player::EnvironmentalDamage
uint32 EnvironmentalDamage(EnviromentalDamage type, uint32 damage)
Definition: Player.cpp:634

Player::GetDrunkValue
uint8 GetDrunkValue() const
Definition: Player.h:2288

Player::SendDirectMessage
void SendDirectMessage(WorldPacket const *data) const
Definition: Player.cpp:6324

Player::GetSkillValue
uint16 GetSkillValue(uint32 skill) const
Definition: Player.cpp:6052

Player::BankItem
Item * BankItem(ItemPosCountVec const &dest, Item *pItem, bool update)
Definition: Player.cpp:12043

Player::RemoveTalent
void RemoveTalent(TalentEntry const *talent)
Definition: Player.cpp:2722

Player::DespawnPersonalSummonsForQuest
void DespawnPersonalSummonsForQuest(uint32 questId)
Definition: Player.cpp:16363

Player::FindQuestSlot
uint16 FindQuestSlot(uint32 quest_id) const
Definition: Player.cpp:16432

Player::SetCanParry
void SetCanParry(bool value)
Definition: Player.cpp:26103

Player::CanStoreItem
InventoryResult CanStoreItem(uint8 bag, uint8 slot, ItemPosCountVec &dest, Item *pItem, bool swap=false) const
Definition: Player.cpp:10037

Player::CreateGarrison
void CreateGarrison(uint32 garrSiteId)
Definition: Player.cpp:29216

Player::SummonPet
Pet * SummonPet(uint32 entry, Optional< PetSaveMode > slot, float x, float y, float z, float ang, uint32 despwtime, bool *isNew=nullptr)
Definition: Player.cpp:29444

Player::TeleportTo
bool TeleportTo(uint32 mapid, float x, float y, float z, float orientation, TeleportToOptions options=TELE_TO_NONE, Optional< uint32 > instanceId={})
Definition: Player.cpp:1250

Player::SetCanTitanGrip
void SetCanTitanGrip(bool value, uint32 penaltySpellId=0)
Definition: Player.cpp:13324

Player::SendProficiency
void SendProficiency(ItemClass itemClass, uint32 itemSubclassMask) const
Definition: Player.cpp:22444

Player::SendTalentsInfoData
void SendTalentsInfoData()
Definition: Player.cpp:27287

Player::UpdatePvPState
void UpdatePvPState(bool onlyFFA=false)
Definition: Player.cpp:23317

Player::DurabilityLossAll
void DurabilityLossAll(double percent, bool inventory)
Definition: Player.cpp:4611

Player::AddHonorXP
void AddHonorXP(uint32 xp)
Definition: Player.cpp:6921

Player::GetDeathTimer
uint32 GetDeathTimer() const
Definition: Player.h:2291

Player::SendPlayerChoice
void SendPlayerChoice(ObjectGuid sender, int32 choiceId)
Definition: Player.cpp:29251

Player::_ApplyItemMods
void _ApplyItemMods(Item *item, uint8 slot, bool apply, bool updateItemAuras=true)
Definition: Player.cpp:7865

Player::GiveXP
void GiveXP(uint32 xp, Unit *victim, float group_rate=1.0f)
Definition: Player.cpp:2210

Player::SetResurrectRequestData
void SetResurrectRequestData(WorldObject const *caster, uint32 health, uint32 mana, uint32 appliedAura)
Definition: Player.cpp:23402

Player::GetItemByEntry
Item * GetItemByEntry(uint32 entry, ItemSearchLocation where=ItemSearchLocation::Default) const
Definition: Player.cpp:12589

Player::SpawnCorpseBones
void SpawnCorpseBones(bool triggerSave=true)
Definition: Player.cpp:4598

Player::SetDrunkValue
void SetDrunkValue(uint8 newDrunkValue, uint32 itemId=0)
Definition: Player.cpp:887

Player::GetGlyphs
std::vector< uint32 > const & GetGlyphs(uint8 spec) const
Definition: Player.h:1877

Player::GetPetStable
PetStable * GetPetStable()
Definition: Player.h:1222

Player::PetSpellInitialize
void PetSpellInitialize()
Definition: Player.cpp:21879

Player::GetSceneMgr
SceneMgr & GetSceneMgr()
Definition: Player.h:2715

Player::SetFallInformation
void SetFallInformation(uint32 time, float z)
Definition: Player.cpp:26672

Player::ApplyEnchantment
void ApplyEnchantment(Item *item, EnchantmentSlot slot, bool apply, bool apply_dur=true, bool ignore_condition=false)
Definition: Player.cpp:13577

Player::ActivateTalentGroup
void ActivateTalentGroup(ChrSpecializationEntry const *spec)
Definition: Player.cpp:27923

Player::UpdateCraftSkill
bool UpdateCraftSkill(SpellInfo const *spellInfo)
Definition: Player.cpp:5541

Player::CanAddQuest
bool CanAddQuest(Quest const *quest, bool msg) const
Definition: Player.cpp:14632

Player::CanBankItem
InventoryResult CanBankItem(uint8 bag, uint8 slot, ItemPosCountVec &dest, Item *pItem, bool swap, bool not_loading=true, bool reagentBankOnly=false) const
Definition: Player.cpp:11172

Player::SetSkill
void SetSkill(uint32 id, uint16 step, uint16 newVal, uint16 maxVal)
Definition: Player.cpp:5786

Player::GetPet
Pet * GetPet() const
Definition: Player.cpp:21513

Player::m_homebind
WorldLocation m_homebind
Definition: Player.h:2503

Player::GetGuild
Guild * GetGuild()
Definition: Player.cpp:29432

Player::SetNumRespecs
void SetNumRespecs(uint8 numRespecs)
Definition: Player.h:2838

Player::GetPureSkillValue
uint16 GetPureSkillValue(uint32 skill) const
Definition: Player.cpp:6108

Player::RemoveTradeableItem
void RemoveTradeableItem(Item *item)
Definition: Player.cpp:13414

Player::SetCanBlock
void SetCanBlock(bool value)
Definition: Player.cpp:26112

Player::GetCommandStatus
bool GetCommandStatus(uint32 command) const
Definition: Player.h:1206

Player::StoreItem
Item * StoreItem(ItemPosCountVec const &pos, Item *pItem, bool update)
Definition: Player.cpp:11612

Player::GetSession
WorldSession * GetSession() const
Definition: Player.h:2101

Player::UpdateAreaDependentAuras
void UpdateAreaDependentAuras(uint32 area_id)
Definition: Player.cpp:25785

Player::GetItemByPos
Item * GetItemByPos(uint16 pos) const
Definition: Player.cpp:9582

Player::GetRestMgr
RestMgr & GetRestMgr() const
Definition: Player.h:2717

Player::RepopAtGraveyard
void RepopAtGraveyard()
Definition: Player.cpp:4832

Player::GetQuestSlotQuestId
uint32 GetQuestSlotQuestId(uint16 slot) const
Definition: Player.cpp:16441

Player::DestroyItem
void DestroyItem(uint8 bag, uint8 slot, bool update)
Definition: Player.cpp:12180

Player::IsResurrectRequested
bool IsResurrectRequested() const
Definition: Player.h:1933

Player::IsInventoryPos
static bool IsInventoryPos(uint16 pos)
Definition: Player.h:1363

Player::ActivateTaxiPathTo
bool ActivateTaxiPathTo(std::vector< uint32 > const &nodes, Creature *npc=nullptr, uint32 spellid=0, uint32 preferredMountDisplay=0)
Definition: Player.cpp:22506

Player::SendLoot
void SendLoot(Loot &loot, bool aeLooting=false)
Definition: Player.cpp:9119

Player::UpdateTraitConfig
void UpdateTraitConfig(WorldPackets::Traits::TraitConfig &&newConfig, int32 savedConfigId, bool withCastTime)
Definition: Player.cpp:28256

Player::DestroyItemCount
uint32 DestroyItemCount(uint32 item, uint32 count, bool update, bool unequip_check=false)
Definition: Player.cpp:12281

Player::RemovePet
void RemovePet(Pet *pet, PetSaveMode mode, bool returnreagent=false)
Definition: Player.cpp:21537

Player::CalculateReputationGain
int32 CalculateReputationGain(ReputationSource source, uint32 creatureOrQuestLevel, int32 rep, int32 faction, bool noQuestBonus=false)
Definition: Player.cpp:6504

Player::GetActionButton
ActionButton const * GetActionButton(uint8 button)
Definition: Player.cpp:6264

Player::DurabilityLoss
void DurabilityLoss(Item *item, double percent)
Definition: Player.cpp:4635

Player::GetWeaponProficiency
uint32 GetWeaponProficiency() const
Definition: Player.h:1484

Player::SendRespecWipeConfirm
void SendRespecWipeConfirm(ObjectGuid const &guid, uint32 cost, SpecResetType respecType) const
Definition: Player.cpp:9210

Player::GetBattleground
Battleground * GetBattleground() const
Definition: Player.cpp:24976

Player::SetRewardedQuest
void SetRewardedQuest(uint32 quest_id)
Definition: Player.cpp:15437

Player::GetSkillStep
uint16 GetSkillStep(uint32 skill) const
Definition: Player.cpp:6040

Player::AutoUnequipOffhandIfNeed
void AutoUnequipOffhandIfNeed(bool force=false)
Definition: Player.cpp:25403

Player::ItemAddedQuestCheck
void ItemAddedQuestCheck(uint32 entry, uint32 count, Optional< bool > boundItemFlagRequirement={}, bool *hadBoundItemObjective=nullptr)
Definition: Player.cpp:16624

Player::EquipItem
Item * EquipItem(uint16 pos, Item *pItem, bool update)
Definition: Player.cpp:11754

Player::SetDuelArbiter
void SetDuelArbiter(ObjectGuid guid)
Definition: Player.h:1976

Player::pvpInfo
PvPInfo pvpInfo
Definition: Player.h:1953

Player::SetQuestSlot
void SetQuestSlot(uint16 slot, uint32 quest_id)
Definition: Player.cpp:16505

Player::AddQuestAndCheckCompletion
void AddQuestAndCheckCompletion(Quest const *quest, Object *questGiver)
Definition: Player.cpp:14774

Player::DurabilityPointsLossAll
void DurabilityPointsLossAll(int32 points, bool inventory)
Definition: Player.cpp:4655

Player::CanTakeQuest
bool CanTakeQuest(Quest const *quest, bool msg) const
Definition: Player.cpp:14620

Player::GetProfessionSkillForExp
uint32 GetProfessionSkillForExp(uint32 skill, int32 expansion) const
Definition: Player.cpp:6005

Player::GetActiveTalentGroup
uint8 GetActiveTalentGroup() const
Definition: Player.h:1843

Player::RemoveSpell
void RemoveSpell(uint32 spell_id, bool disabled=false, bool learn_low_rank=true, bool suppressMessaging=false)
Definition: Player.cpp:3260

Player::SendSummonRequestFrom
void SendSummonRequestFrom(Unit *summoner)
Definition: Player.cpp:25306

Player::AreaExploredOrEventHappens
void AreaExploredOrEventHappens(uint32 questId)
Definition: Player.cpp:16577

Player::TakeQuestSourceItem
bool TakeQuestSourceItem(uint32 questId, bool msg)
Definition: Player.cpp:15999

Player::RemoveActiveQuest
void RemoveActiveQuest(uint32 questId, bool update=true)
Definition: Player.cpp:16093

Player::GetQuestStatus
QuestStatus GetQuestStatus(uint32 quest_id) const
Definition: Player.cpp:16050

Player::m_activePlayerData
UF::UpdateField< UF::ActivePlayerData, 0, TYPEID_ACTIVE_PLAYER > m_activePlayerData
Definition: Player.h:2864

Player::GetGarrison
Garrison * GetGarrison() const
Definition: Player.h:2710

Player::CreateTraitConfig
void CreateTraitConfig(WorldPackets::Traits::TraitConfig &traitConfig)
Definition: Player.cpp:28195

Player::AddArmorProficiency
void AddArmorProficiency(uint32 newflag)
Definition: Player.h:1483

Player::SetHomebind
void SetHomebind(WorldLocation const &loc, uint32 areaId)
Definition: Player.cpp:17581

Player::FailQuest
void FailQuest(uint32 quest_id)
Definition: Player.cpp:15446

Player::IsBankPos
static bool IsBankPos(uint16 pos)
Definition: Player.h:1368

Player::RemoveItem
void RemoveItem(uint8 bag, uint8 slot, bool update)
Definition: Player.cpp:12048

Player::HasSpell
bool HasSpell(uint32 spell) const override
Definition: Player.cpp:3792

Player::GetGroup
Group * GetGroup(Optional< uint8 > partyIndex)
Definition: Player.h:2606

Player::duel
std::unique_ptr< DuelInfo > duel
Definition: Player.h:1972

Player::RemoveRewardedQuest
void RemoveRewardedQuest(uint32 questId, bool update=true)
Definition: Player.cpp:16113

Player::DurabilityPointsLoss
void DurabilityPointsLoss(Item *item, int32 points)
Definition: Player.cpp:4679

Player::SetVisibleItemSlot
void SetVisibleItemSlot(uint8 slot, Item *pItem)
Definition: Player.cpp:11995

Player::GetItemByGuid
Item * GetItemByGuid(ObjectGuid guid) const
Definition: Player.cpp:9566

Player::RemovedInsignia
void RemovedInsignia(Player *looterPlr)
Definition: Player.cpp:9062

Player::UpdateGatherSkill
bool UpdateGatherSkill(uint32 skillId, uint32 skillValue, uint32 redLevel, uint32 multiplicator=1, WorldObject const *object=nullptr)
Definition: Player.cpp:5576

Player::AddWeaponProficiency
void AddWeaponProficiency(uint32 newflag)
Definition: Player.h:1482

Player::ModifyCurrency
void ModifyCurrency(uint32 id, int32 amount, CurrencyGainSource gainSource=CurrencyGainSource::Cheat, CurrencyDestroyReason destroyReason=CurrencyDestroyReason::Cheat)
Modify currency amount.
Definition: Player.cpp:7110

Player::CanStoreNewItem
InventoryResult CanStoreNewItem(uint8 bag, uint8 slot, ItemPosCountVec &dest, uint32 item, uint32 count, uint32 *no_space_count=nullptr) const
Definition: Player.cpp:10032

Player::PlayerTalkClass
std::unique_ptr< PlayerMenu > PlayerTalkClass
Definition: Player.h:2380

Player::GetReputationMgr
ReputationMgr & GetReputationMgr()
Definition: Player.h:2251

Player::AddPetAura
void AddPetAura(PetAura const *petSpell)
Definition: Player.cpp:21636

Player::RewardPlayerAndGroupAtEvent
void RewardPlayerAndGroupAtEvent(uint32 creature_id, WorldObject *pRewardSource)
Definition: Player.cpp:25645

Player::SendNewItem
void SendNewItem(Item *item, uint32 quantity, bool received, bool created, bool broadcast=false, uint32 dungeonEncounterId=0)
Definition: Player.cpp:13990

Player::ResurrectPlayer
void ResurrectPlayer(float restore_percent, bool applySickness=false)
Definition: Player.cpp:4408

Quest
Definition: QuestDef.h:539

Quest::XPValue
uint32 XPValue(Player const *player) const
Definition: QuestDef.cpp:386

Quest::HasFlag
bool HasFlag(QuestFlags flag) const
Definition: QuestDef.h:569

ReputationMgr::ModifyReputation
bool ModifyReputation(FactionEntry const *factionEntry, int32 standing, bool spillOverOnly=false, bool noSpillover=false)
Definition: ReputationMgr.h:135

RestMgr::AddRestBonus
void AddRestBonus(RestTypes restType, float restBonus)
Definition: RestMgr.cpp:85

RestMgr::CalcExtraPerSec
float CalcExtraPerSec(RestTypes restType, float bubble) const
Definition: RestMgr.cpp:161

SceneMgr::PlaySceneByPackageId
uint32 PlaySceneByPackageId(uint32 sceneScriptPackageId, EnumFlag< SceneFlag > playbackflags, Position const *position=nullptr)
Definition: SceneMgr.cpp:83

SceneMgr::PlayScene
uint32 PlayScene(uint32 sceneId, Position const *position=nullptr)
Definition: SceneMgr.cpp:36

SceneObject
Definition: SceneObject.h:33

SceneObject::CreateSceneObject
static SceneObject * CreateSceneObject(uint32 sceneId, Unit *creator, Position const &pos, ObjectGuid privateObjectOwner)
Definition: SceneObject.cpp:92

SpellCastTargets
Definition: SpellDefines.h:331

SpellCastTargets::SetItemTarget
void SetItemTarget(Item *item)
Definition: Spell.cpp:295

SpellCastTargets::SetDst
void SetDst(float x, float y, float z, float orientation, uint32 mapId=MAPID_INVALID)
Definition: Spell.cpp:373

SpellCastTargets::SetGOTarget
void SetGOTarget(GameObject *target)
Definition: Spell.cpp:252

SpellCastTargets::GetObjectTargetGUID
ObjectGuid GetObjectTargetGUID() const
Definition: Spell.cpp:283

SpellCastTargets::SetUnitTarget
void SetUnitTarget(Unit *target)
Definition: Spell.cpp:226

SpellCastTargets::HasDst
bool HasDst() const
Definition: Spell.cpp:425

SpellCastTargets::GetItemTarget
Item * GetItemTarget() const
Definition: SpellDefines.h:360

SpellCastTargets::GetUnitTarget
Unit * GetUnitTarget() const
Definition: Spell.cpp:218

SpellCastTargets::Update
void Update(WorldObject *caster)
Definition: Spell.cpp:430

SpellCastTargets::GetDstPos
WorldLocation const * GetDstPos() const
Definition: Spell.cpp:368

SpellEffectInfo
Definition: SpellInfo.h:213

SpellEffectInfo::PositionFacing
float PositionFacing
Definition: SpellInfo.h:230

SpellEffectInfo::HasRadius
bool HasRadius(SpellTargetIndex targetIndex) const
Definition: SpellInfo.cpp:660

SpellEffectInfo::CalcValue
int32 CalcValue(WorldObject const *caster=nullptr, int32 const *basePoints=nullptr, Unit const *target=nullptr, float *variance=nullptr, uint32 castItemId=0, int32 itemLevel=-1) const
Definition: SpellInfo.cpp:495

SpellEffectInfo::MiscValueB
int32 MiscValueB
Definition: SpellInfo.h:228

SpellEffectInfo::CalcValueMultiplier
float CalcValueMultiplier(WorldObject *caster, Spell *spell=nullptr) const
Definition: SpellInfo.cpp:644

SpellEffectInfo::TriggerSpell
uint32 TriggerSpell
Definition: SpellInfo.h:237

SpellEffectInfo::Effect
SpellEffectName Effect
Definition: SpellInfo.h:218

SpellEffectInfo::MiscValue
int32 MiscValue
Definition: SpellInfo.h:227

SpellEffectInfo::Amplitude
float Amplitude
Definition: SpellInfo.h:224

SpellEffectInfo::ItemType
uint32 ItemType
Definition: SpellInfo.h:236

SpellEffectInfo::EffectIndex
SpellEffIndex EffectIndex
Definition: SpellInfo.h:217

SpellEffectInfo::GetProvidedTargetMask
uint32 GetProvidedTargetMask() const
Definition: SpellInfo.cpp:714

SpellEffectInfo::CalcRadius
float CalcRadius(WorldObject *caster=nullptr, SpellTargetIndex targetIndex=SpellTargetIndex::TargetA, Spell *=nullptr) const
Definition: SpellInfo.cpp:673

SpellHistory::RestoreCharge
void RestoreCharge(uint32 chargeCategoryId)
Definition: SpellHistory.cpp:849

SpellHistory::LockSpellSchool
void LockSpellSchool(SpellSchoolMask schoolMask, Duration lockoutTime)
Definition: SpellHistory.cpp:736

SpellHistory::ModifyCoooldowns
void ModifyCoooldowns(Predicate &&predicate, Duration cooldownMod, bool withoutCategoryCooldown=false)
Definition: SpellHistory.h:118

SpellHistory::ModifyCooldown
void ModifyCooldown(uint32 spellId, Duration cooldownMod, bool withoutCategoryCooldown=false)
Definition: SpellHistory.cpp:608

SpellHistory::HasCooldown
bool HasCooldown(SpellInfo const *spellInfo, uint32 itemId=0) const
Definition: SpellHistory.cpp:667

SpellInfo
Definition: SpellInfo.h:321

SpellInfo::CalcPowerCost
Optional< SpellPowerCost > CalcPowerCost(Powers powerType, bool optionalCost, WorldObject const *caster, SpellSchoolMask schoolMask, Spell *spell=nullptr) const
Definition: SpellInfo.cpp:3870

SpellInfo::GetMaxRange
float GetMaxRange(bool positive=false, WorldObject *caster=nullptr, Spell *spell=nullptr) const
Definition: SpellInfo.cpp:3768

SpellInfo::GetAllEffectsMechanicMask
uint64 GetAllEffectsMechanicMask() const
Definition: SpellInfo.cpp:2470

SpellInfo::Id
uint32 const Id
Definition: SpellInfo.h:325

SpellInfo::StackAmount
uint32 StackAmount
Definition: SpellInfo.h:390

SpellInfo::IsLootCrafting
bool IsLootCrafting() const
Definition: SpellInfo.cpp:1481

SpellInfo::GetDispelMask
uint32 GetDispelMask() const
Definition: SpellInfo.cpp:2519

SpellInfo::NeedsToBeTriggeredByCaster
bool NeedsToBeTriggeredByCaster(SpellInfo const *triggeringSpell) const
Definition: SpellInfo.cpp:1556

SpellInfo::Speed
float Speed
Definition: SpellInfo.h:388

SpellInfo::GetMinRange
float GetMinRange(bool positive=false) const
Definition: SpellInfo.cpp:3761

SpellInfo::EquippedItemClass
int32 EquippedItemClass
Definition: SpellInfo.h:396

SpellInfo::SpellFamilyFlags
flag128 SpellFamilyFlags
Definition: SpellInfo.h:409

SpellInfo::GetSchoolMask
SpellSchoolMask GetSchoolMask() const
Definition: SpellInfo.cpp:2465

SpellInfo::HasAttribute
bool HasAttribute(SpellAttr0 attribute) const
Definition: SpellInfo.h:449

SpellInfo::GetDuration
int32 GetDuration() const
Definition: SpellInfo.cpp:3791

SpellInfo::GetEffect
SpellEffectInfo const & GetEffect(SpellEffIndex index) const
Definition: SpellInfo.h:577

SpellInfo::GetEffects
std::vector< SpellEffectInfo > const & GetEffects() const
Definition: SpellInfo.h:576

SpellInfo::EquippedItemSubClassMask
int32 EquippedItemSubClassMask
Definition: SpellInfo.h:397

SpellInfo::GetExplicitTargetMask
uint32 GetExplicitTargetMask() const
Definition: SpellInfo.cpp:2533

SpellInfo::CalcDuration
int32 CalcDuration(WorldObject const *caster=nullptr) const
Definition: SpellInfo.cpp:3780

SpellInfo::HasAura
bool HasAura(AuraType aura) const
Definition: SpellInfo.cpp:1400

SpellInfo::SpellFamilyName
uint32 SpellFamilyName
Definition: SpellInfo.h:408

SpellInfo::CanBeInterrupted
bool CanBeInterrupted(WorldObject const *interruptCaster, Unit const *interruptTarget, bool ignoreImmunity=false) const
Definition: SpellInfo.cpp:1453

Spell
Definition: Spell.h:255

Spell::CalculateDamage
int32 CalculateDamage(SpellEffectInfo const &spellEffectInfo, Unit const *target, float *var=nullptr) const
Definition: Spell.cpp:7085

Spell::EffectSummonRaFFriend
void EffectSummonRaFFriend()
Definition: SpellEffects.cpp:5176

Spell::GetSpellInfo
SpellInfo const * GetSpellInfo() const
Definition: Spell.h:650

Spell::ExecuteLogEffectTakeTargetPower
void ExecuteLogEffectTakeTargetPower(SpellEffectName effect, Unit *target, uint32 powerType, uint32 points, float amplitude)
Definition: Spell.cpp:5086

Spell::EffectSendEvent
void EffectSendEvent()
Definition: SpellEffects.cpp:1107

Spell::EffectTransmitted
void EffectTransmitted()
Definition: SpellEffects.cpp:4339

Spell::EffectUpgradeHeirloom
void EffectUpgradeHeirloom()
Definition: SpellEffects.cpp:5586

Spell::ExecuteLogEffectSummonObject
void ExecuteLogEffectSummonObject(SpellEffectName effect, WorldObject *obj)
Definition: Spell.cpp:5152

Spell::EffectSpiritHeal
void EffectSpiritHeal()
Definition: SpellEffects.cpp:4560

Spell::EffectRemoveAuraBySpellLabel
void EffectRemoveAuraBySpellLabel()
Definition: SpellEffects.cpp:5339

Spell::EffectBlock
void EffectBlock()
Definition: SpellEffects.cpp:3606

Spell::EffectPlayMusic
void EffectPlayMusic()
Definition: SpellEffects.cpp:4953

Spell::EffectChangeBattlePetQuality
void EffectChangeBattlePetQuality()
Definition: SpellEffects.cpp:5506

Spell::gameObjTarget
GameObject * gameObjTarget
Definition: Spell.h:734

Spell::EffectGrantBattlePetExperience
void EffectGrantBattlePetExperience()
Definition: SpellEffects.cpp:5912

Spell::targetMissInfo
SpellMissInfo targetMissInfo
Definition: Spell.h:738

Spell::UpdateDelayMomentForUnitTarget
void UpdateDelayMomentForUnitTarget(Unit *unit, uint64 hitDelay)
Definition: Spell.cpp:887

Spell::EffectCreateItem2
void EffectCreateItem2()
Definition: SpellEffects.cpp:1401

Spell::EffectEnchantHeldItem
void EffectEnchantHeldItem()
Definition: SpellEffects.cpp:3355

Spell::m_originalCaster
Unit * m_originalCaster
Definition: Spell.h:696

Spell::EffectHealMaxHealth
void EffectHealMaxHealth()
Definition: SpellEffects.cpp:2867

Spell::EffectProspecting
void EffectProspecting()
Definition: SpellEffects.cpp:4473

Spell::_dynObjAura
DynObjAura * _dynObjAura
Definition: Spell.h:745

Spell::ExecuteLogEffectUnsummonObject
void ExecuteLogEffectUnsummonObject(SpellEffectName effect, WorldObject *obj)
Definition: Spell.cpp:5160

Spell::EffectCharge
void EffectCharge()
Definition: SpellEffects.cpp:3822

Spell::EffectSummonObject
void EffectSummonObject()
Definition: SpellEffects.cpp:3496

Spell::ExecuteLogEffectResurrect
void ExecuteLogEffectResurrect(SpellEffectName effect, Unit *target)
Definition: Spell.cpp:5168

Spell::EffectSendTaxi
void EffectSendTaxi()
Definition: SpellEffects.cpp:4030

Spell::EffectCreateItem
void EffectCreateItem()
Definition: SpellEffects.cpp:1392

Spell::ExecuteLogEffectDestroyItem
void ExecuteLogEffectDestroyItem(SpellEffectName effect, uint32 entry)
Definition: Spell.cpp:5144

Spell::EffectTameCreature
void EffectTameCreature()
Definition: SpellEffects.cpp:2512

Spell::ExecuteLogEffectOpenLock
void ExecuteLogEffectOpenLock(SpellEffectName effect, Object *obj)
Definition: Spell.cpp:5128

Spell::EffectGameObjectDamage
void EffectGameObjectDamage()
Definition: SpellEffects.cpp:4847

Spell::m_targets
SpellCastTargets m_targets
Definition: Spell.h:607

Spell::EffectSummonChangeItem
void EffectSummonChangeItem()
Definition: SpellEffects.cpp:1662

Spell::EffectDummy
void EffectDummy()
Definition: SpellEffects.cpp:556

Spell::m_preGeneratedPath
std::unique_ptr< PathGenerator > m_preGeneratedPath
Definition: Spell.h:927

Spell::GetCastDifficulty
Difficulty GetCastDifficulty() const
Definition: Spell.cpp:8038

Spell::EffectLearnAzeriteEssencePower
void EffectLearnAzeriteEssencePower()
Definition: SpellEffects.cpp:5845

Spell::EffectHealthLeech
void EffectHealthLeech()
Definition: SpellEffects.cpp:1256

Spell::EffectActivateGarrisonBuilding
void EffectActivateGarrisonBuilding()
Definition: SpellEffects.cpp:5428

Spell::EffectStealBeneficialBuff
void EffectStealBeneficialBuff()
Definition: SpellEffects.cpp:4607

Spell::EffectCancelConversation
void EffectCancelConversation()
Definition: SpellEffects.cpp:5376

Spell::EffectStuck
void EffectStuck()
Definition: SpellEffects.cpp:3236

Spell::EffectInterruptCast
void EffectInterruptCast()
Definition: SpellEffects.cpp:2890

Spell::EffectSummonPlayer
void EffectSummonPlayer()
Definition: SpellEffects.cpp:3280

Spell::EffectWeaponDmg
void EffectWeaponDmg()
Definition: SpellEffects.cpp:2723

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

Spell::damage
int32 damage
Definition: Spell.h:737

Spell::EffectEnchantItemPrismatic
void EffectEnchantItemPrismatic()
Definition: SpellEffects.cpp:2396

Spell::EffectSummonType
void EffectSummonType()
Definition: SpellEffects.cpp:1798

Spell::EffectSkinPlayerCorpse
void EffectSkinPlayerCorpse()
Definition: SpellEffects.cpp:4586

Spell::effectHandleMode
SpellEffectHandleMode effectHandleMode
Definition: Spell.h:740

Spell::SummonGuardian
void SummonGuardian(SpellEffectInfo const *effect, uint32 entry, SummonPropertiesEntry const *properties, uint32 numSummons, ObjectGuid privateObjectOwner)
Definition: SpellEffects.cpp:4884

Spell::EffectHealMechanical
void EffectHealMechanical()
Definition: SpellEffects.cpp:1236

Spell::EffectGameObjectRepair
void EffectGameObjectRepair()
Definition: SpellEffects.cpp:4862

Spell::EffectCreateGarrison
void EffectCreateGarrison()
Definition: SpellEffects.cpp:5353

Spell::EffectSummonObjectWild
void EffectSummonObjectWild()
Definition: SpellEffects.cpp:2922

Spell::EffectSendChatMessage
void EffectSendChatMessage()
Definition: SpellEffects.cpp:5895

Spell::Id
uint32 Id
Definition: Spell.h:590

Spell::EffectActivateObject
void EffectActivateObject()
Definition: SpellEffects.cpp:3296

Spell::m_UniqueTargetInfo
std::vector< TargetInfo > m_UniqueTargetInfo
Definition: Spell.h:808

Spell::EffectSkill
void EffectSkill()
Definition: SpellEffects.cpp:4527

Spell::m_destTargets
SpellDestination m_destTargets[MAX_SPELL_EFFECTS]
Definition: Spell.h:840

Spell::EffectLeap
void EffectLeap()
Definition: SpellEffects.cpp:3615

Spell::UpdateDelayMomentForDst
void UpdateDelayMomentForDst(uint64 hitDelay)
Definition: Spell.cpp:879

Spell::EffectTradeSkill
void EffectTradeSkill()
Definition: SpellEffects.cpp:2319

Spell::EffectPersistentAA
void EffectPersistentAA()
Definition: SpellEffects.cpp:1444

Spell::EffectQuestClear
void EffectQuestClear()
Definition: SpellEffects.cpp:3981

Spell::EffectModifyThreatPercent
void EffectModifyThreatPercent()
Definition: SpellEffects.cpp:4327

Spell::EffectForceDeselect
void EffectForceDeselect()
Definition: SpellEffects.cpp:3677

Spell::EffectParry
void EffectParry()
Definition: SpellEffects.cpp:3597

Spell::EffectRenamePet
void EffectRenamePet()
Definition: SpellEffects.cpp:4941

Spell::ExecuteLogEffectExtraAttacks
void ExecuteLogEffectExtraAttacks(SpellEffectName effect, Unit *victim, uint32 numAttacks)
Definition: Spell.cpp:5098

Spell::EffectResurrect
void EffectResurrect()
Definition: SpellEffects.cpp:3554

Spell::EffectDestroyAllTotems
void EffectDestroyAllTotems()
Definition: SpellEffects.cpp:4226

Spell::m_attackType
WeaponAttackType m_attackType
Definition: Spell.h:700

Spell::EffectCreateTraitTreeConfig
void EffectCreateTraitTreeConfig()
Definition: SpellEffects.cpp:6014

Spell::EffectResurrectPet
void EffectResurrectPet()
Definition: SpellEffects.cpp:4156

Spell::EffectApplyEnchantIllusion
void EffectApplyEnchantIllusion()
Definition: SpellEffects.cpp:5596

Spell::EffectTriggerSpell
void EffectTriggerSpell()
Definition: SpellEffects.cpp:579

Spell::EffectGiveHonor
void EffectGiveHonor()
Definition: SpellEffects.cpp:5743

Spell::SendSpellInterruptLog
void SendSpellInterruptLog(Unit *victim, uint32 spellId)
Definition: Spell.cpp:5107

Spell::m_customArg
std::any m_customArg
Definition: Spell.h:605

Spell::EffectPullTowards
void EffectPullTowards()
Definition: SpellEffects.cpp:4041

Spell::m_originalCasterGUID
ObjectGuid m_originalCasterGUID
Definition: Spell.h:694

Spell::m_caster
WorldObject *const m_caster
Definition: Spell.h:690

Spell::EffectCreatePrivateSceneObject
void EffectCreatePrivateSceneObject()
Definition: SpellEffects.cpp:5711

Spell::EffectRechargeItem
void EffectRechargeItem()
Definition: SpellEffects.cpp:5101

Spell::EffectLearnGarrisonBuilding
void EffectLearnGarrisonBuilding()
Definition: SpellEffects.cpp:5327

Spell::EffectPowerBurn
void EffectPowerBurn()
Definition: SpellEffects.cpp:1145

Spell::GetDebugInfo
std::string GetDebugInfo() const
Definition: Spell.cpp:9034

Spell::EffectDurabilityDamage
void EffectDurabilityDamage()
Definition: SpellEffects.cpp:4269

Spell::ExecuteLogEffectDurabilityDamage
void ExecuteLogEffectDurabilityDamage(SpellEffectName effect, Unit *victim, int32 itemId, int32 amount)
Definition: Spell.cpp:5118

Spell::EffectSanctuary
void EffectSanctuary()
Definition: SpellEffects.cpp:3125

Spell::EffectHealBattlePetPct
void EffectHealBattlePetPct()
Definition: SpellEffects.cpp:5481

Spell::EffectCastButtons
void EffectCastButtons()
Definition: SpellEffects.cpp:5059

Spell::itemTarget
Item * itemTarget
Definition: Spell.h:733

Spell::SendCastResult
static void SendCastResult(Player *caster, SpellInfo const *spellInfo, SpellCastVisual spellVisual, ObjectGuid cast_count, SpellCastResult result, SpellCustomErrors customError=SPELL_CUSTOM_ERROR_NONE, int32 *param1=nullptr, int32 *param2=nullptr)
Definition: Spell.cpp:4643

Spell::variance
float variance
Definition: Spell.h:739

Spell::m_damage
int32 m_damage
Definition: Spell.h:751

Spell::EffectGiveArtifactPower
void EffectGiveArtifactPower()
Definition: SpellEffects.cpp:5639

Spell::EffectKnockBack
void EffectKnockBack()
Definition: SpellEffects.cpp:3919

Spell::EffectReputation
void EffectReputation()
Definition: SpellEffects.cpp:3630

Spell::EffectDistract
void EffectDistract()
Definition: SpellEffects.cpp:2169

Spell::EffectKillCredit
void EffectKillCredit()
Definition: SpellEffects.cpp:4732

Spell::DoCreateItem
void DoCreateItem(uint32 itemId, ItemContext context=ItemContext::NONE, std::vector< int32 > const *bonusListIDs=nullptr)
Definition: SpellEffects.cpp:1298

Spell::EffectRespecAzeriteEmpoweredItem
void EffectRespecAzeriteEmpoweredItem()
Definition: SpellEffects.cpp:5817

Spell::EffectSummonPet
void EffectSummonPet()
Definition: SpellEffects.cpp:2567

Spell::EffectModifyCooldownsByCategory
void EffectModifyCooldownsByCategory()
Definition: SpellEffects.cpp:5994

Spell::EffectEnergizePct
void EffectEnergizePct()
Definition: SpellEffects.cpp:1535

Spell::EffectDispelMechanic
void EffectDispelMechanic()
Definition: SpellEffects.cpp:4126

Spell::EffectSelfResurrect
void EffectSelfResurrect()
Definition: SpellEffects.cpp:3712

Spell::EffectGiveRestedExperience
void EffectGiveRestedExperience()
Definition: SpellEffects.cpp:5468

Spell::EffectDispel
void EffectDispel()
Definition: SpellEffects.cpp:2062

Spell::EffectBind
void EffectBind()
Definition: SpellEffects.cpp:5123

Spell::SendSpellCooldown
void SendSpellCooldown()
Definition: Spell.cpp:4210

Spell::EffectLearnTransmogIllusion
void EffectLearnTransmogIllusion()
Definition: SpellEffects.cpp:5927

Spell::EffectPlayMovie
void EffectPlayMovie()
Definition: SpellEffects.cpp:2304

Spell::EffectFeedPet
void EffectFeedPet()
Definition: SpellEffects.cpp:3439

Spell::EffectNULL
void EffectNULL()
Definition: SpellEffects.cpp:409

Spell::EffectApplyAura
void EffectApplyAura()
Definition: SpellEffects.cpp:1040

Spell::EffectUncageBattlePet
void EffectUncageBattlePet()
Definition: SpellEffects.cpp:5541

Spell::EffectTriggerRitualOfSummoning
void EffectTriggerRitualOfSummoning()
Definition: SpellEffects.cpp:838

Spell::EffectInstaKill
void EffectInstaKill()
Definition: SpellEffects.cpp:447

Spell::EffectCreateAreaTrigger
void EffectCreateAreaTrigger()
Definition: SpellEffects.cpp:5282

Spell::EffectInebriate
void EffectInebriate()
Definition: SpellEffects.cpp:3419

Spell::EffectOpenLock
void EffectOpenLock()
Definition: SpellEffects.cpp:1559

Spell::EffectEnvironmentalDMG
void EffectEnvironmentalDMG()
Definition: SpellEffects.cpp:471

Spell::EffectRedirectThreat
void EffectRedirectThreat()
Definition: SpellEffects.cpp:4834

Spell::EffectChangeActiveCombatTraitConfig
void EffectChangeActiveCombatTraitConfig()
Definition: SpellEffects.cpp:6039

Spell::EffectLearnTransmogSet
void EffectLearnTransmogSet()
Definition: SpellEffects.cpp:5806

Spell::EffectRemoveAura
void EffectRemoveAura()
Definition: SpellEffects.cpp:5023

Spell::EffectDualWield
void EffectDualWield()
Definition: SpellEffects.cpp:2161

Spell::EffectUpdatePlayerPhase
void EffectUpdatePlayerPhase()
Definition: SpellEffects.cpp:5617

Spell::m_healing
int32 m_healing
Definition: Spell.h:752

Spell::EffectPickPocket
void EffectPickPocket()
Definition: SpellEffects.cpp:2185

Spell::EffectTeleportUnitsWithVisualLoadingScreen
void EffectTeleportUnitsWithVisualLoadingScreen()
Definition: SpellEffects.cpp:1008

Spell::EffectModifyAuraStacks
void EffectModifyAuraStacks()
Definition: SpellEffects.cpp:5943

Spell::EffectProficiency
void EffectProficiency()
Definition: SpellEffects.cpp:1776

Spell::EffectSummonPersonalGameObject
void EffectSummonPersonalGameObject()
Definition: SpellEffects.cpp:5198

Spell::effectInfo
SpellEffectInfo const * effectInfo
Definition: Spell.h:741

Spell::EffectDisEnchant
void EffectDisEnchant()
Definition: SpellEffects.cpp:3403

Spell::EffectEnableBattlePets
void EffectEnableBattlePets()
Definition: SpellEffects.cpp:5493

Spell::EffectGiveArtifactPowerNoBonus
void EffectGiveArtifactPowerNoBonus()
Definition: SpellEffects.cpp:5653

Spell::GetUnitCasterForEffectHandlers
Unit * GetUnitCasterForEffectHandlers() const
Definition: Spell.cpp:8201

Spell::EffectTeleportToReturnPoint
void EffectTeleportToReturnPoint()
Definition: SpellEffects.cpp:5154

Spell::EffectAddExtraAttacks
void EffectAddExtraAttacks()
Definition: SpellEffects.cpp:3584

Spell::m_castItemLevel
int32 m_castItemLevel
Definition: Spell.h:567

Spell::EffectTriggerMissileSpell
void EffectTriggerMissileSpell()
Definition: SpellEffects.cpp:709

Spell::_spellAura
UnitAura * _spellAura
Definition: Spell.h:744

Spell::EffectModifyCooldown
void EffectModifyCooldown()
Definition: SpellEffects.cpp:5965

Spell::unitTarget
Unit * unitTarget
Definition: Spell.h:732

Spell::EffectEnchantItemTmp
void EffectEnchantItemTmp()
Definition: SpellEffects.cpp:2460

Spell::m_spellSchoolMask
SpellSchoolMask m_spellSchoolMask
Definition: Spell.h:699

Spell::EffectCreateRandomItem
void EffectCreateRandomItem()
Definition: SpellEffects.cpp:1430

Spell::EffectTeleUnitsFaceCaster
void EffectTeleUnitsFaceCaster()
Definition: SpellEffects.cpp:2259

Spell::EffectDamageFromMaxHealthPCT
void EffectDamageFromMaxHealthPCT()
Definition: SpellEffects.cpp:5034

Spell::EffectCreateHeirloomItem
void EffectCreateHeirloomItem()
Definition: SpellEffects.cpp:5408

Spell::GetCaster
WorldObject * GetCaster() const
Definition: Spell.h:647

Spell::EffectPullTowardsDest
void EffectPullTowardsDest()
Definition: SpellEffects.cpp:4071

Spell::EffectKillCreditPersonal
void EffectKillCreditPersonal()
Definition: SpellEffects.cpp:4721

Spell::CalculateJumpSpeeds
void CalculateJumpSpeeds(SpellEffectInfo const *effInfo, float dist, float &speedXY, float &speedZ)
Definition: SpellEffects.cpp:864

Spell::EffectLaunchQuestChoice
void EffectLaunchQuestChoice()
Definition: SpellEffects.cpp:5530

Spell::EffectSchoolDMG
void EffectSchoolDMG()
Definition: SpellEffects.cpp:499

Spell::EffectChangeRaidMarker
void EffectChangeRaidMarker()
Definition: SpellEffects.cpp:4107

Spell::EffectGrantBattlePetLevel
void EffectGrantBattlePetLevel()
Definition: SpellEffects.cpp:5440

Spell::EffectThreat
void EffectThreat()
Definition: SpellEffects.cpp:2849

Spell::m_corpseTarget
Corpse * m_corpseTarget
Definition: Spell.h:735

Spell::EffectResurrectNew
void EffectResurrectNew()
Definition: SpellEffects.cpp:419

Spell::EffectChargeDest
void EffectChargeDest()
Definition: SpellEffects.cpp:3877

Spell::EffectUntrainTalents
void EffectUntrainTalents()
Definition: SpellEffects.cpp:2248

Spell::EffectUnlockGuildVaultTab
void EffectUnlockGuildVaultTab()
Definition: SpellEffects.cpp:5187

Spell::EffectLearnSpell
void EffectLearnSpell()
Definition: SpellEffects.cpp:2016

Spell::ExecuteLogEffectCreateItem
void ExecuteLogEffectCreateItem(SpellEffectName effect, uint32 entry)
Definition: Spell.cpp:5136

Spell::EffectMilling
void EffectMilling()
Definition: SpellEffects.cpp:4500

Spell::EffectHealPct
void EffectHealPct()
Definition: SpellEffects.cpp:1218

Spell::EffectJumpCharge
void EffectJumpCharge()
Definition: SpellEffects.cpp:5760

Spell::EffectJumpDest
void EffectJumpDest()
Definition: SpellEffects.cpp:902

Spell::EffectScriptEffect
void EffectScriptEffect()
Definition: SpellEffects.cpp:2975

Spell::EffectAddFarsight
void EffectAddFarsight()
Definition: SpellEffects.cpp:2222

Spell::EffectEnergize
void EffectEnergize()
Definition: SpellEffects.cpp:1491

Spell::m_misc
union Spell::@333 m_misc

Spell::EffectCreateSceneObject
void EffectCreateSceneObject()
Definition: SpellEffects.cpp:5690

Spell::destTarget
WorldLocation * destTarget
Definition: Spell.h:736

Spell::EffectGameObjectSetDestructionState
void EffectGameObjectSetDestructionState()
Definition: SpellEffects.cpp:4873

Spell::EffectIncreaseCurrencyCap
void EffectIncreaseCurrencyCap()
Definition: SpellEffects.cpp:5164

Spell::EffectApplyGlyph
void EffectApplyGlyph()
Definition: SpellEffects.cpp:3309

Spell::EffectResurrectWithAura
void EffectResurrectWithAura()
Definition: SpellEffects.cpp:5250

Spell::EffectGiveCurrency
void EffectGiveCurrency()
Definition: SpellEffects.cpp:5045

Spell::EffectModifyCooldowns
void EffectModifyCooldowns()
Definition: SpellEffects.cpp:5973

Spell::EffectQuestComplete
void EffectQuestComplete()
Definition: SpellEffects.cpp:3653

Spell::EffectDiscoverTaxi
void EffectDiscoverTaxi()
Definition: SpellEffects.cpp:4813

Spell::EffectModifySpellCharges
void EffectModifySpellCharges()
Definition: SpellEffects.cpp:6005

Spell::EffectTeleportUnits
void EffectTeleportUnits()
Definition: SpellEffects.cpp:941

Spell::EffectGiveExperience
void EffectGiveExperience()
Definition: SpellEffects.cpp:5455

Spell::EffectCreatePrivateConversation
void EffectCreatePrivateConversation()
Definition: SpellEffects.cpp:5884

Spell::EffectPlaySceneScriptPackage
void EffectPlaySceneScriptPackage()
Definition: SpellEffects.cpp:5666

Spell::EffectPlaySound
void EffectPlaySound()
Definition: SpellEffects.cpp:4991

Spell::EffectLearnPetSpell
void EffectLearnPetSpell()
Definition: SpellEffects.cpp:2657

Spell::EffectTeleportGraveyard
void EffectTeleportGraveyard()
Definition: SpellEffects.cpp:6055

Spell::EffectPowerDrain
void EffectPowerDrain()
Definition: SpellEffects.cpp:1072

Spell::m_CastItem
Item * m_CastItem
Definition: Spell.h:564

Spell::CallScriptSuccessfulDispel
void CallScriptSuccessfulDispel(SpellEffIndex effIndex)
Definition: Spell.cpp:8746

Spell::m_castItemEntry
uint32 m_castItemEntry
Definition: Spell.h:566

Spell::GetUnitTargetIndexForEffect
int32 GetUnitTargetIndexForEffect(ObjectGuid const &target, SpellEffIndex effect) const
Definition: Spell.cpp:2650

Spell::EffectTaunt
void EffectTaunt()
Definition: SpellEffects.cpp:2683

Spell::EffectLeapBack
void EffectLeapBack()
Definition: SpellEffects.cpp:3963

Spell::EffectDurabilityDamagePCT
void EffectDurabilityDamagePCT()
Definition: SpellEffects.cpp:4298

Spell::m_spellValue
SpellValue *const m_spellValue
Definition: Spell.h:692

Spell::EffectLearnSkill
void EffectLearnSkill()
Definition: SpellEffects.cpp:2274

Spell::finish
void finish(SpellCastResult result=SPELL_CAST_OK)
Definition: Spell.cpp:4311

Spell::SendResurrectRequest
void SendResurrectRequest(Player *target)
Definition: Spell.cpp:5298

Spell::EffectActivateSpec
void EffectActivateSpec()
Definition: SpellEffects.cpp:4972

Spell::EffectForceCast
void EffectForceCast()
Definition: SpellEffects.cpp:775

Spell::EffectDismissPet
void EffectDismissPet()
Definition: SpellEffects.cpp:3482

Spell::EffectPlayScene
void EffectPlayScene()
Definition: SpellEffects.cpp:5732

Spell::EffectEnchantItemPerm
void EffectEnchantItemPerm()
Definition: SpellEffects.cpp:2331

Spell::EffectQuestFail
void EffectQuestFail()
Definition: SpellEffects.cpp:4744

Spell::EffectCreateTamedPet
void EffectCreateTamedPet()
Definition: SpellEffects.cpp:4782

Spell::EffectAddGarrisonFollower
void EffectAddGarrisonFollower()
Definition: SpellEffects.cpp:5396

Spell::EffectJump
void EffectJump()
Definition: SpellEffects.cpp:879

Spell::EffectDestroyItem
void EffectDestroyItem()
Definition: SpellEffects.cpp:5314

Spell::m_castItemGUID
ObjectGuid m_castItemGUID
Definition: Spell.h:565

Spell::EffectRemoveTalent
void EffectRemoveTalent()
Definition: SpellEffects.cpp:5297

Spell::m_SpellVisual
SpellCastVisual m_SpellVisual
Definition: Spell.h:606

Spell::GetUnitTargetCountForEffect
int64 GetUnitTargetCountForEffect(SpellEffIndex effect) const
Definition: Spell.cpp:2667

Spell::focusObject
GameObject * focusObject
Definition: Spell.h:748

Spell::EffectTitanGrip
void EffectTitanGrip()
Definition: SpellEffects.cpp:4825

Spell::m_hitMask
ProcFlagsHit m_hitMask
Definition: Spell.h:759

Spell::m_castId
ObjectGuid m_castId
Definition: Spell.h:568

Spell::m_spellInfo
SpellInfo const *const m_spellInfo
Definition: Spell.h:563

Spell::EffectUnlearnSpecialization
void EffectUnlearnSpecialization()
Definition: SpellEffects.cpp:1056

Spell::EffectUpdateZoneAurasAndPhases
void EffectUpdateZoneAurasAndPhases()
Definition: SpellEffects.cpp:5628

Spell::EffectQuestStart
void EffectQuestStart()
Definition: SpellEffects.cpp:4755

Spell::EffectDuel
void EffectDuel()
Definition: SpellEffects.cpp:3156

Spell::EffectUnused
void EffectUnused()
Definition: SpellEffects.cpp:414

Spell::EffectCreateConversation
void EffectCreateConversation()
Definition: SpellEffects.cpp:5364

Spell::EffectSkinning
void EffectSkinning()
Definition: SpellEffects.cpp:3749

Spell::EffectHeal
void EffectHeal()
Definition: SpellEffects.cpp:1170

TempSummon
Definition: TemporarySummon.h:45

TempSummon::UnSummon
virtual void UnSummon(uint32 msTime=0)
Definition: TemporarySummon.cpp:320

TempSummon::SetTempSummonType
void SetTempSummonType(TempSummonType type)
Definition: TemporarySummon.cpp:315

ThreatManager
Definition: ThreatManager.h:82

ThreatManager::ModifyThreatByPercent
void ModifyThreatByPercent(Unit *target, int32 percent)
Definition: ThreatManager.h:143

ThreatManager::GetCurrentVictim
Unit * GetCurrentVictim()
Definition: ThreatManager.cpp:224

ThreatManager::GetThreatenedByMeList
auto const & GetThreatenedByMeList() const
Definition: ThreatManager.h:135

ThreatManager::IsThreatListEmpty
bool IsThreatListEmpty(bool includeOffline=false) const
Definition: ThreatManager.cpp:247

ThreatManager::AddThreat
void AddThreat(Unit *target, float amount, SpellInfo const *spell=nullptr, bool ignoreModifiers=false, bool ignoreRedirects=false)
== AFFECT MY THREAT LIST ==
Definition: ThreatManager.cpp:353

ThreatManager::RegisterRedirectThreat
void RegisterRedirectThreat(uint32 spellId, ObjectGuid const &victim, uint32 pct)
== REDIRECT SYSTEM ==
Definition: ThreatManager.cpp:786

ThreatManager::MatchUnitThreatToHighestThreat
void MatchUnitThreatToHighestThreat(Unit *target)
Definition: ThreatManager.cpp:474

Totem::UnSummon
void UnSummon(uint32 msTime=0) override
Definition: Totem.cpp:100

Trinity::ObjectEntryAndPrivateOwnerIfExistsCheck
Definition: GridNotifiers.h:1772

Unit
Definition: Unit.h:627

Unit::GetPctModifierValue
float GetPctModifierValue(UnitMods unitMod, UnitModifierPctType modifierType) const
Definition: Unit.cpp:9041

Unit::ClearUnitState
void ClearUnitState(uint32 f)
Definition: Unit.h:733

Unit::IsVehicle
bool IsVehicle() const
Definition: Unit.h:743

Unit::GetContentTuning
int32 GetContentTuning() const
Definition: Unit.h:745

Unit::SetMinion
void SetMinion(Minion *minion, bool apply)
Definition: Unit.cpp:6062

Unit::ModifyPower
int32 ModifyPower(Powers power, int32 val, bool withPowerUpdate=true)
Definition: Unit.cpp:8280

Unit::KnockbackFrom
void KnockbackFrom(Position const &origin, float speedXY, float speedZ, Movement::SpellEffectExtraData const *spellEffectExtraData=nullptr)
Definition: Unit.cpp:11860

Unit::SpellDamageBonusDone
int32 SpellDamageBonusDone(Unit *victim, SpellInfo const *spellProto, int32 pdamage, DamageEffectType damagetype, SpellEffectInfo const &spellEffectInfo, uint32 stack=1, Spell *spell=nullptr, AuraEffect const *aurEff=nullptr) const
Definition: Unit.cpp:6626

Unit::RemoveAurasByType
void RemoveAurasByType(AuraType auraType, std::function< bool(AuraApplication const *)> const &check, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)
Definition: Unit.cpp:3812

Unit::RemoveGameObject
void RemoveGameObject(GameObject *gameObj, bool del)
Definition: Unit.cpp:5238

Unit::GetAuraEffectsByType
AuraEffectList const & GetAuraEffectsByType(AuraType type) const
Definition: Unit.h:1321

Unit::CombatStop
void CombatStop(bool includingCast=false, bool mutualPvP=true, bool(*unitFilter)(Unit const *otherUnit)=nullptr)
Definition: Unit.cpp:5827

Unit::m_lastSanctuaryTime
uint32 m_lastSanctuaryTime
Definition: Unit.h:1547

Unit::MeleeDamageBonusTaken
int32 MeleeDamageBonusTaken(Unit *attacker, int32 pdamage, WeaponAttackType attType, DamageEffectType damagetype, SpellInfo const *spellProto=nullptr, SpellSchoolMask damageSchoolMask=SPELL_SCHOOL_MASK_NORMAL)
Definition: Unit.cpp:7736

Unit::JumpTo
void JumpTo(float speedXY, float speedZ, float angle, Optional< Position > dest={})
Definition: Unit.cpp:12004

Unit::SetHealth
void SetHealth(uint64 val)
Definition: Unit.cpp:9346

Unit::SetVirtualItem
void SetVirtualItem(uint32 slot, uint32 itemId, uint16 appearanceModId=0, uint16 itemVisual=0)
Definition: Unit.cpp:13604

Unit::SpellHealingBonusTaken
int32 SpellHealingBonusTaken(Unit *caster, SpellInfo const *spellProto, int32 healamount, DamageEffectType damagetype) const
Definition: Unit.cpp:7285

Unit::ToPet
Pet * ToPet()
Definition: Unit.h:1750

Unit::CanHaveThreatList
bool CanHaveThreatList() const
====================== THREAT & COMBAT ====================
Definition: Unit.h:1015

Unit::SetUnitFlag3
void SetUnitFlag3(UnitFlags3 flags)
Definition: Unit.h:843

Unit::RemoveAura
void RemoveAura(AuraApplicationMap::iterator &i, AuraRemoveMode mode=AURA_REMOVE_BY_DEFAULT)
Definition: Unit.cpp:3685

Unit::EnergizeBySpell
void EnergizeBySpell(Unit *victim, SpellInfo const *spellInfo, int32 damage, Powers powerType)
Definition: Unit.cpp:6613

Unit::GetThreatManager
ThreatManager & GetThreatManager()
Definition: Unit.h:1063

Unit::SetCanDualWield
virtual void SetCanDualWield(bool value)
Definition: Unit.h:693

Unit::m_unitData
UF::UpdateField< UF::UnitData, 0, TYPEID_UNIT > m_unitData
Definition: Unit.h:1814

Unit::GetClass
uint8 GetClass() const
Definition: Unit.h:752

Unit::m_SummonSlot
std::array< ObjectGuid, MAX_SUMMON_SLOT > m_SummonSlot
Definition: Unit.h:1460

Unit::ToTotem
Totem * ToTotem()
Definition: Unit.h:1753

Unit::GetHealthGain
int64 GetHealthGain(int64 dVal)
Definition: Unit.cpp:8224

Unit::RemoveAurasDueToSpellByDispel
void RemoveAurasDueToSpellByDispel(uint32 spellId, uint32 dispellerSpellId, ObjectGuid casterGUID, WorldObject *dispeller, uint8 chargesRemoved=1)
Definition: Unit.cpp:3864

Unit::AuraEffectList
std::forward_list< AuraEffect * > AuraEffectList
Definition: Unit.h:644

Unit::SetPower
void SetPower(Powers power, int32 val, bool withPowerUpdate=true)
Definition: Unit.cpp:9419

Unit::CreateTamedPetFrom
Pet * CreateTamedPetFrom(Creature *creatureTarget, uint32 spell_id=0)
Definition: Unit.cpp:10441

Unit::CalculateDamage
uint32 CalculateDamage(WeaponAttackType attType, bool normalized, bool addTotalPct) const
Definition: Unit.cpp:2392

Unit::CalcAbsorbResist
static void CalcAbsorbResist(DamageInfo &damageInfo, Spell *spell=nullptr)
Definition: Unit.cpp:1797

Unit::InterruptNonMeleeSpells
void InterruptNonMeleeSpells(bool withDelayed, uint32 spellid=0, bool withInstant=true)
Definition: Unit.cpp:3089

Unit::GetVehicleBase
Unit * GetVehicleBase() const
Definition: Unit.cpp:11480

Unit::GetMotionMaster
MotionMaster * GetMotionMaster()
Definition: Unit.h:1652

Unit::IsPet
bool IsPet() const
Definition: Unit.h:740

Unit::GetPowerType
Powers GetPowerType() const
Definition: Unit.h:799

Unit::HasUnitFlag
bool HasUnitFlag(UnitFlags flags) const
Definition: Unit.h:832

Unit::m_ObjectSlot
std::array< ObjectGuid, MAX_GAMEOBJECT_SLOT > m_ObjectSlot
Definition: Unit.h:1461

Unit::SetCreatedBySpell
void SetCreatedBySpell(int32 spellId)
Definition: Unit.h:847

Unit::IsNonMeleeSpellCast
bool IsNonMeleeSpellCast(bool withDelayed, bool skipChanneled=false, bool skipAutorepeat=false, bool isAutoshoot=false, bool skipInstant=true) const
Definition: Unit.cpp:3059

Unit::GetAuraEffect
AuraEffect * GetAuraEffect(uint32 spellId, uint8 effIndex, ObjectGuid casterGUID=ObjectGuid::Empty) const
Definition: Unit.cpp:4464

Unit::SetDemonCreatorGUID
void SetDemonCreatorGUID(ObjectGuid guid)
Definition: Unit.h:1183

Unit::MeleeDamageBonusDone
int32 MeleeDamageBonusDone(Unit *pVictim, int32 damage, WeaponAttackType attType, DamageEffectType damagetype, SpellInfo const *spellProto=nullptr, Mechanics mechanic=MECHANIC_NONE, SpellSchoolMask damageSchoolMask=SPELL_SCHOOL_MASK_NORMAL, Spell *spell=nullptr, AuraEffect const *aurEff=nullptr)
Definition: Unit.cpp:7624

Unit::IsAlive
bool IsAlive() const
Definition: Unit.h:1164

Unit::IsScriptOverriden
AuraEffect * IsScriptOverriden(SpellInfo const *spell, int32 script) const
Definition: Unit.cpp:4776

Unit::GetCombatReach
float GetCombatReach() const override
Definition: Unit.h:694

Unit::GetMaxPower
int32 GetMaxPower(Powers power) const
Definition: Unit.cpp:9410

Unit::HealBySpell
int32 HealBySpell(HealInfo &healInfo, bool critical=false)
Definition: Unit.cpp:6591

Unit::SendSpellNonMeleeDamageLog
void SendSpellNonMeleeDamageLog(SpellNonMeleeDamage const *log)
Definition: Unit.cpp:5378

Unit::SetPetFlag
void SetPetFlag(UnitPetFlag flags)
Definition: Unit.h:879

Unit::ToTempSummon
TempSummon * ToTempSummon()
Definition: Unit.h:1756

Unit::GetCharmInfo
CharmInfo * GetCharmInfo()
Definition: Unit.h:1221

Unit::SendPlaySpellVisual
void SendPlaySpellVisual(Unit *target, uint32 spellVisualId, uint16 missReason, uint16 reflectStatus, float travelSpeed, bool speedAsTime=false, float launchDelay=0.0f)
Definition: Unit.cpp:11674

Unit::AddGameObject
void AddGameObject(GameObject *gameObj)
Definition: Unit.cpp:5217

Unit::IsInFlight
bool IsInFlight() const
Definition: Unit.h:1012

Unit::SetChannelObject
void SetChannelObject(uint32 slot, ObjectGuid guid)
Definition: Unit.h:1420

Unit::GetMaxHealth
uint64 GetMaxHealth() const
Definition: Unit.h:777

Unit::Attack
bool Attack(Unit *victim, bool meleeAttack)
Definition: Unit.cpp:5670

Unit::GetAura
Aura * GetAura(uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint32 reqEffMask=0) const
Definition: Unit.cpp:4560

Unit::GetHealth
uint64 GetHealth() const
Definition: Unit.h:776

Unit::IsSummon
bool IsSummon() const
Definition: Unit.h:738

Unit::GetFaction
uint32 GetFaction() const override
Definition: Unit.h:858

Unit::GetDispellableAuraList
void GetDispellableAuraList(WorldObject const *caster, uint32 dispelMask, DispelChargesList &dispelList, bool isReflect=false) const
Definition: Unit.cpp:4596

Unit::getAttackers
AttackerSet const & getAttackers() const
Definition: Unit.h:713

Unit::AuraMap
std::multimap< uint32, Aura * > AuraMap
Definition: Unit.h:633

Unit::NearTeleportTo
void NearTeleportTo(Position const &pos, bool casting=false)
Definition: Unit.cpp:12327

Unit::SetFullPower
void SetFullPower(Powers power)
Definition: Unit.h:812

Unit::RemoveAurasWithInterruptFlags
void RemoveAurasWithInterruptFlags(InterruptFlags flag, SpellInfo const *source=nullptr)
Definition: Unit.cpp:4101

Unit::SetMaxHealth
void SetMaxHealth(uint64 val)
Definition: Unit.cpp:9377

Unit::AttackerSet
std::set< Unit * > AttackerSet
Definition: Unit.h:629

Unit::RemoveAppliedAuras
void RemoveAppliedAuras(std::function< bool(AuraApplication const *)> const &check, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)
Definition: Unit.cpp:3758

Unit::IsGuardian
bool IsGuardian() const
Definition: Unit.h:739

Unit::CountPctFromMaxHealth
uint64 CountPctFromMaxHealth(int32 pct) const
Definition: Unit.h:785

Unit::AddExtraAttacks
void AddExtraAttacks(uint32 count)
Definition: Unit.cpp:2265

Unit::SetOwnerGUID
void SetOwnerGUID(ObjectGuid owner)
Definition: Unit.cpp:5986

Unit::GetTransGUID
ObjectGuid GetTransGUID() const override
Definition: Unit.cpp:11510

Unit::HasUnitState
bool HasUnitState(const uint32 f) const
Definition: Unit.h:732

Unit::_CreateAuraApplication
AuraApplication * _CreateAuraApplication(Aura *aura, uint32 effMask)
Definition: Unit.cpp:3348

Unit::SpellDamageBonusTaken
int32 SpellDamageBonusTaken(Unit *caster, SpellInfo const *spellProto, int32 pdamage, DamageEffectType damagetype) const
Definition: Unit.cpp:6809

Unit::SetLevel
void SetLevel(uint8 lvl, bool sendUpdate=true)
Definition: Unit.cpp:9329

Unit::movespline
std::unique_ptr< Movement::MoveSpline > movespline
Definition: Unit.h:1766

Unit::HasAura
bool HasAura(uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint32 reqEffMask=0) const
Definition: Unit.cpp:4664

Unit::HasUnitTypeMask
uint32 HasUnitTypeMask(uint32 mask) const
Definition: Unit.h:736

Unit::GetSpellHistory
SpellHistory * GetSpellHistory()
Definition: Unit.h:1457

Unit::SetCreatorGUID
void SetCreatorGUID(ObjectGuid creator)
Definition: Unit.h:1173

Unit::RemoveMovementImpairingAuras
void RemoveMovementImpairingAuras(bool withRoot)
Definition: Unit.cpp:4154

Unit::IsTotem
bool IsTotem() const
Definition: Unit.h:742

Unit::GetBattlePetCompanionGUID
ObjectGuid GetBattlePetCompanionGUID() const
Definition: Unit.h:1180

Unit::KillSelf
void KillSelf(bool durabilityLoss=true, bool skipSettingDeathState=false)
Definition: Unit.h:921

Unit::Talk
virtual void Talk(std::string_view text, ChatMsg msgType, Language language, float textRange, WorldObject const *target)
Definition: Unit.cpp:13554

Unit::ProcSkillsAndAuras
static void ProcSkillsAndAuras(Unit *actor, Unit *actionTarget, ProcFlagsInit const &typeMaskActor, ProcFlagsInit const &typeMaskActionTarget, ProcFlagsSpellType spellTypeMask, ProcFlagsSpellPhase spellPhaseMask, ProcFlagsHit hitMask, Spell *spell, DamageInfo *damageInfo, HealInfo *healInfo)
Definition: Unit.cpp:5407

Unit::IsEngaged
virtual bool IsEngaged() const
Definition: Unit.h:1019

Unit::GetOwnedAuras
AuraMap & GetOwnedAuras()
Definition: Unit.h:1264

Unit::RemoveAurasDueToSpell
void RemoveAurasDueToSpell(uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, uint32 reqEffMask=0, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)
Definition: Unit.cpp:3831

Unit::Kill
static void Kill(Unit *attacker, Unit *victim, bool durabilityLoss=true, bool skipSettingDeathState=false)
Definition: Unit.cpp:10591

Unit::SpellHealingBonusDone
int32 SpellHealingBonusDone(Unit *victim, SpellInfo const *spellProto, int32 healamount, DamageEffectType damagetype, SpellEffectInfo const &spellEffectInfo, uint32 stack=1, Spell *spell=nullptr, AuraEffect const *aurEff=nullptr) const
Definition: Unit.cpp:7138

Unit::GetTarget
ObjectGuid GetTarget() const
Definition: Unit.h:1759

Unit::GetLevel
uint8 GetLevel() const
Definition: Unit.h:746

Unit::GetRace
uint8 GetRace() const
Definition: Unit.h:749

Unit::InterruptSpell
void InterruptSpell(CurrentSpellTypes spellType, bool withDelayed=true, bool withInstant=true)
Definition: Unit.cpp:3017

Unit::RemoveUnitFlag
void RemoveUnitFlag(UnitFlags flags)
Definition: Unit.h:834

Unit::RemoveAurasDueToSpellBySteal
void RemoveAurasDueToSpellBySteal(uint32 spellId, ObjectGuid casterGUID, WorldObject *stealer, int32 stolenCharges=1)
Definition: Unit.cpp:3892

Unit::GetPetGUID
ObjectGuid GetPetGUID() const
Definition: Unit.h:1176

Unit::isDead
bool isDead() const
Definition: Unit.h:1166

Unit::GetCurrentSpell
Spell * GetCurrentSpell(CurrentSpellTypes spellType) const
Definition: Unit.h:1442

WorldLocation
Definition: Position.h:179

WorldLocation::WorldRelocate
constexpr void WorldRelocate(WorldLocation const &loc)
Definition: Position.h:187

WorldLocation::GetMapId
constexpr uint32 GetMapId() const
Definition: Position.h:201

WorldLocation::m_mapId
uint32 m_mapId
Definition: Position.h:203

WorldLocation::GetWorldLocation
constexpr WorldLocation GetWorldLocation() const
Definition: Position.h:196

WorldObject
Definition: Object.h:493

WorldObject::PlayDirectSound
void PlayDirectSound(uint32 soundId, Player const *target=nullptr, uint32 broadcastTextId=0) const
Definition: Object.cpp:3592

WorldObject::SendMessageToSet
virtual void SendMessageToSet(WorldPacket const *data, bool self) const
Definition: Object.cpp:1744

WorldObject::GetMap
Map * GetMap() const
Definition: Object.h:624

WorldObject::GetLevelForTarget
virtual uint8 GetLevelForTarget(WorldObject const *) const
Definition: Object.h:598

WorldObject::IsWithinLOS
bool IsWithinLOS(float x, float y, float z, LineOfSightChecks checks=LINEOFSIGHT_ALL_CHECKS, VMAP::ModelIgnoreFlags ignoreFlags=VMAP::ModelIgnoreFlags::Nothing) const
Definition: Object.cpp:1161

WorldObject::GetPrivateObjectOwner
ObjectGuid GetPrivateObjectOwner() const
Definition: Object.h:785

WorldObject::GetClosePoint
void GetClosePoint(float &x, float &y, float &z, float size, float distance2d=0, float relAngle=0) const
Definition: Object.cpp:3403

WorldObject::CastSpell
SpellCastResult CastSpell(CastSpellTargetArg const &targets, uint32 spellId, CastSpellExtraArgs const &args={ })
Definition: Object.cpp:2896

WorldObject::GetOwner
Unit * GetOwner() const
Definition: Object.cpp:2229

WorldObject::IsPrivateObject
bool IsPrivateObject() const
Definition: Object.h:784

WorldObject::SetPrivateObjectOwner
void SetPrivateObjectOwner(ObjectGuid const &owner)
Definition: Object.h:786

WorldObject::ModSpellDuration
int32 ModSpellDuration(SpellInfo const *spellInfo, WorldObject const *target, int32 duration, bool positive, uint32 effectMask) const
Definition: Object.cpp:2401

WorldObject::GetName
std::string const & GetName() const
Definition: Object.h:555

WorldObject::GetCharmerOrOwnerPlayerOrPlayerItself
Player * GetCharmerOrOwnerPlayerOrPlayerItself() const
Definition: Object.cpp:2252

WorldObject::SetName
void SetName(std::string newname)
Definition: Object.h:556

WorldObject::m_Events
EventProcessor m_Events
Definition: Object.h:777

WorldObject::GetVisibilityRange
float GetVisibilityRange() const
Definition: Object.cpp:1447

WorldObject::GetDistance
float GetDistance(WorldObject const *obj) const
Definition: Object.cpp:1078

WorldObject::GetAreaId
uint32 GetAreaId() const
Definition: Object.h:546

WorldObject::GetFirstCollisionPosition
Position GetFirstCollisionPosition(float dist, float angle)
Definition: Object.cpp:3416

WorldObject::IsFriendlyTo
bool IsFriendlyTo(WorldObject const *target) const
Definition: Object.cpp:2865

WorldObject::GetCombatReach
virtual float GetCombatReach() const
Definition: Object.h:514

WorldObject::GetAffectingPlayer
Player * GetAffectingPlayer() const
Definition: Object.cpp:2261

WorldObject::GetRandomPoint
void GetRandomPoint(Position const &srcPos, float distance, float &rand_x, float &rand_y, float &rand_z) const
Definition: Object.cpp:1331

WorldObject::GetFactionTemplateEntry
FactionTemplateEntry const * GetFactionTemplateEntry() const
Definition: Object.cpp:2679

WorldPacket
Definition: WorldPacket.h:26

WorldPackets::CombatLog::SpellDispellLog
Definition: CombatLogPackets.h:166

WorldPackets::CombatLog::SpellDispellLog::DispelledBySpellID
int32 DispelledBySpellID
Definition: CombatLogPackets.h:175

WorldPackets::CombatLog::SpellDispellLog::IsSteal
bool IsSteal
Definition: CombatLogPackets.h:177

WorldPackets::CombatLog::SpellDispellLog::Write
WorldPacket const * Write() override
Definition: CombatLogPackets.cpp:434

WorldPackets::CombatLog::SpellDispellLog::TargetGUID
ObjectGuid TargetGUID
Definition: CombatLogPackets.h:174

WorldPackets::CombatLog::SpellDispellLog::DispellData
std::vector< SpellDispellData > DispellData
Definition: CombatLogPackets.h:172

WorldPackets::CombatLog::SpellDispellLog::CasterGUID
ObjectGuid CasterGUID
Definition: CombatLogPackets.h:173

WorldPackets::CombatLog::SpellDispellLog::IsBreak
bool IsBreak
Definition: CombatLogPackets.h:176

WorldPackets::CombatLog::SpellInstakillLog
Definition: CombatLogPackets.h:196

WorldPackets::CombatLog::SpellInstakillLog::Caster
ObjectGuid Caster
Definition: CombatLogPackets.h:203

WorldPackets::CombatLog::SpellInstakillLog::Write
WorldPacket const * Write() override
Definition: CombatLogPackets.cpp:262

WorldPackets::CombatLog::SpellInstakillLog::Target
ObjectGuid Target
Definition: CombatLogPackets.h:202

WorldPackets::CombatLog::SpellInstakillLog::SpellID
int32 SpellID
Definition: CombatLogPackets.h:204

WorldPackets::Combat::PvPCredit
Definition: CombatPackets.h:216

WorldPackets::Combat::PvPCredit::OriginalHonor
int32 OriginalHonor
Definition: CombatPackets.h:222

WorldPackets::Combat::PvPCredit::Write
WorldPacket const * Write() override
Definition: CombatPackets.cpp:151

WorldPackets::Combat::PvPCredit::Honor
int32 Honor
Definition: CombatPackets.h:223

WorldPackets::Duel::DuelRequested
Definition: DuelPackets.h:87

WorldPackets::Duel::DuelRequested::RequestedByGUID
ObjectGuid RequestedByGUID
Definition: DuelPackets.h:94

WorldPackets::Duel::DuelRequested::Write
WorldPacket const * Write() override
Definition: DuelPackets.cpp:50

WorldPackets::Duel::DuelRequested::ArbiterGUID
ObjectGuid ArbiterGUID
Definition: DuelPackets.h:93

WorldPackets::Duel::DuelRequested::RequestedByWowAccount
ObjectGuid RequestedByWowAccount
Definition: DuelPackets.h:95

WorldPackets::Misc::PlayMusic
Definition: MiscPackets.h:516

WorldPackets::Spells::CustomLoadScreen
Definition: SpellPackets.h:1010

WorldPackets::Spells::CustomLoadScreen::Write
WorldPacket const * Write() override
Definition: SpellPackets.cpp:996

WorldPackets::Spells::DispelFailed
Definition: SpellPackets.h:997

WorldPackets::Spells::DispelFailed::CasterGUID
ObjectGuid CasterGUID
Definition: SpellPackets.h:1003

WorldPackets::Spells::DispelFailed::FailedSpells
std::vector< int32 > FailedSpells
Definition: SpellPackets.h:1006

WorldPackets::Spells::DispelFailed::VictimGUID
ObjectGuid VictimGUID
Definition: SpellPackets.h:1004

WorldPackets::Spells::DispelFailed::SpellID
uint32 SpellID
Definition: SpellPackets.h:1005

WorldPackets::Spells::DispelFailed::Write
WorldPacket const * Write() override
Definition: SpellPackets.cpp:984

WorldPackets::Spells::SpellVisualLoadScreen
Definition: SpellPackets.h:762

WorldPackets::Spells::SpellVisualLoadScreen::Write
WorldPacket const * Write() override
Definition: SpellPackets.cpp:794

WorldPackets::Talent::ActiveGlyphs
Definition: TalentPackets.h:113

WorldPackets::Talent::ActiveGlyphs::Glyphs
std::vector< GlyphBinding > Glyphs
Definition: TalentPackets.h:119

WorldPackets::Talent::ActiveGlyphs::IsFullUpdate
bool IsFullUpdate
Definition: TalentPackets.h:120

WorldPackets::Talent::ActiveGlyphs::Write
WorldPacket const * Write() override
Definition: TalentPackets.cpp:95

WorldSession::SendNotification
void SendNotification(char const *format,...) ATTR_PRINTF(2
Definition: WorldSession.cpp:741

WorldSession::GetAccountGUID
ObjectGuid GetAccountGUID() const
Definition: WorldSession.h:1001

WorldSession::HasPermission
bool HasPermission(uint32 permissionId)
Definition: WorldSession.cpp:1231

WorldSession::GetAccountId
uint32 GetAccountId() const
Definition: WorldSession.h:1000

WorldSession::GetCollectionMgr
CollectionMgr * GetCollectionMgr() const
Definition: WorldSession.h:1179

WorldSession::SendDiscoverNewTaxiNode
void SendDiscoverNewTaxiNode(uint32 nodeid)
Definition: TaxiHandler.cpp:161

WorldSession::GetBattlePetMgr
BattlePets::BattlePetMgr * GetBattlePetMgr() const
Definition: WorldSession.h:1177

flag128
Definition: FlagsArray.h:117

sWorld
#define sWorld
Definition: World.h:931

CONFIG_SKILL_MILLING
@ CONFIG_SKILL_MILLING
Definition: World.h:123

CONFIG_SKILL_PROSPECTING
@ CONFIG_SKILL_PROSPECTING
Definition: World.h:122

CONFIG_NO_RESET_TALENT_COST
@ CONFIG_NO_RESET_TALENT_COST
Definition: World.h:150

CONFIG_CAST_UNSTUCK
@ CONFIG_CAST_UNSTUCK
Definition: World.h:119

RATE_DROP_MONEY
@ RATE_DROP_MONEY
Definition: World.h:482

BattlePets::BattlePetXpSource::SpellEffect
@ SpellEffect

BattlePets::BattlePetBreedQuality
BattlePetBreedQuality
Definition: BattlePetMgr.h:44

BattlePets::BattlePetBreedQuality::Poor
@ Poor

BattlePets::BattlePetError::TooHighLevelToUncage
@ TooHighLevelToUncage

BattlePets::BattlePetError::CantHaveMorePetsOfType
@ CantHaveMorePetsOfType

BattlePets::SPELL_VISUAL_UNCAGE_PET
@ SPELL_VISUAL_UNCAGE_PET
Definition: BattlePetMgr.h:34

BattlePets::BattlePetSlot::Slot0
@ Slot0

GameEvents::Trigger
TC_GAME_API void Trigger(uint32 gameEventId, WorldObject *source, WorldObject *target)
Definition: GameEventSender.cpp:28

GameTime::GetGameTimeMS
uint32 GetGameTimeMS()
Definition: GameTime.cpp:49

Movement::gravity
float constexpr gravity
Definition: MovementTypedefs.h:79

ObjectAccessor::FindPlayer
TC_GAME_API Player * FindPlayer(ObjectGuid const &)
Definition: ObjectAccessor.cpp:252

TraitMgr::GetConfigTypeForTree
TraitConfigType GetConfigTypeForTree(int32 traitTreeId)
Definition: TraitMgr.cpp:277

UF::size
constexpr std::size_t size()
Definition: UpdateField.h:796

rbac::RBAC_PERM_LOG_GM_TRADE
@ RBAC_PERM_LOG_GM_TRADE
Definition: RBAC.h:64

ActionButton
Definition: Player.h:319

ActionButton::GetAction
uint64 GetAction() const
Definition: Player.h:327

ActionButton::GetType
ActionButtonType GetType() const
Definition: Player.h:326

AreaTableEntry
Definition: DB2Structure.h:126

AreaTableEntry::GetFlags
EnumFlag< AreaFlags > GetFlags() const
Definition: DB2Structure.h:153

AreaTriggerId
Definition: AreaTriggerTemplate.h:91

AuraCreateInfo
Definition: SpellAuraDefines.h:697

AuraCreateInfo::SetBaseAmount
AuraCreateInfo & SetBaseAmount(int32 const *bp)
Definition: SpellAuraDefines.h:706

AuraCreateInfo::SetCaster
AuraCreateInfo & SetCaster(Unit *caster)
Definition: SpellAuraDefines.h:705

AuraCreateInfo::SetCastItem
AuraCreateInfo & SetCastItem(ObjectGuid const &guid, uint32 itemId, int32 itemLevel)
Definition: SpellAuraDefines.h:707

BattlePetBreedQualityEntry
Definition: DB2Structure.h:457

BattlePetSpeciesEntry
Definition: DB2Structure.h:473

BattlePetSpeciesEntry::CreatureID
int32 CreatureID
Definition: DB2Structure.h:477

CastSpellExtraArgs
Definition: SpellDefines.h:449

CastSpellExtraArgs::SetTriggeringSpell
CastSpellExtraArgs & SetTriggeringSpell(Spell const *triggeringSpell)
Definition: Spell.cpp:9403

CastSpellExtraArgs::CastDifficulty
Difficulty CastDifficulty
Definition: SpellDefines.h:483

CastSpellExtraArgs::TriggerFlags
TriggerCastFlags TriggerFlags
Definition: SpellDefines.h:478

CastSpellExtraArgs::SetOriginalCaster
CastSpellExtraArgs & SetOriginalCaster(ObjectGuid const &guid)
Definition: SpellDefines.h:471

CastSpellExtraArgs::SetCustomArg
CastSpellExtraArgs & SetCustomArg(std::any customArg)
Definition: SpellDefines.h:476

CastSpellExtraArgs::AddSpellMod
CastSpellExtraArgs & AddSpellMod(SpellValueMod mod, int32 val)
Definition: SpellDefines.h:474

CastSpellExtraArgs::CastItem
Item * CastItem
Definition: SpellDefines.h:479

CastSpellExtraArgs::OriginalCastId
ObjectGuid OriginalCastId
Definition: SpellDefines.h:484

CastSpellExtraArgs::OriginalCastItemLevel
Optional< int32 > OriginalCastItemLevel
Definition: SpellDefines.h:485

Cell::VisitGridObjects
static void VisitGridObjects(WorldObject const *obj, T &visitor, float radius, bool dont_load=true)
Definition: CellImpl.h:179

Cell::VisitWorldObjects
static void VisitWorldObjects(WorldObject const *obj, T &visitor, float radius, bool dont_load=true)
Definition: CellImpl.h:191

CharmInfo
Definition: CharmInfo.h:89

CharmInfo::SaveStayPosition
void SaveStayPosition()
Definition: Unit.cpp:12596

CharmInfo::SetIsCommandFollow
void SetIsCommandFollow(bool val)
Definition: Unit.cpp:12586

CharmInfo::SetIsAtStay
void SetIsAtStay(bool val)
Definition: Unit.cpp:12617

CharmInfo::SetIsFollowing
void SetIsFollowing(bool val)
Definition: Unit.cpp:12627

CharmInfo::SetIsReturning
void SetIsReturning(bool val)
Definition: Unit.cpp:12637

CharmInfo::HasCommandState
bool HasCommandState(CommandStates state) const
Definition: CharmInfo.h:99

CharmInfo::SetIsCommandAttack
void SetIsCommandAttack(bool val)
Definition: Unit.cpp:12576

ChrSpecializationEntry
Definition: DB2Structure.h:857

ChrSpecializationEntry::IsPetSpecialization
bool IsPetSpecialization() const
Definition: DB2Structure.h:875

ContentTuningEntry
Definition: DB2Structure.h:918

ContentTuningEntry::ExpansionID
int32 ExpansionID
Definition: DB2Structure.h:921

CreatureDifficulty::GetRequiredLootSkill
SkillType GetRequiredLootSkill() const
Definition: CreatureData.h:464

CreatureDifficulty::SkinLootID
uint32 SkinLootID
Definition: CreatureData.h:452

CreatureDifficulty::PickPocketLootID
uint32 PickPocketLootID
Definition: CreatureData.h:451

FactionEntry
Definition: DB2Structure.h:1567

FactionTemplateEntry
Definition: DB2Structure.h:1597

FactionTemplateEntry::IsFriendlyTo
bool IsFriendlyTo(FactionTemplateEntry const *entry) const
Definition: DB2Structure.h:1610

GameObjectTemplate
Definition: GameObjectData.h:32

GameObjectTemplate::type
uint32 type
Definition: GameObjectData.h:34

GameObjectTemplate::GetNoDamageImmune
uint32 GetNoDamageImmune() const
Definition: GameObjectData.h:1013

GameObjectTemplate::GetLockId
uint32 GetLockId() const
Definition: GameObjectData.h:972

GlyphPropertiesEntry
Definition: DB2Structure.h:1943

ItemEffectEntry
Definition: DB2Structure.h:2264

ItemTemplate
Definition: ItemTemplate.h:772

ItemTemplate::GetRequiredSkillRank
uint32 GetRequiredSkillRank() const
Definition: ItemTemplate.h:792

ItemTemplate::GetBaseItemLevel
uint32 GetBaseItemLevel() const
Definition: ItemTemplate.h:789

ItemTemplate::GetId
uint32 GetId() const
Definition: ItemTemplate.h:776

ItemTemplate::GetMaxStackSize
uint32 GetMaxStackSize() const
Definition: ItemTemplate.h:847

ItemTemplate::HasFlag
bool HasFlag(ItemFlags flag) const
Definition: ItemTemplate.h:871

ItemTemplate::GetDefaultLocaleName
char const * GetDefaultLocaleName() const
Definition: ItemTemplate.cpp:137

ItemTemplate::GetLockID
uint32 GetLockID() const
Definition: ItemTemplate.h:810

JumpArrivalCastArgs
Definition: MovementDefines.h:117

JumpArrivalCastArgs::Target
ObjectGuid Target
Definition: MovementDefines.h:119

JumpArrivalCastArgs::SpellId
uint32 SpellId
Definition: MovementDefines.h:118

JumpChargeParams
Definition: MovementDefines.h:123

Loot
Definition: Loot.h:281

Loot::FillLoot
bool FillLoot(uint32 lootId, LootStore const &store, Player *lootOwner, bool personal, bool noEmptyError=false, uint16 lootMode=LOOT_MODE_DEFAULT, ItemContext context=ItemContext::NONE)
Definition: Loot.cpp:759

NonDefaultConstructible
Definition: Util.h:527

Position
Definition: Position.h:28

Position::SetOrientation
constexpr void SetOrientation(float orientation)
Definition: Position.h:71

Position::GetPositionX
constexpr float GetPositionX() const
Definition: Position.h:76

Position::GetPositionY
constexpr float GetPositionY() const
Definition: Position.h:77

Position::GetExactDist2d
float GetExactDist2d(const float x, const float y) const
Definition: Position.h:106

Position::GetRelativeAngle
float GetRelativeAngle(float x, float y) const
Definition: Position.h:136

Position::GetExactDist
float GetExactDist(float x, float y, float z) const
Definition: Position.h:118

Position::GetAbsoluteAngle
float GetAbsoluteAngle(float x, float y) const
Definition: Position.h:125

Position::GetPosition
constexpr void GetPosition(float &x, float &y) const
Definition: Position.h:81

Position::Relocate
constexpr void Relocate(float x, float y)
Definition: Position.h:63

Position::GetOrientation
constexpr float GetOrientation() const
Definition: Position.h:79

Position::GetPositionZ
constexpr float GetPositionZ() const
Definition: Position.h:78

PvPInfo::IsHostile
bool IsHostile
Definition: Player.h:348

PvPInfo::IsInHostileArea
bool IsInHostileArea
Definition: Player.h:349

QuaternionData
Definition: QuaternionData.h:24

QuaternionData::fromEulerAnglesZYX
static QuaternionData fromEulerAnglesZYX(float Z, float Y, float X)
Definition: GameObject.cpp:118

SkillRaceClassInfoEntry
Definition: DB2Structure.h:3411

SkillRaceClassInfoEntry::Flags
uint16 Flags
Definition: DB2Structure.h:3416

SkillRaceClassInfoEntry::SkillTierID
int16 SkillTierID
Definition: DB2Structure.h:3419

SkillTiersEntry
Definition: ObjectMgr.h:971

SkillTiersEntry::GetValueForTierIndex
uint32 GetValueForTierIndex(uint32 tierIndex) const
Definition: ObjectMgr.cpp:7938

SpellDestination
Definition: SpellDefines.h:315

SpellDestination::_position
WorldLocation _position
Definition: SpellDefines.h:325

SpellDestination::_transportGUID
ObjectGuid _transportGUID
Definition: SpellDefines.h:326

SpellItemEnchantmentEntry
Definition: DB2Structure.h:3636

SpellItemEnchantmentEntry::Effect
std::array< uint8, MAX_ITEM_ENCHANTMENT_EFFECTS > Effect
Definition: DB2Structure.h:3655

SpellItemEnchantmentEntry::Duration
int32 Duration
Definition: DB2Structure.h:3640

SpellNonMeleeDamage
Definition: Unit.h:548

SpellNonMeleeDamage::damage
uint32 damage
Definition: Unit.h:556

SpellNonMeleeDamage::absorb
uint32 absorb
Definition: Unit.h:559

SpellNonMeleeDamage::originalDamage
uint32 originalDamage
Definition: Unit.h:557

SpellNonMeleeDamage::resist
uint32 resist
Definition: Unit.h:560

SpellPowerCost
Definition: SpellInfo.h:315

SpellValue::EffectBasePoints
int32 EffectBasePoints[MAX_SPELL_EFFECTS]
Definition: Spell.h:220

Spell::TargetInfo
Definition: Spell.h:781

SummonPropertiesEntry
Definition: DB2Structure.h:3971

SummonPropertiesEntry::GetFlags
EnumFlag< SummonPropertiesFlags > GetFlags() const
Definition: DB2Structure.h:3979

SummonPropertiesEntry::Title
int32 Title
Definition: DB2Structure.h:3975

SummonPropertiesEntry::Control
int32 Control
Definition: DB2Structure.h:3973

TalentEntry
Definition: DB2Structure.h:3991

Trinity::MessageDistDelivererToHostile
Definition: GridNotifiers.h:197

Trinity::PacketSenderOwning
Definition: GridNotifiers.h:147

Trinity::PacketSenderOwning::Data
Packet Data
Definition: GridNotifiers.h:148

Trinity::WorldObjectListSearcher
Definition: GridNotifiers.h:341

UF::SelectedAzeriteEssences
Definition: UpdateFields.h:184

UF::TraitConfig
Definition: UpdateFields.h:732

UF::TraitConfig::Type
UpdateField< int32, 4, 5 > Type
Definition: UpdateFields.h:736

UF::TraitConfig::TraitSystemID
UpdateField< int32, 8, 11 > TraitSystemID
Definition: UpdateFields.h:741

UF::VisibleItem
Definition: UpdateFields.h:237

UF::VisibleItem::ItemAppearanceModID
UpdateField< uint16, 0, 4 > ItemAppearanceModID
Definition: UpdateFields.h:241

UF::VisibleItem::ItemVisual
UpdateField< uint16, 0, 5 > ItemVisual
Definition: UpdateFields.h:242

UF::VisibleItem::ItemID
UpdateField< int32, 0, 1 > ItemID
Definition: UpdateFields.h:238

WorldPackets::CombatLog::SpellDispellData
Definition: CombatLogPackets.h:158

WorldPackets::CombatLog::SpellDispellData::SpellID
int32 SpellID
Definition: CombatLogPackets.h:159

WorldPackets::CombatLog::SpellDispellData::Harmful
bool Harmful
Definition: CombatLogPackets.h:160

WorldPackets::Traits::TraitConfig
Definition: TraitPacketsCommon.h:46

WorldPackets::Traits::TraitConfig::TraitSystemID
int32 TraitSystemID
Definition: TraitPacketsCommon.h:56

WorldPackets::Traits::TraitConfig::Type
TraitConfigType Type
Definition: TraitPacketsCommon.h:51