#include "SpellMgr.h"

Public Member Functions
CreatureImmunities const *	GetCreatureImmunities (int32 creatureImmunitiesId) const

uint32	GetSpellDifficultyId (uint32 spellId) const

void	SetSpellDifficultyId (uint32 spellId, uint32 id)

uint32	GetSpellIdForDifficulty (uint32 spellId, WorldObject const *caster) const

SpellInfo const *	GetSpellForDifficultyFromSpell (SpellInfo const spell, WorldObject const caster) const

SpellChainNode const *	GetSpellChainNode (uint32 spell_id) const

uint32	GetFirstSpellInChain (uint32 spell_id) const

uint32	GetLastSpellInChain (uint32 spell_id) const

uint32	GetNextSpellInChain (uint32 spell_id) const

uint32	GetPrevSpellInChain (uint32 spell_id) const

uint8	GetSpellRank (uint32 spell_id) const

uint32	GetSpellWithRank (uint32 spell_id, uint32 rank, bool strict=false) const

Acore::IteratorPair< SpellRequiredMap::const_iterator >	GetSpellsRequiredForSpellBounds (uint32 spell_id) const

SpellsRequiringSpellMapBounds	GetSpellsRequiringSpellBounds (uint32 spell_id) const

bool	IsSpellRequiringSpell (uint32 spellid, uint32 req_spellid) const

SpellLearnSkillNode const *	GetSpellLearnSkill (uint32 spell_id) const

std::vector< uint32 >	GetSkillRankSpells (uint32 skillId) const

SpellTargetPosition const *	GetSpellTargetPosition (uint32 spell_id, SpellEffIndex effIndex) const

SpellCone const *	GetSpellCone (uint32 spell_id) const

SpellSpellGroupMapBounds	GetSpellSpellGroupMapBounds (uint32 spell_id) const

bool	IsSpellMemberOfSpellGroup (uint32 spell_id, SpellGroup group_id) const

SpellGroupSpellMapBounds	GetSpellGroupSpellMapBounds (SpellGroup group_id) const

void	GetSetOfSpellsInSpellGroup (SpellGroup group_id, std::set< uint32 > &foundSpells) const

void	GetSetOfSpellsInSpellGroup (SpellGroup group_id, std::set< uint32 > &foundSpells, std::set< SpellGroup > &usedGroups) const

bool	AddSameEffectStackRuleSpellGroups (SpellInfo const *spellInfo, uint32 auraType, int32 amount, std::map< SpellGroup, int32 > &groups) const

SpellGroupStackRule	CheckSpellGroupStackRules (SpellInfo const spellInfo1, SpellInfo const spellInfo2) const

SpellGroupStackRule	GetSpellGroupStackRule (SpellGroup group_id) const

SpellProcEntry const *	GetSpellProcEntry (uint32 spellId) const

bool	CanSpellTriggerProcOnEvent (SpellProcEntry const &procEntry, ProcEventInfo &eventInfo) const

SpellBonusEntry const *	GetSpellBonusData (uint32 spellId) const

SpellThreatEntry const *	GetSpellThreatEntry (uint32 spellID) const

float	GetSpellMixologyBonus (uint32 spellId) const

SkillLineAbilityMapBounds	GetSkillLineAbilityMapBounds (uint32 spell_id) const

PetAura const *	GetPetAura (uint32 spell_id, uint8 eff) const

SpellEnchantProcEntry const *	GetSpellEnchantProcEvent (uint32 enchId) const

bool	IsArenaAllowedEnchancment (uint32 ench_id) const

std::vector< int32 > const *	GetSpellLinked (int32 spell_id) const

PetLevelupSpellSet const *	GetPetLevelupSpellList (uint32 petFamily) const

PetDefaultSpellsEntry const *	GetPetDefaultSpellsEntry (int32 id) const

SpellAreaMapBounds	GetSpellAreaMapBounds (uint32 spell_id) const

SpellAreaForQuestMapBounds	GetSpellAreaForQuestMapBounds (uint32 quest_id) const

SpellAreaForQuestMapBounds	GetSpellAreaForQuestEndMapBounds (uint32 quest_id) const

SpellAreaForAuraMapBounds	GetSpellAreaForAuraMapBounds (uint32 spell_id) const

SpellAreaForAreaMapBounds	GetSpellAreaForAreaMapBounds (uint32 area_id) const

SpellInfo const *	GetSpellInfo (uint32 spellId) const

SpellInfo const *	AssertSpellInfo (uint32 spellId) const

SpellInfo const *	CheckSpellInfo (uint32 spellId) const

uint32	GetSpellInfoStoreSize () const

bool	IsAdditionalTalentSpell (uint32 spellId) const

bool	HasSpellCooldownOverride (uint32 spellId) const

SpellCooldownOverride	GetSpellCooldownOverride (uint32 spellId) const

void	UnloadSpellInfoChains ()

void	LoadSpellTalentRanks ()

void	LoadSpellRanks ()

void	LoadSpellRequired ()

void	LoadSpellLearnSkills ()

void	LoadSpellTargetPositions ()

void	LoadSpellCones ()

void	LoadSpellGroups ()

void	LoadSpellGroupStackRules ()

void	LoadSpellProcs ()

void	LoadSpellBonuses ()

void	LoadSpellThreats ()

void	LoadSpellMixology ()

void	LoadSkillLineAbilityMap ()

void	LoadSpellPetAuras ()

void	LoadEnchantCustomAttr ()

void	LoadSpellEnchantProcData ()

void	LoadSpellLinked ()

void	LoadPetLevelupSpellMap ()

void	LoadPetDefaultSpells ()

void	LoadSpellAreas ()

void	LoadSpellInfoStore ()

void	LoadCreatureImmunities ()

void	LoadSpellCooldownOverrides ()

void	UnloadSpellInfoStore ()

void	UnloadSpellInfoImplicitTargetConditionLists ()

void	LoadSpellInfoCustomAttributes ()

void	LoadSpellInfoImmunities ()

void	LoadSpellInfoCorrections ()

void	LoadSpellSpecificAndAuraState ()

void	LoadSpellJumpDistances ()

Static Public Member Functions
static SpellMgr *	instance ()

static bool	ComputeIsSpellValid (SpellInfo const *spellInfo, bool msg=true)
	Some checks for spells, to prevent adding deprecated/broken spells for trainers, spell book, etc.

static bool	IsSpellValid (SpellInfo const *spellInfo)

static bool	CheckSpellValid (SpellInfo const *spellInfo, uint32 spellId, bool isTalent)

Private Member Functions
	SpellMgr ()

	~SpellMgr ()

SpellInfo *	_GetSpellInfo (uint32 spellId)

Private Attributes
SpellDifficultySearcherMap	mSpellDifficultySearcherMap

SpellChainMap	mSpellChains

SpellsRequiringSpellMap	mSpellsReqSpell

SpellRequiredMap	mSpellReq

SpellLearnSkillMap	mSpellLearnSkills

SpellTargetPositionMap	mSpellTargetPositions

SpellConeMap	mSpellCones

SpellSpellGroupMap	mSpellSpellGroup

SpellGroupSpellMap	mSpellGroupSpell

SpellGroupStackMap	mSpellGroupStack

SameEffectStackMap	mSpellSameEffectStack

SpellProcMap	mSpellProcMap

CreatureImmunitiesMap	mCreatureImmunities

SpellBonusMap	mSpellBonusMap

SpellThreatMap	mSpellThreatMap

SpellMixologyMap	mSpellMixologyMap

SpellPetAuraMap	mSpellPetAuraMap

SpellLinkedMap	mSpellLinkedMap

SpellEnchantProcEventMap	mSpellEnchantProcEventMap

EnchantCustomAttribute	mEnchantCustomAttr

SpellAreaMap	mSpellAreaMap

SpellAreaForQuestMap	mSpellAreaForQuestMap

SpellAreaForQuestMap	mSpellAreaForQuestEndMap

SpellAreaForAuraMap	mSpellAreaForAuraMap

SpellAreaForAreaMap	mSpellAreaForAreaMap

SkillLineAbilityMap	mSkillLineAbilityMap

PetLevelupSpellMap	mPetLevelupSpellMap

PetDefaultSpellsMap	mPetDefaultSpellsMap

SpellInfoMap	mSpellInfoMap

SpellCooldownOverrideMap	mSpellCooldownOverrideMap

TalentAdditionalSet	mTalentSpellAdditionalSet

Detailed Description

Constructor & Destructor Documentation

◆ SpellMgr()

SpellMgr::SpellMgr ( )

private

404{

405}

◆ ~SpellMgr()

SpellMgr::~SpellMgr ( )

private

{
    UnloadSpellInfoStore();
}

References UnloadSpellInfoStore().

Member Function Documentation

◆ _GetSpellInfo()

SpellInfo * SpellMgr::_GetSpellInfo ( uint32 spellId )

inlineprivate

776{ return spellId < GetSpellInfoStoreSize() ? mSpellInfoMap[spellId] : nullptr; }

SpellMgr::GetSpellInfoStoreSize

uint32 GetSpellInfoStoreSize() const

Definition SpellMgr.h:767

SpellMgr::mSpellInfoMap

SpellInfoMap mSpellInfoMap

Definition SpellMgr.h:842

References GetSpellInfoStoreSize(), and mSpellInfoMap.

Referenced by LoadSpellInfoCustomAttributes(), and LoadSpellJumpDistances().

◆ AddSameEffectStackRuleSpellGroups()

bool SpellMgr::AddSameEffectStackRuleSpellGroups	(	SpellInfo const *	spellInfo,
		uint32	auraType,
		int32	amount,
		std::map< SpellGroup, int32 > &	groups
	)		const

{
    uint32 spellId = spellInfo->GetFirstRankSpell()->Id;
    auto spellGroupBounds = GetSpellSpellGroupMapBounds(spellId);
    // Find group with SPELL_GROUP_STACK_RULE_EXCLUSIVE_SAME_EFFECT if it belongs to one
    for (auto itr = spellGroupBounds.first; itr != spellGroupBounds.second; ++itr)
    {
        SpellGroup group = itr->second;
        auto found = mSpellSameEffectStack.find(group);
        if (found != mSpellSameEffectStack.end())
        {
            // check auraTypes
            if (!found->second.count(auraType))
                continue;
 
            // Put the highest amount in the map
            auto groupItr = groups.find(group);
            if (groupItr == groups.end())
                groups.emplace(group, amount);
            else
            {
                int32 curr_amount = groups[group];
                // Take absolute value because this also counts for the highest negative aura
                if (std::abs(curr_amount) < std::abs(amount))
                    groupItr->second = amount;
            }
            // return because a spell should be in only one SPELL_GROUP_STACK_RULE_EXCLUSIVE_SAME_EFFECT group per auraType
            return true;
        }
    }
    // Not in a SPELL_GROUP_STACK_RULE_EXCLUSIVE_SAME_EFFECT group, so return false
    return false;
}

References SpellInfo::GetFirstRankSpell(), GetSpellSpellGroupMapBounds(), SpellInfo::Id, and mSpellSameEffectStack.

◆ AssertSpellInfo()

SpellInfo const * SpellMgr::AssertSpellInfo ( uint32 spellId ) const

inline

    {
        ASSERT(spellId < GetSpellInfoStoreSize());
        SpellInfo const* spellInfo = mSpellInfoMap[spellId];
        ASSERT(spellInfo);
        return spellInfo;
    }

References ASSERT, GetSpellInfoStoreSize(), and mSpellInfoMap.

Referenced by LoadSpellGroupStackRules().

◆ CanSpellTriggerProcOnEvent()

bool SpellMgr::CanSpellTriggerProcOnEvent	(	SpellProcEntry const &	procEntry,
		ProcEventInfo &	eventInfo
	)		const

{
    // proc type doesn't match
    if (!(eventInfo.GetTypeMask() & procEntry.ProcFlags))
        return false;
 
    // check XP or honor target requirement
    if (procEntry.AttributesMask & PROC_ATTR_REQ_EXP_OR_HONOR)
        if (Player* actor = eventInfo.GetActor()->ToPlayer())
            if (eventInfo.GetActionTarget() && !actor->isHonorOrXPTarget(eventInfo.GetActionTarget()))
                return false;
 
    // check mana cost requirement (used by Clearcasting and similar effects)
    if (procEntry.AttributesMask & PROC_ATTR_REQ_MANA_COST)
    {
        SpellInfo const* spellInfo = eventInfo.GetSpellInfo();
        if (!spellInfo || (!spellInfo->ManaCost && !spellInfo->ManaCostPercentage))
            return false;
    }
 
    // always trigger for these types
    if (eventInfo.GetTypeMask() & (PROC_FLAG_KILLED | PROC_FLAG_KILL | PROC_FLAG_DEATH))
        return true;
 
    // check school mask (if set) for other trigger types
    if (procEntry.SchoolMask && !(eventInfo.GetSchoolMask() & procEntry.SchoolMask))
        return false;
 
    // check spell family name/flags (if set) for spells
    if (eventInfo.GetTypeMask() & SPELL_PROC_FLAG_MASK)
        if (SpellInfo const* eventSpellInfo = eventInfo.GetSpellInfo())
            if (!eventSpellInfo->IsAffected(procEntry.SpellFamilyName, procEntry.SpellFamilyMask))
                return false;
 
    // check spell type mask (if set)
    if (eventInfo.GetTypeMask() & (SPELL_PROC_FLAG_MASK | PERIODIC_PROC_FLAG_MASK))
    {
        if (procEntry.SpellTypeMask && !(eventInfo.GetSpellTypeMask() & procEntry.SpellTypeMask))
            return false;
    }
 
    // check spell phase mask
    if (eventInfo.GetTypeMask() & REQ_SPELL_PHASE_PROC_FLAG_MASK)
    {
        if (!(eventInfo.GetSpellPhaseMask() & procEntry.SpellPhaseMask))
            return false;
    }
 
    // check hit mask (on taken hit or on done hit)
    // For CAST phase with DONE flags, only check if HitMask is explicitly set (crit is pre-calculated for travel time spells)
    if ((eventInfo.GetTypeMask() & TAKEN_HIT_PROC_FLAG_MASK) ||
        ((eventInfo.GetTypeMask() & DONE_HIT_PROC_FLAG_MASK) &&
         (!(eventInfo.GetSpellPhaseMask() & PROC_SPELL_PHASE_CAST) || procEntry.HitMask)))
    {
        uint32 hitMask = procEntry.HitMask;
        // get default values if hit mask not set
        if (!hitMask)
        {
            // for taken procs allow normal + critical hits by default
            if (eventInfo.GetTypeMask() & TAKEN_HIT_PROC_FLAG_MASK)
                hitMask |= PROC_HIT_NORMAL | PROC_HIT_CRITICAL;
            // for done procs allow normal + critical + absorbs by default
            else
                hitMask |= PROC_HIT_NORMAL | PROC_HIT_CRITICAL | PROC_HIT_ABSORB;
        }
        if (!(eventInfo.GetHitMask() & hitMask))
            return false;
    }
 
    return true;
}

◆ CheckSpellGroupStackRules()

SpellGroupStackRule SpellMgr::CheckSpellGroupStackRules	(	SpellInfo const *	spellInfo1,
		SpellInfo const *	spellInfo2
	)		const

{
    ASSERT(spellInfo1);
    ASSERT(spellInfo2);
 
    uint32 spell_id1 = spellInfo1->GetFirstRankSpell()->Id;
    uint32 spell_id2 = spellInfo2->GetFirstRankSpell()->Id;
 
    // find SpellGroups which are common for both spells
    SpellSpellGroupMapBounds spellGroup1 = GetSpellSpellGroupMapBounds(spell_id1);
    std::set<SpellGroup> groups;
    for (SpellSpellGroupMap::const_iterator itr = spellGroup1.first; itr != spellGroup1.second; ++itr)
    {
        if (IsSpellMemberOfSpellGroup(spell_id2, itr->second))
        {
            bool add = true;
            SpellGroupSpellMapBounds groupSpell = GetSpellGroupSpellMapBounds(itr->second);
            for (SpellGroupSpellMap::const_iterator itr2 = groupSpell.first; itr2 != groupSpell.second; ++itr2)
            {
                if (itr2->second < 0)
                {
                    SpellGroup currGroup = (SpellGroup)abs(itr2->second);
                    if (IsSpellMemberOfSpellGroup(spell_id1, currGroup) && IsSpellMemberOfSpellGroup(spell_id2, currGroup))
                    {
                        add = false;
                        break;
                    }
                }
            }
            if (add)
                groups.insert(itr->second);
        }
    }
 
    SpellGroupStackRule rule = SPELL_GROUP_STACK_RULE_DEFAULT;
 
    for (std::set<SpellGroup>::iterator itr = groups.begin(); itr!= groups.end(); ++itr)
    {
        SpellGroupStackMap::const_iterator found = mSpellGroupStack.find(*itr);
        if (found != mSpellGroupStack.end())
            rule = found->second;
        if (rule)
            break;
    }
    return rule;
}

References ASSERT, SpellInfo::GetFirstRankSpell(), GetSpellGroupSpellMapBounds(), GetSpellSpellGroupMapBounds(), SpellInfo::Id, IsSpellMemberOfSpellGroup(), mSpellGroupStack, and SPELL_GROUP_STACK_RULE_DEFAULT.

◆ CheckSpellInfo()

SpellInfo const * SpellMgr::CheckSpellInfo ( uint32 spellId ) const

inline

    {
        if (spellId >= GetSpellInfoStoreSize())
        {
            LOG_ERROR("server", "spellId {} is not lower than GetSpellInfoStoreSize() ({})", spellId, GetSpellInfoStoreSize());
            return nullptr;
        }
        SpellInfo const* spellInfo = mSpellInfoMap[spellId];
        if (!spellInfo)
        {
            LOG_ERROR("server", "spellId {} has invalid spellInfo", spellId);
            return nullptr;
        }
        return spellInfo;
    }

References GetSpellInfoStoreSize(), LOG_ERROR, and mSpellInfoMap.

◆ CheckSpellValid()

bool SpellMgr::CheckSpellValid	(	SpellInfo const *	spellInfo,
		uint32	spellId,
		bool	isTalent
	)

static

{
    if (!spellInfo)
    {
        DeleteSpellFromAllPlayers(spellId);
        LOG_ERROR("spells", "Player::{}: Non-existed in SpellStore spell #{} request.", (isTalent ? "AddTalent" : "addSpell"), spellId);
        return false;
    }
 
    if (!IsSpellValid(spellInfo))
    {
        DeleteSpellFromAllPlayers(spellId);
        LOG_ERROR("spells", "Player::{}: Broken spell #{} learning not allowed.", (isTalent ? "AddTalent" : "addSpell"), spellId);
        return false;
    }
 
    return true;
}

References DeleteSpellFromAllPlayers(), IsSpellValid(), and LOG_ERROR.

Referenced by Player::_addSpell(), and Player::addTalent().

◆ ComputeIsSpellValid()

bool SpellMgr::ComputeIsSpellValid	(	SpellInfo const *	spellInfo,
		bool	msg = `true`
	)

static

Some checks for spells, to prevent adding deprecated/broken spells for trainers, spell book, etc.

{
    // not exist
    if (!spellInfo)
        return false;
 
    bool need_check_reagents = false;
 
    // check effects
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        switch (spellInfo->Effects[i].Effect)
        {
            case 0:
                continue;
 
            // craft spell for crafting non-existed item (break client recipes list show)
            case SPELL_EFFECT_CREATE_ITEM:
            case SPELL_EFFECT_CREATE_ITEM_2:
                {
                    if (spellInfo->Effects[i].ItemType == 0)
                    {
                        // skip auto-loot crafting spells, its not need explicit item info (but have special fake items sometime)
                        if (!spellInfo->IsLootCrafting())
                        {
                            if (msg)
                                LOG_ERROR("sql.sql", "Craft spell {} not have create item entry.", spellInfo->Id);
                            return false;
                        }
                    }
                    // also possible IsLootCrafting case but fake item must exist anyway
                    else if (!sObjectMgr->GetItemTemplate(spellInfo->Effects[i].ItemType))
                    {
                        if (msg)
                            LOG_ERROR("sql.sql", "Craft spell {} create not-exist in DB item (Entry: {}) and then...", spellInfo->Id, spellInfo->Effects[i].ItemType);
                        return false;
                    }
 
                    need_check_reagents = true;
                    break;
                }
            case SPELL_EFFECT_LEARN_SPELL:
                {
                    SpellInfo const* spellInfo2 = sSpellMgr->GetSpellInfo(spellInfo->Effects[i].TriggerSpell);
                    if (!ComputeIsSpellValid(spellInfo2, msg))
                    {
                        if (msg)
                            LOG_ERROR("sql.sql", "Spell {} learn to invalid spell {}, and then...", spellInfo->Id, spellInfo->Effects[i].TriggerSpell);
                        return false;
                    }
                    break;
                }
        }
    }
 
    if (need_check_reagents)
    {
        for (uint8 j = 0; j < MAX_SPELL_REAGENTS; ++j)
        {
            if (spellInfo->Reagent[j] > 0 && !sObjectMgr->GetItemTemplate(spellInfo->Reagent[j]))
            {
                if (msg)
                    LOG_ERROR("sql.sql", "Craft spell {} have not-exist reagent in DB item (Entry: {}) and then...", spellInfo->Id, spellInfo->Reagent[j]);
                return false;
            }
        }
    }
 
    return true;
}

References ComputeIsSpellValid(), SpellInfo::Effects, SpellInfo::Id, SpellInfo::IsLootCrafting(), LOG_ERROR, MAX_SPELL_EFFECTS, MAX_SPELL_REAGENTS, SpellInfo::Reagent, sObjectMgr, SPELL_EFFECT_CREATE_ITEM, SPELL_EFFECT_CREATE_ITEM_2, SPELL_EFFECT_LEARN_SPELL, and sSpellMgr.

Referenced by ComputeIsSpellValid(), ObjectMgr::InitializeSpellInfoPrecomputedData(), and ObjectMgr::LoadQuests().

◆ GetCreatureImmunities()

CreatureImmunities const * SpellMgr::GetCreatureImmunities ( int32 creatureImmunitiesId ) const

{
    return Acore::Containers::MapGetValuePtr(mCreatureImmunities, creatureImmunitiesId);
}

References Acore::Containers::MapGetValuePtr(), and mCreatureImmunities.

◆ GetFirstSpellInChain()

uint32 SpellMgr::GetFirstSpellInChain ( uint32 spell_id ) const

{
    if (SpellChainNode const* node = GetSpellChainNode(spell_id))
        return node->first->Id;
 
    return spell_id;
}

References SpellChainNode::first, GetSpellChainNode(), and SpellInfo::Id.

Referenced by GetSpellBonusData(), GetSpellCone(), GetSpellSpellGroupMapBounds(), GetSpellThreatEntry(), LoadSpellCones(), and LoadSpellRequired().

◆ GetLastSpellInChain()

uint32 SpellMgr::GetLastSpellInChain ( uint32 spell_id ) const

{
    if (SpellChainNode const* node = GetSpellChainNode(spell_id))
        return node->last->Id;
 
    return spell_id;
}

References GetSpellChainNode().

◆ GetNextSpellInChain()

uint32 SpellMgr::GetNextSpellInChain ( uint32 spell_id ) const

{
    if (SpellChainNode const* node = GetSpellChainNode(spell_id))
        if (node->next)
            return node->next->Id;
 
    return 0;
}

References GetSpellChainNode().

◆ GetPetAura()

PetAura const * SpellMgr::GetPetAura	(	uint32	spell_id,
		uint8	eff
	)		const

{
    SpellPetAuraMap::const_iterator itr = mSpellPetAuraMap.find((spell_id << 8) + eff);
    if (itr != mSpellPetAuraMap.end())
        return &itr->second;
    else
        return nullptr;
}

References mSpellPetAuraMap.

◆ GetPetDefaultSpellsEntry()

PetDefaultSpellsEntry const * SpellMgr::GetPetDefaultSpellsEntry ( int32 id ) const

{
    PetDefaultSpellsMap::const_iterator itr = mPetDefaultSpellsMap.find(id);
    if (itr != mPetDefaultSpellsMap.end())
        return &itr->second;
    return nullptr;
}

References mPetDefaultSpellsMap.

◆ GetPetLevelupSpellList()

PetLevelupSpellSet const * SpellMgr::GetPetLevelupSpellList ( uint32 petFamily ) const

{
    PetLevelupSpellMap::const_iterator itr = mPetLevelupSpellMap.find(petFamily);
    if (itr != mPetLevelupSpellMap.end())
        return &itr->second;
    else
        return nullptr;
}

References mPetLevelupSpellMap.

◆ GetPrevSpellInChain()

uint32 SpellMgr::GetPrevSpellInChain ( uint32 spell_id ) const

{
    if (SpellChainNode const* node = GetSpellChainNode(spell_id))
        if (node->prev)
            return node->prev->Id;
 
    return 0;
}

References GetSpellChainNode().

◆ GetSetOfSpellsInSpellGroup() [1/2]

void SpellMgr::GetSetOfSpellsInSpellGroup	(	SpellGroup	group_id,
		std::set< uint32 > &	foundSpells
	)		const

{
    std::set<SpellGroup> usedGroups;
    GetSetOfSpellsInSpellGroup(group_id, foundSpells, usedGroups);
}

References GetSetOfSpellsInSpellGroup().

Referenced by GetSetOfSpellsInSpellGroup(), GetSetOfSpellsInSpellGroup(), LoadSpellGroups(), and LoadSpellGroupStackRules().

◆ GetSetOfSpellsInSpellGroup() [2/2]

void SpellMgr::GetSetOfSpellsInSpellGroup	(	SpellGroup	group_id,
		std::set< uint32 > &	foundSpells,
		std::set< SpellGroup > &	usedGroups
	)		const

{
    if (usedGroups.find(group_id) != usedGroups.end())
        return;
    usedGroups.insert(group_id);
 
    SpellGroupSpellMapBounds groupSpell = GetSpellGroupSpellMapBounds(group_id);
    for (SpellGroupSpellMap::const_iterator itr = groupSpell.first; itr != groupSpell.second; ++itr)
    {
        if (itr->second < 0)
        {
            SpellGroup currGroup = (SpellGroup)abs(itr->second);
            GetSetOfSpellsInSpellGroup(currGroup, foundSpells, usedGroups);
        }
        else
        {
            foundSpells.insert(itr->second);
        }
    }
}

References GetSetOfSpellsInSpellGroup(), and GetSpellGroupSpellMapBounds().

◆ GetSkillLineAbilityMapBounds()

SkillLineAbilityMapBounds SpellMgr::GetSkillLineAbilityMapBounds ( uint32 spell_id ) const

{
    return mSkillLineAbilityMap.equal_range(spell_id);
}

References mSkillLineAbilityMap.

◆ GetSkillRankSpells()

std::vector< uint32 > SpellMgr::GetSkillRankSpells ( uint32 skillId ) const

{
    // Returns every spell that grants this skill via SPELL_EFFECT_SKILL,
    // i.e. the profession rank/proficiency spells (Apprentice -> Grand Master),
    // ordered by step. Not strictly limited to the six ranks: any skill-granting
    // spell for the line is included.
    std::vector<uint32> result;
    for (auto const& [spellId, node] : mSpellLearnSkills)
        if (node.skill == skillId)
            result.push_back(spellId);
 
    std::ranges::sort(result, [this](uint32 a, uint32 b)
    {
        return mSpellLearnSkills.at(a).step < mSpellLearnSkills.at(b).step;
    });
    return result;
}

References mSpellLearnSkills.

◆ GetSpellAreaForAreaMapBounds()

SpellAreaForAreaMapBounds SpellMgr::GetSpellAreaForAreaMapBounds ( uint32 area_id ) const

{
    return mSpellAreaForAreaMap.equal_range(area_id);
}

References mSpellAreaForAreaMap.

◆ GetSpellAreaForAuraMapBounds()

SpellAreaForAuraMapBounds SpellMgr::GetSpellAreaForAuraMapBounds ( uint32 spell_id ) const

{
    return mSpellAreaForAuraMap.equal_range(spell_id);
}

References mSpellAreaForAuraMap.

Referenced by LoadSpellAreas().

◆ GetSpellAreaForQuestEndMapBounds()

SpellAreaForQuestMapBounds SpellMgr::GetSpellAreaForQuestEndMapBounds ( uint32 quest_id ) const

{
    return mSpellAreaForQuestEndMap.equal_range(quest_id);
}

References mSpellAreaForQuestEndMap.

◆ GetSpellAreaForQuestMapBounds()

SpellAreaForQuestMapBounds SpellMgr::GetSpellAreaForQuestMapBounds ( uint32 quest_id ) const

{
    return mSpellAreaForQuestMap.equal_range(quest_id);
}

References mSpellAreaForQuestMap.

◆ GetSpellAreaMapBounds()

SpellAreaMapBounds SpellMgr::GetSpellAreaMapBounds ( uint32 spell_id ) const

{
    return mSpellAreaMap.equal_range(spell_id);
}

References mSpellAreaMap.

Referenced by LoadSpellAreas().

◆ GetSpellBonusData()

SpellBonusEntry const * SpellMgr::GetSpellBonusData ( uint32 spellId ) const

{
    // Lookup data
    SpellBonusMap::const_iterator itr = mSpellBonusMap.find(spellId);
    if (itr != mSpellBonusMap.end())
        return &itr->second;
    // Not found, try lookup for 1 spell rank if exist
    if (uint32 rank_1 = GetFirstSpellInChain(spellId))
    {
        SpellBonusMap::const_iterator itr2 = mSpellBonusMap.find(rank_1);
        if (itr2 != mSpellBonusMap.end())
            return &itr2->second;
    }
    return nullptr;
}

References GetFirstSpellInChain(), and mSpellBonusMap.

◆ GetSpellChainNode()

SpellChainNode const * SpellMgr::GetSpellChainNode ( uint32 spell_id ) const

{
    SpellChainMap::const_iterator itr = mSpellChains.find(spell_id);
    if (itr == mSpellChains.end())
        return nullptr;
 
    return &itr->second;
}

References mSpellChains.

Referenced by GetFirstSpellInChain(), GetLastSpellInChain(), GetNextSpellInChain(), GetPrevSpellInChain(), GetSpellRank(), and GetSpellWithRank().

◆ GetSpellCone()

SpellCone const * SpellMgr::GetSpellCone ( uint32 spell_id ) const

{
    spell_id = GetFirstSpellInChain(spell_id);
    auto itr = mSpellCones.find(spell_id);
    if (itr != mSpellCones.end())
        return &itr->second;
 
    return nullptr;
}

References GetFirstSpellInChain(), and mSpellCones.

◆ GetSpellCooldownOverride()

SpellCooldownOverride SpellMgr::GetSpellCooldownOverride ( uint32 spellId ) const

{
    auto range = mSpellCooldownOverrideMap.find(spellId);
    return range->second;
}

References mSpellCooldownOverrideMap.

Referenced by LoadSpellInfoCustomAttributes().

◆ GetSpellDifficultyId()

uint32 SpellMgr::GetSpellDifficultyId ( uint32 spellId ) const

{
    SpellDifficultySearcherMap::const_iterator i = mSpellDifficultySearcherMap.find(spellId);
    return i == mSpellDifficultySearcherMap.end() ? 0 : (*i).second;
}

References mSpellDifficultySearcherMap.

Referenced by GetSpellIdForDifficulty().

◆ GetSpellEnchantProcEvent()

SpellEnchantProcEntry const * SpellMgr::GetSpellEnchantProcEvent ( uint32 enchId ) const

{
    SpellEnchantProcEventMap::const_iterator itr = mSpellEnchantProcEventMap.find(enchId);
    if (itr != mSpellEnchantProcEventMap.end())
        return &itr->second;
    return nullptr;
}

References mSpellEnchantProcEventMap.

◆ GetSpellForDifficultyFromSpell()

SpellInfo const * SpellMgr::GetSpellForDifficultyFromSpell	(	SpellInfo const *	spell,
		WorldObject const *	caster
	)		const

{
    uint32 newSpellId = GetSpellIdForDifficulty(spell->Id, caster);
    SpellInfo const* newSpell = GetSpellInfo(newSpellId);
    if (!newSpell)
    {
        LOG_DEBUG("spells.aura", "SpellMgr::GetSpellForDifficultyFromSpell: spell {} not found. Check spelldifficulty_dbc!", newSpellId);
        return spell;
    }
 
    LOG_DEBUG("spells.aura", "SpellMgr::GetSpellForDifficultyFromSpell: Spell id for instance mode is {} (original {})", newSpell->Id, spell->Id);
    return newSpell;
}

References GetSpellIdForDifficulty(), GetSpellInfo(), SpellInfo::Id, and LOG_DEBUG.

◆ GetSpellGroupSpellMapBounds()

SpellGroupSpellMapBounds SpellMgr::GetSpellGroupSpellMapBounds ( SpellGroup group_id ) const

{
    return mSpellGroupSpell.equal_range(group_id);
}

References mSpellGroupSpell.

Referenced by CheckSpellGroupStackRules(), GetSetOfSpellsInSpellGroup(), and LoadSpellGroupStackRules().

◆ GetSpellGroupStackRule()

SpellGroupStackRule SpellMgr::GetSpellGroupStackRule ( SpellGroup group_id ) const

{
    SpellGroupStackMap::const_iterator itr = mSpellGroupStack.find(group);
    if (itr != mSpellGroupStack.end())
        return itr->second;
 
    return SPELL_GROUP_STACK_RULE_DEFAULT;
}

References mSpellGroupStack, and SPELL_GROUP_STACK_RULE_DEFAULT.

◆ GetSpellIdForDifficulty()

uint32 SpellMgr::GetSpellIdForDifficulty	(	uint32	spellId,
		WorldObject const *	caster
	)		const

{
    if (!GetSpellInfo(spellId))
        return spellId;
 
    if (!caster || !caster->GetMap() || (!caster->GetMap()->IsDungeon() && !caster->GetMap()->IsBattleground()))
        return spellId;
 
    uint32 mode = uint32(caster->GetMap()->GetSpawnMode());
    if (mode >= MAX_DIFFICULTY)
    {
        LOG_ERROR("spells", "SpellMgr::GetSpellIdForDifficulty: Incorrect Difficulty for spell {}.", spellId);
        return spellId; //return source spell
    }
 
    uint32 difficultyId = GetSpellDifficultyId(spellId);
    if (!difficultyId)
        return spellId; //return source spell, it has only REGULAR_DIFFICULTY
 
    SpellDifficultyEntry const* difficultyEntry = sSpellDifficultyStore.LookupEntry(difficultyId);
    if (!difficultyEntry)
    {
        LOG_DEBUG("spells.aura", "SpellMgr::GetSpellIdForDifficulty: SpellDifficultyEntry not found for spell {}. This should never happen.", spellId);
        return spellId; //return source spell
    }
 
    if (difficultyEntry->SpellID[mode] <= 0 && mode > DUNGEON_DIFFICULTY_HEROIC)
    {
        LOG_DEBUG("spells.aura", "SpellMgr::GetSpellIdForDifficulty: spell {} mode {} spell is nullptr, using mode {}", spellId, mode, mode - 2);
        mode -= 2;
    }
 
    if (difficultyEntry->SpellID[mode] <= 0)
    {
        LOG_ERROR("sql.sql", "SpellMgr::GetSpellIdForDifficulty: spell {} mode {} spell is 0. Check spelldifficulty_dbc!", spellId, mode);
        return spellId;
    }
 
    LOG_DEBUG("spells.aura", "SpellMgr::GetSpellIdForDifficulty: spellid for spell {} in mode {} is {}", spellId, mode, difficultyEntry->SpellID[mode]);
    return uint32(difficultyEntry->SpellID[mode]);
}

References DUNGEON_DIFFICULTY_HEROIC, WorldObject::GetMap(), Map::GetSpawnMode(), GetSpellDifficultyId(), GetSpellInfo(), Map::IsBattleground(), Map::IsDungeon(), LOG_DEBUG, LOG_ERROR, MAX_DIFFICULTY, SpellDifficultyEntry::SpellID, and sSpellDifficultyStore.

Referenced by GetSpellForDifficultyFromSpell().

◆ GetSpellInfo()

SpellInfo const * SpellMgr::GetSpellInfo ( uint32 spellId ) const

inline

742{ return spellId < GetSpellInfoStoreSize() ? mSpellInfoMap[spellId] : nullptr; }

References GetSpellInfoStoreSize(), and mSpellInfoMap.

Referenced by GetSpellForDifficultyFromSpell(), GetSpellIdForDifficulty(), LoadEnchantCustomAttr(), LoadPetDefaultSpells(), LoadPetLevelupSpellMap(), LoadSpellAreas(), LoadSpellBonuses(), LoadSpellCones(), LoadSpellGroups(), LoadSpellInfoCorrections(), LoadSpellInfoCustomAttributes(), LoadSpellLearnSkills(), LoadSpellLinked(), LoadSpellMixology(), LoadSpellPetAuras(), LoadSpellProcs(), LoadSpellRanks(), LoadSpellRequired(), LoadSpellTalentRanks(), LoadSpellTargetPositions(), and LoadSpellThreats().

◆ GetSpellInfoStoreSize()

uint32 SpellMgr::GetSpellInfoStoreSize ( ) const

inline

767{ return mSpellInfoMap.size(); }

References mSpellInfoMap.

Referenced by _GetSpellInfo(), AssertSpellInfo(), CheckSpellInfo(), GetSpellInfo(), LoadEnchantCustomAttr(), LoadPetDefaultSpells(), LoadSpellInfoCorrections(), LoadSpellInfoCustomAttributes(), LoadSpellInfoStore(), LoadSpellLearnSkills(), LoadSpellSpecificAndAuraState(), UnloadSpellInfoImplicitTargetConditionLists(), and UnloadSpellInfoStore().

◆ GetSpellLearnSkill()

SpellLearnSkillNode const * SpellMgr::GetSpellLearnSkill ( uint32 spell_id ) const

{
    SpellLearnSkillMap::const_iterator itr = mSpellLearnSkills.find(spell_id);
    if (itr != mSpellLearnSkills.end())
        return &itr->second;
    else
        return nullptr;
}

References mSpellLearnSkills.

◆ GetSpellLinked()

std::vector< int32 > const * SpellMgr::GetSpellLinked ( int32 spell_id ) const

{
    SpellLinkedMap::const_iterator itr = mSpellLinkedMap.find(spell_id);
    return itr != mSpellLinkedMap.end() ? &(itr->second) : nullptr;
}

References mSpellLinkedMap.

◆ GetSpellMixologyBonus()

float SpellMgr::GetSpellMixologyBonus ( uint32 spellId ) const

{
    SpellMixologyMap::const_iterator itr = mSpellMixologyMap.find(spellId);
    if (itr == mSpellMixologyMap.end())
        return 30.0f;
 
    return itr->second;
}

References mSpellMixologyMap.

◆ GetSpellProcEntry()

SpellProcEntry const * SpellMgr::GetSpellProcEntry ( uint32 spellId ) const

{
    SpellProcMap::const_iterator itr = mSpellProcMap.find(spellId);
    if (itr != mSpellProcMap.end())
        return &itr->second;
    return nullptr;
}

References mSpellProcMap.

◆ GetSpellRank()

uint8 SpellMgr::GetSpellRank ( uint32 spell_id ) const

{
    if (SpellChainNode const* node = GetSpellChainNode(spell_id))
        return node->rank;
 
    return 0;
}

References GetSpellChainNode().

◆ GetSpellSpellGroupMapBounds()

SpellSpellGroupMapBounds SpellMgr::GetSpellSpellGroupMapBounds ( uint32 spell_id ) const

{
    spell_id = GetFirstSpellInChain(spell_id);
    return mSpellSpellGroup.equal_range(spell_id);
}

References GetFirstSpellInChain(), and mSpellSpellGroup.

Referenced by AddSameEffectStackRuleSpellGroups(), CheckSpellGroupStackRules(), and IsSpellMemberOfSpellGroup().

◆ GetSpellsRequiredForSpellBounds()

Acore::IteratorPair< SpellRequiredMap::const_iterator > SpellMgr::GetSpellsRequiredForSpellBounds ( uint32 spell_id ) const

{
    return Acore::Containers::MapEqualRange(mSpellReq, spell_id);
}

References Acore::Containers::MapEqualRange(), and mSpellReq.

◆ GetSpellsRequiringSpellBounds()

SpellsRequiringSpellMapBounds SpellMgr::GetSpellsRequiringSpellBounds ( uint32 spell_id ) const

{
    return mSpellsReqSpell.equal_range(spell_id);
}

References mSpellsReqSpell.

Referenced by IsSpellRequiringSpell().

◆ GetSpellTargetPosition()

SpellTargetPosition const * SpellMgr::GetSpellTargetPosition	(	uint32	spell_id,
		SpellEffIndex	effIndex
	)		const

{
    SpellTargetPositionMap::const_iterator itr = mSpellTargetPositions.find(std::make_pair(spell_id, effIndex));
    if (itr != mSpellTargetPositions.end())
        return &itr->second;
    return nullptr;
}

References mSpellTargetPositions.

◆ GetSpellThreatEntry()

SpellThreatEntry const * SpellMgr::GetSpellThreatEntry ( uint32 spellID ) const

{
    SpellThreatMap::const_iterator itr = mSpellThreatMap.find(spellID);
    if (itr != mSpellThreatMap.end())
        return &itr->second;
    else
    {
        uint32 firstSpell = GetFirstSpellInChain(spellID);
        itr = mSpellThreatMap.find(firstSpell);
        if (itr != mSpellThreatMap.end())
            return &itr->second;
    }
    return nullptr;
}

References GetFirstSpellInChain(), and mSpellThreatMap.

◆ GetSpellWithRank()

uint32 SpellMgr::GetSpellWithRank	(	uint32	spell_id,
		uint32	rank,
		bool	strict = `false`
	)		const

{
    if (SpellChainNode const* node = GetSpellChainNode(spell_id))
    {
        if (rank != node->rank)
            return GetSpellWithRank(node->rank < rank ? node->next->Id : node->prev->Id, rank, strict);
    }
    else if (strict && rank > 1)
        return 0;
    return spell_id;
}

References GetSpellChainNode(), and GetSpellWithRank().

Referenced by GetSpellWithRank().

◆ HasSpellCooldownOverride()

bool SpellMgr::HasSpellCooldownOverride ( uint32 spellId ) const

{
    return mSpellCooldownOverrideMap.find(spellId) != mSpellCooldownOverrideMap.end();
}

References mSpellCooldownOverrideMap.

Referenced by LoadSpellInfoCustomAttributes().

◆ instance()

SpellMgr * SpellMgr::instance ( )

static

{
    static SpellMgr instance;
    return &instance;
}

References instance().

Referenced by instance().

◆ IsAdditionalTalentSpell()

bool SpellMgr::IsAdditionalTalentSpell ( uint32 spellId ) const

{
    return mTalentSpellAdditionalSet.find(spellId) != mTalentSpellAdditionalSet.end();
}

References mTalentSpellAdditionalSet.

◆ IsArenaAllowedEnchancment()

bool SpellMgr::IsArenaAllowedEnchancment ( uint32 ench_id ) const

{
    return mEnchantCustomAttr[ench_id];
}

References mEnchantCustomAttr.

◆ IsSpellMemberOfSpellGroup()

bool SpellMgr::IsSpellMemberOfSpellGroup	(	uint32	spell_id,
		SpellGroup	group_id
	)		const

{
    SpellSpellGroupMapBounds spellGroup = GetSpellSpellGroupMapBounds(spell_id);
    for (SpellSpellGroupMap::const_iterator itr = spellGroup.first; itr != spellGroup.second; ++itr)
    {
        if (itr->second == group_id)
            return true;
    }
    return false;
}

References GetSpellSpellGroupMapBounds().

Referenced by CheckSpellGroupStackRules().

◆ IsSpellRequiringSpell()

bool SpellMgr::IsSpellRequiringSpell	(	uint32	spellid,
		uint32	req_spellid
	)		const

{
    SpellsRequiringSpellMapBounds spellsRequiringSpell = GetSpellsRequiringSpellBounds(req_spellid);
    for (SpellsRequiringSpellMap::const_iterator itr = spellsRequiringSpell.first; itr != spellsRequiringSpell.second; ++itr)
    {
        if (itr->second == spellid)
            return true;
    }
    return false;
}

References GetSpellsRequiringSpellBounds().

Referenced by LoadSpellRequired().

◆ IsSpellValid()

bool SpellMgr::IsSpellValid ( SpellInfo const * spellInfo )

static

{
    if (!spellInfo)
        return false;
    return spellInfo->IsSpellValid();
}

References SpellInfo::IsSpellValid().

◆ LoadCreatureImmunities()

void SpellMgr::LoadCreatureImmunities ( )

{
    mCreatureImmunities.clear();
    if (QueryResult result = WorldDatabase.Query("SELECT ID, SchoolMask, DispelTypeMask, MechanicsMask, Effects, Auras, ImmuneAoE, ImmuneChain FROM creature_immunities"))
    {
        do
        {
            Field* fields = result->Fetch();
            int32 id = fields[0].Get<int32>();
            uint8 school = fields[1].Get<uint8>();
            uint16 dispelType = fields[2].Get<uint16>();
            uint64 mechanics = fields[3].Get<uint64>();
            CreatureImmunities& immunities = mCreatureImmunities[id];
            immunities.School = school;
            immunities.DispelType = dispelType;
            immunities.Mechanic = mechanics;
            immunities.ImmuneAoE = fields[6].Get<bool>();
            immunities.ImmuneChain = fields[7].Get<bool>();
            {
                std::string effects = fields[4].Get<std::string>();
                for (std::string_view token : Acore::Tokenize(effects, ',', false))
                {
                    if (Optional<uint32> val = Acore::StringTo<uint32>(token); val && *val < uint32(TOTAL_SPELL_EFFECTS))
                        immunities.Effect.push_back(SpellEffects(*val));
                    else
                        LOG_ERROR("sql.sql", "Invalid effect type in `Effects` {} for creature immunities {}, skipped", token, id);
                }
            }
            {
                std::string auras = fields[5].Get<std::string>();
                for (std::string_view token : Acore::Tokenize(auras, ',', false))
                {
                    if (Optional<uint32> val = Acore::StringTo<uint32>(token); val && *val < TOTAL_AURAS)
                        immunities.Aura.push_back(AuraType(*val));
                    else
                        LOG_ERROR("sql.sql", "Invalid aura type in `Auras` {} for creature immunities {}, skipped", token, id);
                }
            }
        } while (result->NextRow());
    }
}

References Field::Get(), LOG_ERROR, mCreatureImmunities, CreatureImmunities::School, Acore::Tokenize(), TOTAL_AURAS, TOTAL_SPELL_EFFECTS, and WorldDatabase.

Referenced by LoadSpellInfoStore().

◆ LoadEnchantCustomAttr()

void SpellMgr::LoadEnchantCustomAttr ( )

Todo:: : find a better check

{
    uint32 oldMSTime = getMSTime();
 
    uint32 size = sSpellItemEnchantmentStore.GetNumRows();
    mEnchantCustomAttr.resize(size);
 
    for (uint32 i = 0; i < size; ++i)
        mEnchantCustomAttr[i] = 0;
 
    uint32 count = 0;
    for (uint32 i = 0; i < GetSpellInfoStoreSize(); ++i)
    {
        SpellInfo const* spellInfo = GetSpellInfo(i);
        if (!spellInfo)
            continue;
 
        // Xinef: commented second part, fixes warlock enchants like firestone, spellstone
        if (!spellInfo->HasAttribute(SPELL_ATTR2_ENCHANT_OWN_ITEM_ONLY)/* || !spellInfo->HasAttribute(SPELL_ATTR0_NOT_SHAPESHIFTED)*/)
            continue;
 
        for (uint32 j = 0; j < MAX_SPELL_EFFECTS; ++j)
        {
            if (spellInfo->Effects[j].Effect == SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY)
            {
                uint32 enchId = spellInfo->Effects[j].MiscValue;
                SpellItemEnchantmentEntry const* ench = sSpellItemEnchantmentStore.LookupEntry(enchId);
                if (!ench)
                    continue;
                mEnchantCustomAttr[enchId] = true;
                ++count;
                break;
            }
        }
    }
 
    LOG_INFO("server.loading", ">> Loaded {} Custom Enchant Attributes in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References SpellInfo::Effects, getMSTime(), GetMSTimeDiffToNow(), GetSpellInfo(), GetSpellInfoStoreSize(), SpellInfo::HasAttribute(), LOG_INFO, MAX_SPELL_EFFECTS, mEnchantCustomAttr, SPELL_ATTR2_ENCHANT_OWN_ITEM_ONLY, SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY, and sSpellItemEnchantmentStore.

◆ LoadPetDefaultSpells()

void SpellMgr::LoadPetDefaultSpells ( )

{
    uint32 oldMSTime = getMSTime();
 
    mPetDefaultSpellsMap.clear();
 
    uint32 countCreature = 0;
    uint32 countData = 0;
 
    CreatureTemplateContainer const* ctc = sObjectMgr->GetCreatureTemplates();
    for (CreatureTemplateContainer::const_iterator itr = ctc->begin(); itr != ctc->end(); ++itr)
    {
        if (!itr->second.PetSpellDataId)
            continue;
 
        // for creature with PetSpellDataId get default pet spells from dbc
        CreatureSpellDataEntry const* spellDataEntry = sCreatureSpellDataStore.LookupEntry(itr->second.PetSpellDataId);
        if (!spellDataEntry)
            continue;
 
        int32 petSpellsId = -int32(itr->second.PetSpellDataId);
        PetDefaultSpellsEntry petDefSpells;
        for (uint8 j = 0; j < MAX_CREATURE_SPELL_DATA_SLOT; ++j)
            petDefSpells.spellid[j] = spellDataEntry->spellId[j];
 
        if (LoadPetDefaultSpells_helper(&itr->second, petDefSpells))
        {
            mPetDefaultSpellsMap[petSpellsId] = petDefSpells;
            ++countData;
        }
    }
 
    LOG_INFO("server.loading", ">> Loaded Addition Spells For {} Pet Spell Data Entries in {} ms", countData, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
 
    LOG_INFO("server.loading", "Loading Summonable Creature Templates...");
    oldMSTime = getMSTime();
 
    // different summon spells
    for (uint32 i = 0; i < GetSpellInfoStoreSize(); ++i)
    {
        SpellInfo const* spellInfo = GetSpellInfo(i);
        if (!spellInfo)
            continue;
 
        for (uint8 k = 0; k < MAX_SPELL_EFFECTS; ++k)
        {
            if (spellInfo->Effects[k].Effect == SPELL_EFFECT_SUMMON || spellInfo->Effects[k].Effect == SPELL_EFFECT_SUMMON_PET)
            {
                uint32 creature_id = spellInfo->Effects[k].MiscValue;
                CreatureTemplate const* cInfo = sObjectMgr->GetCreatureTemplate(creature_id);
                if (!cInfo)
                    continue;
 
                // already loaded
                if (cInfo->PetSpellDataId)
                    continue;
 
                // for creature without PetSpellDataId get default pet spells from creature_template
                int32 petSpellsId = cInfo->Entry;
                if (mPetDefaultSpellsMap.find(cInfo->Entry) != mPetDefaultSpellsMap.end())
                    continue;
 
                PetDefaultSpellsEntry petDefSpells;
                for (uint8 j = 0; j < MAX_CREATURE_SPELL_DATA_SLOT; ++j)
                    petDefSpells.spellid[j] = cInfo->spells[j];
 
                if (LoadPetDefaultSpells_helper(cInfo, petDefSpells))
                {
                    mPetDefaultSpellsMap[petSpellsId] = petDefSpells;
                    ++countCreature;
                }
            }
        }
    }
 
    LOG_INFO("server.loading", ">> Loaded {} Summonable Creature emplates in {} ms", countCreature, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References SpellInfo::Effects, CreatureTemplate::Entry, getMSTime(), GetMSTimeDiffToNow(), GetSpellInfo(), GetSpellInfoStoreSize(), LoadPetDefaultSpells_helper(), LOG_INFO, MAX_CREATURE_SPELL_DATA_SLOT, MAX_SPELL_EFFECTS, mPetDefaultSpellsMap, CreatureTemplate::PetSpellDataId, sCreatureSpellDataStore, sObjectMgr, SPELL_EFFECT_SUMMON, SPELL_EFFECT_SUMMON_PET, PetDefaultSpellsEntry::spellid, CreatureSpellDataEntry::spellId, and CreatureTemplate::spells.

◆ LoadPetLevelupSpellMap()

void SpellMgr::LoadPetLevelupSpellMap ( )

{
    uint32 oldMSTime = getMSTime();
 
    mPetLevelupSpellMap.clear();                                   // need for reload case
 
    uint32 count = 0;
    uint32 family_count = 0;
 
    for (uint32 i = 0; i < sCreatureFamilyStore.GetNumRows(); ++i)
    {
        CreatureFamilyEntry const* creatureFamily = sCreatureFamilyStore.LookupEntry(i);
        if (!creatureFamily)                                     // not exist
            continue;
 
        for (uint8 j = 0; j < 2; ++j)
        {
            if (!creatureFamily->skillLine[j])
                continue;
 
            for (SkillLineAbilityEntry const* skillLine : GetSkillLineAbilitiesBySkillLine(creatureFamily->skillLine[j]))
            {
                if (skillLine->AcquireMethod != SKILL_LINE_ABILITY_LEARNED_ON_SKILL_LEARN)
                    continue;
 
                SpellInfo const* spell = GetSpellInfo(skillLine->Spell);
                if (!spell) // not exist or triggered or talent
                    continue;
 
                if (!spell->SpellLevel)
                    continue;
 
                PetLevelupSpellSet& spellSet = mPetLevelupSpellMap[creatureFamily->ID];
                if (spellSet.empty())
                    ++family_count;
 
                spellSet.insert(PetLevelupSpellSet::value_type(spell->SpellLevel, spell->Id));
                ++count;
            }
        }
    }
 
    LOG_INFO("server.loading", ">> Loaded {} Pet Levelup And Default Spells For {} Families in {} ms", count, family_count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References getMSTime(), GetMSTimeDiffToNow(), GetSkillLineAbilitiesBySkillLine(), GetSpellInfo(), SpellInfo::Id, CreatureFamilyEntry::ID, LOG_INFO, mPetLevelupSpellMap, sCreatureFamilyStore, SKILL_LINE_ABILITY_LEARNED_ON_SKILL_LEARN, CreatureFamilyEntry::skillLine, and SpellInfo::SpellLevel.

◆ LoadSkillLineAbilityMap()

void SpellMgr::LoadSkillLineAbilityMap ( )

{
    uint32 oldMSTime = getMSTime();
 
    mSkillLineAbilityMap.clear();
 
    uint32 count = 0;
 
    for (uint32 i = 0; i < sSkillLineAbilityStore.GetNumRows(); ++i)
    {
        SkillLineAbilityEntry const* SkillInfo = sSkillLineAbilityStore.LookupEntry(i);
        if (!SkillInfo)
            continue;
 
        mSkillLineAbilityMap.insert(SkillLineAbilityMap::value_type(SkillInfo->Spell, SkillInfo));
        ++count;
    }
 
    LOG_INFO("server.loading", ">> Loaded {} SkillLineAbility MultiMap Data in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References getMSTime(), GetMSTimeDiffToNow(), LOG_INFO, mSkillLineAbilityMap, SkillLineAbilityEntry::Spell, and sSkillLineAbilityStore.

◆ LoadSpellAreas()

void SpellMgr::LoadSpellAreas ( )

{
    uint32 oldMSTime = getMSTime();
 
    mSpellAreaMap.clear();                                  // need for reload case
    mSpellAreaForQuestMap.clear();
    mSpellAreaForQuestEndMap.clear();
    mSpellAreaForAuraMap.clear();
 
    //                                                  0     1         2              3               4                 5          6          7       8         9
    QueryResult result = WorldDatabase.Query("SELECT spell, area, quest_start, quest_start_status, quest_end_status, quest_end, aura_spell, racemask, gender, autocast FROM spell_area");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 spell area requirements. DB table `spell_area` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
 
        uint32 spell = fields[0].Get<uint32>();
        SpellArea spellArea;
        spellArea.spellId             = spell;
        spellArea.areaId              = fields[1].Get<uint32>();
        spellArea.questStart          = fields[2].Get<uint32>();
        spellArea.questStartStatus    = fields[3].Get<uint32>();
        spellArea.questEndStatus      = fields[4].Get<uint32>();
        spellArea.questEnd            = fields[5].Get<uint32>();
        spellArea.auraSpell           = fields[6].Get<int32>();
        spellArea.raceMask            = fields[7].Get<uint32>();
        spellArea.gender              = Gender(fields[8].Get<uint8>());
        spellArea.autocast            = fields[9].Get<bool>();
 
        if (SpellInfo const* spellInfo = GetSpellInfo(spell))
        {
            if (spellArea.autocast)
                const_cast<SpellInfo*>(spellInfo)->Attributes |= SPELL_ATTR0_NO_AURA_CANCEL;
        }
        else
        {
            LOG_ERROR("sql.sql", "Spell {} listed in `spell_area` does not exist", spell);
            continue;
        }
 
        {
            bool ok = true;
            SpellAreaMapBounds sa_bounds = GetSpellAreaMapBounds(spellArea.spellId);
            for (SpellAreaMap::const_iterator itr = sa_bounds.first; itr != sa_bounds.second; ++itr)
            {
                if (spellArea.spellId != itr->second.spellId)
                    continue;
                if (spellArea.areaId != itr->second.areaId)
                    continue;
                if (spellArea.questStart != itr->second.questStart)
                    continue;
                if (spellArea.auraSpell != itr->second.auraSpell)
                    continue;
                if ((spellArea.raceMask & itr->second.raceMask) == 0)
                    continue;
                if (spellArea.gender != itr->second.gender)
                    continue;
 
                // duplicate by requirements
                ok = false;
                break;
            }
 
            if (!ok)
            {
                LOG_ERROR("sql.sql", "Spell {} listed in `spell_area` already listed with similar requirements.", spell);
                continue;
            }
        }
 
        if (spellArea.areaId && !sAreaTableStore.LookupEntry(spellArea.areaId))
        {
            LOG_ERROR("sql.sql", "Spell {} listed in `spell_area` have wrong area ({}) requirement", spell, spellArea.areaId);
            continue;
        }
 
        if (spellArea.questStart && !sObjectMgr->GetQuestTemplate(spellArea.questStart))
        {
            LOG_ERROR("sql.sql", "Spell {} listed in `spell_area` have wrong start quest ({}) requirement", spell, spellArea.questStart);
            continue;
        }
 
        if (spellArea.questEnd)
        {
            if (!sObjectMgr->GetQuestTemplate(spellArea.questEnd))
            {
                LOG_ERROR("sql.sql", "Spell {} listed in `spell_area` have wrong end quest ({}) requirement", spell, spellArea.questEnd);
                continue;
            }
        }
 
        if (spellArea.auraSpell)
        {
            SpellInfo const* spellInfo = GetSpellInfo(std::abs(spellArea.auraSpell));
            if (!spellInfo)
            {
                LOG_ERROR("sql.sql", "Spell {} listed in `spell_area` have wrong aura spell ({}) requirement", spell, std::abs(spellArea.auraSpell));
                continue;
            }
 
            if (uint32(std::abs(spellArea.auraSpell)) == spellArea.spellId)
            {
                LOG_ERROR("sql.sql", "Spell {} listed in `spell_area` have aura spell ({}) requirement for itself", spell, std::abs(spellArea.auraSpell));
                continue;
            }
 
            // not allow autocast chains by auraSpell field (but allow use as alternative if not present)
            if (spellArea.autocast && spellArea.auraSpell > 0)
            {
                bool chain = false;
                SpellAreaForAuraMapBounds saBound = GetSpellAreaForAuraMapBounds(spellArea.spellId);
                for (SpellAreaForAuraMap::const_iterator itr = saBound.first; itr != saBound.second; ++itr)
                {
                    if (itr->second->autocast && itr->second->auraSpell > 0)
                    {
                        chain = true;
                        break;
                    }
                }
 
                if (chain)
                {
                    LOG_ERROR("sql.sql", "Spell {} listed in `spell_area` have aura spell ({}) requirement that itself autocast from aura", spell, spellArea.auraSpell);
                    continue;
                }
 
                SpellAreaMapBounds saBound2 = GetSpellAreaMapBounds(spellArea.auraSpell);
                for (SpellAreaMap::const_iterator itr2 = saBound2.first; itr2 != saBound2.second; ++itr2)
                {
                    if (itr2->second.autocast && itr2->second.auraSpell > 0)
                    {
                        chain = true;
                        break;
                    }
                }
 
                if (chain)
                {
                    LOG_ERROR("sql.sql", "Spell {} listed in `spell_area` have aura spell ({}) requirement that itself autocast from aura", spell, spellArea.auraSpell);
                    continue;
                }
            }
        }
 
        if (spellArea.raceMask && (spellArea.raceMask & sRaceMgr->GetPlayableRaceMask()) == 0)
        {
            LOG_ERROR("sql.sql", "Spell {} listed in `spell_area` have wrong race mask ({}) requirement", spell, spellArea.raceMask);
            continue;
        }
 
        if (spellArea.gender != GENDER_NONE && spellArea.gender != GENDER_FEMALE && spellArea.gender != GENDER_MALE)
        {
            LOG_ERROR("sql.sql", "Spell {} listed in `spell_area` have wrong gender ({}) requirement", spell, spellArea.gender);
            continue;
        }
 
        SpellArea const* sa = &mSpellAreaMap.insert(SpellAreaMap::value_type(spell, spellArea))->second;
 
        // for search by current zone/subzone at zone/subzone change
        if (spellArea.areaId)
            mSpellAreaForAreaMap.insert(SpellAreaForAreaMap::value_type(spellArea.areaId, sa));
 
        // for search at quest start/reward
        if (spellArea.questStart)
            mSpellAreaForQuestMap.insert(SpellAreaForQuestMap::value_type(spellArea.questStart, sa));
 
        // for search at quest start/reward
        if (spellArea.questEnd)
            mSpellAreaForQuestEndMap.insert(SpellAreaForQuestMap::value_type(spellArea.questEnd, sa));
 
        // for search at aura apply
        if (spellArea.auraSpell)
            mSpellAreaForAuraMap.insert(SpellAreaForAuraMap::value_type(std::abs(spellArea.auraSpell), sa));
 
        ++count;
    } while (result->NextRow());
 
    if (sWorld->getIntConfig(CONFIG_ICC_BUFF_HORDE) > 0)
    {
        LOG_INFO("server.loading", ">> Using ICC Buff Horde: {}", sWorld->getIntConfig(CONFIG_ICC_BUFF_HORDE));
        SpellArea spellAreaICCBuffHorde = { sWorld->getIntConfig(CONFIG_ICC_BUFF_HORDE), ICC_AREA, 0, 0, 0, ICC_RACEMASK_HORDE, Gender(2), 64, 11, 1 };
        SpellArea const* saICCBuffHorde = &mSpellAreaMap.insert(SpellAreaMap::value_type(sWorld->getIntConfig(CONFIG_ICC_BUFF_HORDE), spellAreaICCBuffHorde))->second;
        mSpellAreaForAreaMap.insert(SpellAreaForAreaMap::value_type(ICC_AREA, saICCBuffHorde));
        ++count;
    }
    else
        LOG_INFO("server.loading", ">> ICC Buff Horde: disabled");
 
    if (sWorld->getIntConfig(CONFIG_ICC_BUFF_ALLIANCE) > 0)
    {
        LOG_INFO("server.loading", ">> Using ICC Buff Alliance: {}", sWorld->getIntConfig(CONFIG_ICC_BUFF_ALLIANCE));
        SpellArea spellAreaICCBuffAlliance = { sWorld->getIntConfig(CONFIG_ICC_BUFF_ALLIANCE), ICC_AREA, 0, 0, 0, ICC_RACEMASK_ALLIANCE, Gender(2), 64, 11, 1 };
        SpellArea const* saICCBuffAlliance = &mSpellAreaMap.insert(SpellAreaMap::value_type(sWorld->getIntConfig(CONFIG_ICC_BUFF_ALLIANCE), spellAreaICCBuffAlliance))->second;
        mSpellAreaForAreaMap.insert(SpellAreaForAreaMap::value_type(ICC_AREA, saICCBuffAlliance));
        ++count;
    }
    else
        LOG_INFO("server.loading", ">> ICC Buff Alliance: disabled");
 
    LOG_INFO("server.loading", ">> Loaded {} Spell Area Requirements in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References CONFIG_ICC_BUFF_ALLIANCE, CONFIG_ICC_BUFF_HORDE, GENDER_FEMALE, GENDER_MALE, GENDER_NONE, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), GetSpellAreaForAuraMapBounds(), GetSpellAreaMapBounds(), GetSpellInfo(), ICC_AREA, ICC_RACEMASK_ALLIANCE, ICC_RACEMASK_HORDE, LOG_ERROR, LOG_INFO, LOG_WARN, mSpellAreaForAreaMap, mSpellAreaForAuraMap, mSpellAreaForQuestEndMap, mSpellAreaForQuestMap, mSpellAreaMap, sAreaTableStore, sObjectMgr, SPELL_ATTR0_NO_AURA_CANCEL, SpellArea::spellId, sRaceMgr, sWorld, and WorldDatabase.

◆ LoadSpellBonuses()

void SpellMgr::LoadSpellBonuses ( )

{
    uint32 oldMSTime = getMSTime();
 
    mSpellBonusMap.clear();                             // need for reload case
 
    //                                                0      1             2          3         4
    QueryResult result = WorldDatabase.Query("SELECT entry, direct_bonus, dot_bonus, ap_bonus, ap_dot_bonus FROM spell_bonus_data");
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 spell bonus data. DB table `spell_bonus_data` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
        uint32 entry = fields[0].Get<uint32>();
 
        SpellInfo const* spell = GetSpellInfo(entry);
        if (!spell)
        {
            LOG_ERROR("sql.sql", "Spell {} listed in `spell_bonus_data` does not exist", entry);
            continue;
        }
 
        SpellBonusEntry& sbe = mSpellBonusMap[entry];
        sbe.direct_damage = fields[1].Get<float>();
        sbe.dot_damage    = fields[2].Get<float>();
        sbe.ap_bonus      = fields[3].Get<float>();
        sbe.ap_dot_bonus   = fields[4].Get<float>();
 
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} Extra Spell Bonus Data in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References SpellBonusEntry::ap_bonus, SpellBonusEntry::ap_dot_bonus, SpellBonusEntry::direct_damage, SpellBonusEntry::dot_damage, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), GetSpellInfo(), LOG_ERROR, LOG_INFO, LOG_WARN, mSpellBonusMap, and WorldDatabase.

◆ LoadSpellCones()

void SpellMgr::LoadSpellCones ( )

{
    uint32 oldMSTime = getMSTime();
 
    mSpellCones.clear(); // need for reload case
 
    //                                                    0       1
    QueryResult result = WorldDatabase.Query("SELECT ID, ConeDegrees FROM spell_cone");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 spell cone definitions. DB table `spell_cone` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
 
        uint32 spellId = fields[0].Get<uint32>();
        int16 coneDeg = fields[1].Get<int16>();
 
        SpellInfo const* spellInfo = GetSpellInfo(spellId);
        if (!spellInfo)
        {
            LOG_ERROR("sql.sql", "Spell (ID:{}) listed in `spell_cone` does not exist.", spellId);
            continue;
        }
 
        if (coneDeg < -360 || coneDeg > 360)
        {
            LOG_ERROR("sql.sql", "Spell (Id: {}) cone degrees {} out of range (-360..360).", spellId, coneDeg);
            continue;
        }
 
        uint32 firstRankId = GetFirstSpellInChain(spellId);
        SpellInfo const* firstSpellInfo = GetSpellInfo(firstRankId);
 
        SpellInfo const* checkInfo = firstSpellInfo ? firstSpellInfo : spellInfo;
 
        bool hasCone = false;
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (checkInfo->Effects[i].TargetA.GetSelectionCategory() == TARGET_SELECT_CATEGORY_CONE ||
                checkInfo->Effects[i].TargetB.GetSelectionCategory() == TARGET_SELECT_CATEGORY_CONE)
            {
                hasCone = true;
                break;
            }
        }
 
        if (!hasCone)
        {
            LOG_ERROR("sql.sql", "Spell (ID:{}) listed in `spell_cone` does not have a cone implicit target.", spellId);
            continue;
        }
 
        if (firstRankId != spellId)
            LOG_INFO("server.loading", "Spell (ID:{}) listed in `spell_cone` is not first rank; mapping to first rank {}.", spellId, firstRankId);
 
        SpellCone sc{};
        sc.cone_degrees = coneDeg;
 
        // Avoid overwriting an existing first-rank entry with conflicting values
        auto itr = mSpellCones.find(firstRankId);
        if (itr != mSpellCones.end())
        {
            if (itr->second.cone_degrees != sc.cone_degrees)
                LOG_ERROR("sql.sql",
                    "Conflicting `spell_cone` entries for first-rank spell ID {}: {} vs {}. Keeping first value.",
                    firstRankId,
                    itr->second.cone_degrees,
                    sc.cone_degrees);
        }
        else
        {
            mSpellCones[firstRankId] = sc;
            ++count;
        }
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} Spell Cone definitions in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References SpellCone::cone_degrees, SpellInfo::Effects, Field::Get(), GetFirstSpellInChain(), getMSTime(), GetMSTimeDiffToNow(), GetSpellInfo(), LOG_ERROR, LOG_INFO, LOG_WARN, MAX_SPELL_EFFECTS, mSpellCones, TARGET_SELECT_CATEGORY_CONE, and WorldDatabase.

◆ LoadSpellCooldownOverrides()

void SpellMgr::LoadSpellCooldownOverrides ( )

{
    uint32 oldMSTime = getMSTime();
 
    mSpellCooldownOverrideMap.clear();
 
    QueryResult result = WorldDatabase.Query("SELECT Id, RecoveryTime, CategoryRecoveryTime, StartRecoveryTime, StartRecoveryCategory FROM spell_cooldown_overrides");
 
    uint32 count = 0;
 
    if (result)
    {
        do
        {
            Field* fields = result->Fetch();
            SpellCooldownOverride spellCooldown;
            uint32 spellId = fields[0].Get<uint32>();
            spellCooldown.RecoveryTime = fields[1].Get<uint32>();
            spellCooldown.CategoryRecoveryTime = fields[2].Get<uint32>();
            spellCooldown.StartRecoveryTime = fields[3].Get<uint32>();
            spellCooldown.StartRecoveryCategory = fields[4].Get<uint32>();
            mSpellCooldownOverrideMap[spellId] = spellCooldown;
 
            ++count;
        } while (result->NextRow());
    }
 
    LOG_INFO("server.loading", ">> Loaded {} Spell Cooldown Overrides entries in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References SpellCooldownOverride::CategoryRecoveryTime, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_INFO, mSpellCooldownOverrideMap, SpellCooldownOverride::RecoveryTime, SpellCooldownOverride::StartRecoveryCategory, SpellCooldownOverride::StartRecoveryTime, and WorldDatabase.

◆ LoadSpellEnchantProcData()

void SpellMgr::LoadSpellEnchantProcData ( )

{
    uint32 oldMSTime = getMSTime();
 
    mSpellEnchantProcEventMap.clear();                             // need for reload case
 
    //                                                  0         1           2         3          4
    QueryResult result = WorldDatabase.Query("SELECT entry, customChance, PPMChance, procEx, attributeMask FROM spell_enchant_proc_data");
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 spell enchant proc event conditions. DB table `spell_enchant_proc_data` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
 
        uint32 enchantId = fields[0].Get<uint32>();
 
        SpellItemEnchantmentEntry const* ench = sSpellItemEnchantmentStore.LookupEntry(enchantId);
        if (!ench)
        {
            LOG_ERROR("sql.sql", "Enchancment {} listed in `spell_enchant_proc_data` does not exist", enchantId);
            continue;
        }
 
        SpellEnchantProcEntry spe;
 
        spe.customChance = fields[1].Get<uint32>();
        spe.PPMChance = fields[2].Get<float>();
        spe.procEx = fields[3].Get<uint32>();
        spe.attributeMask = fields[4].Get<uint32>();
 
        mSpellEnchantProcEventMap[enchantId] = spe;
 
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} Enchant Proc Data Definitions in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References SpellEnchantProcEntry::attributeMask, SpellEnchantProcEntry::customChance, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, mSpellEnchantProcEventMap, SpellEnchantProcEntry::PPMChance, SpellEnchantProcEntry::procEx, sSpellItemEnchantmentStore, and WorldDatabase.

◆ LoadSpellGroups()

void SpellMgr::LoadSpellGroups ( )

{
    uint32 oldMSTime = getMSTime();
 
    mSpellSpellGroup.clear();                                  // need for reload case
    mSpellGroupSpell.clear();
 
    //                                                    0       1
    QueryResult result = WorldDatabase.Query("SELECT id, spell_id FROM spell_group");
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 spell group definitions. DB table `spell_group` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    std::set<uint32> groups;
    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
 
        uint32 group_id = fields[0].Get<uint32>();
        if (group_id <= SPELL_GROUP_DB_RANGE_MIN && group_id >= SPELL_GROUP_CORE_RANGE_MAX)
        {
            LOG_ERROR("sql.sql", "SpellGroup id {} listed in `spell_group` is in core range, but is not defined in core!", group_id);
            continue;
        }
        int32 spell_id = fields[1].Get<int32>();
 
        groups.insert(group_id);
        mSpellGroupSpell.emplace(SpellGroup(group_id), spell_id);
 
    } while (result->NextRow());
 
    for (auto itr = mSpellGroupSpell.begin(); itr!= mSpellGroupSpell.end();)
    {
        if (itr->second < 0)
        {
            if (groups.find(abs(itr->second)) == groups.end())
            {
                LOG_ERROR("sql.sql", "SpellGroup id {} listed in `spell_group` does not exist", abs(itr->second));
                itr = mSpellGroupSpell.erase(itr);
            }
            else
                ++itr;
        }
        else
        {
            SpellInfo const* spellInfo = GetSpellInfo(itr->second);
            if (!spellInfo)
            {
                LOG_ERROR("sql.sql", "Spell {} listed in `spell_group` does not exist", itr->second);
                itr = mSpellGroupSpell.erase(itr);
            }
            else if (spellInfo->GetRank() > 1)
            {
                LOG_ERROR("sql.sql", "Spell {} listed in `spell_group` is not first rank of spell.", itr->second);
                itr = mSpellGroupSpell.erase(itr);
            }
            else
                ++itr;
        }
    }
 
    for (auto groupItr = groups.begin(); groupItr != groups.end(); ++groupItr)
    {
        std::set<uint32> spells;
        GetSetOfSpellsInSpellGroup(SpellGroup(*groupItr), spells);
 
        for (auto spellItr = spells.begin(); spellItr != spells.end(); ++spellItr)
        {
            ++count;
            mSpellSpellGroup.emplace(*spellItr, SpellGroup(*groupItr));
        }
    }
 
    LOG_INFO("server.loading", ">> Loaded {} spell group Definitions in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References Field::Get(), getMSTime(), GetMSTimeDiffToNow(), SpellInfo::GetRank(), GetSetOfSpellsInSpellGroup(), GetSpellInfo(), LOG_ERROR, LOG_INFO, LOG_WARN, mSpellGroupSpell, mSpellSpellGroup, SPELL_GROUP_CORE_RANGE_MAX, and WorldDatabase.

◆ LoadSpellGroupStackRules()

void SpellMgr::LoadSpellGroupStackRules ( )

{
    uint32 oldMSTime = getMSTime();
 
    mSpellGroupStack.clear();                                  // need for reload case
    mSpellSameEffectStack.clear();
 
    std::vector<uint32> sameEffectGroups;
 
    //                                                       0         1
    QueryResult result = WorldDatabase.Query("SELECT group_id, stack_rule FROM spell_group_stack_rules");
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 spell group stack rules. DB table `spell_group_stack_rules` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
 
        uint32 group_id = fields[0].Get<uint32>();
        uint8 stack_rule = fields[1].Get<int8>();
        if (stack_rule >= SPELL_GROUP_STACK_RULE_MAX)
        {
            LOG_ERROR("sql.sql", "SpellGroupStackRule {} listed in `spell_group_stack_rules` does not exist.", stack_rule);
            continue;
        }
 
        auto bounds = GetSpellGroupSpellMapBounds((SpellGroup)group_id);
        if (bounds.first == bounds.second)
        {
            LOG_ERROR("sql.sql", "SpellGroup id {} listed in `spell_group_stack_rules` does not exist.", group_id);
            continue;
        }
 
        mSpellGroupStack.emplace(SpellGroup(group_id), SpellGroupStackRule(stack_rule));
 
        // different container for same effect stack rules, need to check effect types
        if (stack_rule == SPELL_GROUP_STACK_RULE_EXCLUSIVE_SAME_EFFECT)
            sameEffectGroups.push_back(group_id);
 
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} spell group stack rules in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
 
    count = 0;
    oldMSTime = getMSTime();
 
    for (uint32 group_id : sameEffectGroups)
    {
        std::set<uint32> spellIds;
        GetSetOfSpellsInSpellGroup(SpellGroup(group_id), spellIds);
 
        std::unordered_set<uint32> auraTypes;
 
        // we have to 'guess' what effect this group corresponds to
        {
            std::unordered_multiset<uint32 /*auraName*/> frequencyContainer;
 
            // only waylay for the moment (shared group)
            std::vector<std::vector<uint32 /*auraName*/>> const SubGroups =
            {
                { SPELL_AURA_MOD_MELEE_HASTE, SPELL_AURA_MOD_MELEE_RANGED_HASTE, SPELL_AURA_MOD_RANGED_HASTE }
            };
 
            for (uint32 spellId : spellIds)
            {
                SpellInfo const* spellInfo = AssertSpellInfo(spellId);
                for (SpellEffectInfo const& spellEffectInfo : spellInfo->GetEffects())
                {
                    if (!spellEffectInfo.IsAura())
                        continue;
 
                    uint32 auraName = spellEffectInfo.ApplyAuraName;
                    for (std::vector<uint32> const& subGroup : SubGroups)
                    {
                        if (std::find(subGroup.begin(), subGroup.end(), auraName) != subGroup.end())
                        {
                            // count as first aura
                            auraName = subGroup.front();
                            break;
                        }
                    }
 
                    frequencyContainer.insert(auraName);
                }
            }
 
            uint32 auraType = 0;
            size_t auraTypeCount = 0;
            for (uint32 auraName : frequencyContainer)
            {
                size_t currentCount = frequencyContainer.count(auraName);
                if (currentCount > auraTypeCount)
                {
                    auraType = auraName;
                    auraTypeCount = currentCount;
                }
            }
 
            for (std::vector<uint32> const& subGroup : SubGroups)
            {
                if (auraType == subGroup.front())
                {
                    auraTypes.insert(subGroup.begin(), subGroup.end());
                    break;
                }
            }
 
            if (auraTypes.empty())
                auraTypes.insert(auraType);
        }
 
        // re-check spells against guessed group
        for (uint32 spellId : spellIds)
        {
            SpellInfo const* spellInfo = AssertSpellInfo(spellId);
 
            bool found = false;
            while (spellInfo)
            {
                for (uint32 auraType : auraTypes)
                {
                    if (spellInfo->HasAura(AuraType(auraType)))
                    {
                        found = true;
                        break;
                    }
                }
 
                if (found)
                    break;
 
                spellInfo = spellInfo->GetNextRankSpell();
            }
 
            // not found either, log error
            if (!found)
                LOG_ERROR("sql.sql", "SpellId {} listed in `spell_group` with stack rule 3 does not share aura assigned for group {}", spellId, group_id);
        }
 
        mSpellSameEffectStack[SpellGroup(group_id)] = auraTypes;
        ++count;
    }
 
    LOG_INFO("server.loading", ">> Loaded {} SPELL_GROUP_STACK_RULE_EXCLUSIVE_SAME_EFFECT stack rules in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References AssertSpellInfo(), Field::Get(), SpellInfo::GetEffects(), getMSTime(), GetMSTimeDiffToNow(), SpellInfo::GetNextRankSpell(), GetSetOfSpellsInSpellGroup(), GetSpellGroupSpellMapBounds(), SpellInfo::HasAura(), LOG_ERROR, LOG_INFO, LOG_WARN, mSpellGroupStack, mSpellSameEffectStack, SPELL_AURA_MOD_MELEE_HASTE, SPELL_AURA_MOD_MELEE_RANGED_HASTE, SPELL_AURA_MOD_RANGED_HASTE, SPELL_GROUP_STACK_RULE_EXCLUSIVE_SAME_EFFECT, SPELL_GROUP_STACK_RULE_MAX, and WorldDatabase.

◆ LoadSpellInfoCorrections()

void SpellMgr::LoadSpellInfoCorrections ( )

{
    uint32 oldMSTime = getMSTime();
 
    ApplySpellFix({
        467,    // Thorns (Rank 1)
        782,    // Thorns (Rank 2)
        1075,   // Thorns (Rank 3)
        8914,   // Thorns (Rank 4)
        9756,   // Thorns (Rank 5)
        9910,   // Thorns (Rank 6)
        26992,  // Thorns (Rank 7)
        53307,  // Thorns (Rank 8)
        53352,  // Explosive Shot (trigger)
        50783,  // Slam (Triggered spell)
        20647   // Execute (Triggered spell)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
    });
 
    // Scarlet Raven Priest Image
    ApplySpellFix({ 48763, 48761 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AuraInterruptFlags &= ~AURA_INTERRUPT_FLAG_SPELL_ATTACK;
    });
 
    // Has Brewfest Mug
    ApplySpellFix({ 42533 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(347); // 15 min
    });
 
    // Headless Horseman's Mount - use the flying creature model for the flying variants
    ApplySpellFix({ 48023, 51617 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].MiscValue = 27152;
    });
 
    // Elixir of Minor Fortitude
    ApplySpellFix({ 2378 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ManaCost = 0;
        spellInfo->ManaPerSecond = 0;
    });
 
    // Elixir of Detect Undead
    ApplySpellFix({ 11389 }, [](SpellInfo* spellInfo)
    {
        spellInfo->PowerType = POWER_MANA;
        spellInfo->ManaCost = 0;
        spellInfo->ManaPerSecond = 0;
    });
 
    // Evergrove Druid Transform Crow
    ApplySpellFix({ 38776 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(4); // 120 seconds
    });
 
    ApplySpellFix({
        63026, // Force Cast (HACK: Target shouldn't be changed)
        63137  // Force Cast (HACK: Target shouldn't be changed; summon position should be untied from spell destination)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_DB);
    });
 
    ApplySpellFix({
        53096,  // Quetz'lun's Judgment
        70743,  // AoD Special
        70614   // AoD Special - Vegard
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 1;
    });
 
    // Summon Skeletons
    ApplySpellFix({ 52611, 52612 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].MiscValueB = 64;
    });
 
    ApplySpellFix({
        40244,  // Simon Game Visual
        40245,  // Simon Game Visual
        40246,  // Simon Game Visual
        40247,  // Simon Game Visual
        42835   // Spout, remove damage effect, only anim is needed
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = 0;
    });
 
    ApplySpellFix({
        63665,  // Charge (Argent Tournament emote on riders)
        2895,   // Wrath of Air Totem rank 1 (Aura)
        68933,  // Wrath of Air Totem rank 2 (Aura)
        29200   // Purify Helboar Meat
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(0);
    });
 
    // Howl of Azgalor
    ApplySpellFix({ 31344 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_100_YARDS); // 100yards instead of 50000?!
    });
 
    ApplySpellFix({
        42818,  // Headless Horseman - Wisp Flight Port
        42821   // Headless Horseman - Wisp Flight Missile
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(6); // 100 yards
    });
 
    // Spirit of Kirith
    ApplySpellFix({ 10853 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(3); // 1min
    });
 
    // Headless Horseman - Start Fire
    ApplySpellFix({ 42132 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(6); // 100 yards
    });
 
    //They Must Burn Bomb Aura (self)
    ApplySpellFix({ 36350 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TriggerSpell = 36325; // They Must Burn Bomb Drop (DND)
    });
 
    // Mana Shield (rank 2)
    ApplySpellFix({ 8494 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ProcChance = 0; // because of bug in dbc
    });
 
    ApplySpellFix({
        63320,  // Glyph of Life Tap
        20335,  // Heart of the Crusader
        20336,  // Heart of the Crusader
        20337,  // Heart of the Crusader
        53228,  // Rapid Killing (Rank 1)
        53232,  // Rapid Killing (Rank 2)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_CAN_PROC_FROM_PROCS; // Entries were not updated after spell effect change, we have to do that manually
    });
 
    ApplySpellFix({
        31347,  // Doom
        41635,  // Prayer of Mending
        39365,  // Thundering Storm
        52124,  // Sky Darkener Assault
        42442,  // Vengeance Landing Cannonfire
        45863,  // Cosmetic - Incinerate to Random Target
        25425,  // Shoot
        45761,  // Shoot
        42611,  // Shoot
        61588,  // Blazing Harpoon
        36327   // Shoot Arcane Explosion Arrow
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 1;
    });
 
    // Skartax Purple Beam
    ApplySpellFix({ 36384 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 2;
    });
 
    ApplySpellFix({
        37790,  // Spread Shot
        54172,  // Divine Storm (heal)
        66588  // Flaming Spear
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 3;
    });
 
    // Divine Storm
    ApplySpellFix({ 54171 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 3;
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Divine Storm (Damage)
    ApplySpellFix({ 53385 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 4;
    });
 
    // Spitfire Totem
    ApplySpellFix({ 38296 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 5;
    });
 
    ApplySpellFix({
        40827,  // Sinful Beam
        40859,  // Sinister Beam
        40860,  // Vile Beam
        40861   // Wicked Beam
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 10;
    });
 
    // Unholy Frenzy
    ApplySpellFix({ 50312 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 15;
    });
 
    ApplySpellFix({
        17941,  // Shadow Trance
        22008,  // Netherwind Focus
        31834,  // Light's Grace
        34754,  // Clearcasting
        34936,  // Backlash
        48108,  // Hot Streak
        51124,  // Killing Machine
        54741,  // Firestarter
        64823,  // Item - Druid T8 Balance 4P Bonus
        34477,  // Misdirection
        18820,  // Insight
        57761   // Fireball!
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->ProcCharges = 1;
    });
 
    // Tidal Wave
    ApplySpellFix({ 53390 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ProcCharges = 2;
    });
 
    // Oscillation Field
    ApplySpellFix({ 37408 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_DOT_STACKING_RULE;
    });
 
    // Ascendance (Talisman of Ascendance trinket)
    ApplySpellFix({ 28200 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ProcCharges = 6;
    });
 
    // Crafty's Ultra-Advanced Proto-Typical Shortening Blaster
    ApplySpellFix({ 51912 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Amplitude = 3000;
    });
 
    // Desecration Arm - 36 instead of 37 - typo?
    ApplySpellFix({ 29809 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_7_YARDS);
    });
 
    // Sic'em
    ApplySpellFix({ 42767 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_NEARBY_ENTRY);
    });
 
    // Master Shapeshifter: missing stance data for forms other than bear - bear version has correct data
    // To prevent aura staying on target after talent unlearned
    ApplySpellFix({ 48420 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Stances = 1 << (FORM_CAT - 1);
    });
 
    ApplySpellFix({ 48421 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Stances = 1 << (FORM_MOONKIN - 1);
    });
 
    ApplySpellFix({ 48422 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Stances = 1 << (FORM_TREE - 1);
    });
 
    // Elemental Oath
    ApplySpellFix({ 51466, 51470 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = SPELL_EFFECT_APPLY_AURA;
        spellInfo->Effects[EFFECT_1].ApplyAuraName = SPELL_AURA_ADD_FLAT_MODIFIER;
        spellInfo->Effects[EFFECT_1].MiscValue = SPELLMOD_EFFECT2;
        spellInfo->Effects[EFFECT_1].SpellClassMask = flag96(0x00000000, 0x00004000, 0x00000000);
    });
 
    // Improved Shadowform (Rank 1)
    ApplySpellFix({ 47569 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes &= ~SPELL_ATTR0_NOT_SHAPESHIFTED;   // with this spell atrribute aura can be stacked several times
    });
 
    // Natural shapeshifter
    ApplySpellFix({ 16834, 16835 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(21);
    });
 
    // Ebon Plague
    ApplySpellFix({ 51735, 51734, 51726 }, [](SpellInfo* spellInfo)
    {
        spellInfo->SpellFamilyFlags[2] = 0x10;
        spellInfo->Effects[EFFECT_1].ApplyAuraName = SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_DOT_STACKING_RULE;
    });
 
    // Parasitic Shadowfiend Passive
    ApplySpellFix({ 41013 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_DUMMY;   // proc debuff, and summon infinite fiends
    });
 
    ApplySpellFix({
        27892,  // To Anchor 1
        27928,  // To Anchor 1
        27935,  // To Anchor 1
    }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_10_YARDS);
    });
 
    // Wrath of the Plaguebringer
    ApplySpellFix({ 29214, 54836 }, [](SpellInfo* spellInfo)
    {
        // target allys instead of enemies, target A is src_caster, spells with effect like that have ally target
        // this is the only known exception, probably just wrong data
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ALLY);
        spellInfo->Effects[EFFECT_1].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ALLY);
    });
 
    // Wind Shear
    ApplySpellFix({ 57994 }, [](SpellInfo* spellInfo)
    {
        // improper data for EFFECT_1 in 3.3.5 DBC, but is correct in 4.x
        spellInfo->Effects[EFFECT_1].Effect = SPELL_EFFECT_MODIFY_THREAT_PERCENT;
        spellInfo->Effects[EFFECT_1].BasePoints = -6; // -5%
    });
 
    // Improved Devouring Plague
    ApplySpellFix({ 63675 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BonusMultiplier = 0;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_IGNORE_CASTER_MODIFIERS;
    });
 
    ApplySpellFix({
        8145,   // Tremor Totem (instant pulse)
        6474    // Earthbind Totem (instant pulse)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx5 |= SPELL_ATTR5_EXTRA_INITIAL_PERIOD;
    });
 
    // Marked for Death
    ApplySpellFix({ 53241, 53243, 53244, 53245, 53246 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].SpellClassMask = flag96(399361, 276955137, 1);
    });
 
    ApplySpellFix({
        70728,  // Exploit Weakness
        70840   // Devious Minds
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_PET);
    });
 
    // Culling The Herd
    ApplySpellFix({ 70893 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_MASTER);
    });
 
    // Sigil of the Frozen Conscience
    ApplySpellFix({ 54800 }, [](SpellInfo* spellInfo)
    {
        // change class mask to custom extended flags of Icy Touch
        // this is done because another spell also uses the same SpellFamilyFlags as Icy Touch
        // SpellFamilyFlags[0] & 0x00000040 in SPELLFAMILY_DEATHKNIGHT is currently unused (3.3.5a)
        // this needs research on modifier applying rules, does not seem to be in Attributes fields
        spellInfo->Effects[EFFECT_0].SpellClassMask = flag96(0x00000040, 0x00000000, 0x00000000);
    });
 
    // Idol of the Flourishing Life
    ApplySpellFix({ 64949 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].SpellClassMask = flag96(0x00000000, 0x02000000, 0x00000000);
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_ADD_FLAT_MODIFIER;
    });
 
    ApplySpellFix({
        34231,  // Libram of the Lightbringer
        60792,  // Libram of Tolerance
        64956   // Libram of the Resolute
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].SpellClassMask = flag96(0x80000000, 0x00000000, 0x00000000);
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_ADD_FLAT_MODIFIER;
    });
 
    ApplySpellFix({
        28851,  // Libram of Light
        28853,  // Libram of Divinity
        32403   // Blessed Book of Nagrand
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].SpellClassMask = flag96(0x40000000, 0x00000000, 0x00000000);
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_ADD_FLAT_MODIFIER;
    });
 
    // Ride Carpet
    ApplySpellFix({ 45602 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = 0; // force seat 0, vehicle doesn't have the required seat flags for "no seat specified (-1)"
    });
 
    ApplySpellFix({
        64745,  // Item - Death Knight T8 Tank 4P Bonus
        64936   // Item - Warrior T8 Protection 4P Bonus
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = 100; // 100% chance of procc'ing, not -10% (chance calculated in PrepareTriggersExecutedOnHit)
    });
 
    // Easter Lay Noblegarden Egg Aura
    ApplySpellFix({ 61719 }, [](SpellInfo* spellInfo)
    {
        // Interrupt flags copied from aura which this aura is linked with
        spellInfo->AuraInterruptFlags = AURA_INTERRUPT_FLAG_HITBYSPELL | AURA_INTERRUPT_FLAG_TAKE_DAMAGE;
    });
 
    // Bleh, need to change FamilyFlags :/ (have the same as original aura - bad!)
    ApplySpellFix({ 63510 }, [](SpellInfo* spellInfo)
    {
        spellInfo->SpellFamilyFlags[EFFECT_0] = 0;
        spellInfo->SpellFamilyFlags[EFFECT_2] = 0x4000000;
    });
 
    ApplySpellFix({ 63514 }, [](SpellInfo* spellInfo)
    {
        spellInfo->SpellFamilyFlags[EFFECT_0] = 0;
        spellInfo->SpellFamilyFlags[EFFECT_2] = 0x2000000;
    });
 
    ApplySpellFix({ 63531 }, [](SpellInfo* spellInfo)
    {
        spellInfo->SpellFamilyFlags[EFFECT_0] = 0;
        spellInfo->SpellFamilyFlags[EFFECT_2] = 0x8000000;
    });
 
    // And affecting spells
    ApplySpellFix({
        20138,  // Improved Devotion Aura
        20139,
        20140
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].SpellClassMask[0] = 0;
        spellInfo->Effects[EFFECT_1].SpellClassMask[2] = 0x2000000;
    });
 
    ApplySpellFix({
        20254,  // Improved concentration aura
        20255,
        20256
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].SpellClassMask[0] = 0;
        spellInfo->Effects[EFFECT_1].SpellClassMask[2] = 0x4000000;
        spellInfo->Effects[EFFECT_2].SpellClassMask[0] = 0;
        spellInfo->Effects[EFFECT_2].SpellClassMask[2] = 0x4000000;
    });
 
    ApplySpellFix({
        53379,  // Swift Retribution
        53484,
        53648
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].SpellClassMask[0] = 0;
        spellInfo->Effects[EFFECT_0].SpellClassMask[2] = 0x8000000;
    });
 
    // Sanctified Retribution
    ApplySpellFix({ 31869 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].SpellClassMask[0] = 0;
        spellInfo->Effects[EFFECT_0].SpellClassMask[2] = 0x8000000;
    });
 
    // Seal of Light trigger
    ApplySpellFix({ 20167 }, [](SpellInfo* spellInfo)
    {
        spellInfo->SpellLevel = 0;
        spellInfo->BaseLevel = 0;
        spellInfo->DmgClass = SPELL_DAMAGE_CLASS_MAGIC;
    });
 
    // Hand of Reckoning
    ApplySpellFix({ 62124 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx |= SPELL_ATTR1_NO_REDIRECTION;
    });
 
    // Redemption
    ApplySpellFix({ 7328, 10322, 10324, 20772, 20773, 48949, 48950 }, [](SpellInfo* spellInfo)
    {
        spellInfo->SpellFamilyName = SPELLFAMILY_PALADIN;
    });
 
    ApplySpellFix({
        20184,  // Judgement of Justice
        20185,  // Judgement of Light
        20186,  // Judgement of Wisdom
        20267,  // Judgement of Light (triggered heal on attacker)
        20268,  // Judgement of Wisdom (triggered mana on attacker)
        68055   // Judgements of the Just
        }, [](SpellInfo* spellInfo)
    {
        // hack for seal of light and few spells, judgement consists of few single casts and each of them can proc
        // some spell, base one has disabled proc flag but those dont have this flag
        // 20267/20268 are passive proc effects from the judgement debuff; they must not cause the paladin's
        // on-heal/on-cast procs (e.g. Soul Preserver, which has CAN_PROC_FROM_PROCS) to fire
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_CASTER_PROCS;
    });
 
    ApplySpellFix({
        6940, // Hand of Sacrifice
        64205 // Divine Sacrifice
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx7 |= SPELL_ATTR7_DONT_CAUSE_SPELL_PUSHBACK;
    });
 
    // Seal of Command trigger
    ApplySpellFix({ 20424 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 &= ~SPELL_ATTR3_SUPPRESS_CASTER_PROCS;
    });
 
    // Vindication
    ApplySpellFix({ 67, 26017}, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].MiscValue = 0;
    });
 
    // Arcane Missiles
    ApplySpellFix({ 5143, 5144, 5145, 8416, 8417, 10211, 10212, 25345, 27075, 38699, 38704, 42843, 42846 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    // Glyph of Holy Light
    ApplySpellFix({ 54968 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_IGNORE_CASTER_MODIFIERS;
        spellInfo->DmgClass = SPELL_DAMAGE_CLASS_MAGIC;
    });
 
    // Beacon of Light
    ApplySpellFix({ 53652, 53653, 53654 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_IGNORE_CASTER_MODIFIERS;
        spellInfo->AttributesEx6 &= ~SPELL_ATTR6_IGNORE_HEALTH_MODIFIERS;
        spellInfo->DmgClass = SPELL_DAMAGE_CLASS_MAGIC;
    });
 
    // Wild Hunt
    ApplySpellFix({ 62758, 62762 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_APPLY_AURA;
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_DUMMY;
        spellInfo->Effects[EFFECT_1].Effect = SPELL_EFFECT_APPLY_AURA;
        spellInfo->Effects[EFFECT_1].ApplyAuraName = SPELL_AURA_DUMMY;
    });
 
    // Intervene
    ApplySpellFix({ 3411 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_CANCELS_AUTO_ATTACK_COMBAT;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    // Roar of Sacrifice
    ApplySpellFix({ 53480 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = SPELL_EFFECT_APPLY_AURA;
        spellInfo->Effects[EFFECT_1].ApplyAuraName = SPELL_AURA_SPLIT_DAMAGE_PCT;
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ALLY);
        spellInfo->Effects[EFFECT_1].DieSides = 1;
        spellInfo->Effects[EFFECT_1].BasePoints = 19;
        spellInfo->Effects[EFFECT_1].BasePoints = 127; // all schools
    });
 
    // Silencing Shot
    ApplySpellFix({ 34490, 41084, 42671 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Speed = 0.0f;
    });
 
    // Monstrous Bite
    ApplySpellFix({ 54680, 55495, 55496, 55497, 55498, 55499 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
    });
 
    // Hunter's Mark
    ApplySpellFix({ 1130, 14323, 14324, 14325, 53338 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DmgClass = SPELL_DAMAGE_CLASS_MAGIC;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
    });
 
    // Explosive Trap Effect
    ApplySpellFix({
        13812, // Explosive Trap Effect (Rank 1)
        14314, // Explosive Trap Effect (Rank 2)
        14315, // Explosive Trap Effect (Rank 3)
        27026, // Explosive Trap Effect (Rank 4)
        49064, // Explosive Trap Effect (Rank 5)
        49065  // Explosive Trap Effect (Rank 6)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->DmgClass = SPELL_DAMAGE_CLASS_MAGIC;
    });
 
    // Kill Command
    // Kill Command, Overpower
    ApplySpellFix({ 34027, 37529 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ProcCharges = 0;
    });
 
    // Kindred Spirits, damage aura
    ApplySpellFix({ 57458 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx4 |= SPELL_ATTR4_ALLOW_ENETRING_ARENA;
    });
 
    // Chimera Shot - Serpent trigger
    ApplySpellFix({ 53353 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_IGNORE_CASTER_MODIFIERS;
    });
 
    // Entrapment trigger
    ApplySpellFix({ 19185, 64803, 64804 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_TARGET_ENEMY);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_DEST_AREA_ENEMY);
        spellInfo->AttributesEx5 |= SPELL_ATTR5_ALWAYS_AOE_LINE_OF_SIGHT;
    });
 
    // Improved Stings (Rank 2)
    ApplySpellFix({ 19465 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
    });
 
    // Heart of the Phoenix (triggered)
    ApplySpellFix({ 54114 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx &= ~SPELL_ATTR1_DISMISS_PET_FIRST;
        spellInfo->RecoveryTime = 8 * 60 * IN_MILLISECONDS; // prev 600000
    });
 
    // Master of Subtlety
    ApplySpellFix({ 31221, 31222, 31223 }, [](SpellInfo* spellInfo)
    {
        spellInfo->SpellFamilyName = SPELLFAMILY_ROGUE;
    });
 
    ApplySpellFix({
        31666,  // Master of Subtlety triggers
        58428   // Overkill
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_SCRIPT_EFFECT;
    });
 
    ApplySpellFix({
        5171,   // Slice and Dice
        6774    // Slice and Dice
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    // Envenom
    ApplySpellFix({ 32645, 32684, 57992, 57993 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Dispel = DISPEL_NONE;
    });
 
    ApplySpellFix({
        64014,  // Expedition Base Camp Teleport
        64032,  // Formation Grounds Teleport
        64028,  // Colossal Forge Teleport
        64031,  // Scrapyard Teleport
        64030,  // Antechamber Teleport
        64029,  // Shattered Walkway Teleport
        64024,  // Conservatory Teleport
        64025,  // Halls of Invention Teleport
        65042   // Prison of Yogg-Saron Teleport
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].TargetB = SpellImplicitTargetInfo(TARGET_DEST_DB);
    });
 
    // Killing Spree (teleport)
    ApplySpellFix({ 57840 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(6); // 100 yards
    });
 
    // Killing Spree
    ApplySpellFix({ 51690 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx |= SPELL_ATTR1_ALLOW_WHILE_STEALTHED;
    });
 
    // Blood Tap visual cd reset
    ApplySpellFix({ 47804 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].Effect = 0;
        spellInfo->Effects[EFFECT_1].Effect = 0;
        spellInfo->RuneCostID = 442;
    });
 
    // Chains of Ice
    ApplySpellFix({ 45524 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].Effect = 0;
    });
 
    // Impurity
    ApplySpellFix({ 49220, 49633, 49635, 49636, 49638 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_APPLY_AURA;
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_DUMMY;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
        spellInfo->SpellFamilyName = SPELLFAMILY_DEATHKNIGHT;
    });
 
    // Deadly Aggression (Deadly Gladiator's Death Knight Relic, item: 42620)
    ApplySpellFix({ 60549 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = 0;
    });
 
    // Magic Suppression
    ApplySpellFix({ 49224, 49610, 49611 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ProcCharges = 0;
    });
 
    // Wandering Plague
    ApplySpellFix({ 50526 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_IGNORE_CASTER_MODIFIERS;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    // Dancing Rune Weapon
    ApplySpellFix({ 49028 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].Effect = 0;
        spellInfo->ProcFlags |= PROC_FLAG_DONE_MELEE_AUTO_ATTACK;
    });
 
    // Death and Decay
    ApplySpellFix({ 52212 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
        spellInfo->AttributesEx6 |= SPELL_ATTR6_IGNORE_PHASE_SHIFT;
    });
 
    // T9 blood plague crit bonus
    ApplySpellFix({ 67118 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = 0;
    });
 
    // Pestilence
    ApplySpellFix({ 50842 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].TargetA = TARGET_DEST_TARGET_ENEMY;
    });
 
    // Horn of Winter, stacking issues
    ApplySpellFix({ 57330, 57623 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].TargetA = 0;
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Scourge Strike trigger
    ApplySpellFix({ 70890 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_CASTER_PROCS;
    });
 
    // Blood-caked Blade - Blood-caked Strike trigger
    ApplySpellFix({ 50463 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_CASTER_PROCS;
    });
 
    // Blood Gorged
    ApplySpellFix({ 61274, 61275, 61276, 61277,61278 }, [](SpellInfo* spellInfo)
    {
        // ARP affect Death Strike and Rune Strike
        spellInfo->Effects[EFFECT_0].SpellClassMask = flag96(0x1400011, 0x20000000, 0x0);
    });
 
    // Death Grip
    ApplySpellFix({ 49576, 49560 }, [](SpellInfo* spellInfo)
    {
        // remove main grip mechanic, leave only effect one
        //  should fix taunt on bosses and not break the pull protection at the same time (no aura provides immunity to grip mechanic)
        spellInfo->Mechanic = 0;
    });
 
    // Death Grip Jump Dest
    ApplySpellFix({ 57604 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Death Pact
    ApplySpellFix({ 48743 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx &= ~SPELL_ATTR1_EXCLUDE_CASTER;
    });
 
    // Raise Ally (trigger)
    ApplySpellFix({ 46619 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes &= ~SPELL_ATTR0_NO_AURA_CANCEL;
    });
 
    // Frost Strike
    ApplySpellFix({ 49143, 51416, 51417, 51418, 51419, 55268 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_COMPLETELY_BLOCKED;
    });
 
    // Death Knight T10 Tank 2p Bonus
    ApplySpellFix({ 70650 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_ADD_PCT_MODIFIER;
    });
 
    ApplySpellFix({ 45297, 45284 }, [](SpellInfo* spellInfo)
    {
        spellInfo->CategoryRecoveryTime = 0;
        spellInfo->RecoveryTime = 0;
        spellInfo->AttributesEx6 |= SPELL_ATTR6_IGNORE_CASTER_DAMAGE_MODIFIERS;
    });
 
    // Improved Earth Shield
    ApplySpellFix({ 51560, 51561 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].MiscValue = SPELLMOD_DAMAGE;
    });
 
    // Tidal Force
    ApplySpellFix({ 55166, 55198 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(18);
        spellInfo->ProcCharges = 0;
    });
 
    // Healing Stream Totem
    ApplySpellFix({ 52042 }, [](SpellInfo* spellInfo)
    {
        spellInfo->SpellLevel = 0;
        spellInfo->BaseLevel = 0;
        spellInfo->DmgClass = SPELL_DAMAGE_CLASS_MAGIC;
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(5); // 40yd
    });
 
    // Earth Shield
    ApplySpellFix({ 379 }, [](SpellInfo* spellInfo)
    {
        spellInfo->SpellLevel = 0;
        spellInfo->BaseLevel = 0;
        spellInfo->DmgClass = SPELL_DAMAGE_CLASS_MAGIC;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_IGNORE_CASTER_MODIFIERS;
    });
 
    // Stormstrike
    ApplySpellFix({ 17364 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_DOT_STACKING_RULE;
    });
 
    // Strength of Earth totem effect
    ApplySpellFix({ 8076, 8162, 8163, 10441, 25362, 25527, 57621, 58646 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].RadiusEntry = spellInfo->Effects[EFFECT_0].RadiusEntry;
        spellInfo->Effects[EFFECT_2].RadiusEntry = spellInfo->Effects[EFFECT_0].RadiusEntry;
    });
 
    // Flametongue Totem effect
    ApplySpellFix({ 52109, 52110, 52111, 52112, 52113, 58651, 58654, 58655 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].TargetB = spellInfo->Effects[EFFECT_1].TargetB = spellInfo->Effects[EFFECT_0].TargetB = 0;
        spellInfo->Effects[EFFECT_2].TargetA = spellInfo->Effects[EFFECT_1].TargetA = spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
    });
 
    // Sentry Totem
    ApplySpellFix({ 6495 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(0);
    });
 
    // Bind Sight (PT)
    ApplySpellFix({ 6277 }, [](SpellInfo* spellInfo)
    {
        // because it is passive, needs this to be properly removed at death in RemoveAllAurasOnDeath()
        spellInfo->AttributesEx &= ~SPELL_ATTR1_IS_CHANNELED;
        spellInfo->Attributes |= SPELL_ATTR0_PASSIVE;
        spellInfo->AttributesEx7 |= SPELL_ATTR7_DISABLE_AURA_WHILE_DEAD;
    });
 
    // Ancestral Awakening Heal
    ApplySpellFix({ 52752 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_IGNORE_CASTER_MODIFIERS;
    });
 
    // Heroism
    ApplySpellFix({ 32182 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ExcludeTargetAuraSpell = 57723; // Exhaustion
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Bloodlust
    ApplySpellFix({ 2825 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ExcludeTargetAuraSpell = 57724; // Sated
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Improved Succubus
    ApplySpellFix({ 18754, 18755, 18756 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
    });
 
    // Unstable Affliction
    ApplySpellFix({ 31117 }, [](SpellInfo* spellInfo)
    {
        spellInfo->PreventionType = SPELL_PREVENTION_TYPE_NONE;
    });
 
    // Shadowflame - trigger
    ApplySpellFix({
        47960,  // r1
        61291   // r2
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx |= SPELL_ATTR1_NO_REDIRECTION;
    });
 
    // Curse of Doom
    ApplySpellFix({ 18662 }, [](SpellInfo* spellInfo)
    {
        // summoned doomguard duration fix
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(6);
    });
 
    // Everlasting Affliction
    ApplySpellFix({ 47201, 47202, 47203, 47204, 47205 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].SpellClassMask[0] |= 2; // add corruption to affected spells
    });
 
    // Death's Embrace
    ApplySpellFix({ 47198, 47199, 47200 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].SpellClassMask[0] |= 0x4000; // include Drain Soul
    });
 
    // Improved Demonic Tactics
    ApplySpellFix({ 54347, 54348, 54349 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = spellInfo->Effects[EFFECT_0].Effect;
        spellInfo->Effects[EFFECT_1].ApplyAuraName = spellInfo->Effects[EFFECT_0].ApplyAuraName;
        spellInfo->Effects[EFFECT_1].TargetA = spellInfo->Effects[EFFECT_0].TargetA;
        spellInfo->Effects[EFFECT_0].MiscValue = SPELLMOD_EFFECT1;
        spellInfo->Effects[EFFECT_1].MiscValue = SPELLMOD_EFFECT2;
    });
 
    // Rain of Fire (Doomguard)
    ApplySpellFix({ 42227 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Speed = 0.0f;
    });
 
    // Ritual Enslavement
    ApplySpellFix({ 22987 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_MOD_CHARM;
    });
 
    // Combustion, make this passive
    ApplySpellFix({ 11129 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Dispel = DISPEL_NONE;
    });
 
    // Magic Absorption
    ApplySpellFix({ 29441, 29444 }, [](SpellInfo* spellInfo)
    {
        spellInfo->SpellLevel = 0;
    });
 
    // Living Bomb
    ApplySpellFix({ 44461, 55361, 55362 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
        spellInfo->AttributesEx4 |= SPELL_ATTR4_DAMAGE_DOESNT_BREAK_AURAS;
        // Explosion is AoE triggered on aura expiry - cannot be reflected (retail: Spell Reflection only works on single-target spells)
        spellInfo->AttributesEx |= SPELL_ATTR1_NO_REFLECTION;
    });
 
    // Evocation
    ApplySpellFix({ 12051 }, [](SpellInfo* spellInfo)
    {
        spellInfo->InterruptFlags |= SPELL_INTERRUPT_FLAG_INTERRUPT;
    });
 
    // MI Fireblast, WE Frostbolt, MI Frostbolt
    ApplySpellFix({ 59637, 31707, 72898 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DmgClass = SPELL_DAMAGE_CLASS_MAGIC;
    });
 
    // Blazing Speed
    ApplySpellFix({ 31641, 31642 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TriggerSpell = 31643;
    });
 
    // Summon Water Elemental (permanent)
    ApplySpellFix({ 70908 }, [](SpellInfo* spellInfo)
    {
        // treat it as pet
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_SUMMON_PET;
    });
 
    // // Burnout, trigger
    ApplySpellFix({ 44450 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_POWER_BURN;
    });
 
    // Mirror Image - Summon Spells
    ApplySpellFix({ 58831, 58833, 58834, 65047 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_CASTER);
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(0);
    });
 
    // Initialize Images (Mirror Image)
    ApplySpellFix({ 58836 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
    });
 
    // Arcane Blast, can't be dispelled
    ApplySpellFix({ 36032 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_NO_IMMUNITIES;
    });
 
    // Chilled (frost armor, ice armor proc)
    ApplySpellFix({ 6136, 7321 }, [](SpellInfo* spellInfo)
    {
        spellInfo->PreventionType = SPELL_PREVENTION_TYPE_NONE;
    });
 
    // Mirror Image Frostbolt
    ApplySpellFix({ 59638 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DmgClass = SPELL_DAMAGE_CLASS_MAGIC;
        spellInfo->SpellFamilyName = SPELLFAMILY_MAGE;
        spellInfo->SpellFamilyFlags = flag96(0x20, 0x0, 0x0);
    });
 
    // Fingers of Frost
    ApplySpellFix({ 44544 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Dispel = DISPEL_NONE;
        spellInfo->AttributesEx4 |= SPELL_ATTR4_CANNOT_BE_STOLEN;
        spellInfo->Effects[EFFECT_0].SpellClassMask = flag96(685904631, 1151040, 32);
    });
 
    // Fingers of Frost visual buff
    ApplySpellFix({ 74396 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ProcCharges = 2;
        spellInfo->StackAmount = 0;
    });
 
    // Glyph of blocking
    ApplySpellFix({ 58375 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TriggerSpell = 58374;
    });
 
    // Sweeping Strikes stance change
    ApplySpellFix({ 12328 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_NOT_SHAPESHIFTED;
    });
 
    // Damage Shield
    ApplySpellFix({ 59653 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DmgClass = SPELL_DAMAGE_CLASS_MAGIC;
        spellInfo->SpellLevel = 0;
    });
 
    ApplySpellFix({
        20230,  // Retaliation
        871,    // Shield Wall
        1719    // Recklessness
        }, [](SpellInfo* spellInfo)
    {
        // Strange shared cooldown
        spellInfo->AttributesEx6 |= SPELL_ATTR6_NO_CATEGORY_COOLDOWN_MODS;
    });
 
    // Vigilance
    ApplySpellFix({ 50720 }, [](SpellInfo* spellInfo)
    {
        // fixes bug with empowered renew, single target aura
        spellInfo->SpellFamilyName = SPELLFAMILY_WARRIOR;
    });
 
    // Sunder Armor - Old Ranks
    ApplySpellFix({ 7405, 8380, 11596, 11597, 25225, 47467 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TriggerSpell = 11971;
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE;
    });
 
    // Improved Spell Reflection
    ApplySpellFix({ 59725 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER_AREA_PARTY);
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Hymn of Hope
    ApplySpellFix({ 64904 }, [](SpellInfo* spellInfo)
    {
        // rewrite part of aura system or swap effects...
        spellInfo->Effects[EFFECT_1].ApplyAuraName = SPELL_AURA_MOD_INCREASE_ENERGY_PERCENT;
        spellInfo->Effects[EFFECT_2].Effect = spellInfo->Effects[EFFECT_0].Effect;
        spellInfo->Effects[EFFECT_0].Effect = 0;
        spellInfo->Effects[EFFECT_2].DieSides = spellInfo->Effects[EFFECT_0].DieSides;
        spellInfo->Effects[EFFECT_2].TargetA = spellInfo->Effects[EFFECT_0].TargetB;
        spellInfo->Effects[EFFECT_2].RadiusEntry = spellInfo->Effects[EFFECT_0].RadiusEntry;
        spellInfo->Effects[EFFECT_2].BasePoints = spellInfo->Effects[EFFECT_0].BasePoints;
    });
 
    // Divine Hymn
    ApplySpellFix({ 64844 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DmgClass = SPELL_DAMAGE_CLASS_MAGIC;
        spellInfo->SpellLevel = 0;
    });
 
    ApplySpellFix({
        14898,  // Spiritual Healing affects prayer of mending
        15349,
        15354,
        15355,
        15356,
        47562,  // Divine Providence affects prayer of mending
        47564,
        47565,
        47566,
        47567,
        47586,  // Twin Disciplines affects prayer of mending
        47587,
        47588,
        52802,
        52803
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].SpellClassMask[1] |= 0x20; // prayer of mending
    });
 
    // Lifebloom final bloom
    ApplySpellFix({ 33778 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DmgClass = SPELL_DAMAGE_CLASS_MAGIC;
        spellInfo->SpellLevel = 0;
        spellInfo->SpellFamilyFlags = flag96(0, 0x10, 0);
    });
 
    // Owlkin Frenzy
    ApplySpellFix({ 48391 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_NOT_SHAPESHIFTED;
    });
 
    // Item T10 Restoration 4P Bonus
    ApplySpellFix({ 70691 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_IGNORE_CASTER_MODIFIERS;
    });
 
    ApplySpellFix({
        770,    // Faerie Fire
        16857   // Faerie Fire (Feral)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx &= ~SPELL_ATTR1_IMMUNITY_TO_HOSTILE_AND_FRIENDLY_EFFECTS;
    });
 
    ApplySpellFix({ 49376 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_3_YARDS); // 3yd
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    // Feral Charge - Cat
    ApplySpellFix({ 61138, 61132, 50259 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    // Glyph of Barkskin
    ApplySpellFix({ 63058 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_CHANCE;
    });
 
    // Resurrection Sickness
    ApplySpellFix({ 15007 }, [](SpellInfo* spellInfo)
    {
        spellInfo->SpellFamilyName = SPELLFAMILY_GENERIC;
    });
 
    // Luck of the Draw
    ApplySpellFix({ 72221 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AuraInterruptFlags |= AURA_INTERRUPT_FLAG_CHANGE_MAP;
    });
 
    // Bind
    ApplySpellFix({ 3286 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Targets = 0; // neutral innkeepers not friendly?
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
    });
 
    // Playback Speech
    ApplySpellFix({ 74209 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(1);
    });
 
    ApplySpellFix({
        2641, // Dismiss Pet
        23356 // Taming Lesson
        }, [](SpellInfo* spellInfo)
    {
        // remove creaturetargettype
        spellInfo->TargetCreatureType = 0;
    });
 
    // Aspect of the Viper
    ApplySpellFix({ 34074 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].Effect = SPELL_EFFECT_APPLY_AURA;
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(1);
        spellInfo->Effects[EFFECT_2].ApplyAuraName = SPELL_AURA_DUMMY;
    });
 
    // Strength of Wrynn
    ApplySpellFix({ 60509 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].BasePoints = 1500;
        spellInfo->Effects[EFFECT_1].BasePoints = 150;
        spellInfo->Effects[EFFECT_1].ApplyAuraName = SPELL_AURA_PERIODIC_HEAL;
    });
 
    // Winterfin First Responder
    ApplySpellFix({ 48739 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = 1;
        spellInfo->Effects[EFFECT_0].RealPointsPerLevel = 0;
        spellInfo->Effects[EFFECT_0].DieSides = 0;
        spellInfo->Effects[EFFECT_0].DamageMultiplier = 0;
        spellInfo->Effects[EFFECT_0].BonusMultiplier = 0;
    });
 
    // Army of the Dead (trigger npc aura)
    ApplySpellFix({ 49099 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Amplitude = 15000;
    });
 
    // Frightening Shout
    ApplySpellFix({ 19134 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_DUMMY;
    });
 
    // Isle of Conquest
    ApplySpellFix({ 66551 }, [](SpellInfo* spellInfo)
    {
        // Teleport in, missing range
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(13); // 50000yd
    });
 
    ApplySpellFix({
        57607,  // WintergraspCatapult - Spell Plague Barrel - EffectRadiusIndex
        57619,  // WintergraspDemolisher - Spell Hourl Boulder - EffectRadiusIndex
        57610   // Cannon (Siege Turret)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_25_YARDS); // SPELL_EFFECT_WMO_DAMAGE
    });
 
    // WintergraspCannon - Spell Fire Cannon - EffectRadiusIndex
    ApplySpellFix({ 51422 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_10_YARDS); // SPELL_EFFECT_SCHOOL_DAMAGE
    });
 
    // WintergraspDemolisher - Spell Ram -  EffectRadiusIndex
    ApplySpellFix({ 54107 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_3_YARDS); // SPELL_EFFECT_KNOCK_BACK
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_3_YARDS); // SPELL_EFFECT_SCHOOL_DAMAGE
        spellInfo->Effects[EFFECT_2].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_3_YARDS); // SPELL_EFFECT_WEAPON_DAMAGE
    });
 
    // WintergraspSiegeEngine - Spell Ram - EffectRadiusIndex
    ApplySpellFix({ 51678 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_10_YARDS); // SPELL_EFFECT_KNOCK_BACK
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_10_YARDS); // SPELL_EFFECT_SCHOOL_DAMAGE
        spellInfo->Effects[EFFECT_2].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_20_YARDS); // SPELL_EFFECT_WEAPON_DAMAGE
    });
 
    // WintergraspCatapult - Spell Plague Barrell - Range
    ApplySpellFix({ 57606 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(164); // "Catapult Range"
    });
 
    // Boulder (Demolisher)
    ApplySpellFix({ 50999 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_10_YARDS); // 10yd
    });
 
    // Flame Breath (Catapult)
    ApplySpellFix({ 50990 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_18_YARDS); // 18yd
    });
 
    // Jormungar Bite
    ApplySpellFix({ 56103 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ENEMY);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
    });
 
    // Throw Proximity Bomb
    ApplySpellFix({ 34095 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_TARGET_ENEMY);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
    });
 
    ApplySpellFix({
        53348,  // DEATH KNIGHT SCARLET FIRE ARROW
        53117   // BALISTA
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->RecoveryTime = 5000;
        spellInfo->CategoryRecoveryTime = 5000;
    });
 
    // Teleport To Molten Core
    ApplySpellFix({ 25139 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALLOW_AURA_WHILE_DEAD;
    });
 
    // Landen Stilwell Transform
    ApplySpellFix({ 31310 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_PASSIVE;
    });
 
    // Shadowstalker Stealth
    ApplySpellFix({ 5916 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RealPointsPerLevel = 5.0f;
    });
 
    // Sneak
    ApplySpellFix({ 22766 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RealPointsPerLevel = 5.0f;
    });
 
    // Murmur's Touch
    ApplySpellFix({ 38794, 33711 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 1;
        spellInfo->Effects[EFFECT_0].TriggerSpell = 33760;
    });
 
    // Negaton Field
    ApplySpellFix({
        36729,  // Normal
        38834   // Heroic
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_DOT_STACKING_RULE;
    });
 
    // Curse of the Doomsayer NORMAL
    ApplySpellFix({ 36173 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TriggerSpell = 36174; // Currently triggers heroic version...
    });
 
    // Crystal Channel
    ApplySpellFix({ 34156 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(35); // 35yd;
        spellInfo->ChannelInterruptFlags |= AURA_INTERRUPT_FLAG_MOVE;
    });
 
    // Debris - Debris Visual
    ApplySpellFix({ 36449, 30632 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_AURA_IS_DEBUFF;
    });
 
    // Soul Channel
    ApplySpellFix({ 30531 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_DOT_STACKING_RULE;
    });
 
    // Activate Sunblade Protector
    ApplySpellFix({ 46475, 46476 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(14); // 60yd
    });
 
    // Break Ice
    ApplySpellFix({ 46638 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 &= ~SPELL_ATTR3_ONLY_ON_PLAYER; // Obvious fail, it targets gameobject...
    });
 
    // Sinister Reflection Clone
    ApplySpellFix({ 45785 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Speed = 0.0f;
    });
 
    // Armageddon
    ApplySpellFix({ 45909 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Speed = 8.0f;
    });
 
    // Shadowmoon Reaver - Spell Absorption
    ApplySpellFix({ 41034 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].Effect = SPELL_EFFECT_APPLY_AURA;
        spellInfo->Effects[EFFECT_2].ApplyAuraName = SPELL_AURA_SCHOOL_ABSORB;
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
        spellInfo->Effects[EFFECT_2].MiscValue = SPELL_SCHOOL_MASK_MAGIC;
    });
 
    // Priestess of Delight and Priestess of Torment - Shared Bonds
    ApplySpellFix({ 41363 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx &= ~SPELL_ATTR1_IS_CHANNELED;
    });
 
    // Illidari Council - Veras Darkshadow
    ApplySpellFix({
        41485,  // Deadly Poison
        41487   // Envenom
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx6 |= SPELL_ATTR6_IGNORE_PHASE_SHIFT;
    });
 
    // Illidan Stormrage - Parasitic Shadowfiend
    ApplySpellFix({ 41914 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_AURA_IS_DEBUFF;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_DOT_STACKING_RULE;
    });
 
    // Illidan Stormrage - Demon Fire
    ApplySpellFix({ 40030 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
        spellInfo->AttributesEx4 &= ~SPELL_ATTR4_NO_CAST_LOG;
    });
 
    // Illidan Stormrage - Teleport Maiev
    ApplySpellFix({ 41221 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(13); // 0-50000yd
    });
 
    // Morogrim Tidewalker - Watery Grave Explosion
    ApplySpellFix({ 37852 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx5 |= SPELL_ATTR5_ALLOW_WHILE_STUNNED;
    });
 
    // Prince Malchezaar - Amplify Damage
    ApplySpellFix({ 39095 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 1;
    });
 
    // Energy Feedback
    ApplySpellFix({ 44335 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AuraInterruptFlags |= AURA_INTERRUPT_FLAG_CHANGE_MAP;
        spellInfo->AttributesCu |= SPELL_ATTR0_CU_SINGLE_AURA_STACK;
    });
 
    // Archimonde
    ApplySpellFix({
        31984,  // Finger of Death
        35354   // Hand of Death
        }, [](SpellInfo* spellInfo)
    {
        // Spell doesn't need to ignore invulnerabilities
        spellInfo->Attributes = SPELL_ATTR0_IS_ABILITY;
    });
 
    // Archimonde - Finger of Death
    ApplySpellFix({ 32111 }, [](SpellInfo* spellInfo)
    {
        spellInfo->CastTimeEntry = sSpellCastTimesStore.LookupEntry(0); // We only need the animation, no damage
    });
 
    // Archimonde - Doomfire
    ApplySpellFix({ 31944, 31969 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx4 |= SPELL_ATTR4_NO_CAST_LOG;
    });
 
    // Flame Breath, catapult spell
    ApplySpellFix({ 50989 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes &= ~SPELL_ATTR0_SCALES_WITH_CREATURE_LEVEL;
    });
 
    // Koralon, Flaming Cinder
    ApplySpellFix({ 66690 }, [](SpellInfo* spellInfo)
    {
        // missing radius index
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_100_YARDS); // 100yd
        spellInfo->MaxAffectedTargets = 1;
    });
 
    // Acid Volley
    ApplySpellFix({ 54714, 29325 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 1;
    });
 
    // Summon Plagued Warrior
    ApplySpellFix({ 29237 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_DUMMY;
        spellInfo->Effects[EFFECT_1].Effect = spellInfo->Effects[EFFECT_2].Effect = 0;
    });
 
    // Icebolt
    ApplySpellFix({ 28526 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
    });
 
    // Infected Wound
    ApplySpellFix({ 29306 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_DOT_STACKING_RULE;
    });
 
    // Hopeless
    ApplySpellFix({ 29125 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ENTRY);
    });
 
    // Jagged Knife
    ApplySpellFix({ 55550 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_USES_RANGED_SLOT;
    });
 
    // Moorabi - Transformation
    ApplySpellFix({ 55098 }, [](SpellInfo* spellInfo)
    {
        spellInfo->InterruptFlags |= SPELL_INTERRUPT_FLAG_INTERRUPT;
    });
 
    ApplySpellFix({
        55521,  // Poisoned Spear (Normal)
        58967,  // Poisoned Spear (Heroic)
        55348,  // Throw (Normal)
        58966   // Throw (Heroic)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_USES_RANGED_SLOT;
    });
 
    // Charged Chaotic rift aura, trigger
    ApplySpellFix({ 47737 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(37); // 50yd
    });
 
    // Vanish
    ApplySpellFix({ 55964 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = 0;
        spellInfo->Effects[EFFECT_2].Effect = 0;
    });
 
    // Trollgore - Summon Drakkari Invader
    ApplySpellFix({ 49456, 49457, 49458 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_DB);
    });
 
    ApplySpellFix({
        48278,  // Paralyse
        47669   // Awaken subboss
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
        spellInfo->Effects[0].TargetB = SpellImplicitTargetInfo();
    });
 
    // Skarvald, Charge
    ApplySpellFix({ 43651 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(13); // 0-50000yd
    });
 
    // Ingvar the Plunderer, Woe Strike
    ApplySpellFix({ 42730 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].TriggerSpell = 42739;
    });
 
    ApplySpellFix({ 59735 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].TriggerSpell = 59736;
    });
 
    // Ingvar the Plunderer, Ingvar transform
    ApplySpellFix({ 42796 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALLOW_AURA_WHILE_DEAD;
    });
 
    ApplySpellFix({
        42772,  // Hurl Dagger (Normal)
        59685   // Hurl Dagger (Heroic)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_USES_RANGED_SLOT;
    });
 
    // Control Crystal Activation
    ApplySpellFix({ 57804 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(1);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
    });
 
    // Destroy Door Seal
    ApplySpellFix({ 58040 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ChannelInterruptFlags &= ~(AURA_INTERRUPT_FLAG_HITBYSPELL | AURA_INTERRUPT_FLAG_TAKE_DAMAGE);
    });
 
    // Ichoron, Water Blast
    ApplySpellFix({ 54237, 59520 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
    });
 
    // Krik'thir - Mind Flay
    ApplySpellFix({ 52586, 59367 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ChannelInterruptFlags |= AURA_INTERRUPT_FLAG_MOVE;
    });
 
    // Glare of the Tribunal
    ApplySpellFix({ 50988, 59870 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
    });
 
    // Static Charge
    ApplySpellFix({ 50835, 59847 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ALLY);
    });
 
    // Gift of Twilight Shadow/Fire
    ApplySpellFix({ 57835, 58766 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx &= ~SPELL_ATTR1_IS_CHANNELED;
    });
 
    // Pyrobuffet
    ApplySpellFix({ 57557 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ExcludeTargetAuraSpell = 56911;
    });
 
    // Arcane Barrage
    ApplySpellFix({ 56397 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ENEMY);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ENEMY);
        spellInfo->Effects[EFFECT_1].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ENEMY);
        spellInfo->Effects[EFFECT_2].TargetB = SpellImplicitTargetInfo();
    });
 
    ApplySpellFix({
        55849,  // Power Spark (ground +50% dmg aura)
        56438,  // Arcane Overload (-50% dmg taken) - this is to prevent apply -> unapply -> apply ... dunno whether it's correct
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_DOT_STACKING_RULE;
    });
 
    // Vortex (Control Vehicle)
    ApplySpellFix({ 56263 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
    });
 
    // Haste (Nexus Lord, increase run Speed of the disk)
    ApplySpellFix({ 57060 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_VEHICLE);
    });
 
    // Arcane Overload
    ApplySpellFix({ 56430 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_TRIGGER_MISSILE;
        spellInfo->Effects[EFFECT_0].TriggerSpell = 56429;
    });
 
    // Summon Arcane Bomb
    ApplySpellFix({ 56429 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_DEST);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_1].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_2].TargetB = SpellImplicitTargetInfo();
    });
 
    // Destroy Platform Event
    ApplySpellFix({ 59099 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(22);
        spellInfo->Effects[EFFECT_1].TargetB = SpellImplicitTargetInfo(15);
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(22);
        spellInfo->Effects[EFFECT_2].TargetB = SpellImplicitTargetInfo(15);
    });
 
    // Surge of Power (Phase 3)
    ApplySpellFix({
        57407,  // N
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 1;
        spellInfo->InterruptFlags = 0;
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_50000_YARDS);
        spellInfo->AttributesEx4 |= SPELL_ATTR4_ALLOW_CAST_WHILE_CASTING;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_SRC_CASTER);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ENEMY);
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Surge of Power (Phase 3)
    ApplySpellFix({
        60936   // H
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 3;
        spellInfo->InterruptFlags = 0;
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_50000_YARDS);
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_SRC_CASTER);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ENEMY);
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Wyrmrest Drake - Life Burst
    ApplySpellFix({ 57143 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = 0;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_SRC_CASTER);
        spellInfo->Effects[EFFECT_1].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ALLY);
        spellInfo->Effects[EFFECT_1].PointsPerComboPoint = 2500;
        spellInfo->Effects[EFFECT_1].BasePoints = 2499;
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(1);
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    //Alexstrasza - Gift
    ApplySpellFix({ 61028 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_DEST);
    });
 
    // Meeting Stone Summon
    ApplySpellFix({ 23598 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_CASTER);
    });
 
    // Ulduar, Mimiron, bomb bot explosion
    ApplySpellFix({ 63801 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].MiscValue = 17286;
    });
 
    // Ulduar, Mimiron, Summon Flames Initial
    ApplySpellFix({ 64563 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_DEST);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
    });
 
    // Ulduar, Mimiron, Flames (damage)
    ApplySpellFix({ 64566 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
        spellInfo->AttributesEx4 &= ~SPELL_ATTR4_NO_CAST_LOG;
    });
 
    // Ulduar, Hodir, Starlight
    ApplySpellFix({ 62807 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_1_YARD); // 1yd
    });
 
    // Hodir Shatter Cache
    ApplySpellFix({ 62502 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ENTRY);
    });
 
    // Ulduar, General Vezax, Mark of the Faceless
    ApplySpellFix({ 63278 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = 0;
    });
 
    // Ulduar, General Vezax, Shadow Crash (area aura)
    ApplySpellFix({ 63277 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx5 |= SPELL_ATTR5_DO_NOT_DISPLAY_DURATION;
    });
 
    // Boom (XT-002)
    ApplySpellFix({ 62834 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = 0;
    });
 
    // Supercharge
    ApplySpellFix({ 61920 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_DOT_STACKING_RULE;
    });
 
    // Lightning Whirl
    ApplySpellFix({ 61916 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 3;
    });
 
    ApplySpellFix({ 63482 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 8;
    });
 
    // Stone Grip, remove absorb aura
    ApplySpellFix({ 62056, 63985 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = 0;
    });
 
    // Sentinel Blast
    ApplySpellFix({ 64389, 64678 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Dispel = DISPEL_MAGIC;
    });
 
    // Potent Pheromones
    ApplySpellFix({ 62619 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx |= SPELL_ATTR1_IMMUNITY_PURGES_EFFECT;
    });
 
    // Healthy spore summon periodic
    ApplySpellFix({ 62566 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Amplitude = 2000;
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_PERIODIC_TRIGGER_SPELL;
    });
 
    // Brightleaf Essence trigger
    ApplySpellFix({ 62968 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = 0; // duplicate
    });
 
    // Potent Pheromones
    ApplySpellFix({ 64321 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx |= SPELL_ATTR1_IMMUNITY_PURGES_EFFECT;
    });
 
    // Lightning Orb Charged
    ApplySpellFix({ 62186 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Amplitude = 5000; // Duration 5 secs, amplitude 8 secs...
    });
 
    // Lightning Pillar
    ApplySpellFix({ 62976 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(6);
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(28); // 5 seconds, wrong DBC data?
    });
 
    // Sif's Blizzard
    ApplySpellFix({ 62576, 62602 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_8_YARDS); // 8yd
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_8_YARDS); // 8yd
    });
 
    // Protective Gaze
    ApplySpellFix({ 64175 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RecoveryTime = 25000;
    });
 
    // Shadow Beacon
    ApplySpellFix({ 64465 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TriggerSpell = 64467; // why do they need two script effects :/ (this one has visual effect)
    });
 
    // Sanity
    ApplySpellFix({ 63050 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx6 |= SPELL_ATTR6_IGNORE_PHASE_SHIFT;
    });
 
    // Shadow Nova (Sara)
    ApplySpellFix({ 65719 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
        spellInfo->AttributesEx4 |= SPELL_ATTR4_NO_CAST_LOG;
    });
 
    // Cosmic Smash (Algalon the Observer)
    ApplySpellFix({ 62311, 64596 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_100_YARDS); // 100yd
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(13);  // 50000yd
    });
 
    // Constellation Phase Effect
    ApplySpellFix({ 65509 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 1;
    });
 
    // Black Hole
    ApplySpellFix({ 62168, 65250, 62169 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_AURA_IS_DEBUFF;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ONLY_ON_PLAYER; // pets phased away from their owner get despawned
    });
 
    // Ground Slam
    ApplySpellFix({ 62625 }, [](SpellInfo* spellInfo)
    {
        spellInfo->InterruptFlags |= SPELL_INTERRUPT_FLAG_INTERRUPT;
    });
 
    // Onyxia's Lair, Onyxia, Flame Breath (TriggerSpell = 0 and spamming errors in console)
    ApplySpellFix({ 18435 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = 0;
    });
 
    // Onyxia's Lair, Onyxia, Create Onyxia Spawner
    ApplySpellFix({ 17647 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(37);
    });
 
    ApplySpellFix({
        17646,  // Onyxia's Lair, Onyxia, Summon Onyxia Whelp
        68968   // Onyxia's Lair, Onyxia, Summon Lair Guard
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Targets |= TARGET_FLAG_DEST_LOCATION;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_DEST);
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(13); // 50000yd
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(5);
    });
 
    // Onyxia's Lair, Onyxia, Eruption
    ApplySpellFix({ 17731, 69294 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = SPELL_EFFECT_DUMMY;
        spellInfo->CastTimeEntry = sSpellCastTimesStore.LookupEntry(3);
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_18_YARDS); // 18yd instead of 13yd to make sure all cracks erupt
    });
 
    // Onyxia's Lair, Onyxia, Breath
    ApplySpellFix({
        18576, 18578, 18579, 18580, 18581, 18582, 18583, 18609, 18611, 18612, 18613, 18614, 18615, 18616, 18584,
        18585, 18586, 18587, 18588, 18589, 18590, 18591, 18592, 18593, 18594, 18595, 18564, 18565, 18566, 18567,
        18568, 18569, 18570, 18571, 18572, 18573, 18574, 18575, 18596, 18597, 18598, 18599, 18600, 18601, 18602,
        18603, 18604, 18605, 18606, 18607, 18617, 18619, 18620, 18621, 18622, 18623, 18624, 18625, 18626, 18627,
        18628, 18618, 18351, 18352, 18353, 18354, 18355, 18356, 18357, 18358, 18359, 18360, 18361, 17086, 17087,
        17088, 17089, 17090, 17091, 17092, 17093, 17094, 17095, 17097, 22267, 22268, 21132, 21133, 21135, 21136,
        21137, 21138, 21139
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(328); // 250ms
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(1);
        if (spellInfo->Effects[EFFECT_1].Effect)
        {
            spellInfo->Effects[EFFECT_1].Effect = SPELL_EFFECT_APPLY_AURA;
            spellInfo->Effects[EFFECT_1].ApplyAuraName = SPELL_AURA_PERIODIC_TRIGGER_SPELL;
            spellInfo->Effects[EFFECT_1].Amplitude = ((spellInfo->CastTimeEntry == sSpellCastTimesStore.LookupEntry(170)) ? 50 : 215);
        }
    });
 
    ApplySpellFix({
        48760,  // Oculus, Teleport to Coldarra DND
        49305   // Oculus, Teleport to Boss 1 DND
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(25);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(17);
    });
 
    // Oculus, Drake spell Stop Time
    ApplySpellFix({ 49838 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
        spellInfo->ExcludeTargetAuraSpell = 51162; // exclude planar shift
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_150_YARDS);
    });
 
    // Oculus, Varos Cloudstrider, Energize Cores
    ApplySpellFix({ 61407, 62136, 56251, 54069 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CONE_ENTRY);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
    });
 
    // Halls of Lightning, Arc Weld
    ApplySpellFix({ 59086 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(1);
    });
 
    // Trial of the Champion, Death's Respite
    ApplySpellFix({ 68306 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(25);
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(25);
    });
 
    // Trial of the Champion, Eadric Achievement (The Faceroller)
    ApplySpellFix({ 68197 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ALLY);
        spellInfo->Attributes |= SPELL_ATTR0_ALLOW_CAST_WHILE_DEAD;
    });
 
    // Trial of the Champion, Earth Shield
    ApplySpellFix({ 67530 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_PROC_TRIGGER_SPELL; // will trigger 67537
    });
 
    // Trial of the Champion, Hammer of the Righteous
    ApplySpellFix({ 66867 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_DUMMY;
    });
 
    // Trial of the Champion, Summon Risen Jaeren/Arelas
    ApplySpellFix({ 67705, 67715 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_ALLOW_DEAD_TARGET;
    });
 
    // Trial of the Champion, Ghoul Explode
    ApplySpellFix({ 67751 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_SRC_CASTER);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ENTRY);
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_100_YARDS);
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_SRC_CASTER);
        spellInfo->Effects[EFFECT_1].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ENTRY);
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_100_YARDS);
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(TARGET_SRC_CASTER);
        spellInfo->Effects[EFFECT_2].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ENTRY);
        spellInfo->Effects[EFFECT_2].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_100_YARDS);
    });
 
    // Trial of the Champion, Desecration
    ApplySpellFix({ 67778, 67877 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TriggerSpell = 68766;
    });
 
    // Killing Spree (Off hand damage)
    ApplySpellFix({ 57842 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(2); // Melee Range
    });
 
    // Trial of the Crusader, Jaraxxus Intro spell
    ApplySpellFix({ 67888 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_CANCELS_AUTO_ATTACK_COMBAT;
        spellInfo->AttributesEx |= SPELL_ATTR1_NO_THREAT;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    // Trial of the Crusader, Lich King Intro spell
    ApplySpellFix({ 68193 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ENEMY);
    });
 
    // Trial of the Crusader, Gormok, player vehicle spell, CUSTOM! (default jump to hand, not used)
    ApplySpellFix({ 66342 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_APPLY_AURA;
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_SET_VEHICLE_ID;
        spellInfo->Effects[EFFECT_0].MiscValue = 496;
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(21);
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(13);
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(25);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
        spellInfo->AuraInterruptFlags = AURA_INTERRUPT_FLAG_CHANGE_MAP;
    });
 
    // Trial of the Crusader, Gormok, Fire Bomb
    ApplySpellFix({ 66313 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_DEST_TARGET_ANY);
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
        spellInfo->Effects[EFFECT_1].TargetB = SpellImplicitTargetInfo(TARGET_DEST_TARGET_ANY);
        spellInfo->Effects[EFFECT_1].Effect  = 0;
    });
 
    ApplySpellFix({ 66317 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_CANCELS_AUTO_ATTACK_COMBAT;
        spellInfo->AttributesEx |= SPELL_ATTR1_NO_THREAT;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    ApplySpellFix({ 66318 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
        spellInfo->Speed = 14.0f;
        spellInfo->Attributes |= SPELL_ATTR0_CANCELS_AUTO_ATTACK_COMBAT;
        spellInfo->AttributesEx |= SPELL_ATTR1_NO_THREAT;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    ApplySpellFix({ 66320, 67472, 67473, 67475 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_2_YARDS);
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_2_YARDS);
    });
 
    // Trial of the Crusader, Acidmaw & Dreadscale, Emerge
    ApplySpellFix({ 66947 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx5 |= SPELL_ATTR5_ALLOW_WHILE_STUNNED;
    });
 
    // Trial of the Crusader, Jaraxxus, Curse of the Nether
    ApplySpellFix({ 66211 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ExcludeTargetAuraSpell = 66209; // exclude Touch of Jaraxxus
    });
 
    // Trial of the Crusader, Jaraxxus, Summon Volcano
    ApplySpellFix({ 66258, 67901 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(85); // summon for 18 seconds, 15 not enough
    });
 
    // Trial of the Crusader, Jaraxxus, Spinning Pain Spike
    ApplySpellFix({ 66281 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_4_YARDS);
    });
 
    ApplySpellFix({ 66287 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = SPELL_EFFECT_APPLY_AURA;
        spellInfo->Effects[EFFECT_1].ApplyAuraName = SPELL_AURA_MOD_TAUNT;
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_NEARBY_ENTRY);
        spellInfo->Effects[EFFECT_2].Effect = SPELL_EFFECT_APPLY_AURA;
        spellInfo->Effects[EFFECT_2].ApplyAuraName = SPELL_AURA_MOD_STUN;
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(35); // 4 secs
    });
 
    // Trial of the Crusader, Jaraxxus, Fel Fireball
    ApplySpellFix({ 66532, 66963, 66964, 66965 }, [](SpellInfo* spellInfo)
    {
        spellInfo->InterruptFlags |= SPELL_INTERRUPT_FLAG_INTERRUPT;
    });
 
    // tempfix, make Nether Power not stealable
    ApplySpellFix({ 66228, 67106, 67107, 67108 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx4 |= SPELL_ATTR4_CANNOT_BE_STOLEN;
    });
 
    // Trial of the Crusader, Faction Champions, Druid - Tranquality
    ApplySpellFix({ 66086, 67974, 67975, 67976 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_APPLY_AREA_AURA_FRIEND;
    });
 
    // Trial of the Crusader, Faction Champions, Shaman - Earth Shield
    ApplySpellFix({ 66063 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_PROC_TRIGGER_SPELL;
        spellInfo->Effects[EFFECT_0].TriggerSpell = 66064;
    });
 
    // Trial of the Crusader, Faction Champions, Priest - Mana Burn
    ApplySpellFix({ 66100 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = 5;
        spellInfo->Effects[EFFECT_0].DieSides = 0;
    });
 
    ApplySpellFix({ 68026 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = 8;
        spellInfo->Effects[EFFECT_0].DieSides = 0;
    });
 
    ApplySpellFix({ 68027 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = 6;
        spellInfo->Effects[EFFECT_0].DieSides = 0;
    });
 
    ApplySpellFix({ 68028 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = 10;
        spellInfo->Effects[EFFECT_0].DieSides = 0;
    });
 
    // Trial of the Crusader, Twin Valkyr, Touch of Light/Darkness, Light/Dark Surge
    ApplySpellFix({
        65950   // light 0
        }, [](SpellInfo* spellInfo)
    {
        //spellInfo->EffectApplyAuraName[0] = SPELL_AURA_PERIODIC_DUMMY;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(6);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_1].Effect = 0;
        spellInfo->Effects[EFFECT_2].Effect = 0;
    });
 
    ApplySpellFix({
        65767   // light surge 0
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->ExcludeTargetAuraSpell = 65686;
    });
 
    ApplySpellFix({
        67296   // light 1
        }, [](SpellInfo* spellInfo)
    {
        //spellInfo->Effects[EFFECT_0].ApplyAuraNames = SPELL_AURA_PERIODIC_DUMMY;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(6);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_1].Effect = 0;
        spellInfo->Effects[EFFECT_2].Effect = 0;
    });
 
    ApplySpellFix({
        67274   // light surge 1
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->ExcludeTargetAuraSpell = 67222;
    });
 
    ApplySpellFix({
        67297   // light 2
        }, [](SpellInfo* spellInfo)
    {
        //spellInfo->Effects[EFFECT_0].ApplyAuraNames = SPELL_AURA_PERIODIC_DUMMY;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(6);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_1].Effect = 0;
        spellInfo->Effects[EFFECT_2].Effect = 0;
    });
 
    ApplySpellFix({
        67275   // light surge 2
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->ExcludeTargetAuraSpell = 67223;
    });
 
    ApplySpellFix({
        67298   // light 3
        }, [](SpellInfo* spellInfo)
    {
        //spellInfo->Effects[EFFECT_0].ApplyAuraNames = SPELL_AURA_PERIODIC_DUMMY;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(6);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_1].Effect = 0;
        spellInfo->Effects[EFFECT_2].Effect = 0;
    });
 
    ApplySpellFix({
        67276   // light surge 3
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->ExcludeTargetAuraSpell = 67224;
    });
 
    ApplySpellFix({
        66001   // dark 0
        }, [](SpellInfo* spellInfo)
    {
        //spellInfo->Effects[EFFECT_0].ApplyAuraNames = SPELL_AURA_PERIODIC_DUMMY;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(6);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_1].Effect = 0;
        spellInfo->Effects[EFFECT_2].Effect = 0;
    });
 
    ApplySpellFix({
        65769   // dark surge 0
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->ExcludeTargetAuraSpell = 65684;
    });
 
    ApplySpellFix({
        67281   // dark 1
        }, [](SpellInfo* spellInfo)
    {
        //spellInfo->Effects[EFFECT_0].ApplyAuraNames = SPELL_AURA_PERIODIC_DUMMY;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(6);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_1].Effect = 0;
        spellInfo->Effects[EFFECT_2].Effect = 0;
    });
 
    ApplySpellFix({
        67265   // dark surge 1
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->ExcludeTargetAuraSpell = 67176;
    });
 
    ApplySpellFix({
        67282   // dark 2
        }, [](SpellInfo* spellInfo)
    {
        //spellInfo->Effects[EFFECT_0].ApplyAuraNames = SPELL_AURA_PERIODIC_DUMMY;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(6);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_1].Effect = 0;
        spellInfo->Effects[EFFECT_2].Effect = 0;
    });
 
    ApplySpellFix({
        67266   // dark surge 2
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->ExcludeTargetAuraSpell = 67177;
    });
 
    ApplySpellFix({
        67283   // dark 3
        }, [](SpellInfo* spellInfo)
    {
        //spellInfo->Effects[EFFECT_0].ApplyAuraNames = SPELL_AURA_PERIODIC_DUMMY;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(6);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_1].Effect = 0;
        spellInfo->Effects[EFFECT_2].Effect = 0;
    });
 
    ApplySpellFix({
        67267   // dark surge 3
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->ExcludeTargetAuraSpell = 67178;
    });
 
    // Trial of the Crusader, Twin Valkyr, Twin's Pact
    ApplySpellFix({ 65875, 67303, 67304, 67305, 65876, 67306, 67307, 67308 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = 0;
        spellInfo->Effects[EFFECT_2].Effect = 0;
    });
 
    // Trial of the Crusader, Anub'arak, Emerge
    ApplySpellFix({ 65982 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx5 |= SPELL_ATTR5_ALLOW_WHILE_STUNNED;
    });
 
    // Trial of the Crusader, Anub'arak, Penetrating Cold
    ApplySpellFix({ 66013, 67700, 68509, 68510 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_100_YARDS); // 100yd
    });
 
    // Trial of the Crusader, Anub'arak, Shadow Strike
    ApplySpellFix({ 66134 }, [](SpellInfo* spellInfo)
    {
        spellInfo->InterruptFlags |= SPELL_INTERRUPT_FLAG_INTERRUPT;
        spellInfo->Effects[EFFECT_0].Effect = 0;
    });
 
    // Trial of the Crusader, Anub'arak, Pursuing Spikes
    ApplySpellFix({ 65920, 65922, 65923 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_PERIODIC_DUMMY;
        //spellInfo->EffectTriggerSpell[0] = 0;
    });
 
    // Trial of the Crusader, Anub'arak, Summon Scarab
    ApplySpellFix({ 66339 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(35);
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(25);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
    });
 
    // Trial of the Crusader, Anub'arak, Achievements: The Traitor King
    ApplySpellFix({
        68186,  // Anub'arak Scarab Achievement 10
        68515   // Anub'arak Scarab Achievement 25
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_SRC_CASTER);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ENEMY);
        spellInfo->Attributes |= SPELL_ATTR0_ALLOW_CAST_WHILE_DEAD;
    });
 
    // Trial of the Crusader, Anub'arak, Spider Frenzy
    ApplySpellFix({ 66129 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_DOT_STACKING_RULE;
    });
 
    // Soul Sickness
    ApplySpellFix({ 69131 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_PERIODIC_TRIGGER_SPELL;
        spellInfo->Effects[EFFECT_0].Amplitude = 8000;
        spellInfo->Effects[EFFECT_0].TriggerSpell = 69133;
    });
 
    // Phantom Blast
    ApplySpellFix({ 68982, 70322 }, [](SpellInfo* spellInfo)
    {
        spellInfo->InterruptFlags |= SPELL_INTERRUPT_FLAG_INTERRUPT;
    });
 
    // Empowered Blizzard
    ApplySpellFix({ 70131 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_DEST);
    });
 
    // Ice Lance Volley
    ApplySpellFix({ 70464 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_SRC_CASTER);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ENTRY);
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_70_YARDS);
    });
 
    ApplySpellFix({
        70513,   // Multi-Shot
        59514    // Shriek of the Highborne
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CONE_ENTRY);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
    });
 
    // Icicle
    ApplySpellFix({ 69428, 69426 }, [](SpellInfo* spellInfo)
    {
        spellInfo->InterruptFlags = 0;
        spellInfo->AuraInterruptFlags = 0;
        spellInfo->ChannelInterruptFlags = 0;
    });
 
    ApplySpellFix({ 70525, 70639 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = 0;
        spellInfo->Effects[EFFECT_1].Effect = 0;
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(TARGET_SRC_CASTER);
        spellInfo->Effects[EFFECT_2].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ENTRY);
        spellInfo->Effects[EFFECT_2].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_500_YARDS); // 500yd
    });
 
    // Frost Nova
    ApplySpellFix({ 68198 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(13);
        spellInfo->Targets |= TARGET_FLAG_DEST_LOCATION;
    });
 
    // Blight
    ApplySpellFix({ 69604, 70286 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 1;
        spellInfo->AttributesEx3 |= (SPELL_ATTR3_ALWAYS_HIT | SPELL_ATTR3_ONLY_ON_PLAYER);
    });
 
    // Chilling Wave
    ApplySpellFix({ 68778, 70333 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_TARGET_ENEMY);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
    });
 
    ApplySpellFix({ 68786, 70336 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= (SPELL_ATTR3_ALWAYS_HIT | SPELL_ATTR3_ONLY_ON_PLAYER);
        spellInfo->Effects[EFFECT_2].Effect = SPELL_EFFECT_DUMMY;
    });
 
    // Pursuit
    ApplySpellFix({ 68987 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
        spellInfo->Effects[EFFECT_1].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
        spellInfo->Effects[EFFECT_2].TargetB = SpellImplicitTargetInfo();
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(6); // 100yd
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
    });
 
    ApplySpellFix({ 69029, 70850 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].Effect = 0;
    });
 
    // Explosive Barrage
    ApplySpellFix({ 69263 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_MOD_STUN;
    });
 
    // Overlord's Brand
    ApplySpellFix({ 69172 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ProcFlags = DONE_HIT_PROC_FLAG_MASK & ~PROC_FLAG_DONE_PERIODIC;
        spellInfo->ProcChance = 100;
    });
 
    // Icy Blast
    ApplySpellFix({ 69232 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].TriggerSpell = 69238;
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    ApplySpellFix({ 69233, 69646 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    ApplySpellFix({ 69238, 69628 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_DEST);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_DEST_DYNOBJ_NONE);
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_DEST_DEST);
        spellInfo->Effects[EFFECT_1].TargetB = SpellImplicitTargetInfo(TARGET_DEST_DYNOBJ_NONE);
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Hoarfrost
    ApplySpellFix({ 69246, 69245, 69645 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Devour Humanoid
    ApplySpellFix({ 69503 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ChannelInterruptFlags |= 0;
        spellInfo->AuraInterruptFlags = AURA_INTERRUPT_FLAG_MOVE | AURA_INTERRUPT_FLAG_TURNING;
    });
 
    // Falric: Defiling Horror
    ApplySpellFix({ 72435, 72452 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_200_YARDS);
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_200_YARDS);
    });
 
    // Frostsworn General - Throw Shield
    ApplySpellFix({ 69222, 73076 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ENEMY);
    });
 
    // Halls of Reflection Clone
    ApplySpellFix({ 69828 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = 0;
        spellInfo->Effects[EFFECT_2].Effect = 0;
    });
 
    // Summon Ice Wall
    ApplySpellFix({ 69768 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
        spellInfo->AttributesEx5 |= SPELL_ATTR5_ALLOW_ACTION_DURING_CHANNEL;
    });
 
    ApplySpellFix({ 69767 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_TARGET_ANY);
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
    });
 
    // Essence of the Captured
    ApplySpellFix({ 73035, 70719 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(13);
    });
 
    // Achievement Check
    ApplySpellFix({ 72830 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_200_YARDS);
    });
 
    ApplySpellFix({
        70781,  // Light's Hammer Teleport
        70856,  // Oratory of the Damned Teleport
        70857,  // Rampart of Skulls Teleport
        70858,  // Deathbringer's Rise Teleport
        70859,  // Upper Spire Teleport
        70860,  // Frozen Throne Teleport
        70861   // Sindragosa's Lair Teleport
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_DEST_DB); // this target is for SPELL_EFFECT_TELEPORT_UNITS
        spellInfo->Effects[EFFECT_1].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
        spellInfo->Effects[EFFECT_2].TargetB = SpellImplicitTargetInfo();
    });
 
    ApplySpellFix({
        70960,  // Bone Flurry
        71258   // Adrenaline Rush (Ymirjar Battle-Maiden)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx &= ~SPELL_ATTR1_IS_SELF_CHANNELED;
    });
 
    // Saber Lash (Lord Marrowgar)
    ApplySpellFix({ 69055, 70814 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_5_YARDS); // 5yd
    });
 
    // Impaled (Lord Marrowgar)
    ApplySpellFix({ 69065 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = 0;   // remove stun so Dispersion can be used
    });
 
    // Cold Flame (Lord Marrowgar)
    ApplySpellFix({ 72701, 72702, 72703, 72704 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_DEST_DEST);
        spellInfo->Effects[EFFECT_1].TargetB = SpellImplicitTargetInfo();
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(9);   // 30 secs instead of 12, need him for longer, but will stop his actions after 12 secs
    });
 
    ApplySpellFix({ 69138 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = 0;
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_DEST_DEST);
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(9);   // 30 secs instead of 12, need him for longer, but will stop his actions after 12 secs
    });
 
    ApplySpellFix({ 69146, 70823, 70824, 70825 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_3_YARDS); // 3yd instead of 5yd
        spellInfo->AttributesEx4 &= ~SPELL_ATTR4_NO_CAST_LOG;
    });
 
    // Dark Martyrdom (Lady Deathwhisper)
    ApplySpellFix({ 70897 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_ALLOW_DEAD_TARGET;
    });
 
    ApplySpellFix({
        69075,  // Bone Storm (Lord Marrowgar)
        70834,  // Bone Storm (Lord Marrowgar)
        70835,  // Bone Storm (Lord Marrowgar)
        70836,  // Bone Storm (Lord Marrowgar)
        72378,  // Blood Nova (Deathbringer Saurfang)
        73058,  // Blood Nova (Deathbringer Saurfang)
        72769,  // Scent of Blood (Deathbringer Saurfang)
        72385,  // Boiling Blood (Deathbringer Saurfang)
        72441,  // Boiling Blood (Deathbringer Saurfang)
        72442,  // Boiling Blood (Deathbringer Saurfang)
        72443,  // Boiling Blood (Deathbringer Saurfang)
        71160,  // Plague Stench (Stinky)
        71161,  // Plague Stench (Stinky)
        71123,  // Decimate (Stinky & Precious)
        71464   // Divine Surge (Sister Svalna)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_100_YARDS);   // 100yd
    });
 
    // Shadow's Fate
    ApplySpellFix({ 71169 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_DOT_STACKING_RULE;
    });
 
    // Lock Players and Tap Chest
    ApplySpellFix({ 72347 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 &= ~SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    // Award Reputation - Boss Kill
    ApplySpellFix({ 73843, 73844, 73845, 73846 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_50000_YARDS);
    });
 
    // Death Plague (Rotting Frost Giant)
    ApplySpellFix({ 72864 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ExcludeTargetAuraSpell = 0;
    });
 
    // Gunship Battle, spell Below Zero
    ApplySpellFix({ 69705 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
    });
 
    // Resistant Skin (Deathbringer Saurfang adds)
    ApplySpellFix({ 72723 }, [](SpellInfo* spellInfo)
    {
        // this spell initially granted Shadow damage immunity, however it was removed but the data was left in client
        spellInfo->Effects[EFFECT_2].Effect = 0;
    });
 
    // Mark of the Fallen Champion (Deathbringer Saurfang)
    ApplySpellFix({ 72255, 72444, 72445, 72446 }, [](SpellInfo* spellInfo)
    {
        // Patch 3.3.2 (2010-01-02): Deathbringer Saurfang will no longer gain blood power from Mark of the Fallen Champion.
        // prevented in script, effect needed for Prayer of Mending
        spellInfo->AttributesEx3 &= ~SPELL_ATTR3_SUPPRESS_CASTER_PROCS;
    });
 
    // Coldflame Jets (Traps after Saurfang)
    ApplySpellFix({ 70460 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(1); // 10 seconds
    });
 
    ApplySpellFix({
        70461,  // Coldflame Jets (Traps after Saurfang)
        71289   // Dominate Mind (Lady Deathwhisper)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Severed Essence (Val'kyr Herald)
    ApplySpellFix({ 71906, 71942 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ENEMY);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
        spellInfo->Effects[EFFECT_1].Effect = 0;
    });
 
    ApplySpellFix({
        71159,  // Awaken Plagued Zombies (Precious)
        71302   // Awaken Ymirjar Fallen (Ymirjar Deathbringer)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(21);
    });
 
    // Blood Prince Council, Invocation of Blood
    ApplySpellFix({ 70981, 70982, 70952 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = 0; // clear share health aura
    });
 
    // Ymirjar Frostbinder, Frozen Orb
    ApplySpellFix({ 71274 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(6);
    });
 
    // Ooze Flood (Rotface)
    ApplySpellFix({ 69783, 69797, 69799, 69802 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx |= SPELL_ATTR1_EXCLUDE_CASTER;
    });
 
    // Volatile Ooze Beam Protection
    ApplySpellFix({ 70530 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_APPLY_AURA; // blizzard typo, 65 instead of 6, aura itself is defined (dummy)
    });
 
    // Professor Putricide, Gaseous Bloat (Orange Ooze Channel)
    ApplySpellFix({ 70672, 72455, 72832, 72833 }, [](SpellInfo* spellInfo)
    {
        // copied attributes from Green Ooze Channel
        spellInfo->Attributes |= SPELL_ATTR0_NO_IMMUNITIES;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
    });
 
    ApplySpellFix({
        71412,  // Green Ooze Summon (Professor Putricide)
        71415   // Orange Ooze Summon (Professor Putricide)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
    });
 
    ApplySpellFix({
        71621,  // Create Concoction (Professor Putricide)
        72850,
        72851,
        72852,
        71893,  // Guzzle Potions (Professor Putricide)
        73120,
        73121,
        73122
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->CastTimeEntry = sSpellCastTimesStore.LookupEntry(15); // 4 sec
    });
 
    // Mutated Plague (Professor Putricide)
    ApplySpellFix({ 72454, 72464, 72506, 72507 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx4 |= SPELL_ATTR4_NO_CAST_LOG;
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_50000_YARDS); // 50000yd
    });
 
    // Unbound Plague (Professor Putricide) (needs target selection script)
    ApplySpellFix({ 70911, 72854, 72855, 72856 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ENEMY);
    });
 
    // Mutated Transformation (Professor Putricide)
    ApplySpellFix({ 70402, 72511, 72512, 72513 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_CANT_CRIT;
    });
 
    // Empowered Flare (Blood Prince Council)
    ApplySpellFix({ 71708, 72785, 72786, 72787 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_IGNORE_CASTER_MODIFIERS;
    });
 
    ApplySpellFix({
        71518,  // Unholy Infusion Quest Credit (Professor Putricide)
        72934,  // Blood Infusion Quest Credit (Blood-Queen Lana'thel)
        72289   // Frost Infusion Quest Credit (Sindragosa)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_200_YARDS);   // another missing radius
    });
 
    // Swarming Shadows
    ApplySpellFix({ 71266, 72890 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AreaGroupId = 0; // originally, these require area 4522, which is... outside of Icecrown Citadel
    });
 
    ApplySpellFix({
        71301,  // Summon Dream Portal (Valithria Dreamwalker)
        71977   // Summon Nightmare Portal (Valithria Dreamwalker)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_DEST);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
    });
 
    // Column of Frost (visual marker)
    ApplySpellFix({ 70715 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(32); // 6 seconds (missing)
    });
 
    // Mana Void (periodic aura)
    ApplySpellFix({ 71085 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(9); // 30 seconds (missing)
    });
 
    // Summon Suppressor (needs target selection script)
    ApplySpellFix({ 70936 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
    });
 
    // Corruption
    ApplySpellFix({ 70602 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_DOT_STACKING_RULE;
    });
 
    ApplySpellFix({
        72706,  // Achievement Check (Valithria Dreamwalker)
        71357   // Order Whelp
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_200_YARDS);   // 200yd
    });
 
    // Sindragosa's Fury
    ApplySpellFix({ 70598 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_DEST);
    });
 
    // Tail Smash (Sindragosa)
    ApplySpellFix({ 71077 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_CASTER_BACK);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_DEST_AREA_ENEMY);
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_DEST_CASTER_BACK);
        spellInfo->Effects[EFFECT_1].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_DEST_AREA_ENEMY);
    });
 
    // Frost Bomb
    ApplySpellFix({ 69846 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Speed = 0.0f;    // This spell's summon happens instantly
    });
 
    // Mystic Buffet (Sindragosa)
    ApplySpellFix({ 70127, 72528, 72529, 72530 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = 0; // remove obsolete spell effect with no targets
    });
 
    // Sindragosa, Frost Aura
    ApplySpellFix({ 70084, 71050, 71051, 71052 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes &= ~SPELL_ATTR0_NO_IMMUNITIES;
    });
 
    // Ice Lock
    ApplySpellFix({ 71614 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Mechanic = MECHANIC_STUN;
    });
 
    // Lich King, Infest
    ApplySpellFix({ 70541, 73779, 73780, 73781 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Lich King, Necrotic Plague
    ApplySpellFix({ 70337, 73912, 73913, 73914, 70338, 73785, 73786, 73787 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
    });
 
    ApplySpellFix({
        69099,  // Ice Pulse 10n
        73776,  // Ice Pulse 25n
        73777,  // Ice Pulse 10h
        73778   // Ice Pulse 25h
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_CANT_CRIT;
        spellInfo->AttributesEx4 &= ~SPELL_ATTR4_NO_CAST_LOG;
    });
 
    // Fury of Frostmourne
    ApplySpellFix({ 72350 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_50000_YARDS); // 50000yd
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_50000_YARDS); // 50000yd
    });
 
    ApplySpellFix({
        72351,  // Fury of Frostmourne
        72431,  // Jump (removes Fury of Frostmourne debuff)
        72429,  // Mass Resurrection
        73159   // Play Movie
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_50000_YARDS); // 50000yd
    });
 
    // Raise Dead
    ApplySpellFix({ 72376 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 4;
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_50000_YARDS); // 50000yd
    });
 
    // Jump
    ApplySpellFix({ 71809 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(5); // 40yd
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_10_YARDS); // 10yd
        spellInfo->Effects[EFFECT_0].MiscValue = 190;
    });
 
    // Broken Frostmourne
    ApplySpellFix({ 72405 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_200_YARDS); // 200yd
    });
 
    // Summon Shadow Trap
    ApplySpellFix({ 73540 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(3); // 60 seconds
    });
 
    // Shadow Trap (visual)
    ApplySpellFix({ 73530 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(28); // 5 seconds
    });
 
    // Shadow Trap
    ApplySpellFix({ 73529 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_10_YARDS); // 10yd
    });
 
    // Shadow Trap (searcher)
    ApplySpellFix({ 74282 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_3_YARDS); // 3yd
    });
 
    // Raging Spirit Visual
    ApplySpellFix({ 69198 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(13); // 50000yd
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
    });
 
    // Defile
    ApplySpellFix({ 72762 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(559); // 53 seconds
        spellInfo->ExcludeCasterAuraSpell = 0;
        spellInfo->Attributes |= SPELL_ATTR0_NO_IMMUNITIES;
        spellInfo->AttributesEx6 |= (SPELL_ATTR6_IGNORE_PHASE_SHIFT | SPELL_ATTR6_CAN_TARGET_UNTARGETABLE);
    });
 
    // Defile
    ApplySpellFix({ 72743 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(22); // 45 seconds
    });
 
    ApplySpellFix({ 72754, 73708, 73709, 73710 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_200_YARDS); // 200yd
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_200_YARDS); // 200yd
    });
 
    // Val'kyr Target Search
    ApplySpellFix({ 69030 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_200_YARDS); // 200yd
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_200_YARDS); // 200yd
        spellInfo->Attributes |= SPELL_ATTR0_NO_IMMUNITIES;
    });
 
    // Harvest Souls
    ApplySpellFix({ 73654, 74295, 74296, 74297 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_50000_YARDS); // 50000yd
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_50000_YARDS); // 50000yd
        spellInfo->Effects[EFFECT_2].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_50000_YARDS); // 50000yd
    });
 
    // Restore Soul
    ApplySpellFix({ 72595, 73650 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_200_YARDS); // 200yd
    });
 
    // Kill Frostmourne Players
    ApplySpellFix({ 75127 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_50000_YARDS); // 50000yd
    });
 
    // Harvest Soul
    ApplySpellFix({ 73655 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_IGNORE_CASTER_MODIFIERS;
    });
 
    // Destroy Soul
    ApplySpellFix({ 74086 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_200_YARDS); // 200yd
    });
 
    // Summon Spirit Bomb
    ApplySpellFix({ 74302, 74342 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_200_YARDS); // 200yd
        spellInfo->MaxAffectedTargets = 1;
    });
 
    // Summon Spirit Bomb
    ApplySpellFix({ 74341, 74343 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_200_YARDS); // 200yd
        spellInfo->MaxAffectedTargets = 3;
    });
 
    // Summon Spirit Bomb
    ApplySpellFix({ 73579 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_25_YARDS); // 25yd
    });
 
    // Trigger Vile Spirit (Inside, Heroic)
    ApplySpellFix({ 73582 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_50000_YARDS); // 50000yd
    });
 
    // Scale Aura (used during Dominate Mind from Lady Deathwhisper)
    ApplySpellFix({ 73261 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AuraInterruptFlags |= AURA_INTERRUPT_FLAG_CHANGE_MAP;
    });
 
    // Leap to a Random Location
    ApplySpellFix({ 70485 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(6); // 100yd
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_10_YARDS);
        spellInfo->Effects[EFFECT_0].MiscValue = 100;
    });
 
    ApplySpellFix({ 74509 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_20_YARDS); // 20yd
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_20_YARDS); // 20yd
        spellInfo->Effects[EFFECT_2].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_20_YARDS); // 20yd
    });
 
    // Rallying Shout
    ApplySpellFix({ 75414 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_20_YARDS); // 20yd
    });
 
    // Barrier Channel
    ApplySpellFix({ 76221 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ChannelInterruptFlags &= ~(AURA_INTERRUPT_FLAG_TURNING | AURA_INTERRUPT_FLAG_MOVE);
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_NEARBY_ENTRY);
    });
 
    // Intimidating Roar
    ApplySpellFix({ 74384 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_100_YARDS); // 100yd
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_100_YARDS); // 100yd
    });
 
    ApplySpellFix({
        74562,  // Fiery Combustion
        74792   // Soul Consumption
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx |= SPELL_ATTR1_NO_REDIRECTION;
    });
 
    // Combustion
    ApplySpellFix({ 75883, 75884 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_6_YARDS); // 6yd
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_6_YARDS); // 6yd
    });
 
    // Consumption
    ApplySpellFix({ 75875, 75876 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_6_YARDS); // 6yd
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_6_YARDS); // 6yd
        spellInfo->Effects[EFFECT_0].Mechanic = MECHANIC_NONE;
        spellInfo->Effects[EFFECT_1].Mechanic = MECHANIC_SNARE;
    });
 
    // Soul Consumption
    ApplySpellFix({ 74799 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_12_YARDS); // 12yd
    });
 
    // Twilight Cutter
    ApplySpellFix({ 74769, 77844, 77845, 77846 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_100_YARDS); // 100yd
    });
 
    // Twilight Mending
    ApplySpellFix({ 75509 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx6 |= SPELL_ATTR6_IGNORE_PHASE_SHIFT;
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_100_YARDS); // 100yd
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_100_YARDS); // 100yd
    });
 
    // Meteor Strike
    ApplySpellFix({ 74637 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Speed = 0;
    });
 
    //Blazing Aura
    ApplySpellFix({ 75885, 75886 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx4 &= ~SPELL_ATTR4_NO_CAST_LOG;
    });
 
    ApplySpellFix({
        75952,  //Meteor Strike
        74629   //Combustion Periodic
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx4 &= ~SPELL_ATTR4_NO_CAST_LOG;
    });
 
    // Going Bearback
    ApplySpellFix({ 54897 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = SPELL_EFFECT_DUMMY;
        spellInfo->Effects[EFFECT_1].RadiusEntry = spellInfo->Effects[EFFECT_0].RadiusEntry;
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_DEST_AREA_ENTRY);
    });
 
    // Still At It
    ApplySpellFix({ 51931, 51932, 51933 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(38);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
    });
 
    // Rallying the Troops
    ApplySpellFix({ 47394 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ExcludeTargetAuraSpell = 47394;
    });
 
    // A Tangled Skein
    ApplySpellFix({ 51165, 51173 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    ApplySpellFix({
        69563,  // A Cloudlet of Classy Cologne
        69445,  // A Perfect Puff of Perfume
        69489   // Bonbon Blitz
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
    });
 
    // Control
    ApplySpellFix({ 30790 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].MiscValue = 0;
    });
 
    // Reclusive Runemaster
    ApplySpellFix({ 48028 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_SRC_CASTER);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ENEMY);
    });
 
    // Mastery of
    ApplySpellFix({ 65147 }, [](SpellInfo* spellInfo)
    {
        spellInfo->CategoryEntry = sSpellCategoryStore.LookupEntry(1244);
        spellInfo->CategoryRecoveryTime = 1500;
    });
 
    // Weakness to Lightning
    ApplySpellFix({ 46432 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 &= ~SPELL_ATTR3_ALLOW_AURA_WHILE_DEAD;
    });
 
    // Wrangle Some Aether Rays!
    ApplySpellFix({ 40856 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(27); // 3000ms
    });
 
    // The Black Knight's Orders
    ApplySpellFix({ 63163 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = 52390;
    });
 
    // The Warp Rifts
    ApplySpellFix({ 34888 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(5); // 300 secs
    });
 
    // The Smallest Creatures
    ApplySpellFix({ 38544 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].MiscValueB = 427;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(1);
        spellInfo->Effects[EFFECT_1].Effect = 0;
    });
 
    // Ridding the red rocket
    ApplySpellFix({ 49177 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = 1; // corrects seat id (points - 1 = seatId)
    });
 
    // Jormungar Strike
    ApplySpellFix({ 56513 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RecoveryTime = 2000;
    });
 
    ApplySpellFix({
        37851, // Tag Greater Felfire Diemetradon
        37918  // Arcano-pince
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->RecoveryTime = 3000;
    });
 
    ApplySpellFix({
        54997, // Cast Net (tooltip says 10s but sniffs say 6s)
        56524  // Acid Breath
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->RecoveryTime = 6000;
    });
 
    ApplySpellFix({
        47911, // EMP
        48620, // Wing Buffet
        51752  // Stampy's Stompy-Stomp
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->RecoveryTime = 10000;
    });
 
    ApplySpellFix({
        37727, // Touch of Darkness
        54996  // Ice Slick (tooltip says 20s but sniffs say 12s)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->RecoveryTime = 12000;
    });
 
    // Signal Helmet to Attack
    ApplySpellFix({ 51748 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RecoveryTime = 15000;
    });
 
    ApplySpellFix({
        51756, // Charge
        37919, //Arcano-dismantle
        37917  //Arcano-Cloak
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->RecoveryTime = 20000;
    });
 
    // Kaw the Mammoth Destroyer
    ApplySpellFix({ 46260 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // That's Abominable
    ApplySpellFix({ 59565 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].MiscValueB = 1721; // controllable guardian
    });
 
    // Investigate the Blue Recluse (1920)
    // Investigate the Alchemist Shop (1960)
    ApplySpellFix({ 9095 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_DUMMY;
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_10_YARDS); // 10yd
    });
 
    // Gauging the Resonant Frequency (10594)
    ApplySpellFix({ 37390 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].MiscValueB = 181;
    });
 
    // Where in the World is Hemet Nesingwary? (12521)
    ApplySpellFix({ 50860 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = 50860;
    });
 
    ApplySpellFix({ 50861 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = 0;
    });
 
    // Riding Jokkum
    ApplySpellFix({ 56606 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = 1;
    });
 
    // Blightbeasts be Damned! (12072)
    ApplySpellFix({ 47424 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AuraInterruptFlags &= ~AURA_INTERRUPT_FLAG_NOT_ABOVEWATER;
    });
 
    // Dark Horizon (12664), Reunited (12663)
    ApplySpellFix({ 52190 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = 52391 - 1;
    });
 
    // The Sum is Greater than the Parts (13043) - Chained Grip
    ApplySpellFix({ 60540 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].MiscValue = 300;
    });
 
    // Not a Bug (13342)
    ApplySpellFix({ 60531 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_ALLOW_DEAD_TARGET;
    });
 
    // Frankly,  It Makes No Sense... (10672)
    ApplySpellFix({ 37851 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    // Honor Challenge (12939)
    ApplySpellFix({ 21855 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    // Convocation at Zol'Heb (12730)
    ApplySpellFix({ 52956 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_DEST_AREA_ENTRY);
    });
 
    // Mangletooth
    ApplySpellFix({
        7764,   // Wisdom of Agamaggan
        10767,  // Rising Spirit
        16610,  // Razorhide
        16612,  // Agamaggan's Strength
        16618,  // Spirit of the Wind
        17013   // Agamaggan's Agility
        }, [](SpellInfo* spellInfo)
 
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
        spellInfo->AttributesEx5 |= SPELL_ATTR5_ALWAYS_AOE_LINE_OF_SIGHT;
    });
 
    // Battle for the Undercity
    ApplySpellFix({
        59892   // Cyclone fall
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_APPLY_AREA_AURA_FRIEND;
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_10_YARDS); // 10yd
        spellInfo->AttributesEx &= ~SPELL_ATTR0_NO_AURA_CANCEL;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ONLY_ON_PLAYER;
    });
 
    // enchant Lightweave Embroidery
    ApplySpellFix({ 55637 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].MiscValue = 126;
    });
 
    ApplySpellFix({
        47977, // Magic Broom
        65917  // Magic Rooster
        }, [](SpellInfo* spellInfo)
    {
        // First two effects apply auras, which shouldn't be there
        // due to NO_TARGET applying aura on current caster (core bug)
        // Just wipe effect data, to mimic blizz-behavior
        spellInfo->Effects[EFFECT_0].Effect = 0;
        spellInfo->Effects[EFFECT_1].Effect = 0;
    });
 
    // Titanium Seal of Dalaran, Toss your luck
    ApplySpellFix({ 60476 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
    });
 
    // Mind Amplification Dish, change charm aura
    ApplySpellFix({ 26740 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_MOD_CHARM;
    });
 
    // Deadly Swiftness
    ApplySpellFix({ 31255 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TriggerSpell = 22588;
    });
 
    // Black Magic enchant
    ApplySpellFix({ 59630 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_PASSIVE;
    });
 
    // Precious's Ribbon
    ApplySpellFix({ 72968 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALLOW_AURA_WHILE_DEAD;
    });
 
    ApplySpellFix({
        71646,  // Item - Bauble of True Blood 10m
        71607,  // Item - Bauble of True Blood 25m
        71610,  // Item - Althor's Abacus trigger 10m
        71641   // Item - Althor's Abacus trigger 25m
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->DmgClass = SPELL_DAMAGE_CLASS_MAGIC;
        spellInfo->SpellLevel = 0;
    });
 
    ApplySpellFix({
        6789,  // Warlock - Death Coil (Rank 1)
        17925, // Warlock - Death Coil (Rank 2)
        17926, // Warlock - Death Coil (Rank 3)
        27223, // Warlock - Death Coil (Rank 4)
        47859, // Warlock - Death Coil (Rank 5)
        71838, // Drain Life - Bryntroll Normal
        71839  // Drain Life - Bryntroll Heroic
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_CANT_CRIT;
    });
 
    // Alchemist's Stone
    ApplySpellFix({ 17619 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALLOW_AURA_WHILE_DEAD;
    });
 
    // Stormchops
    ApplySpellFix({ 43730 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(1);
        spellInfo->Effects[EFFECT_1].TargetB = SpellImplicitTargetInfo();
    });
 
    // Savory Deviate Delight (transformations), allow to mount while transformed
    ApplySpellFix({ 8219, 8220, 8221, 8222 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes &= ~SPELL_ATTR0_NO_IMMUNITIES;
    });
 
    // Clamlette Magnifique
    ApplySpellFix({ 72623 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = spellInfo->Effects[EFFECT_1].BasePoints;
    });
 
    // Compact Harvest Reaper
    ApplySpellFix({ 4078 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(6); // 10 minutes
    });
 
    // Dragon Kite, Tuskarr Kite - Kite String
    ApplySpellFix({ 45192 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(6); // 100yd
    });
 
    // Frigid Frostling, Infrigidate
    ApplySpellFix({ 74960 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_20_YARDS); // 20yd
    });
 
    // Apple Trap
    ApplySpellFix({ 43450 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ENEMY);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_DUMMY;
    });
 
    // Dark Iron Attack - spawn mole machine
    ApplySpellFix({ 43563 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].Effect = 0; // summon GO's manually
    });
 
    // Throw Mug visual
    ApplySpellFix({ 42300 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
    });
 
    // Dark Iron knockback Aura
    ApplySpellFix({ 42299 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].ApplyAuraName = SPELL_AURA_DUMMY;
        spellInfo->Effects[EFFECT_0].MiscValue = 100;
        spellInfo->Effects[EFFECT_0].BasePoints = 79;
    });
 
    // Chug and Chuck!
    ApplySpellFix({ 42436 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_SRC_CASTER);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_UNIT_SRC_AREA_ENTRY);
        spellInfo->MaxAffectedTargets = 0;
        spellInfo->ExcludeCasterAuraSpell = 42299;
    });
 
    // Brewfest quests
    ApplySpellFix({ 47134, 51798 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = 0;
    });
 
    // The Heart of The Storms (12998)
    ApplySpellFix({ 43528 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(18);
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(25);
    });
 
    // Water splash
    ApplySpellFix({ 42348 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = 0;
    });
 
    // Summon Lantersn
    ApplySpellFix({ 44255, 44231 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_DEST);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
    });
 
    // Throw Head Back
    ApplySpellFix({ 42401 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_NEARBY_ENTRY);
    });
 
    // Food
    ApplySpellFix({ 65418 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].TriggerSpell = 65410;
    });
 
    ApplySpellFix({ 65422 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].TriggerSpell = 65414;
    });
 
    ApplySpellFix({ 65419 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].TriggerSpell = 65416;
    });
 
    ApplySpellFix({ 65420 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].TriggerSpell = 65412;
    });
 
    ApplySpellFix({ 65421 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].TriggerSpell = 65415;
    });
 
    // Stamp Out Bonfire
    ApplySpellFix({ 45437 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = SPELL_EFFECT_DUMMY;
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_NEARBY_ENTRY);
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Light Bonfire (DND)
    ApplySpellFix({ 29831 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Infernal
    ApplySpellFix({ 33240 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
    });
 
    ApplySpellFix({
        47476,  // Deathknight - Strangulate
        15487,  // Priest - Silence
        5211,   // Druid - Bash  - R1
        6798,   // Druid - Bash  - R2
        8983    // Druid - Bash  - R3
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx7 |= SPELL_ATTR7_CAN_CAUSE_INTERRUPT;
    });
 
    // Shadowmeld
    ApplySpellFix({ 58984 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ONLY_ON_PLAYER;
    });
 
    // Flare activation speed
    ApplySpellFix({ 1543 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Speed = 0.0f;
    });
 
    // Light's Beacon
    ApplySpellFix({ 53651 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx |= SPELL_ATTR1_NO_THREAT;
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_DOT_STACKING_RULE;
    });
 
    // Shadow Hunter Vosh'gajin - Hex
    ApplySpellFix({ 16097 }, [](SpellInfo* spellInfo)
    {
        spellInfo->CastTimeEntry = sSpellCastTimesStore.LookupEntry(16);
    });
 
    // Sacred Cleansing
    ApplySpellFix({ 53659 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(5); // 40yd
    });
 
    // Silithyst
    ApplySpellFix({ 29519 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].ApplyAuraName = SPELL_AURA_MOD_DECREASE_SPEED;
        spellInfo->Effects[EFFECT_0].BasePoints = -25;
    });
 
    // Eye of Kilrogg Passive (DND)
    ApplySpellFix({ 2585 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AuraInterruptFlags |= AURA_INTERRUPT_FLAG_HITBYSPELL | AURA_INTERRUPT_FLAG_TAKE_DAMAGE;
    });
 
    // Nefarius Corruption
    ApplySpellFix({ 23642 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 1;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo();
    });
 
    // Conflagration, Horseman's Cleave
    ApplySpellFix({ 42380, 42587 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
    });
 
    // Serverside - Summon Arcane Disruptor
    ApplySpellFix({ 49591 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ProcChance = 101;
        spellInfo->Effects[EFFECT_1].Effect = 24;
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(25);
        spellInfo->Effects[EFFECT_1].ItemType = 37888;
    });
 
    // Serverside - Create Rocket Pack
    ApplySpellFix({ 70055 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ProcChance = 101;
        spellInfo->Effects[EFFECT_1].Effect = 24;
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(25);
        spellInfo->Effects[EFFECT_1].ItemType = 49278;
    });
 
    // Ashenvale Outrunner Sneak
    // Stealth
    ApplySpellFix({ 20540, 32199 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AuraInterruptFlags |= (AURA_INTERRUPT_FLAG_MELEE_ATTACK | AURA_INTERRUPT_FLAG_CAST);
    });
 
     // Arcane Bolt
    ApplySpellFix({ 15979 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(3); // 20y
    });
 
    // Mortal Shots
    ApplySpellFix({ 19485, 19487, 19488, 19489, 19490 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].SpellClassMask[0] |= 0x00004000;
        spellInfo->Effects[EFFECT_1].Effect = 0;
    });
 
    // Item - Death Knight T9 Melee 4P Bonus
    // Item - Hunter T9 2P Bonus
    // Item - Paladin T9 Retribution 2P Bonus (Righteous Vengeance)
    ApplySpellFix({ 67118, 67150, 67188 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = 0;
    });
 
    // Green Beam
    ApplySpellFix({31628, 31630, 31631}, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
        spellInfo->MaxAffectedTargets = 1;
    });
 
    ApplySpellFix({
        20271, 57774,  // Judgement of Light
        20425,         // Judgement of Command
        32220,         // Judgement of Blood
        53407,         // Judgement of Justice
        53408,         // Judgement of Wisdom
        53725          // Judgement of the Martyr
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 &= ~SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
     // Chaos Bolt Passive
    ApplySpellFix({ 58284 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = SPELL_EFFECT_APPLY_AURA;
        spellInfo->Effects[EFFECT_1].ApplyAuraName = SPELL_AURA_MOD_ABILITY_IGNORE_TARGET_RESIST;
        spellInfo->Effects[EFFECT_1].BasePoints = 100;
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
        spellInfo->Effects[EFFECT_1].MiscValue = 127;
        spellInfo->Effects[EFFECT_1].SpellClassMask[1] = 0x00020000;
    });
 
    // Nefarian: Shadowbolt, Shadow Command
    ApplySpellFix({ 22667, 22677 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(152); // 150 yards
    });
 
    // Manastorm
    ApplySpellFix({ 21097 }, [](SpellInfo* spellInfo)
    {
        spellInfo->InterruptFlags &= ~SPELL_INTERRUPT_FLAG_INTERRUPT;
    });
 
    // Arcane Vacuum
    ApplySpellFix({ 21147 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(4); // 30 yards
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ONLY_ON_PLAYER;
    });
 
    // Reflection
    ApplySpellFix({ 22067 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Dispel = DISPEL_NONE;
    });
 
    // Focused Assault
    // Brutal Assault
    ApplySpellFix({ 46392, 46393 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AuraInterruptFlags |= AURA_INTERRUPT_FLAG_CHANGE_MAP;
    });
 
    // Improved Blessing Protection (Nefarian Class Call)
    ApplySpellFix({ 23415 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_TARGET_ENEMY);
    });
 
    // Bestial Wrath
    ApplySpellFix({ 19574 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx4 |= SPELL_ATTR4_AURA_EXPIRES_OFFLINE;
    });
 
    // Shadowflame
    ApplySpellFix({ 22539 }, [](SpellInfo* spellInfo)
    {
        spellInfo->InterruptFlags &= ~SPELL_INTERRUPT_FLAG_INTERRUPT;
    });
 
    // PX-238 Winter Wondervolt
    ApplySpellFix({ 26157, 26272, 26273, 26274 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Mechanic = 0;
    });
 
    // Calm Dragonkin
    ApplySpellFix({ 19872 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx |= SPELL_ATTR1_EXCLUDE_CASTER;
    });
 
    // Cosmetic - Lightning Beam Channel
    ApplySpellFix({ 45537 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Burning Adrenaline
    ApplySpellFix({ 23478 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = 4374;
        spellInfo->Effects[EFFECT_0].DieSides = 1250;
    });
 
    // Explosion - Razorgore
    ApplySpellFix({ 20038 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_50000_YARDS);
        spellInfo->Attributes |= SPELL_ATTR0_NO_IMMUNITIES;
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Brood Power : Bronze
    ApplySpellFix({ 22311 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_CASTER_PROCS;
    });
 
    // Rapture
    ApplySpellFix({ 63652, 63653, 63654, 63655 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx |= SPELL_ATTR1_NO_THREAT;
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    // Everlasting Affliction
    ApplySpellFix({ 47422 }, [](SpellInfo* spellInfo)
    {
        spellInfo->SchoolMask = SPELL_SCHOOL_MASK_SHADOW;
    });
 
    // Flametongue Weapon (Passive) (Rank 6)
    ApplySpellFix({ 16312 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_PASSIVE;
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(21);
    });
 
    // Mana Tide Totem
    // Cleansing Totem Effect
    ApplySpellFix({ 39609, 52025 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(5); // 40yd
    });
 
    // Increased Totem Radius
    ApplySpellFix({ 21895 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[0].SpellClassMask = flag96(0x0603E000, 0x00200100);
    });
 
    // Jokkum Summon
    ApplySpellFix({ 56541 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].MiscValueB = 844;
    });
 
    // Hakkar Cause Insanity
    ApplySpellFix({ 24327 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Dispel = DISPEL_NONE;
    });
 
    // Summon Nightmare Illusions
    ApplySpellFix({ 24681, 24728, 24729 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].MiscValueB = 64;
    });
 
    // Blood Siphon
    ApplySpellFix({ 24322, 24323 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].ApplyAuraName = SPELL_AURA_MOD_STUN;
        spellInfo->Effects[EFFECT_2].Effect = 0;
        spellInfo->Attributes |= SPELL_ATTR0_NO_AURA_CANCEL;
        spellInfo->AttributesEx5 |= SPELL_ATTR5_ALLOW_ACTION_DURING_CHANNEL;
        spellInfo->ChannelInterruptFlags &= ~AURA_INTERRUPT_FLAG_MOVE;
    });
 
    // Place Fake Fur
    ApplySpellFix({ 46085 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].MiscValue = 8;
    });
 
    // Smash Mammoth Trap
    ApplySpellFix({ 46201 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].MiscValue = 8;
    });
 
    // Elemental Mastery
    ApplySpellFix({ 16166 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].SpellClassMask = flag96(0x00000003, 0x00001000);
    });
 
    // Elemental Vulnerability
    ApplySpellFix({ 28772 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Speed = 1;
    });
 
    // Find the Ancient Hero: Kill Credit
    ApplySpellFix({ 25729 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = TARGET_UNIT_SUMMONER;
    });
 
    // Artorius Demonic Doom
    ApplySpellFix({ 23298 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx4 |= SPELL_ATTR4_IGNORE_DAMAGE_TAKEN_MODIFIERS;
        spellInfo->AttributesEx6 |= SPELL_ATTR6_IGNORE_CASTER_DAMAGE_MODIFIERS;
    });
 
    // Lash
    ApplySpellFix({ 25852 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = 0;
    });
 
    // Explosion
    ApplySpellFix({ 5255 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
    });
 
    // Death's Respite
    ApplySpellFix({ 67731, 68305 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    // Wyvern Sting DoT
    ApplySpellFix({ 24131, 24134, 24135 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ENEMY);
    });
 
     // Feed Pet
    ApplySpellFix({ 1539, 51284 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_ALLOW_WHILE_SITTING;
    });
 
    // Judgement (Paladin T2 8P Bonus)
    // Battlegear of Eternal Justice
    ApplySpellFix({ 23591, 26135 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ProcFlags = PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS;
    });
 
    // Gift of Arthas
    ApplySpellFix({ 11371 }, [](SpellInfo* spellInfo)
    {
        spellInfo->SpellFamilyName = SPELLFAMILY_POTION;
    });
 
    // Refocus (Renataki's charm of beasts)
    ApplySpellFix({ 24531 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
    });
 
    // Collect Rookery Egg
    ApplySpellFix({ 15958 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = 0;
    });
 
    // WotLK Prologue Frozen Shade Visual, temp used to restore visual after Dispersion
    ApplySpellFix({ 53444 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(27);
    });
 
    // Rental Racing Ram
    ApplySpellFix({ 43883 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AuraInterruptFlags &= ~AURA_INTERRUPT_FLAG_NOT_ABOVEWATER;
    });
 
    // Summon Worm
    ApplySpellFix({ 518, 25831, 25832 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].MiscValueB = 64;
    });
 
    // Uppercut
    ApplySpellFix({ 26007 }, [](SpellInfo* spellInfo)
    {
            spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_CASTER_PROCS;
    });
 
    // Digestive Acid (Temporary)
    ApplySpellFix({ 26476 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_NO_IMMUNITIES;
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
    });
 
    // Drums of War/Battle/Speed/Restoration
    ApplySpellFix({ 35475, 35476, 35477, 35478 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ExcludeTargetAuraSpell = 51120;
    });
 
    // Slap!
    ApplySpellFix({ 6754 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx |= SPELL_ATTR1_NO_THREAT;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    // Summon Cauldron Stuff
    ApplySpellFix({ 36549 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(28); // 5 seconds
        spellInfo->Effects[EFFECT_0].TargetB = TARGET_DEST_CASTER;
    });
 
    // Hunter's Mark
    ApplySpellFix({ 31615 }, [](SpellInfo* spellInfo)
    {
        for (uint8 index = EFFECT_0; index <= EFFECT_1; ++index)
        {
            spellInfo->Effects[index].TargetA = TARGET_UNIT_TARGET_ENEMY;
            spellInfo->Effects[index].TargetB = 0;
        }
    });
 
    // Self Visual - Sleep Until Cancelled(DND)
    ApplySpellFix({ 6606, 14915, 16093 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AuraInterruptFlags &= ~AURA_INTERRUPT_FLAG_NOT_SEATED;
    });
 
     // Cleansing Totem, Healing Stream Totem, Mana Tide Totem
    ApplySpellFix({ 8171,52025, 52041, 52042, 52046, 52047, 52048, 52049, 52050, 58759, 58760, 58761, 39610, 39609 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
    // Game In Session
    ApplySpellFix({ 39331 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_APPLY_AURA;
        spellInfo->Attributes |= SPELL_ATTR0_NO_AURA_CANCEL;
        spellInfo->AuraInterruptFlags |= AURA_INTERRUPT_FLAG_CHANGE_MAP;
    });
    // Death Ray Warning Visual, Death Ray Damage Visual
    ApplySpellFix({ 63882, 63886 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx5 |= SPELL_ATTR5_ALLOW_ACTION_DURING_CHANNEL;
    });
 
    // Buffeting Winds of Susurrus
    ApplySpellFix({ 32474 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(556); // 28 seconds
    });
 
    // Quest - Healing Salve
    ApplySpellFix({ 29314 }, [](SpellInfo* spellInfo)
    {
        spellInfo->CastTimeEntry = sSpellCastTimesStore.LookupEntry(1); // 0s
    });
 
    // Seed of Corruption
    ApplySpellFix({ 27285, 47833, 47834 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx |= SPELL_ATTR1_NO_REFLECTION;
    });
 
    // Turn the Tables
    ApplySpellFix({ 51627, 51628, 51629 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_DOT_STACKING_RULE;
    });
 
     // Silence
    ApplySpellFix({ 18278 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx4 |= SPELL_ATTR4_NOT_IN_ARENA_OR_RATED_BATTLEGROUND;
    });
 
    // Honor Among Thieves - allow area aura from different casters to coexist
    ApplySpellFix({ 51698, 51700, 51701 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_DOT_STACKING_RULE;
    });
 
    // Absorb Life
    ApplySpellFix({ 34239 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].ValueMultiplier = 1;
    });
 
    // Summon a Warp Rift in Void Ridge
    ApplySpellFix({ 35036 }, [](SpellInfo* spellInfo)
    {
        spellInfo->CastTimeEntry = sSpellCastTimesStore.LookupEntry(1); // 0s
    });
 
    // Hit Rating (Dungeon T3 - 2P Bonus - Wastewalker, Doomplate)
    ApplySpellFix({ 37608, 37610 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(0);
        spellInfo->Effects[EFFECT_0].MiscValue = 224;
    });
 
    // Target Fissures
    ApplySpellFix({ 30745 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 1;
    });
 
    // Acid Spit
    ApplySpellFix({ 34290 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 1;
    });
 
    // Mulgore Hatchling (periodic)
    ApplySpellFix({ 62586 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TriggerSpell = 62585; // Mulgore Hatchling (fear)
    });
 
    // Poultryized!
    ApplySpellFix({ 30504 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AuraInterruptFlags |= AURA_INTERRUPT_FLAG_TAKE_DAMAGE;
    });
 
    // Torment of the Worgen
    ApplySpellFix({ 30567 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ProcChance = 3;
    });
 
    // Summon Water Elementals
    ApplySpellFix({ 29962, 37051, 37052, 37053 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(13); // 50000yd
    });
 
    // Instill Lord Valthalak's Spirit DND
    ApplySpellFix({ 27360 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ChannelInterruptFlags |= AURA_INTERRUPT_FLAG_MOVE;
    });
 
    // Holiday - Midsummer, Ribbon Pole Periodic Visual
    ApplySpellFix({ 45406 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AuraInterruptFlags |= ( AURA_INTERRUPT_FLAG_MOUNT | AURA_INTERRUPT_FLAG_CAST | AURA_INTERRUPT_FLAG_TALK );
    });
 
    // Improved Mind Flay and Smite
    ApplySpellFix({ 37571 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].SpellClassMask[0] = 8388736;
    });
 
    // Improved Corruption and Immolate (Updated)
    ApplySpellFix({ 61992 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = SPELL_EFFECT_APPLY_AURA;
        spellInfo->Effects[EFFECT_1].ApplyAuraName = SPELL_AURA_ADD_PCT_MODIFIER;
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
        spellInfo->Effects[EFFECT_1].BasePoints = 4;
        spellInfo->Effects[EFFECT_1].DieSides = 1;
        spellInfo->Effects[EFFECT_1].MiscValue = 22;
        spellInfo->Effects[EFFECT_1].SpellClassMask[0] = 6;
    });
 
    // 46747 Fling torch
    ApplySpellFix({ 46747 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_CASTER);
    });
 
    // Chains of Naberius
    ApplySpellFix({ 36146 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 1;
    });
 
    // Force of Neltharaku
    ApplySpellFix({ 38762 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
    });
 
    // Spotlight
    ApplySpellFix({ 29683, 32214 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx5 |= SPELL_ATTR5_DO_NOT_DISPLAY_DURATION;
    });
 
    // Haunted
    ApplySpellFix({ 53768 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_NO_AURA_CANCEL;
    });
 
    // Tidal Wave
    ApplySpellFix({ 37730 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Commanding Shout
    ApplySpellFix({ 469, 47439, 47440 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Battle Shout
    ApplySpellFix({ 2048, 5242, 6192, 6673, 11549, 11550, 11551, 25289, 47436 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Plague Effect
    ApplySpellFix({ 19594, 26557 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Prayer of Fortitude
    ApplySpellFix({ 21562, 21564, 25392, 48162 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Gift of the Wild
    ApplySpellFix({ 21849, 21850, 26991, 48470, 69381 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Arcane Brilliance
    ApplySpellFix({ 23028, 27127, 43002 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Prayer of Spirit
    ApplySpellFix({ 27681, 32999, 48074 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Prayer of Shadow Protection
    ApplySpellFix({ 27683, 39374, 48170 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Nagrand Fort Buff Reward Raid
    ApplySpellFix({ 33006 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Ancestral Awakening
    ApplySpellFix({ 52759 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Turn the Tables
    ApplySpellFix({ 52910, 52914, 52915 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Judgements of the Wise
    ApplySpellFix({ 54180 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Replenishment
    ApplySpellFix({ 57669 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Dalaran Brilliance
    ApplySpellFix({ 61316 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // [DND] Dalaran Brilliance
    ApplySpellFix({ 61332 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Infinite Replenishment + Wisdom
    ApplySpellFix({ 61782 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Renewed Hope
    ApplySpellFix({ 63944 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Fortitude
    ApplySpellFix({ 69377 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Blessing of Forgotten Kings
    ApplySpellFix({ 69378 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Lucky Charm
    ApplySpellFix({ 69511 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Shiny Shard of the Scale Heal Targeter
    ApplySpellFix({ 69749 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Purified Shard of the Scale Heal Targeter
    ApplySpellFix({ 69754 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Brilliance
    ApplySpellFix({ 69994 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Domination
    ApplySpellFix({ 37135 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 5;
    });
 
    // Presence Of Mind
    ApplySpellFix({ 12043 }, [](SpellInfo* spellInfo)
    {
        // It should not share cooldown mods with category[1151] spells (Arcane Power [12042], Decimate [47271])
        spellInfo->AttributesEx6 |= SPELL_ATTR6_NO_CATEGORY_COOLDOWN_MODS;
    });
 
    // Eye of Grillok
    ApplySpellFix({ 38495 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TriggerSpell = 38530; // Quest Credit for Eye of Grillok
    });
 
    // Greater Fireball
    ApplySpellFix({ 33051 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx4 |= SPELL_ATTR4_NO_CAST_LOG;
    });
 
    // Gor'drek's Ointment
    ApplySpellFix({ 32578 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_CASTER_PROCS;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_TARGET_PROCS;
    });
 
    // Shadow Grasp
    ApplySpellFix({ 30410 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx6 |= SPELL_ATTR6_NO_PUSHBACK;
    });
 
    ApplySpellFix({
        471, // Palamino
        8980, // Skeletal Horse
        10788, // Leopard
        10790, // Tiger
        10792, // Spotted Panther
        60136, // Grand Caravan Mammoth
        60140 // Grand Caravan Mammoth
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AuraInterruptFlags &= ~AURA_INTERRUPT_FLAG_NOT_ABOVEWATER;
    });
 
    // Molten Punch
    ApplySpellFix({ 40126 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(TARGET_DEST_CASTER);
    });
 
    // Wing Buffet
    ApplySpellFix({ 37319 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CONE_ENEMY_24);
        spellInfo->Effects[EFFECT_0].TargetB = SpellImplicitTargetInfo(0);
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_20_YARDS);
    });
 
    // Flame Wave
    ApplySpellFix({ 33800 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = SPELL_EFFECT_APPLY_AURA;
        spellInfo->Effects[EFFECT_1].ApplyAuraName = SPELL_AURA_PERIODIC_TRIGGER_SPELL;
        spellInfo->Effects[EFFECT_1].Amplitude = 500;
    });
 
    // Chromatic Resistance Aura
    ApplySpellFix({ 41453 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].MiscValue = 124;
    });
 
    // Power of the Guardian
    ApplySpellFix({ 28142, 28143, 28144, 28145 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALLOW_AURA_WHILE_DEAD;
    });
 
    // Warrior stances passives
    ApplySpellFix({
        2457, // Battle Stance
        2458, // Berserker Stance
        7376  // Defensive Stance Passive
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_CASTER_PROCS;
    });
 
    // Conjure Refreshment Table (Rank 1, Rank 2)
    ApplySpellFix({ 43985, 58661 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_CASTER_FRONT);
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_5_YARDS);
    });
 
    ApplySpellFix({
        698, // Ritual of Summoning (portal for clicking)
        61993 // Ritual of Summoning (summons the closet)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_3_YARDS);
    });
 
    // Paralyze
    ApplySpellFix({ 41083 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx5 |= SPELL_ATTR5_ALLOW_ACTION_DURING_CHANNEL;
    });
 
    // Fatal Attraction
    ApplySpellFix({ 40869 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].TargetB = SpellImplicitTargetInfo(TARGET_DEST_CASTER); // target set by script
    });
 
    // Fatal Attraction
    ApplySpellFix({ 40870 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 1;
    });
 
    // Removing Dragonflayer Harpoon
    ApplySpellFix({ 42968 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 1;
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(7);
    });
 
    // Siphon Life (heal)
    ApplySpellFix({ 63106 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_CASTER_PROCS;
    });
 
    // Fury
    ApplySpellFix({ 40601 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_CASTER_PROCS;
    });
 
    // Claw Rage
    ApplySpellFix({ 43149 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TriggerSpell = 0;
    });
 
    // Black Qiraji Battle Tank
    ApplySpellFix({ 26655, 26656 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AuraInterruptFlags &= ~(AURA_INTERRUPT_FLAG_CHANGE_MAP | AURA_INTERRUPT_FLAG_TELEPORTED);
    });
 
    // Summon Cyclone
    ApplySpellFix({ 43112 }, [](SpellInfo* spellInfo)
    {
        spellInfo->RequiresSpellFocus = 0;
    });
 
    // Booming Voice
    ApplySpellFix({ 40080 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RealPointsPerLevel = 0;
    });
 
    // Mangle (Nalorakk)
    ApplySpellFix({ 42389 }, [](SpellInfo* spellInfo)
    {
        spellInfo->SchoolMask = SPELL_SCHOOL_MASK_NATURE;
    });
 
    // Event food, fixes to give correct stamina and spirit of 25% of the character level
    ApplySpellFix({ 24870 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].BasePoints = 0;
        spellInfo->Effects[EFFECT_0].RealPointsPerLevel = 0.25;
        spellInfo->Effects[EFFECT_1].RealPointsPerLevel = 0.25;
    });
 
    // Smash
    // Dark Smash
    ApplySpellFix({ 42669, 59706, 42723, 59709 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 &= ~SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
    });
 
    // Swoop (Moth hunter pet) root effect fix
    ApplySpellFix({ 52825 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ENEMY);
    });
 
    // Felmyst Strafe (Top)
    ApplySpellFix({ 45585 }, [](SpellInfo* spellInfo)
    {
        spellInfo->MaxAffectedTargets = 3;
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_70_YARDS);
    });
 
    // Felmyst Strafe (Middle, Bottom)
    ApplySpellFix({ 45633, 45635 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_70_YARDS);
    });
 
    ApplySpellFix({
        45662, // Encapsulate
        45642  // Fire Bloom
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx7 |= SPELL_ATTR7_TREAT_AS_NPC_AOE;
    });
 
    // Torch (Death Knights near the Chapel)
    ApplySpellFix({ 52953 }, [](SpellInfo* spellInfo)
        {
            spellInfo->MaxAffectedTargets = 1;
        });
 
    // Missile Barrage
    ApplySpellFix({ 44401 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ProcCharges = 1;
        spellInfo->SpellPriority = 100;
    });
 
    // Item - Mage T8 4P Bonus
    ApplySpellFix({ 64869 }, [](SpellInfo* spellInfo)
    {
        // DBC amount is 10, but the chance to not consume Missile Barrage,
        // Hot Streak or Brain Freeze is 20% according to the available sources
        spellInfo->Effects[EFFECT_0].BasePoints = 20;
        spellInfo->Effects[EFFECT_0].DieSides = 0;
    });
 
    // Auto Shot
    ApplySpellFix({ 75 }, [](SpellInfo* spellInfo)
    {
        spellInfo->CastTimeEntry = sSpellCastTimesStore.LookupEntry(1); // 0s
        spellInfo->InterruptFlags &= ~SPELL_INTERRUPT_UNK;
    });
 
    // Life Tap
    ApplySpellFix({ 1454 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RealPointsPerLevel = 0.0f;
    });
 
    // Life Tap
    ApplySpellFix({ 1455, 1456, 11687, 11688, 11689, 27222, 57946 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RealPointsPerLevel = 0.0f;
        spellInfo->MaxLevel = 16;
        spellInfo->BaseLevel = 6;
        spellInfo->SpellLevel = 6;
    });
 
    // Explosive Sheep
    ApplySpellFix({ 4074 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(25);
    });
 
    // Phase Shift
    ApplySpellFix({ 4511 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AuraInterruptFlags &= ~AURA_INTERRUPT_FLAG_MELEE_ATTACK;
        spellInfo->AuraInterruptFlags |= AURA_INTERRUPT_FLAG_CAST;
    });
 
    // Charge Stun
    ApplySpellFix({ 7922 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_NO_ACTIVE_DEFENSE;
    });
 
    // Tharnariun's Heal
    ApplySpellFix({ 9457 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 &= ~SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_IGNORE_CASTER_AND_TARGET_RESTRICTIONS;
        spellInfo->Effects[EFFECT_0].DieSides = 0;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
    });
 
    // Supercharge
    ApplySpellFix({ 10732 }, [](SpellInfo* spellInfo)
    {
        spellInfo->CategoryEntry = sSpellCategoryStore.LookupEntry(0);
        spellInfo->Attributes &= ~(SPELL_ATTR0_IS_ABILITY | SPELL_ATTR0_DO_NOT_SHEATH);
        spellInfo->Attributes |= SPELL_ATTR0_NOT_SHAPESHIFTED;
        spellInfo->AttributesEx |= SPELL_ATTR1_TRACK_TARGET_IN_CHANNEL;
        spellInfo->AttributesEx2 |= SPELL_ATTR2_NO_TARGET_PER_SECOND_COST;
        spellInfo->AttributesEx3 |= SPELL_ATTR3_CAN_PROC_FROM_PROCS;
        spellInfo->FacingCasterFlags |= SPELL_FACING_FLAG_INFRONT;
        spellInfo->InterruptFlags |= (SPELL_INTERRUPT_FLAG_MOVEMENT | SPELL_INTERRUPT_FLAG_PUSH_BACK |
                                      SPELL_INTERRUPT_FLAG_UNK3 | SPELL_INTERRUPT_FLAG_INTERRUPT);
        spellInfo->ChannelInterruptFlags &= ~AURA_INTERRUPT_FLAG_JUMP;
        spellInfo->ChannelInterruptFlags |= AURA_INTERRUPT_FLAG_UNK14;
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ALLY);
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ALLY);
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ALLY);
        spellInfo->Effects[EFFECT_0].Amplitude = 3000;
        spellInfo->Effects[EFFECT_1].Amplitude = 3000;
        spellInfo->Effects[EFFECT_2].Amplitude = 3000;
        spellInfo->SpellVisual[0] = 12656;
    });
 
    // Intercept
    ApplySpellFix({ 20252 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes &= ~(SPELL_ATTR0_IS_ABILITY | SPELL_ATTR0_NOT_SHAPESHIFTED | SPELL_ATTR0_DO_NOT_SHEATH);
        spellInfo->Attributes |= SPELL_ATTR0_ALLOW_ITEM_SPELL_IN_PVP;
    });
 
    // Intercept
    ApplySpellFix({ 20253 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes &= ~(SPELL_ATTR0_IS_ABILITY | SPELL_ATTR0_NOT_SHAPESHIFTED | SPELL_ATTR0_DO_NOT_SHEATH);
        spellInfo->Attributes |= SPELL_ATTR0_ALLOW_ITEM_SPELL_IN_PVP;
        spellInfo->AttributesEx7 |= (SPELL_ATTR7_NO_ATTACK_DODGE | SPELL_ATTR7_NO_ATTACK_PARRY);
        spellInfo->SpellLevel = 0;
    });
 
    // Heart of the Crusader
    ApplySpellFix({ 20335, 20336, 20337 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].Effect = SPELL_EFFECT_APPLY_AURA;
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ENEMY);
        spellInfo->Effects[EFFECT_1].ApplyAuraName = SPELL_AURA_DUMMY;
    });
 
    // Heart of the Crusader (Rank 1)
    ApplySpellFix({ 20335 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].TriggerSpell = 21183; // Heart of the Crusader (Rank 1)
    });
 
    // Heart of the Crusader (Rank 2)
    ApplySpellFix({ 20336 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].TriggerSpell = 54498; // Heart of the Crusader (Rank 2)
    });
 
    // Heart of the Crusader (Rank 3)
    ApplySpellFix({ 20337 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].TriggerSpell = 54499; // Heart of the Crusader (Rank 3)
    });
 
    // Gordok Ogre Suit
    ApplySpellFix({ 22736 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AuraInterruptFlags |= AURA_INTERRUPT_FLAG_MOUNT;
    });
 
    // Soul Flame
    ApplySpellFix({ 23272 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_2].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
    });
 
    // Tree Disguise
    ApplySpellFix({ 30298 }, [](SpellInfo* spellInfo)
    {
        spellInfo->InterruptFlags |= (SPELL_INTERRUPT_FLAG_MOVEMENT | SPELL_INTERRUPT_FLAG_PUSH_BACK |
                                      SPELL_INTERRUPT_FLAG_UNK3 | SPELL_INTERRUPT_FLAG_INTERRUPT);
        spellInfo->Effects[EFFECT_2].ApplyAuraName = SPELL_AURA_MOD_STUN;
    });
 
    // Internal Shake Camera w/ rumble sound
    ApplySpellFix({ 33271 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes |= SPELL_ATTR0_ALLOW_WHILE_MOUNTED;
    });
 
    // Glaive
    ApplySpellFix({ 36500 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes &= ~SPELL_ATTR0_SCALES_WITH_CREATURE_LEVEL;
        spellInfo->Effects[EFFECT_0].DieSides = 68;
        spellInfo->Effects[EFFECT_0].BasePoints = 201;
    });
 
    // Create Anchorite Relic
    ApplySpellFix({ 39183 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].TargetA = SpellImplicitTargetInfo(0);
    });
 
    // Charge Rifts
    ApplySpellFix({ 47747 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_45_YARDS);
    });
 
    // New Summon Test
    ApplySpellFix({ 49214 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(3);
    });
 
    // Plague Strike
    ApplySpellFix({ 54469 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_5_YARDS);
        spellInfo->Effects[EFFECT_1].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_5_YARDS);
        spellInfo->Effects[EFFECT_2].RadiusEntry = sSpellRadiusStore.LookupEntry(EFFECT_RADIUS_5_YARDS);
    });
 
    // Glyph of Chains of Ice:
    ApplySpellFix({ 58620 }, [](SpellInfo* spellInfo)
    {
        spellInfo->SpellLevel = 0;
    });
 
    // Exit Portal
    ApplySpellFix({ 60474 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx6 |= SPELL_ATTR6_ALLOW_WHILE_RIDING_VEHICLE;
    });
 
        // Eye of Acherus Flight (Boost)
    ApplySpellFix({ 51923 }, [](SpellInfo* spellInfo)
        {
            spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
        });
 
    // Shattering Throw
    ApplySpellFix({ 64382 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Attributes &= ~(SPELL_ATTR0_IS_ABILITY | SPELL_ATTR0_NOT_SHAPESHIFTED | SPELL_ATTR0_DO_NOT_SHEATH);
        spellInfo->Attributes |= SPELL_ATTR0_ALLOW_ITEM_SPELL_IN_PVP;
    });
 
    ApplySpellFix({
        43444, // Explosive Trap (Hex Lord Malacrass)
        43447, // Freezing Trap (Hex Lord Malacrass)
        43449, // Snake Trap (Hex Lord Malacrass)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].Effect = SPELL_EFFECT_SUMMON_OBJECT_SLOT1;
    });
 
    // Arcane Missiles
    ApplySpellFix({ 58529, 61592 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ENEMY);
    });
 
    // Siphon Bloodgem
    ApplySpellFix({ 34367 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ChannelInterruptFlags &= ~AURA_INTERRUPT_FLAG_TURNING;
    });
 
    // Summon Scourged Captive
    ApplySpellFix({ 51597 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = 1;
        spellInfo->Effects[EFFECT_0].DieSides = 0;
    });
 
    // The Green Tower
    ApplySpellFix({ 18097 }, [](SpellInfo* spellInfo)
    {
        spellInfo->DurationEntry = sSpellDurationStore.LookupEntry(21); // -1
    });
 
    ApplySpellFix({
        28032, // Zap Crystal
        28056, // Zap Crystal Corpse
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
    });
 
    // Earth Shield
    ApplySpellFix({ 55599, 58981 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx5 |= SPELL_ATTR5_LIMIT_N;
    });
 
    // Acid Splash
    ApplySpellFix({ 52446, 59363 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_DOT_STACKING_RULE;
    });
 
    // King Mrlg-Mrgl's Spare Suit
    ApplySpellFix({ 45278 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ProcCharges = 1;
    });
 
    ApplySpellFix({
        56917, // To Icecrown Airship - Teleport to Airship (A)
        57417, // To Icecrown Airship - Teleport to Airship (H)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(6); // 100 yards
    });
 
    ApplySpellFix({
        60586, // Mighty Spear Thrust
        60776, // Claw Swipe
        60881, // Fatal Strike
        60864, // Jaws of Death
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx4 |= SPELL_ATTR4_IGNORE_DAMAGE_TAKEN_MODIFIERS;
    });
 
    // The Brothers Bronzebeard
    ApplySpellFix({
        56675, // Summon Brann Bronzebeard
        56676, // Summon Yorg Stormheart
        56697, // Summon Magni Bronzebeard
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].MiscValueB = 64;
    });
 
    ApplySpellFix({
        57374, // Shadow Bolt (Lady Blaumeux 10m)
        57464, // Shadow Bolt (Lady Blaumeux 25m)
        57376, // Holy Bolt (Sir Zeliek 10m)
        57465, // Holy Bolt (Sir Zeliek 25m)
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->InterruptFlags &= ~SPELL_INTERRUPT_FLAG_INTERRUPT;
    });
 
    // Twilight Torment
    ApplySpellFix({ 57935, 58835 }, [](SpellInfo* spellInfo)
    {
        spellInfo->ProcCharges = 0;
    });
 
    // 54933 Hyldnir Harpoon
    ApplySpellFix({ 54933 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].BasePoints = 1;
    });
 
    ApplySpellFix({
        42292,  // PvP Trinket
        59752,  // Every Man for Himself
        19574,  // Bestial Wrath
        34471   // The Beast Within
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx2 |= SPELL_ATTR2_NO_SCHOOL_IMMUNITIES;
    });
 
    // 51036 Summon Venture Co. Air Patrol
    ApplySpellFix({ 51036 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_DEST_CASTER);
    });
 
    // 68415 Corrupted Rage
    ApplySpellFix({ 68415 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].SpellClassMask = flag96(0, 0x20000, 0);
    });
 
    // 31930 Judgements of the Wise
    ApplySpellFix({ 31930 }, [](SpellInfo* spellInfo)
    {
        spellInfo->SpellFamilyName = SPELLFAMILY_PALADIN;
        spellInfo->SpellFamilyFlags = flag96(0x200, 0, 0);
    });
 
    // 64646 Corrupted Wisdom
    ApplySpellFix({ 64646 }, [](SpellInfo* spellInfo)
    {
        spellInfo->Effects[EFFECT_1].SpellClassMask = flag96(0x200, 0, 0);
    });
 
    // Shadowhorn Charge (Rank 1)
    ApplySpellFix({ 6921 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_SUPPRESS_CASTER_PROCS;
    });
 
    // Drag Mine Cart
    ApplySpellFix({ 52414 }, [](SpellInfo* spellInfo)
    {
       spellInfo->Effects[EFFECT_0].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_TARGET_ANY);
    });
 
    // Boulder Assault (Sorlof's Booty)
    ApplySpellFix({ 44966 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx |= SPELL_ATTR1_NO_THREAT;
    });
 
    // Cannon Assault (Sorlof's Booty)
    ApplySpellFix({ 45008 }, [](SpellInfo* spellInfo)
    {
        spellInfo->AttributesEx3 |= SPELL_ATTR3_ALWAYS_HIT;
    });
 
    // Heroic Strike
    ApplySpellFix({
        45026,
        29426
        }, [](SpellInfo* spellInfo)
    {
        spellInfo->SpellLevel = 10;
    });
 
    for (uint32 i = 0; i < GetSpellInfoStoreSize(); ++i)
    {
        SpellInfo* spellInfo = mSpellInfoMap[i];
        if (!spellInfo)
        {
            continue;
        }
 
        for (uint8 j = 0; j < MAX_SPELL_EFFECTS; ++j)
        {
            switch (spellInfo->Effects[j].Effect)
            {
                case SPELL_EFFECT_CHARGE:
                case SPELL_EFFECT_CHARGE_DEST:
                case SPELL_EFFECT_JUMP:
                case SPELL_EFFECT_JUMP_DEST:
                case SPELL_EFFECT_LEAP_BACK:
                    if (!spellInfo->Speed && !spellInfo->SpellFamilyName)
                    {
                        spellInfo->Speed = SPEED_CHARGE;
                    }
                    break;
            }
 
            // Xinef: i hope this will fix the problem with not working resurrection
            if (spellInfo->Effects[j].Effect == SPELL_EFFECT_SELF_RESURRECT)
            {
                spellInfo->Effects[j].TargetA = SpellImplicitTargetInfo(TARGET_UNIT_CASTER);
            }
        }
 
        // Fix range for trajectory triggered spell
        for (SpellEffectInfo const& spellEffectInfo : spellInfo->GetEffects())
        {
            if (spellEffectInfo.IsEffect() && (spellEffectInfo.TargetA.GetTarget() == TARGET_DEST_TRAJ || spellEffectInfo.TargetB.GetTarget() == TARGET_DEST_TRAJ))
            {
                // Get triggered spell if any
                if (SpellInfo* spellInfoTrigger = const_cast<SpellInfo*>(GetSpellInfo(spellEffectInfo.TriggerSpell)))
                {
                    float maxRangeMain = spellInfo->RangeEntry ? spellInfo->RangeEntry->RangeMax[0] : 0.0f;
                    float maxRangeTrigger = spellInfoTrigger->RangeEntry ? spellInfoTrigger->RangeEntry->RangeMax[0] : 0.0f;
 
                    // check if triggered spell has enough max range to cover trajectory
                    if (maxRangeTrigger < maxRangeMain)
                        spellInfoTrigger->RangeEntry = spellInfo->RangeEntry;
                }
            }
        }
 
        if (spellInfo->ActiveIconID == 2158)  // flight
        {
            spellInfo->Attributes |= SPELL_ATTR0_PASSIVE;
        }
 
        switch (spellInfo->SpellFamilyName)
        {
            case SPELLFAMILY_PALADIN:
                // Seals of the Pure should affect Seal of Righteousness
                if (spellInfo->SpellIconID == 25 && (spellInfo->Attributes & SPELL_ATTR0_PASSIVE))
                    spellInfo->Effects[EFFECT_0].SpellClassMask[1] |= 0x20000000;
                break;
            case SPELLFAMILY_DEATHKNIGHT:
                // Icy Touch - extend FamilyFlags (unused value) for Sigil of the Frozen Conscience to use
                if (spellInfo->SpellIconID == 2721 && spellInfo->SpellFamilyFlags[0] & 0x2)
                    spellInfo->SpellFamilyFlags[0] |= 0x40;
                break;
            case SPELLFAMILY_HUNTER:
                // Aimed Shot not affected by category cooldown modifiers
                if (spellInfo->SpellFamilyFlags[0] & 0x00020000)
                {
                    spellInfo->AttributesEx6 |= SPELL_ATTR6_NO_CATEGORY_COOLDOWN_MODS;
                    spellInfo->RecoveryTime = 10 * IN_MILLISECONDS;
                }
                break;
        }
 
        // Recklessness/Shield Wall/Retaliation
        if (spellInfo->CategoryEntry == sSpellCategoryStore.LookupEntry(132) && spellInfo->SpellFamilyName == SPELLFAMILY_WARRIOR)
        {
            spellInfo->AttributesEx6 |= SPELL_ATTR6_NO_CATEGORY_COOLDOWN_MODS;
        }
    }
 
    // Xinef: The Veiled Sea area in outlands (Draenei zone), client blocks casting flying mounts
    for (uint32 i = 0; i < sAreaTableStore.GetNumRows(); ++i)
        if (AreaTableEntry* areaEntry = const_cast<AreaTableEntry*>(sAreaTableStore.LookupEntry(i)))
        {
            if (areaEntry->ID == 3479)
                areaEntry->flags |= AREA_FLAG_NO_FLY_ZONE;
            // Xinef: Dun Morogh, Kharanos tavern, missing resting flag
            else if (areaEntry->ID == 2102)
                areaEntry->flags |= AREA_FLAG_REST_ZONE_ALLIANCE;
        }
 
    // Xinef: fix for something?
    SummonPropertiesEntry* properties = const_cast<SummonPropertiesEntry*>(sSummonPropertiesStore.LookupEntry(121));
    properties->Type = SUMMON_TYPE_TOTEM;
    properties = const_cast<SummonPropertiesEntry*>(sSummonPropertiesStore.LookupEntry(647)); // 52893
    properties->Type = SUMMON_TYPE_TOTEM;
    if ((properties = const_cast<SummonPropertiesEntry*>(sSummonPropertiesStore.LookupEntry(628)))) // Hungry Plaguehound
    {
        properties->Category = SUMMON_CATEGORY_PET;
        properties->Type = SUMMON_TYPE_PET;
    }
 
    // Correct Pet Size
    CreatureDisplayInfoEntry* displayEntry = const_cast<CreatureDisplayInfoEntry*>(sCreatureDisplayInfoStore.LookupEntry(17028)); // Kurken
    displayEntry->scale = 2.5f;
 
    // Oracles and Frenzyheart faction
    FactionEntry* factionEntry = const_cast<FactionEntry*>(sFactionStore.LookupEntry(1104));
    factionEntry->ReputationFlags[0] = 0;
    factionEntry = const_cast<FactionEntry*>(sFactionStore.LookupEntry(1105));
    factionEntry->ReputationFlags[0] = 0;
 
    // Various factions, added 14, 16 to hostile mask
    FactionTemplateEntry* factionTemplateEntry = const_cast<FactionTemplateEntry*>(sFactionTemplateStore.LookupEntry(1978)); // Warsong Offensive
    factionTemplateEntry->hostileMask |= 8;
    factionTemplateEntry = const_cast<FactionTemplateEntry*>(sFactionTemplateStore.LookupEntry(1921)); // The Taunka
    factionTemplateEntry->hostileMask |= 8;
 
    // Remove vehicles attr, making accessories selectable
    VehicleSeatEntry* vse = const_cast<VehicleSeatEntry*>(sVehicleSeatStore.LookupEntry(4689)); // Siege Engine, Accessory
    vse->m_flags &= ~VEHICLE_SEAT_FLAG_PASSENGER_NOT_SELECTABLE;
    vse = const_cast<VehicleSeatEntry*>(sVehicleSeatStore.LookupEntry(4692)); // Siege Engine, Accessory
    vse->m_flags &= ~VEHICLE_SEAT_FLAG_PASSENGER_NOT_SELECTABLE;
    vse = const_cast<VehicleSeatEntry*>(sVehicleSeatStore.LookupEntry(4693)); // Siege Engine, Accessory
    vse->m_flags &= ~VEHICLE_SEAT_FLAG_PASSENGER_NOT_SELECTABLE;
    vse = const_cast<VehicleSeatEntry*>(sVehicleSeatStore.LookupEntry(1520)); // Wyrmrest Vanquisher
    vse->m_flags |= VEHICLE_SEAT_FLAG_PASSENGER_NOT_SELECTABLE;
 
    // Salvaged Siege Engine (Ulduar) extra passenger seats: the only salvaged vehicle seats
    // without this flag, leaving those passengers targetable by Flame Leviathan's AoE
    vse = const_cast<VehicleSeatEntry*>(sVehicleSeatStore.LookupEntry(4026));
    vse->m_flags |= VEHICLE_SEAT_FLAG_PASSENGER_NOT_SELECTABLE;
    vse = const_cast<VehicleSeatEntry*>(sVehicleSeatStore.LookupEntry(4027));
    vse->m_flags |= VEHICLE_SEAT_FLAG_PASSENGER_NOT_SELECTABLE;
 
    // pussywizard: fix z offset for some vehicles:
    vse = const_cast<VehicleSeatEntry*>(sVehicleSeatStore.LookupEntry(6206)); // Marrowgar - Bone Spike
    vse->m_attachmentOffsetZ = 4.0f;
    vse = const_cast<VehicleSeatEntry*>(sVehicleSeatStore.LookupEntry(3806)); // Mimiron - seat on VX-001 for ACU during last phase
    vse->m_attachmentOffsetZ = 15.0f;
    vse = const_cast<VehicleSeatEntry*>(sVehicleSeatStore.LookupEntry(3566)); // Mimiron - Working seat
    vse->m_attachmentOffsetX = -3.5f;
    vse->m_attachmentOffsetY = 0.0f;
    vse = const_cast<VehicleSeatEntry*>(sVehicleSeatStore.LookupEntry(3567)); // Mimiron - Working seat
    vse->m_attachmentOffsetX = 2.3f;
    vse->m_attachmentOffsetY = -2.3f;
 
    // Pilgrim's Bounty offsets
    vse = const_cast<VehicleSeatEntry*>(sVehicleSeatStore.LookupEntry(2841));
    vse->m_attachmentOffsetX += 1.65f;
    vse->m_attachmentOffsetY += 0.75f;
    vse = const_cast<VehicleSeatEntry*>(sVehicleSeatStore.LookupEntry(2842));
    vse->m_attachmentOffsetX += 1.6f;
    vse->m_attachmentOffsetY += -1.0f;
    vse = const_cast<VehicleSeatEntry*>(sVehicleSeatStore.LookupEntry(2843));
    vse->m_attachmentOffsetX += -1.2f;
    vse->m_attachmentOffsetY += 0.2f;
    vse = const_cast<VehicleSeatEntry*>(sVehicleSeatStore.LookupEntry(2844));
    vse->m_attachmentOffsetX += -0.1f;
    vse->m_attachmentOffsetY += -1.6f;
    vse = const_cast<VehicleSeatEntry*>(sVehicleSeatStore.LookupEntry(2845));
    vse->m_attachmentOffsetX += 0.0f;
    vse->m_attachmentOffsetY += 1.6f;
 
    // Once Bitten, Twice Shy (10 player) - Icecrown Citadel
    AchievementEntry* achievement = const_cast<AchievementEntry*>(sAchievementStore.LookupEntry(4539));
    achievement->mapID = 631;    // Correct map requirement (currently has Ulduar)
 
    // Ring of Valor starting Locations
    GraveyardStruct const* entry = sGraveyard->GetGraveyard(1364);
    const_cast<GraveyardStruct*>(entry)->z += 6.0f;
    entry = sGraveyard->GetGraveyard(1365);
    const_cast<GraveyardStruct*>(entry)->z += 6.0f;
 
    LockEntry* key = const_cast<LockEntry*>(sLockStore.LookupEntry(36)); // 3366 Opening, allows to open without proper key
    key->Type[2] = LOCK_KEY_NONE;
 
    LOG_INFO("server.loading", ">> Loading spell dbc data corrections  in {} ms", GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

◆ LoadSpellInfoCustomAttributes()

void SpellMgr::LoadSpellInfoCustomAttributes ( )

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

{
    uint32 const oldMSTime = getMSTime();
    uint32 const customAttrTime = getMSTime();
    uint32 count;
 
    QueryResult result = WorldDatabase.Query("SELECT spell_id, attributes FROM spell_custom_attr");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 Spell Custom Attributes From DB. DB table `spell_custom_attr` Is Empty.");
    }
    else
    {
        count = 0;
 
        do
        {
            ++count;
 
            Field const* fields = result->Fetch();
 
            uint32 const spellId = fields[0].Get<uint32>();
            uint32 attributes = fields[1].Get<uint32>();
 
            SpellInfo* spellInfo = _GetSpellInfo(spellId);
            if (!spellInfo)
            {
                LOG_INFO("sql.sql", "Table `spell_custom_attr` has wrong spell (spell_id: {}), ignored.", spellId);
                continue;
            }
 
            if (attributes & SPELL_ATTR0_CU_NEGATIVE)
            {
                for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
                {
                    if (spellInfo->Effects[i].IsEffect())
                    {
                        if ((attributes & (SPELL_ATTR0_CU_NEGATIVE_EFF0 << i)) && (attributes & (SPELL_ATTR0_CU_POSITIVE_EFF0 << i)))
                        {
                            LOG_ERROR("sql.sql", "Table `spell_custom_attr` has attribute SPELL_ATTR0_CU_NEGATIVE_EFF{} and SPELL_ATTR0_CU_POSITIVE_EFF{} attributes for spell {} which cannot stack together. Attributes will not get applied", static_cast<uint32>(i), static_cast<uint32>(i), spellId);
                            attributes &= ~(SPELL_ATTR0_CU_NEGATIVE_EFF0 << i)|(SPELL_ATTR0_CU_POSITIVE_EFF0 << i);
                        }
                        continue;
                    }
 
                    if (attributes & (SPELL_ATTR0_CU_NEGATIVE_EFF0 << i))
                    {
                        LOG_ERROR("sql.sql", "Table `spell_custom_attr` has attribute SPELL_ATTR0_CU_NEGATIVE_EFF{} for spell {} with no EFFECT_{}", static_cast<uint32>(i), spellId, static_cast<uint32>(i));
                        attributes &= ~(SPELL_ATTR0_CU_NEGATIVE_EFF0 << i);
                    }
                }
            }
 
            if (attributes & SPELL_ATTR0_CU_POSITIVE)
            {
                for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
                {
                    if (spellInfo->Effects[i].IsEffect())
                    {
                        continue;
                    }
 
                    if ((attributes & (SPELL_ATTR0_CU_POSITIVE_EFF0 << i)))
                    {
                        LOG_ERROR("sql.sql", "Table `spell_custom_attr` has attribute SPELL_ATTR0_CU_POSITIVE_EFF{} for spell {} with no EFFECT_{}", uint32(i), spellId, uint32(i));
                        attributes &= ~(SPELL_ATTR0_CU_POSITIVE_EFF0 << i);
                    }
                }
            }
 
            if ((attributes & SPELL_ATTR0_CU_FORCE_AURA_SAVING) && (attributes & SPELL_ATTR0_CU_AURA_CANNOT_BE_SAVED))
            {
                LOG_ERROR("sql.sql", "Table `spell_custom_attr` attribute1 field has attributes SPELL_ATTR1_CU_FORCE_AURA_SAVING and SPELL_ATTR0_CU_AURA_CANNOT_BE_SAVED which cannot stack for spell {}. Both attributes will be ignored.", spellId);
                attributes &= ~(SPELL_ATTR0_CU_FORCE_AURA_SAVING | SPELL_ATTR0_CU_AURA_CANNOT_BE_SAVED);
            }
 
            spellInfo->AttributesCu |= attributes;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} spell custom attributes from DB in {} ms", count, GetMSTimeDiffToNow(customAttrTime));
    }
 
    // xinef: create talent spells set
    for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
    {
        TalentEntry const* talentInfo = sTalentStore.LookupEntry(i);
        if (!talentInfo)
            continue;
 
        for (uint8 j = 0; j < MAX_TALENT_RANK; j++)
            if (uint32 spellId = talentInfo->RankID[j])
                if (SpellInfo const* spellInfo = GetSpellInfo(spellId))
                    for (uint8 k = 0; k < MAX_SPELL_EFFECTS; ++k)
                        if (spellInfo->Effects[k].Effect == SPELL_EFFECT_LEARN_SPELL)
                            if (SpellInfo const* learnSpell = GetSpellInfo(spellInfo->Effects[k].TriggerSpell))
                                if (learnSpell->IsRanked() && !learnSpell->HasAttribute(SpellAttr0(SPELL_ATTR0_PASSIVE | SPELL_ATTR0_DO_NOT_DISPLAY)))
                                    mTalentSpellAdditionalSet.insert(learnSpell->Id);
    }
 
    SpellInfo* spellInfo = nullptr;
    for (uint32 i = 0; i < GetSpellInfoStoreSize(); ++i)
    {
        spellInfo = mSpellInfoMap[i];
        if (!spellInfo)
            continue;
 
        for (uint8 j = 0; j < MAX_SPELL_EFFECTS; ++j)
        {
            switch (spellInfo->Effects[j].ApplyAuraName)
            {
                case SPELL_AURA_MOD_INVISIBILITY:
                {
                    switch (spellInfo->Id)
                    {
                        // Exceptions
                        case 44801: // Spectral Invisibility (Kalecgos, SWP)
                        case 46021: // Spectral Realm (SWP)
                        case 52951: // Chapel Invisibility (DK starting zone)
                        case 43062: // Alpha Worg: Garwal's Invisibility
                        case 45614: // Shroud of the Scourge (Blending In, Temple City of En'kilah)
                            break;
                        default:
                            spellInfo->AuraInterruptFlags |= AURA_INTERRUPT_FLAG_CAST;
                            break;
                    }
                }
                break;
                case SPELL_AURA_TRACK_CREATURES:
                case SPELL_AURA_MOD_RANGED_HASTE:
                case SPELL_AURA_MOD_POSSESS_PET:
                case SPELL_AURA_MOD_INVISIBILITY_DETECT:
                case SPELL_AURA_WATER_BREATHING:
                    spellInfo->AttributesCu |= SPELL_ATTR0_CU_NO_INITIAL_THREAT;
                    break;
                default:
                    break;
            }
 
            switch (spellInfo->Effects[j].ApplyAuraName)
            {
                case SPELL_AURA_CONVERT_RUNE:   // Can't be saved - aura handler relies on calculated amount and changes it
                case SPELL_AURA_OPEN_STABLE:    // No point in saving this, since the stable dialog can't be open on aura load anyway.
                // Auras that require both caster & target to be in world cannot be saved
                case SPELL_AURA_CONTROL_VEHICLE:
                case SPELL_AURA_BIND_SIGHT:
                case SPELL_AURA_MOD_POSSESS:
                case SPELL_AURA_MOD_POSSESS_PET:
                case SPELL_AURA_MOD_CHARM:
                case SPELL_AURA_AOE_CHARM:
                    spellInfo->AttributesCu |= SPELL_ATTR0_CU_AURA_CANNOT_BE_SAVED;
                    break;
                default:
                    break;
            }
 
            switch (spellInfo->Effects[j].ApplyAuraName)
            {
                case SPELL_AURA_MOD_POSSESS:
                case SPELL_AURA_MOD_CONFUSE:
                case SPELL_AURA_MOD_CHARM:
                case SPELL_AURA_AOE_CHARM:
                case SPELL_AURA_MOD_FEAR:
                case SPELL_AURA_MOD_STUN:
                    spellInfo->AttributesCu |= SPELL_ATTR0_CU_AURA_CC;
                    break;
                case SPELL_AURA_BIND_SIGHT:
                    spellInfo->AttributesCu |= SPELL_ATTR0_CU_NO_PVP_FLAG;
                    break;
                default:
                    break;
            }
 
            switch (spellInfo->Effects[j].Effect)
            {
                case SPELL_EFFECT_SCHOOL_DAMAGE:
                case SPELL_EFFECT_WEAPON_DAMAGE:
                case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
                case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:
                case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:
                case SPELL_EFFECT_HEAL:
                    spellInfo->AttributesCu |= SPELL_ATTR0_CU_DIRECT_DAMAGE;
                    break;
                case SPELL_EFFECT_POWER_DRAIN:
                case SPELL_EFFECT_POWER_BURN:
                case SPELL_EFFECT_HEAL_MAX_HEALTH:
                case SPELL_EFFECT_HEALTH_LEECH:
                case SPELL_EFFECT_HEAL_PCT:
                case SPELL_EFFECT_ENERGIZE_PCT:
                case SPELL_EFFECT_ENERGIZE:
                case SPELL_EFFECT_HEAL_MECHANICAL:
                case SPELL_EFFECT_CREATE_ITEM:
                    spellInfo->AttributesCu |= SPELL_ATTR0_CU_NO_INITIAL_THREAT;
                    break;
                case SPELL_EFFECT_CHARGE:
                case SPELL_EFFECT_CHARGE_DEST:
                case SPELL_EFFECT_JUMP:
                case SPELL_EFFECT_JUMP_DEST:
                case SPELL_EFFECT_LEAP_BACK:
                    spellInfo->AttributesCu |= SPELL_ATTR0_CU_CHARGE;
                    break;
                case SPELL_EFFECT_PICKPOCKET:
                    spellInfo->AttributesCu |= SPELL_ATTR0_CU_PICKPOCKET;
                    break;
                case SPELL_EFFECT_ENCHANT_ITEM:
                case SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY:
                case SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC:
                case SPELL_EFFECT_ENCHANT_HELD_ITEM:
                    {
                        // Only Enchanting profession enchant procs can stack when dual-wielding
                        // DK runes (e.g., Unholy Strength) should refresh, not stack
                        if (IsPartOfSkillLine(SKILL_ENCHANTING, i))
                        {
                            uint32 enchantId = spellInfo->Effects[j].MiscValue;
                            SpellItemEnchantmentEntry const* enchant = sSpellItemEnchantmentStore.LookupEntry(enchantId);
                            if (!enchant)
                                break;
 
                            for (uint8 s = 0; s < MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS; ++s)
                            {
                                if (enchant->type[s] != ITEM_ENCHANTMENT_TYPE_COMBAT_SPELL)
                                    continue;
 
                                SpellInfo* procInfo = _GetSpellInfo(enchant->spellid[s]);
                                if (!procInfo)
                                    continue;
 
                                // if proced directly from enchantment, not via proc aura
                                // NOTE: Enchant Weapon - Blade Ward also has proc aura spell and is proced directly
                                // however its not expected to stack so this check is good
                                if (procInfo->HasAura(SPELL_AURA_PROC_TRIGGER_SPELL))
                                    continue;
 
                                procInfo->AttributesCu |= SPELL_ATTR0_CU_ENCHANT_PROC;
                            }
                        }
                        break;
                    }
            }
        }
 
        // Xinef: spells ignoring hit result should not be binary
        if (!spellInfo->HasAttribute(SPELL_ATTR3_ALWAYS_HIT))
        {
            for (uint8 j = 0; j < MAX_SPELL_EFFECTS; ++j)
            {
                if (spellInfo->Effects[j].Effect)
                {
                    switch (spellInfo->Effects[j].Effect)
                    {
                        case SPELL_EFFECT_SCHOOL_DAMAGE:
                        case SPELL_EFFECT_WEAPON_DAMAGE:
                        case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
                        case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:
                        case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:
                        case SPELL_EFFECT_TRIGGER_SPELL:
                        case SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE:
                            continue;
                        case SPELL_EFFECT_PERSISTENT_AREA_AURA:
                        case SPELL_EFFECT_APPLY_AURA:
                        case SPELL_EFFECT_APPLY_AREA_AURA_PARTY:
                        case SPELL_EFFECT_APPLY_AREA_AURA_RAID:
                        case SPELL_EFFECT_APPLY_AREA_AURA_FRIEND:
                        case SPELL_EFFECT_APPLY_AREA_AURA_ENEMY:
                        case SPELL_EFFECT_APPLY_AREA_AURA_PET:
                        case SPELL_EFFECT_APPLY_AREA_AURA_OWNER:
                            if (spellInfo->Effects[j].ApplyAuraName == SPELL_AURA_PERIODIC_DAMAGE ||
                                    spellInfo->Effects[j].ApplyAuraName == SPELL_AURA_PERIODIC_DAMAGE_PERCENT ||
                                    spellInfo->Effects[j].ApplyAuraName == SPELL_AURA_DUMMY ||
                                    spellInfo->Effects[j].ApplyAuraName == SPELL_AURA_PERIODIC_LEECH ||
                                    spellInfo->Effects[j].ApplyAuraName == SPELL_AURA_PERIODIC_HEALTH_FUNNEL ||
                                    spellInfo->Effects[j].ApplyAuraName == SPELL_AURA_PERIODIC_DUMMY)
                                continue;
                            [[fallthrough]]; 
                        default:
                            if (!(spellInfo->Effects[j].CalcValue() ||
                                ((spellInfo->Effects[j].Effect == SPELL_EFFECT_INTERRUPT_CAST || spellInfo->HasAttribute(SPELL_ATTR0_CU_DONT_BREAK_STEALTH)) &&
                                !spellInfo->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES))))
                                continue;
 
                            if (spellInfo->Id == 69649 || spellInfo->Id == 71056 || spellInfo->Id == 71057 || spellInfo->Id == 71058 ||
                                spellInfo->Id == 73061 || spellInfo->Id == 73062 || spellInfo->Id == 73063 || spellInfo->Id == 73064)
                                continue;
 
                            if (spellInfo->SpellFamilyName == SPELLFAMILY_MAGE && (spellInfo->SpellFamilyFlags[0] & 0x20)) // Frostbolt
                                continue;
 
                            if (spellInfo->Id == 55095) // Frost Fever
                                continue;
 
                            if (spellInfo->SpellFamilyName == SPELLFAMILY_WARLOCK &&
                                ((spellInfo->SpellFamilyFlags[1] & 0x40000) || (spellInfo->SpellFamilyFlags[0] & 0x4000))) // Haunt/Drain Soul
                                continue;
 
                            spellInfo->AttributesCu |= SPELL_ATTR0_CU_BINARY_SPELL;
                            break;
                    }
                }
            }
        }
 
        // pussywizard:
        if ((spellInfo->SchoolMask & SPELL_SCHOOL_MASK_NORMAL) && (spellInfo->SchoolMask & SPELL_SCHOOL_MASK_MAGIC))
        {
            spellInfo->SchoolMask &= ~SPELL_SCHOOL_MASK_NORMAL;
            spellInfo->AttributesCu |= SPELL_ATTR0_CU_SCHOOLMASK_NORMAL_WITH_MAGIC;
        }
 
        if (!spellInfo->_IsPositiveEffect(EFFECT_0, false))
            spellInfo->AttributesCu |= SPELL_ATTR0_CU_NEGATIVE_EFF0;
 
        if (!spellInfo->_IsPositiveEffect(EFFECT_1, false))
            spellInfo->AttributesCu |= SPELL_ATTR0_CU_NEGATIVE_EFF1;
 
        if (!spellInfo->_IsPositiveEffect(EFFECT_2, false))
            spellInfo->AttributesCu |= SPELL_ATTR0_CU_NEGATIVE_EFF2;
 
        if (spellInfo->SpellVisual[0] == 3879)
            spellInfo->AttributesCu |= SPELL_ATTR0_CU_CONE_BACK;
 
        switch (spellInfo->SpellFamilyName)
        {
            case SPELLFAMILY_WARRIOR:
                // Shout
                if (spellInfo->SpellFamilyFlags[0] & 0x20000 || spellInfo->SpellFamilyFlags[1] & 0x20)
                    spellInfo->AttributesCu |= SPELL_ATTR0_CU_AURA_CC;
                break;
            case SPELLFAMILY_DRUID:
                // Roar
                if (spellInfo->SpellFamilyFlags[0] & 0x8)
                    spellInfo->AttributesCu |= SPELL_ATTR0_CU_AURA_CC;
                break;
            case SPELLFAMILY_HUNTER:
                // Aspects
                if (spellInfo->GetCategory() == 47)
                {
                    spellInfo->AttributesCu |= SPELL_ATTR0_CU_NO_INITIAL_THREAT;
                }
                // Aimed Shot
                if (spellInfo->SpellFamilyFlags[0] & 0x00020000)
                {
                    spellInfo->AttributesCu |= SPELL_ATTR0_CU_FORCE_SEND_CATEGORY_COOLDOWNS;
                }
                break;
            default:
                break;
        }
 
        switch (spellInfo->Id)
        {
            // Xinef: NOT CUSTOM, cant add in DBC CORRECTION because i need to swap effects, too much work to do there
            // Envenom
            case 32645:
            case 32684:
            case 57992:
            case 57993:
                {
                    SpellEffectInfo info = spellInfo->Effects[EFFECT_0];
                    spellInfo->Effects[EFFECT_0] = spellInfo->Effects[EFFECT_2];
                    spellInfo->Effects[EFFECT_2] = info;
                    break;
                }
 
            // Xinef: Cooldown overwrites
            // Burst of Speed
            case 57493:
                spellInfo->RecoveryTime = 60000;
                spellInfo->_requireCooldownInfo = true;
                break;
            // Strafe Jotunheim Building
            case 7769:
                spellInfo->RecoveryTime = 1500;
                spellInfo->_requireCooldownInfo = true;
                break;
            case 44535: // Spirit Heal, abilities also have no cost
                spellInfo->Effects[EFFECT_0].MiscValue = 127;
                break;
            default:
                break;
        }
 
        if (spellInfo->Speed > 0.0f)
        {
            if (SpellVisualEntry const* spellVisual = sSpellVisualStore.LookupEntry(spellInfo->SpellVisual[0]))
            {
                if (spellVisual->HasMissile)
                {
                    if (spellVisual->MissileModel == -4 || spellVisual->MissileModel == -5)
                    {
                        spellInfo->AttributesCu |= SPELL_ATTR0_CU_NEEDS_AMMO_DATA;
                    }
                }
            }
        }
 
        spellInfo->_InitializeExplicitTargetMask();
 
        if (HasSpellCooldownOverride(spellInfo->Id))
        {
            SpellCooldownOverride spellOverride = GetSpellCooldownOverride(spellInfo->Id);
 
            if (spellInfo->RecoveryTime != spellOverride.RecoveryTime)
            {
                spellInfo->RecoveryTime = spellOverride.RecoveryTime;
            }
 
            if (spellInfo->CategoryRecoveryTime != spellOverride.CategoryRecoveryTime)
            {
                spellInfo->CategoryRecoveryTime = spellOverride.CategoryRecoveryTime;
            }
 
            if (spellInfo->StartRecoveryTime != spellOverride.StartRecoveryTime)
            {
                spellInfo->RecoveryTime = spellOverride.RecoveryTime;
            }
 
            if (spellInfo->StartRecoveryCategory != spellOverride.StartRecoveryCategory)
            {
                spellInfo->RecoveryTime = spellOverride.RecoveryTime;
            }
        }
 
        sScriptMgr->OnLoadSpellCustomAttr(spellInfo);
    }
 
    // Xinef: addition for binary spells, ommit spells triggering other spells
    for (uint32 i = 0; i < GetSpellInfoStoreSize(); ++i)
    {
        spellInfo = mSpellInfoMap[i];
        if (!spellInfo)
            continue;
 
        if (!(spellInfo->AttributesCu & SPELL_ATTR0_CU_BINARY_SPELL))
            continue;
 
        bool allNonBinary = true;
        bool overrideAttr = false;
        for (uint8 j = 0; j < MAX_SPELL_EFFECTS; ++j)
        {
            if (spellInfo->Effects[j].ApplyAuraName && spellInfo->Effects[j].TriggerSpell)
            {
                switch (spellInfo->Effects[j].ApplyAuraName)
                {
                    case SPELL_AURA_PERIODIC_TRIGGER_SPELL:
                    case SPELL_AURA_PERIODIC_TRIGGER_SPELL_FROM_CLIENT:
                    case SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE:
                        if (SpellInfo const* triggerSpell = GetSpellInfo(spellInfo->Effects[j].TriggerSpell))
                        {
                            overrideAttr = true;
                            if (triggerSpell->AttributesCu & SPELL_ATTR0_CU_BINARY_SPELL)
                                allNonBinary = false;
                        }
                        break;
                    default:
                        break;
                }
            }
        }
 
        if (overrideAttr && allNonBinary)
            spellInfo->AttributesCu &= ~SPELL_ATTR0_CU_BINARY_SPELL;
    }
 
    LOG_INFO("server.loading", ">> Loaded SpellInfo Custom Attributes in {} ms", GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References _GetSpellInfo(), SpellInfo::_InitializeExplicitTargetMask(), SpellInfo::_IsPositiveEffect(), SpellInfo::_requireCooldownInfo, SpellInfo::AttributesCu, AURA_INTERRUPT_FLAG_CAST, SpellInfo::AuraInterruptFlags, SpellInfo::CategoryRecoveryTime, SpellCooldownOverride::CategoryRecoveryTime, EFFECT_0, EFFECT_1, EFFECT_2, SpellInfo::Effects, Field::Get(), SpellInfo::GetCategory(), getMSTime(), GetMSTimeDiffToNow(), GetSpellCooldownOverride(), GetSpellInfo(), GetSpellInfoStoreSize(), SpellInfo::HasAttribute(), SpellInfo::HasAura(), HasSpellCooldownOverride(), SpellInfo::Id, IsPartOfSkillLine(), ITEM_ENCHANTMENT_TYPE_COMBAT_SPELL, LOG_ERROR, LOG_INFO, LOG_WARN, MAX_SPELL_EFFECTS, MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS, MAX_TALENT_RANK, mSpellInfoMap, mTalentSpellAdditionalSet, TalentEntry::RankID, SpellInfo::RecoveryTime, SpellCooldownOverride::RecoveryTime, SpellInfo::SchoolMask, SKILL_ENCHANTING, SpellInfo::Speed, SPELL_ATTR0_CU_AURA_CANNOT_BE_SAVED, SPELL_ATTR0_CU_AURA_CC, SPELL_ATTR0_CU_BINARY_SPELL, SPELL_ATTR0_CU_CHARGE, SPELL_ATTR0_CU_CONE_BACK, SPELL_ATTR0_CU_DIRECT_DAMAGE, SPELL_ATTR0_CU_DONT_BREAK_STEALTH, SPELL_ATTR0_CU_ENCHANT_PROC, SPELL_ATTR0_CU_FORCE_AURA_SAVING, SPELL_ATTR0_CU_FORCE_SEND_CATEGORY_COOLDOWNS, SPELL_ATTR0_CU_NEEDS_AMMO_DATA, SPELL_ATTR0_CU_NEGATIVE, SPELL_ATTR0_CU_NEGATIVE_EFF0, SPELL_ATTR0_CU_NEGATIVE_EFF1, SPELL_ATTR0_CU_NEGATIVE_EFF2, SPELL_ATTR0_CU_NO_INITIAL_THREAT, SPELL_ATTR0_CU_NO_PVP_FLAG, SPELL_ATTR0_CU_PICKPOCKET, SPELL_ATTR0_CU_POSITIVE, SPELL_ATTR0_CU_POSITIVE_EFF0, SPELL_ATTR0_CU_SCHOOLMASK_NORMAL_WITH_MAGIC, SPELL_ATTR0_DO_NOT_DISPLAY, SPELL_ATTR0_NO_IMMUNITIES, SPELL_ATTR0_PASSIVE, SPELL_ATTR3_ALWAYS_HIT, SPELL_AURA_AOE_CHARM, SPELL_AURA_BIND_SIGHT, SPELL_AURA_CONTROL_VEHICLE, SPELL_AURA_CONVERT_RUNE, SPELL_AURA_DUMMY, SPELL_AURA_MOD_CHARM, SPELL_AURA_MOD_CONFUSE, SPELL_AURA_MOD_FEAR, SPELL_AURA_MOD_INVISIBILITY, SPELL_AURA_MOD_INVISIBILITY_DETECT, SPELL_AURA_MOD_POSSESS, SPELL_AURA_MOD_POSSESS_PET, SPELL_AURA_MOD_RANGED_HASTE, SPELL_AURA_MOD_STUN, SPELL_AURA_OPEN_STABLE, SPELL_AURA_PERIODIC_DAMAGE, SPELL_AURA_PERIODIC_DAMAGE_PERCENT, SPELL_AURA_PERIODIC_DUMMY, SPELL_AURA_PERIODIC_HEALTH_FUNNEL, SPELL_AURA_PERIODIC_LEECH, SPELL_AURA_PERIODIC_TRIGGER_SPELL, SPELL_AURA_PERIODIC_TRIGGER_SPELL_FROM_CLIENT, SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE, SPELL_AURA_PROC_TRIGGER_SPELL, SPELL_AURA_TRACK_CREATURES, SPELL_AURA_WATER_BREATHING, SPELL_EFFECT_APPLY_AREA_AURA_ENEMY, SPELL_EFFECT_APPLY_AREA_AURA_FRIEND, SPELL_EFFECT_APPLY_AREA_AURA_OWNER, SPELL_EFFECT_APPLY_AREA_AURA_PARTY, SPELL_EFFECT_APPLY_AREA_AURA_PET, SPELL_EFFECT_APPLY_AREA_AURA_RAID, SPELL_EFFECT_APPLY_AURA, SPELL_EFFECT_CHARGE, SPELL_EFFECT_CHARGE_DEST, SPELL_EFFECT_CREATE_ITEM, SPELL_EFFECT_ENCHANT_HELD_ITEM, SPELL_EFFECT_ENCHANT_ITEM, SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC, SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY, SPELL_EFFECT_ENERGIZE, SPELL_EFFECT_ENERGIZE_PCT, SPELL_EFFECT_HEAL, SPELL_EFFECT_HEAL_MAX_HEALTH, SPELL_EFFECT_HEAL_MECHANICAL, SPELL_EFFECT_HEAL_PCT, SPELL_EFFECT_HEALTH_LEECH, SPELL_EFFECT_INTERRUPT_CAST, SPELL_EFFECT_JUMP, SPELL_EFFECT_JUMP_DEST, SPELL_EFFECT_LEAP_BACK, SPELL_EFFECT_LEARN_SPELL, SPELL_EFFECT_NORMALIZED_WEAPON_DMG, SPELL_EFFECT_PERSISTENT_AREA_AURA, SPELL_EFFECT_PICKPOCKET, SPELL_EFFECT_POWER_BURN, SPELL_EFFECT_POWER_DRAIN, SPELL_EFFECT_SCHOOL_DAMAGE, SPELL_EFFECT_TRIGGER_SPELL, SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE, SPELL_EFFECT_WEAPON_DAMAGE, SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL, SPELL_EFFECT_WEAPON_PERCENT_DAMAGE, SPELL_SCHOOL_MASK_MAGIC, SPELL_SCHOOL_MASK_NORMAL, SPELLFAMILY_DRUID, SPELLFAMILY_HUNTER, SPELLFAMILY_MAGE, SPELLFAMILY_WARLOCK, SPELLFAMILY_WARRIOR, SpellInfo::SpellFamilyFlags, SpellInfo::SpellFamilyName, SpellItemEnchantmentEntry::spellid, SpellInfo::SpellVisual, sScriptMgr, sSpellItemEnchantmentStore, sSpellVisualStore, sTalentStore, SpellInfo::StartRecoveryCategory, SpellCooldownOverride::StartRecoveryCategory, SpellInfo::StartRecoveryTime, SpellCooldownOverride::StartRecoveryTime, SpellItemEnchantmentEntry::type, and WorldDatabase.

◆ LoadSpellInfoImmunities()

void SpellMgr::LoadSpellInfoImmunities ( )

{
    uint32 oldMSTime = getMSTime();
 
    for (SpellInfo* spellInfo : mSpellInfoMap)
    {
        if (!spellInfo)
            continue;
        spellInfo->_LoadImmunityInfo();
    }
 
    LOG_INFO("server.loading", ">> Loaded SpellInfo immunity infos in {} ms", GetMSTimeDiffToNow(oldMSTime));
}

References getMSTime(), GetMSTimeDiffToNow(), LOG_INFO, and mSpellInfoMap.

◆ LoadSpellInfoStore()

void SpellMgr::LoadSpellInfoStore ( )

{
    uint32 oldMSTime = getMSTime();
 
    UnloadSpellInfoStore();
    mSpellInfoMap.resize(sSpellStore.GetNumRows(), nullptr);
 
    for (SpellEntry const* spellEntry : sSpellStore)
        mSpellInfoMap[spellEntry->Id] = new SpellInfo(spellEntry);
 
    for (uint32 spellIndex = 0; spellIndex < GetSpellInfoStoreSize(); ++spellIndex)
    {
        if (!mSpellInfoMap[spellIndex])
            continue;
 
        for (SpellEffectInfo const& spellEffectInfo : mSpellInfoMap[spellIndex]->GetEffects())
        {
            //ASSERT(effect.EffectIndex < MAX_SPELL_EFFECTS, "MAX_SPELL_EFFECTS must be at least {}", effect.EffectIndex + 1);
            ASSERT(spellEffectInfo.Effect < TOTAL_SPELL_EFFECTS, "TOTAL_SPELL_EFFECTS must be at least {}", spellEffectInfo.Effect + 1);
            ASSERT(spellEffectInfo.ApplyAuraName < TOTAL_AURAS, "TOTAL_AURAS must be at least {}", spellEffectInfo.ApplyAuraName + 1);
            ASSERT(spellEffectInfo.TargetA.GetTarget() < TOTAL_SPELL_TARGETS, "TOTAL_SPELL_TARGETS must be at least {}", spellEffectInfo.TargetA.GetTarget() + 1);
            ASSERT(spellEffectInfo.TargetB.GetTarget() < TOTAL_SPELL_TARGETS, "TOTAL_SPELL_TARGETS must be at least {}", spellEffectInfo.TargetB.GetTarget() + 1);
        }
    }
 
    LoadCreatureImmunities();
 
    LOG_INFO("server.loading", ">> Loaded Spell Custom Attributes in {} ms", GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References ASSERT, getMSTime(), GetMSTimeDiffToNow(), GetSpellInfoStoreSize(), LoadCreatureImmunities(), LOG_INFO, mSpellInfoMap, sSpellStore, TOTAL_AURAS, TOTAL_SPELL_EFFECTS, TOTAL_SPELL_TARGETS, and UnloadSpellInfoStore().

◆ LoadSpellJumpDistances()

void SpellMgr::LoadSpellJumpDistances ( )

{
    uint32 oldMSTime = getMSTime();
 
    QueryResult result = WorldDatabase.Query("SELECT ID, JumpDistance FROM spell_jump_distance");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 spell jump distances. DB table `spell_jump_distance` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    do
    {
        Field const* fields = result->Fetch();
 
        uint32 const spellId = fields[0].Get<uint32>();
        float const jumpDistance = fields[1].Get<float>();
 
        SpellInfo* spellInfo = _GetSpellInfo(spellId);
        if (!spellInfo)
        {
            LOG_ERROR("sql.sql", "Table `spell_jump_distance` has wrong spell (spell_id: {}), ignored.", spellId);
            continue;
        }
 
        spellInfo->JumpDistance = jumpDistance;
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} spell jump distances in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References _GetSpellInfo(), Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, and WorldDatabase.

◆ LoadSpellLearnSkills()

void SpellMgr::LoadSpellLearnSkills ( )

{
    uint32 oldMSTime = getMSTime();
 
    mSpellLearnSkills.clear();                              // need for reload case
 
    // search auto-learned skills and add its to map also for use in unlearn spells/talents
    uint32 dbc_count = 0;
    for (uint32 spell = 0; spell < GetSpellInfoStoreSize(); ++spell)
    {
        SpellInfo const* entry = GetSpellInfo(spell);
 
        if (!entry)
            continue;
 
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            SpellLearnSkillNode dbc_node;
            switch (entry->Effects[i].Effect)
            {
                case SPELL_EFFECT_SKILL:
                    dbc_node.skill = entry->Effects[i].MiscValue;
                    dbc_node.step  = entry->Effects[i].CalcValue();
                    if (dbc_node.skill != SKILL_RIDING)
                    {
                        dbc_node.value = 1;
                    }
                    else
                    {
                        dbc_node.value = dbc_node.step * 75;
                    }
                    dbc_node.maxvalue = dbc_node.step * 75;
                    break;
                case SPELL_EFFECT_DUAL_WIELD:
                    dbc_node.skill = SKILL_DUAL_WIELD;
                    dbc_node.step = 1;
                    dbc_node.value = 1;
                    dbc_node.maxvalue = 1;
                    break;
                default:
                    continue;
            }
 
            mSpellLearnSkills[spell] = dbc_node;
            ++dbc_count;
            break;
        }
    }
 
    LOG_INFO("server.loading", ">> Loaded {} Spell Learn Skills From DBC in {} ms", dbc_count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References SpellInfo::Effects, getMSTime(), GetMSTimeDiffToNow(), GetSpellInfo(), GetSpellInfoStoreSize(), LOG_INFO, MAX_SPELL_EFFECTS, SpellLearnSkillNode::maxvalue, mSpellLearnSkills, SpellLearnSkillNode::skill, SKILL_DUAL_WIELD, SKILL_RIDING, SPELL_EFFECT_DUAL_WIELD, SPELL_EFFECT_SKILL, SpellLearnSkillNode::step, and SpellLearnSkillNode::value.

◆ LoadSpellLinked()

void SpellMgr::LoadSpellLinked ( )

{
    uint32 oldMSTime = getMSTime();
 
    mSpellLinkedMap.clear();    // need for reload case
 
    //                                                0              1             2
    QueryResult result = WorldDatabase.Query("SELECT spell_trigger, spell_effect, type FROM spell_linked_spell");
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 linked spells. DB table `spell_linked_spell` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
 
        int32 trigger = fields[0].Get<int32>();
        int32 effect = fields[1].Get<int32>();
        int32 type = fields[2].Get<uint8>();
 
        SpellInfo const* spellInfo = GetSpellInfo(std::abs(trigger));
        if (!spellInfo)
        {
            LOG_ERROR("sql.sql", "Spell {} listed in `spell_linked_spell` does not exist", std::abs(trigger));
            continue;
        }
        spellInfo = GetSpellInfo(std::abs(effect));
        if (!spellInfo)
        {
            LOG_ERROR("sql.sql", "Spell {} listed in `spell_linked_spell` does not exist", std::abs(effect));
            continue;
        }
 
        if (type) //we will find a better way when more types are needed
        {
            if (trigger > 0)
                trigger += SPELL_LINKED_MAX_SPELLS * type;
            else
                trigger -= SPELL_LINKED_MAX_SPELLS * type;
        }
        mSpellLinkedMap[trigger].push_back(effect);
 
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} Linked Spells in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References Field::Get(), getMSTime(), GetMSTimeDiffToNow(), GetSpellInfo(), LOG_ERROR, LOG_INFO, LOG_WARN, mSpellLinkedMap, SPELL_LINKED_MAX_SPELLS, and WorldDatabase.

◆ LoadSpellMixology()

void SpellMgr::LoadSpellMixology ( )

{
    uint32 oldMSTime = getMSTime();
 
    mSpellMixologyMap.clear();                                // need for reload case
 
    //                                                0      1
    QueryResult result = WorldDatabase.Query("SELECT entry, pctMod FROM spell_mixology");
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 mixology bonuses. DB table `spell_mixology` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
 
        uint32 entry = fields[0].Get<uint32>();
 
        if (!GetSpellInfo(entry))
        {
            LOG_ERROR("sql.sql", "Spell {} listed in `spell_mixology` does not exist", entry);
            continue;
        }
 
        mSpellMixologyMap[entry] = fields[1].Get<float>();
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} Mixology Bonuses in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References Field::Get(), getMSTime(), GetMSTimeDiffToNow(), GetSpellInfo(), LOG_ERROR, LOG_INFO, LOG_WARN, mSpellMixologyMap, and WorldDatabase.

◆ LoadSpellPetAuras()

void SpellMgr::LoadSpellPetAuras ( )

{
    uint32 oldMSTime = getMSTime();
 
    mSpellPetAuraMap.clear();                                  // need for reload case
 
    //                                                  0       1       2    3
    QueryResult result = WorldDatabase.Query("SELECT spell, effectId, pet, aura FROM spell_pet_auras");
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 spell pet auras. DB table `spell_pet_auras` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
 
        uint32 spell = fields[0].Get<uint32>();
        uint8 eff = fields[1].Get<uint8>();
        uint32 pet = fields[2].Get<uint32>();
        uint32 aura = fields[3].Get<uint32>();
 
        SpellPetAuraMap::iterator itr = mSpellPetAuraMap.find((spell << 8) + eff);
        if (itr != mSpellPetAuraMap.end())
            itr->second.AddAura(pet, aura);
        else
        {
            SpellInfo const* spellInfo = GetSpellInfo(spell);
            if (!spellInfo)
            {
                LOG_ERROR("sql.sql", "Spell {} listed in `spell_pet_auras` does not exist", spell);
                continue;
            }
            if (spellInfo->Effects[eff].Effect != SPELL_EFFECT_DUMMY &&
                    (spellInfo->Effects[eff].Effect != SPELL_EFFECT_APPLY_AURA ||
                     spellInfo->Effects[eff].ApplyAuraName != SPELL_AURA_DUMMY))
            {
                LOG_ERROR("spells", "Spell {} listed in `spell_pet_auras` does not have dummy aura or dummy effect", spell);
                continue;
            }
 
            SpellInfo const* spellInfo2 = GetSpellInfo(aura);
            if (!spellInfo2)
            {
                LOG_ERROR("sql.sql", "Aura {} listed in `spell_pet_auras` does not exist", aura);
                continue;
            }
 
            PetAura pa(pet, aura, spellInfo->Effects[eff].TargetA.GetTarget() == TARGET_UNIT_PET, spellInfo->Effects[eff].CalcValue());
            mSpellPetAuraMap[(spell << 8) + eff] = pa;
        }
 
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} Spell Pet Auras in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References SpellInfo::Effects, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), GetSpellInfo(), LOG_ERROR, LOG_INFO, LOG_WARN, mSpellPetAuraMap, SPELL_AURA_DUMMY, SPELL_EFFECT_APPLY_AURA, SPELL_EFFECT_DUMMY, TARGET_UNIT_PET, and WorldDatabase.

◆ LoadSpellProcs()

void SpellMgr::LoadSpellProcs ( )

{
    uint32 oldMSTime = getMSTime();
 
    mSpellProcMap.clear();                             // need for reload case
 
    //                                                 0        1           2                3                 4                 5                 6          7              8              9         10              11                  12             13      14        15
    QueryResult result = WorldDatabase.Query("SELECT SpellId, SchoolMask, SpellFamilyName, SpellFamilyMask0, SpellFamilyMask1, SpellFamilyMask2, ProcFlags, SpellTypeMask, SpellPhaseMask, HitMask, AttributesMask, DisableEffectsMask, ProcsPerMinute, Chance, Cooldown, Charges FROM spell_proc");
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 Spell Proc Conditions And Data. DB table `spell_proc` Is Empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
 
        int32 spellId = fields[0].Get<int32>();
 
        bool allRanks = false;
        if (spellId < 0)
        {
            allRanks = true;
            spellId = -spellId;
        }
 
        SpellInfo const* spellInfo = GetSpellInfo(spellId);
        if (!spellInfo)
        {
            LOG_ERROR("sql.sql", "Spell {} listed in `spell_proc` does not exist", spellId);
            continue;
        }
 
        if (allRanks)
        {
            if (spellInfo->GetFirstRankSpell()->Id != uint32(spellId))
            {
                LOG_ERROR("sql.sql", "Spell {} listed in `spell_proc` is not first rank of spell.", fields[0].Get<int32>());
                continue;
            }
        }
 
        SpellProcEntry baseProcEntry;
 
        baseProcEntry.SchoolMask         = fields[1].Get<int8>();
        baseProcEntry.SpellFamilyName    = fields[2].Get<uint16>();
        baseProcEntry.SpellFamilyMask[0] = fields[3].Get<uint32>();
        baseProcEntry.SpellFamilyMask[1] = fields[4].Get<uint32>();
        baseProcEntry.SpellFamilyMask[2] = fields[5].Get<uint32>();
        baseProcEntry.ProcFlags          = fields[6].Get<uint32>();
        baseProcEntry.SpellTypeMask      = fields[7].Get<uint32>();
        baseProcEntry.SpellPhaseMask     = fields[8].Get<uint32>();
        baseProcEntry.HitMask            = fields[9].Get<uint32>();
        baseProcEntry.AttributesMask     = fields[10].Get<uint32>();
        baseProcEntry.DisableEffectsMask = fields[11].Get<uint32>();
        baseProcEntry.ProcsPerMinute     = fields[12].Get<float>();
        baseProcEntry.Chance             = fields[13].Get<float>();
        baseProcEntry.Cooldown           = Milliseconds(fields[14].Get<uint32>());
        baseProcEntry.Charges            = fields[15].Get<uint32>();
 
        while (spellInfo)
        {
            if (mSpellProcMap.find(spellInfo->Id) != mSpellProcMap.end())
            {
                LOG_ERROR("sql.sql", "Spell {} listed in `spell_proc` has duplicate entry in the table", spellId);
                break;
            }
            SpellProcEntry procEntry = SpellProcEntry(baseProcEntry);
 
            // take defaults from dbcs
            if (!procEntry.ProcFlags)
                procEntry.ProcFlags = spellInfo->ProcFlags;
            if (!procEntry.Charges)
                procEntry.Charges = spellInfo->ProcCharges;
            if (!procEntry.Chance && !procEntry.ProcsPerMinute)
                procEntry.Chance = float(spellInfo->ProcChance);
 
            // validate data
            if (procEntry.SchoolMask & ~SPELL_SCHOOL_MASK_ALL)
                LOG_ERROR("sql.sql", "`spell_proc` table entry for SpellId {} has wrong `SchoolMask` set: {}", spellId, procEntry.SchoolMask);
            if (procEntry.SpellFamilyName && (procEntry.SpellFamilyName < 3 || procEntry.SpellFamilyName > 17 || procEntry.SpellFamilyName == 14 || procEntry.SpellFamilyName == 16))
                LOG_ERROR("sql.sql", "`spell_proc` table entry for SpellId {} has wrong `SpellFamilyName` set: {}", spellId, procEntry.SpellFamilyName);
            if (procEntry.Chance < 0)
            {
                LOG_ERROR("sql.sql", "`spell_proc` table entry for SpellId {} has negative value in `Chance` field", spellId);
                procEntry.Chance = 0;
            }
            if (procEntry.ProcsPerMinute < 0)
            {
                LOG_ERROR("sql.sql", "`spell_proc` table entry for SpellId {} has negative value in `ProcsPerMinute` field", spellId);
                procEntry.ProcsPerMinute = 0;
            }
            if (procEntry.Charges > 99)
            {
                LOG_ERROR("sql.sql", "`spell_proc` table entry for SpellId {} has too big value in `Charges` field", spellId);
                procEntry.Charges = 99;
            }
            if (!procEntry.ProcFlags)
                LOG_ERROR("sql.sql", "`spell_proc` table entry for SpellId {} doesn't have `ProcFlags` value defined, proc will not be triggered", spellId);
            if (procEntry.SpellTypeMask & ~PROC_SPELL_TYPE_MASK_ALL)
                LOG_ERROR("sql.sql", "`spell_proc` table entry for SpellId {} has wrong `SpellTypeMask` set: {}", spellId, procEntry.SpellTypeMask);
            if (procEntry.SpellTypeMask && !(procEntry.ProcFlags & (SPELL_PROC_FLAG_MASK | PERIODIC_PROC_FLAG_MASK)))
                LOG_ERROR("sql.sql", "`spell_proc` table entry for SpellId {} has `SpellTypeMask` value defined, but it won't be used for defined `ProcFlags` value", spellId);
            if (!procEntry.SpellPhaseMask && procEntry.ProcFlags & REQ_SPELL_PHASE_PROC_FLAG_MASK)
                LOG_ERROR("sql.sql", "`spell_proc` table entry for SpellId {} doesn't have `SpellPhaseMask` value defined, but it's required for defined `ProcFlags` value, proc will not be triggered", spellId);
            if (procEntry.SpellPhaseMask & ~PROC_SPELL_PHASE_MASK_ALL)
                LOG_ERROR("sql.sql", "`spell_proc` table entry for SpellId {} has wrong `SpellPhaseMask` set: {}", spellId, procEntry.SpellPhaseMask);
            if (procEntry.SpellPhaseMask && !(procEntry.ProcFlags & REQ_SPELL_PHASE_PROC_FLAG_MASK))
                LOG_ERROR("sql.sql", "`spell_proc` table entry for SpellId {} has `SpellPhaseMask` value defined, but it won't be used for defined `ProcFlags` value", spellId);
            if (procEntry.HitMask & ~PROC_HIT_MASK_ALL)
                LOG_ERROR("sql.sql", "`spell_proc` table entry for SpellId {} has wrong `HitMask` set: {}", spellId, procEntry.HitMask);
            // HitMask is valid for: TAKEN procs, or DONE procs at any phase (CAST phase has pre-calculated crit for travel-time spells)
            if (procEntry.HitMask && !(procEntry.ProcFlags & TAKEN_HIT_PROC_FLAG_MASK || procEntry.ProcFlags & DONE_HIT_PROC_FLAG_MASK))
                LOG_ERROR("sql.sql", "`spell_proc` table entry for SpellId {} has `HitMask` value defined, but it won't be used for defined `ProcFlags` and `SpellPhaseMask` values", spellId);
            for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
                if ((procEntry.DisableEffectsMask & (1u << i)) && !spellInfo->Effects[i].IsAura())
                    LOG_ERROR("sql.sql", "The `spell_proc` table entry for spellId {} has DisableEffectsMask with effect {}, but effect {} is not an aura effect", spellId, static_cast<uint32>(i), static_cast<uint32>(i));
            if (procEntry.AttributesMask & PROC_ATTR_REQ_SPELLMOD)
            {
                bool found = false;
                for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
                {
                    if (!spellInfo->Effects[i].IsAura())
                        continue;
 
                    if (spellInfo->Effects[i].ApplyAuraName == SPELL_AURA_ADD_PCT_MODIFIER || spellInfo->Effects[i].ApplyAuraName == SPELL_AURA_ADD_FLAT_MODIFIER
                        || spellInfo->Effects[i].ApplyAuraName == SPELL_AURA_MOD_SPELL_CRIT_CHANCE || spellInfo->Effects[i].ApplyAuraName == SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL)
                    {
                        found = true;
                        break;
                    }
                }
 
                if (!found)
                    LOG_ERROR("sql.sql", "The `spell_proc` table entry for spellId {} has Attribute PROC_ATTR_REQ_SPELLMOD, but spell has no spell mods. Proc will not be triggered", spellId);
            }
 
            mSpellProcMap[spellInfo->Id] = procEntry;
 
            if (allRanks)
                spellInfo = spellInfo->GetNextRankSpell();
            else
                break;
        }
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} spell proc conditions and data in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
 
    // Generate default procs for spells with proc flags but no explicit spell_proc entry
    // This ensures backward compatibility and covers spells that rely on DBC data
    LOG_INFO("server.loading", "Generating spell proc data from SpellMap...");
    count = 0;
    oldMSTime = getMSTime();
 
    for (SpellInfo const* spellInfo : mSpellInfoMap)
    {
        if (!spellInfo)
            continue;
 
        // Skip if already has explicit entry
        if (mSpellProcMap.find(spellInfo->Id) != mSpellProcMap.end())
            continue;
 
        // Check if spell has any trigger aura effects
        bool found = false, addTriggerFlag = false;
        uint32 procSpellTypeMask = PROC_SPELL_TYPE_NONE;
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (!spellInfo->Effects[i].IsEffect())
                continue;
 
            uint32 auraName = spellInfo->Effects[i].ApplyAuraName;
            if (!auraName)
                continue;
 
            if (!isTriggerAura[auraName])
                continue;
 
            found = true;
            procSpellTypeMask |= spellTypeMask[auraName];
 
            if (!addTriggerFlag && isAlwaysTriggeredAura[auraName])
                addTriggerFlag = true;
 
            // Many proc auras with taken procFlag mask don't have
            // attribute "can proc with triggered" — they should
            // proc nevertheless (e.g. mage armor spells with
            // judgement)
            if (!addTriggerFlag
                && (spellInfo->ProcFlags & TAKEN_HIT_PROC_FLAG_MASK))
            {
                switch (auraName)
                {
                    case SPELL_AURA_PROC_TRIGGER_SPELL:
                    case SPELL_AURA_PROC_TRIGGER_DAMAGE:
                        addTriggerFlag = true;
                        break;
                    default:
                        break;
                }
            }
        }
 
        if (!found)
            continue;
 
        // Skip if no proc flags in DBC
        if (!spellInfo->ProcFlags)
            continue;
 
        // Generate default proc entry from DBC data
        SpellProcEntry procEntry;
        procEntry.SchoolMask      = 0;
        procEntry.SpellFamilyMask[0] = 0;
        procEntry.SpellFamilyMask[1] = 0;
        procEntry.SpellFamilyMask[2] = 0;
        for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
            if (spellInfo->Effects[i].IsEffect() && isTriggerAura[spellInfo->Effects[i].ApplyAuraName])
                procEntry.SpellFamilyMask |= spellInfo->Effects[i].SpellClassMask;
 
        if (procEntry.SpellFamilyMask)
            procEntry.SpellFamilyName = spellInfo->SpellFamilyName;
        else
            procEntry.SpellFamilyName = 0;
 
        procEntry.ProcFlags = spellInfo->ProcFlags;
        procEntry.SpellTypeMask   = procSpellTypeMask;
        procEntry.SpellPhaseMask  = PROC_SPELL_PHASE_HIT;
        procEntry.HitMask         = PROC_HIT_NONE; // uses default proc @see SpellMgr::CanSpellTriggerProcOnEvent
 
        // Reflect auras should only proc off reflects
        for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (spellInfo->Effects[i].IsAura(SPELL_AURA_REFLECT_SPELLS) || spellInfo->Effects[i].IsAura(SPELL_AURA_REFLECT_SPELLS_SCHOOL))
            {
                procEntry.HitMask = PROC_HIT_REFLECT;
                break;
            }
        }
 
        procEntry.AttributesMask  = 0;
        if (spellInfo->ProcFlags & PROC_FLAG_KILL)
            procEntry.AttributesMask |= PROC_ATTR_REQ_EXP_OR_HONOR;
        if (addTriggerFlag)
            procEntry.AttributesMask |= PROC_ATTR_TRIGGERED_CAN_PROC;
 
        // Modifier auras with charges should require spellmod validation
        if (spellInfo->ProcCharges)
        {
            for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
            {
                if (spellInfo->Effects[i].IsAura(SPELL_AURA_ADD_FLAT_MODIFIER) ||
                    spellInfo->Effects[i].IsAura(SPELL_AURA_ADD_PCT_MODIFIER))
                {
                    procEntry.AttributesMask |= PROC_ATTR_REQ_SPELLMOD;
                    break;
                }
            }
        }
 
        // Calculate DisableEffectsMask for effects that shouldn't trigger procs
        uint32 nonProcMask = 0;
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (!spellInfo->Effects[i].IsAura())
                continue;
            if (!isTriggerAura[spellInfo->Effects[i].ApplyAuraName])
                nonProcMask |= 1u << i;
        }
        procEntry.DisableEffectsMask = nonProcMask;
 
        procEntry.ProcsPerMinute  = 0;
        procEntry.Chance          = static_cast<float>(spellInfo->ProcChance);
        procEntry.Cooldown        = Milliseconds::zero();
        procEntry.Charges         = spellInfo->ProcCharges;
 
        mSpellProcMap[spellInfo->Id] = procEntry;
        ++count;
    }
 
    LOG_INFO("server.loading", ">> Generated spell proc data for {} spells in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References SpellProcEntry::AttributesMask, SpellProcEntry::Chance, SpellProcEntry::Charges, SpellProcEntry::Cooldown, SpellProcEntry::DisableEffectsMask, DONE_HIT_PROC_FLAG_MASK, SpellInfo::Effects, Field::Get(), SpellInfo::GetFirstRankSpell(), getMSTime(), GetMSTimeDiffToNow(), SpellInfo::GetNextRankSpell(), GetSpellInfo(), SpellProcEntry::HitMask, SpellInfo::Id, isAlwaysTriggeredAura, isTriggerAura, LOG_ERROR, LOG_INFO, LOG_WARN, MAX_SPELL_EFFECTS, mSpellInfoMap, mSpellProcMap, PERIODIC_PROC_FLAG_MASK, PROC_ATTR_REQ_EXP_OR_HONOR, PROC_ATTR_REQ_SPELLMOD, PROC_ATTR_TRIGGERED_CAN_PROC, PROC_FLAG_KILL, PROC_HIT_MASK_ALL, PROC_HIT_NONE, PROC_HIT_REFLECT, PROC_SPELL_PHASE_HIT, PROC_SPELL_PHASE_MASK_ALL, PROC_SPELL_TYPE_MASK_ALL, PROC_SPELL_TYPE_NONE, SpellInfo::ProcChance, SpellInfo::ProcCharges, SpellInfo::ProcFlags, SpellProcEntry::ProcFlags, SpellProcEntry::ProcsPerMinute, REQ_SPELL_PHASE_PROC_FLAG_MASK, SpellProcEntry::SchoolMask, SPELL_AURA_ADD_FLAT_MODIFIER, SPELL_AURA_ADD_PCT_MODIFIER, SPELL_AURA_MOD_SPELL_CRIT_CHANCE, SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL, SPELL_AURA_PROC_TRIGGER_DAMAGE, SPELL_AURA_PROC_TRIGGER_SPELL, SPELL_AURA_REFLECT_SPELLS, SPELL_AURA_REFLECT_SPELLS_SCHOOL, SPELL_PROC_FLAG_MASK, SPELL_SCHOOL_MASK_ALL, SpellProcEntry::SpellFamilyMask, SpellProcEntry::SpellFamilyName, SpellProcEntry::SpellPhaseMask, spellTypeMask, SpellProcEntry::SpellTypeMask, TAKEN_HIT_PROC_FLAG_MASK, and WorldDatabase.

◆ LoadSpellRanks()

void SpellMgr::LoadSpellRanks ( )

{
    // cleanup data and load spell ranks for talents from dbc
    LoadSpellTalentRanks();
 
    uint32 oldMSTime = getMSTime();
 
    //                                               0               1          2
    QueryResult result = WorldDatabase.Query("SELECT first_spell_id, spell_id, `rank` from spell_ranks ORDER BY first_spell_id, `rank`");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 spell rank records. DB table `spell_ranks` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    bool finished = false;
 
    do
    {
        // spellid, rank
        std::list < std::pair < int32, int32 > > rankChain;
        int32 currentSpell = -1;
        int32 lastSpell = -1;
 
        // fill one chain
        while (currentSpell == lastSpell && !finished)
        {
            Field* fields = result->Fetch();
 
            currentSpell = fields[0].Get<uint32>();
            if (lastSpell == -1)
                lastSpell = currentSpell;
            uint32 spell_id = fields[1].Get<uint32>();
            uint32 rank = fields[2].Get<uint8>();
 
            // don't drop the row if we're moving to the next rank
            if (currentSpell == lastSpell)
            {
                rankChain.push_back(std::make_pair(spell_id, rank));
                if (!result->NextRow())
                    finished = true;
            }
            else
                break;
        }
        // check if chain is made with valid first spell
        SpellInfo const* first = GetSpellInfo(lastSpell);
        if (!first)
        {
            LOG_ERROR("sql.sql", "Spell rank identifier(first_spell_id) {} listed in `spell_ranks` does not exist!", lastSpell);
            continue;
        }
        // check if chain is long enough
        if (rankChain.size() < 2)
        {
            LOG_ERROR("sql.sql", "There is only 1 spell rank for identifier(first_spell_id) {} in `spell_ranks`, entry is not needed!", lastSpell);
            continue;
        }
        int32 curRank = 0;
        bool valid = true;
        // check spells in chain
        for (std::list<std::pair<int32, int32> >::iterator itr = rankChain.begin(); itr != rankChain.end(); ++itr)
        {
            SpellInfo const* spell = GetSpellInfo(itr->first);
            if (!spell)
            {
                LOG_ERROR("sql.sql", "Spell {} (rank {}) listed in `spell_ranks` for chain {} does not exist!", itr->first, itr->second, lastSpell);
                valid = false;
                break;
            }
            ++curRank;
            if (itr->second != curRank)
            {
                LOG_ERROR("sql.sql", "Spell {} (rank {}) listed in `spell_ranks` for chain {} does not have proper rank value(should be {})!", itr->first, itr->second, lastSpell, curRank);
                valid = false;
                break;
            }
        }
        if (!valid)
            continue;
        int32 prevRank = 0;
        // insert the chain
        std::list<std::pair<int32, int32> >::iterator itr = rankChain.begin();
        do
        {
            ++count;
            int32 addedSpell = itr->first;
            mSpellChains[addedSpell].first = GetSpellInfo(lastSpell);
            mSpellChains[addedSpell].last = GetSpellInfo(rankChain.back().first);
            mSpellChains[addedSpell].rank = itr->second;
            mSpellChains[addedSpell].prev = GetSpellInfo(prevRank);
            mSpellInfoMap[addedSpell]->ChainEntry = &mSpellChains[addedSpell];
            prevRank = addedSpell;
            ++itr;
            if (itr == rankChain.end())
            {
                mSpellChains[addedSpell].next = nullptr;
                break;
            }
            else
                mSpellChains[addedSpell].next = GetSpellInfo(itr->first);
        } while (true);
    } while (!finished);
 
    LOG_INFO("server.loading", ">> Loaded {} spell rank records in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References Field::Get(), getMSTime(), GetMSTimeDiffToNow(), GetSpellInfo(), LoadSpellTalentRanks(), LOG_ERROR, LOG_INFO, LOG_WARN, mSpellChains, mSpellInfoMap, and WorldDatabase.

◆ LoadSpellRequired()

void SpellMgr::LoadSpellRequired ( )

{
    uint32 oldMSTime = getMSTime();
 
    mSpellsReqSpell.clear();                                   // need for reload case
    mSpellReq.clear();                                         // need for reload case
 
    //                                                   0        1
    QueryResult result = WorldDatabase.Query("SELECT spell_id, req_spell from spell_required");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 spell required records. DB table `spell_required` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
 
        uint32 spellId = fields[0].Get<uint32>();
        uint32 spellReq = fields[1].Get<uint32>();
 
        // check if chain is made with valid first spell
        SpellInfo const* spellInfo = GetSpellInfo(spellId);
        if (!spellInfo)
        {
            LOG_ERROR("sql.sql", "spell_id {} in `spell_required` table is not found in dbcs, skipped", spellId);
            continue;
        }
 
        SpellInfo const* reqSpellInfo = GetSpellInfo(spellReq);
        if (!reqSpellInfo)
        {
            LOG_ERROR("sql.sql", "req_spell {} in `spell_required` table is not found in dbcs, skipped", spellReq);
            continue;
        }
 
        if (GetFirstSpellInChain(spellId) == GetFirstSpellInChain(spellReq))
        {
            LOG_ERROR("sql.sql", "req_spell {} and spell_id {} in `spell_required` table are ranks of the same spell, entry not needed, skipped", spellReq, spellId);
            continue;
        }
 
        if (IsSpellRequiringSpell(spellId, spellReq))
        {
            LOG_ERROR("sql.sql", "duplicated entry of req_spell {} and spell_id {} in `spell_required`, skipped", spellReq, spellId);
            continue;
        }
 
        mSpellReq.insert (std::pair<uint32, uint32>(spellId, spellReq));
        mSpellsReqSpell.insert (std::pair<uint32, uint32>(spellReq, spellId));
        ++count;
 
        // xinef: fill additionalTalentInfo data, currently Blessing of Sanctuary only
        if (GetTalentSpellCost(spellReq) > 0)
            mTalentSpellAdditionalSet.insert(spellId);
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} Spell Required Records in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References Field::Get(), GetFirstSpellInChain(), getMSTime(), GetMSTimeDiffToNow(), GetSpellInfo(), GetTalentSpellCost(), IsSpellRequiringSpell(), LOG_ERROR, LOG_INFO, LOG_WARN, mSpellReq, mSpellsReqSpell, mTalentSpellAdditionalSet, and WorldDatabase.

◆ LoadSpellSpecificAndAuraState()

void SpellMgr::LoadSpellSpecificAndAuraState ( )

{
    uint32 oldMSTime = getMSTime();
 
    SpellInfo* spellInfo = nullptr;
    for (uint32 i = 0; i < GetSpellInfoStoreSize(); ++i)
    {
        spellInfo = mSpellInfoMap[i];
        if (!spellInfo)
            continue;
        spellInfo->_spellSpecific = spellInfo->LoadSpellSpecific();
        spellInfo->_auraState = spellInfo->LoadAuraState();
    }
 
    LOG_INFO("server.loading", ">> Loaded Spell Specific And Aura State in {} ms", GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References SpellInfo::_auraState, SpellInfo::_spellSpecific, getMSTime(), GetMSTimeDiffToNow(), GetSpellInfoStoreSize(), SpellInfo::LoadAuraState(), SpellInfo::LoadSpellSpecific(), LOG_INFO, and mSpellInfoMap.

◆ LoadSpellTalentRanks()

void SpellMgr::LoadSpellTalentRanks ( )

{
    // cleanup core data before reload - remove reference to ChainNode from SpellInfo
    UnloadSpellInfoChains();
 
    for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
    {
        TalentEntry const* talentInfo = sTalentStore.LookupEntry(i);
        if (!talentInfo)
            continue;
 
        SpellInfo const* lastSpell = nullptr;
        for (uint8 rank = MAX_TALENT_RANK - 1; rank > 0; --rank)
        {
            if (talentInfo->RankID[rank])
            {
                lastSpell = GetSpellInfo(talentInfo->RankID[rank]);
                break;
            }
        }
 
        if (!lastSpell)
            continue;
 
        SpellInfo const* firstSpell = GetSpellInfo(talentInfo->RankID[0]);
        if (!firstSpell)
        {
            LOG_ERROR("sql.sql", "SpellMgr::LoadSpellTalentRanks: First Rank Spell {} for TalentEntry {} does not exist.", talentInfo->RankID[0], i);
            continue;
        }
 
        SpellInfo const* prevSpell = nullptr;
        for (uint8 rank = 0; rank < MAX_TALENT_RANK; ++rank)
        {
            uint32 spellId = talentInfo->RankID[rank];
            if (!spellId)
                break;
 
            SpellInfo const* currentSpell = GetSpellInfo(spellId);
            if (!currentSpell)
            {
                LOG_ERROR("sql.sql", "SpellMgr::LoadSpellTalentRanks: Spell {} (Rank: {}) for TalentEntry {} does not exist.", spellId, rank + 1, i);
                break;
            }
 
            SpellChainNode node;
            node.first = firstSpell;
            node.last  = lastSpell;
            node.rank  = rank + 1;
 
            node.prev = prevSpell;
            node.next = node.rank < MAX_TALENT_RANK ? GetSpellInfo(talentInfo->RankID[node.rank]) : nullptr;
 
            mSpellChains[spellId] = node;
            mSpellInfoMap[spellId]->ChainEntry = &mSpellChains[spellId];
 
            prevSpell = currentSpell;
        }
    }
}

References SpellChainNode::first, GetSpellInfo(), SpellChainNode::last, LOG_ERROR, MAX_TALENT_RANK, mSpellChains, mSpellInfoMap, SpellChainNode::next, SpellChainNode::prev, SpellChainNode::rank, TalentEntry::RankID, sTalentStore, and UnloadSpellInfoChains().

Referenced by LoadSpellRanks().

◆ LoadSpellTargetPositions()

void SpellMgr::LoadSpellTargetPositions ( )

{
    uint32 oldMSTime = getMSTime();
 
    mSpellTargetPositions.clear();                                // need for reload case
 
    //                                                0      1          2        3         4           5            6
    QueryResult result = WorldDatabase.Query("SELECT ID, EffectIndex, MapID, PositionX, PositionY, PositionZ, Orientation FROM spell_target_position");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 spell target coordinates. DB table `spell_target_position` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
 
        uint32 Spell_ID = fields[0].Get<uint32>();
 
        SpellEffIndex effIndex = SpellEffIndex(fields[1].Get<uint8>());
 
        SpellTargetPosition st;
 
        st.target_mapId       = fields[2].Get<uint16>();
        st.target_X           = fields[3].Get<float>();
        st.target_Y           = fields[4].Get<float>();
        st.target_Z           = fields[5].Get<float>();
        st.target_Orientation = fields[6].Get<float>();
 
        MapEntry const* mapEntry = sMapStore.LookupEntry(st.target_mapId);
        if (!mapEntry)
        {
            LOG_ERROR("sql.sql", "Spell (Id: {}, effIndex: {}) target map (ID: {}) does not exist in `Map.dbc`.", Spell_ID, effIndex, st.target_mapId);
            continue;
        }
 
        if (st.target_X == 0 && st.target_Y == 0 && st.target_Z == 0)
        {
            LOG_ERROR("sql.sql", "Spell (Id: {}, effIndex: {}) target coordinates not provided.", Spell_ID, effIndex);
            continue;
        }
 
        SpellInfo const* spellInfo = GetSpellInfo(Spell_ID);
        if (!spellInfo)
        {
            LOG_ERROR("sql.sql", "Spell (ID:{}) listed in `spell_target_position` does not exist.", Spell_ID);
            continue;
        }
 
        if (spellInfo->Effects[effIndex].TargetA.GetTarget() == TARGET_DEST_DB || spellInfo->Effects[effIndex].TargetB.GetTarget() == TARGET_DEST_DB)
        {
            std::pair<uint32, SpellEffIndex> key = std::make_pair(Spell_ID, effIndex);
            mSpellTargetPositions[key] = st;
            ++count;
        }
        else
        {
            LOG_ERROR("sql.sql", "Spell (Id: {}, effIndex: {}) listed in `spell_target_position` does not have target TARGET_DEST_DB (17).", Spell_ID, effIndex);
            continue;
        }
    } while (result->NextRow());
 
    /*
    // Check all spells
    for (uint32 i = 1; i < GetSpellInfoStoreSize; ++i)
    {
        SpellInfo const* spellInfo = GetSpellInfo(i);
        if (!spellInfo)
            continue;
 
        bool found = false;
        for (int j = 0; j < MAX_SPELL_EFFECTS; ++j)
        {
            switch (spellInfo->Effects[j].TargetA)
            {
                case TARGET_DEST_DB:
                    found = true;
                    break;
            }
            if (found)
                break;
            switch (spellInfo->Effects[j].TargetB)
            {
                case TARGET_DEST_DB:
                    found = true;
                    break;
            }
            if (found)
                break;
        }
        if (found)
        {
            if (!GetSpellTargetPosition(i))
                LOG_DEBUG("spells.aura", "Spell (ID: {}) does not have record in `spell_target_position`", i);
        }
    }*/
 
    LOG_INFO("server.loading", ">> Loaded {} Spell Teleport Coordinates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References SpellInfo::Effects, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), GetSpellInfo(), LOG_ERROR, LOG_INFO, LOG_WARN, mSpellTargetPositions, sMapStore, TARGET_DEST_DB, SpellTargetPosition::target_mapId, SpellTargetPosition::target_Orientation, SpellTargetPosition::target_X, SpellTargetPosition::target_Y, SpellTargetPosition::target_Z, and WorldDatabase.

◆ LoadSpellThreats()

void SpellMgr::LoadSpellThreats ( )

{
    uint32 oldMSTime = getMSTime();
 
    mSpellThreatMap.clear();                                // need for reload case
 
    //                                                0      1        2       3
    QueryResult result = WorldDatabase.Query("SELECT entry, flatMod, pctMod, apPctMod FROM spell_threat");
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 aggro generating spells. DB table `spell_threat` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
 
        uint32 entry = fields[0].Get<uint32>();
 
        if (!GetSpellInfo(entry))
        {
            LOG_ERROR("sql.sql", "Spell {} listed in `spell_threat` does not exist", entry);
            continue;
        }
 
        SpellThreatEntry ste;
        ste.flatMod  = fields[1].Get<int32>();
        ste.pctMod   = fields[2].Get<float>();
        ste.apPctMod = fields[3].Get<float>();
 
        mSpellThreatMap[entry] = ste;
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} SpellThreatEntries in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References SpellThreatEntry::apPctMod, SpellThreatEntry::flatMod, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), GetSpellInfo(), LOG_ERROR, LOG_INFO, LOG_WARN, mSpellThreatMap, SpellThreatEntry::pctMod, and WorldDatabase.

◆ SetSpellDifficultyId()

void SpellMgr::SetSpellDifficultyId	(	uint32	spellId,
		uint32	id
	)

{
    mSpellDifficultySearcherMap[spellId] = id;
}

References mSpellDifficultySearcherMap.

◆ UnloadSpellInfoChains()

void SpellMgr::UnloadSpellInfoChains ( )

{
    for (SpellChainMap::iterator itr = mSpellChains.begin(); itr != mSpellChains.end(); ++itr)
        mSpellInfoMap[itr->first]->ChainEntry = nullptr;
 
    mSpellChains.clear();
}

References mSpellChains, and mSpellInfoMap.

Referenced by LoadSpellTalentRanks().

◆ UnloadSpellInfoImplicitTargetConditionLists()

void SpellMgr::UnloadSpellInfoImplicitTargetConditionLists ( )

{
    for (uint32 i = 0; i < GetSpellInfoStoreSize(); ++i)
    {
        if (mSpellInfoMap[i])
            mSpellInfoMap[i]->_UnloadImplicitTargetConditionLists();
    }
}

References GetSpellInfoStoreSize(), and mSpellInfoMap.

◆ UnloadSpellInfoStore()

void SpellMgr::UnloadSpellInfoStore ( )

{
    for (uint32 i = 0; i < GetSpellInfoStoreSize(); ++i)
        delete mSpellInfoMap[i];
 
    mSpellInfoMap.clear();
}

References GetSpellInfoStoreSize(), and mSpellInfoMap.

Referenced by LoadSpellInfoStore(), and ~SpellMgr().

Member Data Documentation

◆ mCreatureImmunities

CreatureImmunitiesMap SpellMgr::mCreatureImmunities

private

Referenced by GetCreatureImmunities(), and LoadCreatureImmunities().

◆ mEnchantCustomAttr

EnchantCustomAttribute SpellMgr::mEnchantCustomAttr

private

Referenced by IsArenaAllowedEnchancment(), and LoadEnchantCustomAttr().

◆ mPetDefaultSpellsMap

PetDefaultSpellsMap SpellMgr::mPetDefaultSpellsMap

private

Referenced by GetPetDefaultSpellsEntry(), and LoadPetDefaultSpells().

◆ mPetLevelupSpellMap

PetLevelupSpellMap SpellMgr::mPetLevelupSpellMap

private

Referenced by GetPetLevelupSpellList(), and LoadPetLevelupSpellMap().

◆ mSkillLineAbilityMap

SkillLineAbilityMap SpellMgr::mSkillLineAbilityMap

private

Referenced by GetSkillLineAbilityMapBounds(), and LoadSkillLineAbilityMap().

◆ mSpellAreaForAreaMap

SpellAreaForAreaMap SpellMgr::mSpellAreaForAreaMap

private

Referenced by GetSpellAreaForAreaMapBounds(), and LoadSpellAreas().

◆ mSpellAreaForAuraMap

SpellAreaForAuraMap SpellMgr::mSpellAreaForAuraMap

private

Referenced by GetSpellAreaForAuraMapBounds(), and LoadSpellAreas().

◆ mSpellAreaForQuestEndMap

SpellAreaForQuestMap SpellMgr::mSpellAreaForQuestEndMap

private

Referenced by GetSpellAreaForQuestEndMapBounds(), and LoadSpellAreas().

◆ mSpellAreaForQuestMap

SpellAreaForQuestMap SpellMgr::mSpellAreaForQuestMap

private

Referenced by GetSpellAreaForQuestMapBounds(), and LoadSpellAreas().

◆ mSpellAreaMap

SpellAreaMap SpellMgr::mSpellAreaMap

private

Referenced by GetSpellAreaMapBounds(), and LoadSpellAreas().

◆ mSpellBonusMap

SpellBonusMap SpellMgr::mSpellBonusMap

private

Referenced by GetSpellBonusData(), and LoadSpellBonuses().

◆ mSpellChains

SpellChainMap SpellMgr::mSpellChains

private

Referenced by GetSpellChainNode(), LoadSpellRanks(), LoadSpellTalentRanks(), and UnloadSpellInfoChains().

◆ mSpellCones

SpellConeMap SpellMgr::mSpellCones

private

Referenced by GetSpellCone(), and LoadSpellCones().

◆ mSpellCooldownOverrideMap

SpellCooldownOverrideMap SpellMgr::mSpellCooldownOverrideMap

private

Referenced by GetSpellCooldownOverride(), HasSpellCooldownOverride(), and LoadSpellCooldownOverrides().

◆ mSpellDifficultySearcherMap

SpellDifficultySearcherMap SpellMgr::mSpellDifficultySearcherMap

private

Referenced by GetSpellDifficultyId(), and SetSpellDifficultyId().

◆ mSpellEnchantProcEventMap

SpellEnchantProcEventMap SpellMgr::mSpellEnchantProcEventMap

private

Referenced by GetSpellEnchantProcEvent(), and LoadSpellEnchantProcData().

◆ mSpellGroupSpell

SpellGroupSpellMap SpellMgr::mSpellGroupSpell

private

Referenced by GetSpellGroupSpellMapBounds(), and LoadSpellGroups().

◆ mSpellGroupStack

SpellGroupStackMap SpellMgr::mSpellGroupStack

private

Referenced by CheckSpellGroupStackRules(), GetSpellGroupStackRule(), and LoadSpellGroupStackRules().

◆ mSpellInfoMap

SpellInfoMap SpellMgr::mSpellInfoMap

private

Referenced by _GetSpellInfo(), AssertSpellInfo(), CheckSpellInfo(), GetSpellInfo(), GetSpellInfoStoreSize(), LoadSpellInfoCorrections(), LoadSpellInfoCustomAttributes(), LoadSpellInfoImmunities(), LoadSpellInfoStore(), LoadSpellProcs(), LoadSpellRanks(), LoadSpellSpecificAndAuraState(), LoadSpellTalentRanks(), UnloadSpellInfoChains(), UnloadSpellInfoImplicitTargetConditionLists(), and UnloadSpellInfoStore().

◆ mSpellLearnSkills

SpellLearnSkillMap SpellMgr::mSpellLearnSkills

private

Referenced by GetSkillRankSpells(), GetSpellLearnSkill(), and LoadSpellLearnSkills().

◆ mSpellLinkedMap

SpellLinkedMap SpellMgr::mSpellLinkedMap

private

Referenced by GetSpellLinked(), and LoadSpellLinked().

◆ mSpellMixologyMap

SpellMixologyMap SpellMgr::mSpellMixologyMap

private

Referenced by GetSpellMixologyBonus(), and LoadSpellMixology().

◆ mSpellPetAuraMap

SpellPetAuraMap SpellMgr::mSpellPetAuraMap

private

Referenced by GetPetAura(), and LoadSpellPetAuras().

◆ mSpellProcMap

SpellProcMap SpellMgr::mSpellProcMap

private

Referenced by GetSpellProcEntry(), and LoadSpellProcs().

◆ mSpellReq

SpellRequiredMap SpellMgr::mSpellReq

private

Referenced by GetSpellsRequiredForSpellBounds(), and LoadSpellRequired().

◆ mSpellSameEffectStack

SameEffectStackMap SpellMgr::mSpellSameEffectStack

private

Referenced by AddSameEffectStackRuleSpellGroups(), and LoadSpellGroupStackRules().

◆ mSpellSpellGroup

SpellSpellGroupMap SpellMgr::mSpellSpellGroup

private

Referenced by GetSpellSpellGroupMapBounds(), and LoadSpellGroups().

◆ mSpellsReqSpell

SpellsRequiringSpellMap SpellMgr::mSpellsReqSpell

private

Referenced by GetSpellsRequiringSpellBounds(), and LoadSpellRequired().

◆ mSpellTargetPositions

SpellTargetPositionMap SpellMgr::mSpellTargetPositions

private

Referenced by GetSpellTargetPosition(), and LoadSpellTargetPositions().

◆ mSpellThreatMap

SpellThreatMap SpellMgr::mSpellThreatMap

private

Referenced by GetSpellThreatEntry(), and LoadSpellThreats().

◆ mTalentSpellAdditionalSet

TalentAdditionalSet SpellMgr::mTalentSpellAdditionalSet

private

Referenced by IsAdditionalTalentSpell(), LoadSpellInfoCustomAttributes(), and LoadSpellRequired().

The documentation for this class was generated from the following files:

azerothcore-wotlk/src/server/game/Spells/SpellMgr.h
azerothcore-wotlk/src/server/game/Spells/SpellInfoCorrections.cpp
azerothcore-wotlk/src/server/game/Spells/SpellMgr.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SpellMgr()

◆ ~SpellMgr()

Member Function Documentation

◆ _GetSpellInfo()

◆ AddSameEffectStackRuleSpellGroups()

◆ AssertSpellInfo()

◆ CanSpellTriggerProcOnEvent()

◆ CheckSpellGroupStackRules()

◆ CheckSpellInfo()

◆ CheckSpellValid()

◆ ComputeIsSpellValid()

◆ GetCreatureImmunities()

◆ GetFirstSpellInChain()

◆ GetLastSpellInChain()

◆ GetNextSpellInChain()

◆ GetPetAura()

◆ GetPetDefaultSpellsEntry()

◆ GetPetLevelupSpellList()

◆ GetPrevSpellInChain()

◆ GetSetOfSpellsInSpellGroup() [1/2]

◆ GetSetOfSpellsInSpellGroup() [2/2]

◆ GetSkillLineAbilityMapBounds()

◆ GetSkillRankSpells()

◆ GetSpellAreaForAreaMapBounds()

◆ GetSpellAreaForAuraMapBounds()

◆ GetSpellAreaForQuestEndMapBounds()

◆ GetSpellAreaForQuestMapBounds()

◆ GetSpellAreaMapBounds()

◆ GetSpellBonusData()

◆ GetSpellChainNode()

◆ GetSpellCone()

◆ GetSpellCooldownOverride()

◆ GetSpellDifficultyId()

◆ GetSpellEnchantProcEvent()

◆ GetSpellForDifficultyFromSpell()

◆ GetSpellGroupSpellMapBounds()

◆ GetSpellGroupStackRule()

◆ GetSpellIdForDifficulty()

◆ GetSpellInfo()

◆ GetSpellInfoStoreSize()

◆ GetSpellLearnSkill()

◆ GetSpellLinked()

◆ GetSpellMixologyBonus()

◆ GetSpellProcEntry()

◆ GetSpellRank()

◆ GetSpellSpellGroupMapBounds()

◆ GetSpellsRequiredForSpellBounds()

◆ GetSpellsRequiringSpellBounds()

◆ GetSpellTargetPosition()

◆ GetSpellThreatEntry()

◆ GetSpellWithRank()

◆ HasSpellCooldownOverride()

◆ instance()

◆ IsAdditionalTalentSpell()

◆ IsArenaAllowedEnchancment()

◆ IsSpellMemberOfSpellGroup()

◆ IsSpellRequiringSpell()

◆ IsSpellValid()

◆ LoadCreatureImmunities()

◆ LoadEnchantCustomAttr()

◆ LoadPetDefaultSpells()

◆ LoadPetLevelupSpellMap()

◆ LoadSkillLineAbilityMap()

◆ LoadSpellAreas()

◆ LoadSpellBonuses()

◆ LoadSpellCones()

◆ LoadSpellCooldownOverrides()

◆ LoadSpellEnchantProcData()

◆ LoadSpellGroups()

◆ LoadSpellGroupStackRules()

◆ LoadSpellInfoCorrections()

◆ LoadSpellInfoCustomAttributes()

◆ LoadSpellInfoImmunities()

◆ LoadSpellInfoStore()