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 "QuestMgr.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::EffectForceCast2,                               //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::EffectReputation,                               //184 SPELL_EFFECT_REPUTATION_2

    &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::EffectApplyMountEquipment,                      //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::EffectSkipCampaign,                             //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::EffectUpdateInteractions,                       //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::EffectSkipQuestLine,                            //311 SPELL_EFFECT_SKIP_QUESTLINE

    &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

    &Spell::EffectKillCreditLabel,                          //316 SPELL_EFFECT_KILL_CREDIT_LABEL_1

    &Spell::EffectKillCreditLabel,                          //317 SPELL_EFFECT_KILL_CREDIT_LABEL_2

    &Spell::EffectNULL,                                     //318 SPELL_EFFECT_318

    &Spell::EffectNULL,                                     //319 SPELL_EFFECT_319

    &Spell::EffectNULL,                                     //320 SPELL_EFFECT_320

    &Spell::EffectNULL,                                     //321 SPELL_EFFECT_321

    &Spell::EffectNULL,                                     //322 SPELL_EFFECT_322

    &Spell::EffectNULL,                                     //323 SPELL_EFFECT_323

    &Spell::EffectNULL,                                     //324 SPELL_EFFECT_324

    &Spell::EffectNULL,                                     //325 SPELL_EFFECT_325

    &Spell::EffectNULL,                                     //326 SPELL_EFFECT_326

    &Spell::EffectNULL,                                     //327 SPELL_EFFECT_327

    &Spell::EffectNULL,                                     //328 SPELL_EFFECT_328

    &Spell::EffectNULL,                                     //329 SPELL_EFFECT_329

    &Spell::EffectNULL,                                     //330 SPELL_EFFECT_330

    &Spell::EffectNULL,                                     //331 SPELL_EFFECT_331

    &Spell::EffectNULL,                                     //332 SPELL_EFFECT_332

    &Spell::EffectNULL,                                     //333 SPELL_EFFECT_333

    &Spell::EffectNULL,                                     //334 SPELL_EFFECT_334

    &Spell::EffectSetPlayerDataElementAccount,              //335 SPELL_EFFECT_SET_PLAYER_DATA_ELEMENT_ACCOUNT

    &Spell::EffectSetPlayerDataElementCharacter,            //336 SPELL_EFFECT_SET_PLAYER_DATA_ELEMENT_CHARACTER

    &Spell::EffectSetPlayerDataFlagAccount,                 //337 SPELL_EFFECT_SET_PLAYER_DATA_FLAG_ACCOUNT

    &Spell::EffectSetPlayerDataFlagCharacter,               //338 SPELL_EFFECT_SET_PLAYER_DATA_FLAG_CHARACTER

    &Spell::EffectNULL,                                     //339 SPELL_EFFECT_UI_ACTION

    &Spell::EffectNULL,                                     //340 SPELL_EFFECT_340

    &Spell::EffectLearnWarbandScene,                        //341 SPELL_EFFECT_LEARN_WARBAND_SCENE

    &Spell::EffectNULL,                                     //342 SPELL_EFFECT_342

    &Spell::EffectNULL,                                     //343 SPELL_EFFECT_343

    &Spell::EffectNULL,                                     //344 SPELL_EFFECT_344

    &Spell::EffectNULL,                                     //345 SPELL_EFFECT_ASSIST_ACTION

    &Spell::EffectNULL,                                     //346 SPELL_EFFECT_346

    &Spell::EffectEquipTransmogOutfit,                      //347 SPELL_EFFECT_EQUIP_TRANSMOG_OUTFIT

    &Spell::EffectNULL,                                     //348 SPELL_EFFECT_GIVE_HOUSE_LEVEL

    &Spell::EffectNULL,                                     //349 SPELL_EFFECT_LEARN_HOUSE_ROOM

    &Spell::EffectNULL,                                     //350 SPELL_EFFECT_LEARN_HOUSE_EXTERIOR_COMPONENT

    &Spell::EffectNULL,                                     //351 SPELL_EFFECT_LEARN_HOUSE_THEME

    &Spell::EffectNULL,                                     //352 SPELL_EFFECT_LEARN_HOUSE_ROOM_COMPONENT_TEXTURE

    &Spell::EffectCreateAreaTrigger,                        //353 SPELL_EFFECT_CREATE_AREATRIGGER_2

    &Spell::EffectNULL,                                     //354 SPELL_EFFECT_SET_NEIGHBORHOOD_INITIATIVE

    &Spell::EffectNULL,                                     //355 SPELL_EFFECT_LEARN_HOUSE_TYPE

    &Spell::EffectNULL,                                     //356 SPELL_EFFECT_356

    &Spell::EffectNULL,                                     //357 SPELL_EFFECT_357

    &Spell::EffectNULL,                                     //358 SPELL_EFFECT_358

    &Spell::EffectNULL,                                     //359 SPELL_EFFECT_359

};


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 = GetEffectValueAsInt();

    uint32 mana = effectInfo->MiscValue;

    ExecuteLogEffectResurrect(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;


    uint32 damage = GetEffectValueAsInt();

    // 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())

    {

        int32 damage = GetEffectValueAsInt();

        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();

        if (unitCaster && apply_direct_bonus)

        {

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

            damage = bonus + int32(bonus * variance);

            damage = unitTarget->SpellDamageBonusTaken(unitCaster, m_spellInfo, 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;

        }

    }

}


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 = effectValue, 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 & ~(TRIGGERED_IGNORE_POWER_COST | TRIGGERED_IGNORE_REAGENT_COST));

        args.SetOriginalCaster(originalCaster);

        args.OriginalCastId = originalCastId;

        args.OriginalCastItemLevel = itemLevel;

        SpellInfo const* spellInfo = sSpellMgr->AssertSpellInfo(spellEffectInfo->TriggerSpell, caster->GetMap()->GetDifficultyID());

        if (!castItemGuid.IsEmpty() && spellInfo->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 (std::size_t i = 0; i < spellInfo->GetEffects().size(); ++i)

                args.AddSpellMod(SpellValueModFloat(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 & ~(TRIGGERED_IGNORE_POWER_COST | TRIGGERED_IGNORE_REAGENT_COST));

    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 (std::size_t i = 0; i < spellInfo->GetEffects().size(); ++i)

            args.AddSpellMod(SpellValueModFloat(SPELLVALUE_BASE_POINT0 + i), effectValue);


    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_LAUNCH_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)

    {

        switch (m_spellInfo->Id)

        {

            case 52588: // Skeletal Gryphon Escape

            case 48598: // Ride Flamebringer Cue

                unitTarget->RemoveAura(GetEffectValueAsInt());

                break;

            case 52463: // Hide In Mine Car

            case 52349: // Overtake

            {

                CastSpellExtraArgs args(TRIGGERED_FULL_MASK);

                args.SetOriginalCaster(m_originalCasterGUID);

                args.AddSpellMod(SPELLVALUE_BASE_POINT0, effectValue);

                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));

            return;

    }


    CastSpellExtraArgs args(TRIGGERED_FULL_MASK & ~(TRIGGERED_IGNORE_POWER_COST | TRIGGERED_CAST_DIRECTLY | TRIGGERED_IGNORE_REAGENT_COST));

    if (effectInfo->Effect == SPELL_EFFECT_FORCE_CAST_WITH_VALUE)

        for (std::size_t i = 0; i < spellInfo->GetEffects().size(); ++i)

            args.AddSpellMod(SpellValueModFloat(SPELLVALUE_BASE_POINT0 + i), effectValue);


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

}


void Spell::EffectForceCast2()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)

        return;


    if (!unitTarget)

        return;


    uint32 triggered_spell_id = effectInfo->TriggerSpell;

    if (triggered_spell_id == 0)

    {

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

        return;

    }


    // normal case

    if (!sSpellMgr->GetSpellInfo(triggered_spell_id, GetCastDifficulty()))

    {

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

        return;

    }


    // Start the cast during next update tick

    // This is neccessary to preserve proper SMSG_SPELL_START and SMSG_SPELL_GO packet sequence

    // (if packet sequence is not preserved then client cast bar in UI bugs and doesn't stop when the spell is interrupted)

    // Triggered spells from effects handled during launch phase (such as SPELL_EFFECT_TRIGGER_SPELL)

    // normally have their SMSG_SPELL_GO sent before parent spell SMSG_SPELL_GO

    // SPELL_EFFECT_FORCE_CAST_2 requires these packets to be sent after parent spell

    // but also needs to be handled during launch phase as well

    unitTarget->m_Events.AddEventAtOffset([triggered_spell_id, target = CastSpellTargetArg(m_caster), caster = unitTarget]() mutable

    {

        if (!target.Targets)

            return;


        target.Targets->Update(caster);


        caster->CastSpell(target, triggered_spell_id);

    }, 0ms);

}


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::EffectJump()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)

        return;


    Unit* unitCaster = GetUnitCasterForEffectHandlers();

    if (!unitCaster)

        return;


    if (unitCaster->IsInFlight())

        return;


    if (!unitTarget)

        return;


    Optional<float> speedMultiplier = effectInfo->Amplitude > 0.0f ? Optional<float>(effectInfo->Amplitude) : std::nullopt;

    Optional<float> minHeight = effectInfo->MiscValue ? Optional<float>(effectInfo->MiscValue / 10.0f) : std::nullopt;

    Optional<float> maxHeight = effectInfo->MiscValueB ? Optional<float>(effectInfo->MiscValueB / 10.0f) : std::nullopt;


    MovementFacingTarget facing;

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

    {

        if (m_spellInfo->HasAttribute(SPELL_ATTR9_FACE_UNIT_TARGET_UPON_COMPLETION_OF_JUMP_CHARGE))

            facing = target;

    }


    JumpArrivalCastArgs arrivalCast;

    arrivalCast.SpellId = effectInfo->TriggerSpell;

    arrivalCast.Target = unitTarget->GetGUID();

    unitCaster->GetMotionMaster()->MoveJump(EVENT_JUMP, *unitTarget, {}, minHeight, maxHeight,

        facing, m_spellInfo->HasAttribute(SPELL_ATTR9_JUMPCHARGE__NO_FACING_CONTROL),

        false, speedMultiplier, &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;


    Optional<float> speedMultiplier = effectInfo->Amplitude > 0.0f ? Optional<float>(effectInfo->Amplitude) : std::nullopt;

    Optional<float> minHeight = effectInfo->MiscValue ? Optional<float>(effectInfo->MiscValue / 10.0f) : std::nullopt;

    Optional<float> maxHeight = effectInfo->MiscValueB ? Optional<float>(effectInfo->MiscValueB / 10.0f) : std::nullopt;


    MovementFacingTarget facing;

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

    {

        if (m_spellInfo->HasAttribute(SPELL_ATTR9_FACE_UNIT_TARGET_UPON_COMPLETION_OF_JUMP_CHARGE))

            facing = target;

    }

    else

        facing = destTarget->GetOrientation();


    JumpArrivalCastArgs arrivalCast;

    arrivalCast.SpellId = effectInfo->TriggerSpell;

    unitCaster->GetMotionMaster()->MoveJump(EVENT_JUMP, *destTarget, {}, minHeight, maxHeight,

        facing, m_spellInfo->HasAttribute(SPELL_ATTR9_JUMPCHARGE__NO_FACING_CONTROL),

        false, speedMultiplier, &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;


        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

    TeleportLocation targetDest{ .Location = *destTarget };

    if (targetDest.Location.GetMapId() == MAPID_INVALID)

        targetDest.Location.m_mapId = unitTarget->GetMapId();


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

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


    Player* player = unitTarget->ToPlayer();


    if (player)

    {

        // Custom loading screen

        if (uint32 customLoadingScreenId = effectInfo->MiscValue)

            if (targetDest.Location.GetMapId() != unitTarget->GetMapId() || !unitTarget->IsInDist2d(targetDest.Location, TELEPORT_MIN_LOAD_SCREEN_DISTANCE))

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


        if (ObjectGuid transportGuid = m_destTargets[effectInfo->EffectIndex]._transportGUID; !transportGuid.IsEmpty())

        {

            targetDest.TransportGuid = transportGuid;

            targetDest.Location.Relocate(m_destTargets[effectInfo->EffectIndex]._transportOffset);

        }


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

        player->TeleportTo(targetDest, options, m_spellInfo->Id);


    }

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

        unitTarget->NearTeleportTo(targetDest.Location, 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, TeleportLocation 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.Location.GetMapId() == _target->GetMapId())

            _target->NearTeleportTo(_targetDest.Location, (_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;

    TeleportLocation _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

    TeleportLocation targetDest{ .Location = *destTarget };

    if (targetDest.Location.GetMapId() == MAPID_INVALID)

        targetDest.Location.m_mapId = unitTarget->GetMapId();


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

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


    if (ObjectGuid transportGuid = m_destTargets[effectInfo->EffectIndex]._transportGUID; !transportGuid.IsEmpty())

    {

        targetDest.TransportGuid = transportGuid;

        targetDest.Location.Relocate(m_destTargets[effectInfo->EffectIndex]._transportOffset);

    }


    if (effectInfo->MiscValueB)

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

            playerTarget->SendDirectMessage(WorldPackets::Spells::SpellVisualLoadScreen(effectInfo->MiscValueB, Milliseconds(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 || _spellAura->IsRemoved() || !unitTarget)

        return;


    // register target/effect on aura

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

    if (!aurApp)

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

    else

        aurApp->AddEffectToApplyEffectMask(effectInfo->EffectIndex);

}


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;


    int32 drainAmount = GetEffectValueAsInt();

    Powers powerType = Powers(effectInfo->MiscValue);

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

        return;


    Unit* unitCaster = GetUnitCasterForEffectHandlers();

    // add spell damage bonus

    if (unitCaster)

    {

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

        drainAmount = bonus + int32(bonus * variance);

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

    }


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


    // Don't restore from self drain

    float gainMultiplier = 0.f;

    if (unitCaster && unitCaster != unitTarget)

    {

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

        int32 const gain = int32(damage * gainMultiplier);


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

    }

    ExecuteLogEffectTakeTargetPower(effectInfo->Effect, unitTarget, powerType, damage, 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;


    int32 burnAmount = GetEffectValueAsInt();

    Powers powerType = Powers(effectInfo->MiscValue);

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

        return;


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


    // 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(effectInfo->Effect, unitTarget, powerType, damage, 0.0f);


    damage = int32(damage * dmgMultiplier);


    m_damage += damage;

}


void Spell::EffectHeal()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)

        return;


    int32 addhealth = GetEffectValueAsInt();


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

        return;


    Unit* unitCaster = GetUnitCasterForEffectHandlers();


    // Skip if m_originalCaster not available

    if (!unitCaster)

        return;


    // 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(addhealth)), HEAL, *effectInfo, 1, this);

    else

    {

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

        addhealth = bonus + int32(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() || effectValue < 0)

        return;


    int32 heal = unitTarget->CountPctFromMaxHealth(effectValue);

    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() || effectValue < 0)

        return;


    Unit* unitCaster = GetUnitCasterForEffectHandlers();

    int32 heal = GetEffectValueAsInt();

    if (unitCaster)

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


    heal += int32(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;


    int32 damage = GetEffectValueAsInt();

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

        return;


    Unit* unitCaster = GetUnitCasterForEffectHandlers();

    int32 bonus = 0;

    if (unitCaster)

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


    damage = bonus + int32(bonus * variance);


    if (unitCaster)

        damage = unitTarget->SpellDamageBonusTaken(unitCaster, m_spellInfo, damage, SPELL_DIRECT_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

    int32 healthGain = int32(-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 = std::clamp<int32>(GetEffectValueAsInt(), 1, 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(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(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

        if (!m_CastItem)

            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(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, false, true);

        if (!m_CastItem)

            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;


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

    if (!unitCaster->IsInWorld())

        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 = 0.0f;

    for (size_t i = 0; i <= effectInfo->EffectIndex; ++i)

    {

        SpellEffectInfo const& spellEffectInfo = m_spellInfo->GetEffect(SpellEffIndex(i));

        if (spellEffectInfo.IsEffect(SPELL_EFFECT_PERSISTENT_AREA_AURA))

            radius = std::max(radius, spellEffectInfo.CalcRadius(unitCaster).Max);

    }


    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());

    for (size_t i = 0; i < m_spellInfo->GetEffects().size(); ++i)

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

            _dynObjAura->_ApplyEffectForTargets(i);


    if (m_spellInfo->IsChanneled())

        unitCaster->AddChannelObject(dynObj->GetGUID());

}


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;


    int32 energizeAmount = GetEffectValueAsInt();

    // Some level depends spells

    switch (m_spellInfo->Id)

    {

        case 24571:                                         // Blood Fury

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

            energizeAmount -= 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))}.

            energizeAmount -= 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(energizeAmount, 25);

            break;

        }

        default:

            break;

    }


    unitCaster->EnergizeBySpell(unitTarget, m_spellInfo, energizeAmount, 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, effectValue);

    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 (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, true);

    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(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 = std::max(GetEffectValueAsInt(), 1);

            break;

        default:

            numSummons = 1;

            break;

    }


    switch (properties->Control)

    {

        case SUMMON_CATEGORY_WILD:

        case SUMMON_CATEGORY_ALLY:

        {

            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:

                case SummonTitle::Lightwell:

                {

                    if (!unitCaster)

                        return;


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

                    break;

                }

                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 (int32 health = GetEffectValueAsInt())                                            // if not spell info, DB values used

                    {

                        summon->SetMaxHealth(health);

                        summon->SetHealth(health);

                    }

                    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:

                {

                    SpellRange radius = effectInfo->CalcRadius();


                    TempSummonType summonType = TEMPSUMMON_TIMED_DESPAWN;

                    if (duration == 0ms)

                        summonType = TEMPSUMMON_DEAD_DESPAWN;

                    else if (duration == -1ms)

                        summonType = TEMPSUMMON_MANUAL_DESPAWN;

                    else if (properties->GetFlags().HasFlag(SummonPropertiesFlags::UseDemonTimeout))

                        summonType = TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT;


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

                    {

                        Position pos;

                        if (count == 0)

                            pos = destTarget->GetPosition();

                        else

                            // randomize position for multiple summons

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


                        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(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_POSSESSED_VEHICLE:

        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, 0, privateObjectOwner);

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

                return;


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

            uint32 spellId = VEHICLE_SPELL_RIDE_HARDCODED;

            SpellEffectValue 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(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();


    int32 dispelAmount = GetEffectValueAsInt();


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

    DispelChargesList successList;

    successList.reserve(dispelAmount);


    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 < dispelAmount && 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));


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

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


    std::ranges::find(m_UniqueTargetInfo, unitTarget->GetGUID(), &TargetInfo::TargetGUID)->ProcHitMask |= 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(GetEffectValueAsInt() * 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().Max;

    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->IsPlayer())

        return;


    Player* playerTarget = unitTarget->ToPlayer();

    playerTarget->SendRespecWipeConfirm(m_caster->GetGUID(), playerTarget->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())

        return;


    TeleportLocation targetDest{ .Location = *destTarget };

    if (ObjectGuid transportGuid = m_destTargets[effectInfo->EffectIndex]._transportGUID; !transportGuid.IsEmpty())

    {

        targetDest.TransportGuid = transportGuid;

        targetDest.Location.Relocate(m_destTargets[effectInfo->EffectIndex]._transportOffset);

        targetDest.Location.SetOrientation(destTarget->GetAbsoluteAngle(m_caster) - targetDest.Location.GetOrientation());

    }

    else

        targetDest.Location.SetOrientation(destTarget->GetAbsoluteAngle(m_caster));


    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;


    uint16 skillTier = GetEffectValueAsInt();

    if (skillTier < 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(skillTier - 1);


    if (rcEntry->Flags & SKILL_FLAG_ALWAYS_MAX_VALUE)

        skillval = maxSkillVal;


    playerTarget->SetSkill(skillid, skillTier, 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

        effectValue = 1.0;

        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)

            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();


    // add to world

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


    // visual effect for levelup

    pet->SendNewlyTamed();


    // 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(GetEffectValueAsInt());


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

    uint32 effectMask = std::ranges::find(m_UniqueTargetInfo, unitTarget->GetGUID(), &TargetInfo::TargetGUID)->EffectMask;

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

    {

        if (!(effectMask & (1 << j)))

            continue;


        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

    SpellEffectValue fixed_bonus = 0;

    SpellEffectValue 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())

    {

        if (!(effectMask & (1 << spellEffectInfo.EffectIndex)))

            continue;


        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 = fixed_bonus * weapon_total_pct;

        if (spell_bonus)

            spell_bonus = spell_bonus * weapon_total_pct;

    }


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

    Mechanics mechanic = MECHANIC_NONE;


    // Sequence is important

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

    {

        if (!(effectMask & (1 << spellEffectInfo.EffectIndex)))

            continue;


        // 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 = 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 = weaponDamage * totalDamagePercentMod;


    // prevent negative damage

    weaponDamage = std::max(std::round(weaponDamage), 0.0);


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

    weaponDamage = unitCaster->MeleeDamageBonusDone(unitTarget, weaponDamage, m_attackType, SPELL_DIRECT_DAMAGE, m_spellInfo, effectInfo, 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, effectValue, 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 (GetEffectValueAsInt() == 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_CHANNELING

                || (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));

                std::ranges::find(m_UniqueTargetInfo, unitTarget->GetGUID(), &TargetInfo::TargetGUID)->ProcHitMask |= PROC_HIT_INTERRUPT;

                SendSpellInterruptLog(unitTarget, curSpellInfo->Id);

                unitTarget->InterruptSpell(CurrentSpellTypes(i), false, false, SPELL_FAILED_INTERRUPTED_COMBAT, SPELL_FAILED_DONT_REPORT, m_caster->GetGUID());

            }

        }

    }

}


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::fromOrientation(o);

    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(effectInfo->Effect, go);


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

    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(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).Max;

                    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;


                    SpellRange radius = effectInfo->CalcRadius();

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

                        m_caster->CastSpell(m_caster->GetRandomPoint(*destTarget, radius.Max, radius.Min), 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(GetEffectValueAsInt(), 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, GetEffectValueAsInt(), CastSpellExtraArgs()

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

                            }

                        }

                    }

                    return;

                }

            }

            break;

        }

    }

}


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::fromOrientation(pos.GetOrientation());


    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(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 = GetEffectValueAsInt();//+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())

    {

        if (!m_CastItem)

            caster->UpdateCraftSkill(m_spellInfo);


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

        itemTarget->m_loot->FillLoot(*itemTarget->GetDisenchantLootId(), 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 currentDrunk = player->GetDrunkValue();

    int32 drunkMod = GetEffectValueAsInt();


    if (drunkMod == 0)

        return;


    // drunkMod may contain values that are guaranteed to cause uint8 overflow/underflow (examples: 29690, 46874)

    // In addition, we would not want currentDrunk to become more than 100.

    // So before adding the values, let's check that everything is fine.

    if (drunkMod > static_cast<int32>(100 - currentDrunk))

        currentDrunk = 100;

    else if (drunkMod < static_cast<int32>(0 - currentDrunk))

        currentDrunk = 0;

    else

        currentDrunk += drunkMod; // Due to previous checks we can be sure that currentDrunk will not go beyond [0-100] range.


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


    if (currentDrunk == 100 && drunkMod > 0 && roll_chance(25))

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

            .SetTriggeringSpell(this));    // Drunken Vomit

}


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(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(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::fromOrientation(o);


    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(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(effectValue);

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


    ExecuteLogEffectResurrect(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;


    int32 extraAttacks = GetEffectValueAsInt();


    unitTarget->AddExtraAttacks(extraAttacks);


    ExecuteLogEffectExtraAttacks(effectInfo->Effect, unitTarget, extraAttacks);

}


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;


    TeleportLocation targetDest{ .Location = *destTarget };

    if (ObjectGuid transportGuid = m_destTargets[effectInfo->EffectIndex]._transportGUID; !transportGuid.IsEmpty())

    {

        targetDest.TransportGuid = transportGuid;

        targetDest.Location.Relocate(m_destTargets[effectInfo->EffectIndex]._transportOffset);

    }


    unitTarget->NearTeleportTo(targetDest, 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 = GetEffectValueAsInt();


    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;


        QuestStatus questStatus = player->GetQuestStatus(questId);

        if (questStatus == QUEST_STATUS_REWARDED)

            return;


        if (quest->HasFlag(QUEST_FLAGS_COMPLETION_EVENT) || quest->HasFlag(QUEST_FLAGS_COMPLETION_AREA_TRIGGER))

        {

            if (questStatus == QUEST_STATUS_INCOMPLETE)

                player->AreaExploredOrEventHappens(questId);

        }

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

            player->CompleteQuest(questId);

    }

}


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 (effectValue < 0)

    {

        health = uint32(-GetEffectValueAsInt());

        mana = effectInfo->MiscValue;

    }

    // percent case

    else

    {

        health = player->CountPctFromMaxHealth(effectValue);

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

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

    }


    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_MISSILE_SPEED_IS_DELAY_IN_SEC))

            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->IsValidAttackTarget(unitTarget))

            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_MISSILE_SPEED_IS_DELAY_IN_SEC))

            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

    if (unitTarget->HasUnitState(UNIT_STATE_ROOT))

        return;


    float ratio = 0.1f;

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

    float speedZ = effectValue * ratio;

    if (std::abs(speedXY) < 0.01f && std::abs(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 = effectValue / 10.f;


    // Disengage

    unitTarget->KnockbackFrom(unitTarget->GetPosition(), 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;


    player->RemoveActiveQuest(quest_id, false);


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

    if (oldStatus != QUEST_STATUS_REWARDED)

    {

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

        player->TakeQuestSourceItem(quest_id, false);


        if (quest->HasFlag(QUEST_FLAGS_FLAGS_PVP))

        {

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

            player->UpdatePvPState();

        }

    }


    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->KnockbackFrom(unitTarget->GetPosition(), speedXY, speedZ, unitTarget->GetRelativeAngle(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->KnockbackFrom(unitTarget->GetPosition(), speedXY, speedZ, unitTarget->GetRelativeAngle(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(GetEffectValueAsInt(), 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(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);


    CallScriptSuccessfulDispel(SpellEffIndex(effectInfo->EffectIndex));


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

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


    std::ranges::find(m_UniqueTargetInfo, unitTarget->GetGUID(), &TargetInfo::TargetGUID)->ProcHitMask |= PROC_HIT_DISPEL;

}


void Spell::EffectResurrectPet()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)

        return;


    if (effectValue < 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::ranges::find_if(petStable->ActivePets, [](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(effectValue));


    // 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, effectValue);


    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(GetEffectValueAsInt(), (slot < -1));

        ExecuteLogEffectDurabilityDamage(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, GetEffectValueAsInt());

        ExecuteLogEffectDurabilityDamage(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(effectValue / 100.0, (slot < -1));

        return;

    }


    // invalid slot value

    if (slot >= INVENTORY_SLOT_BAG_END)

        return;


    if (effectValue <= 0)

        return;


    if (Item* item = unitTarget->ToPlayer()->GetItemByPos(INVENTORY_SLOT_BAG_0, slot))

        unitTarget->ToPlayer()->DurabilityLoss(item, effectValue / 100.0);

}


void Spell::EffectModifyThreatPercent()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


    Unit* unitCaster = GetUnitCasterForEffectHandlers();

    if (!unitCaster || !unitTarget)

        return;


    unitTarget->GetThreatManager().ModifyThreatByPercent(unitCaster, effectValue);

}


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).Min;

        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

        auto [min_dis, max_dis] = m_spellInfo->GetMinMaxRange(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::fromOrientation(fo);


    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(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(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;


    uint16 skillStep = GetEffectValueAsInt();

    if (skillStep < 1)

        return;


    uint32 skillid = effectInfo->MiscValue;

    if (playerTarget->GetSkillStep(skillid) >= skillStep)

        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(skillStep - 1);


    if (rcEntry->Flags & SKILL_FLAG_ALWAYS_MAX_VALUE)

        skillval = maxSkillVal;


    playerTarget->SetSkill(skillid, skillStep, 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();


    int32 stealAmount = GetEffectValueAsInt();


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

    std::vector<std::tuple<uint32, ObjectGuid, int32>> successList;

    successList.reserve(stealAmount);


    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 < stealAmount && 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);


    std::ranges::find(m_UniqueTargetInfo, unitTarget->GetGUID(), &TargetInfo::TargetGUID)->ProcHitMask |= 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::EffectKillCreditLabel()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


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

    if (!playerTarget)

        return;


    playerTarget->UpdateQuestObjectiveProgress(QUEST_OBJECTIVE_KILL_WITH_LABEL, effectInfo->MiscValue, std::max(1, effectInfo->MiscValueB));

}


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());


    pet->SendNewlyTamed();


    // 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, effectInfo->MiscValue, m_spellInfo->EquippedItemClass, m_spellInfo->EquippedItemSubClassMask);

}


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(), effectValue);

}


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(-GetEffectValueAsInt(), m_caster, GetSpellInfo()->Id);

}


void Spell::EffectGameObjectRepair()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


    if (!gameObjTarget)

        return;


    gameObjTarget->ModifyHealth(GetEffectValueAsInt(), 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(SpellEffects(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(effectValue);

}


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, GetEffectValueAsInt(), 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_IGNORE_CAST_TIME | 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())

            item->SetSpellCharges(itemEffect, 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 (effectValue <= 0)

        return;


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

        player->IncreaseCurrencyCap(effectInfo->MiscValue, GetEffectValueAsInt());

}


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(), GetEffectValueAsInt() - 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::fromOrientation(o);

    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(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(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(effectValue);

    uint32 mana   = CalculatePct(target->GetMaxPower(POWER_MANA), effectValue);

    uint32 resurrectAura = 0;

    if (sSpellMgr->GetSpellInfo(effectInfo->TriggerSpell, DIFFICULTY_NONE))

        resurrectAura = effectInfo->TriggerSpell;


    if (resurrectAura && target->HasAura(resurrectAura))

        return;


    ExecuteLogEffectResurrect(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;


    auto work = [check = Trinity::ObjectEntryAndPrivateOwnerIfExistsCheck(unitTarget->GetGUID(), effectInfo->MiscValue)](Conversation* conversation)

    {

        if (check(conversation))

            conversation->Remove();

    };

    Trinity::ConversationWorker worker(unitTarget, work);

    Cell::VisitGridObjects(unitTarget, worker, 100.0f);

}


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(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(), GetEffectValueAsInt());

}


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, effectValue * float(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(GetEffectValueAsInt());

}


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::ranges::lower_bound(sBattlePetBreedQualityStore, GetEffectValueAsInt(), {}, &BattlePetBreedQualityEntry::MaxQualityRoll);


    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(uint64(effectValue), 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(uint64(effectValue), 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;


    int32 honor = GetEffectValueAsInt();


    WorldPackets::Combat::PvPCredit packet;

    packet.Honor = honor;

    packet.OriginalHonor = honor;


    Player* playerTarget = unitTarget->ToPlayer();

    playerTarget->AddHonorXP(honor);

    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;


    std::variant<std::monostate, float, Milliseconds> speedOrTime = [params]() -> std::variant<std::monostate, float, Milliseconds>

    {

        if (params->TreatSpeedAsMoveTimeSeconds)

            return duration_cast<Milliseconds>(FloatSeconds(params->MoveTimeInSec));


        return params->Speed;

    }();


    MovementFacingTarget facing;

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

    {

        if (m_spellInfo->HasAttribute(SPELL_ATTR9_FACE_UNIT_TARGET_UPON_COMPLETION_OF_JUMP_CHARGE))

            facing = target;

    }


    Optional<JumpArrivalCastArgs> arrivalCast;

    if (effectInfo->TriggerSpell || params->TriggerSpellId)

    {

        arrivalCast.emplace();

        arrivalCast->SpellId = params->TriggerSpellId ? *params->TriggerSpellId : effectInfo->TriggerSpell;

        arrivalCast->Target = unitTarget ? unitTarget->GetGUID() : ObjectGuid::Empty;

    }


    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()->MoveJump(EVENT_JUMP, *destTarget, speedOrTime, params->MinHeight, params->MaxHeight,

        facing, m_spellInfo->HasAttribute(SPELL_ATTR9_JUMPCHARGE__NO_FACING_CONTROL), params->UnlimitedSpeed, {},

        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::EffectApplyMountEquipment()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)

        return;


    Player* playerTarget = unitTarget->ToPlayer();

    if (!playerTarget)

        return;


    for (MountEquipmentEntry const* mountEquipment : sMountEquipmentStore)

    {

        if (mountEquipment->LearnedBySpell == effectInfo->TriggerSpell)

        {

            playerTarget->LearnSpell(mountEquipment->LearnedBySpell, false, 0, true);

            Unit::AuraEffectList const& mountAuras = playerTarget->GetAuraEffectsByType(SPELL_AURA_MOUNTED);

            if (!mountAuras.empty())

                if (MountEntry const* mountEntry = sDB2Manager.GetMount(mountAuras.front()->GetId()))

                    if (!mountEntry->GetFlags().HasFlag(MountFlags::MountEquipmentEffectsSuppressed))

                        playerTarget->CastSpell(playerTarget, mountEquipment->BuffSpell, true);

        }

        else

        {

            playerTarget->RemoveOwnedAura(mountEquipment->BuffSpell);

            playerTarget->RemoveSpell(mountEquipment->LearnedBySpell, false, false, true);

        }

    }


    WorldPackets::Spells::ApplyMountEquipmentResult applyMountEquipmentResult;

    applyMountEquipmentResult.ItemGUID = m_castItemGUID;

    applyMountEquipmentResult.ItemID = m_castItemEntry;

    applyMountEquipmentResult.Result = WorldPackets::Spells::ApplyMountEquipmentResult::Success;

    playerTarget->SendDirectMessage(applyMountEquipmentResult.Write());

}


void Spell::EffectSkipCampaign()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


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

    if (!target)

        return;


    QuestMgr::SkipCampaignForPlayer(effectInfo->MiscValue, target);

}


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(), GetEffectValueAsInt(), 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(GetEffectValueAsInt());

            break;

        case 1:

            targetAura->SetStackAmount(GetEffectValueAsInt());

            break;

        default:

            break;

    }

}


void Spell::EffectModifyCooldown()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


    unitTarget->GetSpellHistory()->ModifyCooldown(effectInfo->TriggerSpell, Milliseconds(GetEffectValueAsInt()));

}


void Spell::EffectModifyCooldowns()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


    unitTarget->GetSpellHistory()->ModifyCoooldowns([this](SpellHistory::CooldownEntry const& cooldown)

    {

        SpellInfo const* spellOnCooldown = sSpellMgr->AssertSpellInfo(cooldown.SpellId, 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;


        return (spellOnCooldown->SpellFamilyFlags[bitIndex / 32] & 1u << (bitIndex % 32)) != 0;

    }, Milliseconds(GetEffectValueAsInt()));

}


void Spell::EffectModifyCooldownsByCategory()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


    unitTarget->GetSpellHistory()->ModifyCoooldowns([this](SpellHistory::CooldownEntry const& cooldown)

    {

        return sSpellMgr->AssertSpellInfo(cooldown.SpellId, DIFFICULTY_NONE)->CategoryId == uint32(effectInfo->MiscValue);

    }, Milliseconds(GetEffectValueAsInt()));

}


void Spell::EffectModifySpellCharges()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


    for (int32 i = 0; i < GetEffectValueAsInt(); ++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;


    if (target->IsLoading() && target->m_activePlayerData->TraitConfigs.empty())

        return; // traits not loaded yet


    WorldPackets::Traits::TraitConfig newConfig;

    newConfig.Type = TraitMgr::GetConfigTypeForTree(effectInfo->MiscValue);

    if (newConfig.Type != TraitConfigType::Generic)

        return;


    newConfig.TraitSystemID = sTraitTreeStore.AssertEntry(effectInfo->MiscValue)->TraitSystemID;

    TraitSystemEntry const* traitSystem = sTraitSystemStore.LookupEntry(newConfig.TraitSystemID);

    if (!traitSystem)

        return;


    switch (traitSystem->GetVariationType())

    {

        case TraitSystemVariationType::None:

            newConfig.VariationID = 0;

            break;

        case TraitSystemVariationType::Spec:

            newConfig.VariationID = AsUnderlyingType(target->GetPrimarySpecialization());

            break;

        default:

            return;

    }


    int32 const* existingConfigIdForSystem = target->m_activePlayerData->TraitConfigs.FindIf([&](UF::TraitConfig const& config)

    {

        return static_cast<TraitConfigType>(*config.Type) == TraitConfigType::Generic

            && config.TraitSystemID == newConfig.TraitSystemID

            && config.VariationID == newConfig.VariationID;

    }).first;


    if (!existingConfigIdForSystem)

        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), GetEffectValueAsInt(), false);

}


void Spell::EffectTeleportGraveyard()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


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

    if (!target)

        return;


    target->RepopAtGraveyard();

}


void Spell::EffectUpdateInteractions()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


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

    if (!target)

        return;


    target->UpdateVisibleObjectInteractions(true, false, true, true);

}


void Spell::EffectSkipQuestLine()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


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

    if (!target)

        return;


    QuestMgr::SkipQuestLineForPlayer(effectInfo->MiscValue, target);

}


void Spell::EffectLearnWarbandScene()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


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

    if (!target)

        return;


    target->GetSession()->GetCollectionMgr()->AddWarbandScene(effectInfo->MiscValue);

}


void Spell::EffectSetPlayerDataElementAccount()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


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

    if (!target)

        return;


    target->SetDataElementAccount(effectInfo->MiscValue, int64(GetEffectValueAsInt()));

}


void Spell::EffectSetPlayerDataElementCharacter()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


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

    if (!target)

        return;


    target->SetDataElementCharacter(effectInfo->MiscValue, int64(GetEffectValueAsInt()));

}


void Spell::EffectSetPlayerDataFlagAccount()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


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

    if (!target)

        return;


    target->SetDataFlagAccount(effectInfo->MiscValue, GetEffectValueAsInt() != 0);

}


void Spell::EffectSetPlayerDataFlagCharacter()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


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

    if (!target)

        return;


    target->SetDataFlagCharacter(effectInfo->MiscValue, GetEffectValueAsInt() != 0);

}


void Spell::EffectEquipTransmogOutfit()

{

    if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)

        return;


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

    if (!target)

        return;


    Optional<bool> locked;

    switch (static_cast<TransmogOutfitEquipAction>(m_misc.EquipTransmogOutfit.EquipAction))

    {

        case TransmogOutfitEquipAction::EquipAndLock:

        case TransmogOutfitEquipAction::RemoveAndLock:

        case TransmogOutfitEquipAction::Lock:

            locked = true;

            break;

        case TransmogOutfitEquipAction::Unlock:

            locked = false;

            break;

        default:

            break;

    }


    target->EquipTransmogOutfit(m_misc.EquipTransmogOutfit.TransmogOutfitId, static_cast<TransmogSituationTrigger>(m_misc.EquipTransmogOutfit.SituationTrigger), locked);

}


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:127

SPELL_SPIRIT_HEAL_MANA
@ SPELL_SPIRIT_HEAL_MANA
Definition Battleground.h:113

SPELL_RESURRECTION_VISUAL
@ SPELL_RESURRECTION_VISUAL
Definition Battleground.h:110

CellImpl.h

CharmInfo.h

CombatLogPackets.h

CombatPackets.h

Common.h

IN_MILLISECONDS
@ IN_MILLISECONDS
Definition Common.h:38

MINUTE
@ MINUTE
Definition Common.h:32

HOUR
@ HOUR
Definition Common.h:33

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)

sMountEquipmentStore
DB2Storage< MountEquipmentEntry > sMountEquipmentStore("MountEquipment.db2", &MountEquipmentLoadInfo::Instance)

sChrSpecializationStore
DB2Storage< ChrSpecializationEntry > sChrSpecializationStore("ChrSpecialization.db2", &ChrSpecializationLoadInfo::Instance)

sTraitSystemStore
DB2Storage< TraitSystemEntry > sTraitSystemStore("TraitSystem.db2", &TraitSystemLoadInfo::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:579

MAX_VEHICLE_SEATS
#define MAX_VEHICLE_SEATS
Definition DB2Structure.h:4952

MAX_ITEM_ENCHANTMENT_EFFECTS
#define MAX_ITEM_ENCHANTMENT_EFFECTS
Definition DB2Structure.h:3972

TraitConfigType
TraitConfigType
Definition DBCEnums.h:2871

TraitConfigType::Generic
@ Generic

MountFlags::MountEquipmentEffectsSuppressed
@ MountEquipmentEffectsSuppressed

SKILL_FLAG_ALWAYS_MAX_VALUE
@ SKILL_FLAG_ALWAYS_MAX_VALUE
Definition DBCEnums.h:2399

ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET
@ ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET
Definition DBCEnums.h:1233

MAX_EFFECT_MASK
#define MAX_EFFECT_MASK
Definition DBCEnums.h:2451

AzeriteItemMilestoneType
AzeriteItemMilestoneType
Definition DBCEnums.h:235

AzeriteItemMilestoneType::MajorEssence
@ MajorEssence

AreaFlags::AllowDueling
@ AllowDueling

ItemContext
ItemContext
Definition DBCEnums.h:1324

ItemContext::NONE
@ NONE

ItemContext::Trade_Skill
@ Trade_Skill

TraitSystemVariationType::None
@ None

TraitSystemVariationType::Spec
@ Spec

TransmogSituationTrigger
TransmogSituationTrigger
Definition DBCEnums.h:2720

DIFFICULTY_NONE
@ DIFFICULTY_NONE
Definition DBCEnums.h:936

MAX_AZERITE_ESSENCE_RANK
#define MAX_AZERITE_ESSENCE_RANK
Definition DBCEnums.h:232

MAX_AZERITE_ESSENCE_SLOT
#define MAX_AZERITE_ESSENCE_SLOT
Definition DBCEnums.h:231

SummonPropertiesFlags::OnlyVisibleToSummonerGroup
@ OnlyVisibleToSummonerGroup

SummonPropertiesFlags::UseDemonTimeout
@ UseDemonTimeout

SummonPropertiesFlags::JoinSummonerSpawnGroup
@ JoinSummonerSpawnGroup

SummonPropertiesFlags::OnlyVisibleToSummoner
@ OnlyVisibleToSummoner

TransmogOutfitEquipAction
TransmogOutfitEquipAction
Definition DBCEnums.h:2574

TransmogOutfitEquipAction::RemoveAndLock
@ RemoveAndLock

TransmogOutfitEquipAction::EquipAndLock
@ EquipAndLock

TransmogOutfitEquipAction::Unlock
@ Unlock

TransmogOutfitEquipAction::Lock
@ Lock

DatabaseEnv.h

uint8
uint8_t uint8
Definition Define.h:156

int64
int64_t int64
Definition Define.h:149

int8
int8_t int8
Definition Define.h:152

int32
int32_t int32
Definition Define.h:150

uint64
uint64_t uint64
Definition Define.h:153

UI64LIT
#define UI64LIT(N)
Definition Define.h:139

uint16
uint16_t uint16
Definition Define.h:155

uint32
uint32_t uint32
Definition Define.h:154

params
std::unordered_set< uint32 > params[2]
Definition DisableMgr.cpp:54

DuelPackets.h

Milliseconds
std::chrono::milliseconds Milliseconds
Milliseconds shorthand typedef.
Definition Duration.h:24

FloatSeconds
std::chrono::duration< double, Seconds::period > FloatSeconds
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
#define ASSERT
Definition Errors.h:72

GameEventSender.h

GameObjectAI.h

GameObjectActions
GameObjectActions
Definition GameObjectData.h:1458

GameObject.h

GO_JUST_DEACTIVATED
@ GO_JUST_DEACTIVATED
Definition GameObject.h:165

FISHING_BOBBER_READY_TIME
#define FISHING_BOBBER_READY_TIME
Definition GameObject.h:169

GameTime.h

Garrison.h

GossipDef.h

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:193

PERM_ENCHANTMENT_SLOT
@ PERM_ENCHANTMENT_SLOT
Definition ItemDefines.h:194

TEMP_ENCHANTMENT_SLOT
@ TEMP_ENCHANTMENT_SLOT
Definition ItemDefines.h:195

PRISMATIC_ENCHANTMENT_SLOT
@ PRISMATIC_ENCHANTMENT_SLOT
Definition ItemDefines.h:200

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:233

ITEM_MODIFIER_BATTLE_PET_DISPLAY_ID
@ ITEM_MODIFIER_BATTLE_PET_DISPLAY_ID
Definition ItemDefines.h:232

ITEM_MODIFIER_BATTLE_PET_BREED_DATA
@ ITEM_MODIFIER_BATTLE_PET_BREED_DATA
Definition ItemDefines.h:230

ITEM_MODIFIER_BATTLE_PET_SPECIES_ID
@ ITEM_MODIFIER_BATTLE_PET_SPECIES_ID
Definition ItemDefines.h:229

ITEM_MODIFIER_BATTLE_PET_LEVEL
@ ITEM_MODIFIER_BATTLE_PET_LEVEL
Definition ItemDefines.h:231

GenerateItemRandomBonusListId
ItemRandomBonusListId GenerateItemRandomBonusListId(uint32 item_id)
Definition ItemEnchantmentMgr.cpp:87

ITEM_CLASS_ARMOR
@ ITEM_CLASS_ARMOR
Definition ItemTemplate.h:458

ITEM_CLASS_WEAPON
@ ITEM_CLASS_WEAPON
Definition ItemTemplate.h:456

ITEM_FIELD_FLAG_UNLOCKED
@ ITEM_FIELD_FLAG_UNLOCKED
Definition ItemTemplate.h:147

ITEM_SPELLTRIGGER_ON_LEARN
@ ITEM_SPELLTRIGGER_ON_LEARN
Definition ItemTemplate.h:118

ITEM_FLAG_IS_MILLABLE
@ ITEM_FLAG_IS_MILLABLE
Definition ItemTemplate.h:219

ITEM_FLAG_IS_PROSPECTABLE
@ ITEM_FLAG_IS_PROSPECTABLE
Definition ItemTemplate.h:208

Item.h

ITEM_CHANGED
@ ITEM_CHANGED
Definition Item.h:47

Language.h

LANG_ZONE_NOFLYZONE
@ LANG_ZONE_NOFLYZONE
Definition Language.h:771

Log.h

TC_LOG_DEBUG
#define TC_LOG_DEBUG(filterType__, message__,...)
Definition Log.h:173

TC_LOG_ERROR
#define TC_LOG_ERROR(filterType__, message__,...)
Definition Log.h:182

sLog
#define sLog
Definition Log.h:156

TC_LOG_WARN
#define TC_LOG_WARN(filterType__, message__,...)
Definition Log.h:179

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:103

LOOT_MILLING
@ LOOT_MILLING
Definition Loot.h:116

LOOT_DISENCHANTING
@ LOOT_DISENCHANTING
Definition Loot.h:105

LOOT_SKINNING
@ LOOT_SKINNING
Definition Loot.h:107

LOOT_PROSPECTING
@ LOOT_PROSPECTING
Definition Loot.h:115

LOOT_ERROR_ALREADY_PICKPOCKETED
@ LOOT_ERROR_ALREADY_PICKPOCKETED
Definition Loot.h:150

Map.h

MiscPackets.h

MotionMaster.h

MoveSpline.h

SPEED_CHARGE
#define SPEED_CHARGE
Definition MovementDefines.h:30

MovementFacingTarget
std::variant< std::monostate, Position, Unit const  *, float > MovementFacingTarget
Definition MovementDefines.h:157

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

TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT
@ TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT
Definition ObjectDefines.h:66

DEFAULT_PLAYER_BOUNDING_RADIUS
#define DEFAULT_PLAYER_BOUNDING_RADIUS
Definition ObjectDefines.h:39

TYPEID_UNIT
@ TYPEID_UNIT
Definition ObjectGuid.h:43

TYPEID_PLAYER
@ TYPEID_PLAYER
Definition ObjectGuid.h:44

GuidSet
std::set< ObjectGuid > GuidSet
Definition ObjectGuid.h:432

HighGuid::DynamicObject
@ DynamicObject

ObjectMgr.h

sObjectMgr
#define sObjectMgr
Definition ObjectMgr.h:1873

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:98

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:730

ItemPosCountVec
std::vector< ItemPosCount > ItemPosCountVec
Definition Player.h:827

DAMAGE_FIRE
@ DAMAGE_FIRE
Definition Player.h:929

INVENTORY_SLOT_BAG_END
@ INVENTORY_SLOT_BAG_END
Definition Player.h:760

TeleportToOptions
TeleportToOptions
Definition Player.h:907

TELE_TO_SPELL
@ TELE_TO_SPELL
Definition Player.h:913

TELE_TO_NOT_LEAVE_COMBAT
@ TELE_TO_NOT_LEAVE_COMBAT
Definition Player.h:911

TELE_TO_NONE
@ TELE_TO_NONE
Definition Player.h:908

TELE_TO_NOT_LEAVE_TRANSPORT
@ TELE_TO_NOT_LEAVE_TRANSPORT
Definition Player.h:910

INVENTORY_SLOT_BAG_0
constexpr uint8 INVENTORY_SLOT_BAG_0
Definition Player.h:706

PLAYER_FLAGS_PET_BATTLES_UNLOCKED
@ PLAYER_FLAGS_PET_BATTLES_UNLOCKED
Definition Player.h:536

CHEAT_GOD
@ CHEAT_GOD
Definition Player.h:1060

ItemSearchLocation::Everywhere
@ Everywhere

ACTION_BUTTON_SPELL
@ ACTION_BUTTON_SPELL
Definition Player.h:365

SPEC_RESET_TALENTS
@ SPEC_RESET_TALENTS
Definition Player.h:244

TELEPORT_MIN_LOAD_SCREEN_DISTANCE
float constexpr TELEPORT_MIN_LOAD_SCREEN_DISTANCE
Definition Player.h:1206

REPUTATION_SOURCE_SPELL
@ REPUTATION_SOURCE_SPELL
Definition Player.h:401

MAPID_INVALID
#define MAPID_INVALID
Definition Position.h:189

QUEST_OBJECTIVE_KILL_WITH_LABEL
@ QUEST_OBJECTIVE_KILL_WITH_LABEL
Definition QuestDef.h:375

QuestStatus
QuestStatus
Definition QuestDef.h:142

QUEST_STATUS_REWARDED
@ QUEST_STATUS_REWARDED
Definition QuestDef.h:149

QUEST_STATUS_INCOMPLETE
@ QUEST_STATUS_INCOMPLETE
Definition QuestDef.h:146

QUEST_STATUS_NONE
@ QUEST_STATUS_NONE
Definition QuestDef.h:143

QUEST_FLAGS_FLAGS_PVP
@ QUEST_FLAGS_FLAGS_PVP
Definition QuestDef.h:227

QUEST_FLAGS_COMPLETION_AREA_TRIGGER
@ QUEST_FLAGS_COMPLETION_AREA_TRIGGER
Definition QuestDef.h:216

QUEST_FLAGS_COMPLETION_EVENT
@ QUEST_FLAGS_COMPLETION_EVENT
Definition QuestDef.h:215

QUEST_FLAGS_TRACKING_EVENT
@ QUEST_FLAGS_TRACKING_EVENT
Definition QuestDef.h:224

QuestMgr.h

rand_norm
float rand_norm()
Definition Random.cpp:76

roll_chance
bool roll_chance(float chance, PseudoRandomDistributionState &state)
Definition Random.cpp:131

urand
uint32 urand(uint32 min, uint32 max)
Definition Random.cpp:43

ReputationMgr.h

RestMgr.h

REST_TYPE_XP
@ REST_TYPE_XP
Definition RestMgr.h:29

SceneFlag::PlayerNonInteractablePhased
@ PlayerNonInteractablePhased

SceneObject.h

ScriptMgr.h

sScriptMgr
#define sScriptMgr
Definition ScriptMgr.h:1449

SharedDefines.h

SpellEffIndex
SpellEffIndex
Definition SharedDefines.h:29

SPELL_ATTR9_JUMPCHARGE__NO_FACING_CONTROL
@ SPELL_ATTR9_JUMPCHARGE__NO_FACING_CONTROL
Definition SharedDefines.h:792

SPELL_ATTR9_MISSILE_SPEED_IS_DELAY_IN_SEC
@ SPELL_ATTR9_MISSILE_SPEED_IS_DELAY_IN_SEC
Definition SharedDefines.h:773

SPELL_ATTR9_FACE_UNIT_TARGET_UPON_COMPLETION_OF_JUMP_CHARGE
@ SPELL_ATTR9_FACE_UNIT_TARGET_UPON_COMPLETION_OF_JUMP_CHARGE
Definition SharedDefines.h:781

SPELL_ATTR7_DISPEL_REMOVES_CHARGES
@ SPELL_ATTR7_DISPEL_REMOVES_CHARGES
Definition SharedDefines.h:705

SPELL_ATTR7_CAN_BE_MULTI_CAST
@ SPELL_ATTR7_CAN_BE_MULTI_CAST
Definition SharedDefines.h:700

SPELL_ATTR7_ATTACK_ON_CHARGE_TO_UNIT
@ SPELL_ATTR7_ATTACK_ON_CHARGE_TO_UNIT
Definition SharedDefines.h:713

SpellEffects
SpellEffects
Definition SharedDefines.h:1345

SPELL_EFFECT_TRIGGER_MISSILE_SPELL_WITH_VALUE
@ SPELL_EFFECT_TRIGGER_MISSILE_SPELL_WITH_VALUE
Definition SharedDefines.h:1494

SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE
@ SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE
Definition SharedDefines.h:1488

SPELL_EFFECT_SUMMON_OBJECT_SLOT1
@ SPELL_EFFECT_SUMMON_OBJECT_SLOT1
Definition SharedDefines.h:1450

SPELL_EFFECT_WEAPON_DAMAGE
@ SPELL_EFFECT_WEAPON_DAMAGE
Definition SharedDefines.h:1404

SPELL_EFFECT_NORMALIZED_WEAPON_DMG
@ SPELL_EFFECT_NORMALIZED_WEAPON_DMG
Definition SharedDefines.h:1467

SPELL_EFFECT_TRIGGER_SPELL
@ SPELL_EFFECT_TRIGGER_SPELL
Definition SharedDefines.h:1410

SPELL_EFFECT_WEAPON_PERCENT_DAMAGE
@ SPELL_EFFECT_WEAPON_PERCENT_DAMAGE
Definition SharedDefines.h:1377

SPELL_EFFECT_KNOCK_BACK_DEST
@ SPELL_EFFECT_KNOCK_BACK_DEST
Definition SharedDefines.h:1490

SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL
@ SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL
Definition SharedDefines.h:1363

SPELL_EFFECT_PERSISTENT_AREA_AURA
@ SPELL_EFFECT_PERSISTENT_AREA_AURA
Definition SharedDefines.h:1373

TOTAL_SPELL_EFFECTS
@ TOTAL_SPELL_EFFECTS
Definition SharedDefines.h:1706

SPELL_EFFECT_FORCE_CAST
@ SPELL_EFFECT_FORCE_CAST
Definition SharedDefines.h:1486

SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC
@ SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC
Definition SharedDefines.h:1502

SPELL_EFFECT_FORCE_CAST_WITH_VALUE
@ SPELL_EFFECT_FORCE_CAST_WITH_VALUE
Definition SharedDefines.h:1487

CLASS_HUNTER
@ CLASS_HUNTER
Definition SharedDefines.h:158

GAMEOBJECT_TYPE_DUEL_ARBITER
@ GAMEOBJECT_TYPE_DUEL_ARBITER
Definition SharedDefines.h:3179

GAMEOBJECT_TYPE_TRAP
@ GAMEOBJECT_TYPE_TRAP
Definition SharedDefines.h:3169

GAMEOBJECT_TYPE_CHEST
@ GAMEOBJECT_TYPE_CHEST
Definition SharedDefines.h:3166

GAMEOBJECT_TYPE_FISHINGHOLE
@ GAMEOBJECT_TYPE_FISHINGHOLE
Definition SharedDefines.h:3188

GAMEOBJECT_TYPE_GOOBER
@ GAMEOBJECT_TYPE_GOOBER
Definition SharedDefines.h:3173

GAMEOBJECT_TYPE_FISHINGNODE
@ GAMEOBJECT_TYPE_FISHINGNODE
Definition SharedDefines.h:3180

GAMEOBJECT_TYPE_RITUAL
@ GAMEOBJECT_TYPE_RITUAL
Definition SharedDefines.h:3181

SpellTargetIndex::TargetA
@ TargetA

SpellTargetIndex::TargetB
@ TargetB

SPELL_MISS_REFLECT
@ SPELL_MISS_REFLECT
Definition SharedDefines.h:3128

ITEM_QUALITY_EPIC
@ ITEM_QUALITY_EPIC
Definition SharedDefines.h:386

SPELL_SCHOOL_MASK_NORMAL
@ SPELL_SCHOOL_MASK_NORMAL
Definition SharedDefines.h:342

EVENT_JUMP
@ EVENT_JUMP
Definition SharedDefines.h:6740

SPELL_ATTR2_RETAIN_ITEM_CAST
@ SPELL_ATTR2_RETAIN_ITEM_CAST
Definition SharedDefines.h:541

SummonTitle
SummonTitle
Definition SharedDefines.h:6674

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:503

UNIT_DYNFLAG_LOOTABLE
@ UNIT_DYNFLAG_LOOTABLE
Definition SharedDefines.h:6442

UNIT_DYNFLAG_NONE
@ UNIT_DYNFLAG_NONE
Definition SharedDefines.h:6440

SUMMON_SLOT_TOTEM
@ SUMMON_SLOT_TOTEM
Definition SharedDefines.h:6724

OFF_ATTACK
@ OFF_ATTACK
Definition SharedDefines.h:7438

BASE_ATTACK
@ BASE_ATTACK
Definition SharedDefines.h:7437

RANGED_ATTACK
@ RANGED_ATTACK
Definition SharedDefines.h:7439

Mechanics
Mechanics
Definition SharedDefines.h:2869

MECHANIC_NONE
@ MECHANIC_NONE
Definition SharedDefines.h:2870

GameObjectDestructibleState
GameObjectDestructibleState
Definition SharedDefines.h:3288

Powers
Powers
Definition SharedDefines.h:293

MAX_POWERS
@ MAX_POWERS
Definition SharedDefines.h:321

POWER_RAGE
@ POWER_RAGE
Definition SharedDefines.h:296

POWER_ENERGY
@ POWER_ENERGY
Definition SharedDefines.h:298

POWER_MANA
@ POWER_MANA
Definition SharedDefines.h:295

POWER_FOCUS
@ POWER_FOCUS
Definition SharedDefines.h:297

SPELL_ATTR0_IS_TRADESKILL
@ SPELL_ATTR0_IS_TRADESKILL
Definition SharedDefines.h:441

MAX_TOTEM_SLOT
#define MAX_TOTEM_SLOT
Definition SharedDefines.h:6734

CurrencyDestroyReason::Spell
@ Spell

SpellCastResult
SpellCastResult
Definition SharedDefines.h:1711

SPELL_FAILED_INTERRUPTED_COMBAT
@ SPELL_FAILED_INTERRUPTED_COMBAT
Definition SharedDefines.h:1776

SPELL_FAILED_DONT_REPORT
@ SPELL_FAILED_DONT_REPORT
Definition SharedDefines.h:1744

SPELL_FAILED_NO_DUELING
@ SPELL_FAILED_NO_DUELING
Definition SharedDefines.h:1814

SPELL_CAST_OK
@ SPELL_CAST_OK
Definition SharedDefines.h:2039

SPELL_FAILED_CANT_ADD_BATTLE_PET
@ SPELL_FAILED_CANT_ADD_BATTLE_PET
Definition SharedDefines.h:1962

SPELLFAMILY_GENERIC
@ SPELLFAMILY_GENERIC
Definition SharedDefines.h:7063

SPELLFAMILY_SHAMAN
@ SPELLFAMILY_SHAMAN
Definition SharedDefines.h:7074

SPELLFAMILY_DEATHKNIGHT
@ SPELLFAMILY_DEATHKNIGHT
Definition SharedDefines.h:7078

DispelType
DispelType
Definition SharedDefines.h:2924

CurrencyGainSource::Spell
@ Spell

ChatMsg
ChatMsg
Definition SharedDefines.h:6474

GO_STATE_READY
@ GO_STATE_READY
Definition SharedDefines.h:3278

SPELL_ATTR4_CANNOT_BE_STOLEN
@ SPELL_ATTR4_CANNOT_BE_STOLEN
Definition SharedDefines.h:590

SUMMON_CATEGORY_POSSESSED_VEHICLE
@ SUMMON_CATEGORY_POSSESSED_VEHICLE
Definition SharedDefines.h:6669

SUMMON_CATEGORY_PET
@ SUMMON_CATEGORY_PET
Definition SharedDefines.h:6667

SUMMON_CATEGORY_VEHICLE
@ SUMMON_CATEGORY_VEHICLE
Definition SharedDefines.h:6670

SUMMON_CATEGORY_ALLY
@ SUMMON_CATEGORY_ALLY
Definition SharedDefines.h:6666

SUMMON_CATEGORY_PUPPET
@ SUMMON_CATEGORY_PUPPET
Definition SharedDefines.h:6668

SUMMON_CATEGORY_WILD
@ SUMMON_CATEGORY_WILD
Definition SharedDefines.h:6665

SkillType
SkillType
Definition SharedDefines.h:5863

SKILL_INSCRIPTION
@ SKILL_INSCRIPTION
Definition SharedDefines.h:5969

SKILL_ENGINEERING
@ SKILL_ENGINEERING
Definition SharedDefines.h:5909

SKILL_NONE
@ SKILL_NONE
Definition SharedDefines.h:5864

SKILL_SKINNING
@ SKILL_SKINNING
Definition SharedDefines.h:5937

SKILL_JEWELCRAFTING
@ SKILL_JEWELCRAFTING
Definition SharedDefines.h:5955

SPELL_ATTR6_IGNORE_CASTER_DAMAGE_MODIFIERS
@ SPELL_ATTR6_IGNORE_CASTER_DAMAGE_MODIFIERS
Definition SharedDefines.h:687

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:61

SPELL_AURA_CONTROL_VEHICLE
@ SPELL_AURA_CONTROL_VEHICLE
Definition SpellAuraDefines.h:323

SPELL_AURA_MOD_STALKED
@ SPELL_AURA_MOD_STALKED
Definition SpellAuraDefines.h:155

SPELL_AURA_MOUNTED
@ SPELL_AURA_MOUNTED
Definition SpellAuraDefines.h:165

SPELL_AURA_OVERRIDE_SUMMONED_OBJECT
@ SPELL_AURA_OVERRIDE_SUMMONED_OBJECT
Definition SpellAuraDefines.h:345

SPELL_AURA_MOD_STUN
@ SPELL_AURA_MOD_STUN
Definition SpellAuraDefines.h:99

SpellAuraEffects.h

SpellAuras.h

SPELLVALUE_PARENT_SPELL_TARGET_COUNT
@ SPELLVALUE_PARENT_SPELL_TARGET_COUNT
Definition SpellDefines.h:218

SPELLVALUE_PARENT_SPELL_TARGET_INDEX
@ SPELLVALUE_PARENT_SPELL_TARGET_INDEX
Definition SpellDefines.h:219

SpellEffectValue
double SpellEffectValue
This is a double instead of float to be able to store full range of int32.
Definition SpellDefines.h:490

SpellAuraInterruptFlags2::ChangeGlyph
@ ChangeGlyph

TARGET_FLAG_DEST_LOCATION
@ TARGET_FLAG_DEST_LOCATION
Definition SpellDefines.h:318

TARGET_FLAG_UNIT_MASK
@ TARGET_FLAG_UNIT_MASK
Definition SpellDefines.h:339

TARGET_FLAG_GAMEOBJECT_MASK
@ TARGET_FLAG_GAMEOBJECT_MASK
Definition SpellDefines.h:341

TRIGGERED_FULL_MASK
@ TRIGGERED_FULL_MASK
Used when doing CastSpell with triggered == true.
Definition SpellDefines.h:293

TRIGGERED_CAST_DIRECTLY
@ TRIGGERED_CAST_DIRECTLY
In Spell::prepare, will be cast directly without setting containers for executed spell.
Definition SpellDefines.h:281

TRIGGERED_IGNORE_CAST_IN_PROGRESS
@ TRIGGERED_IGNORE_CAST_IN_PROGRESS
Will not check if a current cast is in progress.
Definition SpellDefines.h:279

TRIGGERED_IGNORE_POWER_COST
@ TRIGGERED_IGNORE_POWER_COST
Will ignore power and reagent cost.
Definition SpellDefines.h:276

TRIGGERED_IGNORE_REAGENT_COST
@ TRIGGERED_IGNORE_REAGENT_COST
Will ignore reagent cost.
Definition SpellDefines.h:282

TRIGGERED_IGNORE_GCD
@ TRIGGERED_IGNORE_GCD
Will ignore GCD.
Definition SpellDefines.h:274

TRIGGERED_DONT_REPORT_CAST_ERROR
@ TRIGGERED_DONT_REPORT_CAST_ERROR
Will return SPELL_FAILED_DONT_REPORT in CheckCast functions.
Definition SpellDefines.h:292

TRIGGERED_IGNORE_CAST_TIME
@ TRIGGERED_IGNORE_CAST_TIME
Will always be instantly cast.
Definition SpellDefines.h:280

SpellValueModFloat
SpellValueModFloat
Definition SpellDefines.h:225

SPELLVALUE_BASE_POINT0
@ SPELLVALUE_BASE_POINT0
Definition SpellDefines.h:226

GetTeleportOptions
TeleportToOptions GetTeleportOptions(WorldObject const *caster, Unit const *unitTarget, SpellDestination const &targetDest)
Definition SpellEffects.cpp:986

IsUnitTargetSceneObjectAura
bool IsUnitTargetSceneObjectAura(Spell const *spell, TargetInfo const &target)
Definition SpellEffects.cpp:5802

SpellEffectHandlers
NonDefaultConstructible< SpellEffectHandlerFn > SpellEffectHandlers[TOTAL_SPELL_EFFECTS]
Definition SpellEffects.cpp:90

SpellHistory.h

SPELL_ATTR0_CU_SHARE_DAMAGE
@ SPELL_ATTR0_CU_SHARE_DAMAGE
Definition SpellInfo.h:147

IsPartOfSkillLine
bool IsPartOfSkillLine(uint32 skillId, uint32 spellId)
Definition SpellMgr.cpp:119

SpellMgr.h

PROC_SPELL_PHASE_HIT
@ PROC_SPELL_PHASE_HIT
Definition SpellMgr.h:225

sSpellMgr
#define sSpellMgr
Definition SpellMgr.h:812

PROC_SPELL_TYPE_MASK_ALL
@ PROC_SPELL_TYPE_MASK_ALL
Definition SpellMgr.h:216

PROC_FLAG_NONE
@ PROC_FLAG_NONE
Definition SpellMgr.h:92

PROC_FLAG_2_KNOCKBACK
@ PROC_FLAG_2_KNOCKBACK
Definition SpellMgr.h:191

PROC_FLAG_2_SUCCESSFUL_DISPEL
@ PROC_FLAG_2_SUCCESSFUL_DISPEL
Definition SpellMgr.h:194

PROC_HIT_DISPEL
@ PROC_HIT_DISPEL
Definition SpellMgr.h:249

PROC_HIT_INTERRUPT
@ PROC_HIT_INTERRUPT
Definition SpellMgr.h:247

PROC_HIT_NONE
@ PROC_HIT_NONE
Definition SpellMgr.h:234

SpellPackets.h

Spell.h

DispelList
std::vector< std::pair< uint32, ObjectGuid > > DispelList
Definition Spell.h:272

SPELL_EFFECT_HANDLE_LAUNCH_TARGET
@ SPELL_EFFECT_HANDLE_LAUNCH_TARGET
Definition Spell.h:267

SPELL_EFFECT_HANDLE_LAUNCH
@ SPELL_EFFECT_HANDLE_LAUNCH
Definition Spell.h:266

SPELL_EFFECT_HANDLE_HIT
@ SPELL_EFFECT_HANDLE_HIT
Definition Spell.h:268

SPELL_EFFECT_HANDLE_HIT_TARGET
@ SPELL_EFFECT_HANDLE_HIT_TARGET
Definition Spell.h:269

SPELL_STATE_CHANNELING
@ SPELL_STATE_CHANNELING
Definition Spell.h:259

SPELL_STATE_PREPARING
@ SPELL_STATE_PREPARING
Definition Spell.h:257

TalentPackets.h

TemporarySummon.h

Totem.h

TraitMgr.h

TraitPacketsCommon.h

UNIT_PET_FLAG_CAN_BE_RENAMED
@ UNIT_PET_FLAG_CAN_BE_RENAMED
Definition UnitDefines.h:109

REACT_DEFENSIVE
@ REACT_DEFENSIVE
Definition UnitDefines.h:444

REACT_AGGRESSIVE
@ REACT_AGGRESSIVE
Definition UnitDefines.h:445

SPELL_DIRECT_DAMAGE
@ SPELL_DIRECT_DAMAGE
Definition UnitDefines.h:156

HEAL
@ HEAL
Definition UnitDefines.h:158

UNIT_FLAG3_ALREADY_SKINNED
@ UNIT_FLAG3_ALREADY_SKINNED
Definition UnitDefines.h:286

COMMAND_STAY
@ COMMAND_STAY
Definition UnitDefines.h:463

UNIT_FLAG_IMMUNE
@ UNIT_FLAG_IMMUNE
Definition UnitDefines.h:198

UNIT_FLAG_SKINNABLE
@ UNIT_FLAG_SKINNABLE
Definition UnitDefines.h:193

Unit.h

UNIT_MASK_MINION
@ UNIT_MASK_MINION
Definition Unit.h:371

UnitMods
UnitMods
Definition Unit.h:177

UNIT_MOD_DAMAGE_OFFHAND
@ UNIT_MOD_DAMAGE_OFFHAND
Definition Unit.h:218

UNIT_MOD_DAMAGE_RANGED
@ UNIT_MOD_DAMAGE_RANGED
Definition Unit.h:219

UNIT_MOD_DAMAGE_MAINHAND
@ UNIT_MOD_DAMAGE_MAINHAND
Definition Unit.h:217

ALIVE
@ ALIVE
Definition Unit.h:266

CURRENT_FIRST_NON_MELEE_SPELL
#define CURRENT_FIRST_NON_MELEE_SPELL
Definition Unit.h:615

CurrentSpellTypes
CurrentSpellTypes
Definition Unit.h:608

CURRENT_AUTOREPEAT_SPELL
@ CURRENT_AUTOREPEAT_SPELL
Definition Unit.h:612

UNIT_STATE_CONFUSED
@ UNIT_STATE_CONFUSED
Definition Unit.h:286

UNIT_STATE_ROOT
@ UNIT_STATE_ROOT
Definition Unit.h:285

UNIT_STATE_FLEEING
@ UNIT_STATE_FLEEING
Definition Unit.h:282

UNIT_STATE_ALL_ERASABLE
@ UNIT_STATE_ALL_ERASABLE
Definition Unit.h:322

UNIT_STATE_STUNNED
@ UNIT_STATE_STUNNED
Definition Unit.h:278

DispelChargesList
std::vector< DispelableAura > DispelChargesList
Definition Unit.h:152

NULL_BAG
@ NULL_BAG
Definition Unit.h:63

NULL_SLOT
@ NULL_SLOT
Definition Unit.h:64

ARTIFACTS_ALL_WEAPONS_GENERAL_WEAPON_EQUIPPED_PASSIVE
#define ARTIFACTS_ALL_WEAPONS_GENERAL_WEAPON_EQUIPPED_PASSIVE
Definition Unit.h:38

TOTAL_PCT
@ TOTAL_PCT
Definition Unit.h:166

Util.h

AddPct
T AddPct(T &base, U pct)
Definition Util.h:85

AsUnderlyingType
constexpr std::underlying_type< E >::type AsUnderlyingType(E enumValue)
Definition Util.h:565

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:81

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:346

AuraApplication
Definition SpellAuras.h:61

AuraApplication::IsPositive
bool IsPositive() const
Definition SpellAuras.h:88

AuraApplication::AddEffectToApplyEffectMask
void AddEffectToApplyEffectMask(SpellEffIndex spellEffectIndex)
Definition SpellAuras.cpp:216

AuraApplication::GetBase
Aura * GetBase() const
Definition SpellAuras.h:82

AuraEffect
Definition SpellAuraEffects.h:30

Aura
Definition SpellAuras.h:168

Aura::TryCreate
static Aura * TryCreate(AuraCreateInfo &createInfo)
Definition SpellAuras.cpp:390

Aura::SetStackAmount
void SetStackAmount(uint8 num)
Definition SpellAuras.cpp:1056

Aura::GetApplicationOfTarget
AuraApplication const * GetApplicationOfTarget(ObjectGuid guid) const
Definition SpellAuras.cpp:1353

Aura::GetDynobjOwner
DynamicObject * GetDynobjOwner() const
Definition SpellAuras.h:197

Aura::_RegisterForTargets
void _RegisterForTargets()
Definition SpellAuras.h:209

Aura::GetCasterGUID
ObjectGuid GetCasterGUID() const
Definition SpellAuras.h:187

Aura::IsRemoved
bool IsRemoved() const
Definition SpellAuras.h:254

Aura::GetId
uint32 GetId() const
Definition SpellAuras.h:183

Aura::CalcDispelChance
int32 CalcDispelChance(Unit const *auraTarget, bool offensive) const
Definition SpellAuras.cpp:1237

Aura::ToDynObjAura
DynObjAura * ToDynObjAura()
Definition SpellAuras.h:351

Aura::ModStackAmount
bool ModStackAmount(int32 num, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT, bool resetPeriodicTimer=true)
Definition SpellAuras.cpp:1093

Aura::GetStackAmount
uint8 GetStackAmount() const
Definition SpellAuras.h:238

Aura::_ApplyEffectForTargets
void _ApplyEffectForTargets(uint8 effIndex)
Definition SpellAuras.cpp:796

Aura::GetCharges
uint8 GetCharges() const
Definition SpellAuras.h:229

Aura::GetSpellInfo
SpellInfo const * GetSpellInfo() const
Definition SpellAuras.h:182

Aura::IsPassive
bool IsPassive() const
Definition SpellAuras.cpp:1150

AzeriteEmpoweredItem
Definition AzeriteEmpoweredItem.h:24

AzeriteEmpoweredItem::ClearSelectedAzeritePowers
void ClearSelectedAzeritePowers()
Definition AzeriteEmpoweredItem.cpp:141

AzeriteEmpoweredItem::GetRespecCost
int64 GetRespecCost() const
Definition AzeriteEmpoweredItem.cpp:151

AzeriteItem
Definition AzeriteItem.h:30

AzeriteItem::GetSelectedAzeriteEssences
UF::SelectedAzeriteEssences const * GetSelectedAzeriteEssences() const
Definition AzeriteItem.cpp:350

AzeriteItem::SetEssenceRank
void SetEssenceRank(uint32 azeriteEssenceId, uint32 rank)
Definition AzeriteItem.cpp:322

BaseEntity::GetGUID
ObjectGuid const & GetGUID() const
Definition BaseEntity.h:163

BaseEntity::IsInWorld
bool IsInWorld() const
Definition BaseEntity.h:158

BaseEntity::IsCreature
bool IsCreature() const
Definition BaseEntity.h:172

BaseEntity::IsPlayer
bool IsPlayer() const
Definition BaseEntity.h:173

BaseEntity::GetTypeId
TypeID GetTypeId() const
Definition BaseEntity.h:166

BasicEvent
Definition EventProcessor.h:33

BattlePets::BattlePetMgr
Definition BattlePetMgr.h:147

BattlePets::BattlePetMgr::GrantBattlePetExperience
void GrantBattlePetExperience(ObjectGuid guid, uint16 xp, BattlePetXpSource xpSource)
Definition BattlePetMgr.cpp:693

BattlePets::BattlePetMgr::RollPetBreed
static uint16 RollPetBreed(uint32 species)
Definition BattlePetMgr.cpp:198

BattlePets::BattlePetMgr::GetMaxPetLevel
uint16 GetMaxPetLevel() const
Definition BattlePetMgr.cpp:596

BattlePets::BattlePetMgr::SelectPetDisplay
static uint32 SelectPetDisplay(BattlePetSpeciesEntry const *speciesEntry)
Definition BattlePetMgr.cpp:216

BattlePets::BattlePetMgr::UnlockSlot
void UnlockSlot(BattlePetSlot slot)
Definition BattlePetMgr.cpp:578

BattlePets::BattlePetMgr::GetBattlePetSpeciesBySpell
static BattlePetSpeciesEntry const * GetBattlePetSpeciesBySpell(uint32 spellId)
Definition BattlePetMgr.cpp:193

BattlePets::BattlePetMgr::AddPet
void AddPet(uint32 species, uint32 display, uint16 breed, BattlePetBreedQuality quality, uint16 level=1)
Definition BattlePetMgr.cpp:447

BattlePets::BattlePetMgr::GrantBattlePetLevel
void GrantBattlePetLevel(ObjectGuid guid, uint16 grantedLevels)
Definition BattlePetMgr.cpp:752

BattlePets::BattlePetMgr::HasMaxPetCount
bool HasMaxPetCount(BattlePetSpeciesEntry const *battlePetSpecies, ObjectGuid ownerGuid) const
Definition BattlePetMgr.cpp:561

BattlePets::BattlePetMgr::SendError
void SendError(BattlePetError error, uint32 creatureId)
Definition BattlePetMgr.cpp:892

BattlePets::BattlePetMgr::ChangeBattlePetQuality
void ChangeBattlePetQuality(ObjectGuid guid, BattlePetBreedQuality quality)
Definition BattlePetMgr.cpp:659

BattlePets::BattlePetMgr::GetDefaultPetQuality
static BattlePetBreedQuality GetDefaultPetQuality(uint32 species)
Definition BattlePetMgr.cpp:207

CollectionMgr
Definition CollectionMgr.h:109

CollectionMgr::AddTransmogSet
void AddTransmogSet(uint32 transmogSetId)
Definition CollectionMgr.cpp:638

CollectionMgr::GetHeirloomBonus
uint32 GetHeirloomBonus(uint32 itemId) const
Definition CollectionMgr.cpp:255

CollectionMgr::AddWarbandScene
void AddWarbandScene(uint32 warbandSceneId)
Definition CollectionMgr.cpp:1116

CollectionMgr::AddTransmogIllusion
void AddTransmogIllusion(uint32 transmogIllusionId)
Definition CollectionMgr.cpp:962

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:103

Corpse::GetOwnerGUID
ObjectGuid GetOwnerGUID() const override
Definition Corpse.h:108

CreatureTextMgr::GetRangeForChatType
static float GetRangeForChatType(ChatMsg msgType)
Definition CreatureTextMgr.cpp:248

Creature
Definition Creature.h:82

Creature::m_loot
std::unique_ptr< Loot > m_loot
Definition Creature.h:307

Creature::GetCreatureDifficulty
CreatureDifficulty const * GetCreatureDifficulty() const
Definition Creature.h:276

Creature::m_personalLoot
std::unordered_map< ObjectGuid, std::unique_ptr< Loot > > m_personalLoot
Definition Creature.h:308

Creature::GetLevelForTarget
uint8 GetLevelForTarget(WorldObject const *target) const override
Definition Creature.cpp:3227

Creature::StartPickPocketRefillTimer
void StartPickPocketRefillTimer()
Definition Creature.cpp:3760

Creature::SetReactState
void SetReactState(ReactStates st)
Definition Creature.h:180

Creature::DespawnOrUnsummon
void DespawnOrUnsummon(Milliseconds timeToDespawn=0s, Seconds forceRespawnTime=0s)
Definition Creature.cpp:2438

Creature::CanGeneratePickPocketLoot
bool CanGeneratePickPocketLoot() const
Definition Creature.cpp:3765

Creature::IsElite
bool IsElite() const
Definition Creature.cpp:2499

Creature::SetImmuneToAll
void SetImmuneToAll(bool apply) override
Definition Creature.h:187

Creature::IsIgnoringSanctuarySpellEffect
bool IsIgnoringSanctuarySpellEffect() const
Definition Creature.h:354

Creature::SetDisplayId
void SetDisplayId(uint32 displayId, bool setNative=false) override
Definition Creature.cpp:3603

DamageInfo
Definition Unit.h:436

DamageInfo::GetResist
uint32 GetResist() const
Definition Unit.h:469

DamageInfo::GetDamage
uint32 GetDamage() const
Definition Unit.h:466

DamageInfo::GetAbsorb
uint32 GetAbsorb() const
Definition Unit.h:468

DelayedSpellTeleportEvent
Definition SpellEffects.cpp:1052

DelayedSpellTeleportEvent::_target
Unit * _target
Definition SpellEffects.cpp:1070

DelayedSpellTeleportEvent::_options
TeleportToOptions _options
Definition SpellEffects.cpp:1072

DelayedSpellTeleportEvent::_spellId
uint32 _spellId
Definition SpellEffects.cpp:1073

DelayedSpellTeleportEvent::DelayedSpellTeleportEvent
DelayedSpellTeleportEvent(Unit *target, TeleportLocation const &targetDest, TeleportToOptions options, uint32 spellId)
Definition SpellEffects.cpp:1054

DelayedSpellTeleportEvent::Execute
bool Execute(uint64, uint32) override
Definition SpellEffects.cpp:1057

DelayedSpellTeleportEvent::_targetDest
TeleportLocation _targetDest
Definition SpellEffects.cpp:1071

DispelableAura
Definition Unit.h:128

DynamicObject
Definition DynamicObject.h:37

DynamicObject::SetCasterViewpoint
void SetCasterViewpoint()
Definition DynamicObject.cpp:207

DynamicObject::SetDuration
void SetDuration(int32 newDuration)
Definition DynamicObject.cpp:179

DynamicObject::CreateDynamicObject
bool CreateDynamicObject(ObjectGuid::LowType guidlow, Unit *caster, SpellInfo const *spell, Position const &pos, float radius, DynamicObjectType type, SpellCastVisual spellVisual)
Definition DynamicObject.cpp:86

EventProcessor::AddEventAtOffset
void AddEventAtOffset(BasicEvent *event, Milliseconds offset)
Definition EventProcessor.h:106

GameObject
Definition GameObject.h:172

GameObject::GetGOInfo
GameObjectTemplate const * GetGOInfo() const
Definition GameObject.h:209

GameObject::GetFaction
uint32 GetFaction() const override
Definition GameObject.h:403

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:1264

GameObject::SetOwnerGUID
void SetOwnerGUID(ObjectGuid owner)
Definition GameObject.h:241

GameObject::SetDestructibleState
void SetDestructibleState(GameObjectDestructibleState state, WorldObject *attackerOrHealer=nullptr, bool setHealth=false)
Definition GameObject.cpp:3809

GameObject::AddToSkillupList
void AddToSkillupList(ObjectGuid const &PlayerGuidLow)
Definition GameObject.h:322

GameObject::SetLootState
void SetLootState(LootState s, Unit *unit=nullptr)
Definition GameObject.cpp:3896

GameObject::GetLinkedTrap
GameObject * GetLinkedTrap()
Definition GameObject.cpp:4158

GameObject::SetRespawnTime
void SetRespawnTime(int32 respawn)
Definition GameObject.cpp:2290

GameObject::IsInSkillupList
bool IsInSkillupList(ObjectGuid const &playerGuid) const
Definition GameObject.h:323

GameObject::Use
void Use(Unit *user, bool ignoreCastInProgress=false)
Definition GameObject.cpp:2626

GameObject::SetLevel
void SetLevel(uint32 level)
Definition GameObject.h:287

GameObject::ModifyHealth
void ModifyHealth(int32 change, WorldObject *attackerOrHealer=nullptr, uint32 spellId=0)
Definition GameObject.cpp:3760

GameObject::ActivateObject
void ActivateObject(GameObjectActions action, int32 param, WorldObject *spellCaster=nullptr, uint32 spellId=0, int32 effectIndex=-1)
Definition GameObject.cpp:2447

GameObject::AddUniqueUse
void AddUniqueUse(Player *player)
Definition GameObject.cpp:1791

GameObject::SetSpellId
void SetSpellId(uint32 id)
Definition GameObject.h:253

GameObject::SetFaction
void SetFaction(uint32 faction) override
Definition GameObject.h:404

Garrison
Definition Garrison.h:185

Group
Definition Group.h:209

Group::IsAssistant
bool IsAssistant(ObjectGuid guid) const
Definition Group.h:323

Group::AddRaidMarker
void AddRaidMarker(uint8 markerId, uint32 mapId, float positionX, float positionY, float positionZ, ObjectGuid transportGuid=ObjectGuid::Empty)
Definition Group.cpp:1546

Group::IsLeader
bool IsLeader(ObjectGuid guid) const
Definition Group.cpp:1660

Group::GetGUID
ObjectGuid GetGUID() const
Definition Group.cpp:1623

Group::isRaidGroup
bool isRaidGroup() const
Definition Group.cpp:1598

Guardian
Definition TemporarySummon.h:130

Guild
Definition Guild.h:329

HealInfo
Definition Unit.h:476

Item
Definition Item.h:185

Item::SetState
void SetState(ItemUpdateState state, Player *forplayer=nullptr)
Definition Item.cpp:1258

Item::GetSlot
uint8 GetSlot() const
Definition Item.h:296

Item::SetItemFlag
void SetItemFlag(ItemFieldFlags flags)
Definition Item.h:224

Item::GetEffects
std::span< ItemEffectEntry const *const > GetEffects() const
Definition Item.h:370

Item::GetEnchantmentId
uint32 GetEnchantmentId(EnchantmentSlot slot) const
Definition Item.h:314

Item::IsVellum
bool IsVellum() const
Definition Item.h:350

Item::IsAzeriteEmpoweredItem
bool IsAzeriteEmpoweredItem() const
Definition Item.h:270

Item::ToAzeriteItem
AzeriteItem * ToAzeriteItem()
Definition Item.h:259

Item::GetEnchantmentDuration
uint32 GetEnchantmentDuration(EnchantmentSlot slot) const
Definition Item.h:315

Item::SetCount
void SetCount(uint32 value)
Definition Item.cpp:1367

Item::SetModifier
void SetModifier(ItemModifier modifier, uint32 value)
Definition Item.cpp:2515

Item::GetTemplate
ItemTemplate const * GetTemplate() const
Definition Item.cpp:1233

Item::m_itemData
UF::UpdateField< UF::ItemData, uint32(WowCS::EntityFragment::CGObject), TYPEID_ITEM > m_itemData
Definition Item.h:464

Item::GetContext
ItemContext GetContext() const
Definition Item.h:456

Item::IsEquipped
bool IsEquipped() const
Definition Item.cpp:1336

Item::GetOwner
Player * GetOwner() const
Definition Item.cpp:1238

Item::GetOwnerGUID
ObjectGuid GetOwnerGUID() const
Definition Item.h:203

Item::GetPos
uint16 GetPos() const
Definition Item.h:300

Item::GetDisenchantLootId
Optional< uint32 > GetDisenchantLootId() const
Definition Item.cpp:2410

Item::m_loot
std::unique_ptr< Loot > m_loot
Definition Item.h:334

Item::GetEnchantmentCharges
uint32 GetEnchantmentCharges(EnchantmentSlot slot) const
Definition Item.h:316

Item::ClearSoulboundTradeable
void ClearSoulboundTradeable(Player *currentOwner)
Definition Item.cpp:1969

Item::GetCount
uint32 GetCount() const
Definition Item.h:289

Item::ToAzeriteEmpoweredItem
AzeriteEmpoweredItem * ToAzeriteEmpoweredItem()
Definition Item.h:261

Item::GetBagSlot
uint8 GetBagSlot() const
Definition Item.cpp:1331

Item::GetModifier
uint32 GetModifier(ItemModifier modifier) const
Definition Item.cpp:2502

Item::SetEnchantment
void SetEnchantment(EnchantmentSlot slot, uint32 id, uint32 duration, uint32 charges, ObjectGuid caster=ObjectGuid::Empty)
Definition Item.cpp:1511

Item::CreateItem
static Item * CreateItem(uint32 itemEntry, uint32 count, ItemContext context, Player const *player=nullptr, bool addDefaultBonuses=true)
Definition Item.cpp:1721

Map
Definition Map.h:227

Map::IsDungeon
bool IsDungeon() const
Definition Map.cpp:3303

Map::AddToMap
bool AddToMap(T *)
Definition Map.cpp:527

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:1191

Map::GenerateLowGuid
ObjectGuid::LowType GenerateLowGuid()
Definition Map.h:564

Map::GetGameObject
GameObject * GetGameObject(ObjectGuid const &guid)
Definition Map.cpp:3588

Map::GetCreature
Creature * GetCreature(ObjectGuid const &guid)
Definition Map.cpp:3578

Minion
Definition TemporarySummon.h:96

Minion::GetOwner
Unit * GetOwner() const
Definition TemporarySummon.h:102

Minion::GetFollowAngle
float GetFollowAngle() const override
Definition TemporarySummon.h:103

MotionMaster::MoveJump
void MoveJump(uint32 id, Position const &pos, std::variant< std::monostate, float, Milliseconds > speedOrTime={}, Optional< float > minHeight={}, Optional< float > maxHeight={}, MovementFacingTarget const &facing={}, bool orientationFixed=false, bool unlimitedSpeed=false, Optional< float > speedMultiplier={}, JumpArrivalCastArgs const *arrivalCast=nullptr, Movement::SpellEffectExtraData const *spellEffectExtraData=nullptr, Scripting::v2::ActionResultSetter< MovementStopReason > &&scriptResult={})
Definition MotionMaster.cpp:837

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:750

MotionMaster::MoveDistract
void MoveDistract(uint32 time, float orientation)
Definition MotionMaster.cpp:1097

ObjectGuid
Definition ObjectGuid.h:308

ObjectGuid::Empty
static ObjectGuid const Empty
Definition ObjectGuid.h:314

ObjectGuid::IsEmpty
bool IsEmpty() const
Definition ObjectGuid.h:362

ObjectGuid::ToString
std::string ToString() const
Definition ObjectGuid.cpp:866

ObjectGuid::Clear
void Clear()
Definition ObjectGuid.h:329

Object
Definition Object.h:82

Object::SetDynamicFlag
void SetDynamicFlag(uint32 flag)
Definition Object.h:97

Object::ToPlayer
Player * ToPlayer()
Definition Object.h:126

Object::ToGameObject
GameObject * ToGameObject()
Definition Object.h:131

Object::ReplaceAllDynamicFlags
void ReplaceAllDynamicFlags(uint32 flag)
Definition Object.h:99

Object::GetEntry
uint32 GetEntry() const
Definition Object.h:89

Object::ToCreature
Creature * ToCreature()
Definition Object.h:121

Object::ToUnit
Unit * ToUnit()
Definition Object.h:116

PathGenerator
Definition PathGenerator.h:56

PathGenerator::GetPathLength
float GetPathLength() const
Definition PathGenerator.cpp:973

PathGenerator::CalculatePath
bool CalculatePath(float srcX, float srcY, float srcZ, float destX, float destY, float destZ, bool forceDest=false)
Definition PathGenerator.cpp:57

PetAura
Definition SpellMgr.h:435

PetStable
Definition PetDefines.h:145

PetStable::ActivePets
std::array< Optional< PetInfo >, MAX_ACTIVE_PETS > ActivePets
Definition PetDefines.h:169

Pet
Definition Pet.h:40

Pet::SetSpecialization
void SetSpecialization(uint16 spec)
Definition Pet.cpp:1913

Pet::GetOwner
Player * GetOwner() const
Definition Pet.cpp:1809

Pet::SavePetToDB
void SavePetToDB(PetSaveMode mode)
Definition Pet.cpp:451

Pet::isControlled
bool isControlled() const
Definition Pet.h:53

Pet::setDeathState
void setDeathState(DeathState s) override
Definition Pet.cpp:598

Pet::Remove
void Remove(PetSaveMode mode, bool returnreagent=false)
Definition Pet.cpp:711

Pet::SendNewlyTamed
void SendNewlyTamed(bool playPingFx=true) const
Definition Pet.cpp:838

Pet::learnSpell
bool learnSpell(uint32 spell_id)
Definition Pet.cpp:1462

PhasingHandler::InheritPhaseShift
static void InheritPhaseShift(WorldObject *target, WorldObject const *source)
Definition PhasingHandler.cpp:264

PhasingHandler::OnConditionChange
static bool OnConditionChange(WorldObject *object, bool updateVisibility=true)
Definition PhasingHandler.cpp:374

PlayerSocial::HasIgnore
bool HasIgnore(ObjectGuid const &ignoreGuid, ObjectGuid const &ignoreAccountGuid)
Definition SocialMgr.cpp:206

Player
Definition Player.h:1217

Player::SendMovieStart
void SendMovieStart(uint32 movieId)
Definition Player.cpp:6207

Player::SendLootError
void SendLootError(ObjectGuid const &lootObj, ObjectGuid const &owner, LootError error) const
Definition Player.cpp:9104

Player::GetPrimarySpecialization
ChrSpecialization GetPrimarySpecialization() const
Definition Player.h:1993

Player::SendEquipError
void SendEquipError(InventoryResult msg, Item const *item1=nullptr, Item const *item2=nullptr, uint32 itemId=0) const
Definition Player.cpp:13048

Player::m_playerData
UF::UpdateField< UF::PlayerData, int32(WowCS::EntityFragment::CGObject), TYPEID_PLAYER > m_playerData
Definition Player.h:3047

Player::KilledMonsterCredit
void KilledMonsterCredit(uint32 entry, ObjectGuid guid=ObjectGuid::Empty)
Definition Player.cpp:16646

Player::SetDataFlagCharacter
void SetDataFlagCharacter(uint32 dataFlagId, bool on)
Definition Player.cpp:30385

Player::SendPlayerBound
void SendPlayerBound(ObjectGuid const &binderGuid, uint32 areaId) const
Definition Player.cpp:17919

Player::GetArmorProficiency
uint32 GetArmorProficiency() const
Definition Player.h:1625

Player::IsEquipmentPos
static bool IsEquipmentPos(uint16 pos)
Definition Player.h:1472

Player::ApplyAzeriteEssence
void ApplyAzeriteEssence(AzeriteItem *item, uint32 azeriteEssenceId, uint32 rank, bool major, bool apply)
Definition Player.cpp:8526

Player::GetNumRespecs
uint8 GetNumRespecs() const
Definition Player.h:2996

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:11288

Player::HasPvPForcingQuest
bool HasPvPForcingQuest() const
Definition Player.cpp:17487

Player::GetNextResetTalentsCost
uint32 GetNextResetTalentsCost() const
Definition Player.cpp:3380

Player::ModifyMoney
bool ModifyMoney(int64 amount, bool sendError=true)
Definition Player.cpp:24800

Player::CanEquipItem
InventoryResult CanEquipItem(uint8 slot, uint16 &dest, Item *pItem, bool swap, bool not_loading=true) const
Definition Player.cpp:10709

Player::SetPlayerFlag
void SetPlayerFlag(PlayerFlags flags)
Definition Player.h:2896

Player::SetCanTitanGrip
void SetCanTitanGrip(bool value, uint32 penaltySpellId=0, int32 allowedItemClass=0, int32 allowedItemSubClassMask=0)
Definition Player.cpp:13144

Player::GetSocial
PlayerSocial * GetSocial() const
Definition Player.h:1274

Player::SetVisibleItemSlot
void SetVisibleItemSlot(uint8 slot, Item const *item)
Definition Player.cpp:11748

Player::SendBindPointUpdate
void SendBindPointUpdate() const
Definition Player.cpp:17910

Player::EnvironmentalDamage
uint32 EnvironmentalDamage(EnviromentalDamage type, uint32 damage)
Definition Player.cpp:618

Player::GetDrunkValue
uint8 GetDrunkValue() const
Definition Player.h:2462

Player::SendDirectMessage
void SendDirectMessage(WorldPacket const *data) const
Definition Player.cpp:6193

Player::GetSkillValue
uint16 GetSkillValue(uint32 skill) const
Definition Player.cpp:5920

Player::BankItem
Item * BankItem(ItemPosCountVec const &dest, Item *pItem, bool update)
Definition Player.cpp:11902

Player::RemoveTalent
void RemoveTalent(TalentEntry const *talent)
Definition Player.cpp:2624

Player::DespawnPersonalSummonsForQuest
void DespawnPersonalSummonsForQuest(uint32 questId)
Definition Player.cpp:16281

Player::m_activePlayerData
UF::UpdateField< UF::ActivePlayerData, int32(WowCS::EntityFragment::CGObject), TYPEID_ACTIVE_PLAYER > m_activePlayerData
Definition Player.h:3048

Player::SetCanParry
void SetCanParry(bool value)
Definition Player.cpp:26841

Player::UpdateQuestObjectiveProgress
void UpdateQuestObjectiveProgress(QuestObjectiveType objectiveType, int32 objectId, int64 addCount, ObjectGuid victimGuid=ObjectGuid::Empty, std::vector< QuestObjective const * > *updatedObjectives=nullptr, std::function< bool(QuestObjective const *)> const *objectiveFilter=nullptr)
Definition Player.cpp:16704

Player::CanStoreItem
InventoryResult CanStoreItem(uint8 bag, uint8 slot, ItemPosCountVec &dest, Item *pItem, bool swap=false) const
Definition Player.cpp:9975

Player::CreateGarrison
void CreateGarrison(uint32 garrSiteId)
Definition Player.cpp:30062

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:30440

Player::SendProficiency
void SendProficiency(ItemClass itemClass, uint32 itemSubclassMask) const
Definition Player.cpp:23044

Player::SendTalentsInfoData
void SendTalentsInfoData()
Definition Player.cpp:28051

Player::UpdatePvPState
void UpdatePvPState(bool onlyFFA=false)
Definition Player.cpp:24013

Player::DurabilityLossAll
void DurabilityLossAll(double percent, bool inventory)
Definition Player.cpp:4466

Player::AddHonorXP
void AddHonorXP(uint32 xp)
Definition Player.cpp:6849

Player::GetDeathTimer
uint32 GetDeathTimer() const
Definition Player.h:2468

Player::AutoStoreLoot
void AutoStoreLoot(uint8 bag, uint8 slot, uint32 loot_id, LootStore const &store, ItemContext context=ItemContext::NONE, bool broadcast=false, bool pushed=false, bool createdByPlayer=false)
Definition Player.cpp:27123

Player::SendPlayerChoice
void SendPlayerChoice(ObjectGuid sender, int32 choiceId)
Definition Player.cpp:30097

Player::_ApplyItemMods
void _ApplyItemMods(Item *item, uint8 slot, bool apply, bool updateItemAuras=true)
Definition Player.cpp:7807

Player::GiveXP
void GiveXP(uint32 xp, Unit *victim, float group_rate=1.0f)
Definition Player.cpp:2110

Player::SetResurrectRequestData
void SetResurrectRequestData(WorldObject const *caster, uint32 health, uint32 mana, uint32 appliedAura)
Definition Player.cpp:24070

Player::GetItemByEntry
Item * GetItemByEntry(uint32 entry, ItemSearchLocation where=ItemSearchLocation::Default) const
Definition Player.cpp:12393

Player::SpawnCorpseBones
void SpawnCorpseBones(bool triggerSave=true)
Definition Player.cpp:4453

Player::SetDrunkValue
void SetDrunkValue(uint8 newDrunkValue, uint32 itemId=0)
Definition Player.cpp:842

Player::GetGlyphs
std::vector< uint32 > const & GetGlyphs(uint8 spec) const
Definition Player.h:2030

Player::GetPetStable
PetStable * GetPetStable()
Definition Player.h:1339

Player::PetSpellInitialize
void PetSpellInitialize()
Definition Player.cpp:22418

Player::GetSceneMgr
SceneMgr & GetSceneMgr()
Definition Player.h:2873

Player::SetFallInformation
void SetFallInformation(uint32 time, float z)
Definition Player.cpp:27437

Player::ApplyEnchantment
void ApplyEnchantment(Item *item, EnchantmentSlot slot, bool apply, bool apply_dur=true, bool ignore_condition=false)
Definition Player.cpp:13412

Player::IsLoading
bool IsLoading() const override
Definition Player.cpp:17925

Player::ActivateTalentGroup
void ActivateTalentGroup(ChrSpecializationEntry const *spec)
Definition Player.cpp:28786

Player::UpdateCraftSkill
bool UpdateCraftSkill(SpellInfo const *spellInfo)
Definition Player.cpp:5409

Player::CanAddQuest
bool CanAddQuest(Quest const *quest, bool msg) const
Definition Player.cpp:14491

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:10975

Player::SetSkill
void SetSkill(uint32 id, uint16 step, uint16 newVal, uint16 maxVal)
Definition Player.cpp:5654

Player::UpdateVisibleObjectInteractions
void UpdateVisibleObjectInteractions(bool allUnits, bool onlySpellClicks, bool gameObjectQuestGiverStatus, bool questObjectiveGameObjects)
Definition Player.cpp:25880

Player::GetPet
Pet * GetPet() const
Definition Player.cpp:22007

Player::m_homebind
WorldLocation m_homebind
Definition Player.h:2679

Player::GetGuild
Guild * GetGuild()
Definition Player.cpp:30428

Player::SetNumRespecs
void SetNumRespecs(uint8 numRespecs)
Definition Player.h:2997

Player::GetPureSkillValue
uint16 GetPureSkillValue(uint32 skill) const
Definition Player.cpp:5976

Player::RemoveTradeableItem
void RemoveTradeableItem(Item *item)
Definition Player.cpp:13249

Player::CompleteQuest
void CompleteQuest(uint32 quest_id)
Definition Player.cpp:14893

Player::SetCanBlock
void SetCanBlock(bool value)
Definition Player.cpp:26850

Player::GetCommandStatus
bool GetCommandStatus(uint32 command) const
Definition Player.h:1323

Player::StoreItem
Item * StoreItem(ItemPosCountVec const &pos, Item *pItem, bool update)
Definition Player.cpp:11365

Player::GetSession
WorldSession * GetSession() const
Definition Player.h:2256

Player::LearnSpell
void LearnSpell(uint32 spell_id, bool dependent, int32 fromSkill=0, bool suppressMessaging=false, Optional< PlayerSpellTrait > trait={})
Definition Player.cpp:3083

Player::UpdateAreaDependentAuras
void UpdateAreaDependentAuras(uint32 area_id)
Definition Player.cpp:26487

Player::GetItemByPos
Item * GetItemByPos(uint16 pos) const
Definition Player.cpp:9538

Player::EquipTransmogOutfit
void EquipTransmogOutfit(uint32 id, TransmogSituationTrigger trigger, Optional< bool > locked)
Definition Player.cpp:31176

Player::GetRestMgr
RestMgr & GetRestMgr() const
Definition Player.h:2875

Player::RepopAtGraveyard
void RepopAtGraveyard()
Definition Player.cpp:4687

Player::SendNewItem
void SendNewItem(Item *item, uint32 quantity, bool pushed, bool created, bool broadcast=false, uint32 dungeonEncounterId=0)
Definition Player.cpp:13835

Player::SetDataElementCharacter
void SetDataElementCharacter(uint32 dataElementId, std::variant< int64, float > value)
Definition Player.cpp:30308

Player::DestroyItem
void DestroyItem(uint8 bag, uint8 slot, bool update)
Definition Player.cpp:12039

Player::IsResurrectRequested
bool IsResurrectRequested() const
Definition Player.h:2087

Player::IsInventoryPos
static bool IsInventoryPos(uint16 pos)
Definition Player.h:1470

Player::SendLoot
void SendLoot(Loot &loot, bool aeLooting=false)
Definition Player.cpp:9075

Player::UpdateTraitConfig
void UpdateTraitConfig(WorldPackets::Traits::TraitConfig &&newConfig, int32 savedConfigId, bool withCastTime)
Definition Player.cpp:29141

Player::DestroyItemCount
uint32 DestroyItemCount(uint32 item, uint32 count, bool update, bool unequip_check=false)
Definition Player.cpp:12140

Player::RemovePet
void RemovePet(Pet *pet, PetSaveMode mode, bool returnreagent=false)
Definition Player.cpp:22031

Player::CalculateReputationGain
int32 CalculateReputationGain(ReputationSource source, uint32 creatureOrQuestLevel, int32 rep, int32 faction, bool noQuestBonus=false)
Definition Player.cpp:6422

Player::TeleportTo
bool TeleportTo(uint32 mapid, float x, float y, float z, float orientation, TeleportToOptions options=TELE_TO_NONE, Optional< uint32 > instanceId={}, uint32 teleportSpellId=0)
Definition Player.cpp:1181

Player::GetActionButton
ActionButton const * GetActionButton(uint8 button)
Definition Player.cpp:6133

Player::DurabilityLoss
void DurabilityLoss(Item *item, double percent)
Definition Player.cpp:4490

Player::GetWeaponProficiency
uint32 GetWeaponProficiency() const
Definition Player.h:1624

Player::SendRespecWipeConfirm
void SendRespecWipeConfirm(ObjectGuid const &guid, uint32 cost, SpecResetType respecType) const
Definition Player.cpp:9164

Player::GetSkillStep
uint16 GetSkillStep(uint32 skill) const
Definition Player.cpp:5908

Player::SetDataElementAccount
void SetDataElementAccount(uint32 dataElementId, std::variant< int64, float > value)
Definition Player.cpp:30254

Player::AutoUnequipOffhandIfNeed
void AutoUnequipOffhandIfNeed(bool force=false)
Definition Player.cpp:26101

Player::ItemAddedQuestCheck
void ItemAddedQuestCheck(uint32 entry, uint32 count, Optional< bool > boundItemFlagRequirement={}, bool *hadBoundItemObjective=nullptr)
Definition Player.cpp:16566

Player::EquipItem
Item * EquipItem(uint16 pos, Item *pItem, bool update)
Definition Player.cpp:11507

Player::SetDuelArbiter
void SetDuelArbiter(ObjectGuid guid)
Definition Player.h:2130

Player::pvpInfo
PvPInfo pvpInfo
Definition Player.h:2107

Player::AddQuestAndCheckCompletion
void AddQuestAndCheckCompletion(Quest const *quest, Object *questGiver)
Definition Player.cpp:14633

Player::DurabilityPointsLossAll
void DurabilityPointsLossAll(int32 points, bool inventory)
Definition Player.cpp:4510

Player::CanTakeQuest
bool CanTakeQuest(Quest const *quest, bool msg) const
Definition Player.cpp:14479

Player::GetProfessionSkillForExp
uint32 GetProfessionSkillForExp(uint32 skill, int32 expansion) const
Definition Player.cpp:5873

Player::GetActiveTalentGroup
uint8 GetActiveTalentGroup() const
Definition Player.h:1995

Player::RemoveSpell
void RemoveSpell(uint32 spell_id, bool disabled=false, bool learn_low_rank=true, bool suppressMessaging=false)
Definition Player.cpp:3128

Player::SendSummonRequestFrom
void SendSummonRequestFrom(Unit *summoner)
Definition Player.cpp:26005

Player::AreaExploredOrEventHappens
void AreaExploredOrEventHappens(uint32 questId)
Definition Player.cpp:16519

Player::TakeQuestSourceItem
bool TakeQuestSourceItem(uint32 questId, bool msg)
Definition Player.cpp:15878

Player::RemoveActiveQuest
void RemoveActiveQuest(uint32 questId, bool update=true)
Definition Player.cpp:15972

Player::GetQuestStatus
QuestStatus GetQuestStatus(uint32 quest_id) const
Definition Player.cpp:15929

Player::GetGarrison
Garrison * GetGarrison() const
Definition Player.h:2868

Player::CreateTraitConfig
void CreateTraitConfig(WorldPackets::Traits::TraitConfig &traitConfig)
Definition Player.cpp:29068

Player::AddArmorProficiency
void AddArmorProficiency(uint32 newflag)
Definition Player.h:1623

Player::SetHomebind
void SetHomebind(WorldLocation const &loc, uint32 areaId)
Definition Player.cpp:17893

Player::FailQuest
void FailQuest(uint32 quest_id)
Definition Player.cpp:15314

Player::ActivateTaxiPathTo
bool ActivateTaxiPathTo(std::vector< uint32 > const &nodes, Creature *npc=nullptr, uint32 spellid=0, uint32 preferredMountDisplay=0, Optional< float > speed={}, Scripting::v2::ActionResultSetter< MovementStopReason > const &scriptResult={})
Definition Player.cpp:23106

Player::IsBankPos
static bool IsBankPos(uint16 pos)
Definition Player.h:1475

Player::RemoveItem
void RemoveItem(uint8 bag, uint8 slot, bool update)
Definition Player.cpp:11907

Player::HasSpell
bool HasSpell(uint32 spell) const override
Definition Player.cpp:3626

Player::GetGroup
Group * GetGroup(Optional< uint8 > partyIndex)
Definition Player.h:2781

Player::duel
std::unique_ptr< DuelInfo > duel
Definition Player.h:2126

Player::RemoveRewardedQuest
void RemoveRewardedQuest(uint32 questId, bool update=true)
Definition Player.cpp:16005

Player::DurabilityPointsLoss
void DurabilityPointsLoss(Item *item, int32 points)
Definition Player.cpp:4534

Player::GetItemByGuid
Item * GetItemByGuid(ObjectGuid guid) const
Definition Player.cpp:9522

Player::SetDataFlagAccount
void SetDataFlagAccount(uint32 dataFlagId, bool on)
Definition Player.cpp:30348

Player::RemovedInsignia
void RemovedInsignia(Player *looterPlr)
Definition Player.cpp:9018

Player::UpdateGatherSkill
bool UpdateGatherSkill(uint32 skillId, uint32 skillValue, uint32 redLevel, uint32 multiplicator=1, WorldObject const *object=nullptr)
Definition Player.cpp:5444

Player::AddWeaponProficiency
void AddWeaponProficiency(uint32 newflag)
Definition Player.h:1622

Player::ModifyCurrency
void ModifyCurrency(uint32 id, int32 amount, CurrencyGainSource gainSource=CurrencyGainSource::Cheat, CurrencyDestroyReason destroyReason=CurrencyDestroyReason::Cheat)
Modify currency amount.
Definition Player.cpp:7036

Player::CanStoreNewItem
InventoryResult CanStoreNewItem(uint8 bag, uint8 slot, ItemPosCountVec &dest, uint32 item, uint32 count, uint32 *no_space_count=nullptr) const
Definition Player.cpp:9970

Player::PlayerTalkClass
std::unique_ptr< PlayerMenu > PlayerTalkClass
Definition Player.h:2556

Player::GetReputationMgr
ReputationMgr & GetReputationMgr()
Definition Player.h:2422

Player::AddPetAura
void AddPetAura(PetAura const *petSpell)
Definition Player.cpp:22175

Player::RewardPlayerAndGroupAtEvent
void RewardPlayerAndGroupAtEvent(uint32 creature_id, WorldObject *pRewardSource)
Definition Player.cpp:26350

Player::ResurrectPlayer
void ResurrectPlayer(float restore_percent, bool applySickness=false)
Definition Player.cpp:4269

Quest
Definition QuestDef.h:575

Quest::XPValue
uint32 XPValue(Player const *player) const
Definition QuestDef.cpp:428

Quest::HasFlag
bool HasFlag(QuestFlags flag) const
Definition QuestDef.h:615

ReputationMgr::ModifyReputation
bool ModifyReputation(FactionEntry const *factionEntry, int32 standing, bool spillOverOnly=false, bool noSpillover=false)
Definition ReputationMgr.h:131

RestMgr::AddRestBonus
void AddRestBonus(RestTypes restType, float restBonus)
Definition RestMgr.cpp:85

RestMgr::CalcExtraPerSec
float CalcExtraPerSec(RestTypes restType, float bubble) const
Definition RestMgr.cpp:158

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:94

SpellCastTargets
Definition SpellDefines.h:372

SpellCastTargets::SetItemTarget
void SetItemTarget(Item *item)
Definition Spell.cpp:263

SpellCastTargets::SetDst
void SetDst(float x, float y, float z, float orientation, uint32 mapId=MAPID_INVALID)
Definition Spell.cpp:341

SpellCastTargets::SetGOTarget
void SetGOTarget(GameObject *target)
Definition Spell.cpp:220

SpellCastTargets::SetUnitTarget
void SetUnitTarget(Unit *target)
Definition Spell.cpp:194

SpellCastTargets::HasDst
bool HasDst() const
Definition Spell.cpp:393

SpellCastTargets::GetItemTarget
Item * GetItemTarget() const
Definition SpellDefines.h:401

SpellCastTargets::GetUnitTarget
Unit * GetUnitTarget() const
Definition Spell.cpp:186

SpellCastTargets::Update
void Update(WorldObject *caster)
Definition Spell.cpp:398

SpellCastTargets::GetDstPos
WorldLocation const * GetDstPos() const
Definition Spell.cpp:336

SpellEffectInfo
Definition SpellInfo.h:210

SpellEffectInfo::PositionFacing
float PositionFacing
Definition SpellInfo.h:227

SpellEffectInfo::HasRadius
bool HasRadius(SpellTargetIndex targetIndex) const
Definition SpellInfo.cpp:770

SpellEffectInfo::CalcValue
SpellEffectValue CalcValue(WorldObject const *caster=nullptr, SpellEffectValue const *basePoints=nullptr, Unit const *target=nullptr, float *variance=nullptr, uint32 castItemId=0, int32 itemLevel=-1) const
Definition SpellInfo.cpp:521

SpellEffectInfo::MiscValueB
int32 MiscValueB
Definition SpellInfo.h:225

SpellEffectInfo::CalcValueMultiplier
float CalcValueMultiplier(WorldObject *caster, Spell *spell=nullptr) const
Definition SpellInfo.cpp:754

SpellEffectInfo::TriggerSpell
uint32 TriggerSpell
Definition SpellInfo.h:234

SpellEffectInfo::Effect
SpellEffects Effect
Definition SpellInfo.h:215

SpellEffectInfo::MiscValue
int32 MiscValue
Definition SpellInfo.h:224

SpellEffectInfo::IsEffect
bool IsEffect() const
Definition SpellInfo.cpp:455

SpellEffectInfo::Amplitude
float Amplitude
Definition SpellInfo.h:221

SpellEffectInfo::CalcRadius
SpellRange CalcRadius(WorldObject const *caster=nullptr, SpellTargetIndex targetIndex=SpellTargetIndex::TargetA, Spell *spell=nullptr) const
Definition SpellInfo.cpp:783

SpellEffectInfo::ItemType
uint32 ItemType
Definition SpellInfo.h:233

SpellEffectInfo::EffectIndex
SpellEffIndex EffectIndex
Definition SpellInfo.h:214

SpellEffectInfo::GetProvidedTargetMask
uint32 GetProvidedTargetMask() const
Definition SpellInfo.cpp:830

SpellHistory::RestoreCharge
void RestoreCharge(uint32 chargeCategoryId)
Definition SpellHistory.cpp:917

SpellHistory::LockSpellSchool
void LockSpellSchool(SpellSchoolMask schoolMask, Duration lockoutTime)
Definition SpellHistory.cpp:764

SpellHistory::ModifyCoooldowns
void ModifyCoooldowns(Predicate &&predicate, Duration cooldownMod, bool withoutCategoryCooldown=false)
Definition SpellHistory.h:128

SpellHistory::ModifyCooldown
void ModifyCooldown(uint32 spellId, Duration cooldownMod, bool withoutCategoryCooldown=false)
Definition SpellHistory.cpp:632

SpellHistory::HasCooldown
bool HasCooldown(SpellInfo const *spellInfo, uint32 itemId=0) const
Definition SpellHistory.cpp:678

SpellInfo
Definition SpellInfo.h:324

SpellInfo::GetMinMaxRange
SpellRange GetMinMaxRange(bool positive=false, WorldObject const *caster=nullptr, Spell *spell=nullptr) const
Definition SpellInfo.cpp:3969

SpellInfo::CalcPowerCost
Optional< SpellPowerCost > CalcPowerCost(Powers powerType, bool optionalCost, WorldObject const *caster, SpellSchoolMask schoolMask, Spell *spell=nullptr) const
Definition SpellInfo.cpp:4028

SpellInfo::GetAllEffectsMechanicMask
uint64 GetAllEffectsMechanicMask() const
Definition SpellInfo.cpp:2649

SpellInfo::Id
uint32 const Id
Definition SpellInfo.h:328

SpellInfo::StackAmount
uint32 StackAmount
Definition SpellInfo.h:396

SpellInfo::IsLootCrafting
bool IsLootCrafting() const
Definition SpellInfo.cpp:1646

SpellInfo::GetDispelMask
uint32 GetDispelMask() const
Definition SpellInfo.cpp:2698

SpellInfo::NeedsToBeTriggeredByCaster
bool NeedsToBeTriggeredByCaster(SpellInfo const *triggeringSpell) const
Definition SpellInfo.cpp:1721

SpellInfo::Speed
float Speed
Definition SpellInfo.h:393

SpellInfo::EquippedItemClass
int32 EquippedItemClass
Definition SpellInfo.h:402

SpellInfo::SpellFamilyFlags
flag128 SpellFamilyFlags
Definition SpellInfo.h:415

SpellInfo::GetSchoolMask
SpellSchoolMask GetSchoolMask() const
Definition SpellInfo.cpp:2644

SpellInfo::IsChanneled
bool IsChanneled() const
Definition SpellInfo.cpp:1893

SpellInfo::HasAttribute
bool HasAttribute(SpellAttr0 attribute) const
Definition SpellInfo.h:456

SpellInfo::GetDuration
int32 GetDuration() const
Definition SpellInfo.cpp:3994

SpellInfo::GetEffect
SpellEffectInfo const & GetEffect(SpellEffIndex index) const
Definition SpellInfo.h:590

SpellInfo::GetEffects
std::vector< SpellEffectInfo > const & GetEffects() const
Definition SpellInfo.h:589

SpellInfo::EquippedItemSubClassMask
int32 EquippedItemSubClassMask
Definition SpellInfo.h:403

SpellInfo::GetExplicitTargetMask
uint32 GetExplicitTargetMask() const
Definition SpellInfo.cpp:2712

SpellInfo::CalcDuration
int32 CalcDuration(WorldObject const *caster=nullptr) const
Definition SpellInfo.cpp:3983

SpellInfo::HasAura
bool HasAura(AuraType aura) const
Definition SpellInfo.cpp:1565

SpellInfo::SpellFamilyName
uint32 SpellFamilyName
Definition SpellInfo.h:414

SpellInfo::CanBeInterrupted
bool CanBeInterrupted(WorldObject const *interruptCaster, Unit const *interruptTarget, bool ignoreImmunity=false) const
Definition SpellInfo.cpp:1618

Spell
Definition Spell.h:277

Spell::EffectSummonRaFFriend
void EffectSummonRaFFriend()
Definition SpellEffects.cpp:5306

Spell::GetSpellInfo
SpellInfo const * GetSpellInfo() const
Definition Spell.h:702

Spell::EffectSendEvent
void EffectSendEvent()
Definition SpellEffects.cpp:1182

Spell::EffectTransmitted
void EffectTransmitted()
Definition SpellEffects.cpp:4454

Spell::EffectUpgradeHeirloom
void EffectUpgradeHeirloom()
Definition SpellEffects.cpp:5710

Spell::EffectSpiritHeal
void EffectSpiritHeal()
Definition SpellEffects.cpp:4675

Spell::EffectRemoveAuraBySpellLabel
void EffectRemoveAuraBySpellLabel()
Definition SpellEffects.cpp:5469

Spell::EffectBlock
void EffectBlock()
Definition SpellEffects.cpp:3712

Spell::EffectPlayMusic
void EffectPlayMusic()
Definition SpellEffects.cpp:5084

Spell::EffectChangeBattlePetQuality
void EffectChangeBattlePetQuality()
Definition SpellEffects.cpp:5633

Spell::gameObjTarget
GameObject * gameObjTarget
Definition Spell.h:799

Spell::EffectGrantBattlePetExperience
void EffectGrantBattlePetExperience()
Definition SpellEffects.cpp:6097

Spell::targetMissInfo
SpellMissInfo targetMissInfo
Definition Spell.h:804

Spell::ExecuteLogEffectTakeTargetPower
void ExecuteLogEffectTakeTargetPower(SpellEffects effect, Unit *target, Powers powerType, uint32 points, float amplitude)
Definition Spell.cpp:5087

Spell::UpdateDelayMomentForUnitTarget
void UpdateDelayMomentForUnitTarget(Unit *unit, uint64 hitDelay)
Definition Spell.cpp:918

Spell::EffectCreateItem2
void EffectCreateItem2()
Definition SpellEffects.cpp:1472

Spell::EffectEnchantHeldItem
void EffectEnchantHeldItem()
Definition SpellEffects.cpp:3445

Spell::m_originalCaster
Unit * m_originalCaster
Definition Spell.h:751

Spell::EffectHealMaxHealth
void EffectHealMaxHealth()
Definition SpellEffects.cpp:2966

Spell::EffectProspecting
void EffectProspecting()
Definition SpellEffects.cpp:4587

Spell::_dynObjAura
DynObjAura * _dynObjAura
Definition Spell.h:811

Spell::EffectSetPlayerDataFlagCharacter
void EffectSetPlayerDataFlagCharacter()
Definition SpellEffects.cpp:6342

Spell::EffectCharge
void EffectCharge()
Definition SpellEffects.cpp:3940

Spell::EffectSummonObject
void EffectSummonObject()
Definition SpellEffects.cpp:3600

Spell::EffectSendTaxi
void EffectSendTaxi()
Definition SpellEffects.cpp:4140

Spell::EffectCreateItem
void EffectCreateItem()
Definition SpellEffects.cpp:1463

Spell::EffectTameCreature
void EffectTameCreature()
Definition SpellEffects.cpp:2606

Spell::EffectGameObjectDamage
void EffectGameObjectDamage()
Definition SpellEffects.cpp:4978

Spell::m_targets
SpellCastTargets m_targets
Definition Spell.h:651

Spell::EffectSummonChangeItem
void EffectSummonChangeItem()
Definition SpellEffects.cpp:1735

Spell::EffectDummy
void EffectDummy()
Definition SpellEffects.cpp:575

Spell::m_preGeneratedPath
std::unique_ptr< PathGenerator > m_preGeneratedPath
Definition Spell.h:1001

Spell::GetCastDifficulty
Difficulty GetCastDifficulty() const
Definition Spell.cpp:8172

Spell::EffectLearnAzeriteEssencePower
void EffectLearnAzeriteEssencePower()
Definition SpellEffects.cpp:5984

Spell::ExecuteLogEffectExtraAttacks
void ExecuteLogEffectExtraAttacks(SpellEffects effect, Unit *victim, uint32 numAttacks)
Definition Spell.cpp:5099

Spell::EffectHealthLeech
void EffectHealthLeech()
Definition SpellEffects.cpp:1332

Spell::EffectActivateGarrisonBuilding
void EffectActivateGarrisonBuilding()
Definition SpellEffects.cpp:5555

Spell::EffectStealBeneficialBuff
void EffectStealBeneficialBuff()
Definition SpellEffects.cpp:4722

Spell::EffectCancelConversation
void EffectCancelConversation()
Definition SpellEffects.cpp:5506

Spell::EffectStuck
void EffectStuck()
Definition SpellEffects.cpp:3326

Spell::EffectInterruptCast
void EffectInterruptCast()
Definition SpellEffects.cpp:2989

Spell::EffectSummonPlayer
void EffectSummonPlayer()
Definition SpellEffects.cpp:3370

Spell::EffectWeaponDmg
void EffectWeaponDmg()
Definition SpellEffects.cpp:2812

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

Spell::EffectEnchantItemPrismatic
void EffectEnchantItemPrismatic()
Definition SpellEffects.cpp:2490

Spell::EffectSummonType
void EffectSummonType()
Definition SpellEffects.cpp:1871

Spell::EffectSkinPlayerCorpse
void EffectSkinPlayerCorpse()
Definition SpellEffects.cpp:4701

Spell::effectHandleMode
SpellEffectHandleMode effectHandleMode
Definition Spell.h:806

Spell::EffectEquipTransmogOutfit
void EffectEquipTransmogOutfit()
Definition SpellEffects.cpp:6354

Spell::SummonGuardian
void SummonGuardian(SpellEffectInfo const *effect, uint32 entry, SummonPropertiesEntry const *properties, uint32 numSummons, ObjectGuid privateObjectOwner)
Definition SpellEffects.cpp:5015

Spell::EffectHealMechanical
void EffectHealMechanical()
Definition SpellEffects.cpp:1312

Spell::EffectGameObjectRepair
void EffectGameObjectRepair()
Definition SpellEffects.cpp:4993

Spell::EffectCreateGarrison
void EffectCreateGarrison()
Definition SpellEffects.cpp:5483

Spell::EffectSummonObjectWild
void EffectSummonObjectWild()
Definition SpellEffects.cpp:3021

Spell::EffectSendChatMessage
void EffectSendChatMessage()
Definition SpellEffects.cpp:6080

Spell::ExecuteLogEffectDurabilityDamage
void ExecuteLogEffectDurabilityDamage(SpellEffects effect, Unit *victim, int32 itemId, int32 amount)
Definition Spell.cpp:5119

Spell::Id
uint32 Id
Definition Spell.h:626

Spell::EffectActivateObject
void EffectActivateObject()
Definition SpellEffects.cpp:3386

Spell::m_UniqueTargetInfo
std::vector< TargetInfo > m_UniqueTargetInfo
Definition Spell.h:878

Spell::EffectSkill
void EffectSkill()
Definition SpellEffects.cpp:4641

Spell::m_destTargets
SpellDestination m_destTargets[MAX_SPELL_EFFECTS]
Definition Spell.h:910

Spell::EffectSetPlayerDataElementCharacter
void EffectSetPlayerDataElementCharacter()
Definition SpellEffects.cpp:6318

Spell::ExecuteLogEffectCreateItem
void ExecuteLogEffectCreateItem(SpellEffects effect, uint32 entry)
Definition Spell.cpp:5137

Spell::EffectLeap
void EffectLeap()
Definition SpellEffects.cpp:3721

Spell::UpdateDelayMomentForDst
void UpdateDelayMomentForDst(uint64 hitDelay)
Definition Spell.cpp:910

Spell::EffectTradeSkill
void EffectTradeSkill()
Definition SpellEffects.cpp:2413

Spell::EffectPersistentAA
void EffectPersistentAA()
Definition SpellEffects.cpp:1516

Spell::EffectQuestClear
void EffectQuestClear()
Definition SpellEffects.cpp:4096

Spell::EffectModifyThreatPercent
void EffectModifyThreatPercent()
Definition SpellEffects.cpp:4442

Spell::EffectForceDeselect
void EffectForceDeselect()
Definition SpellEffects.cpp:3795

Spell::GetEffectValueAsInt
int32 GetEffectValueAsInt() const
Definition Spell.h:803

Spell::EffectParry
void EffectParry()
Definition SpellEffects.cpp:3703

Spell::EffectRenamePet
void EffectRenamePet()
Definition SpellEffects.cpp:5072

Spell::EffectResurrect
void EffectResurrect()
Definition SpellEffects.cpp:3658

Spell::EffectDestroyAllTotems
void EffectDestroyAllTotems()
Definition SpellEffects.cpp:4341

Spell::m_attackType
WeaponAttackType m_attackType
Definition Spell.h:755

Spell::EffectCreateTraitTreeConfig
void EffectCreateTraitTreeConfig()
Definition SpellEffects.cpp:6197

Spell::EffectResurrectPet
void EffectResurrectPet()
Definition SpellEffects.cpp:4271

Spell::EffectApplyEnchantIllusion
void EffectApplyEnchantIllusion()
Definition SpellEffects.cpp:5720

Spell::EffectTriggerSpell
void EffectTriggerSpell()
Definition SpellEffects.cpp:594

Spell::CalculateDamage
SpellEffectValue CalculateDamage(SpellEffectInfo const &spellEffectInfo, Unit const *target, float *var=nullptr) const
Definition Spell.cpp:7199

Spell::EffectGiveHonor
void EffectGiveHonor()
Definition SpellEffects.cpp:5867

Spell::SendSpellInterruptLog
void SendSpellInterruptLog(Unit *victim, uint32 spellId)
Definition Spell.cpp:5108

Spell::m_customArg
std::any m_customArg
Definition Spell.h:649

Spell::EffectPullTowards
void EffectPullTowards()
Definition SpellEffects.cpp:4151

Spell::m_originalCasterGUID
ObjectGuid m_originalCasterGUID
Definition Spell.h:749

Spell::m_caster
WorldObject *const m_caster
Definition Spell.h:745

Spell::EffectCreatePrivateSceneObject
void EffectCreatePrivateSceneObject()
Definition SpellEffects.cpp:5835

Spell::EffectRechargeItem
void EffectRechargeItem()
Definition SpellEffects.cpp:5232

Spell::EffectLearnGarrisonBuilding
void EffectLearnGarrisonBuilding()
Definition SpellEffects.cpp:5457

Spell::EffectPowerBurn
void EffectPowerBurn()
Definition SpellEffects.cpp:1220

Spell::EffectUpdateInteractions
void EffectUpdateInteractions()
Definition SpellEffects.cpp:6270

Spell::GetDebugInfo
std::string GetDebugInfo() const
Definition Spell.cpp:9245

Spell::EffectDurabilityDamage
void EffectDurabilityDamage()
Definition SpellEffects.cpp:4384

Spell::EffectKillCreditLabel
void EffectKillCreditLabel()
Definition SpellEffects.cpp:4861

Spell::EffectSanctuary
void EffectSanctuary()
Definition SpellEffects.cpp:3215

Spell::ExecuteLogEffectOpenLock
void ExecuteLogEffectOpenLock(SpellEffects effect, Object *obj)
Definition Spell.cpp:5129

Spell::EffectHealBattlePetPct
void EffectHealBattlePetPct()
Definition SpellEffects.cpp:5608

Spell::EffectCastButtons
void EffectCastButtons()
Definition SpellEffects.cpp:5190

Spell::itemTarget
Item * itemTarget
Definition Spell.h:798

Spell::variance
float variance
Definition Spell.h:805

Spell::m_damage
int32 m_damage
Definition Spell.h:818

Spell::EffectGiveArtifactPower
void EffectGiveArtifactPower()
Definition SpellEffects.cpp:5763

Spell::EffectKnockBack
void EffectKnockBack()
Definition SpellEffects.cpp:4037

Spell::EffectReputation
void EffectReputation()
Definition SpellEffects.cpp:3742

Spell::EffectDistract
void EffectDistract()
Definition SpellEffects.cpp:2249

Spell::EffectKillCredit
void EffectKillCredit()
Definition SpellEffects.cpp:4849

Spell::DoCreateItem
void DoCreateItem(uint32 itemId, ItemContext context=ItemContext::NONE, std::vector< int32 > const *bonusListIDs=nullptr)
Definition SpellEffects.cpp:1373

Spell::EffectRespecAzeriteEmpoweredItem
void EffectRespecAzeriteEmpoweredItem()
Definition SpellEffects.cpp:5956

Spell::EffectSummonPet
void EffectSummonPet()
Definition SpellEffects.cpp:2656

Spell::EffectModifyCooldownsByCategory
void EffectModifyCooldownsByCategory()
Definition SpellEffects.cpp:6177

Spell::effectValue
SpellEffectValue effectValue
Definition Spell.h:802

Spell::EffectEnergizePct
void EffectEnergizePct()
Definition SpellEffects.cpp:1619

Spell::EffectDispelMechanic
void EffectDispelMechanic()
Definition SpellEffects.cpp:4236

Spell::EffectSelfResurrect
void EffectSelfResurrect()
Definition SpellEffects.cpp:3830

Spell::EffectGiveRestedExperience
void EffectGiveRestedExperience()
Definition SpellEffects.cpp:5595

Spell::EffectDispel
void EffectDispel()
Definition SpellEffects.cpp:2137

Spell::EffectBind
void EffectBind()
Definition SpellEffects.cpp:5253

Spell::SendSpellCooldown
void SendSpellCooldown()
Definition Spell.cpp:4229

Spell::EffectLearnTransmogIllusion
void EffectLearnTransmogIllusion()
Definition SpellEffects.cpp:6112

Spell::EffectPlayMovie
void EffectPlayMovie()
Definition SpellEffects.cpp:2398

Spell::EffectFeedPet
void EffectFeedPet()
Definition SpellEffects.cpp:3543

Spell::EffectNULL
void EffectNULL()
Definition SpellEffects.cpp:454

Spell::EffectApplyAura
void EffectApplyAura()
Definition SpellEffects.cpp:1114

Spell::EffectUncageBattlePet
void EffectUncageBattlePet()
Definition SpellEffects.cpp:5665

Spell::EffectTriggerRitualOfSummoning
void EffectTriggerRitualOfSummoning()
Definition SpellEffects.cpp:891

Spell::EffectInstaKill
void EffectInstaKill()
Definition SpellEffects.cpp:492

Spell::EffectCreateAreaTrigger
void EffectCreateAreaTrigger()
Definition SpellEffects.cpp:5412

Spell::EffectInebriate
void EffectInebriate()
Definition SpellEffects.cpp:3511

Spell::ExecuteLogEffectDestroyItem
void ExecuteLogEffectDestroyItem(SpellEffects effect, uint32 entry)
Definition Spell.cpp:5145

Spell::EffectOpenLock
void EffectOpenLock()
Definition SpellEffects.cpp:1643

Spell::EffectEnvironmentalDMG
void EffectEnvironmentalDMG()
Definition SpellEffects.cpp:516

Spell::EffectRedirectThreat
void EffectRedirectThreat()
Definition SpellEffects.cpp:4965

Spell::EffectChangeActiveCombatTraitConfig
void EffectChangeActiveCombatTraitConfig()
Definition SpellEffects.cpp:6242

Spell::EffectLearnTransmogSet
void EffectLearnTransmogSet()
Definition SpellEffects.cpp:5945

Spell::EffectRemoveAura
void EffectRemoveAura()
Definition SpellEffects.cpp:5154

Spell::EffectDualWield
void EffectDualWield()
Definition SpellEffects.cpp:2241

Spell::ExecuteLogEffectSummonObject
void ExecuteLogEffectSummonObject(SpellEffects effect, WorldObject *obj)
Definition Spell.cpp:5153

Spell::EffectUpdatePlayerPhase
void EffectUpdatePlayerPhase()
Definition SpellEffects.cpp:5741

Spell::m_healing
int32 m_healing
Definition Spell.h:819

Spell::EffectPickPocket
void EffectPickPocket()
Definition SpellEffects.cpp:2265

Spell::EffectTeleportUnitsWithVisualLoadingScreen
void EffectTeleportUnitsWithVisualLoadingScreen()
Definition SpellEffects.cpp:1076

Spell::EffectModifyAuraStacks
void EffectModifyAuraStacks()
Definition SpellEffects.cpp:6128

Spell::EffectProficiency
void EffectProficiency()
Definition SpellEffects.cpp:1849

Spell::EffectSummonPersonalGameObject
void EffectSummonPersonalGameObject()
Definition SpellEffects.cpp:5328

Spell::effectInfo
SpellEffectInfo const  * effectInfo
Definition Spell.h:807

Spell::EffectDisEnchant
void EffectDisEnchant()
Definition SpellEffects.cpp:3493

Spell::EffectEnableBattlePets
void EffectEnableBattlePets()
Definition SpellEffects.cpp:5620

Spell::EffectGiveArtifactPowerNoBonus
void EffectGiveArtifactPowerNoBonus()
Definition SpellEffects.cpp:5777

Spell::GetUnitCasterForEffectHandlers
Unit * GetUnitCasterForEffectHandlers() const
Definition Spell.cpp:8356

Spell::EffectTeleportToReturnPoint
void EffectTeleportToReturnPoint()
Definition SpellEffects.cpp:5284

Spell::EffectAddExtraAttacks
void EffectAddExtraAttacks()
Definition SpellEffects.cpp:3688

Spell::m_castItemLevel
int32 m_castItemLevel
Definition Spell.h:603

Spell::EffectTriggerMissileSpell
void EffectTriggerMissileSpell()
Definition SpellEffects.cpp:725

Spell::_spellAura
UnitAura * _spellAura
Definition Spell.h:810

Spell::EffectModifyCooldown
void EffectModifyCooldown()
Definition SpellEffects.cpp:6150

Spell::unitTarget
Unit * unitTarget
Definition Spell.h:797

Spell::EffectEnchantItemTmp
void EffectEnchantItemTmp()
Definition SpellEffects.cpp:2554

Spell::m_spellSchoolMask
SpellSchoolMask m_spellSchoolMask
Definition Spell.h:754

Spell::EffectCreateRandomItem
void EffectCreateRandomItem()
Definition SpellEffects.cpp:1502

Spell::EffectTeleUnitsFaceCaster
void EffectTeleUnitsFaceCaster()
Definition SpellEffects.cpp:2340

Spell::EffectDamageFromMaxHealthPCT
void EffectDamageFromMaxHealthPCT()
Definition SpellEffects.cpp:5165

Spell::EffectCreateHeirloomItem
void EffectCreateHeirloomItem()
Definition SpellEffects.cpp:5535

Spell::GetCaster
WorldObject * GetCaster() const
Definition Spell.h:699

Spell::EffectPullTowardsDest
void EffectPullTowardsDest()
Definition SpellEffects.cpp:4181

Spell::EffectSetPlayerDataElementAccount
void EffectSetPlayerDataElementAccount()
Definition SpellEffects.cpp:6306

Spell::m_misc
union Spell::@323 m_misc

Spell::EffectKillCreditPersonal
void EffectKillCreditPersonal()
Definition SpellEffects.cpp:4838

Spell::EffectLaunchQuestChoice
void EffectLaunchQuestChoice()
Definition SpellEffects.cpp:5654

Spell::EffectSchoolDMG
void EffectSchoolDMG()
Definition SpellEffects.cpp:545

Spell::EffectChangeRaidMarker
void EffectChangeRaidMarker()
Definition SpellEffects.cpp:4217

Spell::EffectGrantBattlePetLevel
void EffectGrantBattlePetLevel()
Definition SpellEffects.cpp:5567

Spell::EffectThreat
void EffectThreat()
Definition SpellEffects.cpp:2948

Spell::m_corpseTarget
Corpse * m_corpseTarget
Definition Spell.h:800

Spell::EffectResurrectNew
void EffectResurrectNew()
Definition SpellEffects.cpp:464

Spell::EffectChargeDest
void EffectChargeDest()
Definition SpellEffects.cpp:3995

Spell::EffectUntrainTalents
void EffectUntrainTalents()
Definition SpellEffects.cpp:2328

Spell::EffectUnlockGuildVaultTab
void EffectUnlockGuildVaultTab()
Definition SpellEffects.cpp:5317

Spell::EffectLearnSpell
void EffectLearnSpell()
Definition SpellEffects.cpp:2091

Spell::EffectMilling
void EffectMilling()
Definition SpellEffects.cpp:4614

Spell::EffectHealPct
void EffectHealPct()
Definition SpellEffects.cpp:1294

Spell::EffectJumpCharge
void EffectJumpCharge()
Definition SpellEffects.cpp:5886

Spell::EffectJumpDest
void EffectJumpDest()
Definition SpellEffects.cpp:951

Spell::EffectScriptEffect
void EffectScriptEffect()
Definition SpellEffects.cpp:3069

Spell::EffectAddFarsight
void EffectAddFarsight()
Definition SpellEffects.cpp:2302

Spell::EffectEnergize
void EffectEnergize()
Definition SpellEffects.cpp:1574

Spell::EffectCreateSceneObject
void EffectCreateSceneObject()
Definition SpellEffects.cpp:5814

Spell::destTarget
WorldLocation * destTarget
Definition Spell.h:801

Spell::EffectGameObjectSetDestructionState
void EffectGameObjectSetDestructionState()
Definition SpellEffects.cpp:5004

Spell::EffectIncreaseCurrencyCap
void EffectIncreaseCurrencyCap()
Definition SpellEffects.cpp:5294

Spell::EffectApplyGlyph
void EffectApplyGlyph()
Definition SpellEffects.cpp:3399

Spell::EffectResurrectWithAura
void EffectResurrectWithAura()
Definition SpellEffects.cpp:5380

Spell::EffectGiveCurrency
void EffectGiveCurrency()
Definition SpellEffects.cpp:5176

Spell::EffectModifyCooldowns
void EffectModifyCooldowns()
Definition SpellEffects.cpp:6158

Spell::EffectQuestComplete
void EffectQuestComplete()
Definition SpellEffects.cpp:3765

Spell::SendCastResult
static void SendCastResult(Player const *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:4641

Spell::EffectDiscoverTaxi
void EffectDiscoverTaxi()
Definition SpellEffects.cpp:4944

Spell::EffectModifySpellCharges
void EffectModifySpellCharges()
Definition SpellEffects.cpp:6188

Spell::EffectForceCast2
void EffectForceCast2()
Definition SpellEffects.cpp:851

Spell::EffectTeleportUnits
void EffectTeleportUnits()
Definition SpellEffects.cpp:1003

Spell::EffectGiveExperience
void EffectGiveExperience()
Definition SpellEffects.cpp:5582

Spell::EffectCreatePrivateConversation
void EffectCreatePrivateConversation()
Definition SpellEffects.cpp:6023

Spell::EffectPlaySceneScriptPackage
void EffectPlaySceneScriptPackage()
Definition SpellEffects.cpp:5790

Spell::EffectPlaySound
void EffectPlaySound()
Definition SpellEffects.cpp:5122

Spell::EffectLearnPetSpell
void EffectLearnPetSpell()
Definition SpellEffects.cpp:2746

Spell::EffectTeleportGraveyard
void EffectTeleportGraveyard()
Definition SpellEffects.cpp:6258

Spell::EffectPowerDrain
void EffectPowerDrain()
Definition SpellEffects.cpp:1146

Spell::m_CastItem
Item * m_CastItem
Definition Spell.h:600

Spell::CallScriptSuccessfulDispel
void CallScriptSuccessfulDispel(SpellEffIndex effIndex)
Definition Spell.cpp:8909

Spell::m_castItemEntry
uint32 m_castItemEntry
Definition Spell.h:602

Spell::GetUnitTargetIndexForEffect
int32 GetUnitTargetIndexForEffect(ObjectGuid const &target, SpellEffIndex effect) const
Definition Spell.cpp:2695

Spell::EffectTaunt
void EffectTaunt()
Definition SpellEffects.cpp:2772

Spell::EffectLeapBack
void EffectLeapBack()
Definition SpellEffects.cpp:4077

Spell::EffectDurabilityDamagePCT
void EffectDurabilityDamagePCT()
Definition SpellEffects.cpp:4413

Spell::m_spellValue
SpellValue *const m_spellValue
Definition Spell.h:747

Spell::EffectLearnSkill
void EffectLearnSkill()
Definition SpellEffects.cpp:2367

Spell::finish
void finish(SpellCastResult result=SPELL_CAST_OK)
Definition Spell.cpp:4359

Spell::SendResurrectRequest
void SendResurrectRequest(Player *target)
Definition Spell.cpp:5349

Spell::EffectActivateSpec
void EffectActivateSpec()
Definition SpellEffects.cpp:5103

Spell::EffectForceCast
void EffectForceCast()
Definition SpellEffects.cpp:791

Spell::EffectDismissPet
void EffectDismissPet()
Definition SpellEffects.cpp:3586

Spell::EffectPlayScene
void EffectPlayScene()
Definition SpellEffects.cpp:5856

Spell::EffectEnchantItemPerm
void EffectEnchantItemPerm()
Definition SpellEffects.cpp:2425

Spell::EffectQuestFail
void EffectQuestFail()
Definition SpellEffects.cpp:4873

Spell::EffectCreateTamedPet
void EffectCreateTamedPet()
Definition SpellEffects.cpp:4911

Spell::EffectSetPlayerDataFlagAccount
void EffectSetPlayerDataFlagAccount()
Definition SpellEffects.cpp:6330

Spell::EffectAddGarrisonFollower
void EffectAddGarrisonFollower()
Definition SpellEffects.cpp:5523

Spell::EffectLearnWarbandScene
void EffectLearnWarbandScene()
Definition SpellEffects.cpp:6294

Spell::EffectJump
void EffectJump()
Definition SpellEffects.cpp:917

Spell::EffectSkipQuestLine
void EffectSkipQuestLine()
Definition SpellEffects.cpp:6282

Spell::EffectDestroyItem
void EffectDestroyItem()
Definition SpellEffects.cpp:5444

Spell::m_castItemGUID
ObjectGuid m_castItemGUID
Definition Spell.h:601

Spell::EffectRemoveTalent
void EffectRemoveTalent()
Definition SpellEffects.cpp:5427

Spell::m_SpellVisual
SpellCastVisual m_SpellVisual
Definition Spell.h:650

Spell::GetUnitTargetCountForEffect
int64 GetUnitTargetCountForEffect(SpellEffIndex effect) const
Definition Spell.cpp:2712

Spell::ExecuteLogEffectUnsummonObject
void ExecuteLogEffectUnsummonObject(SpellEffects effect, WorldObject *obj)
Definition Spell.cpp:5161

Spell::focusObject
GameObject * focusObject
Definition Spell.h:815

Spell::EffectTitanGrip
void EffectTitanGrip()
Definition SpellEffects.cpp:4956

Spell::m_castId
ObjectGuid m_castId
Definition Spell.h:604

Spell::ExecuteLogEffectResurrect
void ExecuteLogEffectResurrect(SpellEffects effect, Unit *target)
Definition Spell.cpp:5169

Spell::m_spellInfo
SpellInfo const  *const m_spellInfo
Definition Spell.h:599

Spell::EffectUnlearnSpecialization
void EffectUnlearnSpecialization()
Definition SpellEffects.cpp:1130

Spell::EffectUpdateZoneAurasAndPhases
void EffectUpdateZoneAurasAndPhases()
Definition SpellEffects.cpp:5752

Spell::EffectQuestStart
void EffectQuestStart()
Definition SpellEffects.cpp:4884

Spell::EffectApplyMountEquipment
void EffectApplyMountEquipment()
Definition SpellEffects.cpp:6034

Spell::EffectSkipCampaign
void EffectSkipCampaign()
Definition SpellEffects.cpp:6068

Spell::EffectDuel
void EffectDuel()
Definition SpellEffects.cpp:3246

Spell::EffectUnused
void EffectUnused()
Definition SpellEffects.cpp:459

Spell::EffectCreateConversation
void EffectCreateConversation()
Definition SpellEffects.cpp:5494

Spell::EffectSkinning
void EffectSkinning()
Definition SpellEffects.cpp:3867

Spell::EffectHeal
void EffectHeal()
Definition SpellEffects.cpp:1246

TempSummon
Definition TemporarySummon.h:44

TempSummon::UnSummon
virtual void UnSummon(uint32 msTime=0)
Definition TemporarySummon.cpp:339

TempSummon::SetTempSummonType
void SetTempSummonType(TempSummonType type)
Definition TemporarySummon.cpp:334

ThreatManager
Definition ThreatManager.h:82

ThreatManager::RegisterRedirectThreat
void RegisterRedirectThreat(uint32 spellId, ObjectGuid const &victim, float pct)
== REDIRECT SYSTEM ==
Definition ThreatManager.cpp:801

ThreatManager::GetCurrentVictim
Unit * GetCurrentVictim()
Definition ThreatManager.cpp:242

ThreatManager::GetThreatenedByMeList
auto const & GetThreatenedByMeList() const
Definition ThreatManager.h:139

ThreatManager::ModifyThreatByPercent
void ModifyThreatByPercent(Unit *target, float percent)
Definition ThreatManager.h:147

ThreatManager::IsThreatListEmpty
bool IsThreatListEmpty(bool includeOffline=false) const
Definition ThreatManager.cpp:265

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:382

ThreatManager::MatchUnitThreatToHighestThreat
void MatchUnitThreatToHighestThreat(Unit *target)
Definition ThreatManager.cpp:484

Totem::UnSummon
void UnSummon(uint32 msTime=0) override
Definition Totem.cpp:100

Trinity::ObjectEntryAndPrivateOwnerIfExistsCheck
Definition GridNotifiers.h:2028

Unit
Definition Unit.h:647

Unit::GetPctModifierValue
float GetPctModifierValue(UnitMods unitMod, UnitModifierPctType modifierType) const
Definition Unit.cpp:9695

Unit::ClearUnitState
void ClearUnitState(uint32 f)
Definition Unit.h:756

Unit::IsVehicle
bool IsVehicle() const
Definition Unit.h:766

Unit::GetContentTuning
int32 GetContentTuning() const
Definition Unit.h:768

Unit::SetMinion
void SetMinion(Minion *minion, bool apply)
Definition Unit.cpp:6266

Unit::ModifyPower
int32 ModifyPower(Powers power, int32 val, bool withPowerUpdate=true)
Definition Unit.cpp:8716

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:6830

Unit::RemoveOwnedAura
void RemoveOwnedAura(AuraMap::iterator &i, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)
Definition Unit.cpp:3769

Unit::RemoveAurasByType
void RemoveAurasByType(AuraType auraType, std::function< bool(AuraApplication const *)> const &check, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)
Definition Unit.cpp:3973

Unit::RemoveGameObject
void RemoveGameObject(GameObject *gameObj, bool del)
Definition Unit.cpp:5436

Unit::GetAuraEffectsByType
AuraEffectList const & GetAuraEffectsByType(AuraType type) const
Definition Unit.h:1362

Unit::CombatStop
void CombatStop(bool includingCast=false, bool mutualPvP=true, bool(*unitFilter)(Unit const *otherUnit)=nullptr)
Definition Unit.cpp:6031

Unit::m_lastSanctuaryTime
uint32 m_lastSanctuaryTime
Definition Unit.h:1617

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:8152

Unit::SetHealth
void SetHealth(uint64 val)
Definition Unit.cpp:10041

Unit::SetVirtualItem
void SetVirtualItem(uint32 slot, uint32 itemId, uint16 appearanceModId=0, uint16 itemVisual=0)
Definition Unit.cpp:14521

Unit::CountPctFromMaxHealth
uint64 CountPctFromMaxHealth(float pct) const
Definition Unit.h:809

Unit::SpellHealingBonusTaken
int32 SpellHealingBonusTaken(Unit *caster, SpellInfo const *spellProto, int32 healamount, DamageEffectType damagetype) const
Definition Unit.cpp:7514

Unit::ToPet
Pet * ToPet()
Definition Unit.h:1838

Unit::CanHaveThreatList
bool CanHaveThreatList() const
====================== THREAT & COMBAT ====================
Definition Unit.h:1045

Unit::SetUnitFlag3
void SetUnitFlag3(UnitFlags3 flags)
Definition Unit.h:871

Unit::RemoveAura
void RemoveAura(AuraApplicationMap::iterator &i, AuraRemoveMode mode=AURA_REMOVE_BY_DEFAULT)
Definition Unit.cpp:3846

Unit::EnergizeBySpell
void EnergizeBySpell(Unit *victim, SpellInfo const *spellInfo, int32 damage, Powers powerType)
Definition Unit.cpp:6817

Unit::SendPlaySpellVisual
void SendPlaySpellVisual(Unit *target, uint32 spellVisualId, uint8 missReason, uint8 reflectStatus, float travelSpeed, bool speedAsTime=false, float launchDelay=0.0f)
Definition Unit.cpp:12400

Unit::GetThreatManager
ThreatManager & GetThreatManager()
Definition Unit.h:1093

Unit::SetCanDualWield
virtual void SetCanDualWield(bool value)
Definition Unit.h:716

Unit::GetClass
uint8 GetClass() const
Definition Unit.h:776

Unit::m_SummonSlot
std::array< ObjectGuid, MAX_SUMMON_SLOT > m_SummonSlot
Definition Unit.h:1524

Unit::ToTotem
Totem * ToTotem()
Definition Unit.h:1841

Unit::GetHealthGain
int64 GetHealthGain(int64 dVal)
Definition Unit.cpp:8660

Unit::RemoveAurasDueToSpellByDispel
void RemoveAurasDueToSpellByDispel(uint32 spellId, uint32 dispellerSpellId, ObjectGuid casterGUID, WorldObject *dispeller, uint8 chargesRemoved=1)
Definition Unit.cpp:4025

Unit::AuraEffectList
std::forward_list< AuraEffect * > AuraEffectList
Definition Unit.h:664

Unit::SetPower
void SetPower(Powers power, int32 val, bool withPowerUpdate=true)
Definition Unit.cpp:10114

Unit::CreateTamedPetFrom
Pet * CreateTamedPetFrom(Creature *creatureTarget, uint32 spell_id=0)
Definition Unit.cpp:11160

Unit::CalculateDamage
uint32 CalculateDamage(WeaponAttackType attType, bool normalized, bool addTotalPct) const
Definition Unit.cpp:2490

Unit::CalcAbsorbResist
static void CalcAbsorbResist(DamageInfo &damageInfo, Spell *spell=nullptr)
Definition Unit.cpp:1866

Unit::GetVehicleBase
Unit * GetVehicleBase() const
Definition Unit.cpp:12206

Unit::GetMotionMaster
MotionMaster * GetMotionMaster()
Definition Unit.h:1750

Unit::IsPet
bool IsPet() const
Definition Unit.h:763

Unit::GetPowerType
Powers GetPowerType() const
Definition Unit.h:823

Unit::HasUnitFlag
bool HasUnitFlag(UnitFlags flags) const
Definition Unit.h:860

Unit::InterruptSpell
void InterruptSpell(CurrentSpellTypes spellType, bool withDelayed=true, bool withInstant=true, SpellCastResult result=SPELL_FAILED_INTERRUPTED, Optional< SpellCastResult > resultOther={}, ObjectGuid const &interrupter=ObjectGuid::Empty)
Definition Unit.cpp:3158

Unit::m_ObjectSlot
std::array< ObjectGuid, MAX_GAMEOBJECT_SLOT > m_ObjectSlot
Definition Unit.h:1525

Unit::SetCreatedBySpell
void SetCreatedBySpell(int32 spellId)
Definition Unit.h:875

Unit::AddChannelObject
void AddChannelObject(ObjectGuid guid)
Definition Unit.cpp:3046

Unit::GetAuraEffect
AuraEffect * GetAuraEffect(uint32 spellId, uint8 effIndex, ObjectGuid casterGUID=ObjectGuid::Empty) const
Definition Unit.cpp:4622

Unit::SetDemonCreatorGUID
void SetDemonCreatorGUID(ObjectGuid guid)
Definition Unit.h:1224

Unit::IsAlive
bool IsAlive() const
Definition Unit.h:1205

Unit::IsScriptOverriden
AuraEffect * IsScriptOverriden(SpellInfo const *spell, int32 script) const
Definition Unit.cpp:4934

Unit::GetCombatReach
float GetCombatReach() const override
Definition Unit.h:717

Unit::GetMaxPower
int32 GetMaxPower(Powers power) const
Definition Unit.cpp:10105

Unit::HealBySpell
int32 HealBySpell(HealInfo &healInfo, bool critical=false)
Definition Unit.cpp:6795

Unit::SendSpellNonMeleeDamageLog
void SendSpellNonMeleeDamageLog(SpellNonMeleeDamage const *log)
Definition Unit.cpp:5559

Unit::SetPetFlag
void SetPetFlag(UnitPetFlag flags)
Definition Unit.h:907

Unit::ToTempSummon
TempSummon * ToTempSummon()
Definition Unit.h:1844

Unit::GetCharmInfo
CharmInfo * GetCharmInfo()
Definition Unit.h:1262

Unit::AddGameObject
void AddGameObject(GameObject *gameObj)
Definition Unit.cpp:5385

Unit::IsInFlight
bool IsInFlight() const
Definition Unit.h:1042

Unit::SetChannelObject
void SetChannelObject(uint32 slot, ObjectGuid guid)
Definition Unit.cpp:3051

Unit::GetMaxHealth
uint64 GetMaxHealth() const
Definition Unit.h:801

Unit::Attack
bool Attack(Unit *victim, bool meleeAttack)
Definition Unit.cpp:5872

Unit::GetAura
Aura * GetAura(uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint32 reqEffMask=0) const
Definition Unit.cpp:4718

Unit::GetHealth
uint64 GetHealth() const
Definition Unit.h:800

Unit::IsSummon
bool IsSummon() const
Definition Unit.h:761

Unit::GetFaction
uint32 GetFaction() const override
Definition Unit.h:886

Unit::GetDispellableAuraList
void GetDispellableAuraList(WorldObject const *caster, uint32 dispelMask, DispelChargesList &dispelList, bool isReflect=false) const
Definition Unit.cpp:4754

Unit::getAttackers
AttackerSet const & getAttackers() const
Definition Unit.h:736

Unit::AuraMap
std::multimap< uint32, Aura * > AuraMap
Definition Unit.h:653

Unit::SetFullPower
void SetFullPower(Powers power)
Definition Unit.h:837

Unit::RemoveAurasWithInterruptFlags
void RemoveAurasWithInterruptFlags(InterruptFlags flag, SpellInfo const *source=nullptr)
Definition Unit.cpp:4259

Unit::SetMaxHealth
void SetMaxHealth(uint64 val)
Definition Unit.cpp:10072

Unit::AttackerSet
std::set< Unit * > AttackerSet
Definition Unit.h:649

Unit::RemoveAppliedAuras
void RemoveAppliedAuras(std::function< bool(AuraApplication const *)> const &check, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)
Definition Unit.cpp:3919

Unit::IsGuardian
bool IsGuardian() const
Definition Unit.h:762

Unit::m_unitData
UF::UpdateField< UF::UnitData, int32(WowCS::EntityFragment::CGObject), TYPEID_UNIT > m_unitData
Definition Unit.h:1897

Unit::AddExtraAttacks
void AddExtraAttacks(uint32 count)
Definition Unit.cpp:2363

Unit::SetOwnerGUID
void SetOwnerGUID(ObjectGuid owner)
Definition Unit.cpp:6190

Unit::GetTransGUID
ObjectGuid GetTransGUID() const override
Definition Unit.cpp:12236

Unit::NearTeleportTo
void NearTeleportTo(TeleportLocation const &target, bool casting=false)
Definition Unit.cpp:13054

Unit::HasUnitState
bool HasUnitState(const uint32 f) const
Definition Unit.h:755

Unit::_CreateAuraApplication
AuraApplication * _CreateAuraApplication(Aura *aura, uint32 effMask)
Definition Unit.cpp:3507

Unit::SpellDamageBonusTaken
int32 SpellDamageBonusTaken(Unit *caster, SpellInfo const *spellProto, int32 pdamage, DamageEffectType damagetype) const
Definition Unit.cpp:7013

Unit::movespline
std::unique_ptr< Movement::MoveSpline > movespline
Definition Unit.h:1854

Unit::KnockbackFrom
void KnockbackFrom(Position const &origin, float speedXY, float speedZ, float angle=M_PI, Movement::SpellEffectExtraData const *spellEffectExtraData=nullptr)
Definition Unit.cpp:12587

Unit::HasAura
bool HasAura(uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint32 reqEffMask=0) const
Definition Unit.cpp:4822

Unit::HasUnitTypeMask
uint32 HasUnitTypeMask(uint32 mask) const
Definition Unit.h:759

Unit::MeleeDamageBonusDone
int32 MeleeDamageBonusDone(Unit *pVictim, int32 damage, WeaponAttackType attType, DamageEffectType damagetype, SpellInfo const *spellProto=nullptr, SpellEffectInfo const *spellEffectInfo=nullptr, Mechanics mechanic=MECHANIC_NONE, SpellSchoolMask damageSchoolMask=SPELL_SCHOOL_MASK_NORMAL, Spell *spell=nullptr, AuraEffect const *aurEff=nullptr)
Definition Unit.cpp:8040

Unit::GetSpellHistory
SpellHistory * GetSpellHistory()
Definition Unit.h:1521

Unit::SetCreatorGUID
void SetCreatorGUID(ObjectGuid creator)
Definition Unit.h:1214

Unit::RemoveMovementImpairingAuras
void RemoveMovementImpairingAuras(bool withRoot)
Definition Unit.cpp:4312

Unit::IsTotem
bool IsTotem() const
Definition Unit.h:765

Unit::GetBattlePetCompanionGUID
ObjectGuid GetBattlePetCompanionGUID() const
Definition Unit.h:1221

Unit::KillSelf
void KillSelf(bool durabilityLoss=true, bool skipSettingDeathState=false)
Definition Unit.h:951

Unit::Talk
virtual void Talk(std::string_view text, ChatMsg msgType, Language language, float textRange, WorldObject const *target)
Definition Unit.cpp:14471

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:5589

Unit::IsEngaged
virtual bool IsEngaged() const
Definition Unit.h:1049

Unit::GetOwnedAuras
AuraMap & GetOwnedAuras()
Definition Unit.h:1305

Unit::RemoveAurasDueToSpell
void RemoveAurasDueToSpell(uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, uint32 reqEffMask=0, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)
Definition Unit.cpp:3992

Unit::Kill
static void Kill(Unit *attacker, Unit *victim, bool durabilityLoss=true, bool skipSettingDeathState=false)
Definition Unit.cpp:11311

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:7347

Unit::GetTarget
ObjectGuid GetTarget() const
Definition Unit.h:1847

Unit::GetLevel
uint8 GetLevel() const
Definition Unit.h:769

Unit::GetRace
uint8 GetRace() const
Definition Unit.h:773

Unit::RemoveUnitFlag
void RemoveUnitFlag(UnitFlags flags)
Definition Unit.h:862

Unit::RemoveAurasDueToSpellBySteal
void RemoveAurasDueToSpellBySteal(uint32 spellId, ObjectGuid casterGUID, WorldObject *stealer, int32 stolenCharges=1)
Definition Unit.cpp:4053

Unit::GetPetGUID
ObjectGuid GetPetGUID() const
Definition Unit.h:1217

Unit::isDead
bool isDead() const
Definition Unit.h:1207

Unit::GetCurrentSpell
Spell * GetCurrentSpell(CurrentSpellTypes spellType) const
Definition Unit.h:1490

WorldLocation
Definition Position.h:192

WorldLocation::WorldRelocate
constexpr void WorldRelocate(WorldLocation const &loc)
Definition Position.h:202

WorldLocation::GetMapId
constexpr uint32 GetMapId() const
Definition Position.h:216

WorldLocation::m_mapId
uint32 m_mapId
Definition Position.h:218

WorldLocation::GetWorldLocation
constexpr WorldLocation GetWorldLocation() const
Definition Position.h:211

WorldObject
Definition Object.h:281

WorldObject::PlayDirectSound
void PlayDirectSound(uint32 soundId, Player const *target=nullptr, uint32 broadcastTextId=0) const
Definition Object.cpp:2941

WorldObject::SendMessageToSet
virtual void SendMessageToSet(WorldPacket const *data, bool self) const
Definition Object.cpp:1099

WorldObject::GetMap
Map * GetMap() const
Definition Object.h:411

WorldObject::GetRandomPoint
Position GetRandomPoint(Position const &srcPos, float distance, float minDistance=0.0f) const
Definition Object.cpp:678

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:513

WorldObject::GetPrivateObjectOwner
ObjectGuid GetPrivateObjectOwner() const
Definition Object.h:569

WorldObject::GetClosePoint
void GetClosePoint(float &x, float &y, float &z, float size, float distance2d=0, float relAngle=0) const
Definition Object.cpp:2754

WorldObject::CastSpell
SpellCastResult CastSpell(CastSpellTargetArg const &targets, uint32 spellId, CastSpellExtraArgs const &args={ })
Definition Object.cpp:2222

WorldObject::IsValidAttackTarget
bool IsValidAttackTarget(WorldObject const *target, SpellInfo const *bySpell=nullptr) const
Definition Object.cpp:2329

WorldObject::GetOwner
Unit * GetOwner() const
Definition Object.cpp:1603

WorldObject::IsPrivateObject
bool IsPrivateObject() const
Definition Object.h:568

WorldObject::SetPrivateObjectOwner
void SetPrivateObjectOwner(ObjectGuid const &owner)
Definition Object.h:570

WorldObject::ModSpellDuration
int32 ModSpellDuration(SpellInfo const *spellInfo, WorldObject const *target, int32 duration, bool positive, uint32 effectMask) const
Definition Object.cpp:1725

WorldObject::GetName
std::string const & GetName() const
Definition Object.h:342

WorldObject::GetCharmerOrOwnerPlayerOrPlayerItself
Player * GetCharmerOrOwnerPlayerOrPlayerItself() const
Definition Object.cpp:1626

WorldObject::SetName
void SetName(std::string newname)
Definition Object.h:343

WorldObject::m_Events
EventProcessor m_Events
Definition Object.h:561

WorldObject::GetVisibilityRange
float GetVisibilityRange() const
Definition Object.cpp:785

WorldObject::GetDistance
float GetDistance(WorldObject const *obj) const
Definition Object.cpp:430

WorldObject::GetAreaId
uint32 GetAreaId() const
Definition Object.h:333

WorldObject::GetFirstCollisionPosition
Position GetFirstCollisionPosition(float dist, float angle)
Definition Object.cpp:2767

WorldObject::IsFriendlyTo
bool IsFriendlyTo(WorldObject const *target) const
Definition Object.cpp:2191

WorldObject::GetCombatReach
virtual float GetCombatReach() const
Definition Object.h:302

WorldObject::GetAffectingPlayer
Player * GetAffectingPlayer() const
Definition Object.cpp:1635

WorldObject::GetFactionTemplateEntry
FactionTemplateEntry const * GetFactionTemplateEntry() const
Definition Object.cpp:2005

WorldPacket
Definition WorldPacket.h:26

WorldPackets::CombatLog::SpellDispellLog
Definition CombatLogPackets.h:169

WorldPackets::CombatLog::SpellDispellLog::DispelledBySpellID
int32 DispelledBySpellID
Definition CombatLogPackets.h:178

WorldPackets::CombatLog::SpellDispellLog::IsSteal
bool IsSteal
Definition CombatLogPackets.h:180

WorldPackets::CombatLog::SpellDispellLog::Write
WorldPacket const * Write() override
Definition CombatLogPackets.cpp:447

WorldPackets::CombatLog::SpellDispellLog::TargetGUID
ObjectGuid TargetGUID
Definition CombatLogPackets.h:177

WorldPackets::CombatLog::SpellDispellLog::DispellData
std::vector< SpellDispellData > DispellData
Definition CombatLogPackets.h:175

WorldPackets::CombatLog::SpellDispellLog::CasterGUID
ObjectGuid CasterGUID
Definition CombatLogPackets.h:176

WorldPackets::CombatLog::SpellDispellLog::IsBreak
bool IsBreak
Definition CombatLogPackets.h:179

WorldPackets::CombatLog::SpellInstakillLog
Definition CombatLogPackets.h:199

WorldPackets::CombatLog::SpellInstakillLog::Caster
ObjectGuid Caster
Definition CombatLogPackets.h:206

WorldPackets::CombatLog::SpellInstakillLog::Write
WorldPacket const * Write() override
Definition CombatLogPackets.cpp:278

WorldPackets::CombatLog::SpellInstakillLog::Target
ObjectGuid Target
Definition CombatLogPackets.h:205

WorldPackets::CombatLog::SpellInstakillLog::SpellID
int32 SpellID
Definition CombatLogPackets.h:207

WorldPackets::Combat::PvPCredit
Definition CombatPackets.h:215

WorldPackets::Combat::PvPCredit::OriginalHonor
int32 OriginalHonor
Definition CombatPackets.h:221

WorldPackets::Combat::PvPCredit::Write
WorldPacket const * Write() override
Definition CombatPackets.cpp:145

WorldPackets::Combat::PvPCredit::Honor
int32 Honor
Definition CombatPackets.h:222

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:53

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:536

WorldPackets::Spells::ApplyMountEquipmentResult
Definition SpellPackets.h:1167

WorldPackets::Spells::ApplyMountEquipmentResult::ItemGUID
ObjectGuid ItemGUID
Definition SpellPackets.h:1179

WorldPackets::Spells::ApplyMountEquipmentResult::Write
WorldPacket const * Write() override
Definition SpellPackets.cpp:1157

WorldPackets::Spells::ApplyMountEquipmentResult::Success
@ Success
Definition SpellPackets.h:1171

WorldPackets::Spells::ApplyMountEquipmentResult::ItemID
int32 ItemID
Definition SpellPackets.h:1180

WorldPackets::Spells::ApplyMountEquipmentResult::Result
ApplyResult Result
Definition SpellPackets.h:1181

WorldPackets::Spells::CustomLoadScreen
Definition SpellPackets.h:1145

WorldPackets::Spells::CustomLoadScreen::Write
WorldPacket const * Write() override
Definition SpellPackets.cpp:1142

WorldPackets::Spells::DispelFailed
Definition SpellPackets.h:1132

WorldPackets::Spells::DispelFailed::CasterGUID
ObjectGuid CasterGUID
Definition SpellPackets.h:1138

WorldPackets::Spells::DispelFailed::FailedSpells
std::vector< int32 > FailedSpells
Definition SpellPackets.h:1141

WorldPackets::Spells::DispelFailed::VictimGUID
ObjectGuid VictimGUID
Definition SpellPackets.h:1139

WorldPackets::Spells::DispelFailed::SpellID
uint32 SpellID
Definition SpellPackets.h:1140

WorldPackets::Spells::DispelFailed::Write
WorldPacket const * Write() override
Definition SpellPackets.cpp:1130

WorldPackets::Spells::SpellVisualLoadScreen
Definition SpellPackets.h:803

WorldPackets::Spells::SpellVisualLoadScreen::Write
WorldPacket const * Write() override
Definition SpellPackets.cpp:855

WorldPackets::Talent::ActiveGlyphs
Definition TalentPackets.h:148

WorldPackets::Talent::ActiveGlyphs::Glyphs
std::vector< GlyphBinding > Glyphs
Definition TalentPackets.h:154

WorldPackets::Talent::ActiveGlyphs::IsFullUpdate
bool IsFullUpdate
Definition TalentPackets.h:155

WorldPackets::Talent::ActiveGlyphs::Write
WorldPacket const * Write() override
Definition TalentPackets.cpp:156

WorldSession::SendNotification
void SendNotification(char const *format,...) ATTR_PRINTF(2
Definition WorldSession.cpp:752

WorldSession::GetAccountGUID
ObjectGuid GetAccountGUID() const
Definition WorldSession.h:1019

WorldSession::HasPermission
bool HasPermission(uint32 permissionId)
Definition WorldSession.cpp:1483

WorldSession::GetAccountId
uint32 GetAccountId() const
Definition WorldSession.h:1018

WorldSession::GetCollectionMgr
CollectionMgr * GetCollectionMgr() const
Definition WorldSession.h:1235

WorldSession::SendDiscoverNewTaxiNode
void SendDiscoverNewTaxiNode(uint32 nodeid)
Definition TaxiHandler.cpp:153

WorldSession::GetBattlePetMgr
BattlePets::BattlePetMgr * GetBattlePetMgr() const
Definition WorldSession.h:1233

flag128
Definition FlagsArray.h:117

sWorld
#define sWorld
Definition World.h:919

RATE_DROP_MONEY
@ RATE_DROP_MONEY
Definition World.h:481

CONFIG_SKILL_MILLING
@ CONFIG_SKILL_MILLING
Definition World.h:124

CONFIG_SKILL_PROSPECTING
@ CONFIG_SKILL_PROSPECTING
Definition World.h:123

CONFIG_CAST_UNSTUCK
@ CONFIG_CAST_UNSTUCK
Definition World.h:120

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:57

Movement::gravity
float constexpr gravity
Definition MovementTypedefs.h:81

ObjectAccessor::FindPlayer
TC_GAME_API Player * FindPlayer(ObjectGuid const &)
Definition ObjectAccessor.cpp:255

QuestMgr::SkipCampaignForPlayer
TC_GAME_API void SkipCampaignForPlayer(uint32 campaignId, Player *player)
Definition QuestMgr.cpp:205

QuestMgr::SkipQuestLineForPlayer
TC_GAME_API void SkipQuestLineForPlayer(uint32 questLineId, Player *player)
Definition QuestMgr.cpp:148

TraitMgr::GetConfigTypeForTree
TraitConfigType GetConfigTypeForTree(int32 traitTreeId)
Definition TraitMgr.cpp:324

rbac::RBAC_PERM_LOG_GM_TRADE
@ RBAC_PERM_LOG_GM_TRADE
Definition RBAC.h:64

ActionButton
Definition Player.h:409

ActionButton::GetAction
uint64 GetAction() const
Definition Player.h:417

ActionButton::GetType
ActionButtonType GetType() const
Definition Player.h:416

AreaTableEntry
Definition DB2Structure.h:126

AreaTableEntry::GetFlags
EnumFlag< AreaFlags > GetFlags() const
Definition DB2Structure.h:153

AreaTriggerId
Definition AreaTriggerTemplate.h:76

AuraCreateInfo
Definition SpellAuras.h:107

AuraCreateInfo::SetCaster
AuraCreateInfo & SetCaster(Unit *caster)
Definition SpellAuras.h:115

AuraCreateInfo::SetCastItem
AuraCreateInfo & SetCastItem(ObjectGuid const &guid, uint32 itemId, int32 itemLevel)
Definition SpellAuras.h:117

AuraCreateInfo::SetBaseAmount
AuraCreateInfo & SetBaseAmount(SpellEffectValue const *bp)
Definition SpellAuras.h:116

BattlePetBreedQualityEntry::MaxQualityRoll
int32 MaxQualityRoll
Definition DB2Structure.h:477

BattlePetSpeciesEntry
Definition DB2Structure.h:491

BattlePetSpeciesEntry::CreatureID
int32 CreatureID
Definition DB2Structure.h:495

CastSpellExtraArgsInit::CastDifficulty
Difficulty CastDifficulty
Definition SpellDefines.h:495

CastSpellExtraArgsInit::CastItem
Item * CastItem
Definition SpellDefines.h:496

CastSpellExtraArgsInit::TriggerFlags
TriggerCastFlags TriggerFlags
Definition SpellDefines.h:494

CastSpellExtraArgsInit::OriginalCastItemLevel
Optional< int32 > OriginalCastItemLevel
Definition SpellDefines.h:501

CastSpellExtraArgsInit::OriginalCastId
ObjectGuid OriginalCastId
Definition SpellDefines.h:500

CastSpellExtraArgs
Definition SpellDefines.h:521

CastSpellExtraArgs::SetTriggeringSpell
CastSpellExtraArgs & SetTriggeringSpell(Spell const *triggeringSpell)
Definition Spell.cpp:9646

CastSpellExtraArgs::SetOriginalCaster
CastSpellExtraArgs & SetOriginalCaster(ObjectGuid const &guid)
Definition SpellDefines.h:545

CastSpellExtraArgs::SetCustomArg
CastSpellExtraArgs & SetCustomArg(std::any customArg)
Definition SpellDefines.h:551

CastSpellExtraArgs::AddSpellMod
CastSpellExtraArgs & AddSpellMod(SpellValueMod mod, int32 val)
Definition SpellDefines.h:548

CastSpellTargetArg
Definition SpellDefines.h:462

Cell::VisitWorldObjects
static void VisitWorldObjects(WorldObject const *obj, T &visitor, float radius)
Definition CellImpl.h:150

Cell::VisitGridObjects
static void VisitGridObjects(WorldObject const *obj, T &visitor, float radius)
Definition CellImpl.h:140

CharmInfo
Definition CharmInfo.h:88

CharmInfo::SaveStayPosition
void SaveStayPosition()
Definition Unit.cpp:13328

CharmInfo::SetIsCommandFollow
void SetIsCommandFollow(bool val)
Definition Unit.cpp:13318

CharmInfo::SetIsAtStay
void SetIsAtStay(bool val)
Definition Unit.cpp:13349

CharmInfo::SetIsFollowing
void SetIsFollowing(bool val)
Definition Unit.cpp:13359

CharmInfo::SetIsReturning
void SetIsReturning(bool val)
Definition Unit.cpp:13369

CharmInfo::HasCommandState
bool HasCommandState(CommandStates state) const
Definition CharmInfo.h:98

CharmInfo::SetIsCommandAttack
void SetIsCommandAttack(bool val)
Definition Unit.cpp:13308

ChrSpecializationEntry
Definition DB2Structure.h:923

ChrSpecializationEntry::IsPetSpecialization
bool IsPetSpecialization() const
Definition DB2Structure.h:941

ContentTuningEntry
Definition DB2Structure.h:985

ContentTuningEntry::ExpansionID
int32 ExpansionID
Definition DB2Structure.h:988

CreatureDifficulty::GetRequiredLootSkill
SkillType GetRequiredLootSkill() const
Definition CreatureData.h:475

CreatureDifficulty::SkinLootID
uint32 SkinLootID
Definition CreatureData.h:463

CreatureDifficulty::PickPocketLootID
uint32 PickPocketLootID
Definition CreatureData.h:462

FactionEntry
Definition DB2Structure.h:1674

FactionTemplateEntry
Definition DB2Structure.h:1707

FactionTemplateEntry::IsFriendlyTo
bool IsFriendlyTo(FactionTemplateEntry const *entry) const
Definition DB2Structure.h:1720

GameObjectTemplate
Definition GameObjectData.h:62

GameObjectTemplate::type
uint32 type
Definition GameObjectData.h:64

GameObjectTemplate::GetNoDamageImmune
uint32 GetNoDamageImmune() const
Definition GameObjectData.h:1074

GameObjectTemplate::GetLockId
uint32 GetLockId() const
Definition GameObjectData.h:1033

GlyphPropertiesEntry
Definition DB2Structure.h:2092

ItemEffectEntry
Definition DB2Structure.h:2428

ItemTemplate
Definition ItemTemplate.h:846

ItemTemplate::GetRequiredSkillRank
uint32 GetRequiredSkillRank() const
Definition ItemTemplate.h:867

ItemTemplate::GetBaseItemLevel
uint32 GetBaseItemLevel() const
Definition ItemTemplate.h:864

ItemTemplate::GetId
uint32 GetId() const
Definition ItemTemplate.h:850

ItemTemplate::GetMaxStackSize
uint32 GetMaxStackSize() const
Definition ItemTemplate.h:925

ItemTemplate::HasFlag
bool HasFlag(ItemFlags flag) const
Definition ItemTemplate.h:958

ItemTemplate::GetDefaultLocaleName
char const * GetDefaultLocaleName() const
Definition ItemTemplate.cpp:142

ItemTemplate::GetLockID
uint32 GetLockID() const
Definition ItemTemplate.h:888

JumpArrivalCastArgs
Definition MovementDefines.h:132

JumpArrivalCastArgs::Target
ObjectGuid Target
Definition MovementDefines.h:134

JumpArrivalCastArgs::SpellId
uint32 SpellId
Definition MovementDefines.h:133

JumpChargeParams
Definition MovementDefines.h:138

Loot
Definition Loot.h:286

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:859

MountEntry
Definition DB2Structure.h:3073

MountEquipmentEntry
Definition DB2Structure.h:3107

NonDefaultConstructible
Definition Util.h:601

Position
Definition Position.h:30

Position::GetPositionX
constexpr float GetPositionX() const
Definition Position.h:87

Position::GetPositionY
constexpr float GetPositionY() const
Definition Position.h:88

Position::GetRelativeAngle
float GetRelativeAngle(float x, float y) const
Definition Position.h:147

Position::IsInDist2d
constexpr bool IsInDist2d(float x, float y, float dist) const
Definition Position.h:151

Position::GetExactDist
float GetExactDist(float x, float y, float z) const
Definition Position.h:129

Position::GetAbsoluteAngle
float GetAbsoluteAngle(float x, float y) const
Definition Position.h:136

Position::GetPosition
constexpr void GetPosition(float &x, float &y) const
Definition Position.h:92

Position::Relocate
constexpr void Relocate(float x, float y)
Definition Position.h:74

Position::GetOrientation
constexpr float GetOrientation() const
Definition Position.h:90

Position::GetPositionZ
constexpr float GetPositionZ() const
Definition Position.h:89

PvPInfo::IsHostile
bool IsHostile
Definition Player.h:438

PvPInfo::IsInHostileArea
bool IsInHostileArea
Definition Player.h:439

QuaternionData
Definition QuaternionData.h:24

QuaternionData::fromOrientation
static QuaternionData fromOrientation(float orientation)
Definition GameObject.cpp:133

SkillRaceClassInfoEntry
Definition DB2Structure.h:3730

SkillRaceClassInfoEntry::Flags
int32 Flags
Definition DB2Structure.h:3734

SkillRaceClassInfoEntry::SkillTierID
int16 SkillTierID
Definition DB2Structure.h:3737

SkillTiersEntry
Definition ObjectMgr.h:878

SkillTiersEntry::GetValueForTierIndex
uint32 GetValueForTierIndex(uint32 tierIndex) const
Definition ObjectMgr.cpp:7955

SpellDestination
Definition SpellDefines.h:356

SpellDestination::_transportOffset
Position _transportOffset
Definition SpellDefines.h:368

SpellDestination::_position
WorldLocation _position
Definition SpellDefines.h:366

SpellDestination::_transportGUID
ObjectGuid _transportGUID
Definition SpellDefines.h:367

SpellHistory::CooldownEntry
Definition SpellHistory.h:66

SpellHistory::CooldownEntry::SpellId
uint32 SpellId
Definition SpellHistory.h:67

SpellItemEnchantmentEntry
Definition DB2Structure.h:3975

SpellItemEnchantmentEntry::Effect
std::array< uint8, MAX_ITEM_ENCHANTMENT_EFFECTS > Effect
Definition DB2Structure.h:3994

SpellItemEnchantmentEntry::Duration
int32 Duration
Definition DB2Structure.h:3979

SpellNonMeleeDamage
Definition Unit.h:567

SpellNonMeleeDamage::damage
uint32 damage
Definition Unit.h:575

SpellNonMeleeDamage::absorb
uint32 absorb
Definition Unit.h:578

SpellNonMeleeDamage::originalDamage
uint32 originalDamage
Definition Unit.h:576

SpellNonMeleeDamage::resist
uint32 resist
Definition Unit.h:579

SpellPowerCost
Definition SpellInfo.h:318

SpellRange
Definition SpellDefines.h:347

SpellRange::Min
float Min
Definition SpellDefines.h:348

SpellRange::Max
float Max
Definition SpellDefines.h:349

SpellValue::EffectBasePoints
SpellEffectValue EffectBasePoints[MAX_SPELL_EFFECTS]
Definition Spell.h:242

Spell::TargetInfo
Definition Spell.h:849

Spell::TargetInfo::TargetGUID
ObjectGuid TargetGUID
Definition Spell.h:854

SummonPropertiesEntry
Definition DB2Structure.h:4319

SummonPropertiesEntry::GetFlags
EnumFlag< SummonPropertiesFlags > GetFlags() const
Definition DB2Structure.h:4327

SummonPropertiesEntry::Title
int32 Title
Definition DB2Structure.h:4323

SummonPropertiesEntry::Control
int32 Control
Definition DB2Structure.h:4321

TalentEntry
Definition DB2Structure.h:4339

TeleportLocation
Definition Player.h:1209

TeleportLocation::Location
WorldLocation Location
Definition Player.h:1210

TraitSystemEntry
Definition DB2Structure.h:4637

TraitSystemEntry::GetVariationType
TraitSystemVariationType GetVariationType() const
Definition DB2Structure.h:4645

Trinity::ConversationWorker
Definition GridNotifiers.h:852

Trinity::MessageDistDelivererToHostile
Definition GridNotifiers.h:212

Trinity::PacketSenderOwning
Definition GridNotifiers.h:162

Trinity::PacketSenderOwning::Data
Packet Data
Definition GridNotifiers.h:163

UF::SelectedAzeriteEssences
Definition UpdateFields.h:197

UF::TraitConfig
Definition UpdateFields.h:979

UF::TraitConfig::TraitSystemID
UpdateField< int32, 12, 13 > TraitSystemID
Definition UpdateFields.h:989

UF::TraitConfig::Type
UpdateField< int32, 4, 6 > Type
Definition UpdateFields.h:984

UF::TraitConfig::VariationID
UpdateField< int32, 12, 14 > VariationID
Definition UpdateFields.h:990

UF::VisibleItem
Definition UpdateFields.h:256

UF::VisibleItem::ItemVisual
UpdateField< uint16, 0, 7 > ItemVisual
Definition UpdateFields.h:263

UF::VisibleItem::ItemID
UpdateField< int32, 0, 3 > ItemID
Definition UpdateFields.h:259

UF::VisibleItem::ItemAppearanceModID
UpdateField< uint16, 0, 6 > ItemAppearanceModID
Definition UpdateFields.h:262

WorldPackets::CombatLog::SpellDispellData
Definition CombatLogPackets.h:161

WorldPackets::CombatLog::SpellDispellData::SpellID
int32 SpellID
Definition CombatLogPackets.h:162

WorldPackets::CombatLog::SpellDispellData::Harmful
bool Harmful
Definition CombatLogPackets.h:163

WorldPackets::Traits::TraitConfig
Definition TraitPacketsCommon.h:58

WorldPackets::Traits::TraitConfig::TraitSystemID
int32 TraitSystemID
Definition TraitPacketsCommon.h:68

WorldPackets::Traits::TraitConfig::VariationID
int32 VariationID
Definition TraitPacketsCommon.h:69

WorldPackets::Traits::TraitConfig::Type
TraitConfigType Type
Definition TraitPacketsCommon.h:63