src/game/Spell.h

   1 /*
   2  * Copyright (C) 2005-2010 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 __SPELL_H
  20 #define __SPELL_H
  21
  22 #include "GridDefines.h"
  23 #include "SharedDefines.h"
  24
  25 class WorldSession;
  26 class Unit;
  27 class DynamicObj;
  28 class Player;
  29 class GameObject;
  30 class Group;
  31 class Aura;
  32
  33 enum SpellCastTargetFlags
  34 {
  35     TARGET_FLAG_SELF            = 0x00000000,
  36     TARGET_FLAG_UNUSED1         = 0x00000001,               // not used in any spells as of 3.0.3 (can be set dynamically)
  37     TARGET_FLAG_UNIT            = 0x00000002,               // pguid
  38     TARGET_FLAG_UNUSED2         = 0x00000004,               // not used in any spells as of 3.0.3 (can be set dynamically)
  39     TARGET_FLAG_UNUSED3         = 0x00000008,               // not used in any spells as of 3.0.3 (can be set dynamically)
  40     TARGET_FLAG_ITEM            = 0x00000010,               // pguid
  41     TARGET_FLAG_SOURCE_LOCATION = 0x00000020,               // 3 float
  42     TARGET_FLAG_DEST_LOCATION   = 0x00000040,               // 3 float
  43     TARGET_FLAG_OBJECT_UNK      = 0x00000080,               // used in 7 spells only
  44     TARGET_FLAG_UNIT_UNK        = 0x00000100,               // looks like self target (480 spells)
  45     TARGET_FLAG_PVP_CORPSE      = 0x00000200,               // pguid
  46     TARGET_FLAG_UNIT_CORPSE     = 0x00000400,               // 10 spells (gathering professions)
  47     TARGET_FLAG_OBJECT          = 0x00000800,               // pguid, 2 spells
  48     TARGET_FLAG_TRADE_ITEM      = 0x00001000,               // pguid, 0 spells
  49     TARGET_FLAG_STRING          = 0x00002000,               // string, 0 spells
  50     TARGET_FLAG_UNK1            = 0x00004000,               // 199 spells, opening object/lock
  51     TARGET_FLAG_CORPSE          = 0x00008000,               // pguid, resurrection spells
  52     TARGET_FLAG_UNK2            = 0x00010000,               // pguid, not used in any spells as of 3.0.3 (can be set dynamically)
  53     TARGET_FLAG_GLYPH           = 0x00020000                // used in glyph spells
  54 };
  55
  56 enum SpellCastFlags
  57 {
  58     CAST_FLAG_NONE               = 0x00000000,
  59     CAST_FLAG_UNKNOWN0           = 0x00000001,              // may be pending spell cast
  60     CAST_FLAG_UNKNOWN1           = 0x00000002,
  61     CAST_FLAG_UNKNOWN11          = 0x00000004,
  62     CAST_FLAG_UNKNOWN12          = 0x00000008,
  63     CAST_FLAG_UNKNOWN2           = 0x00000010,
  64     CAST_FLAG_AMMO               = 0x00000020,              // Projectiles visual
  65     CAST_FLAG_UNKNOWN8           = 0x00000040,
  66     CAST_FLAG_UNKNOWN9           = 0x00000080,
  67     CAST_FLAG_UNKNOWN3           = 0x00000100,
  68     CAST_FLAG_UNKNOWN13          = 0x00000200,
  69     CAST_FLAG_UNKNOWN14          = 0x00000400,
  70     CAST_FLAG_UNKNOWN6           = 0x00000800,              // wotlk, trigger rune cooldown
  71     CAST_FLAG_UNKNOWN15          = 0x00001000,
  72     CAST_FLAG_UNKNOWN16          = 0x00002000,
  73     CAST_FLAG_UNKNOWN17          = 0x00004000,
  74     CAST_FLAG_UNKNOWN18          = 0x00008000,
  75     CAST_FLAG_UNKNOWN19          = 0x00010000,
  76     CAST_FLAG_UNKNOWN4           = 0x00020000,              // wotlk
  77     CAST_FLAG_UNKNOWN10          = 0x00040000,
  78     CAST_FLAG_UNKNOWN5           = 0x00080000,              // wotlk
  79     CAST_FLAG_UNKNOWN20          = 0x00100000,
  80     CAST_FLAG_UNKNOWN7           = 0x00200000,              // wotlk, rune cooldown list
  81     CAST_FLAG_UNKNOWN21          = 0x04000000
  82 };
  83
  84 enum SpellNotifyPushType
  85 {
  86     PUSH_IN_FRONT,
  87     PUSH_IN_FRONT_90,
  88     PUSH_IN_FRONT_30,
  89     PUSH_IN_FRONT_15,
  90     PUSH_IN_BACK,
  91     PUSH_SELF_CENTER,
  92     PUSH_DEST_CENTER,
  93     PUSH_TARGET_CENTER
  94 };
  95
  96 bool IsQuestTameSpell(uint32 spellId);
  97
  98 namespace MaNGOS
  99 {
 100     struct SpellNotifierPlayer;
 101     struct SpellNotifierCreatureAndPlayer;
 102 }
 103
 104 class SpellCastTargets
 105 {
 106     public:
 107         SpellCastTargets();
 108         ~SpellCastTargets();
 109
 110         bool read ( WorldPacket * data, Unit *caster );
 111         void write ( WorldPacket * data );
 112
 113         SpellCastTargets& operator=(const SpellCastTargets &target)
 114         {
 115             m_unitTarget = target.m_unitTarget;
 116             m_itemTarget = target.m_itemTarget;
 117             m_GOTarget   = target.m_GOTarget;
 118
 119             m_unitTargetGUID   = target.m_unitTargetGUID;
 120             m_GOTargetGUID     = target.m_GOTargetGUID;
 121             m_CorpseTargetGUID = target.m_CorpseTargetGUID;
 122             m_itemTargetGUID   = target.m_itemTargetGUID;
 123
 124             m_itemTargetEntry  = target.m_itemTargetEntry;
 125
 126             m_srcX = target.m_srcX;
 127             m_srcY = target.m_srcY;
 128             m_srcZ = target.m_srcZ;
 129
 130             m_destX = target.m_destX;
 131             m_destY = target.m_destY;
 132             m_destZ = target.m_destZ;
 133
 134             m_strTarget = target.m_strTarget;
 135
 136             m_targetMask = target.m_targetMask;
 137
 138             return *this;
 139         }
 140
 141         uint64 getUnitTargetGUID() const { return m_unitTargetGUID; }
 142         Unit *getUnitTarget() const { return m_unitTarget; }
 143         void setUnitTarget(Unit *target);
 144         void setDestination(float x, float y, float z);
 145         void setSource(float x, float y, float z);
 146
 147         uint64 getGOTargetGUID() const { return m_GOTargetGUID; }
 148         GameObject *getGOTarget() const { return m_GOTarget; }
 149         void setGOTarget(GameObject *target);
 150
 151         uint64 getCorpseTargetGUID() const { return m_CorpseTargetGUID; }
 152         void setCorpseTarget(Corpse* corpse);
 153         uint64 getItemTargetGUID() const { return m_itemTargetGUID; }
 154         Item* getItemTarget() const { return m_itemTarget; }
 155         uint32 getItemTargetEntry() const { return m_itemTargetEntry; }
 156         void setItemTarget(Item* item);
 157         void updateTradeSlotItem()
 158         {
 159             if(m_itemTarget && (m_targetMask & TARGET_FLAG_TRADE_ITEM))
 160             {
 161                 m_itemTargetGUID = m_itemTarget->GetGUID();
 162                 m_itemTargetEntry = m_itemTarget->GetEntry();
 163             }
 164         }
 165
 166         bool IsEmpty() const { return m_GOTargetGUID==0 && m_unitTargetGUID==0 && m_itemTarget==0 && m_CorpseTargetGUID==0; }
 167
 168         void Update(Unit* caster);
 169
 170         float m_srcX, m_srcY, m_srcZ;
 171         float m_destX, m_destY, m_destZ;
 172         std::string m_strTarget;
 173
 174         uint32 m_targetMask;
 175     private:
 176         // objects (can be used at spell creating and after Update at casting
 177         Unit *m_unitTarget;
 178         GameObject *m_GOTarget;
 179         Item *m_itemTarget;
 180
 181         // object GUID/etc, can be used always
 182         uint64 m_unitTargetGUID;
 183         uint64 m_GOTargetGUID;
 184         uint64 m_CorpseTargetGUID;
 185         uint64 m_itemTargetGUID;
 186         uint32 m_itemTargetEntry;
 187 };
 188
 189 enum SpellState
 190 {
 191     SPELL_STATE_NULL      = 0,
 192     SPELL_STATE_PREPARING = 1,
 193     SPELL_STATE_CASTING   = 2,
 194     SPELL_STATE_FINISHED  = 3,
 195     SPELL_STATE_IDLE      = 4,
 196     SPELL_STATE_DELAYED   = 5
 197 };
 198
 199 enum SpellTargets
 200 {
 201     SPELL_TARGETS_HOSTILE,
 202     SPELL_TARGETS_NOT_FRIENDLY,
 203     SPELL_TARGETS_NOT_HOSTILE,
 204     SPELL_TARGETS_FRIENDLY,
 205     SPELL_TARGETS_AOE_DAMAGE
 206 };
 207
 208 #define SPELL_SPELL_CHANNEL_UPDATE_INTERVAL (1*IN_MILISECONDS)
 209
 210 typedef std::multimap<uint64, uint64> SpellTargetTimeMap;
 211
 212 class Spell
 213 {
 214     friend struct MaNGOS::SpellNotifierPlayer;
 215     friend struct MaNGOS::SpellNotifierCreatureAndPlayer;
 216     friend void Unit::SetCurrentCastedSpell( Spell * pSpell );
 217     public:
 218
 219         void EffectNULL(uint32 );
 220         void EffectUnused(uint32 );
 221         void EffectDistract(uint32 i);
 222         void EffectPull(uint32 i);
 223         void EffectSchoolDMG(uint32 i);
 224         void EffectEnvironmentalDMG(uint32 i);
 225         void EffectInstaKill(uint32 i);
 226         void EffectDummy(uint32 i);
 227         void EffectTeleportUnits(uint32 i);
 228         void EffectApplyAura(uint32 i);
 229         void EffectSendEvent(uint32 i);
 230         void EffectPowerBurn(uint32 i);
 231         void EffectPowerDrain(uint32 i);
 232         void EffectHeal(uint32 i);
 233         void EffectHealthLeech(uint32 i);
 234         void EffectQuestComplete(uint32 i);
 235         void EffectCreateItem(uint32 i);
 236         void EffectCreateItem2(uint32 i);
 237         void EffectCreateRandomItem(uint32 i);
 238         void EffectPersistentAA(uint32 i);
 239         void EffectEnergize(uint32 i);
 240         void EffectOpenLock(uint32 i);
 241         void EffectSummonChangeItem(uint32 i);
 242         void EffectProficiency(uint32 i);
 243         void EffectApplyAreaAura(uint32 i);
 244         void EffectSummonType(uint32 i);
 245         void EffectSummon(uint32 i);
 246         void EffectLearnSpell(uint32 i);
 247         void EffectDispel(uint32 i);
 248         void EffectDualWield(uint32 i);
 249         void EffectPickPocket(uint32 i);
 250         void EffectAddFarsight(uint32 i);
 251         void EffectSummonWild(uint32 i, uint32 forceFaction = 0);
 252         void EffectSummonGuardian(uint32 i, uint32 forceFaction = 0);
 253         void EffectHealMechanical(uint32 i);
 254         void EffectJump(uint32 i);
 255         void EffectTeleUnitsFaceCaster(uint32 i);
 256         void EffectLearnSkill(uint32 i);
 257         void EffectAddHonor(uint32 i);
 258         void EffectTradeSkill(uint32 i);
 259         void EffectEnchantItemPerm(uint32 i);
 260         void EffectEnchantItemTmp(uint32 i);
 261         void EffectTameCreature(uint32 i);
 262         void EffectSummonPet(uint32 i);
 263         void EffectLearnPetSpell(uint32 i);
 264         void EffectWeaponDmg(uint32 i);
 265         void EffectForceCast(uint32 i);
 266         void EffectTriggerSpell(uint32 i);
 267         void EffectTriggerMissileSpell(uint32 i);
 268         void EffectThreat(uint32 i);
 269         void EffectHealMaxHealth(uint32 i);
 270         void EffectInterruptCast(uint32 i);
 271         void EffectSummonObjectWild(uint32 i);
 272         void EffectScriptEffect(uint32 i);
 273         void EffectSanctuary(uint32 i);
 274         void EffectAddComboPoints(uint32 i);
 275         void EffectDuel(uint32 i);
 276         void EffectStuck(uint32 i);
 277         void EffectSummonPlayer(uint32 i);
 278         void EffectActivateObject(uint32 i);
 279         void EffectApplyGlyph(uint32 i);
 280         void EffectSummonTotem(uint32 i, uint8 slot = 0);
 281         void EffectEnchantHeldItem(uint32 i);
 282         void EffectSummonObject(uint32 i);
 283         void EffectResurrect(uint32 i);
 284         void EffectParry(uint32 i);
 285         void EffectBlock(uint32 i);
 286         void EffectLeapForward(uint32 i);
 287         void EffectLeapBack(uint32 i);
 288         void EffectTransmitted(uint32 i);
 289         void EffectDisEnchant(uint32 i);
 290         void EffectInebriate(uint32 i);
 291         void EffectFeedPet(uint32 i);
 292         void EffectDismissPet(uint32 i);
 293         void EffectReputation(uint32 i);
 294         void EffectSelfResurrect(uint32 i);
 295         void EffectSkinning(uint32 i);
 296         void EffectCharge(uint32 i);
 297         void EffectCharge2(uint32 i);
 298         void EffectProspecting(uint32 i);
 299         void EffectMilling(uint32 i);
 300         void EffectRenamePet(uint32 i);
 301         void EffectSendTaxi(uint32 i);
 302         void EffectSummonCritter(uint32 i, uint32 forceFaction = 0);
 303         void EffectKnockBack(uint32 i);
 304         void EffectPlayerPull(uint32 i);
 305         void EffectDispelMechanic(uint32 i);
 306         void EffectSummonDeadPet(uint32 i);
 307         void EffectSummonAllTotems(uint32 i);
 308         void EffectDestroyAllTotems(uint32 i);
 309         void EffectDurabilityDamage(uint32 i);
 310         void EffectSkill(uint32 i);
 311         void EffectTaunt(uint32 i);
 312         void EffectDurabilityDamagePCT(uint32 i);
 313         void EffectModifyThreatPercent(uint32 i);
 314         void EffectResurrectNew(uint32 i);
 315         void EffectAddExtraAttacks(uint32 i);
 316         void EffectSpiritHeal(uint32 i);
 317         void EffectSkinPlayerCorpse(uint32 i);
 318         void EffectStealBeneficialBuff(uint32 i);
 319         void EffectUnlearnSpecialization(uint32 i);
 320         void EffectHealPct(uint32 i);
 321         void EffectEnergisePct(uint32 i);
 322         void EffectTriggerSpellWithValue(uint32 i);
 323         void EffectTriggerRitualOfSummoning(uint32 i);
 324         void EffectKillCreditPersonal(uint32 i);
 325         void EffectKillCredit(uint32 i);
 326         void EffectQuestFail(uint32 i);
 327         void EffectActivateRune(uint32 i);
 328         void EffectTitanGrip(uint32 i);
 329         void EffectEnchantItemPrismatic(uint32 i);
 330         void EffectPlayMusic(uint32 i);
 331
 332         Spell( Unit* Caster, SpellEntry const *info, bool triggered, uint64 originalCasterGUID = 0, Spell** triggeringContainer = NULL );
 333         ~Spell();
 334
 335         void prepare(SpellCastTargets const* targets, Aura* triggeredByAura = NULL);
 336         void cancel();
 337         void update(uint32 difftime);
 338         void cast(bool skipCheck = false);
 339         void finish(bool ok = true);
 340         void TakePower();
 341         void TakeReagents();
 342         void TakeCastItem();
 343
 344         SpellCastResult CheckCast(bool strict);
 345         SpellCastResult CheckPetCast(Unit* target);
 346
 347         // handlers
 348         void handle_immediate();
 349         uint64 handle_delayed(uint64 t_offset);
 350         // handler helpers
 351         void _handle_immediate_phase();
 352         void _handle_finish_phase();
 353
 354         SpellCastResult CheckItems();
 355         SpellCastResult CheckRange(bool strict);
 356         SpellCastResult CheckPower();
 357         SpellCastResult CheckOrTakeRunePower(bool take);
 358         SpellCastResult CheckCasterAuras() const;
 359
 360         int32 CalculateDamage(uint8 i, Unit* target) { return m_caster->CalculateSpellDamage(m_spellInfo,i,m_currentBasePoints[i],target); }
 361         int32 CalculatePowerCost();
 362
 363         bool HaveTargetsForEffect(uint8 effect) const;
 364         void Delayed();
 365         void DelayedChannel();
 366         uint32 getState() const { return m_spellState; }
 367         void setState(uint32 state) { m_spellState = state; }
 368
 369         void DoCreateItem(uint32 i, uint32 itemtype);
 370         void WriteSpellGoTargets( WorldPacket * data );
 371         void WriteAmmoToPacket( WorldPacket * data );
 372
 373         typedef std::list<Unit*> UnitList;
 374         void FillTargetMap();
 375         void SetTargetMap(uint32 effIndex, uint32 targetMode, UnitList &targetUnitMap);
 376
 377         void FillAreaTargets(UnitList &targetUnitMap, float x, float y, float radius, SpellNotifyPushType pushType, SpellTargets spellTargets);
 378         void FillRaidOrPartyTargets(UnitList &targetUnitMap, Unit* member, Unit* center, float radius, bool raid, bool withPets, bool withcaster);
 379         void FillRaidOrPartyManaPriorityTargets(UnitList &targetUnitMap, Unit* member, Unit* center, float radius, uint32 count, bool raid, bool withPets, bool withcaster);
 380         void FillRaidOrPartyHealthPriorityTargets(UnitList &targetUnitMap, Unit* member, Unit* center, float radius, uint32 count, bool raid, bool withPets, bool withcaster);
 381
 382         template<typename T> WorldObject* FindCorpseUsing();
 383
 384         bool CheckTarget( Unit* target, uint32 eff );
 385         bool CanAutoCast(Unit* target);
 386
 387         static void MANGOS_DLL_SPEC SendCastResult(Player* caster, SpellEntry const* spellInfo, uint8 cast_count, SpellCastResult result);
 388         void SendCastResult(SpellCastResult result);
 389         void SendSpellStart();
 390         void SendSpellGo();
 391         void SendSpellCooldown();
 392         void SendLogExecute();
 393         void SendInterrupted(uint8 result);
 394         void SendChannelUpdate(uint32 time);
 395         void SendChannelStart(uint32 duration);
 396         void SendResurrectRequest(Player* target);
 397         void SendPlaySpellVisual(uint32 SpellID);
 398
 399         void HandleEffects(Unit *pUnitTarget,Item *pItemTarget,GameObject *pGOTarget,uint32 i, float DamageMultiplier = 1.0);
 400         void HandleThreatSpells(uint32 spellId);
 401         //void HandleAddAura(Unit* Target);
 402
 403         SpellEntry const* m_spellInfo;
 404         int32 m_currentBasePoints[3];                       // cache SpellEntry::EffectBasePoints and use for set custom base points
 405         Item* m_CastItem;
 406         uint8 m_cast_count;
 407         uint32 m_glyphIndex;
 408         SpellCastTargets m_targets;
 409
 410         int32 GetCastTime() const { return m_casttime; }
 411         uint32 GetCastedTime() { return m_timer; }
 412         bool IsAutoRepeat() const { return m_autoRepeat; }
 413         void SetAutoRepeat(bool rep) { m_autoRepeat = rep; }
 414         void ReSetTimer() { m_timer = m_casttime > 0 ? m_casttime : 0; }
 415         bool IsNextMeleeSwingSpell() const
 416         {
 417             return m_spellInfo->Attributes & (SPELL_ATTR_ON_NEXT_SWING_1|SPELL_ATTR_ON_NEXT_SWING_2);
 418         }
 419         bool IsRangedSpell() const
 420         {
 421             return  m_spellInfo->Attributes & SPELL_ATTR_RANGED;
 422         }
 423         bool IsChannelActive() const { return m_caster->GetUInt32Value(UNIT_CHANNEL_SPELL) != 0; }
 424         bool IsMeleeAttackResetSpell() const { return !m_IsTriggeredSpell && (m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_AUTOATTACK);  }
 425         bool IsRangedAttackResetSpell() const { return !m_IsTriggeredSpell && IsRangedSpell() && (m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_AUTOATTACK); }
 426
 427         bool IsDeletable() const { return !m_referencedFromCurrentSpell && !m_executedCurrently; }
 428         void SetReferencedFromCurrent(bool yes) { m_referencedFromCurrentSpell = yes; }
 429         void SetExecutedCurrently(bool yes) { m_executedCurrently = yes; }
 430         uint64 GetDelayStart() const { return m_delayStart; }
 431         void SetDelayStart(uint64 m_time) { m_delayStart = m_time; }
 432         uint64 GetDelayMoment() const { return m_delayMoment; }
 433
 434         bool IsNeedSendToClient() const;                    // use for hide spell cast for client in case when cast not have client side affect (animation or log entries)
 435         bool IsTriggeredSpellWithRedundentData() const;     // use for ignore some spell data for triggered spells like cast time, some triggered spells have redundent copy data from main spell for client use purpose
 436
 437         CurrentSpellTypes GetCurrentContainer();
 438
 439         Unit* GetCaster() const { return m_caster; }
 440         Unit* GetOriginalCaster() const { return m_originalCaster; }
 441         int32 GetPowerCost() const { return m_powerCost; }
 442
 443         void UpdatePointers();                              // must be used at call Spell code after time delay (non triggered spell cast/update spell call/etc)
 444
 445         bool IsAffectedByAura(Aura *aura) const;
 446
 447         bool CheckTargetCreatureType(Unit* target) const;
 448
 449         void AddTriggeredSpell(SpellEntry const* spellInfo) { m_TriggerSpells.push_back(spellInfo); }
 450         void AddPrecastSpell(SpellEntry const* spellInfo) { m_preCastSpells.push_back(spellInfo); }
 451         void AddTriggeredSpell(uint32 spellId);
 452         void AddPrecastSpell(uint32 spellId);
 453         void CastPreCastSpells(Unit* target);
 454         void CastTriggerSpells();
 455
 456         void CleanupTargetList();
 457     protected:
 458
 459         void SendLoot(uint64 guid, LootType loottype);
 460         bool IgnoreItemRequirements() const;                        // some item use spells have unexpected reagent data
 461
 462         Unit* m_caster;
 463
 464         uint64 m_originalCasterGUID;                        // real source of cast (aura caster/etc), used for spell targets selection
 465                                                             // e.g. damage around area spell trigered by victim aura and da,age emeies of aura caster
 466         Unit* m_originalCaster;                             // cached pointer for m_originalCaster, updated at Spell::UpdatePointers()
 467
 468         Spell** m_selfContainer;                            // pointer to our spell container (if applicable)
 469         Spell** m_triggeringContainer;                      // pointer to container with spell that has triggered us
 470
 471         //Spell data
 472         SpellSchoolMask m_spellSchoolMask;                  // Spell school (can be overwrite for some spells (wand shoot for example)
 473         WeaponAttackType m_attackType;                      // For weapon based attack
 474         int32 m_powerCost;                                  // Calculated spell cost     initialized only in Spell::prepare
 475         int32 m_casttime;                                   // Calculated spell cast time initialized only in Spell::prepare
 476         bool m_canReflect;                                  // can reflect this spell?
 477         bool m_autoRepeat;
 478         uint8 m_runesState;
 479
 480         uint8 m_delayAtDamageCount;
 481         bool isDelayableNoMore()
 482         {
 483             if(m_delayAtDamageCount >= 2)
 484                 return true;
 485
 486             m_delayAtDamageCount++;
 487             return false;
 488         }
 489
 490         // Delayed spells system
 491         uint64 m_delayStart;                                // time of spell delay start, filled by event handler, zero = just started
 492         uint64 m_delayMoment;                               // moment of next delay call, used internally
 493         bool m_immediateHandled;                            // were immediate actions handled? (used by delayed spells only)
 494
 495         // These vars are used in both delayed spell system and modified immediate spell system
 496         bool m_referencedFromCurrentSpell;                  // mark as references to prevent deleted and access by dead pointers
 497         bool m_executedCurrently;                           // mark as executed to prevent deleted and access by dead pointers
 498         bool m_needSpellLog;                                // need to send spell log?
 499         uint8 m_applyMultiplierMask;                        // by effect: damage multiplier needed?
 500         float m_damageMultipliers[3];                       // by effect: damage multiplier
 501
 502         // Current targets, to be used in SpellEffects (MUST BE USED ONLY IN SPELL EFFECTS)
 503         Unit* unitTarget;
 504         Item* itemTarget;
 505         GameObject* gameObjTarget;
 506         int32 damage;
 507
 508         // this is set in Spell Hit, but used in Apply Aura handler
 509         DiminishingLevels m_diminishLevel;
 510         DiminishingGroup m_diminishGroup;
 511
 512         // -------------------------------------------
 513         GameObject* focusObject;
 514
 515         // Damage and healing in effects need just calculate
 516         int32 m_damage;           // Damge   in effects count here
 517         int32 m_healing;          // Healing in effects count here
 518         int32 m_healthLeech;      // Health leech in effects for all targets count here
 519
 520         //******************************************
 521         // Spell trigger system
 522         //******************************************
 523         bool   m_canTrigger;                  // Can start trigger (m_IsTriggeredSpell can`t use for this)
 524         uint32 m_procAttacker;                // Attacker trigger flags
 525         uint32 m_procVictim;                  // Victim   trigger flags
 526         void   prepareDataForTriggerSystem();
 527
 528         //*****************************************
 529         // Spell target subsystem
 530         //*****************************************
 531         // Targets store structures and data
 532         struct TargetInfo
 533         {
 534             uint64 targetGUID;
 535             uint64 timeDelay;
 536             SpellMissInfo missCondition:8;
 537             SpellMissInfo reflectResult:8;
 538             uint8  effectMask:8;
 539             bool   processed:1;
 540         };
 541         std::list<TargetInfo> m_UniqueTargetInfo;
 542         uint8 m_needAliveTargetMask;                        // Mask req. alive targets
 543
 544         struct GOTargetInfo
 545         {
 546             uint64 targetGUID;
 547             uint64 timeDelay;
 548             uint8  effectMask:8;
 549             bool   processed:1;
 550         };
 551         std::list<GOTargetInfo> m_UniqueGOTargetInfo;
 552
 553         struct ItemTargetInfo
 554         {
 555             Item  *item;
 556             uint8 effectMask;
 557         };
 558         std::list<ItemTargetInfo> m_UniqueItemInfo;
 559
 560         void AddUnitTarget(Unit* target, uint32 effIndex);
 561         void AddUnitTarget(uint64 unitGUID, uint32 effIndex);
 562         void AddGOTarget(GameObject* target, uint32 effIndex);
 563         void AddGOTarget(uint64 goGUID, uint32 effIndex);
 564         void AddItemTarget(Item* target, uint32 effIndex);
 565         void DoAllEffectOnTarget(TargetInfo *target);
 566         void DoSpellHitOnUnit(Unit *unit, uint32 effectMask);
 567         void DoAllEffectOnTarget(GOTargetInfo *target);
 568         void DoAllEffectOnTarget(ItemTargetInfo *target);
 569         bool IsAliveUnitPresentInTargetList();
 570         SpellCastResult CanOpenLock(uint32 effIndex, uint32 lockid, SkillType& skillid, int32& reqSkillValue, int32& skillValue);
 571         // -------------------------------------------
 572
 573         //List For Triggered Spells
 574         typedef std::list<SpellEntry const*> SpellInfoList;
 575         SpellInfoList m_TriggerSpells;                      // casted by caster to same targets settings in m_targets at success finish of current spell
 576         SpellInfoList m_preCastSpells;                      // casted by caster to each target at spell hit before spell effects apply
 577
 578         uint32 m_spellState;
 579         uint32 m_timer;
 580
 581         float m_castPositionX;
 582         float m_castPositionY;
 583         float m_castPositionZ;
 584         float m_castOrientation;
 585         bool m_IsTriggeredSpell;
 586
 587         // if need this can be replaced by Aura copy
 588         // we can't store original aura link to prevent access to deleted auras
 589         // and in same time need aura data and after aura deleting.
 590         SpellEntry const* m_triggeredByAuraSpell;
 591 };
 592
 593 enum ReplenishType
 594 {
 595     REPLENISH_UNDEFINED = 0,
 596     REPLENISH_HEALTH    = 20,
 597     REPLENISH_MANA      = 21,
 598     REPLENISH_RAGE      = 22
 599 };
 600
 601 namespace MaNGOS
 602 {
 603     struct MANGOS_DLL_DECL SpellNotifierPlayer
 604     {
 605         std::list<Unit*> &i_data;
 606         Spell &i_spell;
 607         const uint32& i_index;
 608         float i_radius;
 609         Unit* i_originalCaster;
 610
 611         SpellNotifierPlayer(Spell &spell, std::list<Unit*> &data, const uint32 &i, float radius)
 612             : i_data(data), i_spell(spell), i_index(i), i_radius(radius)
 613         {
 614             i_originalCaster = i_spell.GetOriginalCaster();
 615         }
 616
 617         void Visit(PlayerMapType &m)
 618         {
 619             if(!i_originalCaster)
 620                 return;
 621
 622             for(PlayerMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
 623             {
 624                 Player * pPlayer = itr->getSource();
 625                 if( !pPlayer->isAlive() || pPlayer->isInFlight())
 626                     continue;
 627
 628                 if( i_originalCaster->IsFriendlyTo(pPlayer) )
 629                     continue;
 630
 631                 if( pPlayer->IsWithinDist3d(i_spell.m_targets.m_destX, i_spell.m_targets.m_destY, i_spell.m_targets.m_destZ,i_radius))
 632                     i_data.push_back(pPlayer);
 633             }
 634         }
 635         template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
 636     };
 637
 638     struct MANGOS_DLL_DECL SpellNotifierCreatureAndPlayer
 639     {
 640         std::list<Unit*> *i_data;
 641         Spell &i_spell;
 642         SpellNotifyPushType i_push_type;
 643         float i_radius;
 644         SpellTargets i_TargetType;
 645         Unit* i_originalCaster;
 646
 647         SpellNotifierCreatureAndPlayer(Spell &spell, std::list<Unit*> &data, float radius, SpellNotifyPushType type,
 648             SpellTargets TargetType = SPELL_TARGETS_NOT_FRIENDLY)
 649             : i_data(&data), i_spell(spell), i_push_type(type), i_radius(radius), i_TargetType(TargetType)
 650         {
 651             i_originalCaster = spell.GetOriginalCaster();
 652         }
 653
 654         template<class T> inline void Visit(GridRefManager<T>  &m)
 655         {
 656             assert(i_data);
 657
 658             if(!i_originalCaster)
 659                 return;
 660
 661             for(typename GridRefManager<T>::iterator itr = m.begin(); itr != m.end(); ++itr)
 662             {
 663                 // there are still more spells which can be casted on dead, but
 664                 // they are no AOE and don't have such a nice SPELL_ATTR flag
 665                 if ( !itr->getSource()->isTargetableForAttack(i_spell.m_spellInfo->AttributesEx3 & SPELL_ATTR_EX3_CAST_ON_DEAD)
 666                     // mostly phase check
 667                     || !itr->getSource()->IsInMap(i_originalCaster))
 668                     continue;
 669
 670                 switch (i_TargetType)
 671                 {
 672                     case SPELL_TARGETS_HOSTILE:
 673                         if (!i_originalCaster->IsHostileTo( itr->getSource() ))
 674                             continue;
 675                         break;
 676                     case SPELL_TARGETS_NOT_FRIENDLY:
 677                         if (i_originalCaster->IsFriendlyTo( itr->getSource() ))
 678                             continue;
 679                         break;
 680                     case SPELL_TARGETS_NOT_HOSTILE:
 681                         if (i_originalCaster->IsHostileTo( itr->getSource() ))
 682                             continue;
 683                         break;
 684                     case SPELL_TARGETS_FRIENDLY:
 685                         if (!i_originalCaster->IsFriendlyTo( itr->getSource() ))
 686                             continue;
 687                         break;
 688                     case SPELL_TARGETS_AOE_DAMAGE:
 689                     {
 690                         if(itr->getSource()->GetTypeId()==TYPEID_UNIT && ((Creature*)itr->getSource())->isTotem())
 691                             continue;
 692
 693                         Unit* check = i_originalCaster->GetCharmerOrOwnerOrSelf();
 694
 695                         if( check->GetTypeId()==TYPEID_PLAYER )
 696                         {
 697                             if (check->IsFriendlyTo( itr->getSource() ))
 698                                 continue;
 699                         }
 700                         else
 701                         {
 702                             if (!check->IsHostileTo( itr->getSource() ))
 703                                 continue;
 704                         }
 705                     }
 706                     break;
 707                     default: continue;
 708                 }
 709
 710                 // we don't need to check InMap here, it's already done some lines above
 711                 switch(i_push_type)
 712                 {
 713                     case PUSH_IN_FRONT:
 714                         if(i_spell.GetCaster()->isInFront((Unit*)(itr->getSource()), i_radius, 2*M_PI/3 ))
 715                             i_data->push_back(itr->getSource());
 716                         break;
 717                     case PUSH_IN_FRONT_90:
 718                         if(i_spell.GetCaster()->isInFront((Unit*)(itr->getSource()), i_radius, M_PI/2 ))
 719                             i_data->push_back(itr->getSource());
 720                         break;
 721                     case PUSH_IN_FRONT_30:
 722                         if(i_spell.GetCaster()->isInFront((Unit*)(itr->getSource()), i_radius, M_PI/6 ))
 723                             i_data->push_back(itr->getSource());
 724                         break;
 725                     case PUSH_IN_FRONT_15:
 726                         if(i_spell.GetCaster()->isInFront((Unit*)(itr->getSource()), i_radius, M_PI/12 ))
 727                             i_data->push_back(itr->getSource());
 728                         break;
 729                     case PUSH_IN_BACK:
 730                         if(i_spell.GetCaster()->isInBack((Unit*)(itr->getSource()), i_radius, 2*M_PI/3 ))
 731                             i_data->push_back(itr->getSource());
 732                         break;
 733                     case PUSH_SELF_CENTER:
 734                         if(i_spell.GetCaster()->IsWithinDist((Unit*)(itr->getSource()), i_radius))
 735                             i_data->push_back(itr->getSource());
 736                         break;
 737                     case PUSH_DEST_CENTER:
 738                         if(itr->getSource()->IsWithinDist3d(i_spell.m_targets.m_destX, i_spell.m_targets.m_destY, i_spell.m_targets.m_destZ,i_radius))
 739                             i_data->push_back(itr->getSource());
 740                         break;
 741                     case PUSH_TARGET_CENTER:
 742                         if(i_spell.m_targets.getUnitTarget()->IsWithinDist((Unit*)(itr->getSource()), i_radius))
 743                             i_data->push_back(itr->getSource());
 744                         break;
 745                 }
 746             }
 747         }
 748
 749         #ifdef WIN32
 750         template<> inline void Visit(CorpseMapType & ) {}
 751         template<> inline void Visit(GameObjectMapType & ) {}
 752         template<> inline void Visit(DynamicObjectMapType & ) {}
 753         #endif
 754     };
 755
 756     #ifndef WIN32
 757     template<> inline void SpellNotifierCreatureAndPlayer::Visit(CorpseMapType& ) {}
 758     template<> inline void SpellNotifierCreatureAndPlayer::Visit(GameObjectMapType& ) {}
 759     template<> inline void SpellNotifierCreatureAndPlayer::Visit(DynamicObjectMapType& ) {}
 760     #endif
 761 }
 762
 763 typedef void(Spell::*pEffect)(uint32 i);
 764
 765 class SpellEvent : public BasicEvent
 766 {
 767     public:
 768         SpellEvent(Spell* spell);
 769         virtual ~SpellEvent();
 770
 771         virtual bool Execute(uint64 e_time, uint32 p_time);
 772         virtual void Abort(uint64 e_time);
 773         virtual bool IsDeletable() const;
 774     protected:
 775         Spell* m_Spell;
 776 };
 777 #endif