SpellMgr.h File Reference

#include "Log.h"
#include "IteratorPair.h"
#include "SharedDefines.h"
#include "Unit.h"
#include <vector>
#include <bitset>

Go to the source code of this file.

Classes
struct	SpellProcEntry
struct	SpellEnchantProcEntry
struct	SpellBonusEntry
struct	std::hash< SpellGroup >
struct	SpellThreatEntry
struct	SpellTargetPosition
struct	SpellCone
class	PetAura
struct	SpellArea
struct	SpellChainNode
struct	CreatureImmunities
struct	SpellLearnSkillNode
struct	PetDefaultSpellsEntry
struct	SpellCooldownOverride
class	SpellMgr

Namespaces
namespace	std
	STL namespace.

Macros
#define	SPELL_RELIC_COOLDOWN   1
#define	SPELL_LINKED_MAX_SPELLS   200000
#define	MELEE_BASED_TRIGGER_MASK
#define	AURA_SPELL_PROC_EX_MASK
#define	SPELL_GROUP_DB_RANGE_MIN   1000
#define	sSpellMgr   SpellMgr::instance()

Typedefs
typedef std::unordered_map< uint32, SpellProcEntry >	SpellProcMap
typedef std::unordered_map< uint32, SpellEnchantProcEntry >	SpellEnchantProcEventMap
typedef std::unordered_map< uint32, SpellBonusEntry >	SpellBonusMap
typedef std::unordered_multimap< uint32, SpellGroup >	SpellSpellGroupMap
typedef std::pair< SpellSpellGroupMap::const_iterator, SpellSpellGroupMap::const_iterator >	SpellSpellGroupMapBounds
typedef std::unordered_multimap< SpellGroup, int32 >	SpellGroupSpellMap
typedef std::pair< SpellGroupSpellMap::const_iterator, SpellGroupSpellMap::const_iterator >	SpellGroupSpellMapBounds
typedef std::unordered_map< SpellGroup, SpellGroupStackRule >	SpellGroupStackMap
typedef std::unordered_map< SpellGroup, std::unordered_set< uint32 > >	SameEffectStackMap
typedef std::unordered_map< uint32, SpellThreatEntry >	SpellThreatMap
typedef std::map< uint32, float >	SpellMixologyMap
typedef std::map< std::pair< uint32, SpellEffIndex >, SpellTargetPosition >	SpellTargetPositionMap
typedef std::map< uint32, SpellCone >	SpellConeMap
typedef std::map< uint32, PetAura >	SpellPetAuraMap
typedef std::multimap< uint32, SpellArea >	SpellAreaMap
typedef std::multimap< uint32, SpellArea const * >	SpellAreaForQuestMap
typedef std::multimap< uint32, SpellArea const * >	SpellAreaForAuraMap
typedef std::multimap< uint32, SpellArea const * >	SpellAreaForAreaMap
typedef std::pair< SpellAreaMap::const_iterator, SpellAreaMap::const_iterator >	SpellAreaMapBounds
typedef std::pair< SpellAreaForQuestMap::const_iterator, SpellAreaForQuestMap::const_iterator >	SpellAreaForQuestMapBounds
typedef std::pair< SpellAreaForAuraMap::const_iterator, SpellAreaForAuraMap::const_iterator >	SpellAreaForAuraMapBounds
typedef std::pair< SpellAreaForAreaMap::const_iterator, SpellAreaForAreaMap::const_iterator >	SpellAreaForAreaMapBounds
typedef std::unordered_map< uint32, SpellChainNode >	SpellChainMap
typedef std::multimap< uint32, uint32 >	SpellRequiredMap
typedef std::pair< SpellRequiredMap::const_iterator, SpellRequiredMap::const_iterator >	SpellRequiredMapBounds
typedef std::multimap< uint32, uint32 >	SpellsRequiringSpellMap
typedef std::pair< SpellsRequiringSpellMap::const_iterator, SpellsRequiringSpellMap::const_iterator >	SpellsRequiringSpellMapBounds
typedef std::unordered_map< int32, CreatureImmunities >	CreatureImmunitiesMap
typedef std::unordered_map< uint32, SpellLearnSkillNode >	SpellLearnSkillMap
typedef std::multimap< uint32, SkillLineAbilityEntry const * >	SkillLineAbilityMap
typedef std::pair< SkillLineAbilityMap::const_iterator, SkillLineAbilityMap::const_iterator >	SkillLineAbilityMapBounds
typedef std::multimap< uint32, uint32 >	PetLevelupSpellSet
typedef std::map< uint32, PetLevelupSpellSet >	PetLevelupSpellMap
typedef std::map< uint32, uint32 >	SpellDifficultySearcherMap
typedef std::map< int32, PetDefaultSpellsEntry >	PetDefaultSpellsMap
typedef std::vector< uint32 >	SpellCustomAttribute
typedef std::vector< bool >	EnchantCustomAttribute
typedef std::vector< SpellInfo * >	SpellInfoMap
typedef std::map< int32, std::vector< int32 > >	SpellLinkedMap
typedef std::map< uint32, SpellCooldownOverride >	SpellCooldownOverrideMap
typedef std::set< uint32 >	TalentAdditionalSet

Enumerations
enum	SpellCategories {   SPELLCATEGORY_HEALTH_MANA_POTIONS = 4 ,   SPELLCATEGORY_DEVOUR_MAGIC = 12 ,   SPELLCATEGORY_JUDGEMENT = 1210 ,   SPELLCATEGORY_FOOD = 11 ,   SPELLCATEGORY_DRINK = 59 }
enum	SpellFamilyFlag {   SPELLFAMILYFLAG_ROGUE_VANISH = 0x00000800 ,   SPELLFAMILYFLAG_ROGUE_VAN_EVAS_SPRINT = 0x00000860 ,   SPELLFAMILYFLAG1_ROGUE_COLDB_SHADOWSTEP = 0x00000240 ,   SPELLFAMILYFLAG_ROGUE_KICK = 0x00000010 ,   SPELLFAMILYFLAG1_ROGUE_DISMANTLE = 0x00100000 ,   SPELLFAMILYFLAG_ROGUE_BLADE_FLURRY = 0x40000000 ,   SPELLFAMILYFLAG1_ROGUE_BLADE_FLURRY = 0x00000800 ,   SPELLFAMILYFLAG_WARRIOR_CHARGE = 0x00000001 ,   SPELLFAMILYFLAG_WARRIOR_SLAM = 0x00200000 ,   SPELLFAMILYFLAG_WARRIOR_EXECUTE = 0x20000000 ,   SPELLFAMILYFLAG_WARRIOR_CONCUSSION_BLOW = 0x04000000 ,   SPELLFAMILYFLAG_WARLOCK_LIFETAP = 0x00040000 ,   SPELLFAMILYFLAG2_DRUID_STARFALL = 0x00000100 ,   SPELLFAMILYFLAG1_PALADIN_DIVINESTORM = 0x00020000 ,   SPELLFAMILYFLAG_SHAMAN_FROST_SHOCK = 0x80000000 ,   SPELLFAMILYFLAG_SHAMAN_HEALING_STREAM = 0x00002000 ,   SPELLFAMILYFLAG_SHAMAN_MANA_SPRING = 0x00004000 ,   SPELLFAMILYFLAG2_SHAMAN_LAVA_LASH = 0x00000004 ,   SPELLFAMILYFLAG_SHAMAN_FIRE_NOVA = 0x28000000 ,   SPELLFAMILYFLAG_DK_DEATH_STRIKE = 0x00000010 ,   SPELLFAMILYFLAG_DK_DEATH_COIL = 0x00002000 ,   SPELLFAMILYFLAG_SHAMAN_TOTEM_EFFECTS = 0x04000000 }
enum	SpellLinkedType {   SPELL_LINK_CAST = 0 ,   SPELL_LINK_HIT = 1 * 200000 ,   SPELL_LINK_AURA = 2 * 200000 ,   SPELL_LINK_REMOVE = 0 }
enum	ProcFlags {   PROC_FLAG_NONE = 0x00000000 ,   PROC_FLAG_KILLED = 0x00000001 ,   PROC_FLAG_KILL = 0x00000002 ,   PROC_FLAG_DONE_MELEE_AUTO_ATTACK = 0x00000004 ,   PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK = 0x00000008 ,   PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS = 0x00000010 ,   PROC_FLAG_TAKEN_SPELL_MELEE_DMG_CLASS = 0x00000020 ,   PROC_FLAG_DONE_RANGED_AUTO_ATTACK = 0x00000040 ,   PROC_FLAG_TAKEN_RANGED_AUTO_ATTACK = 0x00000080 ,   PROC_FLAG_DONE_SPELL_RANGED_DMG_CLASS = 0x00000100 ,   PROC_FLAG_TAKEN_SPELL_RANGED_DMG_CLASS = 0x00000200 ,   PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS = 0x00000400 ,   PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_POS = 0x00000800 ,   PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_NEG = 0x00001000 ,   PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_NEG = 0x00002000 ,   PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS = 0x00004000 ,   PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_POS = 0x00008000 ,   PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG = 0x00010000 ,   PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG = 0x00020000 ,   PROC_FLAG_DONE_PERIODIC = 0x00040000 ,   PROC_FLAG_TAKEN_PERIODIC = 0x00080000 ,   PROC_FLAG_TAKEN_DAMAGE = 0x00100000 ,   PROC_FLAG_DONE_TRAP_ACTIVATION = 0x00200000 ,   PROC_FLAG_DONE_MAINHAND_ATTACK = 0x00400000 ,   PROC_FLAG_DONE_OFFHAND_ATTACK = 0x00800000 ,   PROC_FLAG_DEATH = 0x01000000 ,   AUTO_ATTACK_PROC_FLAG_MASK ,   MELEE_PROC_FLAG_MASK ,   RANGED_PROC_FLAG_MASK ,   SPELL_PROC_FLAG_MASK ,   PERIODIC_PROC_FLAG_MASK = PROC_FLAG_DONE_PERIODIC | PROC_FLAG_TAKEN_PERIODIC ,   DONE_HIT_PROC_FLAG_MASK ,   TAKEN_HIT_PROC_FLAG_MASK ,   REQ_SPELL_PHASE_PROC_FLAG_MASK = SPELL_PROC_FLAG_MASK & DONE_HIT_PROC_FLAG_MASK }
enum	ProcFlagsExLegacy {   PROC_EX_NONE = 0x0000000 ,   PROC_EX_NORMAL_HIT = 0x0000001 ,   PROC_EX_CRITICAL_HIT = 0x0000002 ,   PROC_EX_MISS = 0x0000004 ,   PROC_EX_RESIST = 0x0000008 ,   PROC_EX_DODGE = 0x0000010 ,   PROC_EX_PARRY = 0x0000020 ,   PROC_EX_BLOCK = 0x0000040 ,   PROC_EX_EVADE = 0x0000080 ,   PROC_EX_IMMUNE = 0x0000100 ,   PROC_EX_DEFLECT = 0x0000200 ,   PROC_EX_ABSORB = 0x0000400 ,   PROC_EX_REFLECT = 0x0000800 ,   PROC_EX_INTERRUPT = 0x0001000 ,   PROC_EX_FULL_BLOCK = 0x0002000 ,   PROC_EX_RESERVED2 = 0x0004000 ,   PROC_EX_NOT_ACTIVE_SPELL = 0x0008000 ,   PROC_EX_EX_TRIGGER_ALWAYS = 0x0010000 ,   PROC_EX_EX_ONE_TIME_TRIGGER = 0x0020000 ,   PROC_EX_ONLY_ACTIVE_SPELL = 0x0040000 ,   PROC_EX_NO_OVERHEAL = 0x0080000 ,   PROC_EX_NO_AURA_REFRESH = 0x0100000 ,   PROC_EX_ONLY_FIRST_TICK = 0x0200000 ,   PROC_EX_INTERNAL_CANT_PROC = 0x0800000 ,   PROC_EX_INTERNAL_DOT = 0x1000000 ,   PROC_EX_INTERNAL_HOT = 0x2000000 ,   PROC_EX_INTERNAL_TRIGGERED = 0x4000000 ,   PROC_EX_INTERNAL_REQ_FAMILY = 0x8000000 }
enum	ProcFlagsSpellType {   PROC_SPELL_TYPE_NONE = 0x0000000 ,   PROC_SPELL_TYPE_DAMAGE = 0x0000001 ,   PROC_SPELL_TYPE_HEAL = 0x0000002 ,   PROC_SPELL_TYPE_NO_DMG_HEAL = 0x0000004 ,   PROC_SPELL_TYPE_MASK_ALL = PROC_SPELL_TYPE_DAMAGE | PROC_SPELL_TYPE_HEAL | PROC_SPELL_TYPE_NO_DMG_HEAL }
enum	ProcFlagsSpellPhase {   PROC_SPELL_PHASE_NONE = 0x0000000 ,   PROC_SPELL_PHASE_CAST = 0x0000001 ,   PROC_SPELL_PHASE_HIT = 0x0000002 ,   PROC_SPELL_PHASE_FINISH = 0x0000004 ,   PROC_SPELL_PHASE_MASK_ALL = PROC_SPELL_PHASE_CAST | PROC_SPELL_PHASE_HIT | PROC_SPELL_PHASE_FINISH }
enum	ProcFlagsHit {   PROC_HIT_NONE = 0x0000000 ,   PROC_HIT_NORMAL = 0x0000001 ,   PROC_HIT_CRITICAL = 0x0000002 ,   PROC_HIT_MISS = 0x0000004 ,   PROC_HIT_FULL_RESIST = 0x0000008 ,   PROC_HIT_DODGE = 0x0000010 ,   PROC_HIT_PARRY = 0x0000020 ,   PROC_HIT_BLOCK = 0x0000040 ,   PROC_HIT_EVADE = 0x0000080 ,   PROC_HIT_IMMUNE = 0x0000100 ,   PROC_HIT_DEFLECT = 0x0000200 ,   PROC_HIT_ABSORB = 0x0000400 ,   PROC_HIT_REFLECT = 0x0000800 ,   PROC_HIT_INTERRUPT = 0x0001000 ,   PROC_HIT_FULL_BLOCK = 0x0002000 ,   PROC_HIT_MASK_ALL = 0x0002FFF }
enum	ProcAttributes {   PROC_ATTR_REQ_EXP_OR_HONOR = 0x0000001 ,   PROC_ATTR_TRIGGERED_CAN_PROC = 0x0000002 ,   PROC_ATTR_REQ_MANA_COST = 0x0000004 ,   PROC_ATTR_REQ_SPELLMOD = 0x0000008 ,   PROC_ATTR_USE_STACKS_FOR_CHARGES = 0x0000010 ,   PROC_ATTR_REDUCE_PROC_60 = 0x0000080 ,   PROC_ATTR_CANT_PROC_FROM_ITEM_CAST = 0x0000100 }
enum	EnchantProcAttributes {   ENCHANT_PROC_ATTR_EXCLUSIVE = 0x1 ,   ENCHANT_PROC_ATTR_WHITE_HIT = 0x2 }
enum	SpellGroup {   SPELL_GROUP_NONE = 0 ,   SPELL_GROUP_ELIXIR_BATTLE = 1 ,   SPELL_GROUP_ELIXIR_GUARDIAN = 2 ,   SPELL_GROUP_CORE_RANGE_MAX = 3 }
enum	SpellGroupStackRule {   SPELL_GROUP_STACK_RULE_DEFAULT ,   SPELL_GROUP_STACK_RULE_EXCLUSIVE ,   SPELL_GROUP_STACK_RULE_EXCLUSIVE_FROM_SAME_CASTER ,   SPELL_GROUP_STACK_RULE_EXCLUSIVE_SAME_EFFECT ,   SPELL_GROUP_STACK_RULE_EXCLUSIVE_HIGHEST ,   SPELL_GROUP_STACK_RULE_MAX }
enum	EffectRadiusIndex {   EFFECT_RADIUS_2_YARDS = 7 ,   EFFECT_RADIUS_5_YARDS = 8 ,   EFFECT_RADIUS_20_YARDS = 9 ,   EFFECT_RADIUS_30_YARDS = 10 ,   EFFECT_RADIUS_45_YARDS = 11 ,   EFFECT_RADIUS_100_YARDS = 12 ,   EFFECT_RADIUS_10_YARDS = 13 ,   EFFECT_RADIUS_8_YARDS = 14 ,   EFFECT_RADIUS_3_YARDS = 15 ,   EFFECT_RADIUS_1_YARD = 16 ,   EFFECT_RADIUS_13_YARDS = 17 ,   EFFECT_RADIUS_15_YARDS = 18 ,   EFFECT_RADIUS_18_YARDS = 19 ,   EFFECT_RADIUS_25_YARDS = 20 ,   EFFECT_RADIUS_35_YARDS = 21 ,   EFFECT_RADIUS_200_YARDS = 22 ,   EFFECT_RADIUS_40_YARDS = 23 ,   EFFECT_RADIUS_65_YARDS = 24 ,   EFFECT_RADIUS_70_YARDS = 25 ,   EFFECT_RADIUS_4_YARDS = 26 ,   EFFECT_RADIUS_50_YARDS = 27 ,   EFFECT_RADIUS_50000_YARDS = 28 ,   EFFECT_RADIUS_6_YARDS = 29 ,   EFFECT_RADIUS_500_YARDS = 30 ,   EFFECT_RADIUS_80_YARDS = 31 ,   EFFECT_RADIUS_12_YARDS = 32 ,   EFFECT_RADIUS_99_YARDS = 33 ,   EFFECT_RADIUS_55_YARDS = 35 ,   EFFECT_RADIUS_0_YARDS = 36 ,   EFFECT_RADIUS_7_YARDS = 37 ,   EFFECT_RADIUS_21_YARDS = 38 ,   EFFECT_RADIUS_34_YARDS = 39 ,   EFFECT_RADIUS_9_YARDS = 40 ,   EFFECT_RADIUS_150_YARDS = 41 ,   EFFECT_RADIUS_11_YARDS = 42 ,   EFFECT_RADIUS_16_YARDS = 43 ,   EFFECT_RADIUS_0_5_YARDS = 44 ,   EFFECT_RADIUS_10_YARDS_2 = 45 ,   EFFECT_RADIUS_5_YARDS_2 = 46 ,   EFFECT_RADIUS_15_YARDS_2 = 47 ,   EFFECT_RADIUS_60_YARDS = 48 ,   EFFECT_RADIUS_90_YARDS = 49 ,   EFFECT_RADIUS_15_YARDS_3 = 50 ,   EFFECT_RADIUS_60_YARDS_2 = 51 ,   EFFECT_RADIUS_5_YARDS_3 = 52 ,   EFFECT_RADIUS_60_YARDS_3 = 53 ,   EFFECT_RADIUS_50000_YARDS_2 = 54 ,   EFFECT_RADIUS_130_YARDS = 55 ,   EFFECT_RADIUS_38_YARDS = 56 ,   EFFECT_RADIUS_45_YARDS_2 = 57 ,   EFFECT_RADIUS_32_YARDS = 59 ,   EFFECT_RADIUS_44_YARDS = 60 ,   EFFECT_RADIUS_14_YARDS = 61 ,   EFFECT_RADIUS_47_YARDS = 62 ,   EFFECT_RADIUS_23_YARDS = 63 ,   EFFECT_RADIUS_3_5_YARDS = 64 ,   EFFECT_RADIUS_80_YARDS_2 = 65 }
enum	ICCBuff {   ICC_AREA = 4812 ,   ICC_RACEMASK_HORDE = 690 ,   ICC_RACEMASK_ALLIANCE = 1101 }

Functions
bool	IsPrimaryProfessionSkill (uint32 skill)
bool	IsProfessionSkill (uint32 skill)
bool	IsProfessionOrRidingSkill (uint32 skill)
bool	IsPartOfSkillLine (uint32 skillId, uint32 spellId)
DiminishingGroup	GetDiminishingReturnsGroupForSpell (SpellInfo const *spellproto, bool triggered)
DiminishingReturnsType	GetDiminishingReturnsGroupType (DiminishingGroup group)
DiminishingLevels	GetDiminishingReturnsMaxLevel (DiminishingGroup group)
int32	GetDiminishingReturnsLimitDuration (DiminishingGroup group, SpellInfo const *spellproto)
bool	IsDiminishingReturnsGroupDurationLimited (DiminishingGroup group)

Macro Definition Documentation

AURA_SPELL_PROC_EX_MASK

#define AURA_SPELL_PROC_EX_MASK

Value:

   (PROC_EX_NORMAL_HIT | PROC_EX_CRITICAL_HIT | PROC_EX_MISS | \
    PROC_EX_RESIST | PROC_EX_DODGE | PROC_EX_PARRY | PROC_EX_BLOCK | \
    PROC_EX_EVADE | PROC_EX_IMMUNE | PROC_EX_DEFLECT | \
    PROC_EX_ABSORB | PROC_EX_REFLECT | PROC_EX_INTERRUPT)

{
    PROC_SPELL_TYPE_NONE              = 0x0000000,
    PROC_SPELL_TYPE_DAMAGE            = 0x0000001, // damage type of spell
    PROC_SPELL_TYPE_HEAL              = 0x0000002, // heal type of spell
    PROC_SPELL_TYPE_NO_DMG_HEAL       = 0x0000004, // other spells
    PROC_SPELL_TYPE_MASK_ALL          = PROC_SPELL_TYPE_DAMAGE | PROC_SPELL_TYPE_HEAL | PROC_SPELL_TYPE_NO_DMG_HEAL
};
 
enum ProcFlagsSpellPhase
{
    PROC_SPELL_PHASE_NONE             = 0x0000000,
    PROC_SPELL_PHASE_CAST             = 0x0000001,
    PROC_SPELL_PHASE_HIT              = 0x0000002,
    PROC_SPELL_PHASE_FINISH           = 0x0000004,
    PROC_SPELL_PHASE_MASK_ALL         = PROC_SPELL_PHASE_CAST | PROC_SPELL_PHASE_HIT | PROC_SPELL_PHASE_FINISH
};
 
enum ProcFlagsHit
{
    PROC_HIT_NONE                = 0x0000000, // no value - PROC_HIT_NORMAL | PROC_HIT_CRITICAL for TAKEN proc type, PROC_HIT_NORMAL | PROC_HIT_CRITICAL | PROC_HIT_ABSORB for DONE
    PROC_HIT_NORMAL              = 0x0000001, // non-critical hits
    PROC_HIT_CRITICAL            = 0x0000002,
    PROC_HIT_MISS                = 0x0000004,
    PROC_HIT_FULL_RESIST         = 0x0000008,
    PROC_HIT_DODGE               = 0x0000010,
    PROC_HIT_PARRY               = 0x0000020,
    PROC_HIT_BLOCK               = 0x0000040, // partial or full block
    PROC_HIT_EVADE               = 0x0000080,
    PROC_HIT_IMMUNE              = 0x0000100,
    PROC_HIT_DEFLECT             = 0x0000200,
    PROC_HIT_ABSORB              = 0x0000400, // partial or full absorb
    PROC_HIT_REFLECT             = 0x0000800,
    PROC_HIT_INTERRUPT           = 0x0001000, // (not used atm)
    PROC_HIT_FULL_BLOCK          = 0x0002000,
    PROC_HIT_MASK_ALL            = 0x0002FFF,
};
 
enum ProcAttributes
{
    PROC_ATTR_REQ_EXP_OR_HONOR          = 0x0000001, // requires proc target to give exp or honor for aura proc
    PROC_ATTR_TRIGGERED_CAN_PROC        = 0x0000002, // aura can proc even with triggered spells
    PROC_ATTR_REQ_MANA_COST             = 0x0000004, // requires triggering spell to have a mana cost for aura proc
    PROC_ATTR_REQ_SPELLMOD              = 0x0000008, // requires triggering spell to be affected by proccing aura to drop charges
    PROC_ATTR_USE_STACKS_FOR_CHARGES    = 0x0000010, // consuming proc drops a stack from proccing aura instead of charge
    PROC_ATTR_REDUCE_PROC_60            = 0x0000080, // aura should have a reduced chance to proc if level of proc actor > 60
    PROC_ATTR_CANT_PROC_FROM_ITEM_CAST  = 0x0000100, // do not allow aura proc if proc is caused by a spell casted by item
};
 
struct SpellProcEntry
{
    uint32       SchoolMask;                                 // if nonzero - bitmask for matching proc condition based on spell's school
    uint32       SpellFamilyName;                            // if nonzero - for matching proc condition based on candidate spell's SpellFamilyName
    flag96       SpellFamilyMask;                            // if nonzero - bitmask for matching proc condition based on candidate spell's SpellFamilyFlags
    uint32       ProcFlags;                                  // if nonzero - owerwrite procFlags field for given Spell.dbc entry, bitmask for matching proc condition, see enum ProcFlags
    uint32       SpellTypeMask;                              // if nonzero - bitmask for matching proc condition based on candidate spell's damage/heal effects, see enum ProcFlagsSpellType
    uint32       SpellPhaseMask;                             // if nonzero - bitmask for matching phase of a spellcast on which proc occurs, see enum ProcFlagsSpellPhase
    uint32       HitMask;                                    // if nonzero - bitmask for matching proc condition based on hit result, see enum ProcFlagsHit
    uint32       AttributesMask;                             // bitmask, see ProcAttributes
    uint32       DisableEffectsMask;                         // bitmask of effects to disable from triggering proc
    float        ProcsPerMinute;                             // if nonzero - chance to proc is equal to value * aura caster's weapon speed / 60
    float        Chance;                                     // if nonzero - owerwrite procChance field for given Spell.dbc entry, defines chance of proc to occur, not used if ProcsPerMinute set
    Milliseconds Cooldown;                                   // if nonzero - cooldown in secs for aura proc, applied to aura
    uint32       Charges;                                    // if nonzero - owerwrite procCharges field for given Spell.dbc entry, defines how many times proc can occur before aura remove, 0 - infinite
};
 
typedef std::unordered_map<uint32, SpellProcEntry> SpellProcMap;
 
enum EnchantProcAttributes
{
    ENCHANT_PROC_ATTR_EXCLUSIVE     = 0x1, // Only one instance of that effect can be active
    ENCHANT_PROC_ATTR_WHITE_HIT     = 0x2  // Enchant shall only proc off white hits (not abilities)
};
 
struct SpellEnchantProcEntry
{
    uint32      customChance;
    float       PPMChance;
    uint32      procEx;
    uint32      attributeMask;
};
 
typedef std::unordered_map<uint32, SpellEnchantProcEntry> SpellEnchantProcEventMap;
 
struct SpellBonusEntry
{
    float  direct_damage;
    float  dot_damage;
    float  ap_bonus;
    float  ap_dot_bonus;
};
 
typedef std::unordered_map<uint32, SpellBonusEntry>     SpellBonusMap;
 
enum SpellGroup
{
    SPELL_GROUP_NONE             = 0,
    SPELL_GROUP_ELIXIR_BATTLE    = 1,
    SPELL_GROUP_ELIXIR_GUARDIAN  = 2,
    SPELL_GROUP_CORE_RANGE_MAX   = 3
};
 
namespace std
{
    template<>
    struct hash<SpellGroup>
    {
        size_t operator()(SpellGroup const& group) const
        {
            return hash<uint32>()(uint32(group));
        }
    };
}
 
#define SPELL_GROUP_DB_RANGE_MIN 1000
 
//                  spell_id, group_id
typedef std::unordered_multimap<uint32, SpellGroup> SpellSpellGroupMap;
typedef std::pair<SpellSpellGroupMap::const_iterator, SpellSpellGroupMap::const_iterator> SpellSpellGroupMapBounds;
 
//                      group_id, spell_id
typedef std::unordered_multimap<SpellGroup, int32> SpellGroupSpellMap;
typedef std::pair<SpellGroupSpellMap::const_iterator, SpellGroupSpellMap::const_iterator> SpellGroupSpellMapBounds;
 
enum SpellGroupStackRule
{
    SPELL_GROUP_STACK_RULE_DEFAULT,
    SPELL_GROUP_STACK_RULE_EXCLUSIVE,
    SPELL_GROUP_STACK_RULE_EXCLUSIVE_FROM_SAME_CASTER,
    SPELL_GROUP_STACK_RULE_EXCLUSIVE_SAME_EFFECT,
    SPELL_GROUP_STACK_RULE_EXCLUSIVE_HIGHEST,
    SPELL_GROUP_STACK_RULE_MAX
};
 
typedef std::unordered_map<SpellGroup, SpellGroupStackRule> SpellGroupStackMap;
 
typedef std::unordered_map<SpellGroup, std::unordered_set<uint32 /*auraName*/>> SameEffectStackMap;
 
struct SpellThreatEntry
{
    int32       flatMod;                                    // flat threat-value for this Spell  - default: 0
    float       pctMod;                                     // threat-multiplier for this Spell  - default: 1.0f
    float       apPctMod;                                   // Pct of AP that is added as Threat - default: 0.0f
};
 
typedef std::unordered_map<uint32, SpellThreatEntry> SpellThreatMap;
typedef std::map<uint32, float> SpellMixologyMap;
 
// coordinates for spells (accessed using SpellMgr functions)
struct SpellTargetPosition
{
    uint32 target_mapId;
    float  target_X;
    float  target_Y;
    float  target_Z;
    float  target_Orientation;
};
 
typedef std::map<std::pair<uint32 /*spell_id*/, SpellEffIndex /*effIndex*/>, SpellTargetPosition> SpellTargetPositionMap;
 
struct SpellCone
{
    int16_t cone_degrees;
};
 
typedef std::map<uint32 /*spell_id*/, SpellCone> SpellConeMap;
 
// Enum with EffectRadiusIndex and their actual radius
enum EffectRadiusIndex
{
    EFFECT_RADIUS_2_YARDS       = 7,
    EFFECT_RADIUS_5_YARDS       = 8,
    EFFECT_RADIUS_20_YARDS      = 9,
    EFFECT_RADIUS_30_YARDS      = 10,
    EFFECT_RADIUS_45_YARDS      = 11,
    EFFECT_RADIUS_100_YARDS     = 12,
    EFFECT_RADIUS_10_YARDS      = 13,
    EFFECT_RADIUS_8_YARDS       = 14,
    EFFECT_RADIUS_3_YARDS       = 15,
    EFFECT_RADIUS_1_YARD        = 16,
    EFFECT_RADIUS_13_YARDS      = 17,
    EFFECT_RADIUS_15_YARDS      = 18,
    EFFECT_RADIUS_18_YARDS      = 19,
    EFFECT_RADIUS_25_YARDS      = 20,
    EFFECT_RADIUS_35_YARDS      = 21,
    EFFECT_RADIUS_200_YARDS     = 22,
    EFFECT_RADIUS_40_YARDS      = 23,
    EFFECT_RADIUS_65_YARDS      = 24,
    EFFECT_RADIUS_70_YARDS      = 25,
    EFFECT_RADIUS_4_YARDS       = 26,
    EFFECT_RADIUS_50_YARDS      = 27,
    EFFECT_RADIUS_50000_YARDS   = 28,
    EFFECT_RADIUS_6_YARDS       = 29,
    EFFECT_RADIUS_500_YARDS     = 30,
    EFFECT_RADIUS_80_YARDS      = 31,
    EFFECT_RADIUS_12_YARDS      = 32,
    EFFECT_RADIUS_99_YARDS      = 33,
    EFFECT_RADIUS_55_YARDS      = 35,
    EFFECT_RADIUS_0_YARDS       = 36,
    EFFECT_RADIUS_7_YARDS       = 37,
    EFFECT_RADIUS_21_YARDS      = 38,
    EFFECT_RADIUS_34_YARDS      = 39,
    EFFECT_RADIUS_9_YARDS       = 40,
    EFFECT_RADIUS_150_YARDS     = 41,
    EFFECT_RADIUS_11_YARDS      = 42,
    EFFECT_RADIUS_16_YARDS      = 43,
    EFFECT_RADIUS_0_5_YARDS     = 44,   // 0.5 yards
    EFFECT_RADIUS_10_YARDS_2    = 45,
    EFFECT_RADIUS_5_YARDS_2     = 46,
    EFFECT_RADIUS_15_YARDS_2    = 47,
    EFFECT_RADIUS_60_YARDS      = 48,
    EFFECT_RADIUS_90_YARDS      = 49,
    EFFECT_RADIUS_15_YARDS_3    = 50,
    EFFECT_RADIUS_60_YARDS_2    = 51,
    EFFECT_RADIUS_5_YARDS_3     = 52,
    EFFECT_RADIUS_60_YARDS_3    = 53,
    EFFECT_RADIUS_50000_YARDS_2 = 54,
    EFFECT_RADIUS_130_YARDS     = 55,
    EFFECT_RADIUS_38_YARDS      = 56,
    EFFECT_RADIUS_45_YARDS_2    = 57,
    EFFECT_RADIUS_32_YARDS      = 59,
    EFFECT_RADIUS_44_YARDS      = 60,
    EFFECT_RADIUS_14_YARDS      = 61,
    EFFECT_RADIUS_47_YARDS      = 62,
    EFFECT_RADIUS_23_YARDS      = 63,
    EFFECT_RADIUS_3_5_YARDS     = 64,   // 3.5 yards
    EFFECT_RADIUS_80_YARDS_2    = 65
};
 
// Spell pet auras
class PetAura
{
private:
    typedef std::unordered_map<uint32, uint32> PetAuraMap;
 
public:
    PetAura()
    {
        auras.clear();
    }
 
    PetAura(uint32 petEntry, uint32 aura, bool _removeOnChangePet, int _damage) :
        removeOnChangePet(_removeOnChangePet), damage(_damage)
    {
        auras[petEntry] = aura;
    }
 
    [[nodiscard]] uint32 GetAura(uint32 petEntry) const
    {
        PetAuraMap::const_iterator itr = auras.find(petEntry);
        if (itr != auras.end())
            return itr->second;
        PetAuraMap::const_iterator itr2 = auras.find(0);
        if (itr2 != auras.end())
            return itr2->second;
        return 0;
    }
 
    void AddAura(uint32 petEntry, uint32 aura)
    {
        auras[petEntry] = aura;
    }
 
    [[nodiscard]] bool IsRemovedOnChangePet() const
    {
        return removeOnChangePet;
    }
 
    [[nodiscard]] int32 GetDamage() const
    {
        return damage;
    }
 
private:
    PetAuraMap auras;
    bool removeOnChangePet{false};
    int32 damage{0};
};
typedef std::map<uint32, PetAura> SpellPetAuraMap;
 
enum ICCBuff
{
    ICC_AREA              = 4812,
    ICC_RACEMASK_HORDE    =  690,
    ICC_RACEMASK_ALLIANCE = 1101
};
 
struct SpellArea
{
    uint32 spellId;
    uint32 areaId;                                          // zone/subzone/or 0 is not limited to zone
    uint32 questStart;                                      // quest start (quest must be active or rewarded for spell apply)
    uint32 questEnd;                                        // quest end (quest must not be rewarded for spell apply)
    int32  auraSpell;                                       // spell aura must be applied for spell apply)if possitive) and it must not be applied in other case
    uint32 raceMask;                                        // can be applied only to races
    Gender gender;                                          // can be applied only to gender
    uint32 questStartStatus;                                // QuestStatus that quest_start must have in order to keep the spell
    uint32 questEndStatus;                                  // QuestStatus that the quest_end must have in order to keep the spell (if the quest_end's status is different than this, the spell will be dropped)
    bool autocast;                                          // if true then auto applied at area enter, in other case just allowed to cast
 
    // helpers
    bool IsFitToRequirements(Player const* player, uint32 newZone, uint32 newArea) const;
};
 
typedef std::multimap<uint32, SpellArea> SpellAreaMap;
typedef std::multimap<uint32, SpellArea const*> SpellAreaForQuestMap;
typedef std::multimap<uint32, SpellArea const*> SpellAreaForAuraMap;
typedef std::multimap<uint32, SpellArea const*> SpellAreaForAreaMap;
typedef std::pair<SpellAreaMap::const_iterator, SpellAreaMap::const_iterator> SpellAreaMapBounds;
typedef std::pair<SpellAreaForQuestMap::const_iterator, SpellAreaForQuestMap::const_iterator> SpellAreaForQuestMapBounds;
typedef std::pair<SpellAreaForAuraMap::const_iterator, SpellAreaForAuraMap::const_iterator>  SpellAreaForAuraMapBounds;
typedef std::pair<SpellAreaForAreaMap::const_iterator, SpellAreaForAreaMap::const_iterator>  SpellAreaForAreaMapBounds;
 
// Spell rank chain  (accessed using SpellMgr functions)
struct SpellChainNode
{
    SpellInfo const* prev;
    SpellInfo const* next;
    SpellInfo const* first;
    SpellInfo const* last;
    uint8  rank;
};
 
typedef std::unordered_map<uint32, SpellChainNode> SpellChainMap;
 
//                   spell_id  req_spell
typedef std::multimap<uint32, uint32> SpellRequiredMap;
typedef std::pair<SpellRequiredMap::const_iterator, SpellRequiredMap::const_iterator> SpellRequiredMapBounds;
 
//                   req_spell spell_id
typedef std::multimap<uint32, uint32> SpellsRequiringSpellMap;
typedef std::pair<SpellsRequiringSpellMap::const_iterator, SpellsRequiringSpellMap::const_iterator> SpellsRequiringSpellMapBounds;
 
// Spell learning properties (accessed using SpellMgr functions)
struct CreatureImmunities
{
    std::bitset<MAX_SPELL_SCHOOL> School;
    std::bitset<DISPEL_MAX> DispelType;
    std::bitset<MAX_MECHANIC> Mechanic;
    std::vector<SpellEffects> Effect;
    std::vector<AuraType> Aura;
    bool ImmuneAoE = false;
    bool ImmuneChain = false;
};
 
typedef std::unordered_map<int32, CreatureImmunities> CreatureImmunitiesMap;
struct SpellLearnSkillNode
{
    uint16 skill;
    uint16 step;
    uint16 value;                                           // 0  - max skill value for player level
    uint16 maxvalue;                                        // 0  - max skill value for player level
};
 
typedef std::unordered_map<uint32, SpellLearnSkillNode> SpellLearnSkillMap;
 
typedef std::multimap<uint32, SkillLineAbilityEntry const*> SkillLineAbilityMap;
typedef std::pair<SkillLineAbilityMap::const_iterator, SkillLineAbilityMap::const_iterator> SkillLineAbilityMapBounds;
 
typedef std::multimap<uint32, uint32> PetLevelupSpellSet;
typedef std::map<uint32, PetLevelupSpellSet> PetLevelupSpellMap;
 
typedef std::map<uint32, uint32> SpellDifficultySearcherMap;
 
struct PetDefaultSpellsEntry
{
    uint32 spellid[MAX_CREATURE_SPELL_DATA_SLOT];
};
 
// < 0 for petspelldata id, > 0 for creature_id
typedef std::map<int32, PetDefaultSpellsEntry> PetDefaultSpellsMap;
 
typedef std::vector<uint32> SpellCustomAttribute;
typedef std::vector<bool> EnchantCustomAttribute;
 
typedef std::vector<SpellInfo*> SpellInfoMap;
 
typedef std::map<int32, std::vector<int32> > SpellLinkedMap;
 
struct SpellCooldownOverride
{
    uint32 RecoveryTime;
    uint32 CategoryRecoveryTime;
    uint32 StartRecoveryTime;
    uint32 StartRecoveryCategory;
};
 
typedef std::map<uint32, SpellCooldownOverride> SpellCooldownOverrideMap;
 
bool IsPrimaryProfessionSkill(uint32 skill);
 
inline bool IsProfessionSkill(uint32 skill)
{
    return  IsPrimaryProfessionSkill(skill) || skill == SKILL_FISHING || skill == SKILL_COOKING || skill == SKILL_FIRST_AID;
}
 
inline bool IsProfessionOrRidingSkill(uint32 skill)
{
    return  IsProfessionSkill(skill) || skill == SKILL_RIDING;
}
 
bool IsPartOfSkillLine(uint32 skillId, uint32 spellId);
 
// spell diminishing returns
DiminishingGroup GetDiminishingReturnsGroupForSpell(SpellInfo const* spellproto, bool triggered);
DiminishingReturnsType GetDiminishingReturnsGroupType(DiminishingGroup group);
DiminishingLevels GetDiminishingReturnsMaxLevel(DiminishingGroup group);
int32 GetDiminishingReturnsLimitDuration(DiminishingGroup group, SpellInfo const* spellproto);
bool IsDiminishingReturnsGroupDurationLimited(DiminishingGroup group);
 
typedef std::set<uint32> TalentAdditionalSet;
 
class SpellMgr
{
    // Constructors
private:
    SpellMgr();
    ~SpellMgr();
 
    // Accessors (const or static functions)
public:
    static SpellMgr* instance();
 
    // creature immunity definitions loaded from DB
    CreatureImmunities const* GetCreatureImmunities(int32 creatureImmunitiesId) const;
 
    // Spell correctness for client using
    static bool ComputeIsSpellValid(SpellInfo const* spellInfo, bool msg = true);
    static bool IsSpellValid(SpellInfo const* spellInfo);
    static bool CheckSpellValid(SpellInfo const* spellInfo, uint32 spellId, bool isTalent);
 
    // Spell difficulty
    [[nodiscard]] uint32 GetSpellDifficultyId(uint32 spellId) const;
    void SetSpellDifficultyId(uint32 spellId, uint32 id);
    uint32 GetSpellIdForDifficulty(uint32 spellId, Unit const* caster) const;
    SpellInfo const* GetSpellForDifficultyFromSpell(SpellInfo const* spell, Unit const* caster) const;
 
    // Spell Ranks table
    [[nodiscard]] SpellChainNode const* GetSpellChainNode(uint32 spell_id) const;
    [[nodiscard]] uint32 GetFirstSpellInChain(uint32 spell_id) const;
    [[nodiscard]] uint32 GetLastSpellInChain(uint32 spell_id) const;
    [[nodiscard]] uint32 GetNextSpellInChain(uint32 spell_id) const;
    [[nodiscard]] uint32 GetPrevSpellInChain(uint32 spell_id) const;
    [[nodiscard]] uint8 GetSpellRank(uint32 spell_id) const;
    // not strict check returns provided spell if rank not avalible
    [[nodiscard]] uint32 GetSpellWithRank(uint32 spell_id, uint32 rank, bool strict = false) const;
 
    // Spell Required table
    [[nodiscard]] Acore::IteratorPair<SpellRequiredMap::const_iterator>GetSpellsRequiredForSpellBounds(uint32 spell_id) const;
    [[nodiscard]] SpellsRequiringSpellMapBounds GetSpellsRequiringSpellBounds(uint32 spell_id) const;
    [[nodiscard]] bool IsSpellRequiringSpell(uint32 spellid, uint32 req_spellid) const;
 
    // Spell learning
    [[nodiscard]] SpellLearnSkillNode const* GetSpellLearnSkill(uint32 spell_id) const;
    [[nodiscard]] std::vector<uint32> GetSkillRankSpells(uint32 skillId) const;
 
    // Spell target coordinates
    [[nodiscard]] SpellTargetPosition const* GetSpellTargetPosition(uint32 spell_id, SpellEffIndex effIndex) const;
    [[nodiscard]] SpellCone const* GetSpellCone(uint32 spell_id) const;
 
    // Spell Groups table
    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;
 
    // Spell Group Stack Rules table
    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;
 
    // Spell proc table
    [[nodiscard]] SpellProcEntry const* GetSpellProcEntry(uint32 spellId) const;
    bool CanSpellTriggerProcOnEvent(SpellProcEntry const& procEntry, ProcEventInfo& eventInfo) const;
 
    // Spell bonus data table
    [[nodiscard]] SpellBonusEntry const* GetSpellBonusData(uint32 spellId) const;
 
    // Spell threat table
    [[nodiscard]] SpellThreatEntry const* GetSpellThreatEntry(uint32 spellID) const;
 
    // Spell mixology table
    [[nodiscard]] float GetSpellMixologyBonus(uint32 spellId) const;
 
    [[nodiscard]] SkillLineAbilityMapBounds GetSkillLineAbilityMapBounds(uint32 spell_id) const;
 
    [[nodiscard]] PetAura const* GetPetAura(uint32 spell_id, uint8 eff) const;
 
    [[nodiscard]] SpellEnchantProcEntry const* GetSpellEnchantProcEvent(uint32 enchId) const;
    [[nodiscard]] bool IsArenaAllowedEnchancment(uint32 ench_id) const;
 
    [[nodiscard]] const std::vector<int32>* GetSpellLinked(int32 spell_id) const;
 
    [[nodiscard]] PetLevelupSpellSet const* GetPetLevelupSpellList(uint32 petFamily) const;
    [[nodiscard]] PetDefaultSpellsEntry const* GetPetDefaultSpellsEntry(int32 id) const;
 
    // Spell area
    [[nodiscard]] SpellAreaMapBounds GetSpellAreaMapBounds(uint32 spell_id) const;
    [[nodiscard]] SpellAreaForQuestMapBounds GetSpellAreaForQuestMapBounds(uint32 quest_id) const;
    [[nodiscard]] SpellAreaForQuestMapBounds GetSpellAreaForQuestEndMapBounds(uint32 quest_id) const;
    [[nodiscard]] SpellAreaForAuraMapBounds GetSpellAreaForAuraMapBounds(uint32 spell_id) const;
    [[nodiscard]] SpellAreaForAreaMapBounds GetSpellAreaForAreaMapBounds(uint32 area_id) const;
 
    // SpellInfo object management
    [[nodiscard]] SpellInfo const* GetSpellInfo(uint32 spellId) const { return spellId < GetSpellInfoStoreSize() ?  mSpellInfoMap[spellId] : nullptr; }
    // Use this only with 100% valid spellIds
    [[nodiscard]] SpellInfo const* AssertSpellInfo(uint32 spellId) const
    {
        ASSERT(spellId < GetSpellInfoStoreSize());
        SpellInfo const* spellInfo = mSpellInfoMap[spellId];
        ASSERT(spellInfo);
        return spellInfo;
    }
    // use this instead of AssertSpellInfo to have the problem logged instead of crashing the server
    [[nodiscard]] SpellInfo const* CheckSpellInfo(uint32 spellId) const
    {
        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;
    }
    [[nodiscard]] uint32 GetSpellInfoStoreSize() const { return mSpellInfoMap.size(); }
 
    // Talent Additional Set
    [[nodiscard]] bool IsAdditionalTalentSpell(uint32 spellId) const;
 
    [[nodiscard]] bool HasSpellCooldownOverride(uint32 spellId) const;
    [[nodiscard]] SpellCooldownOverride GetSpellCooldownOverride(uint32 spellId) const;
 
private:
    SpellInfo* _GetSpellInfo(uint32 spellId) { return spellId < GetSpellInfoStoreSize() ? mSpellInfoMap[spellId] : nullptr; }
 
    // Modifiers
public:
    // Loading data at server startup
    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();
 
private:
    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;           // only spells not listed in related mPetLevelupSpellMap entry
    SpellInfoMap               mSpellInfoMap;
    SpellCooldownOverrideMap   mSpellCooldownOverrideMap;
    TalentAdditionalSet        mTalentSpellAdditionalSet;
};
 
#define sSpellMgr SpellMgr::instance()
 
#endif

MELEE_BASED_TRIGGER_MASK

#define MELEE_BASED_TRIGGER_MASK

Value:

                                  (PROC_FLAG_DONE_MELEE_AUTO_ATTACK      | \
                                  PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK     | \
                                  PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS  | \
                                  PROC_FLAG_TAKEN_SPELL_MELEE_DMG_CLASS | \
                                  PROC_FLAG_DONE_RANGED_AUTO_ATTACK     | \
                                  PROC_FLAG_TAKEN_RANGED_AUTO_ATTACK    | \
                                  PROC_FLAG_DONE_SPELL_RANGED_DMG_CLASS | \
                                  PROC_FLAG_TAKEN_SPELL_RANGED_DMG_CLASS)

SPELL_GROUP_DB_RANGE_MIN

#define SPELL_GROUP_DB_RANGE_MIN   1000

SPELL_LINKED_MAX_SPELLS

#define SPELL_LINKED_MAX_SPELLS   200000

SPELL_RELIC_COOLDOWN

#define SPELL_RELIC_COOLDOWN   1

sSpellMgr

#define sSpellMgr   SpellMgr::instance()

Typedef Documentation

CreatureImmunitiesMap

typedef std::unordered_map<int32, CreatureImmunities> CreatureImmunitiesMap

EnchantCustomAttribute

typedef std::vector<bool> EnchantCustomAttribute

PetDefaultSpellsMap

typedef std::map<int32, PetDefaultSpellsEntry> PetDefaultSpellsMap

PetLevelupSpellMap

typedef std::map<uint32, PetLevelupSpellSet> PetLevelupSpellMap

PetLevelupSpellSet

typedef std::multimap<uint32, uint32> PetLevelupSpellSet

SameEffectStackMap

typedef std::unordered_map<SpellGroup, std::unordered_set<uint32 > > SameEffectStackMap

SkillLineAbilityMap

typedef std::multimap<uint32, SkillLineAbilityEntry const*> SkillLineAbilityMap

SkillLineAbilityMapBounds

typedef std::pair<SkillLineAbilityMap::const_iterator, SkillLineAbilityMap::const_iterator> SkillLineAbilityMapBounds

SpellAreaForAreaMap

typedef std::multimap<uint32, SpellArea const*> SpellAreaForAreaMap

SpellAreaForAreaMapBounds

typedef std::pair<SpellAreaForAreaMap::const_iterator, SpellAreaForAreaMap::const_iterator> SpellAreaForAreaMapBounds

SpellAreaForAuraMap

typedef std::multimap<uint32, SpellArea const*> SpellAreaForAuraMap

SpellAreaForAuraMapBounds

typedef std::pair<SpellAreaForAuraMap::const_iterator, SpellAreaForAuraMap::const_iterator> SpellAreaForAuraMapBounds

SpellAreaForQuestMap

typedef std::multimap<uint32, SpellArea const*> SpellAreaForQuestMap

SpellAreaForQuestMapBounds

typedef std::pair<SpellAreaForQuestMap::const_iterator, SpellAreaForQuestMap::const_iterator> SpellAreaForQuestMapBounds

SpellAreaMap

typedef std::multimap<uint32, SpellArea> SpellAreaMap

SpellAreaMapBounds

typedef std::pair<SpellAreaMap::const_iterator, SpellAreaMap::const_iterator> SpellAreaMapBounds

SpellBonusMap

typedef std::unordered_map<uint32, SpellBonusEntry> SpellBonusMap

SpellChainMap

typedef std::unordered_map<uint32, SpellChainNode> SpellChainMap

SpellConeMap

typedef std::map<uint32 , SpellCone> SpellConeMap

SpellCooldownOverrideMap

typedef std::map<uint32, SpellCooldownOverride> SpellCooldownOverrideMap

SpellCustomAttribute

typedef std::vector<uint32> SpellCustomAttribute

SpellDifficultySearcherMap

typedef std::map<uint32, uint32> SpellDifficultySearcherMap

SpellEnchantProcEventMap

typedef std::unordered_map<uint32, SpellEnchantProcEntry> SpellEnchantProcEventMap

SpellGroupSpellMap

typedef std::unordered_multimap<SpellGroup, int32> SpellGroupSpellMap

SpellGroupSpellMapBounds

typedef std::pair<SpellGroupSpellMap::const_iterator, SpellGroupSpellMap::const_iterator> SpellGroupSpellMapBounds

SpellGroupStackMap

typedef std::unordered_map<SpellGroup, SpellGroupStackRule> SpellGroupStackMap

SpellInfoMap

typedef std::vector<SpellInfo*> SpellInfoMap

SpellLearnSkillMap

typedef std::unordered_map<uint32, SpellLearnSkillNode> SpellLearnSkillMap

SpellLinkedMap

typedef std::map<int32, std::vector<int32> > SpellLinkedMap

SpellMixologyMap

typedef std::map<uint32, float> SpellMixologyMap

SpellPetAuraMap

typedef std::map<uint32, PetAura> SpellPetAuraMap

SpellProcMap

typedef std::unordered_map<uint32, SpellProcEntry> SpellProcMap

SpellRequiredMap

typedef std::multimap<uint32, uint32> SpellRequiredMap

SpellRequiredMapBounds

typedef std::pair<SpellRequiredMap::const_iterator, SpellRequiredMap::const_iterator> SpellRequiredMapBounds

SpellSpellGroupMap

typedef std::unordered_multimap<uint32, SpellGroup> SpellSpellGroupMap

SpellSpellGroupMapBounds

typedef std::pair<SpellSpellGroupMap::const_iterator, SpellSpellGroupMap::const_iterator> SpellSpellGroupMapBounds

SpellsRequiringSpellMap

typedef std::multimap<uint32, uint32> SpellsRequiringSpellMap

SpellsRequiringSpellMapBounds

typedef std::pair<SpellsRequiringSpellMap::const_iterator, SpellsRequiringSpellMap::const_iterator> SpellsRequiringSpellMapBounds

SpellTargetPositionMap

typedef std::map<std::pair<uint32 , SpellEffIndex >, SpellTargetPosition> SpellTargetPositionMap

SpellThreatMap

typedef std::unordered_map<uint32, SpellThreatEntry> SpellThreatMap

TalentAdditionalSet

typedef std::set<uint32> TalentAdditionalSet

Enumeration Type Documentation

EffectRadiusIndex

enum EffectRadiusIndex

Enumerator
EFFECT_RADIUS_2_YARDS
EFFECT_RADIUS_5_YARDS
EFFECT_RADIUS_20_YARDS
EFFECT_RADIUS_30_YARDS
EFFECT_RADIUS_45_YARDS
EFFECT_RADIUS_100_YARDS
EFFECT_RADIUS_10_YARDS
EFFECT_RADIUS_8_YARDS
EFFECT_RADIUS_3_YARDS
EFFECT_RADIUS_1_YARD
EFFECT_RADIUS_13_YARDS
EFFECT_RADIUS_15_YARDS
EFFECT_RADIUS_18_YARDS
EFFECT_RADIUS_25_YARDS
EFFECT_RADIUS_35_YARDS
EFFECT_RADIUS_200_YARDS
EFFECT_RADIUS_40_YARDS
EFFECT_RADIUS_65_YARDS
EFFECT_RADIUS_70_YARDS
EFFECT_RADIUS_4_YARDS
EFFECT_RADIUS_50_YARDS
EFFECT_RADIUS_50000_YARDS
EFFECT_RADIUS_6_YARDS
EFFECT_RADIUS_500_YARDS
EFFECT_RADIUS_80_YARDS
EFFECT_RADIUS_12_YARDS
EFFECT_RADIUS_99_YARDS
EFFECT_RADIUS_55_YARDS
EFFECT_RADIUS_0_YARDS
EFFECT_RADIUS_7_YARDS
EFFECT_RADIUS_21_YARDS
EFFECT_RADIUS_34_YARDS
EFFECT_RADIUS_9_YARDS
EFFECT_RADIUS_150_YARDS
EFFECT_RADIUS_11_YARDS
EFFECT_RADIUS_16_YARDS
EFFECT_RADIUS_0_5_YARDS
EFFECT_RADIUS_10_YARDS_2
EFFECT_RADIUS_5_YARDS_2
EFFECT_RADIUS_15_YARDS_2
EFFECT_RADIUS_60_YARDS
EFFECT_RADIUS_90_YARDS
EFFECT_RADIUS_15_YARDS_3
EFFECT_RADIUS_60_YARDS_2
EFFECT_RADIUS_5_YARDS_3
EFFECT_RADIUS_60_YARDS_3
EFFECT_RADIUS_50000_YARDS_2
EFFECT_RADIUS_130_YARDS
EFFECT_RADIUS_38_YARDS
EFFECT_RADIUS_45_YARDS_2
EFFECT_RADIUS_32_YARDS
EFFECT_RADIUS_44_YARDS
EFFECT_RADIUS_14_YARDS
EFFECT_RADIUS_47_YARDS
EFFECT_RADIUS_23_YARDS
EFFECT_RADIUS_3_5_YARDS
EFFECT_RADIUS_80_YARDS_2

{
    EFFECT_RADIUS_2_YARDS       = 7,
    EFFECT_RADIUS_5_YARDS       = 8,
    EFFECT_RADIUS_20_YARDS      = 9,
    EFFECT_RADIUS_30_YARDS      = 10,
    EFFECT_RADIUS_45_YARDS      = 11,
    EFFECT_RADIUS_100_YARDS     = 12,
    EFFECT_RADIUS_10_YARDS      = 13,
    EFFECT_RADIUS_8_YARDS       = 14,
    EFFECT_RADIUS_3_YARDS       = 15,
    EFFECT_RADIUS_1_YARD        = 16,
    EFFECT_RADIUS_13_YARDS      = 17,
    EFFECT_RADIUS_15_YARDS      = 18,
    EFFECT_RADIUS_18_YARDS      = 19,
    EFFECT_RADIUS_25_YARDS      = 20,
    EFFECT_RADIUS_35_YARDS      = 21,
    EFFECT_RADIUS_200_YARDS     = 22,
    EFFECT_RADIUS_40_YARDS      = 23,
    EFFECT_RADIUS_65_YARDS      = 24,
    EFFECT_RADIUS_70_YARDS      = 25,
    EFFECT_RADIUS_4_YARDS       = 26,
    EFFECT_RADIUS_50_YARDS      = 27,
    EFFECT_RADIUS_50000_YARDS   = 28,
    EFFECT_RADIUS_6_YARDS       = 29,
    EFFECT_RADIUS_500_YARDS     = 30,
    EFFECT_RADIUS_80_YARDS      = 31,
    EFFECT_RADIUS_12_YARDS      = 32,
    EFFECT_RADIUS_99_YARDS      = 33,
    EFFECT_RADIUS_55_YARDS      = 35,
    EFFECT_RADIUS_0_YARDS       = 36,
    EFFECT_RADIUS_7_YARDS       = 37,
    EFFECT_RADIUS_21_YARDS      = 38,
    EFFECT_RADIUS_34_YARDS      = 39,
    EFFECT_RADIUS_9_YARDS       = 40,
    EFFECT_RADIUS_150_YARDS     = 41,
    EFFECT_RADIUS_11_YARDS      = 42,
    EFFECT_RADIUS_16_YARDS      = 43,
    EFFECT_RADIUS_0_5_YARDS     = 44,   // 0.5 yards
    EFFECT_RADIUS_10_YARDS_2    = 45,
    EFFECT_RADIUS_5_YARDS_2     = 46,
    EFFECT_RADIUS_15_YARDS_2    = 47,
    EFFECT_RADIUS_60_YARDS      = 48,
    EFFECT_RADIUS_90_YARDS      = 49,
    EFFECT_RADIUS_15_YARDS_3    = 50,
    EFFECT_RADIUS_60_YARDS_2    = 51,
    EFFECT_RADIUS_5_YARDS_3     = 52,
    EFFECT_RADIUS_60_YARDS_3    = 53,
    EFFECT_RADIUS_50000_YARDS_2 = 54,
    EFFECT_RADIUS_130_YARDS     = 55,
    EFFECT_RADIUS_38_YARDS      = 56,
    EFFECT_RADIUS_45_YARDS_2    = 57,
    EFFECT_RADIUS_32_YARDS      = 59,
    EFFECT_RADIUS_44_YARDS      = 60,
    EFFECT_RADIUS_14_YARDS      = 61,
    EFFECT_RADIUS_47_YARDS      = 62,
    EFFECT_RADIUS_23_YARDS      = 63,
    EFFECT_RADIUS_3_5_YARDS     = 64,   // 3.5 yards
    EFFECT_RADIUS_80_YARDS_2    = 65
};

EnchantProcAttributes

enum EnchantProcAttributes

Enumerator
ENCHANT_PROC_ATTR_EXCLUSIVE
ENCHANT_PROC_ATTR_WHITE_HIT

{
    ENCHANT_PROC_ATTR_EXCLUSIVE     = 0x1, // Only one instance of that effect can be active
    ENCHANT_PROC_ATTR_WHITE_HIT     = 0x2  // Enchant shall only proc off white hits (not abilities)
};

ICCBuff

enum ICCBuff

Enumerator
ICC_AREA
ICC_RACEMASK_HORDE
ICC_RACEMASK_ALLIANCE

{
    ICC_AREA              = 4812,
    ICC_RACEMASK_HORDE    =  690,
    ICC_RACEMASK_ALLIANCE = 1101
};

ProcAttributes

enum ProcAttributes

Enumerator
PROC_ATTR_REQ_EXP_OR_HONOR
PROC_ATTR_TRIGGERED_CAN_PROC
PROC_ATTR_REQ_MANA_COST
PROC_ATTR_REQ_SPELLMOD
PROC_ATTR_USE_STACKS_FOR_CHARGES
PROC_ATTR_REDUCE_PROC_60
PROC_ATTR_CANT_PROC_FROM_ITEM_CAST

{
    PROC_ATTR_REQ_EXP_OR_HONOR          = 0x0000001, // requires proc target to give exp or honor for aura proc
    PROC_ATTR_TRIGGERED_CAN_PROC        = 0x0000002, // aura can proc even with triggered spells
    PROC_ATTR_REQ_MANA_COST             = 0x0000004, // requires triggering spell to have a mana cost for aura proc
    PROC_ATTR_REQ_SPELLMOD              = 0x0000008, // requires triggering spell to be affected by proccing aura to drop charges
    PROC_ATTR_USE_STACKS_FOR_CHARGES    = 0x0000010, // consuming proc drops a stack from proccing aura instead of charge
    PROC_ATTR_REDUCE_PROC_60            = 0x0000080, // aura should have a reduced chance to proc if level of proc actor > 60
    PROC_ATTR_CANT_PROC_FROM_ITEM_CAST  = 0x0000100, // do not allow aura proc if proc is caused by a spell casted by item
};

ProcFlags

enum ProcFlags

Enumerator
PROC_FLAG_NONE
PROC_FLAG_KILLED
PROC_FLAG_KILL
PROC_FLAG_DONE_MELEE_AUTO_ATTACK
PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK
PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS
PROC_FLAG_TAKEN_SPELL_MELEE_DMG_CLASS
PROC_FLAG_DONE_RANGED_AUTO_ATTACK
PROC_FLAG_TAKEN_RANGED_AUTO_ATTACK
PROC_FLAG_DONE_SPELL_RANGED_DMG_CLASS
PROC_FLAG_TAKEN_SPELL_RANGED_DMG_CLASS
PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS
PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_POS
PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_NEG
PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_NEG
PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS
PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_POS
PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG
PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG
PROC_FLAG_DONE_PERIODIC
PROC_FLAG_TAKEN_PERIODIC
PROC_FLAG_TAKEN_DAMAGE
PROC_FLAG_DONE_TRAP_ACTIVATION
PROC_FLAG_DONE_MAINHAND_ATTACK
PROC_FLAG_DONE_OFFHAND_ATTACK
PROC_FLAG_DEATH
AUTO_ATTACK_PROC_FLAG_MASK
MELEE_PROC_FLAG_MASK
RANGED_PROC_FLAG_MASK
SPELL_PROC_FLAG_MASK
PERIODIC_PROC_FLAG_MASK
DONE_HIT_PROC_FLAG_MASK
TAKEN_HIT_PROC_FLAG_MASK
REQ_SPELL_PHASE_PROC_FLAG_MASK

{
    PROC_FLAG_NONE                            = 0x00000000,
 
    PROC_FLAG_KILLED                          = 0x00000001,    // 00 Killed by agressor - not sure about this flag
    PROC_FLAG_KILL                            = 0x00000002,    // 01 Kill target (in most cases need XP/Honor reward)
 
    PROC_FLAG_DONE_MELEE_AUTO_ATTACK          = 0x00000004,    // 02 Done melee auto attack
    PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK         = 0x00000008,    // 03 Taken melee auto attack
 
    PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS      = 0x00000010,    // 04 Done attack by Spell that has dmg class melee
    PROC_FLAG_TAKEN_SPELL_MELEE_DMG_CLASS     = 0x00000020,    // 05 Taken attack by Spell that has dmg class melee
 
    PROC_FLAG_DONE_RANGED_AUTO_ATTACK         = 0x00000040,    // 06 Done ranged auto attack
    PROC_FLAG_TAKEN_RANGED_AUTO_ATTACK        = 0x00000080,    // 07 Taken ranged auto attack
 
    PROC_FLAG_DONE_SPELL_RANGED_DMG_CLASS     = 0x00000100,    // 08 Done attack by Spell that has dmg class ranged
    PROC_FLAG_TAKEN_SPELL_RANGED_DMG_CLASS    = 0x00000200,    // 09 Taken attack by Spell that has dmg class ranged
 
    PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS   = 0x00000400,    // 10 Done positive spell that has dmg class none
    PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_POS  = 0x00000800,    // 11 Taken positive spell that has dmg class none
 
    PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_NEG   = 0x00001000,    // 12 Done negative spell that has dmg class none
    PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_NEG  = 0x00002000,    // 13 Taken negative spell that has dmg class none
 
    PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS  = 0x00004000,    // 14 Done positive spell that has dmg class magic
    PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_POS = 0x00008000,    // 15 Taken positive spell that has dmg class magic
 
    PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG  = 0x00010000,    // 16 Done negative spell that has dmg class magic
    PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG = 0x00020000,    // 17 Taken negative spell that has dmg class magic
 
    PROC_FLAG_DONE_PERIODIC                   = 0x00040000,    // 18 Successful do periodic (damage / healing)
    PROC_FLAG_TAKEN_PERIODIC                  = 0x00080000,    // 19 Taken spell periodic (damage / healing)
 
    PROC_FLAG_TAKEN_DAMAGE                    = 0x00100000,    // 20 Taken any damage
    PROC_FLAG_DONE_TRAP_ACTIVATION            = 0x00200000,    // 21 On trap activation (possibly needs name change to ON_GAMEOBJECT_CAST or USE)
 
    PROC_FLAG_DONE_MAINHAND_ATTACK            = 0x00400000,    // 22 Done main-hand melee attacks (spell and autoattack)
    PROC_FLAG_DONE_OFFHAND_ATTACK             = 0x00800000,    // 23 Done off-hand melee attacks (spell and autoattack)
 
    PROC_FLAG_DEATH                           = 0x01000000,    // 24 Died in any way
 
    // flag masks
    AUTO_ATTACK_PROC_FLAG_MASK                = PROC_FLAG_DONE_MELEE_AUTO_ATTACK | PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK
                                                | PROC_FLAG_DONE_RANGED_AUTO_ATTACK | PROC_FLAG_TAKEN_RANGED_AUTO_ATTACK,
 
    MELEE_PROC_FLAG_MASK                      = PROC_FLAG_DONE_MELEE_AUTO_ATTACK | PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK
                                                | PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS | PROC_FLAG_TAKEN_SPELL_MELEE_DMG_CLASS
                                                | PROC_FLAG_DONE_MAINHAND_ATTACK | PROC_FLAG_DONE_OFFHAND_ATTACK,
 
    RANGED_PROC_FLAG_MASK                     = PROC_FLAG_DONE_RANGED_AUTO_ATTACK | PROC_FLAG_TAKEN_RANGED_AUTO_ATTACK
                                                | PROC_FLAG_DONE_SPELL_RANGED_DMG_CLASS | PROC_FLAG_TAKEN_SPELL_RANGED_DMG_CLASS,
 
    SPELL_PROC_FLAG_MASK                      = PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS | PROC_FLAG_TAKEN_SPELL_MELEE_DMG_CLASS
                                                | PROC_FLAG_DONE_RANGED_AUTO_ATTACK | PROC_FLAG_TAKEN_RANGED_AUTO_ATTACK
                                                | PROC_FLAG_DONE_SPELL_RANGED_DMG_CLASS | PROC_FLAG_TAKEN_SPELL_RANGED_DMG_CLASS
                                                | PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS | PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_POS
                                                | PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_NEG | PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_NEG
                                                | PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS | PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_POS
                                                | PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG | PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG
                                                | PROC_FLAG_DONE_PERIODIC | PROC_FLAG_TAKEN_PERIODIC
                                                | PROC_FLAG_DONE_TRAP_ACTIVATION,
 
    PERIODIC_PROC_FLAG_MASK                    = PROC_FLAG_DONE_PERIODIC | PROC_FLAG_TAKEN_PERIODIC,
 
    DONE_HIT_PROC_FLAG_MASK                    = PROC_FLAG_DONE_MELEE_AUTO_ATTACK | PROC_FLAG_DONE_RANGED_AUTO_ATTACK
                                                 | PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS | PROC_FLAG_DONE_SPELL_RANGED_DMG_CLASS
                                                 | PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS | PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_NEG
                                                 | PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS | PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG
                                                 | PROC_FLAG_DONE_PERIODIC | PROC_FLAG_DONE_TRAP_ACTIVATION
                                                 | PROC_FLAG_DONE_MAINHAND_ATTACK | PROC_FLAG_DONE_OFFHAND_ATTACK,
 
    TAKEN_HIT_PROC_FLAG_MASK                   = PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK | PROC_FLAG_TAKEN_RANGED_AUTO_ATTACK
                                                | PROC_FLAG_TAKEN_SPELL_MELEE_DMG_CLASS | PROC_FLAG_TAKEN_SPELL_RANGED_DMG_CLASS
                                                | PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_POS | PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_NEG
                                                | PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_POS | PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG
                                                | PROC_FLAG_TAKEN_PERIODIC | PROC_FLAG_TAKEN_DAMAGE,
 
    REQ_SPELL_PHASE_PROC_FLAG_MASK             = SPELL_PROC_FLAG_MASK & DONE_HIT_PROC_FLAG_MASK,
};

ProcFlagsExLegacy

enum ProcFlagsExLegacy

Enumerator
PROC_EX_NONE
PROC_EX_NORMAL_HIT
PROC_EX_CRITICAL_HIT
PROC_EX_MISS
PROC_EX_RESIST
PROC_EX_DODGE
PROC_EX_PARRY
PROC_EX_BLOCK
PROC_EX_EVADE
PROC_EX_IMMUNE
PROC_EX_DEFLECT
PROC_EX_ABSORB
PROC_EX_REFLECT
PROC_EX_INTERRUPT
PROC_EX_FULL_BLOCK
PROC_EX_RESERVED2
PROC_EX_NOT_ACTIVE_SPELL
PROC_EX_EX_TRIGGER_ALWAYS
PROC_EX_EX_ONE_TIME_TRIGGER
PROC_EX_ONLY_ACTIVE_SPELL
PROC_EX_NO_OVERHEAL
PROC_EX_NO_AURA_REFRESH
PROC_EX_ONLY_FIRST_TICK
PROC_EX_INTERNAL_CANT_PROC
PROC_EX_INTERNAL_DOT
PROC_EX_INTERNAL_HOT
PROC_EX_INTERNAL_TRIGGERED
PROC_EX_INTERNAL_REQ_FAMILY

{
    PROC_EX_NONE                = 0x0000000,                 // If none can tigger on Hit/Crit only (passive spells MUST defined by SpellFamily flag)
    PROC_EX_NORMAL_HIT          = 0x0000001,                 // If set only from normal hit (only damage spells)
    PROC_EX_CRITICAL_HIT        = 0x0000002,
    PROC_EX_MISS                = 0x0000004,
    PROC_EX_RESIST              = 0x0000008,
    PROC_EX_DODGE               = 0x0000010,
    PROC_EX_PARRY               = 0x0000020,
    PROC_EX_BLOCK               = 0x0000040,
    PROC_EX_EVADE               = 0x0000080,
    PROC_EX_IMMUNE              = 0x0000100,
    PROC_EX_DEFLECT             = 0x0000200,
    PROC_EX_ABSORB              = 0x0000400,
    PROC_EX_REFLECT             = 0x0000800,
    PROC_EX_INTERRUPT           = 0x0001000,                 // Melee hit result can be Interrupt (not used)
    PROC_EX_FULL_BLOCK          = 0x0002000,                 // block all attack damage
    PROC_EX_RESERVED2           = 0x0004000,
    PROC_EX_NOT_ACTIVE_SPELL    = 0x0008000,                 // Spell mustn't do damage/heal to proc
    PROC_EX_EX_TRIGGER_ALWAYS   = 0x0010000,                 // If set trigger always no matter of hit result
    PROC_EX_EX_ONE_TIME_TRIGGER = 0x0020000,                 // If set trigger always but only one time (not implemented yet)
    PROC_EX_ONLY_ACTIVE_SPELL   = 0x0040000,                 // Spell has to do damage/heal to proc
    PROC_EX_NO_OVERHEAL         = 0x0080000,                 // Proc if heal did some work
    PROC_EX_NO_AURA_REFRESH     = 0x0100000,                 // Proc if aura was not refreshed
    PROC_EX_ONLY_FIRST_TICK     = 0x0200000,                 // Proc only on first tick (in case of periodic spells)
 
    // Flags for internal use - do not use these in db!
    PROC_EX_INTERNAL_CANT_PROC  = 0x0800000,
    PROC_EX_INTERNAL_DOT        = 0x1000000,
    PROC_EX_INTERNAL_HOT        = 0x2000000,
    PROC_EX_INTERNAL_TRIGGERED  = 0x4000000,
    PROC_EX_INTERNAL_REQ_FAMILY = 0x8000000
};

ProcFlagsHit

enum ProcFlagsHit

Enumerator
PROC_HIT_NONE
PROC_HIT_NORMAL
PROC_HIT_CRITICAL
PROC_HIT_MISS
PROC_HIT_FULL_RESIST
PROC_HIT_DODGE
PROC_HIT_PARRY
PROC_HIT_BLOCK
PROC_HIT_EVADE
PROC_HIT_IMMUNE
PROC_HIT_DEFLECT
PROC_HIT_ABSORB
PROC_HIT_REFLECT
PROC_HIT_INTERRUPT
PROC_HIT_FULL_BLOCK
PROC_HIT_MASK_ALL

{
    PROC_HIT_NONE                = 0x0000000, // no value - PROC_HIT_NORMAL | PROC_HIT_CRITICAL for TAKEN proc type, PROC_HIT_NORMAL | PROC_HIT_CRITICAL | PROC_HIT_ABSORB for DONE
    PROC_HIT_NORMAL              = 0x0000001, // non-critical hits
    PROC_HIT_CRITICAL            = 0x0000002,
    PROC_HIT_MISS                = 0x0000004,
    PROC_HIT_FULL_RESIST         = 0x0000008,
    PROC_HIT_DODGE               = 0x0000010,
    PROC_HIT_PARRY               = 0x0000020,
    PROC_HIT_BLOCK               = 0x0000040, // partial or full block
    PROC_HIT_EVADE               = 0x0000080,
    PROC_HIT_IMMUNE              = 0x0000100,
    PROC_HIT_DEFLECT             = 0x0000200,
    PROC_HIT_ABSORB              = 0x0000400, // partial or full absorb
    PROC_HIT_REFLECT             = 0x0000800,
    PROC_HIT_INTERRUPT           = 0x0001000, // (not used atm)
    PROC_HIT_FULL_BLOCK          = 0x0002000,
    PROC_HIT_MASK_ALL            = 0x0002FFF,
};

ProcFlagsSpellPhase

enum ProcFlagsSpellPhase

Enumerator
PROC_SPELL_PHASE_NONE
PROC_SPELL_PHASE_CAST
PROC_SPELL_PHASE_HIT
PROC_SPELL_PHASE_FINISH
PROC_SPELL_PHASE_MASK_ALL

{
    PROC_SPELL_PHASE_NONE             = 0x0000000,
    PROC_SPELL_PHASE_CAST             = 0x0000001,
    PROC_SPELL_PHASE_HIT              = 0x0000002,
    PROC_SPELL_PHASE_FINISH           = 0x0000004,
    PROC_SPELL_PHASE_MASK_ALL         = PROC_SPELL_PHASE_CAST | PROC_SPELL_PHASE_HIT | PROC_SPELL_PHASE_FINISH
};

ProcFlagsSpellType

enum ProcFlagsSpellType

Enumerator
PROC_SPELL_TYPE_NONE
PROC_SPELL_TYPE_DAMAGE
PROC_SPELL_TYPE_HEAL
PROC_SPELL_TYPE_NO_DMG_HEAL
PROC_SPELL_TYPE_MASK_ALL

{
    PROC_SPELL_TYPE_NONE              = 0x0000000,
    PROC_SPELL_TYPE_DAMAGE            = 0x0000001, // damage type of spell
    PROC_SPELL_TYPE_HEAL              = 0x0000002, // heal type of spell
    PROC_SPELL_TYPE_NO_DMG_HEAL       = 0x0000004, // other spells
    PROC_SPELL_TYPE_MASK_ALL          = PROC_SPELL_TYPE_DAMAGE | PROC_SPELL_TYPE_HEAL | PROC_SPELL_TYPE_NO_DMG_HEAL
};

SpellCategories

enum SpellCategories

Enumerator
SPELLCATEGORY_HEALTH_MANA_POTIONS
SPELLCATEGORY_DEVOUR_MAGIC
SPELLCATEGORY_JUDGEMENT
SPELLCATEGORY_FOOD
SPELLCATEGORY_DRINK

{
    SPELLCATEGORY_HEALTH_MANA_POTIONS = 4,
    SPELLCATEGORY_DEVOUR_MAGIC        = 12,
    SPELLCATEGORY_JUDGEMENT           = 1210,               // Judgement (seal trigger)
    SPELLCATEGORY_FOOD             = 11,
    SPELLCATEGORY_DRINK            = 59,
};

SpellFamilyFlag

enum SpellFamilyFlag

Enumerator
SPELLFAMILYFLAG_ROGUE_VANISH
SPELLFAMILYFLAG_ROGUE_VAN_EVAS_SPRINT
SPELLFAMILYFLAG1_ROGUE_COLDB_SHADOWSTEP
SPELLFAMILYFLAG_ROGUE_KICK
SPELLFAMILYFLAG1_ROGUE_DISMANTLE
SPELLFAMILYFLAG_ROGUE_BLADE_FLURRY
SPELLFAMILYFLAG1_ROGUE_BLADE_FLURRY
SPELLFAMILYFLAG_WARRIOR_CHARGE
SPELLFAMILYFLAG_WARRIOR_SLAM
SPELLFAMILYFLAG_WARRIOR_EXECUTE
SPELLFAMILYFLAG_WARRIOR_CONCUSSION_BLOW
SPELLFAMILYFLAG_WARLOCK_LIFETAP
SPELLFAMILYFLAG2_DRUID_STARFALL
SPELLFAMILYFLAG1_PALADIN_DIVINESTORM
SPELLFAMILYFLAG_SHAMAN_FROST_SHOCK
SPELLFAMILYFLAG_SHAMAN_HEALING_STREAM
SPELLFAMILYFLAG_SHAMAN_MANA_SPRING
SPELLFAMILYFLAG2_SHAMAN_LAVA_LASH
SPELLFAMILYFLAG_SHAMAN_FIRE_NOVA
SPELLFAMILYFLAG_DK_DEATH_STRIKE
SPELLFAMILYFLAG_DK_DEATH_COIL
SPELLFAMILYFLAG_SHAMAN_TOTEM_EFFECTS	Todo: : Figure out a more accurate name for the following familyflag(s)

{
    // SPELLFAMILYFLAG  = SpellFamilyFlags[0]
    // SPELLFAMILYFLAG1 = SpellFamilyFlags[1]
    // SPELLFAMILYFLAG2 = SpellFamilyFlags[2]
 
    // Rogue
    SPELLFAMILYFLAG_ROGUE_VANISH            = 0x00000800,
    SPELLFAMILYFLAG_ROGUE_VAN_EVAS_SPRINT   = 0x00000860,    // Vanish, Evasion, Sprint
    SPELLFAMILYFLAG1_ROGUE_COLDB_SHADOWSTEP = 0x00000240,    // Cold Blood, Shadowstep
    SPELLFAMILYFLAG_ROGUE_KICK              = 0x00000010,   // Kick
    SPELLFAMILYFLAG1_ROGUE_DISMANTLE        = 0x00100000,   // Dismantle
    SPELLFAMILYFLAG_ROGUE_BLADE_FLURRY      = 0x40000000,   // Blade Flurry
    SPELLFAMILYFLAG1_ROGUE_BLADE_FLURRY     = 0x00000800,   // Blade Flurry
 
    // Warrior
    SPELLFAMILYFLAG_WARRIOR_CHARGE          = 0x00000001,
    SPELLFAMILYFLAG_WARRIOR_SLAM            = 0x00200000,
    SPELLFAMILYFLAG_WARRIOR_EXECUTE         = 0x20000000,
    SPELLFAMILYFLAG_WARRIOR_CONCUSSION_BLOW = 0x04000000,
 
    // Warlock
    SPELLFAMILYFLAG_WARLOCK_LIFETAP         = 0x00040000,
 
    // Druid
    SPELLFAMILYFLAG2_DRUID_STARFALL         = 0x00000100,
 
    // Paladin
    SPELLFAMILYFLAG1_PALADIN_DIVINESTORM    = 0x00020000,
 
    // Shaman
    SPELLFAMILYFLAG_SHAMAN_FROST_SHOCK      = 0x80000000,
    SPELLFAMILYFLAG_SHAMAN_HEALING_STREAM   = 0x00002000,
    SPELLFAMILYFLAG_SHAMAN_MANA_SPRING      = 0x00004000,
    SPELLFAMILYFLAG2_SHAMAN_LAVA_LASH       = 0x00000004,
    SPELLFAMILYFLAG_SHAMAN_FIRE_NOVA        = 0x28000000,
 
    // Deathknight
    SPELLFAMILYFLAG_DK_DEATH_STRIKE         = 0x00000010,
    SPELLFAMILYFLAG_DK_DEATH_COIL           = 0x00002000,
 
    SPELLFAMILYFLAG_SHAMAN_TOTEM_EFFECTS    = 0x04000000,  // Seems to be linked to most totems and some totem effects
};

SpellGroup

enum SpellGroup

Enumerator
SPELL_GROUP_NONE
SPELL_GROUP_ELIXIR_BATTLE
SPELL_GROUP_ELIXIR_GUARDIAN
SPELL_GROUP_CORE_RANGE_MAX

{
    SPELL_GROUP_NONE             = 0,
    SPELL_GROUP_ELIXIR_BATTLE    = 1,
    SPELL_GROUP_ELIXIR_GUARDIAN  = 2,
    SPELL_GROUP_CORE_RANGE_MAX   = 3
};

SpellGroupStackRule

enum SpellGroupStackRule

Enumerator
SPELL_GROUP_STACK_RULE_DEFAULT
SPELL_GROUP_STACK_RULE_EXCLUSIVE
SPELL_GROUP_STACK_RULE_EXCLUSIVE_FROM_SAME_CASTER
SPELL_GROUP_STACK_RULE_EXCLUSIVE_SAME_EFFECT
SPELL_GROUP_STACK_RULE_EXCLUSIVE_HIGHEST
SPELL_GROUP_STACK_RULE_MAX

{
    SPELL_GROUP_STACK_RULE_DEFAULT,
    SPELL_GROUP_STACK_RULE_EXCLUSIVE,
    SPELL_GROUP_STACK_RULE_EXCLUSIVE_FROM_SAME_CASTER,
    SPELL_GROUP_STACK_RULE_EXCLUSIVE_SAME_EFFECT,
    SPELL_GROUP_STACK_RULE_EXCLUSIVE_HIGHEST,
    SPELL_GROUP_STACK_RULE_MAX
};

SpellLinkedType

enum SpellLinkedType

Enumerator
SPELL_LINK_CAST
SPELL_LINK_HIT
SPELL_LINK_AURA
SPELL_LINK_REMOVE

{
    SPELL_LINK_CAST     = 0,            // +: cast; -: remove
    SPELL_LINK_HIT      = 1 * 200000,
    SPELL_LINK_AURA     = 2 * 200000,   // +: aura; -: immune
    SPELL_LINK_REMOVE   = 0,
};

Function Documentation

GetDiminishingReturnsGroupForSpell()

DiminishingGroup GetDiminishingReturnsGroupForSpell	(	SpellInfo const *	spellproto,
		bool	triggered
	)

{
    if (spellproto->IsPositive())
        return DIMINISHING_NONE;
 
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (spellproto->Effects[i].ApplyAuraName == SPELL_AURA_MOD_TAUNT)
            return DIMINISHING_TAUNT;
    }
 
    // Explicit Diminishing Groups
    switch (spellproto->SpellFamilyName)
    {
        case SPELLFAMILY_GENERIC:
            {
                // Pet charge effects (Infernal Awakening, Demon Charge)
                if (spellproto->SpellVisual[0] == 2816 && spellproto->SpellIconID == 15)
                    return DIMINISHING_CONTROLLED_STUN;
                // Gnaw
                else if (spellproto->Id == 47481)
                    return DIMINISHING_CONTROLLED_STUN;
                // Screams of the Past
                else if (spellproto->Id == 7074)
                    return DIMINISHING_NONE;
                break;
            }
        // Event spells
        case SPELLFAMILY_UNK1:
            return DIMINISHING_NONE;
        case SPELLFAMILY_MAGE:
            {
                // Frostbite
                if (spellproto->Id == 12494)
                    return DIMINISHING_ROOT;
                // Shattered Barrier
                else if (spellproto->Id == 55080)
                    return DIMINISHING_ROOT;
                // Deep Freeze
                else if (spellproto->SpellIconID == 2939 && spellproto->SpellVisual[0] == 9963)
                    return DIMINISHING_CONTROLLED_STUN;
                // Frost Nova / Freeze (Water Elemental)
                else if (spellproto->SpellIconID == 193)
                    return DIMINISHING_CONTROLLED_ROOT;
                // Dragon's Breath
                else if (spellproto->SpellFamilyFlags[0] & 0x800000)
                    return DIMINISHING_DRAGONS_BREATH;
                break;
            }
        case SPELLFAMILY_WARRIOR:
            {
                // Hamstring - limit duration to 10s in PvP
                if (spellproto->SpellFamilyFlags[0] & 0x2)
                    return DIMINISHING_LIMITONLY;
                // Improved Hamstring
                else if (spellproto->Id == 23694)
                    return DIMINISHING_ROOT;
                // Charge Stun (own diminishing)
                else if (spellproto->SpellFamilyFlags[0] & 0x01000000)
                    return DIMINISHING_CHARGE;
                break;
            }
        case SPELLFAMILY_WARLOCK:
            {
                // Curses/etc
                if ((spellproto->SpellFamilyFlags[0] & 0x80000000) || (spellproto->SpellFamilyFlags[1] & 0x200))
                    return DIMINISHING_LIMITONLY;
                // Seduction
                else if (spellproto->SpellFamilyFlags[1] & 0x10000000)
                    return DIMINISHING_FEAR;
                break;
            }
        case SPELLFAMILY_DRUID:
            {
                // Pounce
                if (spellproto->SpellFamilyFlags[0] & 0x20000)
                    return DIMINISHING_OPENING_STUN;
                // Cyclone
                else if (spellproto->SpellFamilyFlags[1] & 0x20)
                    return DIMINISHING_CYCLONE;
                // Entangling Roots
                // Nature's Grasp
                else if (spellproto->SpellFamilyFlags[0] & 0x00000200)
                    return DIMINISHING_CONTROLLED_ROOT;
                // Faerie Fire
                else if (spellproto->SpellFamilyFlags[0] & 0x400)
                    return DIMINISHING_LIMITONLY;
                // Feral Charge Root Effect
                else if (spellproto->Id == 45334)
                    return DIMINISHING_NONE;
                break;
            }
        case SPELLFAMILY_ROGUE:
            {
                // Gouge
                if (spellproto->SpellFamilyFlags[0] & 0x8)
                    return DIMINISHING_DISORIENT;
                // Blind
                else if (spellproto->SpellFamilyFlags[0] & 0x1000000)
                    return DIMINISHING_FEAR;
                // Cheap Shot
                else if (spellproto->SpellFamilyFlags[0] & 0x400)
                    return DIMINISHING_OPENING_STUN;
                // Crippling poison - Limit to 10 seconds in PvP (No SpellFamilyFlags)
                else if (spellproto->SpellIconID == 163)
                    return DIMINISHING_LIMITONLY;
                break;
            }
        case SPELLFAMILY_HUNTER:
            {
                // Hunter's Mark
                if ((spellproto->SpellFamilyFlags[0] & 0x400) && spellproto->SpellIconID == 538)
                    return DIMINISHING_LIMITONLY;
                // Scatter Shot (own diminishing)
                else if ((spellproto->SpellFamilyFlags[0] & 0x40000) && spellproto->SpellIconID == 132)
                    return DIMINISHING_SCATTER_SHOT;
                // Entrapment (own diminishing)
                else if (spellproto->SpellVisual[0] == 7484 && spellproto->SpellIconID == 20)
                    return DIMINISHING_ENTRAPMENT;
                // Wyvern Sting mechanic is MECHANIC_SLEEP but the diminishing is DIMINISHING_DISORIENT
                else if ((spellproto->SpellFamilyFlags[1] & 0x1000) && spellproto->SpellIconID == 1721)
                    return DIMINISHING_DISORIENT;
                // Freezing Arrow
                else if (spellproto->SpellFamilyFlags[0] & 0x8)
                    return DIMINISHING_DISORIENT;
                break;
            }
        case SPELLFAMILY_PALADIN:
            {
                // Judgement of Justice - limit duration to 10s in PvP
                if (spellproto->SpellFamilyFlags[0] & 0x100000)
                    return DIMINISHING_LIMITONLY;
                // Turn Evil
                else if ((spellproto->SpellFamilyFlags[1] & 0x804000) && spellproto->SpellIconID == 309)
                    return DIMINISHING_FEAR;
                break;
            }
        case SPELLFAMILY_SHAMAN:
            {
                // Storm, Earth and Fire - Earthgrab
                if (spellproto->SpellFamilyFlags[2] & 0x4000)
                    return DIMINISHING_CONTROLLED_ROOT;
                break;
            }
        case SPELLFAMILY_DEATHKNIGHT:
            {
                // Hungering Cold (no flags)
                if (spellproto->SpellIconID == 2797)
                    return DIMINISHING_DISORIENT;
                // Mark of Blood
                else if ((spellproto->SpellFamilyFlags[0] & 0x10000000) && spellproto->SpellIconID == 2285)
                    return DIMINISHING_LIMITONLY;
                break;
            }
        default:
            break;
    }
 
    // Lastly - Set diminishing depending on mechanic
    uint64 mechanic = spellproto->GetAllEffectsMechanicMask();
    if (mechanic & (1ULL << MECHANIC_CHARM))
        return DIMINISHING_MIND_CONTROL;
    if (mechanic & (1ULL << MECHANIC_SILENCE))
        return DIMINISHING_SILENCE;
    if (mechanic & (1ULL << MECHANIC_SLEEP))
        return DIMINISHING_SLEEP;
    if (mechanic & ((1ULL << MECHANIC_SAPPED) | (1ULL << MECHANIC_POLYMORPH) | (1ULL << MECHANIC_SHACKLE)))
        return DIMINISHING_DISORIENT;
    // Mechanic Knockout, except Blast Wave
    if (mechanic & (1ULL << MECHANIC_KNOCKOUT) && spellproto->SpellIconID != 292)
        return DIMINISHING_DISORIENT;
    if (mechanic & (1ULL << MECHANIC_DISARM))
        return DIMINISHING_DISARM;
    if (mechanic & (1ULL << MECHANIC_FEAR))
        return DIMINISHING_FEAR;
    if (mechanic & (1ULL << MECHANIC_STUN))
        return triggered ? DIMINISHING_STUN : DIMINISHING_CONTROLLED_STUN;
    if (mechanic & (1ULL << MECHANIC_BANISH))
        return DIMINISHING_BANISH;
    if (mechanic & (1ULL << MECHANIC_ROOT))
        return triggered ? DIMINISHING_ROOT : DIMINISHING_CONTROLLED_ROOT;
    if (mechanic & (1ULL << MECHANIC_HORROR))
        return DIMINISHING_HORROR;
 
    return DIMINISHING_NONE;
}

References DIMINISHING_BANISH, DIMINISHING_CHARGE, DIMINISHING_CONTROLLED_ROOT, DIMINISHING_CONTROLLED_STUN, DIMINISHING_CYCLONE, DIMINISHING_DISARM, DIMINISHING_DISORIENT, DIMINISHING_DRAGONS_BREATH, DIMINISHING_ENTRAPMENT, DIMINISHING_FEAR, DIMINISHING_HORROR, DIMINISHING_LIMITONLY, DIMINISHING_MIND_CONTROL, DIMINISHING_NONE, DIMINISHING_OPENING_STUN, DIMINISHING_ROOT, DIMINISHING_SCATTER_SHOT, DIMINISHING_SILENCE, DIMINISHING_SLEEP, DIMINISHING_STUN, DIMINISHING_TAUNT, SpellInfo::Effects, SpellInfo::GetAllEffectsMechanicMask(), SpellInfo::Id, SpellInfo::IsPositive(), MAX_SPELL_EFFECTS, MECHANIC_BANISH, MECHANIC_CHARM, MECHANIC_DISARM, MECHANIC_FEAR, MECHANIC_HORROR, MECHANIC_KNOCKOUT, MECHANIC_POLYMORPH, MECHANIC_ROOT, MECHANIC_SAPPED, MECHANIC_SHACKLE, MECHANIC_SILENCE, MECHANIC_SLEEP, MECHANIC_STUN, SPELL_AURA_MOD_TAUNT, SPELLFAMILY_DEATHKNIGHT, SPELLFAMILY_DRUID, SPELLFAMILY_GENERIC, SPELLFAMILY_HUNTER, SPELLFAMILY_MAGE, SPELLFAMILY_PALADIN, SPELLFAMILY_ROGUE, SPELLFAMILY_SHAMAN, SPELLFAMILY_UNK1, SPELLFAMILY_WARLOCK, SPELLFAMILY_WARRIOR, SpellInfo::SpellFamilyFlags, SpellInfo::SpellFamilyName, SpellInfo::SpellIconID, and SpellInfo::SpellVisual.

Referenced by Spell::DoSpellHitOnUnit().

GetDiminishingReturnsGroupType()

DiminishingReturnsType GetDiminishingReturnsGroupType

(

DiminishingGroup

group

)

{
    switch (group)
    {
        case DIMINISHING_TAUNT:
        case DIMINISHING_CONTROLLED_STUN:
        case DIMINISHING_STUN:
        case DIMINISHING_OPENING_STUN:
        case DIMINISHING_CYCLONE:
        case DIMINISHING_CHARGE:
            return DRTYPE_ALL;
        case DIMINISHING_LIMITONLY:
        case DIMINISHING_NONE:
            return DRTYPE_NONE;
        default:
            return DRTYPE_PLAYER;
    }
}

References DIMINISHING_CHARGE, DIMINISHING_CONTROLLED_STUN, DIMINISHING_CYCLONE, DIMINISHING_LIMITONLY, DIMINISHING_NONE, DIMINISHING_OPENING_STUN, DIMINISHING_STUN, DIMINISHING_TAUNT, DRTYPE_ALL, DRTYPE_NONE, and DRTYPE_PLAYER.

Referenced by Unit::ApplyDiminishingToDuration(), and Spell::DoSpellHitOnUnit().

GetDiminishingReturnsLimitDuration()

int32 GetDiminishingReturnsLimitDuration	(	DiminishingGroup	group,
		SpellInfo const *	spellproto
	)

{
    if (!IsDiminishingReturnsGroupDurationLimited(group))
        return 0;
 
    // Explicit diminishing duration
    switch (spellproto->SpellFamilyName)
    {
        case SPELLFAMILY_DRUID:
            {
                // Faerie Fire - limit to 40 seconds in PvP (3.1)
                if (spellproto->SpellFamilyFlags[0] & 0x400)
                    return 40 * IN_MILLISECONDS;
                break;
            }
        case SPELLFAMILY_HUNTER:
            {
                // Wyvern Sting
                if (spellproto->SpellFamilyFlags[1] & 0x1000)
                    return 6 * IN_MILLISECONDS;
                // Hunter's Mark
                if (spellproto->SpellFamilyFlags[0] & 0x400)
                    return 120 * IN_MILLISECONDS;
                break;
            }
        case SPELLFAMILY_PALADIN:
            {
                // Repentance - limit to 6 seconds in PvP
                if (spellproto->SpellFamilyFlags[0] & 0x4)
                    return 6 * IN_MILLISECONDS;
                break;
            }
        case SPELLFAMILY_WARLOCK:
            {
                // Banish - limit to 6 seconds in PvP
                if (spellproto->SpellFamilyFlags[1] & 0x8000000)
                    return 6 * IN_MILLISECONDS;
                // Curse of Tongues - limit to 12 seconds in PvP
                else if (spellproto->SpellFamilyFlags[2] & 0x800)
                    return 12 * IN_MILLISECONDS;
                // Curse of Elements - limit to 120 seconds in PvP
                else if (spellproto->SpellFamilyFlags[1] & 0x200)
                    return 120 * IN_MILLISECONDS;
                // Curse of Exhaustion
                else if (spellproto->SpellFamilyFlags[0] & 0x400000)
                    return 12 * IN_MILLISECONDS;
                break;
            }
        default:
            break;
    }
 
    return 10 * IN_MILLISECONDS;
}

References IN_MILLISECONDS, IsDiminishingReturnsGroupDurationLimited(), SPELLFAMILY_DRUID, SPELLFAMILY_HUNTER, SPELLFAMILY_PALADIN, SPELLFAMILY_WARLOCK, SpellInfo::SpellFamilyFlags, and SpellInfo::SpellFamilyName.

Referenced by Spell::DoSpellHitOnUnit().

GetDiminishingReturnsMaxLevel()

DiminishingLevels GetDiminishingReturnsMaxLevel

(

DiminishingGroup

group

)

{
    switch (group)
    {
        case DIMINISHING_TAUNT:
            return DIMINISHING_LEVEL_TAUNT_IMMUNE;
        default:
            return DIMINISHING_LEVEL_IMMUNE;
    }
}

References DIMINISHING_LEVEL_IMMUNE, DIMINISHING_LEVEL_TAUNT_IMMUNE, and DIMINISHING_TAUNT.

Referenced by Unit::IncrDiminishing().

IsDiminishingReturnsGroupDurationLimited()

bool IsDiminishingReturnsGroupDurationLimited

(

DiminishingGroup

group

)

{
    switch (group)
    {
        case DIMINISHING_BANISH:
        case DIMINISHING_CONTROLLED_STUN:
        case DIMINISHING_CONTROLLED_ROOT:
        case DIMINISHING_CYCLONE:
        case DIMINISHING_DISORIENT:
        case DIMINISHING_ENTRAPMENT:
        case DIMINISHING_FEAR:
        case DIMINISHING_HORROR:
        case DIMINISHING_MIND_CONTROL:
        case DIMINISHING_OPENING_STUN:
        case DIMINISHING_ROOT:
        case DIMINISHING_STUN:
        case DIMINISHING_SLEEP:
        case DIMINISHING_LIMITONLY:
            return true;
        default:
            return false;
    }
}

References DIMINISHING_BANISH, DIMINISHING_CONTROLLED_ROOT, DIMINISHING_CONTROLLED_STUN, DIMINISHING_CYCLONE, DIMINISHING_DISORIENT, DIMINISHING_ENTRAPMENT, DIMINISHING_FEAR, DIMINISHING_HORROR, DIMINISHING_LIMITONLY, DIMINISHING_MIND_CONTROL, DIMINISHING_OPENING_STUN, DIMINISHING_ROOT, DIMINISHING_SLEEP, and DIMINISHING_STUN.

Referenced by GetDiminishingReturnsLimitDuration().

IsPartOfSkillLine()

bool IsPartOfSkillLine	(	uint32	skillId,
		uint32	spellId
	)

{
    SkillLineAbilityMapBounds skillBounds = sSpellMgr->GetSkillLineAbilityMapBounds(spellId);
    for (SkillLineAbilityMap::const_iterator itr = skillBounds.first; itr != skillBounds.second; ++itr)
        if (itr->second->SkillLine == skillId)
            return true;
 
    return false;
}

References sSpellMgr.

Referenced by SpellMgr::LoadSpellInfoCustomAttributes().

IsPrimaryProfessionSkill()

bool IsPrimaryProfessionSkill

(

uint32

skill

)

{
    SkillLineEntry const* pSkill = sSkillLineStore.LookupEntry(skill);
    if (!pSkill)
        return false;
 
    if (pSkill->categoryId != SKILL_CATEGORY_PROFESSION)
        return false;
 
    return true;
}

References SkillLineEntry::categoryId, SKILL_CATEGORY_PROFESSION, and sSkillLineStore.

Referenced by WorldSession::HandleUnlearnSkillOpcode(), SpellInfo::IsPrimaryProfession(), and IsProfessionSkill().

IsProfessionOrRidingSkill()

bool IsProfessionOrRidingSkill ( uint32  skill )

inline

{
    return  IsProfessionSkill(skill) || skill == SKILL_RIDING;
}

References IsProfessionSkill(), and SKILL_RIDING.

Referenced by SpellInfo::IsProfessionOrRiding(), Player::LearnDefaultSkill(), and Player::UpdateSkillsToMaxSkillsForLevel().

IsProfessionSkill()

bool IsProfessionSkill ( uint32  skill )

inline

{
    return  IsPrimaryProfessionSkill(skill) || skill == SKILL_FISHING || skill == SKILL_COOKING || skill == SKILL_FIRST_AID;
}

References IsPrimaryProfessionSkill(), SKILL_COOKING, SKILL_FIRST_AID, and SKILL_FISHING.

Referenced by SpellInfo::IsProfession(), and IsProfessionOrRidingSkill().