src/game/SpellMgr.h

   1 /*
   2  * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #ifndef _SPELLMGR_H
  20 #define _SPELLMGR_H
  21
  22 // For static or at-server-startup loaded spell data
  23 // For more high level function for sSpellStore data
  24
  25 #include "SharedDefines.h"
  26 #include "DBCStructure.h"
  27 #include "Database/SQLStorage.h"
  28
  29 #include "Utilities/UnorderedMap.h"
  30
  31 #include "Player.h"
  32
  33 #include <map>
  34
  35 class Player;
  36 class Spell;
  37
  38 extern SQLStorage sSpellThreatStore;
  39
  40 // only used in code
  41 enum SpellCategories
  42 {
  43     SPELLCATEGORY_HEALTH_MANA_POTIONS = 4,
  44     SPELLCATEGORY_DEVOUR_MAGIC        = 12
  45 };
  46
  47 enum SpellFamilyNames
  48 {
  49     SPELLFAMILY_GENERIC     = 0,
  50     SPELLFAMILY_UNK1        = 1,                            // events, holidays
  51     // 2 - unused
  52     SPELLFAMILY_MAGE        = 3,
  53     SPELLFAMILY_WARRIOR     = 4,
  54     SPELLFAMILY_WARLOCK     = 5,
  55     SPELLFAMILY_PRIEST      = 6,
  56     SPELLFAMILY_DRUID       = 7,
  57     SPELLFAMILY_ROGUE       = 8,
  58     SPELLFAMILY_HUNTER      = 9,
  59     SPELLFAMILY_PALADIN     = 10,
  60     SPELLFAMILY_SHAMAN      = 11,
  61     SPELLFAMILY_UNK2        = 12,                           // 2 spells (silence resistance)
  62     SPELLFAMILY_POTION      = 13,
  63     // 14 - unused
  64     SPELLFAMILY_DEATHKNIGHT = 15,
  65     // 16 - unused
  66     SPELLFAMILY_PET         = 17
  67 };
  68
  69 //Some SpellFamilyFlags
  70 #define SPELLFAMILYFLAG_ROGUE_VANISH            0x000000800LL
  71 #define SPELLFAMILYFLAG_ROGUE_STEALTH           0x000400000LL
  72 #define SPELLFAMILYFLAG_ROGUE_BACKSTAB          0x000800004LL
  73 #define SPELLFAMILYFLAG_ROGUE_SAP               0x000000080LL
  74 #define SPELLFAMILYFLAG_ROGUE_FEINT             0x008000000LL
  75 #define SPELLFAMILYFLAG_ROGUE_KIDNEYSHOT        0x000200000LL
  76 #define SPELLFAMILYFLAG_ROGUE__FINISHING_MOVE   0x9003E0000LL
  77
  78 #define SPELLFAMILYFLAG_PALADIN_SEALS           0x26000C000A000000LL
  79 // Spell clasification
  80 enum SpellSpecific
  81 {
  82     SPELL_NORMAL            = 0,
  83     SPELL_SEAL              = 1,
  84     SPELL_BLESSING          = 2,
  85     SPELL_AURA              = 3,
  86     SPELL_STING             = 4,
  87     SPELL_CURSE             = 5,
  88     SPELL_ASPECT            = 6,
  89     SPELL_TRACKER           = 7,
  90     SPELL_WARLOCK_ARMOR     = 8,
  91     SPELL_MAGE_ARMOR        = 9,
  92     SPELL_ELEMENTAL_SHIELD  = 10,
  93     SPELL_MAGE_POLYMORPH    = 11,
  94     SPELL_POSITIVE_SHOUT    = 12,
  95     SPELL_JUDGEMENT         = 13,
  96     SPELL_BATTLE_ELIXIR     = 14,
  97     SPELL_GUARDIAN_ELIXIR   = 15,
  98     SPELL_FLASK_ELIXIR      = 16,
  99     SPELL_PRESENCE          = 17
 100 };
 101
 102 SpellSpecific GetSpellSpecific(uint32 spellId);
 103
 104 // Different spell properties
 105 inline float GetSpellRadius(SpellRadiusEntry const *radius) { return (radius ? radius->Radius : 0); }
 106 uint32 GetSpellCastTime(SpellEntry const* spellInfo, Spell const* spell = NULL);
 107 inline float GetSpellMinRange(SpellRangeEntry const *range) { return (range ? range->minRange : 0); }
 108 inline float GetSpellMaxRange(SpellRangeEntry const *range) { return (range ? range->maxRange : 0); }
 109 inline uint32 GetSpellRecoveryTime(SpellEntry const *spellInfo) { return spellInfo->RecoveryTime > spellInfo->CategoryRecoveryTime ? spellInfo->RecoveryTime : spellInfo->CategoryRecoveryTime; }
 110 int32 GetSpellDuration(SpellEntry const *spellInfo);
 111 int32 GetSpellMaxDuration(SpellEntry const *spellInfo);
 112
 113 inline bool IsSpellHaveEffect(SpellEntry const *spellInfo, SpellEffects effect)
 114 {
 115     for(int i= 0; i < 3; ++i)
 116         if(SpellEffects(spellInfo->Effect[i])==effect)
 117             return true;
 118     return false;
 119 }
 120
 121 bool IsNoStackAuraDueToAura(uint32 spellId_1, uint32 effIndex_1, uint32 spellId_2, uint32 effIndex_2);
 122
 123 inline bool IsSealSpell(SpellEntry const *spellInfo)
 124 {
 125     //Collection of all the seal family flags. No other paladin spell has any of those.
 126     return spellInfo->SpellFamilyName == SPELLFAMILY_PALADIN &&
 127         ( spellInfo->SpellFamilyFlags & SPELLFAMILYFLAG_PALADIN_SEALS );
 128 }
 129
 130 inline bool IsElementalShield(SpellEntry const *spellInfo)
 131 {
 132     // family flags 10 (Lightning), 42 (Earth), 37 (Water), proc shield from T2 8 pieces bonus
 133     return (spellInfo->SpellFamilyFlags & 0x42000000400LL) || spellInfo->Id == 23552;
 134 }
 135
 136 inline bool IsExplicitDiscoverySpell(SpellEntry const *spellInfo)
 137 {
 138     return spellInfo->Effect[0]==SPELL_EFFECT_CREATE_ITEM_2 && spellInfo->Effect[1]==SPELL_EFFECT_SCRIPT_EFFECT;
 139 }
 140
 141 inline bool IsLootCraftingSpell(SpellEntry const *spellInfo)
 142 {
 143     return spellInfo->Effect[0]==SPELL_EFFECT_CREATE_ITEM_2 && (
 144         spellInfo->Effect[1]==SPELL_EFFECT_SCRIPT_EFFECT || // see IsExplicitDiscoverySpell
 145         !spellInfo->EffectItemType[0] ||                    // result item not provided
 146         spellInfo->TotemCategory[0] == 121);                // different random cards from Inscription (121==Virtuoso Inking Set category)
 147 }
 148
 149 int32 CompareAuraRanks(uint32 spellId_1, uint32 effIndex_1, uint32 spellId_2, uint32 effIndex_2);
 150 bool IsSingleFromSpellSpecificPerCaster(SpellSpecific spellSpec1,SpellSpecific spellSpec2);
 151 bool IsSingleFromSpellSpecificRanksPerTarget(SpellSpecific spellId_spec, SpellSpecific i_spellId_spec);
 152 bool IsPassiveSpell(uint32 spellId);
 153
 154 inline bool IsPassiveSpellStackableWithRanks(SpellEntry const* spellProto)
 155 {
 156     if(!IsPassiveSpell(spellProto->Id))
 157         return false;
 158
 159     return !IsSpellHaveEffect(spellProto,SPELL_EFFECT_APPLY_AURA);
 160 }
 161
 162
 163 inline bool IsDeathPersistentSpell(SpellEntry const *spellInfo)
 164 {
 165     return spellInfo->AttributesEx3 & SPELL_ATTR_EX3_DEATH_PERSISTENT;
 166 }
 167
 168 inline bool IsNonCombatSpell(SpellEntry const *spellInfo)
 169 {
 170     return (spellInfo->Attributes & SPELL_ATTR_CANT_USED_IN_COMBAT) != 0;
 171 }
 172
 173 bool IsPositiveSpell(uint32 spellId);
 174 bool IsPositiveEffect(uint32 spellId, uint32 effIndex);
 175 bool IsPositiveTarget(uint32 targetA, uint32 targetB);
 176
 177 bool IsSingleTargetSpell(SpellEntry const *spellInfo);
 178 bool IsSingleTargetSpells(SpellEntry const *spellInfo1, SpellEntry const *spellInfo2);
 179
 180 bool IsAuraAddedBySpell(uint32 auraType, uint32 spellId);
 181
 182 inline bool IsAreaEffectTarget( Targets target )
 183 {
 184     switch (target )
 185     {
 186         case TARGET_AREAEFFECT_INSTANT:
 187         case TARGET_AREAEFFECT_CUSTOM:
 188         case TARGET_ALL_ENEMY_IN_AREA:
 189         case TARGET_ALL_ENEMY_IN_AREA_INSTANT:
 190         case TARGET_ALL_PARTY_AROUND_CASTER:
 191         case TARGET_IN_FRONT_OF_CASTER:
 192         case TARGET_ALL_ENEMY_IN_AREA_CHANNELED:
 193         case TARGET_ALL_FRIENDLY_UNITS_AROUND_CASTER:
 194         case TARGET_ALL_FRIENDLY_UNITS_IN_AREA:
 195         case TARGET_ALL_PARTY:
 196         case TARGET_ALL_PARTY_AROUND_CASTER_2:
 197         case TARGET_AREAEFFECT_PARTY:
 198         case TARGET_AREAEFFECT_CUSTOM_2:
 199         case TARGET_ALL_RAID_AROUND_CASTER:
 200         case TARGET_AREAEFFECT_PARTY_AND_CLASS:
 201             return true;
 202         default:
 203             break;
 204     }
 205     return false;
 206 }
 207
 208 inline bool IsAreaOfEffectSpell(SpellEntry const *spellInfo)
 209 {
 210     if(IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetA[0])) || IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetB[0])))
 211         return true;
 212     if(IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetA[1])) || IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetB[1])))
 213         return true;
 214     if(IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetA[2])) || IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetB[2])))
 215         return true;
 216     return false;
 217 }
 218
 219 inline bool IsAreaAuraEffect(uint32 effect)
 220 {
 221     if( effect == SPELL_EFFECT_APPLY_AREA_AURA_PARTY    ||
 222         effect == SPELL_EFFECT_APPLY_AREA_AURA_RAID     ||
 223         effect == SPELL_EFFECT_APPLY_AREA_AURA_FRIEND   ||
 224         effect == SPELL_EFFECT_APPLY_AREA_AURA_ENEMY    ||
 225         effect == SPELL_EFFECT_APPLY_AREA_AURA_PET      ||
 226         effect == SPELL_EFFECT_APPLY_AREA_AURA_OWNER)
 227         return true;
 228     return false;
 229 }
 230
 231 inline bool IsDispelSpell(SpellEntry const *spellInfo)
 232 {
 233     if (spellInfo->Effect[0] == SPELL_EFFECT_DISPEL ||
 234         spellInfo->Effect[1] == SPELL_EFFECT_DISPEL ||
 235         spellInfo->Effect[2] == SPELL_EFFECT_DISPEL )
 236         return true;
 237     return false;
 238 }
 239 inline bool isSpellBreakStealth(SpellEntry const* spellInfo)
 240 {
 241     return !(spellInfo->AttributesEx & SPELL_ATTR_EX_NOT_BREAK_STEALTH);
 242 }
 243
 244 inline bool IsAutoRepeatRangedSpell(SpellEntry const* spellInfo)
 245 {
 246     return (spellInfo->Attributes & SPELL_ATTR_RANGED) && (spellInfo->AttributesEx2 & SPELL_ATTR_EX2_AUTOREPEAT_FLAG);
 247 }
 248
 249 SpellCastResult GetErrorAtShapeshiftedCast (SpellEntry const *spellInfo, uint32 form);
 250
 251 inline bool IsChanneledSpell(SpellEntry const* spellInfo)
 252 {
 253     return (spellInfo->AttributesEx & (SPELL_ATTR_EX_CHANNELED_1 | SPELL_ATTR_EX_CHANNELED_2));
 254 }
 255
 256 inline bool NeedsComboPoints(SpellEntry const* spellInfo)
 257 {
 258     return (spellInfo->AttributesEx & (SPELL_ATTR_EX_REQ_COMBO_POINTS1 | SPELL_ATTR_EX_REQ_COMBO_POINTS2));
 259 }
 260
 261 inline SpellSchoolMask GetSpellSchoolMask(SpellEntry const* spellInfo)
 262 {
 263     return SpellSchoolMask(spellInfo->SchoolMask);
 264 }
 265
 266 inline uint32 GetSpellMechanicMask(SpellEntry const* spellInfo, int32 effect)
 267 {
 268     uint32 mask = 0;
 269     if (spellInfo->Mechanic)
 270         mask |= 1<<spellInfo->Mechanic;
 271     if (spellInfo->EffectMechanic[effect])
 272         mask |= 1<<spellInfo->EffectMechanic[effect];
 273     return mask;
 274 }
 275
 276 inline uint32 GetAllSpellMechanicMask(SpellEntry const* spellInfo)
 277 {
 278     uint32 mask = 0;
 279     if (spellInfo->Mechanic)
 280         mask |= 1<<spellInfo->Mechanic;
 281     for (int i=0; i< 3; ++i)
 282         if (spellInfo->EffectMechanic[i])
 283             mask |= 1<<spellInfo->EffectMechanic[i];
 284     return mask;
 285 }
 286
 287 inline Mechanics GetEffectMechanic(SpellEntry const* spellInfo, int32 effect)
 288 {
 289     if (spellInfo->EffectMechanic[effect])
 290         return Mechanics(spellInfo->EffectMechanic[effect]);
 291     if (spellInfo->Mechanic)
 292         return Mechanics(spellInfo->Mechanic);
 293     return MECHANIC_NONE;
 294 }
 295
 296 inline uint32 GetDispellMask(DispelType dispel)
 297 {
 298     // If dispell all
 299     if (dispel == DISPEL_ALL)
 300         return DISPEL_ALL_MASK;
 301     else
 302         return (1 << dispel);
 303 }
 304
 305 // Diminishing Returns interaction with spells
 306 DiminishingGroup GetDiminishingReturnsGroupForSpell(SpellEntry const* spellproto, bool triggered);
 307 bool IsDiminishingReturnsGroupDurationLimited(DiminishingGroup group);
 308 DiminishingReturnsType GetDiminishingReturnsGroupType(DiminishingGroup group);
 309
 310 // Spell affects related declarations (accessed using SpellMgr functions)
 311 struct SpellAffectEntry
 312 {
 313     uint32 SpellClassMask[3];
 314 };
 315 typedef UNORDERED_MAP<uint32, SpellAffectEntry> SpellAffectMap;
 316
 317 // Spell proc event related declarations (accessed using SpellMgr functions)
 318 enum ProcFlags
 319 {
 320    PROC_FLAG_NONE                          = 0x00000000,
 321
 322    PROC_FLAG_KILLED                        = 0x00000001,    // 00 Killed by agressor
 323    PROC_FLAG_KILL                          = 0x00000002,    // 01 Kill target (in most cases need XP/Honor reward)
 324
 325    PROC_FLAG_SUCCESSFUL_MILEE_HIT          = 0x00000004,    // 02 Successful melee auto attack
 326    PROC_FLAG_TAKEN_MELEE_HIT               = 0x00000008,    // 03 Taken damage from melee auto attack hit
 327
 328    PROC_FLAG_SUCCESSFUL_MELEE_SPELL_HIT    = 0x00000010,    // 04 Successful attack by Spell that use melee weapon
 329    PROC_FLAG_TAKEN_MELEE_SPELL_HIT         = 0x00000020,    // 05 Taken damage by Spell that use melee weapon
 330
 331    PROC_FLAG_SUCCESSFUL_RANGED_HIT         = 0x00000040,    // 06 Successful Ranged auto attack
 332    PROC_FLAG_TAKEN_RANGED_HIT              = 0x00000080,    // 07 Taken damage from ranged auto attack
 333
 334    PROC_FLAG_SUCCESSFUL_RANGED_SPELL_HIT   = 0x00000100,    // 08 Successful Ranged attack by Spell that use ranged weapon
 335    PROC_FLAG_TAKEN_RANGED_SPELL_HIT        = 0x00000200,    // 09 Taken damage by Spell that use ranged weapon
 336
 337    PROC_FLAG_SUCCESSFUL_POSITIVE_AOE_HIT   = 0x00000400,    // 10 Successful AoE (not 100% shure unused)
 338    PROC_FLAG_TAKEN_POSITIVE_AOE            = 0x00000800,    // 11 Taken AoE      (not 100% shure unused)
 339
 340    PROC_FLAG_SUCCESSFUL_AOE_SPELL_HIT      = 0x00001000,    // 12 Successful AoE damage spell hit (not 100% shure unused)
 341    PROC_FLAG_TAKEN_AOE_SPELL_HIT           = 0x00002000,    // 13 Taken AoE damage spell hit      (not 100% shure unused)
 342
 343    PROC_FLAG_SUCCESSFUL_POSITIVE_SPELL     = 0x00004000,    // 14 Successful cast positive spell (by default only on healing)
 344    PROC_FLAG_TAKEN_POSITIVE_SPELL          = 0x00008000,    // 15 Taken positive spell hit (by default only on healing)
 345
 346    PROC_FLAG_SUCCESSFUL_NEGATIVE_SPELL_HIT = 0x00010000,    // 16 Successful negative spell cast (by default only on damage)
 347    PROC_FLAG_TAKEN_NEGATIVE_SPELL_HIT      = 0x00020000,    // 17 Taken negative spell (by default only on damage)
 348
 349    PROC_FLAG_ON_DO_PERIODIC                = 0x00040000,    // 18 Successful do periodic (damage / healing, determined from 14-17 flags)
 350    PROC_FLAG_ON_TAKE_PERIODIC              = 0x00080000,    // 19 Taken spell periodic (damage / healing, determined from 14-17 flags)
 351
 352    PROC_FLAG_TAKEN_ANY_DAMAGE              = 0x00100000,    // 20 Taken any damage
 353    PROC_FLAG_ON_TRAP_ACTIVATION            = 0x00200000,    // 21 On trap activation
 354
 355    PROC_FLAG_TAKEN_OFFHAND_HIT             = 0x00400000,    // 22 Taken off-hand melee attacks(not used)
 356    PROC_FLAG_SUCCESSFUL_OFFHAND_HIT        = 0x00800000     // 23 Successful off-hand melee attacks
 357 };
 358
 359 #define MELEE_BASED_TRIGGER_MASK (PROC_FLAG_SUCCESSFUL_MILEE_HIT        | \
 360                                   PROC_FLAG_TAKEN_MELEE_HIT             | \
 361                                   PROC_FLAG_SUCCESSFUL_MELEE_SPELL_HIT  | \
 362                                   PROC_FLAG_TAKEN_MELEE_SPELL_HIT       | \
 363                                   PROC_FLAG_SUCCESSFUL_RANGED_HIT       | \
 364                                   PROC_FLAG_TAKEN_RANGED_HIT            | \
 365                                   PROC_FLAG_SUCCESSFUL_RANGED_SPELL_HIT | \
 366                                   PROC_FLAG_TAKEN_RANGED_SPELL_HIT)
 367
 368 enum ProcFlagsEx
 369 {
 370    PROC_EX_NONE                = 0x0000000,                 // If none can tigger on Hit/Crit only (passive spells MUST defined by SpellFamily flag)
 371    PROC_EX_NORMAL_HIT          = 0x0000001,                 // If set only from normal hit (only damage spells)
 372    PROC_EX_CRITICAL_HIT        = 0x0000002,
 373    PROC_EX_MISS                = 0x0000004,
 374    PROC_EX_RESIST              = 0x0000008,
 375    PROC_EX_DODGE               = 0x0000010,
 376    PROC_EX_PARRY               = 0x0000020,
 377    PROC_EX_BLOCK               = 0x0000040,
 378    PROC_EX_EVADE               = 0x0000080,
 379    PROC_EX_IMMUNE              = 0x0000100,
 380    PROC_EX_DEFLECT             = 0x0000200,
 381    PROC_EX_ABSORB              = 0x0000400,
 382    PROC_EX_REFLECT             = 0x0000800,
 383    PROC_EX_INTERRUPT           = 0x0001000,                 // Melee hit result can be Interrupt (not used)
 384    PROC_EX_RESERVED1           = 0x0002000,
 385    PROC_EX_RESERVED2           = 0x0004000,
 386    PROC_EX_RESERVED3           = 0x0008000,
 387    PROC_EX_EX_TRIGGER_ALWAYS   = 0x0010000,                 // If set trigger always ( no matter another flags) used for drop charges
 388    PROC_EX_EX_ONE_TIME_TRIGGER = 0x0020000                  // If set trigger always but only one time (not used)
 389 };
 390
 391 struct SpellProcEventEntry
 392 {
 393     uint32      schoolMask;                                 // if nonzero - bit mask for matching proc condition based on spell candidate's school: Fire=2, Mask=1<<(2-1)=2
 394     uint32      spellFamilyName;                            // if nonzero - for matching proc condition based on candidate spell's SpellFamilyNamer value
 395     uint64      spellFamilyMask;                            // if nonzero - for matching proc condition based on candidate spell's SpellFamilyFlags  (like auras 107 and 108 do)
 396     uint32      spellFamilyMask2;                           // if nonzero - for matching proc condition based on candidate spell's SpellFamilyFlags2 (like auras 107 and 108 do)
 397     uint32      procFlags;                                  // bitmask for matching proc event
 398     uint32      procEx;                                     // proc Extend info (see ProcFlagsEx)
 399     float       ppmRate;                                    // for melee (ranged?) damage spells - proc rate per minute. if zero, falls back to flat chance from Spell.dbc
 400     float       customChance;                               // Owerride chance (in most cases for debug only)
 401     uint32      cooldown;                                   // hidden cooldown used for some spell proc events, applied to _triggered_spell_
 402 };
 403
 404 struct SpellBonusEntry
 405 {
 406     float  direct_damage;
 407     float  dot_damage;
 408     float  ap_bonus;
 409 };
 410
 411 typedef UNORDERED_MAP<uint32, SpellProcEventEntry> SpellProcEventMap;
 412 typedef UNORDERED_MAP<uint32, SpellBonusEntry>     SpellBonusMap;
 413
 414 #define ELIXIR_BATTLE_MASK    0x1
 415 #define ELIXIR_GUARDIAN_MASK  0x2
 416 #define ELIXIR_FLASK_MASK     (ELIXIR_BATTLE_MASK|ELIXIR_GUARDIAN_MASK)
 417 #define ELIXIR_UNSTABLE_MASK  0x4
 418 #define ELIXIR_SHATTRATH_MASK 0x8
 419
 420 typedef std::map<uint32, uint8> SpellElixirMap;
 421
 422 // Spell script target related declarations (accessed using SpellMgr functions)
 423 enum SpellTargetType
 424 {
 425     SPELL_TARGET_TYPE_GAMEOBJECT = 0,
 426     SPELL_TARGET_TYPE_CREATURE   = 1,
 427     SPELL_TARGET_TYPE_DEAD       = 2
 428 };
 429
 430 #define MAX_SPELL_TARGET_TYPE 3
 431
 432 struct SpellTargetEntry
 433 {
 434     SpellTargetEntry(SpellTargetType type_,uint32 targetEntry_) : type(type_), targetEntry(targetEntry_) {}
 435     SpellTargetType type;
 436     uint32 targetEntry;
 437 };
 438
 439 typedef std::multimap<uint32,SpellTargetEntry> SpellScriptTarget;
 440
 441 // coordinates for spells (accessed using SpellMgr functions)
 442 struct SpellTargetPosition
 443 {
 444     uint32 target_mapId;
 445     float  target_X;
 446     float  target_Y;
 447     float  target_Z;
 448     float  target_Orientation;
 449 };
 450
 451 typedef UNORDERED_MAP<uint32, SpellTargetPosition> SpellTargetPositionMap;
 452
 453 // Spell pet auras
 454 class PetAura
 455 {
 456     public:
 457         PetAura()
 458         {
 459             auras.clear();
 460         }
 461
 462         PetAura(uint16 petEntry, uint16 aura, bool _removeOnChangePet, int _damage) :
 463         removeOnChangePet(_removeOnChangePet), damage(_damage)
 464         {
 465             auras[petEntry] = aura;
 466         }
 467
 468         uint16 GetAura(uint16 petEntry) const
 469         {
 470             std::map<uint16, uint16>::const_iterator itr = auras.find(petEntry);
 471             if(itr != auras.end())
 472                 return itr->second;
 473             else
 474             {
 475                 std::map<uint16, uint16>::const_iterator itr2 = auras.find(0);
 476                 if(itr2 != auras.end())
 477                     return itr2->second;
 478                 else
 479                     return 0;
 480             }
 481         }
 482
 483         void AddAura(uint16 petEntry, uint16 aura)
 484         {
 485             auras[petEntry] = aura;
 486         }
 487
 488         bool IsRemovedOnChangePet() const
 489         {
 490             return removeOnChangePet;
 491         }
 492
 493         int32 GetDamage() const
 494         {
 495             return damage;
 496         }
 497
 498     private:
 499         std::map<uint16, uint16> auras;
 500         bool removeOnChangePet;
 501         int32 damage;
 502 };
 503 typedef std::map<uint16, PetAura> SpellPetAuraMap;
 504
 505 struct SpellArea
 506 {
 507     uint32 spellId;
 508     uint32 areaId;                                          // zone/subzone/or 0 is not limited to zone
 509     uint32 questStart;                                      // quest start (quest must be active or rewarded for spell apply)
 510     uint32 questEnd;                                        // quest end (quest don't must be rewarded for spell apply)
 511     int32  auraSpell;                                       // spell aura must be applied for spell apply )if possitive) and it don't must be applied in other case
 512     uint32 raceMask;                                        // can be applied only to races
 513     Gender gender;                                          // can be applied only to gender
 514     bool questStartCanActive;                               // if true then quest start can be active (not only rewarded)
 515     bool autocast;                                          // if true then auto applied at area enter, in other case just allowed to cast
 516
 517     // helpers
 518     bool IsFitToRequirements(Player const* player, uint32 newZone, uint32 newArea) const;
 519 };
 520
 521 typedef std::multimap<uint32,SpellArea> SpellAreaMap;
 522 typedef std::multimap<uint32,SpellArea const*> SpellAreaForQuestMap;
 523 typedef std::multimap<uint32,SpellArea const*> SpellAreaForAuraMap;
 524 typedef std::multimap<uint32,SpellArea const*> SpellAreaForAreaMap;
 525 typedef std::pair<SpellAreaMap::const_iterator,SpellAreaMap::const_iterator> SpellAreaMapBounds;
 526 typedef std::pair<SpellAreaForQuestMap::const_iterator,SpellAreaForQuestMap::const_iterator> SpellAreaForQuestMapBounds;
 527 typedef std::pair<SpellAreaForAuraMap::const_iterator, SpellAreaForAuraMap::const_iterator>  SpellAreaForAuraMapBounds;
 528 typedef std::pair<SpellAreaForAreaMap::const_iterator, SpellAreaForAreaMap::const_iterator>  SpellAreaForAreaMapBounds;
 529
 530
 531 // Spell rank chain  (accessed using SpellMgr functions)
 532 struct SpellChainNode
 533 {
 534     uint32 prev;
 535     uint32 first;
 536     uint32 req;
 537     uint8  rank;
 538 };
 539
 540 typedef UNORDERED_MAP<uint32, SpellChainNode> SpellChainMap;
 541 typedef std::multimap<uint32, uint32> SpellChainMapNext;
 542
 543 // Spell learning properties (accessed using SpellMgr functions)
 544 struct SpellLearnSkillNode
 545 {
 546     uint32 skill;
 547     uint32 value;                                           // 0  - max skill value for player level
 548     uint32 maxvalue;                                        // 0  - max skill value for player level
 549 };
 550
 551 typedef std::map<uint32, SpellLearnSkillNode> SpellLearnSkillMap;
 552
 553 struct SpellLearnSpellNode
 554 {
 555     uint32 spell;
 556     bool active;                                            // show in spellbook or not
 557     bool autoLearned;
 558 };
 559
 560 typedef std::multimap<uint32, SpellLearnSpellNode> SpellLearnSpellMap;
 561
 562 typedef std::multimap<uint32, SkillLineAbilityEntry const*> SkillLineAbilityMap;
 563
 564 typedef std::multimap<uint32, uint32> PetLevelupSpellSet;
 565 typedef std::map<uint32, PetLevelupSpellSet> PetLevelupSpellMap;
 566
 567 struct PetDefaultSpellsEntry
 568 {
 569     uint32 spellid[MAX_CREATURE_SPELL_DATA_SLOT];
 570 };
 571
 572 // < 0 for petspelldata id, > 0 for creature_id
 573 typedef std::map<int32, PetDefaultSpellsEntry> PetDefaultSpellsMap;
 574
 575
 576 inline bool IsPrimaryProfessionSkill(uint32 skill)
 577 {
 578     SkillLineEntry const *pSkill = sSkillLineStore.LookupEntry(skill);
 579     if(!pSkill)
 580         return false;
 581
 582     if(pSkill->categoryId != SKILL_CATEGORY_PROFESSION)
 583         return false;
 584
 585     return true;
 586 }
 587
 588 inline bool IsProfessionSkill(uint32 skill)
 589 {
 590     return  IsPrimaryProfessionSkill(skill) || skill == SKILL_FISHING || skill == SKILL_COOKING || skill == SKILL_FIRST_AID;
 591 }
 592
 593 inline bool IsProfessionOrRidingSkill(uint32 skill)
 594 {
 595     return  IsProfessionSkill(skill) || skill == SKILL_RIDING;
 596 }
 597
 598 class SpellMgr
 599 {
 600     // Constructors
 601     public:
 602         SpellMgr();
 603         ~SpellMgr();
 604
 605     // Accessors (const or static functions)
 606     public:
 607         // Spell affects
 608         SpellAffectEntry const*GetSpellAffect(uint16 spellId, uint8 effectId) const
 609         {
 610             SpellAffectMap::const_iterator itr = mSpellAffectMap.find((spellId<<8) + effectId);
 611             if( itr != mSpellAffectMap.end( ) )
 612                 return &itr->second;
 613             return 0;
 614         }
 615
 616         bool IsAffectedByMod(SpellEntry const *spellInfo, SpellModifier *mod) const;
 617
 618         SpellElixirMap const& GetSpellElixirMap() const { return mSpellElixirs; }
 619
 620         uint32 GetSpellElixirMask(uint32 spellid) const
 621         {
 622             SpellElixirMap::const_iterator itr = mSpellElixirs.find(spellid);
 623             if(itr==mSpellElixirs.end())
 624                 return 0x0;
 625
 626             return itr->second;
 627         }
 628
 629         SpellSpecific GetSpellElixirSpecific(uint32 spellid) const
 630         {
 631             uint32 mask = GetSpellElixirMask(spellid);
 632             if((mask & ELIXIR_FLASK_MASK)==ELIXIR_FLASK_MASK)
 633                 return SPELL_FLASK_ELIXIR;
 634             else if(mask & ELIXIR_BATTLE_MASK)
 635                 return SPELL_BATTLE_ELIXIR;
 636             else if(mask & ELIXIR_GUARDIAN_MASK)
 637                 return SPELL_GUARDIAN_ELIXIR;
 638             else
 639                 return SPELL_NORMAL;
 640         }
 641
 642         // Spell proc events
 643         SpellProcEventEntry const* GetSpellProcEvent(uint32 spellId) const
 644         {
 645             SpellProcEventMap::const_iterator itr = mSpellProcEventMap.find(spellId);
 646             if( itr != mSpellProcEventMap.end( ) )
 647                 return &itr->second;
 648             return NULL;
 649         }
 650
 651         static bool IsSpellProcEventCanTriggeredBy( SpellProcEventEntry const * spellProcEvent, uint32 EventProcFlag, SpellEntry const * procSpell, uint32 procFlags, uint32 procExtra, bool active);
 652
 653         // Spell bonus data
 654         SpellBonusEntry const* GetSpellBonusData(uint32 spellId) const
 655         {
 656             // Lookup data
 657             SpellBonusMap::const_iterator itr = mSpellBonusMap.find(spellId);
 658             if( itr != mSpellBonusMap.end( ) )
 659                 return &itr->second;
 660             // Not found, try lookup for 1 spell rank if exist
 661             if (uint32 rank_1 = GetFirstSpellInChain(spellId))
 662             {
 663                 SpellBonusMap::const_iterator itr2 = mSpellBonusMap.find(rank_1);
 664                 if( itr2 != mSpellBonusMap.end( ) )
 665                     return &itr2->second;
 666             }
 667             return NULL;
 668         }
 669
 670         // Spell target coordinates
 671         SpellTargetPosition const* GetSpellTargetPosition(uint32 spell_id) const
 672         {
 673             SpellTargetPositionMap::const_iterator itr = mSpellTargetPositions.find( spell_id );
 674             if( itr != mSpellTargetPositions.end( ) )
 675                 return &itr->second;
 676             return NULL;
 677         }
 678
 679         // Spell ranks chains
 680         SpellChainNode const* GetSpellChainNode(uint32 spell_id) const
 681         {
 682             SpellChainMap::const_iterator itr = mSpellChains.find(spell_id);
 683             if(itr == mSpellChains.end())
 684                 return NULL;
 685
 686             return &itr->second;
 687         }
 688
 689         uint32 GetFirstSpellInChain(uint32 spell_id) const
 690         {
 691             if(SpellChainNode const* node = GetSpellChainNode(spell_id))
 692                 return node->first;
 693
 694             return spell_id;
 695         }
 696
 697         uint32 GetPrevSpellInChain(uint32 spell_id) const
 698         {
 699             if(SpellChainNode const* node = GetSpellChainNode(spell_id))
 700                 return node->prev;
 701
 702             return 0;
 703         }
 704
 705         SpellChainMapNext const& GetSpellChainNext() const { return mSpellChainsNext; }
 706
 707         // Note: not use rank for compare to spell ranks: spell chains isn't linear order
 708         // Use IsHighRankOfSpell instead
 709         uint8 GetSpellRank(uint32 spell_id) const
 710         {
 711             if(SpellChainNode const* node = GetSpellChainNode(spell_id))
 712                 return node->rank;
 713
 714             return 0;
 715         }
 716
 717         uint8 IsHighRankOfSpell(uint32 spell1,uint32 spell2) const
 718         {
 719             SpellChainMap::const_iterator itr = mSpellChains.find(spell1);
 720
 721             uint32 rank2 = GetSpellRank(spell2);
 722
 723             // not ordered correctly by rank value
 724             if(itr == mSpellChains.end() || !rank2 || itr->second.rank <= rank2)
 725                 return false;
 726
 727             // check present in same rank chain
 728             for(; itr != mSpellChains.end(); itr = mSpellChains.find(itr->second.prev))
 729                 if(itr->second.prev==spell2)
 730                     return true;
 731
 732             return false;
 733         }
 734
 735         bool IsRankSpellDueToSpell(SpellEntry const *spellInfo_1,uint32 spellId_2) const;
 736         static bool canStackSpellRanks(SpellEntry const *spellInfo);
 737         bool IsNoStackSpellDueToSpell(uint32 spellId_1, uint32 spellId_2) const;
 738
 739         SpellEntry const* SelectAuraRankForPlayerLevel(SpellEntry const* spellInfo, uint32 playerLevel) const;
 740
 741         // Spell learning
 742         SpellLearnSkillNode const* GetSpellLearnSkill(uint32 spell_id) const
 743         {
 744             SpellLearnSkillMap::const_iterator itr = mSpellLearnSkills.find(spell_id);
 745             if(itr != mSpellLearnSkills.end())
 746                 return &itr->second;
 747             else
 748                 return NULL;
 749         }
 750
 751         bool IsSpellLearnSpell(uint32 spell_id) const
 752         {
 753             return mSpellLearnSpells.find(spell_id) != mSpellLearnSpells.end();
 754         }
 755
 756         SpellLearnSpellMap::const_iterator GetBeginSpellLearnSpell(uint32 spell_id) const
 757         {
 758             return mSpellLearnSpells.lower_bound(spell_id);
 759         }
 760
 761         SpellLearnSpellMap::const_iterator GetEndSpellLearnSpell(uint32 spell_id) const
 762         {
 763             return mSpellLearnSpells.upper_bound(spell_id);
 764         }
 765
 766         bool IsSpellLearnToSpell(uint32 spell_id1,uint32 spell_id2) const
 767         {
 768             SpellLearnSpellMap::const_iterator b = GetBeginSpellLearnSpell(spell_id1);
 769             SpellLearnSpellMap::const_iterator e = GetEndSpellLearnSpell(spell_id1);
 770             for(SpellLearnSpellMap::const_iterator i = b; i != e; ++i)
 771                 if(i->second.spell==spell_id2)
 772                     return true;
 773             return false;
 774         }
 775
 776         static bool IsProfessionOrRidingSpell(uint32 spellId);
 777         static bool IsProfessionSpell(uint32 spellId);
 778         static bool IsPrimaryProfessionSpell(uint32 spellId);
 779         bool IsPrimaryProfessionFirstRankSpell(uint32 spellId) const;
 780
 781         bool IsSkillBonusSpell(uint32 spellId) const;
 782
 783
 784         // Spell script targets
 785         SpellScriptTarget::const_iterator GetBeginSpellScriptTarget(uint32 spell_id) const
 786         {
 787             return mSpellScriptTarget.lower_bound(spell_id);
 788         }
 789
 790         SpellScriptTarget::const_iterator GetEndSpellScriptTarget(uint32 spell_id) const
 791         {
 792             return mSpellScriptTarget.upper_bound(spell_id);
 793         }
 794
 795         // Spell correctess for client using
 796         static bool IsSpellValid(SpellEntry const * spellInfo, Player* pl = NULL, bool msg = true);
 797
 798         SkillLineAbilityMap::const_iterator GetBeginSkillLineAbilityMap(uint32 spell_id) const
 799         {
 800             return mSkillLineAbilityMap.lower_bound(spell_id);
 801         }
 802
 803         SkillLineAbilityMap::const_iterator GetEndSkillLineAbilityMap(uint32 spell_id) const
 804         {
 805             return mSkillLineAbilityMap.upper_bound(spell_id);
 806         }
 807
 808         PetAura const* GetPetAura(uint16 spell_id)
 809         {
 810             SpellPetAuraMap::const_iterator itr = mSpellPetAuraMap.find(spell_id);
 811             if(itr != mSpellPetAuraMap.end())
 812                 return &itr->second;
 813             else
 814                 return NULL;
 815         }
 816
 817         PetLevelupSpellSet const* GetPetLevelupSpellList(uint32 petFamily) const
 818         {
 819             PetLevelupSpellMap::const_iterator itr = mPetLevelupSpellMap.find(petFamily);
 820             if(itr != mPetLevelupSpellMap.end())
 821                 return &itr->second;
 822             else
 823                 return NULL;
 824         }
 825
 826         // < 0 for petspelldata id, > 0 for creature_id
 827         PetDefaultSpellsEntry const* GetPetDefaultSpellsEntry(int32 id) const
 828         {
 829             PetDefaultSpellsMap::const_iterator itr = mPetDefaultSpellsMap.find(id);
 830             if(itr != mPetDefaultSpellsMap.end())
 831                 return &itr->second;
 832             return NULL;
 833         }
 834
 835         SpellCastResult GetSpellAllowedInLocationError(SpellEntry const *spellInfo, uint32 map_id, uint32 zone_id, uint32 area_id, Player const* player = NULL);
 836
 837         SpellAreaMapBounds GetSpellAreaMapBounds(uint32 spell_id) const
 838         {
 839             return SpellAreaMapBounds(mSpellAreaMap.lower_bound(spell_id),mSpellAreaMap.upper_bound(spell_id));
 840         }
 841
 842         SpellAreaForQuestMapBounds GetSpellAreaForQuestMapBounds(uint32 quest_id, bool active) const
 843         {
 844             if(active)
 845                 return SpellAreaForQuestMapBounds(mSpellAreaForActiveQuestMap.lower_bound(quest_id),mSpellAreaForActiveQuestMap.upper_bound(quest_id));
 846             else
 847                 return SpellAreaForQuestMapBounds(mSpellAreaForQuestMap.lower_bound(quest_id),mSpellAreaForQuestMap.upper_bound(quest_id));
 848         }
 849
 850         SpellAreaForQuestMapBounds GetSpellAreaForQuestEndMapBounds(uint32 quest_id) const
 851         {
 852             return SpellAreaForQuestMapBounds(mSpellAreaForQuestEndMap.lower_bound(quest_id),mSpellAreaForQuestEndMap.upper_bound(quest_id));
 853         }
 854
 855         SpellAreaForAuraMapBounds GetSpellAreaForAuraMapBounds(uint32 spell_id) const
 856         {
 857             return SpellAreaForAuraMapBounds(mSpellAreaForAuraMap.lower_bound(spell_id),mSpellAreaForAuraMap.upper_bound(spell_id));
 858         }
 859
 860         SpellAreaForAreaMapBounds GetSpellAreaForAreaMapBounds(uint32 area_id) const
 861         {
 862             return SpellAreaForAreaMapBounds(mSpellAreaForAreaMap.lower_bound(area_id),mSpellAreaForAreaMap.upper_bound(area_id));
 863         }
 864
 865     // Modifiers
 866     public:
 867         static SpellMgr& Instance();
 868
 869         // Loading data at server startup
 870         void LoadSpellChains();
 871         void LoadSpellLearnSkills();
 872         void LoadSpellLearnSpells();
 873         void LoadSpellScriptTarget();
 874         void LoadSpellAffects();
 875         void LoadSpellElixirs();
 876         void LoadSpellProcEvents();
 877         void LoadSpellBonusess();
 878         void LoadSpellTargetPositions();
 879         void LoadSpellThreats();
 880         void LoadSkillLineAbilityMap();
 881         void LoadSpellPetAuras();
 882         void LoadPetLevelupSpellMap();
 883         void LoadPetDefaultSpells();
 884         void LoadSpellAreas();
 885
 886     private:
 887         SpellScriptTarget  mSpellScriptTarget;
 888         SpellChainMap      mSpellChains;
 889         SpellChainMapNext  mSpellChainsNext;
 890         SpellLearnSkillMap mSpellLearnSkills;
 891         SpellLearnSpellMap mSpellLearnSpells;
 892         SpellTargetPositionMap mSpellTargetPositions;
 893         SpellAffectMap     mSpellAffectMap;
 894         SpellElixirMap     mSpellElixirs;
 895         SpellProcEventMap  mSpellProcEventMap;
 896         SpellBonusMap      mSpellBonusMap;
 897         SkillLineAbilityMap mSkillLineAbilityMap;
 898         SpellPetAuraMap     mSpellPetAuraMap;
 899         PetLevelupSpellMap  mPetLevelupSpellMap;
 900         PetDefaultSpellsMap mPetDefaultSpellsMap;           // only spells not listed in related mPetLevelupSpellMap entry
 901         SpellAreaMap         mSpellAreaMap;
 902         SpellAreaForQuestMap mSpellAreaForQuestMap;
 903         SpellAreaForQuestMap mSpellAreaForActiveQuestMap;
 904         SpellAreaForQuestMap mSpellAreaForQuestEndMap;
 905         SpellAreaForAuraMap  mSpellAreaForAuraMap;
 906         SpellAreaForAreaMap  mSpellAreaForAreaMap;
 907 };
 908
 909 #define spellmgr SpellMgr::Instance()
 910 #endif