?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[9058] Implement spell 7057
[getmangos.git] / src / game / SpellAuras.cpp
blob3e4469c264b274403af04c4eccd4f35aec3b2e76
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 #include "Common.h"
20 #include "Database/DatabaseEnv.h"
21 #include "WorldPacket.h"
22 #include "WorldSession.h"
23 #include "Opcodes.h"
24 #include "Log.h"
25 #include "UpdateMask.h"
26 #include "World.h"
27 #include "ObjectMgr.h"
28 #include "SpellMgr.h"
29 #include "Player.h"
30 #include "Unit.h"
31 #include "Spell.h"
32 #include "DynamicObject.h"
33 #include "Group.h"
34 #include "UpdateData.h"
35 #include "ObjectAccessor.h"
36 #include "Policies/SingletonImp.h"
37 #include "Totem.h"
38 #include "Creature.h"
39 #include "Formulas.h"
40 #include "BattleGround.h"
41 #include "CreatureAI.h"
42 #include "ScriptCalls.h"
43 #include "Util.h"
44 #include "GridNotifiers.h"
45 #include "GridNotifiersImpl.h"
46 #include "Vehicle.h"
47 #include "CellImpl.h"
48
49 #define NULL_AURA_SLOT 0xFF
50
51 pAuraHandler AuraHandler[TOTAL_AURAS]=
52 {
53 &Aura::HandleNULL, // 0 SPELL_AURA_NONE
54 &Aura::HandleBindSight, // 1 SPELL_AURA_BIND_SIGHT
55 &Aura::HandleModPossess, // 2 SPELL_AURA_MOD_POSSESS
56 &Aura::HandlePeriodicDamage, // 3 SPELL_AURA_PERIODIC_DAMAGE
57 &Aura::HandleAuraDummy, // 4 SPELL_AURA_DUMMY
58 &Aura::HandleModConfuse, // 5 SPELL_AURA_MOD_CONFUSE
59 &Aura::HandleModCharm, // 6 SPELL_AURA_MOD_CHARM
60 &Aura::HandleModFear, // 7 SPELL_AURA_MOD_FEAR
61 &Aura::HandlePeriodicHeal, // 8 SPELL_AURA_PERIODIC_HEAL
62 &Aura::HandleModAttackSpeed, // 9 SPELL_AURA_MOD_ATTACKSPEED
63 &Aura::HandleModThreat, // 10 SPELL_AURA_MOD_THREAT
64 &Aura::HandleModTaunt, // 11 SPELL_AURA_MOD_TAUNT
65 &Aura::HandleAuraModStun, // 12 SPELL_AURA_MOD_STUN
66 &Aura::HandleModDamageDone, // 13 SPELL_AURA_MOD_DAMAGE_DONE
67 &Aura::HandleNoImmediateEffect, // 14 SPELL_AURA_MOD_DAMAGE_TAKEN implemented in Unit::MeleeDamageBonus and Unit::SpellBaseDamageBonusForVictim
68 &Aura::HandleNoImmediateEffect, // 15 SPELL_AURA_DAMAGE_SHIELD implemented in Unit::DealMeleeDamage
69 &Aura::HandleModStealth, // 16 SPELL_AURA_MOD_STEALTH
70 &Aura::HandleNoImmediateEffect, // 17 SPELL_AURA_MOD_STEALTH_DETECT implemented in Unit::isVisibleForOrDetect
71 &Aura::HandleInvisibility, // 18 SPELL_AURA_MOD_INVISIBILITY
72 &Aura::HandleInvisibilityDetect, // 19 SPELL_AURA_MOD_INVISIBILITY_DETECTION
73 &Aura::HandleAuraModTotalHealthPercentRegen, // 20 SPELL_AURA_OBS_MOD_HEALTH
74 &Aura::HandleAuraModTotalManaPercentRegen, // 21 SPELL_AURA_OBS_MOD_MANA
75 &Aura::HandleAuraModResistance, // 22 SPELL_AURA_MOD_RESISTANCE
76 &Aura::HandlePeriodicTriggerSpell, // 23 SPELL_AURA_PERIODIC_TRIGGER_SPELL
77 &Aura::HandlePeriodicEnergize, // 24 SPELL_AURA_PERIODIC_ENERGIZE
78 &Aura::HandleAuraModPacify, // 25 SPELL_AURA_MOD_PACIFY
79 &Aura::HandleAuraModRoot, // 26 SPELL_AURA_MOD_ROOT
80 &Aura::HandleAuraModSilence, // 27 SPELL_AURA_MOD_SILENCE
81 &Aura::HandleNoImmediateEffect, // 28 SPELL_AURA_REFLECT_SPELLS implement in Unit::SpellHitResult
82 &Aura::HandleAuraModStat, // 29 SPELL_AURA_MOD_STAT
83 &Aura::HandleAuraModSkill, // 30 SPELL_AURA_MOD_SKILL
84 &Aura::HandleAuraModIncreaseSpeed, // 31 SPELL_AURA_MOD_INCREASE_SPEED
85 &Aura::HandleAuraModIncreaseMountedSpeed, // 32 SPELL_AURA_MOD_INCREASE_MOUNTED_SPEED
86 &Aura::HandleAuraModDecreaseSpeed, // 33 SPELL_AURA_MOD_DECREASE_SPEED
87 &Aura::HandleAuraModIncreaseHealth, // 34 SPELL_AURA_MOD_INCREASE_HEALTH
88 &Aura::HandleAuraModIncreaseEnergy, // 35 SPELL_AURA_MOD_INCREASE_ENERGY
89 &Aura::HandleAuraModShapeshift, // 36 SPELL_AURA_MOD_SHAPESHIFT
90 &Aura::HandleAuraModEffectImmunity, // 37 SPELL_AURA_EFFECT_IMMUNITY
91 &Aura::HandleAuraModStateImmunity, // 38 SPELL_AURA_STATE_IMMUNITY
92 &Aura::HandleAuraModSchoolImmunity, // 39 SPELL_AURA_SCHOOL_IMMUNITY
93 &Aura::HandleAuraModDmgImmunity, // 40 SPELL_AURA_DAMAGE_IMMUNITY
94 &Aura::HandleAuraModDispelImmunity, // 41 SPELL_AURA_DISPEL_IMMUNITY
95 &Aura::HandleAuraProcTriggerSpell, // 42 SPELL_AURA_PROC_TRIGGER_SPELL implemented in Unit::ProcDamageAndSpellFor and Unit::HandleProcTriggerSpell
96 &Aura::HandleNoImmediateEffect, // 43 SPELL_AURA_PROC_TRIGGER_DAMAGE implemented in Unit::ProcDamageAndSpellFor
97 &Aura::HandleAuraTrackCreatures, // 44 SPELL_AURA_TRACK_CREATURES
98 &Aura::HandleAuraTrackResources, // 45 SPELL_AURA_TRACK_RESOURCES
99 &Aura::HandleUnused, // 46 SPELL_AURA_46 (used in test spells 54054 and 54058, and spell 48050) (3.0.8a-3.2.2a)
100 &Aura::HandleAuraModParryPercent, // 47 SPELL_AURA_MOD_PARRY_PERCENT
101 &Aura::HandleNULL, // 48 SPELL_AURA_48 spell Napalm (area damage spell with additional delayed damage effect)
102 &Aura::HandleAuraModDodgePercent, // 49 SPELL_AURA_MOD_DODGE_PERCENT
103 &Aura::HandleNoImmediateEffect, // 50 SPELL_AURA_MOD_CRITICAL_HEALING_AMOUNT implemented in Unit::SpellCriticalHealingBonus
104 &Aura::HandleAuraModBlockPercent, // 51 SPELL_AURA_MOD_BLOCK_PERCENT
105 &Aura::HandleAuraModCritPercent, // 52 SPELL_AURA_MOD_CRIT_PERCENT
106 &Aura::HandlePeriodicLeech, // 53 SPELL_AURA_PERIODIC_LEECH
107 &Aura::HandleModHitChance, // 54 SPELL_AURA_MOD_HIT_CHANCE
108 &Aura::HandleModSpellHitChance, // 55 SPELL_AURA_MOD_SPELL_HIT_CHANCE
109 &Aura::HandleAuraTransform, // 56 SPELL_AURA_TRANSFORM
110 &Aura::HandleModSpellCritChance, // 57 SPELL_AURA_MOD_SPELL_CRIT_CHANCE
111 &Aura::HandleAuraModIncreaseSwimSpeed, // 58 SPELL_AURA_MOD_INCREASE_SWIM_SPEED
112 &Aura::HandleNoImmediateEffect, // 59 SPELL_AURA_MOD_DAMAGE_DONE_CREATURE implemented in Unit::MeleeDamageBonus and Unit::SpellDamageBonus
113 &Aura::HandleAuraModPacifyAndSilence, // 60 SPELL_AURA_MOD_PACIFY_SILENCE
114 &Aura::HandleAuraModScale, // 61 SPELL_AURA_MOD_SCALE
115 &Aura::HandlePeriodicHealthFunnel, // 62 SPELL_AURA_PERIODIC_HEALTH_FUNNEL
116 &Aura::HandleUnused, // 63 unused (3.0.8a-3.2.2a) old SPELL_AURA_PERIODIC_MANA_FUNNEL
117 &Aura::HandlePeriodicManaLeech, // 64 SPELL_AURA_PERIODIC_MANA_LEECH
118 &Aura::HandleModCastingSpeed, // 65 SPELL_AURA_MOD_CASTING_SPEED_NOT_STACK
119 &Aura::HandleFeignDeath, // 66 SPELL_AURA_FEIGN_DEATH
120 &Aura::HandleAuraModDisarm, // 67 SPELL_AURA_MOD_DISARM
121 &Aura::HandleAuraModStalked, // 68 SPELL_AURA_MOD_STALKED
122 &Aura::HandleSchoolAbsorb, // 69 SPELL_AURA_SCHOOL_ABSORB implemented in Unit::CalcAbsorbResist
123 &Aura::HandleUnused, // 70 SPELL_AURA_EXTRA_ATTACKS Useless, used by only one spell 41560 that has only visual effect (3.2.2a)
124 &Aura::HandleModSpellCritChanceShool, // 71 SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL
125 &Aura::HandleModPowerCostPCT, // 72 SPELL_AURA_MOD_POWER_COST_SCHOOL_PCT
126 &Aura::HandleModPowerCost, // 73 SPELL_AURA_MOD_POWER_COST_SCHOOL
127 &Aura::HandleNoImmediateEffect, // 74 SPELL_AURA_REFLECT_SPELLS_SCHOOL implemented in Unit::SpellHitResult
128 &Aura::HandleNoImmediateEffect, // 75 SPELL_AURA_MOD_LANGUAGE implemented in WorldSession::HandleMessagechatOpcode
129 &Aura::HandleFarSight, // 76 SPELL_AURA_FAR_SIGHT
130 &Aura::HandleModMechanicImmunity, // 77 SPELL_AURA_MECHANIC_IMMUNITY
131 &Aura::HandleAuraMounted, // 78 SPELL_AURA_MOUNTED
132 &Aura::HandleModDamagePercentDone, // 79 SPELL_AURA_MOD_DAMAGE_PERCENT_DONE
133 &Aura::HandleModPercentStat, // 80 SPELL_AURA_MOD_PERCENT_STAT
134 &Aura::HandleNoImmediateEffect, // 81 SPELL_AURA_SPLIT_DAMAGE_PCT implemented in Unit::CalcAbsorbResist
135 &Aura::HandleWaterBreathing, // 82 SPELL_AURA_WATER_BREATHING
136 &Aura::HandleModBaseResistance, // 83 SPELL_AURA_MOD_BASE_RESISTANCE
137 &Aura::HandleModRegen, // 84 SPELL_AURA_MOD_REGEN
138 &Aura::HandleModPowerRegen, // 85 SPELL_AURA_MOD_POWER_REGEN
139 &Aura::HandleChannelDeathItem, // 86 SPELL_AURA_CHANNEL_DEATH_ITEM
140 &Aura::HandleNoImmediateEffect, // 87 SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN implemented in Unit::MeleeDamageBonus and Unit::SpellDamageBonus
141 &Aura::HandleNoImmediateEffect, // 88 SPELL_AURA_MOD_HEALTH_REGEN_PERCENT implemented in Player::RegenerateHealth
142 &Aura::HandlePeriodicDamagePCT, // 89 SPELL_AURA_PERIODIC_DAMAGE_PERCENT
143 &Aura::HandleUnused, // 90 unused (3.0.8a-3.2.2a) old SPELL_AURA_MOD_RESIST_CHANCE
144 &Aura::HandleNoImmediateEffect, // 91 SPELL_AURA_MOD_DETECT_RANGE implemented in Creature::GetAttackDistance
145 &Aura::HandlePreventFleeing, // 92 SPELL_AURA_PREVENTS_FLEEING
146 &Aura::HandleModUnattackable, // 93 SPELL_AURA_MOD_UNATTACKABLE
147 &Aura::HandleNoImmediateEffect, // 94 SPELL_AURA_INTERRUPT_REGEN implemented in Player::RegenerateAll
148 &Aura::HandleAuraGhost, // 95 SPELL_AURA_GHOST
149 &Aura::HandleNoImmediateEffect, // 96 SPELL_AURA_SPELL_MAGNET implemented in Unit::SelectMagnetTarget
150 &Aura::HandleManaShield, // 97 SPELL_AURA_MANA_SHIELD implemented in Unit::CalcAbsorbResist
151 &Aura::HandleAuraModSkill, // 98 SPELL_AURA_MOD_SKILL_TALENT
152 &Aura::HandleAuraModAttackPower, // 99 SPELL_AURA_MOD_ATTACK_POWER
153 &Aura::HandleUnused, //100 SPELL_AURA_AURAS_VISIBLE obsolete 3.x? all player can see all auras now, but still have 2 spells including GM-spell (1852,2855)
154 &Aura::HandleModResistancePercent, //101 SPELL_AURA_MOD_RESISTANCE_PCT
155 &Aura::HandleNoImmediateEffect, //102 SPELL_AURA_MOD_MELEE_ATTACK_POWER_VERSUS implemented in Unit::MeleeDamageBonus
156 &Aura::HandleAuraModTotalThreat, //103 SPELL_AURA_MOD_TOTAL_THREAT
157 &Aura::HandleAuraWaterWalk, //104 SPELL_AURA_WATER_WALK
158 &Aura::HandleAuraFeatherFall, //105 SPELL_AURA_FEATHER_FALL
159 &Aura::HandleAuraHover, //106 SPELL_AURA_HOVER
160 &Aura::HandleAddModifier, //107 SPELL_AURA_ADD_FLAT_MODIFIER
161 &Aura::HandleAddModifier, //108 SPELL_AURA_ADD_PCT_MODIFIER
162 &Aura::HandleAddTargetTrigger, //109 SPELL_AURA_ADD_TARGET_TRIGGER
163 &Aura::HandleModPowerRegenPCT, //110 SPELL_AURA_MOD_POWER_REGEN_PERCENT
164 &Aura::HandleNoImmediateEffect, //111 SPELL_AURA_ADD_CASTER_HIT_TRIGGER implemented in Unit::SelectMagnetTarget
165 &Aura::HandleNoImmediateEffect, //112 SPELL_AURA_OVERRIDE_CLASS_SCRIPTS implemented in diff functions.
166 &Aura::HandleNoImmediateEffect, //113 SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN implemented in Unit::MeleeDamageBonus
167 &Aura::HandleNoImmediateEffect, //114 SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN_PCT implemented in Unit::MeleeDamageBonus
168 &Aura::HandleNoImmediateEffect, //115 SPELL_AURA_MOD_HEALING implemented in Unit::SpellBaseHealingBonusForVictim
169 &Aura::HandleNoImmediateEffect, //116 SPELL_AURA_MOD_REGEN_DURING_COMBAT imppemented in Player::RegenerateAll and Player::RegenerateHealth
170 &Aura::HandleNoImmediateEffect, //117 SPELL_AURA_MOD_MECHANIC_RESISTANCE implemented in Unit::MagicSpellHitResult
171 &Aura::HandleNoImmediateEffect, //118 SPELL_AURA_MOD_HEALING_PCT implemented in Unit::SpellHealingBonus
172 &Aura::HandleUnused, //119 unused (3.0.8a-3.2.2a) old SPELL_AURA_SHARE_PET_TRACKING
173 &Aura::HandleAuraUntrackable, //120 SPELL_AURA_UNTRACKABLE
174 &Aura::HandleAuraEmpathy, //121 SPELL_AURA_EMPATHY
175 &Aura::HandleModOffhandDamagePercent, //122 SPELL_AURA_MOD_OFFHAND_DAMAGE_PCT
176 &Aura::HandleModTargetResistance, //123 SPELL_AURA_MOD_TARGET_RESISTANCE
177 &Aura::HandleAuraModRangedAttackPower, //124 SPELL_AURA_MOD_RANGED_ATTACK_POWER
178 &Aura::HandleNoImmediateEffect, //125 SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN implemented in Unit::MeleeDamageBonus
179 &Aura::HandleNoImmediateEffect, //126 SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN_PCT implemented in Unit::MeleeDamageBonus
180 &Aura::HandleNoImmediateEffect, //127 SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS implemented in Unit::MeleeDamageBonus
181 &Aura::HandleModPossessPet, //128 SPELL_AURA_MOD_POSSESS_PET
182 &Aura::HandleAuraModIncreaseSpeed, //129 SPELL_AURA_MOD_SPEED_ALWAYS
183 &Aura::HandleAuraModIncreaseMountedSpeed, //130 SPELL_AURA_MOD_MOUNTED_SPEED_ALWAYS
184 &Aura::HandleNoImmediateEffect, //131 SPELL_AURA_MOD_RANGED_ATTACK_POWER_VERSUS implemented in Unit::MeleeDamageBonus
185 &Aura::HandleAuraModIncreaseEnergyPercent, //132 SPELL_AURA_MOD_INCREASE_ENERGY_PERCENT
186 &Aura::HandleAuraModIncreaseHealthPercent, //133 SPELL_AURA_MOD_INCREASE_HEALTH_PERCENT
187 &Aura::HandleAuraModRegenInterrupt, //134 SPELL_AURA_MOD_MANA_REGEN_INTERRUPT
188 &Aura::HandleModHealingDone, //135 SPELL_AURA_MOD_HEALING_DONE
189 &Aura::HandleNoImmediateEffect, //136 SPELL_AURA_MOD_HEALING_DONE_PERCENT implemented in Unit::SpellHealingBonus
190 &Aura::HandleModTotalPercentStat, //137 SPELL_AURA_MOD_TOTAL_STAT_PERCENTAGE
191 &Aura::HandleHaste, //138 SPELL_AURA_MOD_HASTE
192 &Aura::HandleForceReaction, //139 SPELL_AURA_FORCE_REACTION
193 &Aura::HandleAuraModRangedHaste, //140 SPELL_AURA_MOD_RANGED_HASTE
194 &Aura::HandleRangedAmmoHaste, //141 SPELL_AURA_MOD_RANGED_AMMO_HASTE
195 &Aura::HandleAuraModBaseResistancePCT, //142 SPELL_AURA_MOD_BASE_RESISTANCE_PCT
196 &Aura::HandleAuraModResistanceExclusive, //143 SPELL_AURA_MOD_RESISTANCE_EXCLUSIVE
197 &Aura::HandleAuraSafeFall, //144 SPELL_AURA_SAFE_FALL implemented in WorldSession::HandleMovementOpcodes
198 &Aura::HandleAuraModPetTalentsPoints, //145 SPELL_AURA_MOD_PET_TALENT_POINTS
199 &Aura::HandleNoImmediateEffect, //146 SPELL_AURA_ALLOW_TAME_PET_TYPE implemented in Player::CanTameExoticPets
200 &Aura::HandleModMechanicImmunityMask, //147 SPELL_AURA_MECHANIC_IMMUNITY_MASK implemented in Unit::IsImmunedToSpell and Unit::IsImmunedToSpellEffect (check part)
201 &Aura::HandleAuraRetainComboPoints, //148 SPELL_AURA_RETAIN_COMBO_POINTS
202 &Aura::HandleNoImmediateEffect, //149 SPELL_AURA_REDUCE_PUSHBACK implemented in Spell::Delayed and Spell::DelayedChannel
203 &Aura::HandleShieldBlockValue, //150 SPELL_AURA_MOD_SHIELD_BLOCKVALUE_PCT
204 &Aura::HandleAuraTrackStealthed, //151 SPELL_AURA_TRACK_STEALTHED
205 &Aura::HandleNoImmediateEffect, //152 SPELL_AURA_MOD_DETECTED_RANGE implemented in Creature::GetAttackDistance
206 &Aura::HandleNoImmediateEffect, //153 SPELL_AURA_SPLIT_DAMAGE_FLAT implemented in Unit::CalcAbsorbResist
207 &Aura::HandleNoImmediateEffect, //154 SPELL_AURA_MOD_STEALTH_LEVEL implemented in Unit::isVisibleForOrDetect
208 &Aura::HandleNoImmediateEffect, //155 SPELL_AURA_MOD_WATER_BREATHING implemented in Player::getMaxTimer
209 &Aura::HandleNoImmediateEffect, //156 SPELL_AURA_MOD_REPUTATION_GAIN implemented in Player::CalculateReputationGain
210 &Aura::HandleUnused, //157 SPELL_AURA_PET_DAMAGE_MULTI (single test like spell 20782, also single for 214 aura)
211 &Aura::HandleShieldBlockValue, //158 SPELL_AURA_MOD_SHIELD_BLOCKVALUE
212 &Aura::HandleNoImmediateEffect, //159 SPELL_AURA_NO_PVP_CREDIT implemented in Player::RewardHonor
213 &Aura::HandleNoImmediateEffect, //160 SPELL_AURA_MOD_AOE_AVOIDANCE implemented in Unit::MagicSpellHitResult
214 &Aura::HandleNoImmediateEffect, //161 SPELL_AURA_MOD_HEALTH_REGEN_IN_COMBAT implemented in Player::RegenerateAll and Player::RegenerateHealth
215 &Aura::HandleAuraPowerBurn, //162 SPELL_AURA_POWER_BURN_MANA
216 &Aura::HandleNoImmediateEffect, //163 SPELL_AURA_MOD_CRIT_DAMAGE_BONUS_MELEE implememnted in Unit::CalculateMeleeDamage and Unit::SpellCriticalDamageBonus
217 &Aura::HandleUnused, //164 unused (3.0.8a-3.2.2a), only one test spell 10654
218 &Aura::HandleNoImmediateEffect, //165 SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS implemented in Unit::MeleeDamageBonus
219 &Aura::HandleAuraModAttackPowerPercent, //166 SPELL_AURA_MOD_ATTACK_POWER_PCT
220 &Aura::HandleAuraModRangedAttackPowerPercent, //167 SPELL_AURA_MOD_RANGED_ATTACK_POWER_PCT
221 &Aura::HandleNoImmediateEffect, //168 SPELL_AURA_MOD_DAMAGE_DONE_VERSUS implemented in Unit::SpellDamageBonus, Unit::MeleeDamageBonus
222 &Aura::HandleNoImmediateEffect, //169 SPELL_AURA_MOD_CRIT_PERCENT_VERSUS implemented in Unit::DealDamageBySchool, Unit::DoAttackDamage, Unit::SpellCriticalBonus
223 &Aura::HandleNULL, //170 SPELL_AURA_DETECT_AMORE different spells that ignore transformation effects
224 &Aura::HandleAuraModIncreaseSpeed, //171 SPELL_AURA_MOD_SPEED_NOT_STACK
225 &Aura::HandleAuraModIncreaseMountedSpeed, //172 SPELL_AURA_MOD_MOUNTED_SPEED_NOT_STACK
226 &Aura::HandleUnused, //173 unused (3.0.8a-3.2.2a) no spells, old SPELL_AURA_ALLOW_CHAMPION_SPELLS only for Proclaim Champion spell
227 &Aura::HandleModSpellDamagePercentFromStat, //174 SPELL_AURA_MOD_SPELL_DAMAGE_OF_STAT_PERCENT implemented in Unit::SpellBaseDamageBonus
228 &Aura::HandleModSpellHealingPercentFromStat, //175 SPELL_AURA_MOD_SPELL_HEALING_OF_STAT_PERCENT implemented in Unit::SpellBaseHealingBonus
229 &Aura::HandleSpiritOfRedemption, //176 SPELL_AURA_SPIRIT_OF_REDEMPTION only for Spirit of Redemption spell, die at aura end
230 &Aura::HandleNULL, //177 SPELL_AURA_AOE_CHARM (22 spells)
231 &Aura::HandleNoImmediateEffect, //178 SPELL_AURA_MOD_DEBUFF_RESISTANCE implemented in Unit::MagicSpellHitResult
232 &Aura::HandleNoImmediateEffect, //179 SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE implemented in Unit::SpellCriticalBonus
233 &Aura::HandleNoImmediateEffect, //180 SPELL_AURA_MOD_FLAT_SPELL_DAMAGE_VERSUS implemented in Unit::SpellDamageBonus
234 &Aura::HandleUnused, //181 unused (3.0.8a-3.2.2a) old SPELL_AURA_MOD_FLAT_SPELL_CRIT_DAMAGE_VERSUS
235 &Aura::HandleAuraModResistenceOfStatPercent, //182 SPELL_AURA_MOD_RESISTANCE_OF_STAT_PERCENT
236 &Aura::HandleNoImmediateEffect, //183 SPELL_AURA_MOD_CRITICAL_THREAT only used in 28746, implemented in ThreatCalcHelper::calcThreat
237 &Aura::HandleNoImmediateEffect, //184 SPELL_AURA_MOD_ATTACKER_MELEE_HIT_CHANCE implemented in Unit::RollMeleeOutcomeAgainst
238 &Aura::HandleNoImmediateEffect, //185 SPELL_AURA_MOD_ATTACKER_RANGED_HIT_CHANCE implemented in Unit::RollMeleeOutcomeAgainst
239 &Aura::HandleNoImmediateEffect, //186 SPELL_AURA_MOD_ATTACKER_SPELL_HIT_CHANCE implemented in Unit::MagicSpellHitResult
240 &Aura::HandleNoImmediateEffect, //187 SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_CHANCE implemented in Unit::GetUnitCriticalChance
241 &Aura::HandleNoImmediateEffect, //188 SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_CHANCE implemented in Unit::GetUnitCriticalChance
242 &Aura::HandleModRating, //189 SPELL_AURA_MOD_RATING
243 &Aura::HandleNoImmediateEffect, //190 SPELL_AURA_MOD_FACTION_REPUTATION_GAIN implemented in Player::CalculateReputationGain
244 &Aura::HandleAuraModUseNormalSpeed, //191 SPELL_AURA_USE_NORMAL_MOVEMENT_SPEED
245 &Aura::HandleModMeleeRangedSpeedPct, //192 SPELL_AURA_HASTE_MELEE
246 &Aura::HandleModCombatSpeedPct, //193 SPELL_AURA_MELEE_SLOW (in fact combat (any type attack) speed pct)
247 &Aura::HandleNoImmediateEffect, //194 SPELL_AURA_MOD_IGNORE_ABSORB_SCHOOL implement in Unit::CalcNotIgnoreAbsorbDamage
248 &Aura::HandleNoImmediateEffect, //195 SPELL_AURA_MOD_IGNORE_ABSORB_FOR_SPELL implement in Unit::CalcNotIgnoreAbsorbDamage
249 &Aura::HandleNULL, //196 SPELL_AURA_MOD_COOLDOWN (single spell 24818 in 3.2.2a)
250 &Aura::HandleNoImmediateEffect, //197 SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE implemented in Unit::SpellCriticalBonus Unit::GetUnitCriticalChance
251 &Aura::HandleUnused, //198 unused (3.0.8a-3.2.2a) old SPELL_AURA_MOD_ALL_WEAPON_SKILLS
252 &Aura::HandleNoImmediateEffect, //199 SPELL_AURA_MOD_INCREASES_SPELL_PCT_TO_HIT implemented in Unit::MagicSpellHitResult
253 &Aura::HandleNoImmediateEffect, //200 SPELL_AURA_MOD_KILL_XP_PCT implemented in Player::GiveXP
254 &Aura::HandleAuraAllowFlight, //201 SPELL_AURA_FLY this aura enable flight mode...
255 &Aura::HandleNoImmediateEffect, //202 SPELL_AURA_CANNOT_BE_DODGED implemented in Unit::RollPhysicalOutcomeAgainst
256 &Aura::HandleNoImmediateEffect, //203 SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE implemented in Unit::CalculateMeleeDamage and Unit::SpellCriticalDamageBonus
257 &Aura::HandleNoImmediateEffect, //204 SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE implemented in Unit::CalculateMeleeDamage and Unit::SpellCriticalDamageBonus
258 &Aura::HandleNoImmediateEffect, //205 SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_DAMAGE implemented in Unit::SpellCriticalDamageBonus
259 &Aura::HandleNULL, //206 SPELL_AURA_MOD_SPEED_MOUNTED
260 &Aura::HandleAuraModIncreaseFlightSpeed, //207 SPELL_AURA_MOD_INCREASE_FLIGHT_SPEED
261 &Aura::HandleAuraModIncreaseFlightSpeed, //208 SPELL_AURA_MOD_SPEED_FLIGHT, used only in spell: Flight Form (Passive)
262 &Aura::HandleAuraModIncreaseFlightSpeed, //209 SPELL_AURA_MOD_FLIGHT_SPEED_ALWAYS
263 &Aura::HandleNULL, //210 "Increase flight speed by"
264 &Aura::HandleAuraModIncreaseFlightSpeed, //211 SPELL_AURA_MOD_FLIGHT_SPEED_NOT_STACK
265 &Aura::HandleAuraModRangedAttackPowerOfStatPercent, //212 SPELL_AURA_MOD_RANGED_ATTACK_POWER_OF_STAT_PERCENT
266 &Aura::HandleNoImmediateEffect, //213 SPELL_AURA_MOD_RAGE_FROM_DAMAGE_DEALT implemented in Player::RewardRage
267 &Aura::HandleUnused, //214 Tamed Pet Passive (single test like spell 20782, also single for 157 aura)
268 &Aura::HandleArenaPreparation, //215 SPELL_AURA_ARENA_PREPARATION
269 &Aura::HandleModCastingSpeed, //216 SPELL_AURA_HASTE_SPELLS
270 &Aura::HandleUnused, //217 unused (3.0.8a-3.2.2a)
271 &Aura::HandleAuraModRangedHaste, //218 SPELL_AURA_HASTE_RANGED
272 &Aura::HandleModManaRegen, //219 SPELL_AURA_MOD_MANA_REGEN_FROM_STAT
273 &Aura::HandleModRatingFromStat, //220 SPELL_AURA_MOD_RATING_FROM_STAT
274 &Aura::HandleNULL, //221 ignored
275 &Aura::HandleUnused, //222 unused (3.0.8a-3.2.2a) only for spell 44586 that not used in real spell cast
276 &Aura::HandleNULL, //223 dummy code (cast damage spell to attacker) and another dymmy (jump to another nearby raid member)
277 &Aura::HandleUnused, //224 unused (3.0.8a-3.2.2a)
278 &Aura::HandleNoImmediateEffect, //225 SPELL_AURA_PRAYER_OF_MENDING
279 &Aura::HandleAuraPeriodicDummy, //226 SPELL_AURA_PERIODIC_DUMMY
280 &Aura::HandlePeriodicTriggerSpellWithValue, //227 SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE
281 &Aura::HandleNoImmediateEffect, //228 SPELL_AURA_DETECT_STEALTH
282 &Aura::HandleNoImmediateEffect, //229 SPELL_AURA_MOD_AOE_DAMAGE_AVOIDANCE implemented in Unit::SpellDamageBonus
283 &Aura::HandleAuraModIncreaseMaxHealth, //230 Commanding Shout
284 &Aura::HandleNoImmediateEffect, //231 SPELL_AURA_PROC_TRIGGER_SPELL_WITH_VALUE
285 &Aura::HandleNoImmediateEffect, //232 SPELL_AURA_MECHANIC_DURATION_MOD implement in Unit::CalculateSpellDuration
286 &Aura::HandleNULL, //233 set model id to the one of the creature with id m_modifier.m_miscvalue
287 &Aura::HandleNoImmediateEffect, //234 SPELL_AURA_MECHANIC_DURATION_MOD_NOT_STACK implement in Unit::CalculateSpellDuration
288 &Aura::HandleAuraModDispelResist, //235 SPELL_AURA_MOD_DISPEL_RESIST implement in Unit::MagicSpellHitResult
289 &Aura::HandleAuraControlVehicle, //236 SPELL_AURA_CONTROL_VEHICLE
290 &Aura::HandleModSpellDamagePercentFromAttackPower, //237 SPELL_AURA_MOD_SPELL_DAMAGE_OF_ATTACK_POWER implemented in Unit::SpellBaseDamageBonus
291 &Aura::HandleModSpellHealingPercentFromAttackPower, //238 SPELL_AURA_MOD_SPELL_HEALING_OF_ATTACK_POWER implemented in Unit::SpellBaseHealingBonus
292 &Aura::HandleAuraModScale, //239 SPELL_AURA_MOD_SCALE_2 only in Noggenfogger Elixir (16595) before 2.3.0 aura 61
293 &Aura::HandleAuraModExpertise, //240 SPELL_AURA_MOD_EXPERTISE
294 &Aura::HandleForceMoveForward, //241 Forces the player to move forward
295 &Aura::HandleUnused, //242 SPELL_AURA_MOD_SPELL_DAMAGE_FROM_HEALING (only 2 test spels in 3.2.2a)
296 &Aura::HandleNULL, //243 faction reaction override spells
297 &Aura::HandleComprehendLanguage, //244 SPELL_AURA_COMPREHEND_LANGUAGE
298 &Aura::HandleNoImmediateEffect, //245 SPELL_AURA_MOD_DURATION_OF_MAGIC_EFFECTS implemented in Unit::CalculateSpellDuration
299 &Aura::HandleNoImmediateEffect, //246 SPELL_AURA_MOD_DURATION_OF_EFFECTS_BY_DISPEL implemented in Unit::CalculateSpellDuration
300 &Aura::HandleNULL, //247 target to become a clone of the caster
301 &Aura::HandleNoImmediateEffect, //248 SPELL_AURA_MOD_COMBAT_RESULT_CHANCE implemented in Unit::RollMeleeOutcomeAgainst
302 &Aura::HandleAuraConvertRune, //249 SPELL_AURA_CONVERT_RUNE
303 &Aura::HandleAuraModIncreaseHealth, //250 SPELL_AURA_MOD_INCREASE_HEALTH_2
304 &Aura::HandleNULL, //251 SPELL_AURA_MOD_ENEMY_DODGE
305 &Aura::HandleNULL, //252 haste all?
306 &Aura::HandleNULL, //253 SPELL_AURA_MOD_BLOCK_CRIT_CHANCE
307 &Aura::HandleNULL, //254 SPELL_AURA_MOD_DISARM_SHIELD disarm Shield
308 &Aura::HandleNoImmediateEffect, //255 SPELL_AURA_MOD_MECHANIC_DAMAGE_TAKEN_PERCENT implemented in Unit::SpellDamageBonus
309 &Aura::HandleNoReagentUseAura, //256 SPELL_AURA_NO_REAGENT_USE Use SpellClassMask for spell select
310 &Aura::HandleNULL, //257 SPELL_AURA_MOD_TARGET_RESIST_BY_SPELL_CLASS Use SpellClassMask for spell select
311 &Aura::HandleNULL, //258 SPELL_AURA_MOD_SPELL_VISUAL
312 &Aura::HandleNULL, //259 corrupt healing over time spell
313 &Aura::HandleNoImmediateEffect, //260 SPELL_AURA_SCREEN_EFFECT (miscvalue = id in ScreenEffect.dbc) not required any code
314 &Aura::HandlePhase, //261 SPELL_AURA_PHASE undetectable invisibility? implemented in Unit::isVisibleForOrDetect
315 &Aura::HandleNULL, //262 ignore combat/aura state?
316 &Aura::HandleAllowOnlyAbility, //263 SPELL_AURA_ALLOW_ONLY_ABILITY player can use only abilities set in SpellClassMask
317 &Aura::HandleUnused, //264 unused (3.0.8a-3.2.2a)
318 &Aura::HandleUnused, //265 unused (3.0.8a-3.2.2a)
319 &Aura::HandleUnused, //266 unused (3.0.8a-3.2.2a)
320 &Aura::HandleNoImmediateEffect, //267 SPELL_AURA_MOD_IMMUNE_AURA_APPLY_SCHOOL implemented in Unit::IsImmunedToSpellEffect
321 &Aura::HandleAuraModAttackPowerOfStatPercent, //268 SPELL_AURA_MOD_ATTACK_POWER_OF_STAT_PERCENT
322 &Aura::HandleNoImmediateEffect, //269 SPELL_AURA_MOD_IGNORE_DAMAGE_REDUCTION_SCHOOL implemented in Unit::CalcNotIgnoreDamageRedunction
323 &Aura::HandleUnused, //270 SPELL_AURA_MOD_IGNORE_TARGET_RESIST (unused in 3.2.2a)
324 &Aura::HandleNoImmediateEffect, //271 SPELL_AURA_MOD_DAMAGE_FROM_CASTER implemented in Unit::SpellDamageBonus
325 &Aura::HandleNoImmediateEffect, //272 SPELL_AURA_MAELSTROM_WEAPON (unclear use for aura, it used in (3.2.2a...3.3.0) in single spell 53817 that spellmode stacked and charged spell expected to be drop as stack
326 &Aura::HandleNoImmediateEffect, //273 SPELL_AURA_X_RAY (client side implementation)
327 &Aura::HandleNULL, //274 proc free shot?
328 &Aura::HandleNoImmediateEffect, //275 SPELL_AURA_MOD_IGNORE_SHAPESHIFT Use SpellClassMask for spell select
329 &Aura::HandleNULL, //276 mod damage % mechanic?
330 &Aura::HandleNoImmediateEffect, //277 SPELL_AURA_MOD_MAX_AFFECTED_TARGETS Use SpellClassMask for spell select
331 &Aura::HandleNULL, //278 SPELL_AURA_MOD_DISARM_RANGED disarm ranged weapon
332 &Aura::HandleNULL, //279 visual effects? 58836 and 57507
333 &Aura::HandleModTargetArmorPct, //280 SPELL_AURA_MOD_TARGET_ARMOR_PCT
334 &Aura::HandleNoImmediateEffect, //281 SPELL_AURA_MOD_HONOR_GAIN implemented in Player::RewardHonor
335 &Aura::HandleAuraIncreaseBaseHealthPercent, //282 SPELL_AURA_INCREASE_BASE_HEALTH_PERCENT
336 &Aura::HandleNoImmediateEffect, //283 SPELL_AURA_MOD_HEALING_RECEIVED implemented in Unit::SpellHealingBonus
337 &Aura::HandleNULL, //284 51 spells
338 &Aura::HandleAuraModAttackPowerOfArmor, //285 SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR implemented in Player::UpdateAttackPowerAndDamage
339 &Aura::HandleNoImmediateEffect, //286 SPELL_AURA_ABILITY_PERIODIC_CRIT implemented in Aura::IsCritFromAbilityAura called from Aura::PeriodicTick
340 &Aura::HandleNoImmediateEffect, //287 SPELL_AURA_DEFLECT_SPELLS implemented in Unit::MagicSpellHitResult and Unit::MeleeSpellHitResult
341 &Aura::HandleNULL, //288 increase parry/deflect, prevent attack (single spell used 67801)
342 &Aura::HandleUnused, //289 unused (3.2.2a)
343 &Aura::HandleAuraModAllCritChance, //290 SPELL_AURA_MOD_ALL_CRIT_CHANCE
344 &Aura::HandleNoImmediateEffect, //291 SPELL_AURA_MOD_QUEST_XP_PCT implemented in Player::GiveXP
345 &Aura::HandleNULL, //292 call stabled pet
346 &Aura::HandleNULL, //293 3 spells
347 &Aura::HandleNULL, //294 2 spells, possible prevent mana regen
348 &Aura::HandleUnused, //295 unused (3.2.2a)
349 &Aura::HandleNULL, //296 2 spells
350 &Aura::HandleNULL, //297 1 spell (counter spell school?)
351 &Aura::HandleUnused, //298 unused (3.2.2a)
352 &Aura::HandleUnused, //299 unused (3.2.2a)
353 &Aura::HandleNULL, //300 3 spells (share damage?)
354 &Aura::HandleNULL, //301 5 spells
355 &Aura::HandleUnused, //302 unused (3.2.2a)
356 &Aura::HandleNULL, //303 17 spells
357 &Aura::HandleNULL, //304 2 spells (alcohol effect?)
358 &Aura::HandleAuraModIncreaseSpeed, //305 SPELL_AURA_MOD_MINIMUM_SPEED
359 &Aura::HandleNULL //306 1 spell
360 };
361
362 static AuraType const frozenAuraTypes[] = { SPELL_AURA_MOD_ROOT, SPELL_AURA_MOD_STUN, SPELL_AURA_NONE };
363
364 Aura::Aura(SpellEntry const* spellproto, uint32 eff, int32 *currentBasePoints, Unit *target, Unit *caster, Item* castItem) :
365 m_spellmod(NULL), m_caster_guid(0), m_target(target), m_castItemGuid(castItem?castItem->GetGUID():0),
366 m_timeCla(1000), m_periodicTimer(0), m_removeMode(AURA_REMOVE_BY_DEFAULT), m_AuraDRGroup(DIMINISHING_NONE),
367 m_effIndex(eff), m_auraSlot(MAX_AURAS), m_auraFlags(AFLAG_NONE), m_auraLevel(1), m_procCharges(0), m_stackAmount(1),
368 m_positive(false), m_permanent(false), m_isPeriodic(false), m_isAreaAura(false), m_isPersistent(false),
369 m_isRemovedOnShapeLost(true), m_in_use(0), m_deleted(false)
370 {
371 assert(target);
372
373 assert(spellproto && spellproto == sSpellStore.LookupEntry( spellproto->Id ) && "`info` must be pointer to sSpellStore element");
374
375 m_spellProto = spellproto;
376
377 m_currentBasePoints = currentBasePoints ? *currentBasePoints : m_spellProto->EffectBasePoints[eff];
378
379 m_isPassive = IsPassiveSpell(GetId());
380 m_positive = IsPositiveEffect(GetId(), m_effIndex);
381
382 m_isSingleTargetAura = IsSingleTargetSpell(m_spellProto);
383
384 m_applyTime = time(NULL);
385
386 int32 damage;
387 if(!caster)
388 {
389 m_caster_guid = target->GetGUID();
390 damage = m_currentBasePoints+1; // stored value-1
391 m_maxduration = target->CalculateSpellDuration(m_spellProto, m_effIndex, target);
392 }
393 else
394 {
395 m_caster_guid = caster->GetGUID();
396
397 damage = caster->CalculateSpellDamage(m_spellProto,m_effIndex,m_currentBasePoints,target);
398 m_maxduration = caster->CalculateSpellDuration(m_spellProto, m_effIndex, target);
399
400 if (!damage && castItem && castItem->GetItemSuffixFactor())
401 {
402 ItemRandomSuffixEntry const *item_rand_suffix = sItemRandomSuffixStore.LookupEntry(abs(castItem->GetItemRandomPropertyId()));
403 if(item_rand_suffix)
404 {
405 for (int k = 0; k < 3; ++k)
406 {
407 SpellItemEnchantmentEntry const *pEnchant = sSpellItemEnchantmentStore.LookupEntry(item_rand_suffix->enchant_id[k]);
408 if(pEnchant)
409 {
410 for (int t = 0; t < 3; ++t)
411 if(pEnchant->spellid[t] == m_spellProto->Id)
412 {
413 damage = uint32((item_rand_suffix->prefix[k]*castItem->GetItemSuffixFactor()) / 10000 );
414 break;
415 }
416 }
417
418 if(damage)
419 break;
420 }
421 }
422 }
423 }
424
425 if(m_maxduration == -1 || m_isPassive && m_spellProto->DurationIndex == 0)
426 m_permanent = true;
427
428 Player* modOwner = caster ? caster->GetSpellModOwner() : NULL;
429
430 if(!m_permanent && modOwner)
431 {
432 modOwner->ApplySpellMod(GetId(), SPELLMOD_DURATION, m_maxduration);
433 // Get zero duration aura after - need set m_maxduration > 0 for apply/remove aura work
434 if (m_maxduration<=0)
435 m_maxduration = 1;
436 }
437
438 m_duration = m_maxduration;
439
440 sLog.outDebug("Aura: construct Spellid : %u, Aura : %u Duration : %d Target : %d Damage : %d", m_spellProto->Id, m_spellProto->EffectApplyAuraName[eff], m_maxduration, m_spellProto->EffectImplicitTargetA[eff],damage);
441
442 m_effIndex = eff;
443 SetModifier(AuraType(m_spellProto->EffectApplyAuraName[eff]), damage, m_spellProto->EffectAmplitude[eff], m_spellProto->EffectMiscValue[eff]);
444
445 // Apply periodic time mod
446 if(modOwner && m_modifier.periodictime)
447 modOwner->ApplySpellMod(GetId(), SPELLMOD_ACTIVATION_TIME, m_modifier.periodictime);
448
449 // Start periodic on next tick or at aura apply
450 if (!(m_spellProto->AttributesEx5 & SPELL_ATTR_EX5_START_PERIODIC_AT_APPLY))
451 m_periodicTimer += m_modifier.periodictime;
452
453 m_isDeathPersist = IsDeathPersistentSpell(m_spellProto);
454
455 m_procCharges = m_spellProto->procCharges;
456 if(modOwner)
457 modOwner->ApplySpellMod(GetId(), SPELLMOD_CHARGES, m_procCharges);
458
459 m_isRemovedOnShapeLost = (m_caster_guid==m_target->GetGUID() &&
460 m_spellProto->Stances &&
461 !(m_spellProto->AttributesEx2 & SPELL_ATTR_EX2_NOT_NEED_SHAPESHIFT) &&
462 !(m_spellProto->Attributes & SPELL_ATTR_NOT_SHAPESHIFT));
463
464 if (caster && m_spellProto->Id == 22959) // Improved Scorch
465 {
466 // Glyph of Improved Scorch
467 if (Aura* glyph = caster->GetDummyAura(56371))
468 m_stackAmount = glyph->GetModifier()->m_amount;
469 }
470 }
471
472 Aura::~Aura()
473 {
474 }
475
476 AreaAura::AreaAura(SpellEntry const* spellproto, uint32 eff, int32 *currentBasePoints, Unit *target,
477 Unit *caster, Item* castItem) : Aura(spellproto, eff, currentBasePoints, target, caster, castItem)
478 {
479 m_isAreaAura = true;
480
481 // caster==NULL in constructor args if target==caster in fact
482 Unit* caster_ptr = caster ? caster : target;
483
484 m_radius = GetSpellRadius(sSpellRadiusStore.LookupEntry(GetSpellProto()->EffectRadiusIndex[m_effIndex]));
485 if(Player* modOwner = caster_ptr->GetSpellModOwner())
486 modOwner->ApplySpellMod(GetId(), SPELLMOD_RADIUS, m_radius);
487
488 switch(spellproto->Effect[eff])
489 {
490 case SPELL_EFFECT_APPLY_AREA_AURA_PARTY:
491 m_areaAuraType = AREA_AURA_PARTY;
492 if (target->GetTypeId() == TYPEID_UNIT && ((Creature*)target)->isTotem())
493 m_modifier.m_auraname = SPELL_AURA_NONE;
494 break;
495 case SPELL_EFFECT_APPLY_AREA_AURA_RAID:
496 m_areaAuraType = AREA_AURA_RAID;
497 if (target->GetTypeId() == TYPEID_UNIT && ((Creature*)target)->isTotem())
498 m_modifier.m_auraname = SPELL_AURA_NONE;
499 // Light's Beacon not applied to caster itself (TODO: more generic check for another simialr spell if any?)
500 else if (target == caster_ptr && m_spellProto->Id == 53651)
501 m_modifier.m_auraname = SPELL_AURA_NONE;
502 break;
503 case SPELL_EFFECT_APPLY_AREA_AURA_FRIEND:
504 m_areaAuraType = AREA_AURA_FRIEND;
505 break;
506 case SPELL_EFFECT_APPLY_AREA_AURA_ENEMY:
507 m_areaAuraType = AREA_AURA_ENEMY;
508 if (target == caster_ptr)
509 m_modifier.m_auraname = SPELL_AURA_NONE; // Do not do any effect on self
510 break;
511 case SPELL_EFFECT_APPLY_AREA_AURA_PET:
512 m_areaAuraType = AREA_AURA_PET;
513 break;
514 case SPELL_EFFECT_APPLY_AREA_AURA_OWNER:
515 m_areaAuraType = AREA_AURA_OWNER;
516 if (target == caster_ptr)
517 m_modifier.m_auraname = SPELL_AURA_NONE;
518 break;
519 default:
520 sLog.outError("Wrong spell effect in AreaAura constructor");
521 ASSERT(false);
522 break;
523 }
524 }
525
526 AreaAura::~AreaAura()
527 {
528 }
529
530 PersistentAreaAura::PersistentAreaAura(SpellEntry const* spellproto, uint32 eff, int32 *currentBasePoints, Unit *target,
531 Unit *caster, Item* castItem) : Aura(spellproto, eff, currentBasePoints, target, caster, castItem)
532 {
533 m_isPersistent = true;
534 }
535
536 PersistentAreaAura::~PersistentAreaAura()
537 {
538 }
539
540 SingleEnemyTargetAura::SingleEnemyTargetAura(SpellEntry const* spellproto, uint32 eff, int32 *currentBasePoints, Unit *target,
541 Unit *caster, Item* castItem) : Aura(spellproto, eff, currentBasePoints, target, caster, castItem)
542 {
543 if (caster)
544 m_casters_target_guid = caster->GetTypeId()==TYPEID_PLAYER ? ((Player*)caster)->GetSelection() : caster->GetTargetGUID();
545 else
546 m_casters_target_guid = 0;
547 }
548
549 SingleEnemyTargetAura::~SingleEnemyTargetAura()
550 {
551 }
552
553 Unit* SingleEnemyTargetAura::GetTriggerTarget() const
554 {
555 return ObjectAccessor::GetUnit(*m_target, m_casters_target_guid);
556 }
557
558 Aura* CreateAura(SpellEntry const* spellproto, uint32 eff, int32 *currentBasePoints, Unit *target, Unit *caster, Item* castItem)
559 {
560 if (IsAreaAuraEffect(spellproto->Effect[eff]))
561 return new AreaAura(spellproto, eff, currentBasePoints, target, caster, castItem);
562
563 uint32 triggeredSpellId = spellproto->EffectTriggerSpell[eff];
564
565 if(SpellEntry const* triggeredSpellInfo = sSpellStore.LookupEntry(triggeredSpellId))
566 for (int i = 0; i < 3; ++i)
567 if (triggeredSpellInfo->EffectImplicitTargetA[i] == TARGET_SINGLE_ENEMY)
568 return new SingleEnemyTargetAura(spellproto, eff, currentBasePoints, target, caster, castItem);
569
570 return new Aura(spellproto, eff, currentBasePoints, target, caster, castItem);
571 }
572
573 Unit* Aura::GetCaster() const
574 {
575 if(m_caster_guid == m_target->GetGUID())
576 return m_target;
577
578 //return ObjectAccessor::GetUnit(*m_target,m_caster_guid);
579 //must return caster even if it's in another grid/map
580 Unit *unit = ObjectAccessor::GetUnitInWorld(*m_target,m_caster_guid);
581 return unit && unit->IsInWorld() ? unit : NULL;
582 }
583
584 void Aura::SetModifier(AuraType t, int32 a, uint32 pt, int32 miscValue)
585 {
586 m_modifier.m_auraname = t;
587 m_modifier.m_amount = a;
588 m_modifier.m_miscvalue = miscValue;
589 m_modifier.periodictime = pt;
590 }
591
592 void Aura::Update(uint32 diff)
593 {
594 if (m_duration > 0)
595 {
596 m_duration -= diff;
597 if (m_duration < 0)
598 m_duration = 0;
599 m_timeCla -= diff;
600
601 // GetEffIndex()==0 prevent double/triple apply manaPerSecond/manaPerSecondPerLevel to same spell with many auras
602 // all spells with manaPerSecond/manaPerSecondPerLevel have aura in effect 0
603 if(GetEffIndex()==0 && m_timeCla <= 0)
604 {
605 if(Unit* caster = GetCaster())
606 {
607 Powers powertype = Powers(m_spellProto->powerType);
608 int32 manaPerSecond = m_spellProto->manaPerSecond + m_spellProto->manaPerSecondPerLevel * caster->getLevel();
609 m_timeCla = 1*IN_MILISECONDS;
610 if (manaPerSecond)
611 {
612 if(powertype==POWER_HEALTH)
613 caster->ModifyHealth(-manaPerSecond);
614 else
615 caster->ModifyPower(powertype,-manaPerSecond);
616 }
617 }
618 }
619 }
620
621 // Channeled aura required check distance from caster
622 if(IsChanneledSpell(m_spellProto) && m_caster_guid != m_target->GetGUID())
623 {
624 Unit* caster = GetCaster();
625 if(!caster)
626 {
627 m_target->RemoveAura(GetId(), GetEffIndex());
628 return;
629 }
630
631 // need check distance for channeled target only
632 if (caster->GetChannelObjectGUID() == m_target->GetGUID())
633 {
634 // Get spell range
635 float max_range = GetSpellMaxRange(sSpellRangeStore.LookupEntry(m_spellProto->rangeIndex));
636
637 if(Player* modOwner = caster->GetSpellModOwner())
638 modOwner->ApplySpellMod(GetId(), SPELLMOD_RANGE, max_range, NULL);
639
640 if(!caster->IsWithinDistInMap(m_target, max_range))
641 {
642 m_target->RemoveAura(GetId(), GetEffIndex());
643 return;
644 }
645 }
646 }
647
648 if(m_isPeriodic && (m_duration >= 0 || m_isPassive || m_permanent))
649 {
650 m_periodicTimer -= diff;
651 if(m_periodicTimer <= 0) // tick also at m_periodicTimer==0 to prevent lost last tick in case max m_duration == (max m_periodicTimer)*N
652 {
653 // update before applying (aura can be removed in TriggerSpell or PeriodicTick calls)
654 m_periodicTimer += m_modifier.periodictime;
655 PeriodicTick();
656 }
657 }
658 }
659
660 void AreaAura::Update(uint32 diff)
661 {
662 // update for the caster of the aura
663 if(m_caster_guid == m_target->GetGUID())
664 {
665 Unit* caster = m_target;
666
667 if( !caster->hasUnitState(UNIT_STAT_ISOLATED) )
668 {
669 Unit* owner = caster->GetCharmerOrOwner();
670 if (!owner)
671 owner = caster;
672 std::list<Unit *> targets;
673
674 switch(m_areaAuraType)
675 {
676 case AREA_AURA_PARTY:
677 {
678 Group *pGroup = NULL;
679
680 if (owner->GetTypeId() == TYPEID_PLAYER)
681 pGroup = ((Player*)owner)->GetGroup();
682
683 if( pGroup)
684 {
685 uint8 subgroup = ((Player*)owner)->GetSubGroup();
686 for(GroupReference *itr = pGroup->GetFirstMember(); itr != NULL; itr = itr->next())
687 {
688 Player* Target = itr->getSource();
689 if(Target && Target->isAlive() && Target->GetSubGroup()==subgroup && caster->IsFriendlyTo(Target))
690 {
691 if(caster->IsWithinDistInMap(Target, m_radius))
692 targets.push_back(Target);
693 Pet *pet = Target->GetPet();
694 if(pet && pet->isAlive() && caster->IsWithinDistInMap(pet, m_radius))
695 targets.push_back(pet);
696 }
697 }
698 }
699 else
700 {
701 // add owner
702 if( owner != caster && caster->IsWithinDistInMap(owner, m_radius) )
703 targets.push_back(owner);
704 // add caster's pet
705 Unit* pet = caster->GetPet();
706 if( pet && caster->IsWithinDistInMap(pet, m_radius))
707 targets.push_back(pet);
708 }
709 break;
710 }
711 case AREA_AURA_RAID:
712 {
713 Group *pGroup = NULL;
714
715 if (owner->GetTypeId() == TYPEID_PLAYER)
716 pGroup = ((Player*)owner)->GetGroup();
717
718 if( pGroup)
719 {
720 for(GroupReference *itr = pGroup->GetFirstMember(); itr != NULL; itr = itr->next())
721 {
722 Player* Target = itr->getSource();
723 if(Target && Target->isAlive() && caster->IsFriendlyTo(Target))
724 {
725 if(caster->IsWithinDistInMap(Target, m_radius))
726 targets.push_back(Target);
727 Pet *pet = Target->GetPet();
728 if(pet && pet->isAlive() && caster->IsWithinDistInMap(pet, m_radius))
729 targets.push_back(pet);
730 }
731 }
732 }
733 else
734 {
735 // add owner
736 if( owner != caster && caster->IsWithinDistInMap(owner, m_radius) )
737 targets.push_back(owner);
738 // add caster's pet
739 Unit* pet = caster->GetPet();
740 if( pet && caster->IsWithinDistInMap(pet, m_radius))
741 targets.push_back(pet);
742 }
743 break;
744 }
745 case AREA_AURA_FRIEND:
746 {
747 CellPair p(MaNGOS::ComputeCellPair(caster->GetPositionX(), caster->GetPositionY()));
748 Cell cell(p);
749 cell.data.Part.reserved = ALL_DISTRICT;
750 cell.SetNoCreate();
751
752 MaNGOS::AnyFriendlyUnitInObjectRangeCheck u_check(caster, owner, m_radius);
753 MaNGOS::UnitListSearcher<MaNGOS::AnyFriendlyUnitInObjectRangeCheck> searcher(caster,targets, u_check);
754 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyFriendlyUnitInObjectRangeCheck>, WorldTypeMapContainer > world_unit_searcher(searcher);
755 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyFriendlyUnitInObjectRangeCheck>, GridTypeMapContainer > grid_unit_searcher(searcher);
756 CellLock<GridReadGuard> cell_lock(cell, p);
757 cell_lock->Visit(cell_lock, world_unit_searcher, *caster->GetMap(), *caster, m_radius);
758 cell_lock->Visit(cell_lock, grid_unit_searcher, *caster->GetMap(), *caster, m_radius);
759 break;
760 }
761 case AREA_AURA_ENEMY:
762 {
763 CellPair p(MaNGOS::ComputeCellPair(caster->GetPositionX(), caster->GetPositionY()));
764 Cell cell(p);
765 cell.data.Part.reserved = ALL_DISTRICT;
766 cell.SetNoCreate();
767
768 MaNGOS::AnyAoETargetUnitInObjectRangeCheck u_check(caster, owner, m_radius); // No GetCharmer in searcher
769 MaNGOS::UnitListSearcher<MaNGOS::AnyAoETargetUnitInObjectRangeCheck> searcher(caster, targets, u_check);
770 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyAoETargetUnitInObjectRangeCheck>, WorldTypeMapContainer > world_unit_searcher(searcher);
771 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyAoETargetUnitInObjectRangeCheck>, GridTypeMapContainer > grid_unit_searcher(searcher);
772 CellLock<GridReadGuard> cell_lock(cell, p);
773 cell_lock->Visit(cell_lock, world_unit_searcher, *caster->GetMap(), *caster, m_radius);
774 cell_lock->Visit(cell_lock, grid_unit_searcher, *caster->GetMap(), *caster, m_radius);
775 break;
776 }
777 case AREA_AURA_OWNER:
778 case AREA_AURA_PET:
779 {
780 if(owner != caster && caster->IsWithinDistInMap(owner, m_radius))
781 targets.push_back(owner);
782 break;
783 }
784 }
785
786 for(std::list<Unit *>::iterator tIter = targets.begin(); tIter != targets.end(); tIter++)
787 {
788 // flag for seelction is need apply aura to current iteration target
789 bool apply = true;
790
791 // we need ignore present caster self applied are auras sometime
792 // in cases if this only auras applied for spell effect
793 Unit::spellEffectPair spair = Unit::spellEffectPair(GetId(), m_effIndex);
794 for(Unit::AuraMap::const_iterator i = (*tIter)->GetAuras().lower_bound(spair); i != (*tIter)->GetAuras().upper_bound(spair); ++i)
795 {
796 if (i->second->IsDeleted())
797 continue;
798
799 switch(m_areaAuraType)
800 {
801 case AREA_AURA_ENEMY:
802 // non caster self-casted auras (non stacked)
803 if(i->second->GetModifier()->m_auraname != SPELL_AURA_NONE)
804 apply = false;
805 break;
806 case AREA_AURA_RAID:
807 // non caster self-casted auras (stacked from diff. casters)
808 if(i->second->GetModifier()->m_auraname != SPELL_AURA_NONE || i->second->GetCasterGUID() == GetCasterGUID())
809 apply = false;
810 break;
811 default:
812 // in generic case not allow stacking area auras
813 apply = false;
814 break;
815 }
816
817 if(!apply)
818 break;
819 }
820
821 if(!apply)
822 continue;
823
824 if(SpellEntry const *actualSpellInfo = sSpellMgr.SelectAuraRankForPlayerLevel(GetSpellProto(), (*tIter)->getLevel()))
825 {
826 int32 actualBasePoints = m_currentBasePoints;
827 // recalculate basepoints for lower rank (all AreaAura spell not use custom basepoints?)
828 if(actualSpellInfo != GetSpellProto())
829 actualBasePoints = actualSpellInfo->EffectBasePoints[m_effIndex];
830 AreaAura *aur = new AreaAura(actualSpellInfo, m_effIndex, &actualBasePoints, (*tIter), caster, NULL);
831 aur->SetAuraDuration(GetAuraDuration());
832 (*tIter)->AddAura(aur);
833 }
834 }
835 }
836 Aura::Update(diff);
837 }
838 else // aura at non-caster
839 {
840 Unit* caster = GetCaster();
841
842 Aura::Update(diff);
843
844 // remove aura if out-of-range from caster (after teleport for example)
845 // or caster is isolated or caster no longer has the aura
846 // or caster is (no longer) friendly
847 bool needFriendly = (m_areaAuraType == AREA_AURA_ENEMY ? false : true);
848 if( !caster || caster->hasUnitState(UNIT_STAT_ISOLATED) ||
849 !caster->IsWithinDistInMap(m_target, m_radius) ||
850 !caster->HasAura(GetId(), GetEffIndex()) ||
851 caster->IsFriendlyTo(m_target) != needFriendly
852 )
853 {
854 m_target->RemoveAurasByCasterSpell(GetId(), GetEffIndex(),GetCasterGUID());
855 }
856 else if( m_areaAuraType == AREA_AURA_PARTY) // check if in same sub group
857 {
858 // not check group if target == owner or target == pet
859 if (caster->GetCharmerOrOwnerGUID() != m_target->GetGUID() && caster->GetGUID() != m_target->GetCharmerOrOwnerGUID())
860 {
861 Player* check = caster->GetCharmerOrOwnerPlayerOrPlayerItself();
862
863 Group *pGroup = check ? check->GetGroup() : NULL;
864 if( pGroup )
865 {
866 Player* checkTarget = m_target->GetCharmerOrOwnerPlayerOrPlayerItself();
867 if(!checkTarget || !pGroup->SameSubGroup(check, checkTarget))
868 m_target->RemoveAura(GetId(), GetEffIndex());
869 }
870 else
871 m_target->RemoveAura(GetId(), GetEffIndex());
872 }
873 }
874 else if( m_areaAuraType == AREA_AURA_RAID) // TODO: fix me!
875 {
876 // not check group if target == owner or target == pet
877 if (caster->GetCharmerOrOwnerGUID() != m_target->GetGUID() && caster->GetGUID() != m_target->GetCharmerOrOwnerGUID())
878 {
879 Player* check = caster->GetCharmerOrOwnerPlayerOrPlayerItself();
880
881 Group *pGroup = check ? check->GetGroup() : NULL;
882 if( pGroup )
883 {
884 Player* checkTarget = m_target->GetCharmerOrOwnerPlayerOrPlayerItself();
885 if(!checkTarget)
886 m_target->RemoveAurasByCasterSpell(GetId(), GetEffIndex(), GetCasterGUID());
887 }
888 else
889 m_target->RemoveAurasByCasterSpell(GetId(), GetEffIndex(), GetCasterGUID());
890 }
891 }
892 else if( m_areaAuraType == AREA_AURA_PET || m_areaAuraType == AREA_AURA_OWNER )
893 {
894 if( m_target->GetGUID() != caster->GetCharmerOrOwnerGUID() )
895 m_target->RemoveAurasByCasterSpell(GetId(), GetEffIndex(), GetCasterGUID());
896 }
897 }
898 }
899
900 void PersistentAreaAura::Update(uint32 diff)
901 {
902 bool remove = false;
903
904 // remove the aura if its caster or the dynamic object causing it was removed
905 // or if the target moves too far from the dynamic object
906 if(Unit *caster = GetCaster())
907 {
908 DynamicObject *dynObj = caster->GetDynObject(GetId(), GetEffIndex());
909 if (dynObj)
910 {
911 if (!m_target->IsWithinDistInMap(dynObj, dynObj->GetRadius()))
912 remove = true;
913 }
914 else
915 remove = true;
916 }
917 else
918 remove = true;
919
920 Aura::Update(diff);
921
922 if(remove)
923 m_target->RemoveAura(GetId(), GetEffIndex());
924 }
925
926 void Aura::ApplyModifier(bool apply, bool Real)
927 {
928 AuraType aura = m_modifier.m_auraname;
929
930 SetInUse(true);
931 if(aura < TOTAL_AURAS)
932 (*this.*AuraHandler [aura])(apply, Real);
933 SetInUse(false);
934 }
935
936 bool Aura::IsNeedVisibleSlot(Unit const* caster) const
937 {
938 bool totemAura = caster && caster->GetTypeId() == TYPEID_UNIT && ((Creature*)caster)->isTotem();
939
940 // passive auras (except totem auras) do not get placed in the slots
941 if (m_isPassive && !totemAura)
942 return false;
943
944 // generic not caster case
945 if (m_target != caster)
946 return true;
947
948 // special area auras case at caster
949 switch(m_spellProto->Effect[GetEffIndex()])
950 {
951 case SPELL_EFFECT_APPLY_AREA_AURA_ENEMY:
952 return false;
953 case SPELL_EFFECT_APPLY_AREA_AURA_RAID:
954 // not sure is totemAura need, just preserve old code results
955 return totemAura || m_modifier.m_auraname != SPELL_AURA_NONE;
956 default: break;
957 }
958
959 return true;
960 }
961
962 void Aura::_AddAura()
963 {
964 if (!GetId())
965 return;
966 if(!m_target)
967 return;
968
969 // Second aura if some spell
970 bool secondaura = false;
971 // Try find slot for aura
972 uint8 slot = NULL_AURA_SLOT;
973 // Lookup for some spell auras (and get slot from it)
974 for(uint8 i = 0; i < m_effIndex; ++i)
975 {
976 Unit::spellEffectPair spair = Unit::spellEffectPair(GetId(), i);
977 for(Unit::AuraMap::const_iterator itr = m_target->GetAuras().lower_bound(spair); itr != m_target->GetAuras().upper_bound(spair); ++itr)
978 {
979 // allow use single slot only by auras from same caster
980 if(itr->second->GetCasterGUID()==GetCasterGUID())
981 {
982 slot = itr->second->GetAuraSlot();
983 secondaura = true;
984 break;
985 }
986 }
987 if (secondaura)
988 break;
989 }
990 // Lookup free slot
991 if (!secondaura && m_target->GetVisibleAurasCount() < MAX_AURAS)
992 {
993 Unit::VisibleAuraMap const *visibleAuras = m_target->GetVisibleAuras();
994 for(uint8 i = 0; i < MAX_AURAS; ++i)
995 {
996 Unit::VisibleAuraMap::const_iterator itr = visibleAuras->find(i);
997 if(itr == visibleAuras->end())
998 {
999 slot = i;
1000 // update for out of range group members (on 1 slot use)
1001 m_target->UpdateAuraForGroup(slot);
1002 break;
1003 }
1004 }
1005 }
1006
1007 Unit* caster = GetCaster();
1008
1009 // set infinity cooldown state for spells
1010 if(caster && caster->GetTypeId() == TYPEID_PLAYER)
1011 {
1012 if (m_spellProto->Attributes & SPELL_ATTR_DISABLED_WHILE_ACTIVE)
1013 {
1014 Item* castItem = m_castItemGuid ? ((Player*)caster)->GetItemByGuid(m_castItemGuid) : NULL;
1015 ((Player*)caster)->AddSpellAndCategoryCooldowns(m_spellProto,castItem ? castItem->GetEntry() : 0, NULL,true);
1016 }
1017 }
1018
1019 if (IsNeedVisibleSlot(caster))
1020 {
1021 SetAuraSlot( slot );
1022 if(slot < MAX_AURAS) // slot found send data to client
1023 {
1024 SetAura(false);
1025 SetAuraFlags((1 << GetEffIndex()) | AFLAG_NOT_CASTER | ((GetAuraMaxDuration() > 0) ? AFLAG_DURATION : AFLAG_NONE) | (IsPositive() ? AFLAG_POSITIVE : AFLAG_NEGATIVE));
1026 SetAuraLevel(caster ? caster->getLevel() : sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL));
1027 SendAuraUpdate(false);
1028 }
1029
1030 //*****************************************************
1031 // Update target aura state flag (at 1 aura apply)
1032 // TODO: Make it easer
1033 //*****************************************************
1034 if (!secondaura)
1035 {
1036 // Sitdown on apply aura req seated
1037 if (m_spellProto->AuraInterruptFlags & AURA_INTERRUPT_FLAG_NOT_SEATED && !m_target->IsSitState())
1038 m_target->SetStandState(UNIT_STAND_STATE_SIT);
1039
1040 // register aura diminishing on apply
1041 if (getDiminishGroup() != DIMINISHING_NONE )
1042 m_target->ApplyDiminishingAura(getDiminishGroup(), true);
1043
1044 // Update Seals information
1045 if (IsSealSpell(m_spellProto))
1046 m_target->ModifyAuraState(AURA_STATE_JUDGEMENT, true);
1047
1048 // Conflagrate aura state on Immolate and Shadowflame
1049 if (m_spellProto->SpellFamilyName == SPELLFAMILY_WARLOCK &&
1050 // Immolate
1051 ((m_spellProto->SpellFamilyFlags & UI64LIT(0x0000000000000004)) ||
1052 // Shadowflame
1053 (m_spellProto->SpellFamilyFlags2 & 0x00000002)))
1054 m_target->ModifyAuraState(AURA_STATE_CONFLAGRATE, true);
1055
1056 // Faerie Fire (druid versions)
1057 if (m_spellProto->SpellFamilyName == SPELLFAMILY_DRUID && (m_spellProto->SpellFamilyFlags & UI64LIT(0x0000000000000400)))
1058 m_target->ModifyAuraState(AURA_STATE_FAERIE_FIRE, true);
1059
1060 // Victorious
1061 if (m_spellProto->SpellFamilyName == SPELLFAMILY_WARRIOR && (m_spellProto->SpellFamilyFlags & UI64LIT(0x0004000000000000)))
1062 m_target->ModifyAuraState(AURA_STATE_WARRIOR_VICTORY_RUSH, true);
1063
1064 // Swiftmend state on Regrowth & Rejuvenation
1065 if (m_spellProto->SpellFamilyName == SPELLFAMILY_DRUID && (m_spellProto->SpellFamilyFlags & UI64LIT(0x50)))
1066 m_target->ModifyAuraState(AURA_STATE_SWIFTMEND, true);
1067
1068 // Deadly poison aura state
1069 if(m_spellProto->SpellFamilyName == SPELLFAMILY_ROGUE && (m_spellProto->SpellFamilyFlags & UI64LIT(0x10000)))
1070 m_target->ModifyAuraState(AURA_STATE_DEADLY_POISON, true);
1071
1072 // Enrage aura state
1073 if(m_spellProto->Dispel == DISPEL_ENRAGE)
1074 m_target->ModifyAuraState(AURA_STATE_ENRAGE, true);
1075 }
1076 }
1077 }
1078
1079 bool Aura::_RemoveAura()
1080 {
1081 // Remove all triggered by aura spells vs unlimited duration
1082 // except same aura replace case
1083 if(m_removeMode!=AURA_REMOVE_BY_STACK)
1084 CleanupTriggeredSpells();
1085
1086 Unit* caster = GetCaster();
1087
1088 if(caster && IsPersistent())
1089 {
1090 DynamicObject *dynObj = caster->GetDynObject(GetId(), GetEffIndex());
1091 if (dynObj)
1092 dynObj->RemoveAffected(m_target);
1093 }
1094
1095 //passive auras do not get put in slots
1096 // Note: but totem can be not accessible for aura target in time remove (to far for find in grid)
1097 //if(m_isPassive && !(caster && caster->GetTypeId() == TYPEID_UNIT && ((Creature*)caster)->isTotem()))
1098 // return;
1099
1100 uint8 slot = GetAuraSlot();
1101
1102 if(slot >= MAX_AURAS) // slot not set
1103 return false;
1104
1105 if(m_target->GetVisibleAura(slot) == 0)
1106 return false;
1107
1108 bool lastaura = true;
1109
1110 // find other aura in same slot (current already removed from list)
1111 for(uint8 i = 0; i < 3; ++i)
1112 {
1113 Unit::spellEffectPair spair = Unit::spellEffectPair(GetId(), i);
1114 for(Unit::AuraMap::const_iterator itr = m_target->GetAuras().lower_bound(spair); itr != m_target->GetAuras().upper_bound(spair); ++itr)
1115 {
1116 if(itr->second->GetAuraSlot() == slot)
1117 {
1118 lastaura = false;
1119 break;
1120 }
1121 }
1122 if(!lastaura)
1123 break;
1124 }
1125
1126 // only remove icon when the last aura of the spell is removed (current aura already removed from list)
1127 if (!lastaura)
1128 return false;
1129
1130 // unregister aura diminishing (and store last time)
1131 if (getDiminishGroup() != DIMINISHING_NONE )
1132 m_target->ApplyDiminishingAura(getDiminishGroup(), false);
1133
1134 SetAura(true);
1135 SetAuraFlags(AFLAG_NONE);
1136 SetAuraLevel(0);
1137
1138 if (m_removeMode != AURA_REMOVE_BY_DELETE)
1139 {
1140 SendAuraUpdate(true);
1141
1142 // update for out of range group members
1143 m_target->UpdateAuraForGroup(slot);
1144
1145 //*****************************************************
1146 // Update target aura state flag (at last aura remove)
1147 //*****************************************************
1148 // Enrage aura state
1149 if(m_spellProto->Dispel == DISPEL_ENRAGE)
1150 m_target->ModifyAuraState(AURA_STATE_ENRAGE, false);
1151
1152 uint32 removeState = 0;
1153 uint64 removeFamilyFlag = m_spellProto->SpellFamilyFlags;
1154 uint32 removeFamilyFlag2 = m_spellProto->SpellFamilyFlags2;
1155 switch(m_spellProto->SpellFamilyName)
1156 {
1157 case SPELLFAMILY_PALADIN:
1158 if (IsSealSpell(m_spellProto))
1159 removeState = AURA_STATE_JUDGEMENT; // Update Seals information
1160 break;
1161 case SPELLFAMILY_WARLOCK:
1162 // Conflagrate aura state on Immolate and Shadowflame,
1163 if ((m_spellProto->SpellFamilyFlags & UI64LIT(0x0000000000000004)) ||
1164 (m_spellProto->SpellFamilyFlags2 & 0x00000002))
1165 {
1166 removeFamilyFlag = UI64LIT(0x0000000000000004);
1167 removeFamilyFlag2 = 0x00000002;
1168 removeState = AURA_STATE_CONFLAGRATE;
1169 }
1170 break;
1171 case SPELLFAMILY_DRUID:
1172 if(m_spellProto->SpellFamilyFlags & UI64LIT(0x0000000000000400))
1173 removeState = AURA_STATE_FAERIE_FIRE; // Faerie Fire (druid versions)
1174 else if(m_spellProto->SpellFamilyFlags & UI64LIT(0x50))
1175 {
1176 removeFamilyFlag = 0x50;
1177 removeState = AURA_STATE_SWIFTMEND; // Swiftmend aura state
1178 }
1179 break;
1180 case SPELLFAMILY_WARRIOR:
1181 if(m_spellProto->SpellFamilyFlags & UI64LIT(0x0004000000000000))
1182 removeState = AURA_STATE_WARRIOR_VICTORY_RUSH; // Victorious
1183 break;
1184 case SPELLFAMILY_ROGUE:
1185 if(m_spellProto->SpellFamilyFlags & UI64LIT(0x10000))
1186 removeState = AURA_STATE_DEADLY_POISON; // Deadly poison aura state
1187 break;
1188 case SPELLFAMILY_HUNTER:
1189 if(m_spellProto->SpellFamilyFlags & UI64LIT(0x1000000000000000))
1190 removeState = AURA_STATE_FAERIE_FIRE; // Sting (hunter versions)
1191 }
1192
1193 // Remove state (but need check other auras for it)
1194 if (removeState)
1195 {
1196 bool found = false;
1197 Unit::AuraMap& Auras = m_target->GetAuras();
1198 for(Unit::AuraMap::iterator i = Auras.begin(); i != Auras.end(); ++i)
1199 {
1200 SpellEntry const *auraSpellInfo = (*i).second->GetSpellProto();
1201 if(auraSpellInfo->SpellFamilyName == m_spellProto->SpellFamilyName &&
1202 (auraSpellInfo->SpellFamilyFlags & removeFamilyFlag || auraSpellInfo->SpellFamilyFlags2 & removeFamilyFlag2))
1203 {
1204 found = true;
1205 break;
1206 }
1207 }
1208 // this has been last aura
1209 if(!found)
1210 m_target->ModifyAuraState(AuraState(removeState), false);
1211 }
1212
1213 // reset cooldown state for spells
1214 if(caster && caster->GetTypeId() == TYPEID_PLAYER)
1215 {
1216 if ( GetSpellProto()->Attributes & SPELL_ATTR_DISABLED_WHILE_ACTIVE )
1217 // note: item based cooldowns and cooldown spell mods with charges ignored (unknown existed cases)
1218 ((Player*)caster)->SendCooldownEvent(GetSpellProto());
1219 }
1220 }
1221
1222 return true;
1223 }
1224
1225 void Aura::SendAuraUpdate(bool remove)
1226 {
1227 WorldPacket data(SMSG_AURA_UPDATE);
1228 data.append(m_target->GetPackGUID());
1229 data << uint8(GetAuraSlot());
1230 data << uint32(remove ? 0 : GetId());
1231
1232 if(remove)
1233 {
1234 m_target->SendMessageToSet(&data, true);
1235 return;
1236 }
1237
1238 uint8 auraFlags = GetAuraFlags();
1239 data << uint8(auraFlags);
1240 data << uint8(GetAuraLevel());
1241 data << uint8(m_procCharges ? m_procCharges*m_stackAmount : m_stackAmount);
1242
1243 if(!(auraFlags & AFLAG_NOT_CASTER))
1244 {
1245 data << uint8(0); // pguid
1246 }
1247
1248 if(auraFlags & AFLAG_DURATION)
1249 {
1250 data << uint32(GetAuraMaxDuration());
1251 data << uint32(GetAuraDuration());
1252 }
1253
1254 m_target->SendMessageToSet(&data, true);
1255 }
1256
1257 void Aura::SetStackAmount(uint8 stackAmount)
1258 {
1259 Unit *target = GetTarget();
1260 Unit *caster = GetCaster();
1261 if (!target || !caster)
1262 return;
1263
1264 bool refresh = stackAmount >= m_stackAmount;
1265 if (stackAmount != m_stackAmount)
1266 {
1267 m_stackAmount = stackAmount;
1268 int32 amount = m_stackAmount * caster->CalculateSpellDamage(m_spellProto, m_effIndex, m_currentBasePoints, target);
1269 // Reapply if amount change
1270 if (amount!=m_modifier.m_amount)
1271 {
1272 ApplyModifier(false, true);
1273 m_modifier.m_amount = amount;
1274 ApplyModifier(true, true);
1275 }
1276 }
1277
1278 if (refresh)
1279 // Stack increased refresh duration
1280 RefreshAura();
1281 else
1282 // Stack decreased only send update
1283 SendAuraUpdate(false);
1284 }
1285
1286 bool Aura::modStackAmount(int32 num)
1287 {
1288 // Can`t mod
1289 if (!m_spellProto->StackAmount)
1290 return true;
1291
1292 // Modify stack but limit it
1293 int32 stackAmount = m_stackAmount + num;
1294 if (stackAmount > m_spellProto->StackAmount)
1295 stackAmount = m_spellProto->StackAmount;
1296 else if (stackAmount <=0) // Last aura from stack removed
1297 {
1298 m_stackAmount = 0;
1299 return true; // need remove aura
1300 }
1301
1302 // Update stack amount
1303 SetStackAmount(stackAmount);
1304 return false;
1305 }
1306
1307 void Aura::RefreshAura()
1308 {
1309 m_duration = m_maxduration;
1310 SendAuraUpdate(false);
1311 }
1312
1313 bool Aura::isAffectedOnSpell(SpellEntry const *spell) const
1314 {
1315 // Check family name
1316 if (spell->SpellFamilyName != m_spellProto->SpellFamilyName)
1317 return false;
1318 // Check EffectClassMask
1319 uint32 const *ptr = getAuraSpellClassMask();
1320 if (((uint64*)ptr)[0] & spell->SpellFamilyFlags)
1321 return true;
1322 if (ptr[2] & spell->SpellFamilyFlags2)
1323 return true;
1324 return false;
1325 }
1326
1327 void Aura::ReapplyAffectedPassiveAuras( Unit* target, bool owner_mode )
1328 {
1329 std::set<uint32> affectedSelf;
1330 std::set<uint32> affectedAuraCaster;
1331
1332 for(Unit::AuraMap::const_iterator itr = target->GetAuras().begin(); itr != target->GetAuras().end(); ++itr)
1333 {
1334 // permanent passive or permanent area aura
1335 // passive spells can be affected only by own or owner spell mods)
1336 if (itr->second->IsPermanent() && (owner_mode && itr->second->IsPassive() || itr->second->IsAreaAura()) &&
1337 // non deleted and not same aura (any with same spell id)
1338 !itr->second->IsDeleted() && itr->second->GetId() != GetId() &&
1339 // and affected by aura
1340 isAffectedOnSpell(itr->second->GetSpellProto()))
1341 {
1342 // only applied by self or aura caster
1343 if (itr->second->GetCasterGUID() == target->GetGUID())
1344 affectedSelf.insert(itr->second->GetId());
1345 else if (itr->second->GetCasterGUID() == GetCasterGUID())
1346 affectedAuraCaster.insert(itr->second->GetId());
1347 }
1348 }
1349
1350 for(std::set<uint32>::const_iterator set_itr = affectedSelf.begin(); set_itr != affectedSelf.end(); ++set_itr)
1351 {
1352 target->RemoveAurasDueToSpell(*set_itr);
1353 target->CastSpell(m_target, *set_itr, true);
1354 }
1355
1356 if (!affectedAuraCaster.empty())
1357 {
1358 Unit* caster = GetCaster();
1359 for(std::set<uint32>::const_iterator set_itr = affectedAuraCaster.begin(); set_itr != affectedAuraCaster.end(); ++set_itr)
1360 {
1361 target->RemoveAurasDueToSpell(*set_itr);
1362 if (caster)
1363 caster->CastSpell(m_target, *set_itr, true);
1364 }
1365 }
1366 }
1367
1368 /*********************************************************/
1369 /*** BASIC AURA FUNCTION ***/
1370 /*********************************************************/
1371 void Aura::HandleAddModifier(bool apply, bool Real)
1372 {
1373 if(m_target->GetTypeId() != TYPEID_PLAYER || !Real)
1374 return;
1375
1376 if(m_modifier.m_miscvalue >= MAX_SPELLMOD)
1377 return;
1378
1379 if (apply)
1380 {
1381 // Add custom charges for some mod aura
1382 switch (m_spellProto->Id)
1383 {
1384 case 17941: // Shadow Trance
1385 case 22008: // Netherwind Focus
1386 case 31834: // Light's Grace
1387 case 34754: // Clearcasting
1388 case 34936: // Backlash
1389 case 44401: // Missile Barrage
1390 case 48108: // Hot Streak
1391 case 51124: // Killing Machine
1392 case 54741: // Firestarter
1393 case 57761: // Fireball!
1394 case 64823: // Elune's Wrath (Balance druid t8 set
1395 SetAuraCharges(1);
1396 break;
1397 }
1398
1399 m_spellmod = new SpellModifier(
1400 SpellModOp(m_modifier.m_miscvalue),
1401 SpellModType(m_modifier.m_auraname), // SpellModType value == spell aura types
1402 m_modifier.m_amount,
1403 this,
1404 // prevent expire spell mods with (charges > 0 && m_stackAmount > 1)
1405 // all this spell expected expire not at use but at spell proc event check
1406 m_spellProto->StackAmount > 1 ? 0 : m_procCharges);
1407 }
1408
1409 ((Player*)m_target)->AddSpellMod(m_spellmod, apply);
1410
1411 // reapply talents to own passive persistent auras
1412 ReapplyAffectedPassiveAuras(m_target, true);
1413
1414 // re-apply talents/passives/area auras applied to pet (it affected by player spellmods)
1415 if(Pet* pet = m_target->GetPet())
1416 ReapplyAffectedPassiveAuras(pet, true);
1417
1418 // re-apply talents/passives/area auras applied to totems (it affected by player spellmods)
1419 for(int i = 0; i < MAX_TOTEM; ++i)
1420 if(m_target->m_TotemSlot[i])
1421 if(Creature* totem = m_target->GetMap()->GetCreature(m_target->m_TotemSlot[i]))
1422 ReapplyAffectedPassiveAuras(totem, true);
1423
1424 // re-apply talents/passives/area auras applied to group members (it affected by player spellmods)
1425 if (Group* group = ((Player*)m_target)->GetGroup())
1426 for(GroupReference *itr = group->GetFirstMember(); itr != NULL; itr = itr->next())
1427 if (Player* member = itr->getSource())
1428 if (member != m_target && member->IsInMap(m_target))
1429 ReapplyAffectedPassiveAuras(member, false);
1430 }
1431
1432 void Aura::HandleAddTargetTrigger(bool apply, bool /*Real*/)
1433 {
1434 // Use SpellModifier structure for check
1435 // used only fields:
1436 // spellId, mask, mask2
1437 if (apply)
1438 {
1439 SpellModifier *mod = new SpellModifier;
1440 mod->spellId = GetId();
1441
1442 uint32 const *ptr = m_spellProto->GetEffectSpellClassMask(m_effIndex);
1443
1444 mod->mask = (uint64)ptr[0] | (uint64)ptr[1]<<32;
1445 mod->mask2= ptr[2];
1446 m_spellmod = mod;
1447 }
1448 else
1449 {
1450 delete m_spellmod;
1451 m_spellmod = NULL;
1452 }
1453 }
1454
1455 void Aura::TriggerSpell()
1456 {
1457 const uint64& casterGUID = GetCasterGUID();
1458 Unit* target = GetTriggerTarget();
1459
1460 if(!casterGUID || !target)
1461 return;
1462
1463 // generic casting code with custom spells and target/caster customs
1464 uint32 trigger_spell_id = GetSpellProto()->EffectTriggerSpell[m_effIndex];
1465
1466 SpellEntry const *triggeredSpellInfo = sSpellStore.LookupEntry(trigger_spell_id);
1467 SpellEntry const *auraSpellInfo = GetSpellProto();
1468 uint32 auraId = auraSpellInfo->Id;
1469
1470 // specific code for cases with no trigger spell provided in field
1471 if (triggeredSpellInfo == NULL)
1472 {
1473 switch(auraSpellInfo->SpellFamilyName)
1474 {
1475 case SPELLFAMILY_GENERIC:
1476 {
1477 switch(auraId)
1478 {
1479 // Firestone Passive (1-5 ranks)
1480 case 758:
1481 case 17945:
1482 case 17947:
1483 case 17949:
1484 case 27252:
1485 {
1486 if (target->GetTypeId() != TYPEID_PLAYER)
1487 return;
1488 Item* item = ((Player*)target)->GetWeaponForAttack(BASE_ATTACK);
1489 if (!item)
1490 return;
1491 uint32 enchant_id = 0;
1492 switch (GetId())
1493 {
1494 case 758: enchant_id = 1803; break; // Rank 1
1495 case 17945: enchant_id = 1823; break; // Rank 2
1496 case 17947: enchant_id = 1824; break; // Rank 3
1497 case 17949: enchant_id = 1825; break; // Rank 4
1498 case 27252: enchant_id = 2645; break; // Rank 5
1499 default:
1500 return;
1501 }
1502 // remove old enchanting before applying new
1503 ((Player*)target)->ApplyEnchantment(item,TEMP_ENCHANTMENT_SLOT,false);
1504 item->SetEnchantment(TEMP_ENCHANTMENT_SLOT, enchant_id, m_modifier.periodictime+1000, 0);
1505 // add new enchanting
1506 ((Player*)target)->ApplyEnchantment(item,TEMP_ENCHANTMENT_SLOT,true);
1507 return;
1508 }
1509 // // Periodic Mana Burn
1510 // case 812: break;
1511 // // Polymorphic Ray
1512 // case 6965: break;
1513 // // Fire Nova (1-7 ranks)
1514 // case 8350:
1515 // case 8508:
1516 // case 8509:
1517 // case 11312:
1518 // case 11313:
1519 // case 25540:
1520 // case 25544:
1521 // break;
1522 // Thaumaturgy Channel
1523 case 9712: trigger_spell_id = 21029; break;
1524 // // Egan's Blaster
1525 // case 17368: break;
1526 // // Haunted
1527 // case 18347: break;
1528 // // Ranshalla Waiting
1529 // case 18953: break;
1530 // // Inferno
1531 // case 19695: break;
1532 // // Frostwolf Muzzle DND
1533 // case 21794: break;
1534 // // Alterac Ram Collar DND
1535 // case 21866: break;
1536 // // Celebras Waiting
1537 // case 21916: break;
1538 // Brood Affliction: Bronze
1539 case 23170:
1540 {
1541 m_target->CastSpell(m_target, 23171, true, 0, this);
1542 return;
1543 }
1544 // // Mark of Frost
1545 // case 23184: break;
1546 // Restoration
1547 case 23493:
1548 {
1549 int32 heal = target->GetMaxHealth() / 10;
1550 target->DealHeal(target, heal, auraSpellInfo);
1551
1552 if (int32 mana = target->GetMaxPower(POWER_MANA))
1553 {
1554 mana /= 10;
1555 target->EnergizeBySpell(target, 23493, mana, POWER_MANA);
1556 }
1557 return;
1558 }
1559 // // Stoneclaw Totem Passive TEST
1560 // case 23792: break;
1561 // // Axe Flurry
1562 // case 24018: break;
1563 // // Mark of Arlokk
1564 // case 24210: break;
1565 // // Restoration
1566 // case 24379: break;
1567 // // Happy Pet
1568 // case 24716: break;
1569 // // Dream Fog
1570 // case 24780: break;
1571 // // Cannon Prep
1572 // case 24832: break;
1573 // // Shadow Bolt Whirl
1574 // case 24834: break;
1575 // // Stink Trap
1576 // case 24918: break;
1577 // // Mark of Nature
1578 // case 25041: break;
1579 // // Agro Drones
1580 // case 25152: break;
1581 // Consume
1582 case 25371:
1583 {
1584 int32 bpDamage = target->GetMaxHealth()*10/100;
1585 target->CastCustomSpell(target, 25373, &bpDamage, NULL, NULL, true, NULL, this, casterGUID);
1586 return;
1587 }
1588 // // Pain Spike
1589 // case 25572: break;
1590 // // Rotate 360
1591 // case 26009: break;
1592 // // Rotate -360
1593 // case 26136: break;
1594 // // Consume
1595 // case 26196: break;
1596 // // Berserk
1597 // case 26615: break;
1598 // // Defile
1599 // case 27177: break;
1600 // // Teleport: IF/UC
1601 // case 27601: break;
1602 // // Five Fat Finger Exploding Heart Technique
1603 // case 27673: break;
1604 // // Nitrous Boost
1605 // case 27746: break;
1606 // // Steam Tank Passive
1607 // case 27747: break;
1608 // Frost Blast
1609 case 27808:
1610 {
1611 int32 bpDamage = target->GetMaxHealth()*26/100;
1612 target->CastCustomSpell(target, 29879, &bpDamage, NULL, NULL, true, NULL, this, casterGUID);
1613 return;
1614 }
1615 // // Detonate Mana
1616 // case 27819: break;
1617 // // Controller Timer
1618 // case 28095: break;
1619 // // Stalagg Chain
1620 // case 28096: break;
1621 // // Stalagg Tesla Passive
1622 // case 28097: break;
1623 // // Feugen Tesla Passive
1624 // case 28109: break;
1625 // // Feugen Chain
1626 // case 28111: break;
1627 // // Mark of Didier
1628 // case 28114: break;
1629 // // Communique Timer, camp
1630 // case 28346: break;
1631 // // Icebolt
1632 // case 28522: break;
1633 // // Silithyst
1634 // case 29519: break;
1635 // Inoculate Nestlewood Owlkin
1636 case 29528:
1637 if(target->GetTypeId() != TYPEID_UNIT)// prevent error reports in case ignored player target
1638 return;
1639 break;
1640 // // Overload
1641 // case 29768: break;
1642 // // Return Fire
1643 // case 29788: break;
1644 // // Return Fire
1645 // case 29793: break;
1646 // // Return Fire
1647 // case 29794: break;
1648 // // Guardian of Icecrown Passive
1649 // case 29897: break;
1650 // Feed Captured Animal
1651 case 29917: trigger_spell_id = 29916; break;
1652 // // Flame Wreath
1653 // case 29946: break;
1654 // // Flame Wreath
1655 // case 29947: break;
1656 // // Mind Exhaustion Passive
1657 // case 30025: break;
1658 // // Nether Beam - Serenity
1659 // case 30401: break;
1660 // Extract Gas
1661 case 30427:
1662 {
1663 Unit* caster = GetCaster();
1664 if (!caster)
1665 return;
1666 // move loot to player inventory and despawn target
1667 if(caster->GetTypeId() ==TYPEID_PLAYER &&
1668 target->GetTypeId() == TYPEID_UNIT &&
1669 ((Creature*)target)->GetCreatureInfo()->type == CREATURE_TYPE_GAS_CLOUD)
1670 {
1671 Player* player = (Player*)caster;
1672 Creature* creature = (Creature*)target;
1673 // missing lootid has been reported on startup - just return
1674 if (!creature->GetCreatureInfo()->SkinLootId)
1675 return;
1676
1677 player->AutoStoreLoot(creature->GetCreatureInfo()->SkinLootId,LootTemplates_Skinning,true);
1678
1679 creature->ForcedDespawn();
1680 }
1681 return;
1682 }
1683 // Quake
1684 case 30576: trigger_spell_id = 30571; break;
1685 // // Burning Maul
1686 // case 30598: break;
1687 // // Regeneration
1688 // case 30799:
1689 // case 30800:
1690 // case 30801:
1691 // break;
1692 // // Despawn Self - Smoke cloud
1693 // case 31269: break;
1694 // // Time Rift Periodic
1695 // case 31320: break;
1696 // // Corrupt Medivh
1697 // case 31326: break;
1698 // Doom
1699 case 31347:
1700 {
1701 m_target->CastSpell(m_target,31350,true);
1702 m_target->DealDamage(m_target, m_target->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
1703 return;
1704 }
1705 // Spellcloth
1706 case 31373:
1707 {
1708 // Summon Elemental after create item
1709 target->SummonCreature(17870, 0, 0, 0, target->GetOrientation(), TEMPSUMMON_DEAD_DESPAWN, 0);
1710 return;
1711 }
1712 // // Bloodmyst Tesla
1713 // case 31611: break;
1714 // Doomfire
1715 case 31944:
1716 {
1717 int32 damage = m_modifier.m_amount * ((float)(GetAuraDuration() + m_modifier.periodictime) / GetAuraMaxDuration());
1718 target->CastCustomSpell(target, 31969, &damage, NULL, NULL, true, NULL, this, casterGUID);
1719 return;
1720 }
1721 // // Teleport Test
1722 // case 32236: break;
1723 // // Earthquake
1724 // case 32686: break;
1725 // // Possess
1726 // case 33401: break;
1727 // // Draw Shadows
1728 // case 33563: break;
1729 // // Murmur's Touch
1730 // case 33711: break;
1731 // Flame Quills
1732 case 34229:
1733 {
1734 // cast 24 spells 34269-34289, 34314-34316
1735 for(uint32 spell_id = 34269; spell_id != 34290; ++spell_id)
1736 target->CastSpell(target, spell_id, true, NULL, this, casterGUID);
1737 for(uint32 spell_id = 34314; spell_id != 34317; ++spell_id)
1738 target->CastSpell(target, spell_id, true, NULL, this, casterGUID);
1739 return;
1740 }
1741 // // Gravity Lapse
1742 // case 34480: break;
1743 // // Tornado
1744 // case 34683: break;
1745 // // Frostbite Rotate
1746 // case 34748: break;
1747 // // Arcane Flurry
1748 // case 34821: break;
1749 // // Interrupt Shutdown
1750 // case 35016: break;
1751 // // Interrupt Shutdown
1752 // case 35176: break;
1753 // // Inferno
1754 // case 35268: break;
1755 // // Salaadin's Tesla
1756 // case 35515: break;
1757 // // Ethereal Channel (Red)
1758 // case 35518: break;
1759 // // Nether Vapor
1760 // case 35879: break;
1761 // // Dark Portal Storm
1762 // case 36018: break;
1763 // // Burning Maul
1764 // case 36056: break;
1765 // // Living Grove Defender Lifespan
1766 // case 36061: break;
1767 // // Professor Dabiri Talks
1768 // case 36064: break;
1769 // // Kael Gaining Power
1770 // case 36091: break;
1771 // // They Must Burn Bomb Aura
1772 // case 36344: break;
1773 // // They Must Burn Bomb Aura (self)
1774 // case 36350: break;
1775 // // Stolen Ravenous Ravager Egg
1776 // case 36401: break;
1777 // // Activated Cannon
1778 // case 36410: break;
1779 // // Stolen Ravenous Ravager Egg
1780 // case 36418: break;
1781 // // Enchanted Weapons
1782 // case 36510: break;
1783 // // Cursed Scarab Periodic
1784 // case 36556: break;
1785 // // Cursed Scarab Despawn Periodic
1786 // case 36561: break;
1787 // // Vision Guide
1788 // case 36573: break;
1789 // // Cannon Charging (platform)
1790 // case 36785: break;
1791 // // Cannon Charging (self)
1792 // case 36860: break;
1793 // Remote Toy
1794 case 37027: trigger_spell_id = 37029; break;
1795 // // Mark of Death
1796 // case 37125: break;
1797 // // Arcane Flurry
1798 // case 37268: break;
1799 // // Spout
1800 // case 37429: break;
1801 // // Spout
1802 // case 37430: break;
1803 // // Karazhan - Chess NPC AI, Snapshot timer
1804 // case 37440: break;
1805 // // Karazhan - Chess NPC AI, action timer
1806 // case 37504: break;
1807 // // Karazhan - Chess: Is Square OCCUPIED aura (DND)
1808 // case 39400: break;
1809 // // Banish
1810 // case 37546: break;
1811 // // Shriveling Gaze
1812 // case 37589: break;
1813 // // Fake Aggro Radius (2 yd)
1814 // case 37815: break;
1815 // // Corrupt Medivh
1816 // case 37853: break;
1817 // Eye of Grillok
1818 case 38495:
1819 {
1820 m_target->CastSpell(m_target, 38530, true);
1821 return;
1822 }
1823 // Absorb Eye of Grillok (Zezzak's Shard)
1824 case 38554:
1825 {
1826 if(m_target->GetTypeId() != TYPEID_UNIT)
1827 return;
1828
1829 if (Unit* caster = GetCaster())
1830 caster->CastSpell(caster, 38495, true, NULL, this);
1831 else
1832 return;
1833
1834 Creature* creatureTarget = (Creature*)m_target;
1835
1836 creatureTarget->ForcedDespawn();
1837 return;
1838 }
1839 // // Magic Sucker Device timer
1840 // case 38672: break;
1841 // // Tomb Guarding Charging
1842 // case 38751: break;
1843 // // Murmur's Touch
1844 // case 38794: break;
1845 // // Activate Nether-wraith Beacon (31742 Nether-wraith Beacon item)
1846 // case 39105: break;
1847 // // Drain World Tree Visual
1848 // case 39140: break;
1849 // // Quest - Dustin's Undead Dragon Visual aura
1850 // case 39259: break;
1851 // // Hellfire - The Exorcism, Jules releases darkness, aura
1852 // case 39306: break;
1853 // // Inferno
1854 // case 39346: break;
1855 // // Enchanted Weapons
1856 // case 39489: break;
1857 // // Shadow Bolt Whirl
1858 // case 39630: break;
1859 // // Shadow Bolt Whirl
1860 // case 39634: break;
1861 // // Shadow Inferno
1862 // case 39645: break;
1863 // Tear of Azzinoth Summon Channel - it's not really supposed to do anything,and this only prevents the console spam
1864 case 39857: trigger_spell_id = 39856; break;
1865 // // Soulgrinder Ritual Visual (Smashed)
1866 // case 39974: break;
1867 // // Simon Game Pre-game timer
1868 // case 40041: break;
1869 // // Knockdown Fel Cannon: The Aggro Check Aura
1870 // case 40113: break;
1871 // // Spirit Lance
1872 // case 40157: break;
1873 // // Demon Transform 2
1874 // case 40398: break;
1875 // // Demon Transform 1
1876 // case 40511: break;
1877 // // Ancient Flames
1878 // case 40657: break;
1879 // // Ethereal Ring Cannon: Cannon Aura
1880 // case 40734: break;
1881 // // Cage Trap
1882 // case 40760: break;
1883 // // Random Periodic
1884 // case 40867: break;
1885 // // Prismatic Shield
1886 // case 40879: break;
1887 // // Aura of Desire
1888 // case 41350: break;
1889 // // Dementia
1890 // case 41404: break;
1891 // // Chaos Form
1892 // case 41629: break;
1893 // // Alert Drums
1894 // case 42177: break;
1895 // // Spout
1896 // case 42581: break;
1897 // // Spout
1898 // case 42582: break;
1899 // // Return to the Spirit Realm
1900 // case 44035: break;
1901 // // Curse of Boundless Agony
1902 // case 45050: break;
1903 // // Earthquake
1904 // case 46240: break;
1905 // Personalized Weather
1906 case 46736: trigger_spell_id = 46737; break;
1907 // // Stay Submerged
1908 // case 46981: break;
1909 // // Dragonblight Ram
1910 // case 47015: break;
1911 // // Party G.R.E.N.A.D.E.
1912 // case 51510: break;
1913 default:
1914 break;
1915 }
1916 break;
1917 }
1918 case SPELLFAMILY_MAGE:
1919 {
1920 switch(auraId)
1921 {
1922 // Invisibility
1923 case 66:
1924 // Here need periodic triger reducing threat spell (or do it manually)
1925 return;
1926 default:
1927 break;
1928 }
1929 break;
1930 }
1931 // case SPELLFAMILY_WARRIOR:
1932 // {
1933 // switch(auraId)
1934 // {
1935 // // Wild Magic
1936 // case 23410: break;
1937 // // Corrupted Totems
1938 // case 23425: break;
1939 // default:
1940 // break;
1941 // }
1942 // break;
1943 // }
1944 // case SPELLFAMILY_PRIEST:
1945 // {
1946 // switch(auraId)
1947 // {
1948 // // Blue Beam
1949 // case 32930: break;
1950 // // Fury of the Dreghood Elders
1951 // case 35460: break;
1952 // default:
1953 // break;
1954 // }
1955 // break;
1956 // }
1957 case SPELLFAMILY_HUNTER:
1958 {
1959 switch (auraId)
1960 {
1961 // Sniper training
1962 case 53302:
1963 case 53303:
1964 case 53304:
1965 if (target->GetTypeId() != TYPEID_PLAYER)
1966 return;
1967
1968 // Reset reapply counter at move
1969 if (((Player*)target)->isMoving())
1970 {
1971 m_modifier.m_amount = 6;
1972 return;
1973 }
1974
1975 // We are standing at the moment
1976 if (m_modifier.m_amount > 0)
1977 {
1978 --m_modifier.m_amount;
1979 return;
1980 }
1981
1982 // select rank of buff
1983 switch(auraId)
1984 {
1985 case 53302: trigger_spell_id = 64418; break;
1986 case 53303: trigger_spell_id = 64419; break;
1987 case 53304: trigger_spell_id = 64420; break;
1988 }
1989
1990 // If aura is active - no need to continue
1991 if (target->HasAura(trigger_spell_id))
1992 return;
1993
1994 break;
1995 default:
1996 break;
1997 }
1998 break;
1999 }
2000 case SPELLFAMILY_DRUID:
2001 {
2002 switch(auraId)
2003 {
2004 // Cat Form
2005 // trigger_spell_id not set and unknown effect triggered in this case, ignoring for while
2006 case 768:
2007 return;
2008 // Frenzied Regeneration
2009 case 22842:
2010 case 22895:
2011 case 22896:
2012 case 26999:
2013 {
2014 int32 LifePerRage = GetModifier()->m_amount;
2015
2016 int32 lRage = m_target->GetPower(POWER_RAGE);
2017 if(lRage > 100) // rage stored as rage*10
2018 lRage = 100;
2019 m_target->ModifyPower(POWER_RAGE, -lRage);
2020 int32 FRTriggerBasePoints = int32(lRage*LifePerRage/10);
2021 m_target->CastCustomSpell(m_target, 22845, &FRTriggerBasePoints, NULL, NULL, true, NULL, this);
2022 return;
2023 }
2024 default:
2025 break;
2026 }
2027 break;
2028 }
2029
2030 // case SPELLFAMILY_HUNTER:
2031 // {
2032 // switch(auraId)
2033 // {
2034 // //Frost Trap Aura
2035 // case 13810:
2036 // return;
2037 // //Rizzle's Frost Trap
2038 // case 39900:
2039 // return;
2040 // // Tame spells
2041 // case 19597: // Tame Ice Claw Bear
2042 // case 19676: // Tame Snow Leopard
2043 // case 19677: // Tame Large Crag Boar
2044 // case 19678: // Tame Adult Plainstrider
2045 // case 19679: // Tame Prairie Stalker
2046 // case 19680: // Tame Swoop
2047 // case 19681: // Tame Dire Mottled Boar
2048 // case 19682: // Tame Surf Crawler
2049 // case 19683: // Tame Armored Scorpid
2050 // case 19684: // Tame Webwood Lurker
2051 // case 19685: // Tame Nightsaber Stalker
2052 // case 19686: // Tame Strigid Screecher
2053 // case 30100: // Tame Crazed Dragonhawk
2054 // case 30103: // Tame Elder Springpaw
2055 // case 30104: // Tame Mistbat
2056 // case 30647: // Tame Barbed Crawler
2057 // case 30648: // Tame Greater Timberstrider
2058 // case 30652: // Tame Nightstalker
2059 // return;
2060 // default:
2061 // break;
2062 // }
2063 // break;
2064 // }
2065 case SPELLFAMILY_SHAMAN:
2066 {
2067 switch(auraId)
2068 {
2069 // Lightning Shield (The Earthshatterer set trigger after cast Lighting Shield)
2070 case 28820:
2071 {
2072 // Need remove self if Lightning Shield not active
2073 Unit::AuraMap const& auras = target->GetAuras();
2074 for(Unit::AuraMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
2075 {
2076 SpellEntry const* spell = itr->second->GetSpellProto();
2077 if( spell->SpellFamilyName == SPELLFAMILY_SHAMAN &&
2078 (spell->SpellFamilyFlags & UI64LIT(0x0000000000000400)))
2079 return;
2080 }
2081 target->RemoveAurasDueToSpell(28820);
2082 return;
2083 }
2084 // Totemic Mastery (Skyshatter Regalia (Shaman Tier 6) - bonus)
2085 case 38443:
2086 {
2087 bool all = true;
2088 for(int i = 0; i < MAX_TOTEM; ++i)
2089 {
2090 if(!target->m_TotemSlot[i])
2091 {
2092 all = false;
2093 break;
2094 }
2095 }
2096
2097 if(all)
2098 target->CastSpell(target, 38437, true, NULL, this);
2099 else
2100 target->RemoveAurasDueToSpell(38437);
2101 return;
2102 }
2103 default:
2104 break;
2105 }
2106 break;
2107 }
2108 default:
2109 break;
2110 }
2111
2112 // Reget trigger spell proto
2113 triggeredSpellInfo = sSpellStore.LookupEntry(trigger_spell_id);
2114 }
2115 else
2116 {
2117 // Spell exist but require custom code
2118 switch(auraId)
2119 {
2120 // Curse of Idiocy
2121 case 1010:
2122 {
2123 // TODO: spell casted by result in correct way mostly
2124 // BUT:
2125 // 1) target show casting at each triggered cast: target don't must show casting animation for any triggered spell
2126 // but must show affect apply like item casting
2127 // 2) maybe aura must be replace by new with accumulative stat mods instead stacking
2128
2129 // prevent cast by triggered auras
2130 if(casterGUID == target->GetGUID())
2131 return;
2132
2133 // stop triggering after each affected stats lost > 90
2134 int32 intelectLoss = 0;
2135 int32 spiritLoss = 0;
2136
2137 Unit::AuraList const& mModStat = target->GetAurasByType(SPELL_AURA_MOD_STAT);
2138 for(Unit::AuraList::const_iterator i = mModStat.begin(); i != mModStat.end(); ++i)
2139 {
2140 if ((*i)->GetId() == 1010)
2141 {
2142 switch((*i)->GetModifier()->m_miscvalue)
2143 {
2144 case STAT_INTELLECT: intelectLoss += (*i)->GetModifier()->m_amount; break;
2145 case STAT_SPIRIT: spiritLoss += (*i)->GetModifier()->m_amount; break;
2146 default: break;
2147 }
2148 }
2149 }
2150
2151 if(intelectLoss <= -90 && spiritLoss <= -90)
2152 return;
2153
2154 break;
2155 }
2156 // Mana Tide
2157 case 16191:
2158 {
2159 target->CastCustomSpell(target, trigger_spell_id, &m_modifier.m_amount, NULL, NULL, true, NULL, this);
2160 return;
2161 }
2162 // Ground Slam
2163 case 33525:
2164 target->CastSpell(target, trigger_spell_id, true, NULL, this, casterGUID);
2165 return;
2166 // Beacon of Light
2167 case 53563:
2168 // original caster must be target (beacon)
2169 target->CastSpell(target, trigger_spell_id, true, NULL, this, target->GetGUID());
2170 return;
2171 // Rapid Recuperation (triggered energize have baspioints == 0)
2172 case 56654:
2173 case 58882:
2174 {
2175 int32 mana = m_target->GetMaxPower(POWER_MANA) * m_modifier.m_amount / 100;
2176 target->CastCustomSpell(target, trigger_spell_id, &mana, NULL, NULL, true, NULL, this);
2177 return;
2178 }
2179 }
2180 }
2181
2182 // All ok cast by default case
2183 if(triggeredSpellInfo)
2184 target->CastSpell(target, triggeredSpellInfo, true, NULL, this, casterGUID);
2185 else
2186 {
2187 if (Unit* caster = GetCaster())
2188 {
2189 if(target->GetTypeId() != TYPEID_UNIT || !Script->EffectDummyCreature(caster, GetId(), GetEffIndex(), (Creature*)target))
2190 sLog.outError("Aura::TriggerSpell: Spell %u have 0 in EffectTriggered[%d], not handled custom case?",GetId(),GetEffIndex());
2191 }
2192 }
2193 }
2194
2195 void Aura::TriggerSpellWithValue()
2196 {
2197 const uint64& casterGUID = GetCasterGUID();
2198 Unit* target = GetTriggerTarget();
2199
2200 if(!casterGUID || !target)
2201 return;
2202
2203 // generic casting code with custom spells and target/caster customs
2204 uint32 trigger_spell_id = GetSpellProto()->EffectTriggerSpell[m_effIndex];
2205 int32 basepoints0 = this->GetModifier()->m_amount;
2206
2207 target->CastCustomSpell(target, trigger_spell_id, &basepoints0, NULL, NULL, true, NULL, this, casterGUID);
2208 }
2209
2210 /*********************************************************/
2211 /*** AURA EFFECTS ***/
2212 /*********************************************************/
2213
2214 void Aura::HandleAuraDummy(bool apply, bool Real)
2215 {
2216 // spells required only Real aura add/remove
2217 if(!Real)
2218 return;
2219
2220 // AT APPLY
2221 if(apply)
2222 {
2223 switch(m_spellProto->SpellFamilyName)
2224 {
2225 case SPELLFAMILY_GENERIC:
2226 switch(GetId())
2227 {
2228 case 1515: // Tame beast
2229 // FIX_ME: this is 2.0.12 threat effect replaced in 2.1.x by dummy aura, must be checked for correctness
2230 if (m_target->CanHaveThreatList())
2231 if (Unit* caster = GetCaster())
2232 m_target->AddThreat(caster, 10.0f, false, GetSpellSchoolMask(GetSpellProto()), GetSpellProto());
2233 return;
2234 case 7057: // Haunting Spirits
2235 // expected to tick with 30 sec period (tick part see in Aura::PeriodicTick)
2236 m_isPeriodic = true;
2237 m_modifier.periodictime = 30*IN_MILISECONDS;
2238 m_periodicTimer = m_modifier.periodictime;
2239 return;
2240 case 13139: // net-o-matic
2241 // root to self part of (root_target->charge->root_self sequence
2242 if (Unit* caster = GetCaster())
2243 caster->CastSpell(caster, 13138, true, NULL, this);
2244 return;
2245 case 39850: // Rocket Blast
2246 if(roll_chance_i(20)) // backfire stun
2247 m_target->CastSpell(m_target, 51581, true, NULL, this);
2248 return;
2249 case 43873: // Headless Horseman Laugh
2250 m_target->PlayDistanceSound(11965);
2251 return;
2252 case 46354: // Blood Elf Illusion
2253 if (Unit* caster = GetCaster())
2254 {
2255 switch(caster->getGender())
2256 {
2257 case GENDER_FEMALE:
2258 caster->CastSpell(m_target, 46356, true, NULL, this);
2259 break;
2260 case GENDER_MALE:
2261 caster->CastSpell(m_target, 46355, true, NULL, this);
2262 break;
2263 default:
2264 break;
2265 }
2266 }
2267 return;
2268 case 46699: // Requires No Ammo
2269 if (m_target->GetTypeId() == TYPEID_PLAYER)
2270 // not use ammo and not allow use
2271 ((Player*)m_target)->RemoveAmmo();
2272 return;
2273 case 62061: // Festive Holiday Mount
2274 if (m_target->HasAuraType(SPELL_AURA_MOUNTED))
2275 // Reindeer Transformation
2276 m_target->CastSpell(m_target, 25860, true, NULL, this);
2277 return;
2278 }
2279 break;
2280 case SPELLFAMILY_WARRIOR:
2281 // Overpower
2282 if(m_spellProto->SpellFamilyFlags & UI64LIT(0x0000000000000004))
2283 {
2284 // Must be casting target
2285 if (!m_target->IsNonMeleeSpellCasted(false))
2286 return;
2287
2288 Unit* caster = GetCaster();
2289 if (!caster)
2290 return;
2291
2292 Unit::AuraList const& modifierAuras = caster->GetAurasByType(SPELL_AURA_ADD_FLAT_MODIFIER);
2293 for(Unit::AuraList::const_iterator itr = modifierAuras.begin(); itr != modifierAuras.end(); ++itr)
2294 {
2295 // Unrelenting Assault
2296 if((*itr)->GetSpellProto()->SpellFamilyName==SPELLFAMILY_WARRIOR && (*itr)->GetSpellProto()->SpellIconID == 2775)
2297 {
2298 switch ((*itr)->GetSpellProto()->Id)
2299 {
2300 case 46859: // Unrelenting Assault, rank 1
2301 m_target->CastSpell(m_target,64849,true,NULL,(*itr));
2302 break;
2303 case 46860: // Unrelenting Assault, rank 2
2304 m_target->CastSpell(m_target,64850,true,NULL,(*itr));
2305 break;
2306 default:
2307 break;
2308 }
2309 break;
2310 }
2311 }
2312 return;
2313 }
2314 break;
2315 case SPELLFAMILY_SHAMAN:
2316 // Tidal Force
2317 if (GetId() == 55198)
2318 {
2319 // apply max stack bufs
2320 SpellEntry const* buffEntry = sSpellStore.LookupEntry(55166);
2321 if (!buffEntry)
2322 return;
2323 for(int k = 0; k < buffEntry->StackAmount; ++k)
2324 m_target->CastSpell(m_target, buffEntry, true, NULL, this);
2325 }
2326 // Earth Shield
2327 else if ((GetSpellProto()->SpellFamilyFlags & UI64LIT(0x40000000000)))
2328 {
2329 // prevent double apply bonuses
2330 if(m_target->GetTypeId() != TYPEID_PLAYER || !((Player*)m_target)->GetSession()->PlayerLoading())
2331 if (Unit* caster = GetCaster())
2332 m_modifier.m_amount = caster->SpellHealingBonus(m_target, GetSpellProto(), m_modifier.m_amount, SPELL_DIRECT_DAMAGE);
2333 return;
2334 }
2335 break;
2336 }
2337 }
2338 // AT REMOVE
2339 else
2340 {
2341 if( m_target->GetTypeId() == TYPEID_PLAYER &&
2342 ( GetSpellProto()->Effect[0]==72 || GetSpellProto()->Effect[0]==6 &&
2343 ( GetSpellProto()->EffectApplyAuraName[0]==1 || GetSpellProto()->EffectApplyAuraName[0]==128 ) ) )
2344 {
2345 // spells with SpellEffect=72 and aura=4: 6196, 6197, 21171, 21425
2346 ((Player*)m_target)->SetFarSightGUID(0);
2347 WorldPacket data(SMSG_CLEAR_FAR_SIGHT_IMMEDIATE, 0);
2348 ((Player*)m_target)->GetSession()->SendPacket(&data);
2349 return;
2350 }
2351
2352 if (IsQuestTameSpell(GetId()) && m_target->isAlive())
2353 {
2354 Unit* caster = GetCaster();
2355 if (!caster || !caster->isAlive())
2356 return;
2357
2358 uint32 finalSpelId = 0;
2359 switch(GetId())
2360 {
2361 case 19548: finalSpelId = 19597; break;
2362 case 19674: finalSpelId = 19677; break;
2363 case 19687: finalSpelId = 19676; break;
2364 case 19688: finalSpelId = 19678; break;
2365 case 19689: finalSpelId = 19679; break;
2366 case 19692: finalSpelId = 19680; break;
2367 case 19693: finalSpelId = 19684; break;
2368 case 19694: finalSpelId = 19681; break;
2369 case 19696: finalSpelId = 19682; break;
2370 case 19697: finalSpelId = 19683; break;
2371 case 19699: finalSpelId = 19685; break;
2372 case 19700: finalSpelId = 19686; break;
2373 case 30646: finalSpelId = 30647; break;
2374 case 30653: finalSpelId = 30648; break;
2375 case 30654: finalSpelId = 30652; break;
2376 case 30099: finalSpelId = 30100; break;
2377 case 30102: finalSpelId = 30103; break;
2378 case 30105: finalSpelId = 30104; break;
2379 }
2380
2381 if(finalSpelId)
2382 caster->CastSpell(m_target, finalSpelId, true, NULL, this);
2383 return;
2384 }
2385
2386 switch(GetId())
2387 {
2388 case 36730: // Flame Strike
2389 {
2390 m_target->CastSpell(m_target, 36731, true, NULL, this);
2391 return;
2392 }
2393 case 44191: // Flame Strike
2394 {
2395 if (m_target->GetMap()->IsDungeon())
2396 {
2397 uint32 spellId = m_target->GetMap()->IsRegularDifficulty() ? 44190 : 46163;
2398
2399 m_target->CastSpell(m_target, spellId, true, NULL, this);
2400 }
2401 return;
2402 }
2403 case 45934: // Dark Fiend
2404 {
2405 // Kill target if dispelled
2406 if (m_removeMode==AURA_REMOVE_BY_DISPEL)
2407 m_target->DealDamage(m_target, m_target->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
2408 return;
2409 }
2410 case 46308: // Burning Winds
2411 {
2412 // casted only at creatures at spawn
2413 m_target->CastSpell(m_target, 47287, true, NULL, this);
2414 return;
2415 }
2416 }
2417
2418 // Living Bomb
2419 if (m_spellProto->SpellFamilyName == SPELLFAMILY_MAGE && (m_spellProto->SpellFamilyFlags & UI64LIT(0x2000000000000)))
2420 {
2421 // Zero duration is equal to AURA_REMOVE_BY_DEFAULT. We can't use it directly, as it is set even
2422 // when removing aura from one target due to casting Living Bomb at other.
2423 if (m_duration == 0 || m_removeMode == AURA_REMOVE_BY_DISPEL)
2424 m_target->CastSpell(m_target,m_modifier.m_amount,true,NULL,this);
2425 return;
2426 }
2427
2428 if (m_removeMode == AURA_REMOVE_BY_DEATH)
2429 {
2430 // Stop caster Arcane Missle chanelling on death
2431 if (m_spellProto->SpellFamilyName == SPELLFAMILY_MAGE &&
2432 (m_spellProto->SpellFamilyFlags & UI64LIT(0x0000000000000800)))
2433 {
2434 if (Unit* caster = GetCaster())
2435 caster->InterruptSpell(CURRENT_CHANNELED_SPELL);
2436 return;
2437 }
2438 // Stop caster Penance chanelling on death
2439 if (m_spellProto->SpellFamilyName == SPELLFAMILY_PRIEST &&
2440 (m_spellProto->SpellFamilyFlags2 & UI64LIT(0x00000080)))
2441 {
2442 if (Unit* caster = GetCaster())
2443 caster->InterruptSpell(CURRENT_CHANNELED_SPELL);
2444 return;
2445 }
2446 }
2447 }
2448
2449 // AT APPLY & REMOVE
2450
2451 switch(m_spellProto->SpellFamilyName)
2452 {
2453 case SPELLFAMILY_GENERIC:
2454 {
2455 switch(GetId())
2456 {
2457 // Recently Bandaged
2458 case 11196:
2459 m_target->ApplySpellImmune(GetId(), IMMUNITY_MECHANIC, GetMiscValue(), apply);
2460 return;
2461 // Unstable Power
2462 case 24658:
2463 {
2464 uint32 spellId = 24659;
2465 if (apply)
2466 {
2467 SpellEntry const *spell = sSpellStore.LookupEntry(spellId);
2468 Unit* caster = GetCaster();
2469 if (!spell || !caster)
2470 return;
2471
2472 for (int i=0; i < spell->StackAmount; ++i)
2473 caster->CastSpell(m_target, spellId, true, NULL, NULL, GetCasterGUID());
2474 return;
2475 }
2476 m_target->RemoveAurasDueToSpell(spellId);
2477 return;
2478 }
2479 // Restless Strength
2480 case 24661:
2481 {
2482 uint32 spellId = 24662;
2483 if (apply)
2484 {
2485 SpellEntry const* spell = sSpellStore.LookupEntry(spellId);
2486 Unit* caster = GetCaster();
2487 if (!spell || !caster)
2488 return;
2489 for (int i=0; i < spell->StackAmount; ++i)
2490 caster->CastSpell(m_target, spell->Id, true, NULL, NULL, GetCasterGUID());
2491 return;
2492 }
2493 m_target->RemoveAurasDueToSpell(spellId);
2494 return;
2495 }
2496 //Summon Fire Elemental
2497 case 40133:
2498 {
2499 Unit* caster = GetCaster();
2500 if (!caster)
2501 return;
2502
2503 Unit *owner = caster->GetOwner();
2504 if (owner && owner->GetTypeId() == TYPEID_PLAYER)
2505 {
2506 if(apply)
2507 owner->CastSpell(owner, 8985, true);
2508 else
2509 ((Player*)owner)->RemovePet(NULL, PET_SAVE_NOT_IN_SLOT, true);
2510 }
2511 return;
2512 }
2513 //Summon Earth Elemental
2514 case 40132 :
2515 {
2516 Unit* caster = GetCaster();
2517 if (!caster)
2518 return;
2519
2520 Unit *owner = caster->GetOwner();
2521 if (owner && owner->GetTypeId() == TYPEID_PLAYER)
2522 {
2523 if(apply)
2524 owner->CastSpell(owner, 19704, true);
2525 else
2526 ((Player*)owner)->RemovePet(NULL, PET_SAVE_NOT_IN_SLOT, true);
2527 }
2528 return;
2529 }
2530 //Dragonmaw Illusion
2531 case 40214 :
2532 {
2533 if(apply)
2534 {
2535 m_target->CastSpell(m_target, 40216, true);
2536 m_target->CastSpell(m_target, 42016, true);
2537 }
2538 else
2539 {
2540 m_target->RemoveAurasDueToSpell(40216);
2541 m_target->RemoveAurasDueToSpell(42016);
2542 }
2543 return;
2544 }
2545 // LK Intro VO (1)
2546 case 58204:
2547 if(m_target->GetTypeId() == TYPEID_PLAYER)
2548 {
2549 // Play part 1
2550 if(apply)
2551 m_target->PlayDirectSound(14970, (Player *)m_target);
2552 // continue in 58205
2553 else
2554 m_target->CastSpell(m_target, 58205, true);
2555 }
2556 return;
2557 // LK Intro VO (2)
2558 case 58205:
2559 if(m_target->GetTypeId() == TYPEID_PLAYER)
2560 {
2561 // Play part 2
2562 if(apply)
2563 m_target->PlayDirectSound(14971, (Player *)m_target);
2564 // Play part 3
2565 else
2566 m_target->PlayDirectSound(14972, (Player *)m_target);
2567 }
2568 return;
2569 case 40131:
2570 case 27978:
2571 if (apply)
2572 m_target->m_AuraFlags |= UNIT_AURAFLAG_ALIVE_INVISIBLE;
2573 else
2574 m_target->m_AuraFlags |= ~UNIT_AURAFLAG_ALIVE_INVISIBLE;
2575 return;
2576 }
2577 break;
2578 }
2579 case SPELLFAMILY_MAGE:
2580 break;
2581 case SPELLFAMILY_WARLOCK:
2582 {
2583 // Haunt
2584 if (GetSpellProto()->SpellIconID == 3172 && (GetSpellProto()->SpellFamilyFlags & UI64LIT(0x0004000000000000)))
2585 {
2586 // NOTE: for avoid use additional field damage stored in dummy value (replace unused 100%
2587 if (apply)
2588 m_modifier.m_amount = 0; // use value as damage counter instead redundent 100% percent
2589 else
2590 {
2591 int32 bp0 = m_modifier.m_amount;
2592
2593 if (Unit* caster = GetCaster())
2594 m_target->CastCustomSpell(caster,48210,&bp0,NULL,NULL,true);
2595 }
2596 }
2597 break;
2598 }
2599 case SPELLFAMILY_PRIEST:
2600 {
2601 // Pain and Suffering
2602 if( m_spellProto->SpellIconID == 2874 && m_target->GetTypeId()==TYPEID_PLAYER )
2603 {
2604 if(apply)
2605 {
2606 // Reduce backfire damage (dot damage) from Shadow Word: Death
2607 // aura have wrong effectclassmask, so use hardcoded value
2608 m_spellmod = new SpellModifier(SPELLMOD_DOT,SPELLMOD_PCT,m_modifier.m_amount,GetId(),UI64LIT(0x0000200000000000));
2609 }
2610 ((Player*)m_target)->AddSpellMod(m_spellmod, apply);
2611 return;
2612 }
2613 break;
2614 }
2615 case SPELLFAMILY_DRUID:
2616 {
2617 switch(GetId())
2618 {
2619 case 34246: // Idol of the Emerald Queen
2620 case 60779: // Idol of Lush Moss
2621 {
2622 if (m_target->GetTypeId() != TYPEID_PLAYER)
2623 return;
2624
2625 if(apply)
2626 // dummy not have proper effectclassmask
2627 m_spellmod = new SpellModifier(SPELLMOD_DOT,SPELLMOD_FLAT,m_modifier.m_amount/7,GetId(),UI64LIT(0x001000000000));
2628
2629 ((Player*)m_target)->AddSpellMod(m_spellmod, apply);
2630 return;
2631 }
2632 case 52610: // Savage Roar
2633 {
2634 if(apply)
2635 {
2636 if(m_target->m_form != FORM_CAT)
2637 return;
2638
2639 m_target->CastSpell(m_target, 62071, true);
2640 }
2641 else
2642 m_target-> RemoveAurasDueToSpell(62071);
2643 return;
2644 }
2645 case 61336: // Survival Instincts
2646 {
2647 if(apply)
2648 {
2649 if (!m_target->IsInFeralForm())
2650 return;
2651
2652 int32 bp0 = int32(m_target->GetMaxHealth() * m_modifier.m_amount / 100);
2653 m_target->CastCustomSpell(m_target, 50322, &bp0, NULL, NULL, true);
2654 }
2655 else
2656 m_target-> RemoveAurasDueToSpell(50322);
2657 return;
2658 }
2659 }
2660
2661 // Lifebloom
2662 if (GetSpellProto()->SpellFamilyFlags & UI64LIT(0x1000000000))
2663 {
2664 if ( apply )
2665 {
2666 if (Unit* caster = GetCaster())
2667 // prevent double apply bonuses
2668 if(m_target->GetTypeId()!=TYPEID_PLAYER || !((Player*)m_target)->GetSession()->PlayerLoading())
2669 m_modifier.m_amount = caster->SpellHealingBonus(m_target, GetSpellProto(), m_modifier.m_amount, SPELL_DIRECT_DAMAGE);
2670 }
2671 else
2672 {
2673 // Final heal only on dispelled or duration end
2674 if ( !(GetAuraDuration() <= 0 || m_removeMode == AURA_REMOVE_BY_DISPEL) )
2675 return;
2676
2677 // have a look if there is still some other Lifebloom dummy aura
2678 Unit::AuraList const& auras = m_target->GetAurasByType(SPELL_AURA_DUMMY);
2679 for(Unit::AuraList::const_iterator itr = auras.begin(); itr!=auras.end(); ++itr)
2680 if((*itr)->GetSpellProto()->SpellFamilyName == SPELLFAMILY_DRUID &&
2681 ((*itr)->GetSpellProto()->SpellFamilyFlags & UI64LIT(0x1000000000)))
2682 return;
2683
2684 // final heal
2685 if(m_target->IsInWorld() && m_stackAmount > 0)
2686 {
2687 int32 amount = m_modifier.m_amount / m_stackAmount;
2688 m_target->CastCustomSpell(m_target, 33778, &amount, NULL, NULL, true, NULL, this, GetCasterGUID());
2689
2690 if (Unit* caster = GetCaster())
2691 {
2692 int32 returnmana = (GetSpellProto()->ManaCostPercentage * caster->GetCreateMana() / 100) * m_stackAmount / 2;
2693 caster->CastCustomSpell(caster, 64372, &returnmana, NULL, NULL, true, NULL, this, GetCasterGUID());
2694 }
2695 }
2696 }
2697 return;
2698 }
2699
2700 // Predatory Strikes
2701 if(m_target->GetTypeId()==TYPEID_PLAYER && GetSpellProto()->SpellIconID == 1563)
2702 {
2703 ((Player*)m_target)->UpdateAttackPowerAndDamage();
2704 return;
2705 }
2706
2707 // Improved Moonkin Form
2708 if(GetSpellProto()->SpellIconID == 2855)
2709 {
2710 uint32 spell_id;
2711 switch(GetId())
2712 {
2713 case 48384: spell_id = 50170; break; //Rank 1
2714 case 48395: spell_id = 50171; break; //Rank 2
2715 case 48396: spell_id = 50172; break; //Rank 3
2716 default:
2717 sLog.outError("HandleAuraDummy: Not handled rank of IMF (Spell: %u)",GetId());
2718 return;
2719 }
2720
2721 if(apply)
2722 {
2723 if(m_target->m_form != FORM_MOONKIN)
2724 return;
2725
2726 m_target->CastSpell(m_target, spell_id, true);
2727 }
2728 else
2729 m_target-> RemoveAurasDueToSpell(spell_id);
2730 return;
2731 }
2732 break;
2733 }
2734 case SPELLFAMILY_HUNTER:
2735 break;
2736 case SPELLFAMILY_PALADIN:
2737 switch(GetId())
2738 {
2739 case 20911: // Blessing of Sanctuary
2740 case 25899: // Greater Blessing of Sanctuary
2741 {
2742 if (apply)
2743 m_target->CastSpell(m_target, 67480, true, NULL, this);
2744 else
2745 m_target->RemoveAurasDueToSpell(67480);
2746 return;
2747 }
2748 }
2749 break;
2750 case SPELLFAMILY_SHAMAN:
2751 break;
2752 }
2753
2754 // pet auras
2755 if(PetAura const* petSpell = sSpellMgr.GetPetAura(GetId(), m_effIndex))
2756 {
2757 if(apply)
2758 m_target->AddPetAura(petSpell);
2759 else
2760 m_target->RemovePetAura(petSpell);
2761 return;
2762 }
2763
2764 if(GetEffIndex()==0 && m_target->GetTypeId()==TYPEID_PLAYER)
2765 {
2766 SpellAreaForAreaMapBounds saBounds = sSpellMgr.GetSpellAreaForAuraMapBounds(GetId());
2767 if(saBounds.first != saBounds.second)
2768 {
2769 uint32 zone, area;
2770 m_target->GetZoneAndAreaId(zone, area);
2771
2772 for(SpellAreaForAreaMap::const_iterator itr = saBounds.first; itr != saBounds.second; ++itr)
2773 {
2774 // some auras remove at aura remove
2775 if(!itr->second->IsFitToRequirements((Player*)m_target, zone, area))
2776 m_target->RemoveAurasDueToSpell(itr->second->spellId);
2777 // some auras applied at aura apply
2778 else if(itr->second->autocast)
2779 {
2780 if( !m_target->HasAura(itr->second->spellId, 0) )
2781 m_target->CastSpell(m_target, itr->second->spellId, true);
2782 }
2783 }
2784 }
2785 }
2786 }
2787
2788 void Aura::HandleAuraMounted(bool apply, bool Real)
2789 {
2790 // only at real add/remove aura
2791 if(!Real)
2792 return;
2793
2794 if(apply)
2795 {
2796 CreatureInfo const* ci = ObjectMgr::GetCreatureTemplate(m_modifier.m_miscvalue);
2797 if(!ci)
2798 {
2799 sLog.outErrorDb("AuraMounted: `creature_template`='%u' not found in database (only need it modelid)", m_modifier.m_miscvalue);
2800 return;
2801 }
2802
2803 uint32 team = 0;
2804 if (m_target->GetTypeId()==TYPEID_PLAYER)
2805 team = ((Player*)m_target)->GetTeam();
2806
2807 uint32 display_id = sObjectMgr.ChooseDisplayId(team,ci);
2808 CreatureModelInfo const *minfo = sObjectMgr.GetCreatureModelRandomGender(display_id);
2809 if (minfo)
2810 display_id = minfo->modelid;
2811
2812 m_target->Mount(display_id);
2813 }
2814 else
2815 {
2816 m_target->Unmount();
2817 }
2818 }
2819
2820 void Aura::HandleAuraWaterWalk(bool apply, bool Real)
2821 {
2822 // only at real add/remove aura
2823 if(!Real)
2824 return;
2825
2826 WorldPacket data;
2827 if(apply)
2828 data.Initialize(SMSG_MOVE_WATER_WALK, 8+4);
2829 else
2830 data.Initialize(SMSG_MOVE_LAND_WALK, 8+4);
2831 data.append(m_target->GetPackGUID());
2832 data << uint32(0);
2833 m_target->SendMessageToSet(&data, true);
2834 }
2835
2836 void Aura::HandleAuraFeatherFall(bool apply, bool Real)
2837 {
2838 // only at real add/remove aura
2839 if(!Real)
2840 return;
2841
2842 WorldPacket data;
2843 if(apply)
2844 data.Initialize(SMSG_MOVE_FEATHER_FALL, 8+4);
2845 else
2846 data.Initialize(SMSG_MOVE_NORMAL_FALL, 8+4);
2847 data.append(m_target->GetPackGUID());
2848 data << uint32(0);
2849 m_target->SendMessageToSet(&data, true);
2850
2851 // start fall from current height
2852 if(!apply && m_target->GetTypeId() == TYPEID_PLAYER)
2853 ((Player*)m_target)->SetFallInformation(0, m_target->GetPositionZ());
2854 }
2855
2856 void Aura::HandleAuraHover(bool apply, bool Real)
2857 {
2858 // only at real add/remove aura
2859 if(!Real)
2860 return;
2861
2862 WorldPacket data;
2863 if(apply)
2864 data.Initialize(SMSG_MOVE_SET_HOVER, 8+4);
2865 else
2866 data.Initialize(SMSG_MOVE_UNSET_HOVER, 8+4);
2867 data.append(m_target->GetPackGUID());
2868 data << uint32(0);
2869 m_target->SendMessageToSet(&data, true);
2870 }
2871
2872 void Aura::HandleWaterBreathing(bool /*apply*/, bool /*Real*/)
2873 {
2874 // update timers in client
2875 if(m_target->GetTypeId()==TYPEID_PLAYER)
2876 ((Player*)m_target)->UpdateMirrorTimers();
2877 }
2878
2879 void Aura::HandleAuraModShapeshift(bool apply, bool Real)
2880 {
2881 if(!Real)
2882 return;
2883
2884 uint32 modelid = 0;
2885 Powers PowerType = POWER_MANA;
2886 ShapeshiftForm form = ShapeshiftForm(m_modifier.m_miscvalue);
2887
2888 SpellShapeshiftEntry const* ssEntry = sSpellShapeshiftStore.LookupEntry(form);
2889 if (!ssEntry)
2890 {
2891 sLog.outError("Unknown shapeshift form %u in spell %u", form, GetId());
2892 return;
2893 }
2894
2895 if (ssEntry->modelID_A)
2896 {
2897 // i will asume that creatures will always take the defined model from the dbc
2898 // since no field in creature_templates describes wether an alliance or
2899 // horde modelid should be used at shapeshifting
2900 if (m_target->GetTypeId() != TYPEID_PLAYER)
2901 modelid = ssEntry->modelID_A;
2902 else
2903 {
2904 // players are a bit difficult since the dbc has seldomly an horde modelid
2905 // so we add hacks here to set the right model
2906 if (Player::TeamForRace(m_target->getRace()) == ALLIANCE)
2907 modelid = ssEntry->modelID_A;
2908 else // 3.2.3 only the moonkin form has this information
2909 modelid = ssEntry->modelID_H;
2910
2911 // no model found, if player is horde we look here for our hardcoded modelids
2912 if (!modelid && Player::TeamForRace(m_target->getRace()) == HORDE)
2913 {
2914
2915 switch(form)
2916 {
2917 case FORM_CAT:
2918 modelid = 8571;
2919 break;
2920 case FORM_BEAR:
2921 case FORM_DIREBEAR:
2922 modelid = 2289;
2923 break;
2924 case FORM_FLIGHT:
2925 modelid = 20872;
2926 break;
2927 case FORM_FLIGHT_EPIC:
2928 modelid = 21244;
2929 break;
2930 // per default use alliance modelid
2931 // mostly horde and alliance share the same
2932 default:
2933 modelid = ssEntry->modelID_A;
2934 break;
2935 }
2936 }
2937 }
2938 }
2939
2940 // now only powertype must be set
2941 switch(form)
2942 {
2943 case FORM_CAT:
2944 PowerType = POWER_ENERGY;
2945 break;
2946 case FORM_BEAR:
2947 case FORM_DIREBEAR:
2948 case FORM_BATTLESTANCE:
2949 case FORM_BERSERKERSTANCE:
2950 case FORM_DEFENSIVESTANCE:
2951 PowerType = POWER_RAGE;
2952 break;
2953 default:
2954 break;
2955 }
2956
2957 // remove polymorph before changing display id to keep new display id
2958 switch ( form )
2959 {
2960 case FORM_CAT:
2961 case FORM_TREE:
2962 case FORM_TRAVEL:
2963 case FORM_AQUA:
2964 case FORM_BEAR:
2965 case FORM_DIREBEAR:
2966 case FORM_FLIGHT_EPIC:
2967 case FORM_FLIGHT:
2968 case FORM_MOONKIN:
2969 {
2970 // remove movement affects
2971 m_target->RemoveSpellsCausingAura(SPELL_AURA_MOD_ROOT);
2972 Unit::AuraList const& slowingAuras = m_target->GetAurasByType(SPELL_AURA_MOD_DECREASE_SPEED);
2973 for (Unit::AuraList::const_iterator iter = slowingAuras.begin(); iter != slowingAuras.end();)
2974 {
2975 SpellEntry const* aurSpellInfo = (*iter)->GetSpellProto();
2976
2977 uint32 aurMechMask = GetAllSpellMechanicMask(aurSpellInfo);
2978
2979 // If spell that caused this aura has Croud Control or Daze effect
2980 if((aurMechMask & MECHANIC_NOT_REMOVED_BY_SHAPESHIFT) ||
2981 // some Daze spells have these parameters instead of MECHANIC_DAZE (skip snare spells)
2982 aurSpellInfo->SpellIconID == 15 && aurSpellInfo->Dispel == 0 &&
2983 (aurMechMask & (1 << (MECHANIC_SNARE-1)))==0)
2984 {
2985 ++iter;
2986 continue;
2987 }
2988
2989 // All OK, remove aura now
2990 m_target->RemoveAurasDueToSpellByCancel(aurSpellInfo->Id);
2991 iter = slowingAuras.begin();
2992 }
2993
2994 // and polymorphic affects
2995 if(m_target->IsPolymorphed())
2996 m_target->RemoveAurasDueToSpell(m_target->getTransForm());
2997
2998 break;
2999 }
3000 default:
3001 break;
3002 }
3003
3004 if(apply)
3005 {
3006 // remove other shapeshift before applying a new one
3007 if(m_target->m_ShapeShiftFormSpellId)
3008 m_target->RemoveAurasDueToSpell(m_target->m_ShapeShiftFormSpellId, this);
3009
3010 m_target->SetByteValue(UNIT_FIELD_BYTES_2, 3, form);
3011
3012 if(modelid > 0)
3013 m_target->SetDisplayId(modelid);
3014
3015 if(PowerType != POWER_MANA)
3016 {
3017 // reset power to default values only at power change
3018 if(m_target->getPowerType() != PowerType)
3019 m_target->setPowerType(PowerType);
3020
3021 switch(form)
3022 {
3023 case FORM_CAT:
3024 case FORM_BEAR:
3025 case FORM_DIREBEAR:
3026 {
3027 // get furor proc chance
3028 int32 furorChance = 0;
3029 Unit::AuraList const& mDummy = m_target->GetAurasByType(SPELL_AURA_DUMMY);
3030 for(Unit::AuraList::const_iterator i = mDummy.begin(); i != mDummy.end(); ++i)
3031 {
3032 if ((*i)->GetSpellProto()->SpellIconID == 238)
3033 {
3034 furorChance = (*i)->GetModifier()->m_amount;
3035 break;
3036 }
3037 }
3038
3039 if (m_modifier.m_miscvalue == FORM_CAT)
3040 {
3041 // Furor chance is now amount allowed to save energy for cat form
3042 // without talent it reset to 0
3043 if (m_target->GetPower(POWER_ENERGY) > furorChance)
3044 {
3045 m_target->SetPower(POWER_ENERGY, 0);
3046 m_target->CastCustomSpell(m_target, 17099, &furorChance, NULL, NULL, this);
3047 }
3048 }
3049 else if(furorChance) // only if talent known
3050 {
3051 m_target->SetPower(POWER_RAGE, 0);
3052 if(urand(1,100) <= furorChance)
3053 m_target->CastSpell(m_target, 17057, true, NULL, this);
3054 }
3055 break;
3056 }
3057 case FORM_BATTLESTANCE:
3058 case FORM_DEFENSIVESTANCE:
3059 case FORM_BERSERKERSTANCE:
3060 {
3061 uint32 Rage_val = 0;
3062 // Stance mastery + Tactical mastery (both passive, and last have aura only in defense stance, but need apply at any stance switch)
3063 if(m_target->GetTypeId() == TYPEID_PLAYER)
3064 {
3065 PlayerSpellMap const& sp_list = ((Player *)m_target)->GetSpellMap();
3066 for (PlayerSpellMap::const_iterator itr = sp_list.begin(); itr != sp_list.end(); ++itr)
3067 {
3068 if(itr->second->state == PLAYERSPELL_REMOVED) continue;
3069 SpellEntry const *spellInfo = sSpellStore.LookupEntry(itr->first);
3070 if (spellInfo && spellInfo->SpellFamilyName == SPELLFAMILY_WARRIOR && spellInfo->SpellIconID == 139)
3071 Rage_val += m_target->CalculateSpellDamage(spellInfo, 0, spellInfo->EffectBasePoints[0], m_target) * 10;
3072 }
3073 }
3074
3075 if (m_target->GetPower(POWER_RAGE) > Rage_val)
3076 m_target->SetPower(POWER_RAGE, Rage_val);
3077 break;
3078 }
3079 default:
3080 break;
3081 }
3082 }
3083
3084 m_target->m_ShapeShiftFormSpellId = GetId();
3085 m_target->m_form = form;
3086
3087 // a form can give the player a new castbar with some spells.. this is a clientside process..
3088 // serverside just needs to register the new spells so that player isn't kicked as cheater
3089 if (m_target->GetTypeId() == TYPEID_PLAYER)
3090 for (uint32 i = 0; i < 8; ++i)
3091 if (ssEntry->spellId[i])
3092 ((Player*)m_target)->addSpell(ssEntry->spellId[i], true, false, false, false);
3093
3094 }
3095 else
3096 {
3097 if(modelid > 0)
3098 m_target->SetDisplayId(m_target->GetNativeDisplayId());
3099 m_target->SetByteValue(UNIT_FIELD_BYTES_2, 3, FORM_NONE);
3100 if(m_target->getClass() == CLASS_DRUID)
3101 m_target->setPowerType(POWER_MANA);
3102 m_target->m_ShapeShiftFormSpellId = 0;
3103 m_target->m_form = FORM_NONE;
3104
3105 switch(form)
3106 {
3107 // Nordrassil Harness - bonus
3108 case FORM_BEAR:
3109 case FORM_DIREBEAR:
3110 case FORM_CAT:
3111 if(Aura* dummy = m_target->GetDummyAura(37315) )
3112 m_target->CastSpell(m_target, 37316, true, NULL, dummy);
3113 break;
3114 // Nordrassil Regalia - bonus
3115 case FORM_MOONKIN:
3116 if(Aura* dummy = m_target->GetDummyAura(37324) )
3117 m_target->CastSpell(m_target, 37325, true, NULL, dummy);
3118 break;
3119 default:
3120 break;
3121 }
3122
3123 // look at the comment in apply-part
3124 if (m_target->GetTypeId() == TYPEID_PLAYER)
3125 for (uint32 i = 0; i < 8; ++i)
3126 if (ssEntry->spellId[i])
3127 ((Player*)m_target)->removeSpell(ssEntry->spellId[i], false, false, false);
3128
3129 }
3130
3131 // adding/removing linked auras
3132 // add/remove the shapeshift aura's boosts
3133 HandleShapeshiftBoosts(apply);
3134
3135 if(m_target->GetTypeId() == TYPEID_PLAYER)
3136 ((Player*)m_target)->InitDataForForm();
3137 }
3138
3139 void Aura::HandleAuraTransform(bool apply, bool Real)
3140 {
3141 if (apply)
3142 {
3143 // special case (spell specific functionality)
3144 if (m_modifier.m_miscvalue == 0)
3145 {
3146 // player applied only
3147 if (m_target->GetTypeId() != TYPEID_PLAYER)
3148 return;
3149
3150 switch (GetId())
3151 {
3152 // Orb of Deception
3153 case 16739:
3154 {
3155 uint32 orb_model = m_target->GetNativeDisplayId();
3156 switch(orb_model)
3157 {
3158 // Troll Female
3159 case 1479: m_target->SetDisplayId(10134); break;
3160 // Troll Male
3161 case 1478: m_target->SetDisplayId(10135); break;
3162 // Tauren Male
3163 case 59: m_target->SetDisplayId(10136); break;
3164 // Human Male
3165 case 49: m_target->SetDisplayId(10137); break;
3166 // Human Female
3167 case 50: m_target->SetDisplayId(10138); break;
3168 // Orc Male
3169 case 51: m_target->SetDisplayId(10139); break;
3170 // Orc Female
3171 case 52: m_target->SetDisplayId(10140); break;
3172 // Dwarf Male
3173 case 53: m_target->SetDisplayId(10141); break;
3174 // Dwarf Female
3175 case 54: m_target->SetDisplayId(10142); break;
3176 // NightElf Male
3177 case 55: m_target->SetDisplayId(10143); break;
3178 // NightElf Female
3179 case 56: m_target->SetDisplayId(10144); break;
3180 // Undead Female
3181 case 58: m_target->SetDisplayId(10145); break;
3182 // Undead Male
3183 case 57: m_target->SetDisplayId(10146); break;
3184 // Tauren Female
3185 case 60: m_target->SetDisplayId(10147); break;
3186 // Gnome Male
3187 case 1563: m_target->SetDisplayId(10148); break;
3188 // Gnome Female
3189 case 1564: m_target->SetDisplayId(10149); break;
3190 // BloodElf Female
3191 case 15475: m_target->SetDisplayId(17830); break;
3192 // BloodElf Male
3193 case 15476: m_target->SetDisplayId(17829); break;
3194 // Dranei Female
3195 case 16126: m_target->SetDisplayId(17828); break;
3196 // Dranei Male
3197 case 16125: m_target->SetDisplayId(17827); break;
3198 default: break;
3199 }
3200 break;
3201 }
3202 // Murloc costume
3203 case 42365: m_target->SetDisplayId(21723); break;
3204 // Honor the Dead
3205 case 65386:
3206 case 65495:
3207 {
3208 switch(m_target->getGender())
3209 {
3210 case GENDER_MALE:
3211 m_target->SetDisplayId(29203); // Chapman
3212 break;
3213 case GENDER_FEMALE:
3214 case GENDER_NONE:
3215 m_target->SetDisplayId(29204); // Catrina
3216 break;
3217 }
3218 break;
3219 }
3220 default: break;
3221 }
3222 }
3223 else
3224 {
3225 uint32 model_id;
3226
3227 CreatureInfo const * ci = ObjectMgr::GetCreatureTemplate(m_modifier.m_miscvalue);
3228 if (!ci)
3229 {
3230 model_id = 16358; // pig pink ^_^
3231 sLog.outError("Auras: unknown creature id = %d (only need its modelid) Form Spell Aura Transform in Spell ID = %d", m_modifier.m_miscvalue, GetId());
3232 }
3233 else
3234 model_id = ci->DisplayID_A[0]; // Will use the default model here
3235
3236 // Polymorph (sheep/penguin case)
3237 if (GetSpellProto()->SpellFamilyName == SPELLFAMILY_MAGE && GetSpellProto()->SpellIconID == 82)
3238 if (Unit* caster = GetCaster())
3239 if (caster->HasAura(52648)) // Glyph of the Penguin
3240 model_id = 26452;
3241
3242 m_target->SetDisplayId(model_id);
3243
3244 // Dragonmaw Illusion (set mount model also)
3245 if(GetId()==42016 && m_target->GetMountID() && !m_target->GetAurasByType(SPELL_AURA_MOD_INCREASE_FLIGHT_SPEED).empty())
3246 m_target->SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID,16314);
3247 }
3248
3249 // update active transform spell only not set or not overwriting negative by positive case
3250 if (!m_target->getTransForm() || !IsPositiveSpell(GetId()) || IsPositiveSpell(m_target->getTransForm()))
3251 m_target->setTransForm(GetId());
3252
3253 // polymorph case
3254 if (Real && m_target->GetTypeId() == TYPEID_PLAYER && m_target->IsPolymorphed())
3255 {
3256 // for players, start regeneration after 1s (in polymorph fast regeneration case)
3257 // only if caster is Player (after patch 2.4.2)
3258 if (IS_PLAYER_GUID(GetCasterGUID()) )
3259 ((Player*)m_target)->setRegenTimer(1*IN_MILISECONDS);
3260
3261 //dismount polymorphed target (after patch 2.4.2)
3262 if (m_target->IsMounted())
3263 m_target->RemoveSpellsCausingAura(SPELL_AURA_MOUNTED);
3264 }
3265 }
3266 else
3267 {
3268 // ApplyModifier(true) will reapply it if need
3269 m_target->setTransForm(0);
3270 m_target->SetDisplayId(m_target->GetNativeDisplayId());
3271
3272 // re-aplly some from still active with preference negative cases
3273 Unit::AuraList const& otherTransforms = m_target->GetAurasByType(SPELL_AURA_TRANSFORM);
3274 if (!otherTransforms.empty())
3275 {
3276 // look for other transform auras
3277 Aura* handledAura = *otherTransforms.begin();
3278 for(Unit::AuraList::const_iterator i = otherTransforms.begin();i != otherTransforms.end(); ++i)
3279 {
3280 // negative auras are preferred
3281 if (!IsPositiveSpell((*i)->GetSpellProto()->Id))
3282 {
3283 handledAura = *i;
3284 break;
3285 }
3286 }
3287 handledAura->ApplyModifier(true);
3288 }
3289
3290 // Dragonmaw Illusion (restore mount model)
3291 if (GetId() == 42016 && m_target->GetMountID() == 16314)
3292 {
3293 if (!m_target->GetAurasByType(SPELL_AURA_MOUNTED).empty())
3294 {
3295 uint32 cr_id = m_target->GetAurasByType(SPELL_AURA_MOUNTED).front()->GetModifier()->m_miscvalue;
3296 if (CreatureInfo const* ci = ObjectMgr::GetCreatureTemplate(cr_id))
3297 {
3298 uint32 team = 0;
3299 if (m_target->GetTypeId() == TYPEID_PLAYER)
3300 team = ((Player*)m_target)->GetTeam();
3301
3302 uint32 display_id = sObjectMgr.ChooseDisplayId(team, ci);
3303 CreatureModelInfo const *minfo = sObjectMgr.GetCreatureModelRandomGender(display_id);
3304 if (minfo)
3305 display_id = minfo->modelid;
3306
3307 m_target->SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, display_id);
3308 }
3309 }
3310 }
3311 }
3312 }
3313
3314 void Aura::HandleForceReaction(bool apply, bool Real)
3315 {
3316 if(m_target->GetTypeId() != TYPEID_PLAYER)
3317 return;
3318
3319 if(!Real)
3320 return;
3321
3322 Player* player = (Player*)m_target;
3323
3324 uint32 faction_id = m_modifier.m_miscvalue;
3325 ReputationRank faction_rank = ReputationRank(m_modifier.m_amount);
3326
3327 player->GetReputationMgr().ApplyForceReaction(faction_id, faction_rank, apply);
3328 player->GetReputationMgr().SendForceReactions();
3329
3330 // stop fighting if at apply forced rank friendly or at remove real rank friendly
3331 if (apply && faction_rank >= REP_FRIENDLY || !apply && player->GetReputationRank(faction_id) >= REP_FRIENDLY)
3332 player->StopAttackFaction(faction_id);
3333 }
3334
3335 void Aura::HandleAuraModSkill(bool apply, bool /*Real*/)
3336 {
3337 if(m_target->GetTypeId() != TYPEID_PLAYER)
3338 return;
3339
3340 uint32 prot=GetSpellProto()->EffectMiscValue[m_effIndex];
3341 int32 points = GetModifier()->m_amount;
3342
3343 ((Player*)m_target)->ModifySkillBonus(prot, (apply ? points: -points), m_modifier.m_auraname == SPELL_AURA_MOD_SKILL_TALENT);
3344 if(prot == SKILL_DEFENSE)
3345 ((Player*)m_target)->UpdateDefenseBonusesMod();
3346 }
3347
3348 void Aura::HandleChannelDeathItem(bool apply, bool Real)
3349 {
3350 if(Real && !apply)
3351 {
3352 if(m_removeMode != AURA_REMOVE_BY_DEATH)
3353 return;
3354 // Item amount
3355 if (m_modifier.m_amount <= 0)
3356 return;
3357
3358 SpellEntry const *spellInfo = GetSpellProto();
3359 if(spellInfo->EffectItemType[m_effIndex] == 0)
3360 return;
3361
3362 Unit* victim = GetTarget();
3363 Unit* caster = GetCaster();
3364 if (!caster || caster->GetTypeId() != TYPEID_PLAYER)
3365 return;
3366
3367 // Soul Shard only from non-grey units
3368 if( spellInfo->EffectItemType[m_effIndex] == 6265 &&
3369 (victim->getLevel() <= MaNGOS::XP::GetGrayLevel(caster->getLevel()) ||
3370 victim->GetTypeId()==TYPEID_UNIT && !((Player*)caster)->isAllowedToLoot((Creature*)victim)) )
3371 return;
3372 //Adding items
3373 uint32 noSpaceForCount = 0;
3374 uint32 count = m_modifier.m_amount;
3375
3376 ItemPosCountVec dest;
3377 uint8 msg = ((Player*)caster)->CanStoreNewItem( NULL_BAG, NULL_SLOT, dest, spellInfo->EffectItemType[m_effIndex], count, &noSpaceForCount);
3378 if( msg != EQUIP_ERR_OK )
3379 {
3380 count-=noSpaceForCount;
3381 ((Player*)caster)->SendEquipError( msg, NULL, NULL );
3382 if (count==0)
3383 return;
3384 }
3385
3386 Item* newitem = ((Player*)caster)->StoreNewItem(dest, spellInfo->EffectItemType[m_effIndex], true);
3387 ((Player*)caster)->SendNewItem(newitem, count, true, false);
3388 }
3389 }
3390
3391 void Aura::HandleBindSight(bool apply, bool /*Real*/)
3392 {
3393 Unit* caster = GetCaster();
3394 if(!caster || caster->GetTypeId() != TYPEID_PLAYER)
3395 return;
3396
3397 ((Player*)caster)->SetFarSightGUID(apply ? m_target->GetGUID() : 0);
3398 }
3399
3400 void Aura::HandleFarSight(bool apply, bool /*Real*/)
3401 {
3402 Unit* caster = GetCaster();
3403 if(!caster || caster->GetTypeId() != TYPEID_PLAYER)
3404 return;
3405
3406 ((Player*)caster)->SetFarSightGUID(apply ? m_target->GetGUID() : 0);
3407 }
3408
3409 void Aura::HandleAuraTrackCreatures(bool apply, bool /*Real*/)
3410 {
3411 if(m_target->GetTypeId()!=TYPEID_PLAYER)
3412 return;
3413
3414 if(apply)
3415 m_target->RemoveNoStackAurasDueToAura(this);
3416 m_target->SetUInt32Value(PLAYER_TRACK_CREATURES, apply ? ((uint32)1)<<(m_modifier.m_miscvalue-1) : 0 );
3417 }
3418
3419 void Aura::HandleAuraTrackResources(bool apply, bool /*Real*/)
3420 {
3421 if(m_target->GetTypeId()!=TYPEID_PLAYER)
3422 return;
3423
3424 if(apply)
3425 m_target->RemoveNoStackAurasDueToAura(this);
3426 m_target->SetUInt32Value(PLAYER_TRACK_RESOURCES, apply ? ((uint32)1)<<(m_modifier.m_miscvalue-1): 0 );
3427 }
3428
3429 void Aura::HandleAuraTrackStealthed(bool apply, bool /*Real*/)
3430 {
3431 if(m_target->GetTypeId()!=TYPEID_PLAYER)
3432 return;
3433
3434 if(apply)
3435 m_target->RemoveNoStackAurasDueToAura(this);
3436
3437 m_target->ApplyModFlag(PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTE_TRACK_STEALTHED, apply);
3438 }
3439
3440 void Aura::HandleAuraModScale(bool apply, bool /*Real*/)
3441 {
3442 m_target->ApplyPercentModFloatValue(OBJECT_FIELD_SCALE_X, m_modifier.m_amount, apply);
3443 }
3444
3445 void Aura::HandleModPossess(bool apply, bool Real)
3446 {
3447 if(!Real)
3448 return;
3449
3450 // not possess yourself
3451 if(GetCasterGUID() == m_target->GetGUID())
3452 return;
3453
3454 Unit* caster = GetCaster();
3455 if(!caster || caster->GetTypeId() != TYPEID_PLAYER)
3456 return;
3457
3458 Player* p_caster = (Player*)caster;
3459
3460
3461 if( apply )
3462 {
3463 m_target->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED);
3464
3465 m_target->SetCharmerGUID(p_caster->GetGUID());
3466 m_target->setFaction(p_caster->getFaction());
3467
3468 p_caster->SetCharm(m_target);
3469
3470 p_caster->SetFarSightGUID(m_target->GetGUID());
3471 p_caster->SetClientControl(m_target, 1);
3472 p_caster->SetMover(m_target);
3473
3474 m_target->CombatStop();
3475 m_target->DeleteThreatList();
3476
3477 if(m_target->GetTypeId() == TYPEID_UNIT)
3478 {
3479 m_target->StopMoving();
3480 m_target->GetMotionMaster()->Clear();
3481 m_target->GetMotionMaster()->MoveIdle();
3482 }
3483 else if(m_target->GetTypeId() == TYPEID_PLAYER)
3484 {
3485 ((Player*)m_target)->SetClientControl(m_target, 0);
3486 }
3487
3488 if(CharmInfo *charmInfo = m_target->InitCharmInfo(m_target))
3489 charmInfo->InitPossessCreateSpells();
3490
3491 p_caster->PossessSpellInitialize();
3492 }
3493 else
3494 {
3495 m_target->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED);
3496
3497 m_target->SetCharmerGUID(0);
3498 p_caster->InterruptSpell(CURRENT_CHANNELED_SPELL); // the spell is not automatically canceled when interrupted, do it now
3499
3500 if(m_target->GetTypeId() == TYPEID_PLAYER)
3501 {
3502 ((Player*)m_target)->setFactionForRace(m_target->getRace());
3503 ((Player*)m_target)->SetClientControl(m_target, 1);
3504 }
3505 else if(m_target->GetTypeId() == TYPEID_UNIT)
3506 {
3507 CreatureInfo const *cinfo = ((Creature*)m_target)->GetCreatureInfo();
3508 m_target->setFaction(cinfo->faction_A);
3509 }
3510
3511 p_caster->SetCharm(NULL);
3512
3513 p_caster->SetFarSightGUID(0);
3514 p_caster->SetClientControl(m_target, 0);
3515 p_caster->SetMover(NULL);
3516
3517 p_caster->RemovePetActionBar();
3518
3519 if(m_target->GetTypeId() == TYPEID_UNIT)
3520 {
3521 ((Creature*)m_target)->AIM_Initialize();
3522
3523 if (((Creature*)m_target)->AI())
3524 ((Creature*)m_target)->AI()->AttackedBy(caster);
3525 }
3526 }
3527 }
3528
3529 void Aura::HandleModPossessPet(bool apply, bool Real)
3530 {
3531 if(!Real)
3532 return;
3533
3534 Unit* caster = GetCaster();
3535 if(!caster || caster->GetTypeId() != TYPEID_PLAYER)
3536 return;
3537
3538 Pet *pet = caster->GetPet();
3539 if(!pet || pet != m_target)
3540 return;
3541
3542 Player* p_caster = (Player*)caster;
3543
3544 if(apply)
3545 pet->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED);
3546 else
3547 pet->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED);
3548
3549 p_caster->SetFarSightGUID(apply ? pet->GetGUID() : 0);
3550 p_caster->SetCharm(apply ? pet : NULL);
3551 p_caster->SetClientControl(pet, apply ? 1 : 0);
3552 ((Player*)caster)->SetMover(apply ? pet : NULL);
3553
3554 if(apply)
3555 {
3556 pet->StopMoving();
3557 pet->GetMotionMaster()->Clear();
3558 pet->GetMotionMaster()->MoveIdle();
3559 }
3560 else
3561 {
3562 pet->AttackStop();
3563 pet->GetMotionMaster()->MoveFollow(caster, PET_FOLLOW_DIST, PET_FOLLOW_ANGLE);
3564 pet->AddMonsterMoveFlag(MONSTER_MOVE_WALK);
3565 }
3566 }
3567
3568 void Aura::HandleAuraModPetTalentsPoints(bool /*Apply*/, bool Real)
3569 {
3570 if(!Real)
3571 return;
3572
3573 // Recalculate pet talent points
3574 if (Pet *pet=m_target->GetPet())
3575 pet->InitTalentForLevel();
3576 }
3577
3578 void Aura::HandleModCharm(bool apply, bool Real)
3579 {
3580 if(!Real)
3581 return;
3582
3583 // not charm yourself
3584 if(GetCasterGUID() == m_target->GetGUID())
3585 return;
3586
3587 Unit* caster = GetCaster();
3588 if(!caster)
3589 return;
3590
3591 if( apply )
3592 {
3593 if (m_target->GetCharmerGUID())
3594 {
3595 m_target->RemoveSpellsCausingAura(SPELL_AURA_MOD_CHARM);
3596 m_target->RemoveSpellsCausingAura(SPELL_AURA_MOD_POSSESS);
3597 }
3598
3599 m_target->SetCharmerGUID(GetCasterGUID());
3600 m_target->setFaction(caster->getFaction());
3601 m_target->CastStop(m_target == caster ? GetId() : 0);
3602 caster->SetCharm(m_target);
3603
3604 m_target->CombatStop();
3605 m_target->DeleteThreatList();
3606
3607 if(m_target->GetTypeId() == TYPEID_UNIT)
3608 {
3609 ((Creature*)m_target)->AIM_Initialize();
3610 CharmInfo *charmInfo = m_target->InitCharmInfo(m_target);
3611 charmInfo->InitCharmCreateSpells();
3612 charmInfo->SetReactState( REACT_DEFENSIVE );
3613
3614 if(caster->GetTypeId() == TYPEID_PLAYER && caster->getClass() == CLASS_WARLOCK)
3615 {
3616 CreatureInfo const *cinfo = ((Creature*)m_target)->GetCreatureInfo();
3617 if(cinfo && cinfo->type == CREATURE_TYPE_DEMON)
3618 {
3619 // creature with pet number expected have class set
3620 if(m_target->GetByteValue(UNIT_FIELD_BYTES_0, 1)==0)
3621 {
3622 if(cinfo->unit_class==0)
3623 sLog.outErrorDb("Creature (Entry: %u) have unit_class = 0 but used in charmed spell, that will be result client crash.",cinfo->Entry);
3624 else
3625 sLog.outError("Creature (Entry: %u) have unit_class = %u but at charming have class 0!!! that will be result client crash.",cinfo->Entry,cinfo->unit_class);
3626
3627 m_target->SetByteValue(UNIT_FIELD_BYTES_0, 1, CLASS_MAGE);
3628 }
3629
3630 //just to enable stat window
3631 charmInfo->SetPetNumber(sObjectMgr.GeneratePetNumber(), true);
3632 //if charmed two demons the same session, the 2nd gets the 1st one's name
3633 m_target->SetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP, time(NULL));
3634 }
3635 }
3636 }
3637
3638 if(caster->GetTypeId() == TYPEID_PLAYER)
3639 ((Player*)caster)->CharmSpellInitialize();
3640 }
3641 else
3642 {
3643 m_target->SetCharmerGUID(0);
3644
3645 if(m_target->GetTypeId() == TYPEID_PLAYER)
3646 ((Player*)m_target)->setFactionForRace(m_target->getRace());
3647 else
3648 {
3649 CreatureInfo const *cinfo = ((Creature*)m_target)->GetCreatureInfo();
3650
3651 // restore faction
3652 if(((Creature*)m_target)->isPet())
3653 {
3654 if(Unit* owner = m_target->GetOwner())
3655 m_target->setFaction(owner->getFaction());
3656 else if(cinfo)
3657 m_target->setFaction(cinfo->faction_A);
3658 }
3659 else if(cinfo) // normal creature
3660 m_target->setFaction(cinfo->faction_A);
3661
3662 // restore UNIT_FIELD_BYTES_0
3663 if(cinfo && caster->GetTypeId() == TYPEID_PLAYER && caster->getClass() == CLASS_WARLOCK && cinfo->type == CREATURE_TYPE_DEMON)
3664 {
3665 // DB must have proper class set in field at loading, not req. restore, including workaround case at apply
3666 // m_target->SetByteValue(UNIT_FIELD_BYTES_0, 1, cinfo->unit_class);
3667
3668 if(m_target->GetCharmInfo())
3669 m_target->GetCharmInfo()->SetPetNumber(0, true);
3670 else
3671 sLog.outError("Aura::HandleModCharm: target (GUID: %u TypeId: %u) has a charm aura but no charm info!", m_target->GetGUIDLow(), m_target->GetTypeId());
3672 }
3673 }
3674
3675 caster->SetCharm(NULL);
3676
3677 if(caster->GetTypeId() == TYPEID_PLAYER)
3678 ((Player*)caster)->RemovePetActionBar();
3679
3680 if(m_target->GetTypeId() == TYPEID_UNIT)
3681 {
3682 ((Creature*)m_target)->AIM_Initialize();
3683 if (((Creature*)m_target)->AI())
3684 ((Creature*)m_target)->AI()->AttackedBy(caster);
3685 }
3686 }
3687 }
3688
3689 void Aura::HandleModConfuse(bool apply, bool Real)
3690 {
3691 if(!Real)
3692 return;
3693
3694 m_target->SetConfused(apply, GetCasterGUID(), GetId());
3695 }
3696
3697 void Aura::HandleModFear(bool apply, bool Real)
3698 {
3699 if (!Real)
3700 return;
3701
3702 m_target->SetFeared(apply, GetCasterGUID(), GetId());
3703 }
3704
3705 void Aura::HandleFeignDeath(bool apply, bool Real)
3706 {
3707 if(!Real)
3708 return;
3709
3710 m_target->SetFeignDeath(apply, GetCasterGUID(), GetId());
3711 }
3712
3713 void Aura::HandleAuraModDisarm(bool apply, bool Real)
3714 {
3715 if(!Real)
3716 return;
3717
3718 if(!apply && m_target->HasAuraType(SPELL_AURA_MOD_DISARM))
3719 return;
3720
3721 // not sure for it's correctness
3722 if(apply)
3723 m_target->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISARMED);
3724 else
3725 m_target->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISARMED);
3726
3727 // only at real add/remove aura
3728 if (m_target->GetTypeId() != TYPEID_PLAYER)
3729 return;
3730
3731 // main-hand attack speed already set to special value for feral form already and don't must change and reset at remove.
3732 if (m_target->IsInFeralForm())
3733 return;
3734
3735 if (apply)
3736 m_target->SetAttackTime(BASE_ATTACK,BASE_ATTACK_TIME);
3737 else
3738 ((Player *)m_target)->SetRegularAttackTime();
3739
3740 m_target->UpdateDamagePhysical(BASE_ATTACK);
3741 }
3742
3743 void Aura::HandleAuraModStun(bool apply, bool Real)
3744 {
3745 if(!Real)
3746 return;
3747
3748 if (apply)
3749 {
3750 // Frost stun aura -> freeze/unfreeze target
3751 if (GetSpellSchoolMask(m_spellProto) & SPELL_SCHOOL_MASK_FROST)
3752 m_target->ModifyAuraState(AURA_STATE_FROZEN, apply);
3753
3754 m_target->addUnitState(UNIT_STAT_STUNNED);
3755 m_target->SetTargetGUID(0);
3756
3757 m_target->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED);
3758 m_target->CastStop(m_target->GetGUID() == GetCasterGUID() ? GetId() : 0);
3759
3760 // Creature specific
3761 if(m_target->GetTypeId() != TYPEID_PLAYER)
3762 m_target->StopMoving();
3763 else
3764 {
3765 ((Player*)m_target)->m_movementInfo.SetMovementFlags(MOVEMENTFLAG_NONE);
3766 m_target->SetStandState(UNIT_STAND_STATE_STAND);// in 1.5 client
3767 }
3768
3769 WorldPacket data(SMSG_FORCE_MOVE_ROOT, 8);
3770 data.append(m_target->GetPackGUID());
3771 data << uint32(0);
3772 m_target->SendMessageToSet(&data, true);
3773
3774 // Summon the Naj'entus Spine GameObject on target if spell is Impaling Spine
3775 if(GetId() == 39837)
3776 {
3777 GameObject* pObj = new GameObject;
3778 if(pObj->Create(sObjectMgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT), 185584, m_target->GetMap(), m_target->GetPhaseMask(),
3779 m_target->GetPositionX(), m_target->GetPositionY(), m_target->GetPositionZ(), m_target->GetOrientation(), 0.0f, 0.0f, 0.0f, 0.0f, 100, GO_STATE_READY))
3780 {
3781 pObj->SetRespawnTime(GetAuraDuration()/IN_MILISECONDS);
3782 pObj->SetSpellId(GetId());
3783 m_target->AddGameObject(pObj);
3784 m_target->GetMap()->Add(pObj);
3785 }
3786 else
3787 delete pObj;
3788 }
3789 }
3790 else
3791 {
3792 // Frost stun aura -> freeze/unfreeze target
3793 if (GetSpellSchoolMask(m_spellProto) & SPELL_SCHOOL_MASK_FROST)
3794 {
3795 bool found_another = false;
3796 for(AuraType const* itr = &frozenAuraTypes[0]; *itr != SPELL_AURA_NONE; ++itr)
3797 {
3798 Unit::AuraList const& auras = m_target->GetAurasByType(*itr);
3799 for(Unit::AuraList::const_iterator i = auras.begin(); i != auras.end(); ++i)
3800 {
3801 if( GetSpellSchoolMask((*i)->GetSpellProto()) & SPELL_SCHOOL_MASK_FROST)
3802 {
3803 found_another = true;
3804 break;
3805 }
3806 }
3807 if(found_another)
3808 break;
3809 }
3810
3811 if(!found_another)
3812 m_target->ModifyAuraState(AURA_STATE_FROZEN, apply);
3813 }
3814
3815 // Real remove called after current aura remove from lists, check if other similar auras active
3816 if(m_target->HasAuraType(SPELL_AURA_MOD_STUN))
3817 return;
3818
3819 m_target->clearUnitState(UNIT_STAT_STUNNED);
3820 m_target->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED);
3821
3822 if(!m_target->hasUnitState(UNIT_STAT_ROOT)) // prevent allow move if have also root effect
3823 {
3824 if(m_target->getVictim() && m_target->isAlive())
3825 m_target->SetTargetGUID(m_target->getVictim()->GetGUID());
3826
3827 WorldPacket data(SMSG_FORCE_MOVE_UNROOT, 8+4);
3828 data.append(m_target->GetPackGUID());
3829 data << uint32(0);
3830 m_target->SendMessageToSet(&data, true);
3831 }
3832
3833 // Wyvern Sting
3834 if (m_spellProto->SpellFamilyName == SPELLFAMILY_HUNTER && m_spellProto->SpellFamilyFlags & UI64LIT(0x0000100000000000))
3835 {
3836 Unit* caster = GetCaster();
3837 if( !caster || caster->GetTypeId()!=TYPEID_PLAYER )
3838 return;
3839
3840 uint32 spell_id = 0;
3841
3842 switch(GetId())
3843 {
3844 case 19386: spell_id = 24131; break;
3845 case 24132: spell_id = 24134; break;
3846 case 24133: spell_id = 24135; break;
3847 case 27068: spell_id = 27069; break;
3848 case 49011: spell_id = 49009; break;
3849 case 49012: spell_id = 49010; break;
3850 default:
3851 sLog.outError("Spell selection called for unexpected original spell %u, new spell for this spell family?",GetId());
3852 return;
3853 }
3854
3855 SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell_id);
3856
3857 if(!spellInfo)
3858 return;
3859
3860 caster->CastSpell(m_target,spellInfo,true,NULL,this);
3861 return;
3862 }
3863 }
3864 }
3865
3866 void Aura::HandleModStealth(bool apply, bool Real)
3867 {
3868 if (apply)
3869 {
3870 // drop flag at stealth in bg
3871 m_target->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_IMMUNE_OR_LOST_SELECTION);
3872
3873 // only at real aura add
3874 if (Real)
3875 {
3876 m_target->SetStandFlags(UNIT_STAND_FLAGS_CREEP);
3877
3878 if (m_target->GetTypeId()==TYPEID_PLAYER)
3879 m_target->SetFlag(PLAYER_FIELD_BYTES2, 0x2000);
3880
3881 // apply only if not in GM invisibility (and overwrite invisibility state)
3882 if (m_target->GetVisibility()!=VISIBILITY_OFF)
3883 {
3884 m_target->SetVisibility(VISIBILITY_GROUP_NO_DETECT);
3885 m_target->SetVisibility(VISIBILITY_GROUP_STEALTH);
3886 }
3887
3888 // apply full stealth period bonuses only at first stealth aura in stack
3889 if(m_target->GetAurasByType(SPELL_AURA_MOD_STEALTH).size()<=1)
3890 {
3891 Unit::AuraList const& mDummyAuras = m_target->GetAurasByType(SPELL_AURA_DUMMY);
3892 for(Unit::AuraList::const_iterator i = mDummyAuras.begin();i != mDummyAuras.end(); ++i)
3893 {
3894 // Master of Subtlety
3895 if ((*i)->GetSpellProto()->SpellIconID == 2114)
3896 {
3897 m_target->RemoveAurasDueToSpell(31666);
3898 int32 bp = (*i)->GetModifier()->m_amount;
3899 m_target->CastCustomSpell(m_target,31665,&bp,NULL,NULL,true);
3900 }
3901 // Overkill
3902 else if ((*i)->GetId() == 58426 && GetSpellProto()->SpellFamilyFlags & UI64LIT(0x0000000000400000))
3903 {
3904 m_target->RemoveAurasDueToSpell(58428);
3905 m_target->CastSpell(m_target, 58427, true);
3906 }
3907 }
3908 }
3909 }
3910 }
3911 else
3912 {
3913 // only at real aura remove of _last_ SPELL_AURA_MOD_STEALTH
3914 if (Real && !m_target->HasAuraType(SPELL_AURA_MOD_STEALTH))
3915 {
3916 // if no GM invisibility
3917 if (m_target->GetVisibility()!=VISIBILITY_OFF)
3918 {
3919 m_target->RemoveStandFlags(UNIT_STAND_FLAGS_CREEP);
3920
3921 if (m_target->GetTypeId()==TYPEID_PLAYER)
3922 m_target->RemoveFlag(PLAYER_FIELD_BYTES2, 0x2000);
3923
3924 // restore invisibility if any
3925 if (m_target->HasAuraType(SPELL_AURA_MOD_INVISIBILITY))
3926 {
3927 m_target->SetVisibility(VISIBILITY_GROUP_NO_DETECT);
3928 m_target->SetVisibility(VISIBILITY_GROUP_INVISIBILITY);
3929 }
3930 else
3931 m_target->SetVisibility(VISIBILITY_ON);
3932 }
3933
3934 // apply delayed talent bonus remover at last stealth aura remove
3935 Unit::AuraList const& mDummyAuras = m_target->GetAurasByType(SPELL_AURA_DUMMY);
3936 for(Unit::AuraList::const_iterator i = mDummyAuras.begin();i != mDummyAuras.end(); ++i)
3937 {
3938 // Master of Subtlety
3939 if ((*i)->GetSpellProto()->SpellIconID == 2114)
3940 m_target->CastSpell(m_target, 31666, true);
3941 // Overkill
3942 else if ((*i)->GetId() == 58426 && GetSpellProto()->SpellFamilyFlags & UI64LIT(0x0000000000400000))
3943 m_target->CastSpell(m_target, 58428, true);
3944 }
3945 }
3946 }
3947 }
3948
3949 void Aura::HandleInvisibility(bool apply, bool Real)
3950 {
3951 if(apply)
3952 {
3953 m_target->m_invisibilityMask |= (1 << m_modifier.m_miscvalue);
3954
3955 m_target->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_IMMUNE_OR_LOST_SELECTION);
3956
3957 if(Real && m_target->GetTypeId()==TYPEID_PLAYER)
3958 {
3959 // apply glow vision
3960 m_target->SetFlag(PLAYER_FIELD_BYTES2,PLAYER_FIELD_BYTE2_INVISIBILITY_GLOW);
3961
3962 }
3963
3964 // apply only if not in GM invisibility and not stealth
3965 if(m_target->GetVisibility() == VISIBILITY_ON)
3966 {
3967 // Aura not added yet but visibility code expect temporary add aura
3968 m_target->SetVisibility(VISIBILITY_GROUP_NO_DETECT);
3969 m_target->SetVisibility(VISIBILITY_GROUP_INVISIBILITY);
3970 }
3971 }
3972 else
3973 {
3974 // recalculate value at modifier remove (current aura already removed)
3975 m_target->m_invisibilityMask = 0;
3976 Unit::AuraList const& auras = m_target->GetAurasByType(SPELL_AURA_MOD_INVISIBILITY);
3977 for(Unit::AuraList::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
3978 m_target->m_invisibilityMask |= (1 << m_modifier.m_miscvalue);
3979
3980 // only at real aura remove and if not have different invisibility auras.
3981 if(Real && m_target->m_invisibilityMask == 0)
3982 {
3983 // remove glow vision
3984 if(m_target->GetTypeId() == TYPEID_PLAYER)
3985 m_target->RemoveFlag(PLAYER_FIELD_BYTES2,PLAYER_FIELD_BYTE2_INVISIBILITY_GLOW);
3986
3987 // apply only if not in GM invisibility & not stealthed while invisible
3988 if(m_target->GetVisibility() != VISIBILITY_OFF)
3989 {
3990 // if have stealth aura then already have stealth visibility
3991 if(!m_target->HasAuraType(SPELL_AURA_MOD_STEALTH))
3992 m_target->SetVisibility(VISIBILITY_ON);
3993 }
3994 }
3995 }
3996 }
3997
3998 void Aura::HandleInvisibilityDetect(bool apply, bool Real)
3999 {
4000 if(apply)
4001 {
4002 m_target->m_detectInvisibilityMask |= (1 << m_modifier.m_miscvalue);
4003 }
4004 else
4005 {
4006 // recalculate value at modifier remove (current aura already removed)
4007 m_target->m_detectInvisibilityMask = 0;
4008 Unit::AuraList const& auras = m_target->GetAurasByType(SPELL_AURA_MOD_INVISIBILITY_DETECTION);
4009 for(Unit::AuraList::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
4010 m_target->m_detectInvisibilityMask |= (1 << m_modifier.m_miscvalue);
4011 }
4012 if(Real && m_target->GetTypeId()==TYPEID_PLAYER)
4013 ((Player*)m_target)->UpdateVisibilityForPlayer();
4014 }
4015
4016 void Aura::HandleAuraModRoot(bool apply, bool Real)
4017 {
4018 // only at real add/remove aura
4019 if(!Real)
4020 return;
4021
4022 if (apply)
4023 {
4024 // Frost root aura -> freeze/unfreeze target
4025 if (GetSpellSchoolMask(m_spellProto) & SPELL_SCHOOL_MASK_FROST)
4026 m_target->ModifyAuraState(AURA_STATE_FROZEN, apply);
4027
4028 m_target->addUnitState(UNIT_STAT_ROOT);
4029 m_target->SetTargetGUID(0);
4030 // probably wrong (this add skinnable flag)
4031 // TODO: find correct flag
4032 //m_target->SetFlag(UNIT_FIELD_FLAGS,(apply_stat<<16));
4033
4034 //Save last orientation
4035 if( m_target->getVictim() )
4036 m_target->SetOrientation(m_target->GetAngle(m_target->getVictim()));
4037
4038 if(m_target->GetTypeId() == TYPEID_PLAYER)
4039 {
4040 WorldPacket data(SMSG_FORCE_MOVE_ROOT, 10);
4041 data.append(m_target->GetPackGUID());
4042 data << (uint32)2;
4043 m_target->SendMessageToSet(&data, true);
4044
4045 //Clear unit movement flags
4046 ((Player*)m_target)->m_movementInfo.SetMovementFlags(MOVEMENTFLAG_NONE);
4047 }
4048 else
4049 m_target->StopMoving();
4050 }
4051 else
4052 {
4053 // Frost root aura -> freeze/unfreeze target
4054 if (GetSpellSchoolMask(m_spellProto) & SPELL_SCHOOL_MASK_FROST)
4055 {
4056 bool found_another = false;
4057 for(AuraType const* itr = &frozenAuraTypes[0]; *itr != SPELL_AURA_NONE; ++itr)
4058 {
4059 Unit::AuraList const& auras = m_target->GetAurasByType(*itr);
4060 for(Unit::AuraList::const_iterator i = auras.begin(); i != auras.end(); ++i)
4061 {
4062 if( GetSpellSchoolMask((*i)->GetSpellProto()) & SPELL_SCHOOL_MASK_FROST)
4063 {
4064 found_another = true;
4065 break;
4066 }
4067 }
4068 if(found_another)
4069 break;
4070 }
4071
4072 if(!found_another)
4073 m_target->ModifyAuraState(AURA_STATE_FROZEN, apply);
4074 }
4075
4076 // Real remove called after current aura remove from lists, check if other similar auras active
4077 if(m_target->HasAuraType(SPELL_AURA_MOD_ROOT))
4078 return;
4079
4080 m_target->clearUnitState(UNIT_STAT_ROOT);
4081 // probably wrong (this add skinnable flag)
4082 // TODO: find correct flag
4083 //m_target->RemoveFlag(UNIT_FIELD_FLAGS,(apply_stat<<16));
4084
4085 if(!m_target->hasUnitState(UNIT_STAT_STUNNED)) // prevent allow move if have also stun effect
4086 {
4087 if(m_target->getVictim() && m_target->isAlive())
4088 m_target->SetTargetGUID(m_target->getVictim()->GetGUID());
4089
4090 if(m_target->GetTypeId() == TYPEID_PLAYER)
4091 {
4092 WorldPacket data(SMSG_FORCE_MOVE_UNROOT, 10);
4093 data.append(m_target->GetPackGUID());
4094 data << (uint32)2;
4095 m_target->SendMessageToSet(&data, true);
4096 }
4097 }
4098 }
4099 }
4100
4101 void Aura::HandleAuraModSilence(bool apply, bool Real)
4102 {
4103 // only at real add/remove aura
4104 if(!Real)
4105 return;
4106
4107 if(apply)
4108 {
4109 m_target->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED);
4110 // Stop cast only spells vs PreventionType == SPELL_PREVENTION_TYPE_SILENCE
4111 for (uint32 i = CURRENT_MELEE_SPELL; i < CURRENT_MAX_SPELL; ++i)
4112 if (Spell* spell = m_target->GetCurrentSpell(CurrentSpellTypes(i)))
4113 if(spell->m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE)
4114 // Stop spells on prepare or casting state
4115 m_target->InterruptSpell(CurrentSpellTypes(i), false);
4116 }
4117 else
4118 {
4119 // Real remove called after current aura remove from lists, check if other similar auras active
4120 if(m_target->HasAuraType(SPELL_AURA_MOD_SILENCE))
4121 return;
4122
4123 m_target->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED);
4124 }
4125 }
4126
4127 void Aura::HandleModThreat(bool apply, bool Real)
4128 {
4129 // only at real add/remove aura
4130 if (!Real)
4131 return;
4132
4133 if (!m_target->isAlive())
4134 return;
4135
4136 Unit* caster = GetCaster();
4137
4138 if (!caster || !caster->isAlive())
4139 return;
4140
4141 int level_diff = 0;
4142 int multiplier = 0;
4143 switch (GetId())
4144 {
4145 // Arcane Shroud
4146 case 26400:
4147 level_diff = m_target->getLevel() - 60;
4148 multiplier = 2;
4149 break;
4150 // The Eye of Diminution
4151 case 28862:
4152 level_diff = m_target->getLevel() - 60;
4153 multiplier = 1;
4154 break;
4155 }
4156
4157 if (level_diff > 0)
4158 m_modifier.m_amount += multiplier * level_diff;
4159
4160 if (m_target->GetTypeId() == TYPEID_PLAYER)
4161 for(int8 x=0;x < MAX_SPELL_SCHOOL;x++)
4162 if (m_modifier.m_miscvalue & int32(1<<x))
4163 ApplyPercentModFloatVar(m_target->m_threatModifier[x], m_modifier.m_amount, apply);
4164 }
4165
4166 void Aura::HandleAuraModTotalThreat(bool apply, bool Real)
4167 {
4168 // only at real add/remove aura
4169 if (!Real)
4170 return;
4171
4172 if (!m_target->isAlive() || m_target->GetTypeId() != TYPEID_PLAYER)
4173 return;
4174
4175 Unit* caster = GetCaster();
4176
4177 if (!caster || !caster->isAlive())
4178 return;
4179
4180 float threatMod = apply ? float(m_modifier.m_amount) : float(-m_modifier.m_amount);
4181
4182 m_target->getHostileRefManager().threatAssist(caster, threatMod, GetSpellProto());
4183 }
4184
4185 void Aura::HandleModTaunt(bool apply, bool Real)
4186 {
4187 // only at real add/remove aura
4188 if (!Real)
4189 return;
4190
4191 if (!m_target->isAlive() || !m_target->CanHaveThreatList())
4192 return;
4193
4194 Unit* caster = GetCaster();
4195
4196 if (!caster || !caster->isAlive())
4197 return;
4198
4199 if (apply)
4200 m_target->TauntApply(caster);
4201 else
4202 {
4203 // When taunt aura fades out, mob will switch to previous target if current has less than 1.1 * secondthreat
4204 m_target->TauntFadeOut(caster);
4205 }
4206 }
4207
4208 /*********************************************************/
4209 /*** MODIFY SPEED ***/
4210 /*********************************************************/
4211 void Aura::HandleAuraModIncreaseSpeed(bool /*apply*/, bool Real)
4212 {
4213 // all applied/removed only at real aura add/remove
4214 if(!Real)
4215 return;
4216
4217 m_target->UpdateSpeed(MOVE_RUN, true);
4218 }
4219
4220 void Aura::HandleAuraModIncreaseMountedSpeed(bool apply, bool Real)
4221 {
4222 // all applied/removed only at real aura add/remove
4223 if(!Real)
4224 return;
4225
4226 m_target->UpdateSpeed(MOVE_RUN, true);
4227
4228 // Festive Holiday Mount
4229 if (apply && GetSpellProto()->SpellIconID != 1794 && m_target->HasAura(62061))
4230 // Reindeer Transformation
4231 m_target->CastSpell(m_target, 25860, true, NULL, this);
4232 }
4233
4234 void Aura::HandleAuraModIncreaseFlightSpeed(bool apply, bool Real)
4235 {
4236 // all applied/removed only at real aura add/remove
4237 if(!Real)
4238 return;
4239
4240 // Enable Fly mode for flying mounts
4241 if (m_modifier.m_auraname == SPELL_AURA_MOD_INCREASE_FLIGHT_SPEED)
4242 {
4243 WorldPacket data;
4244 if(apply)
4245 data.Initialize(SMSG_MOVE_SET_CAN_FLY, 12);
4246 else
4247 data.Initialize(SMSG_MOVE_UNSET_CAN_FLY, 12);
4248 data.append(m_target->GetPackGUID());
4249 data << uint32(0); // unknown
4250 m_target->SendMessageToSet(&data, true);
4251
4252 //Players on flying mounts must be immune to polymorph
4253 if (m_target->GetTypeId()==TYPEID_PLAYER)
4254 m_target->ApplySpellImmune(GetId(),IMMUNITY_MECHANIC,MECHANIC_POLYMORPH,apply);
4255
4256 // Dragonmaw Illusion (overwrite mount model, mounted aura already applied)
4257 if( apply && m_target->HasAura(42016,0) && m_target->GetMountID())
4258 m_target->SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID,16314);
4259
4260 // Festive Holiday Mount
4261 if (apply && GetSpellProto()->SpellIconID != 1794 && m_target->HasAura(62061))
4262 // Reindeer Transformation
4263 m_target->CastSpell(m_target, 25860, true, NULL, this);
4264 }
4265
4266 m_target->UpdateSpeed(MOVE_FLIGHT, true);
4267 }
4268
4269 void Aura::HandleAuraModIncreaseSwimSpeed(bool /*apply*/, bool Real)
4270 {
4271 // all applied/removed only at real aura add/remove
4272 if(!Real)
4273 return;
4274
4275 m_target->UpdateSpeed(MOVE_SWIM, true);
4276 }
4277
4278 void Aura::HandleAuraModDecreaseSpeed(bool apply, bool Real)
4279 {
4280 // all applied/removed only at real aura add/remove
4281 if(!Real)
4282 return;
4283
4284 if (apply)
4285 {
4286 // Gronn Lord's Grasp, becomes stoned
4287 if (GetId() == 33572)
4288 {
4289 if (GetStackAmount() >= 5 && !m_target->HasAura(33652))
4290 m_target->CastSpell(m_target, 33652, true);
4291 }
4292 }
4293
4294 m_target->UpdateSpeed(MOVE_RUN, true);
4295 m_target->UpdateSpeed(MOVE_SWIM, true);
4296 m_target->UpdateSpeed(MOVE_FLIGHT, true);
4297 }
4298
4299 void Aura::HandleAuraModUseNormalSpeed(bool /*apply*/, bool Real)
4300 {
4301 // all applied/removed only at real aura add/remove
4302 if(!Real)
4303 return;
4304
4305 m_target->UpdateSpeed(MOVE_RUN, true);
4306 m_target->UpdateSpeed(MOVE_SWIM, true);
4307 m_target->UpdateSpeed(MOVE_FLIGHT, true);
4308 }
4309
4310 /*********************************************************/
4311 /*** IMMUNITY ***/
4312 /*********************************************************/
4313
4314 void Aura::HandleModMechanicImmunity(bool apply, bool /*Real*/)
4315 {
4316 uint32 misc = m_modifier.m_miscvalue;
4317 // Forbearance
4318 // in DBC wrong mechanic immune since 3.0.x
4319 if (GetId() == 25771)
4320 misc = MECHANIC_IMMUNE_SHIELD;
4321
4322
4323 if(apply && GetSpellProto()->AttributesEx & SPELL_ATTR_EX_DISPEL_AURAS_ON_IMMUNITY)
4324 {
4325 uint32 mechanic = 1 << (misc-1);
4326
4327 //immune movement impairment and loss of control
4328 if(GetId()==42292 || GetId()==59752)
4329 mechanic=IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK;
4330
4331 m_target->RemoveAurasAtMechanicImmunity(mechanic,GetId());
4332 }
4333
4334 m_target->ApplySpellImmune(GetId(),IMMUNITY_MECHANIC,misc,apply);
4335
4336 // Bestial Wrath
4337 if (GetSpellProto()->SpellFamilyName == SPELLFAMILY_HUNTER && GetSpellProto()->SpellIconID == 1680)
4338 {
4339 // The Beast Within cast on owner if talent present
4340 if (Unit* owner = m_target->GetOwner())
4341 {
4342 // Search talent
4343 Unit::AuraList const& dummyAuras = owner->GetAurasByType(SPELL_AURA_DUMMY);
4344 for(Unit::AuraList::const_iterator i = dummyAuras.begin(); i != dummyAuras.end(); ++i)
4345 {
4346 if ((*i)->GetSpellProto()->SpellIconID == 2229)
4347 {
4348 if (apply)
4349 owner->CastSpell(owner, 34471, true, 0, this);
4350 else
4351 owner->RemoveAurasDueToSpell(34471);
4352 break;
4353 }
4354 }
4355 }
4356 }
4357 }
4358
4359 void Aura::HandleModMechanicImmunityMask(bool apply, bool /*Real*/)
4360 {
4361 uint32 mechanic = m_modifier.m_miscvalue;
4362
4363 if(apply && GetSpellProto()->AttributesEx & SPELL_ATTR_EX_DISPEL_AURAS_ON_IMMUNITY)
4364 m_target->RemoveAurasAtMechanicImmunity(mechanic,GetId());
4365
4366 // check implemented in Unit::IsImmunedToSpell and Unit::IsImmunedToSpellEffect
4367 }
4368
4369 //this method is called whenever we add / remove aura which gives m_target some imunity to some spell effect
4370 void Aura::HandleAuraModEffectImmunity(bool apply, bool /*Real*/)
4371 {
4372 // when removing flag aura, handle flag drop
4373 if( !apply && m_target->GetTypeId() == TYPEID_PLAYER
4374 && (GetSpellProto()->AuraInterruptFlags & AURA_INTERRUPT_FLAG_IMMUNE_OR_LOST_SELECTION) )
4375 {
4376 if( BattleGround *bg = ((Player*)m_target)->GetBattleGround() )
4377 bg->EventPlayerDroppedFlag(((Player*)m_target));
4378 }
4379
4380 m_target->ApplySpellImmune(GetId(), IMMUNITY_EFFECT, m_modifier.m_miscvalue, apply);
4381 }
4382
4383 void Aura::HandleAuraModStateImmunity(bool apply, bool Real)
4384 {
4385 if(apply && Real && GetSpellProto()->AttributesEx & SPELL_ATTR_EX_DISPEL_AURAS_ON_IMMUNITY)
4386 {
4387 Unit::AuraList const& auraList = m_target->GetAurasByType(AuraType(m_modifier.m_miscvalue));
4388 for(Unit::AuraList::const_iterator itr = auraList.begin(); itr != auraList.end();)
4389 {
4390 if (auraList.front() != this) // skip itself aura (it already added)
4391 {
4392 m_target->RemoveAurasDueToSpell(auraList.front()->GetId());
4393 itr = auraList.begin();
4394 }
4395 else
4396 ++itr;
4397 }
4398 }
4399
4400 m_target->ApplySpellImmune(GetId(), IMMUNITY_STATE, m_modifier.m_miscvalue, apply);
4401 }
4402
4403 void Aura::HandleAuraModSchoolImmunity(bool apply, bool Real)
4404 {
4405 m_target->ApplySpellImmune(GetId(), IMMUNITY_SCHOOL, m_modifier.m_miscvalue, apply);
4406
4407 // remove all flag auras (they are positive, but they must be removed when you are immune)
4408 if( this->GetSpellProto()->AttributesEx & SPELL_ATTR_EX_DISPEL_AURAS_ON_IMMUNITY
4409 && this->GetSpellProto()->AttributesEx2 & SPELL_ATTR_EX2_DAMAGE_REDUCED_SHIELD )
4410 m_target->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_IMMUNE_OR_LOST_SELECTION);
4411
4412 // TODO: optimalize this cycle - use RemoveAurasWithInterruptFlags call or something else
4413 if( Real && apply
4414 && GetSpellProto()->AttributesEx & SPELL_ATTR_EX_DISPEL_AURAS_ON_IMMUNITY
4415 && IsPositiveSpell(GetId()) ) //Only positive immunity removes auras
4416 {
4417 uint32 school_mask = m_modifier.m_miscvalue;
4418 Unit::AuraMap& Auras = m_target->GetAuras();
4419 for(Unit::AuraMap::iterator iter = Auras.begin(), next; iter != Auras.end(); iter = next)
4420 {
4421 next = iter;
4422 ++next;
4423 SpellEntry const *spell = iter->second->GetSpellProto();
4424 if((GetSpellSchoolMask(spell) & school_mask)//Check for school mask
4425 && !( spell->Attributes & SPELL_ATTR_UNAFFECTED_BY_INVULNERABILITY) //Spells unaffected by invulnerability
4426 && !iter->second->IsPositive() //Don't remove positive spells
4427 && spell->Id != GetId() ) //Don't remove self
4428 {
4429 m_target->RemoveAurasDueToSpell(spell->Id);
4430 if(Auras.empty())
4431 break;
4432 else
4433 next = Auras.begin();
4434 }
4435 }
4436 }
4437 if( Real && GetSpellProto()->Mechanic == MECHANIC_BANISH )
4438 {
4439 if( apply )
4440 m_target->addUnitState(UNIT_STAT_ISOLATED);
4441 else
4442 m_target->clearUnitState(UNIT_STAT_ISOLATED);
4443 }
4444 }
4445
4446 void Aura::HandleAuraModDmgImmunity(bool apply, bool /*Real*/)
4447 {
4448 m_target->ApplySpellImmune(GetId(), IMMUNITY_DAMAGE, m_modifier.m_miscvalue, apply);
4449 }
4450
4451 void Aura::HandleAuraModDispelImmunity(bool apply, bool Real)
4452 {
4453 // all applied/removed only at real aura add/remove
4454 if(!Real)
4455 return;
4456
4457 m_target->ApplySpellDispelImmunity(m_spellProto, DispelType(m_modifier.m_miscvalue), apply);
4458 }
4459
4460 void Aura::HandleAuraProcTriggerSpell(bool apply, bool Real)
4461 {
4462 if(!Real)
4463 return;
4464
4465 if(apply)
4466 {
4467 // some spell have charges by functionality not have its in spell data
4468 switch (GetId())
4469 {
4470 case 28200: // Ascendance (Talisman of Ascendance trinket)
4471 SetAuraCharges(6);
4472 break;
4473 default: break;
4474 }
4475 }
4476 }
4477
4478 void Aura::HandleAuraModStalked(bool apply, bool /*Real*/)
4479 {
4480 // used by spells: Hunter's Mark, Mind Vision, Syndicate Tracker (MURP) DND
4481 if(apply)
4482 m_target->SetFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_TRACK_UNIT);
4483 else
4484 m_target->RemoveFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_TRACK_UNIT);
4485 }
4486
4487 /*********************************************************/
4488 /*** PERIODIC ***/
4489 /*********************************************************/
4490
4491 void Aura::HandlePeriodicTriggerSpell(bool apply, bool /*Real*/)
4492 {
4493 m_isPeriodic = apply;
4494
4495 if (!apply)
4496 {
4497 switch(m_spellProto->Id)
4498 {
4499 case 66: // Invisibility
4500 if (m_removeMode == AURA_REMOVE_BY_DEFAULT && m_duration<=0)
4501 m_target->CastSpell(m_target, 32612, true, NULL, this);
4502
4503 return;
4504 case 42783: //Wrath of the Astrom...
4505 if (m_removeMode == AURA_REMOVE_BY_DEFAULT && GetEffIndex() + 1 < 3)
4506 m_target->CastSpell(m_target, m_spellProto->CalculateSimpleValue(GetEffIndex()+1), true);
4507 return;
4508 default:
4509 break;
4510 }
4511 }
4512 }
4513
4514 void Aura::HandlePeriodicTriggerSpellWithValue(bool apply, bool /*Real*/)
4515 {
4516 m_isPeriodic = apply;
4517 }
4518
4519 void Aura::HandlePeriodicEnergize(bool apply, bool Real)
4520 {
4521 if (!Real)
4522 return;
4523
4524 // For prevent double apply bonuses
4525 bool loading = (m_target->GetTypeId() == TYPEID_PLAYER && ((Player*)m_target)->GetSession()->PlayerLoading());
4526
4527 if (apply && !loading)
4528 {
4529 switch (GetId())
4530 {
4531 case 54833: // Glyph of Innervate (value%/2 of casters base mana)
4532 {
4533 if (Unit* caster = GetCaster())
4534 m_modifier.m_amount = int32(caster->GetCreateMana() * GetBasePoints() / (200 * m_maxduration / m_periodicTimer));
4535 break;
4536
4537 }
4538 case 29166: // Innervate (value% of casters base mana)
4539 {
4540 if (Unit* caster = GetCaster())
4541 {
4542 // Glyph of Innervate
4543 if (caster->HasAura(54832))
4544 caster->CastSpell(caster,54833,true,NULL,this);
4545
4546 m_modifier.m_amount = int32(caster->GetCreateMana() * GetBasePoints() / (100 * m_maxduration / m_periodicTimer));
4547 }
4548 break;
4549 }
4550 case 48391: // Owlkin Frenzy 2% base mana
4551 m_modifier.m_amount = m_target->GetCreateMana() * 2 / 100;
4552 break;
4553 case 57669: // Replenishment (0.2% from max)
4554 case 61782: // Infinite Replenishment
4555 m_modifier.m_amount = m_target->GetMaxPower(POWER_MANA) * 2 / 1000;
4556 break;
4557 default:
4558 break;
4559 }
4560 }
4561
4562 m_isPeriodic = apply;
4563 }
4564
4565 void Aura::HandleAuraPowerBurn(bool apply, bool /*Real*/)
4566 {
4567 m_isPeriodic = apply;
4568 }
4569
4570 void Aura::HandleAuraPeriodicDummy(bool apply, bool Real)
4571 {
4572 // spells required only Real aura add/remove
4573 if(!Real)
4574 return;
4575
4576 // For prevent double apply bonuses
4577 bool loading = (m_target->GetTypeId() == TYPEID_PLAYER && ((Player*)m_target)->GetSession()->PlayerLoading());
4578
4579 SpellEntry const*spell = GetSpellProto();
4580 switch( spell->SpellFamilyName)
4581 {
4582 case SPELLFAMILY_ROGUE:
4583 {
4584 if(!apply)
4585 {
4586 switch(spell->Id)
4587 {
4588 // Master of Subtlety
4589 case 31666: m_target->RemoveAurasDueToSpell(31665); break;
4590 // Overkill
4591 case 58428: m_target->RemoveAurasDueToSpell(58427); break;
4592 }
4593 }
4594 break;
4595 }
4596 case SPELLFAMILY_HUNTER:
4597 {
4598 Unit* caster = GetCaster();
4599
4600 // Explosive Shot
4601 if (apply && !loading && caster)
4602 m_modifier.m_amount += int32(caster->GetTotalAttackPowerValue(RANGED_ATTACK) * 14 / 100);
4603 break;
4604 }
4605 }
4606
4607 m_isPeriodic = apply;
4608 }
4609
4610 void Aura::HandlePeriodicHeal(bool apply, bool /*Real*/)
4611 {
4612 m_isPeriodic = apply;
4613 }
4614
4615 void Aura::HandlePeriodicDamage(bool apply, bool Real)
4616 {
4617 // spells required only Real aura add/remove
4618 if(!Real)
4619 return;
4620
4621 m_isPeriodic = apply;
4622
4623 // For prevent double apply bonuses
4624 bool loading = (m_target->GetTypeId() == TYPEID_PLAYER && ((Player*)m_target)->GetSession()->PlayerLoading());
4625
4626 // Custom damage calculation after
4627 if (apply)
4628 {
4629 if(loading)
4630 return;
4631
4632 Unit *caster = GetCaster();
4633 if (!caster)
4634 return;
4635
4636 switch (m_spellProto->SpellFamilyName)
4637 {
4638 case SPELLFAMILY_GENERIC:
4639 {
4640 // Pounce Bleed
4641 if ( m_spellProto->SpellIconID == 147 && m_spellProto->SpellVisual[0] == 0 )
4642 {
4643 // $AP*0.18/6 bonus per tick
4644 m_modifier.m_amount += int32(caster->GetTotalAttackPowerValue(BASE_ATTACK) * 3 / 100);
4645 return;
4646 }
4647 break;
4648 }
4649 case SPELLFAMILY_WARRIOR:
4650 {
4651 // Rend
4652 if (m_spellProto->SpellFamilyFlags & UI64LIT(0x0000000000000020))
4653 {
4654 // $0.2*(($MWB+$mwb)/2+$AP/14*$MWS) bonus per tick
4655 float ap = caster->GetTotalAttackPowerValue(BASE_ATTACK);
4656 int32 mws = caster->GetAttackTime(BASE_ATTACK);
4657 float mwb_min = caster->GetWeaponDamageRange(BASE_ATTACK,MINDAMAGE);
4658 float mwb_max = caster->GetWeaponDamageRange(BASE_ATTACK,MAXDAMAGE);
4659 m_modifier.m_amount+=int32(((mwb_min+mwb_max)/2+ap*mws/14000)*0.2f);
4660 return;
4661 }
4662 break;
4663 }
4664 case SPELLFAMILY_DRUID:
4665 {
4666 // Rake
4667 if (m_spellProto->SpellFamilyFlags & UI64LIT(0x0000000000001000) && m_spellProto->Effect[2]==SPELL_EFFECT_ADD_COMBO_POINTS)
4668 {
4669 // $AP*0.18/3 bonus per tick
4670 m_modifier.m_amount += int32(caster->GetTotalAttackPowerValue(BASE_ATTACK) * 6 / 100);
4671 return;
4672 }
4673 // Lacerate
4674 if (m_spellProto->SpellFamilyFlags & UI64LIT(0x000000010000000000))
4675 {
4676 // $AP*0.05/5 bonus per tick
4677 m_modifier.m_amount += int32(caster->GetTotalAttackPowerValue(BASE_ATTACK) / 100);
4678 return;
4679 }
4680 // Rip
4681 if (m_spellProto->SpellFamilyFlags & UI64LIT(0x000000000000800000))
4682 {
4683 // 0.01*$AP*cp
4684 if (caster->GetTypeId() != TYPEID_PLAYER)
4685 return;
4686
4687 uint8 cp = ((Player*)caster)->GetComboPoints();
4688
4689 // Idol of Feral Shadows. Cant be handled as SpellMod in SpellAura:Dummy due its dependency from CPs
4690 Unit::AuraList const& dummyAuras = caster->GetAurasByType(SPELL_AURA_DUMMY);
4691 for(Unit::AuraList::const_iterator itr = dummyAuras.begin(); itr != dummyAuras.end(); ++itr)
4692 {
4693 if((*itr)->GetId()==34241)
4694 {
4695 m_modifier.m_amount += cp * (*itr)->GetModifier()->m_amount;
4696 break;
4697 }
4698 }
4699 m_modifier.m_amount += int32(caster->GetTotalAttackPowerValue(BASE_ATTACK) * cp / 100);
4700 return;
4701 }
4702 // Lock Jaw
4703 if (m_spellProto->SpellFamilyFlags & UI64LIT(0x1000000000000000))
4704 {
4705 // 0.15*$AP
4706 m_modifier.m_amount += int32(caster->GetTotalAttackPowerValue(BASE_ATTACK) * 15 / 100);
4707 return;
4708 }
4709 break;
4710 }
4711 case SPELLFAMILY_ROGUE:
4712 {
4713 // Rupture
4714 if (m_spellProto->SpellFamilyFlags & UI64LIT(0x000000000000100000))
4715 {
4716 if (caster->GetTypeId() != TYPEID_PLAYER)
4717 return;
4718 //1 point : ${($m1+$b1*1+0.015*$AP)*4} damage over 8 secs
4719 //2 points: ${($m1+$b1*2+0.024*$AP)*5} damage over 10 secs
4720 //3 points: ${($m1+$b1*3+0.03*$AP)*6} damage over 12 secs
4721 //4 points: ${($m1+$b1*4+0.03428571*$AP)*7} damage over 14 secs
4722 //5 points: ${($m1+$b1*5+0.0375*$AP)*8} damage over 16 secs
4723 float AP_per_combo[6] = {0.0f, 0.015f, 0.024f, 0.03f, 0.03428571f, 0.0375f};
4724 uint8 cp = ((Player*)caster)->GetComboPoints();
4725 if (cp > 5) cp = 5;
4726 m_modifier.m_amount += int32(caster->GetTotalAttackPowerValue(BASE_ATTACK) * AP_per_combo[cp]);
4727 return;
4728 }
4729 // Garrote
4730 if (m_spellProto->SpellFamilyFlags & UI64LIT(0x000000000000000100))
4731 {
4732 // $AP*0.07 bonus per tick
4733 m_modifier.m_amount += int32(caster->GetTotalAttackPowerValue(BASE_ATTACK) * 7 / 100);
4734 return;
4735 }
4736 // Deadly Poison
4737 if (m_spellProto->SpellFamilyFlags & UI64LIT(0x0000000000010000))
4738 {
4739 // 0.08*$AP / 4 * amount of stack
4740 m_modifier.m_amount += int32(caster->GetTotalAttackPowerValue(BASE_ATTACK) * 2 * GetStackAmount() / 100);
4741 return;
4742 }
4743 break;
4744 }
4745 case SPELLFAMILY_HUNTER:
4746 {
4747 // Serpent Sting
4748 if (m_spellProto->SpellFamilyFlags & UI64LIT(0x0000000000004000))
4749 {
4750 // $RAP*0.2/5 bonus per tick
4751 m_modifier.m_amount += int32(caster->GetTotalAttackPowerValue(RANGED_ATTACK) * 0.2 / 5);
4752 return;
4753 }
4754 // Immolation Trap
4755 if ((m_spellProto->SpellFamilyFlags & UI64LIT(0x0000000000000004)) && m_spellProto->SpellIconID == 678)
4756 {
4757 // $RAP*0.1/5 bonus per tick
4758 m_modifier.m_amount += int32(caster->GetTotalAttackPowerValue(RANGED_ATTACK) * 10 / 500);
4759 return;
4760 }
4761 break;
4762 }
4763 default:
4764 break;
4765 }
4766 }
4767 // remove time effects
4768 else
4769 {
4770 // Parasitic Shadowfiend - handle summoning of two Shadowfiends on DoT expire
4771 if(m_spellProto->Id == 41917)
4772 m_target->CastSpell(m_target, 41915, true);
4773 }
4774 }
4775
4776 void Aura::HandlePeriodicDamagePCT(bool apply, bool /*Real*/)
4777 {
4778 m_isPeriodic = apply;
4779 }
4780
4781 void Aura::HandlePeriodicLeech(bool apply, bool /*Real*/)
4782 {
4783 m_isPeriodic = apply;
4784 }
4785
4786 void Aura::HandlePeriodicManaLeech(bool apply, bool /*Real*/)
4787 {
4788 m_isPeriodic = apply;
4789 }
4790
4791 void Aura::HandlePeriodicHealthFunnel(bool apply, bool /*Real*/)
4792 {
4793 m_isPeriodic = apply;
4794 }
4795
4796 /*********************************************************/
4797 /*** MODIFY STATS ***/
4798 /*********************************************************/
4799
4800 /********************************/
4801 /*** RESISTANCE ***/
4802 /********************************/
4803
4804 void Aura::HandleAuraModResistanceExclusive(bool apply, bool /*Real*/)
4805 {
4806 for(int8 x = SPELL_SCHOOL_NORMAL; x < MAX_SPELL_SCHOOL;x++)
4807 {
4808 if(m_modifier.m_miscvalue & int32(1<<x))
4809 {
4810 m_target->HandleStatModifier(UnitMods(UNIT_MOD_RESISTANCE_START + x), BASE_VALUE, float(m_modifier.m_amount), apply);
4811 if(m_target->GetTypeId() == TYPEID_PLAYER)
4812 m_target->ApplyResistanceBuffModsMod(SpellSchools(x), m_positive, m_modifier.m_amount, apply);
4813 }
4814 }
4815 }
4816
4817 void Aura::HandleAuraModResistance(bool apply, bool /*Real*/)
4818 {
4819 for(int8 x = SPELL_SCHOOL_NORMAL; x < MAX_SPELL_SCHOOL;x++)
4820 {
4821 if(m_modifier.m_miscvalue & int32(1<<x))
4822 {
4823 m_target->HandleStatModifier(UnitMods(UNIT_MOD_RESISTANCE_START + x), TOTAL_VALUE, float(m_modifier.m_amount), apply);
4824 if(m_target->GetTypeId() == TYPEID_PLAYER || ((Creature*)m_target)->isPet())
4825 m_target->ApplyResistanceBuffModsMod(SpellSchools(x), m_positive, m_modifier.m_amount, apply);
4826 }
4827 }
4828 }
4829
4830 void Aura::HandleAuraModBaseResistancePCT(bool apply, bool /*Real*/)
4831 {
4832 // only players have base stats
4833 if(m_target->GetTypeId() != TYPEID_PLAYER)
4834 {
4835 //pets only have base armor
4836 if(((Creature*)m_target)->isPet() && (m_modifier.m_miscvalue & SPELL_SCHOOL_MASK_NORMAL))
4837 m_target->HandleStatModifier(UNIT_MOD_ARMOR, BASE_PCT, float(m_modifier.m_amount), apply);
4838 }
4839 else
4840 {
4841 for(int8 x = SPELL_SCHOOL_NORMAL; x < MAX_SPELL_SCHOOL;x++)
4842 {
4843 if(m_modifier.m_miscvalue & int32(1<<x))
4844 m_target->HandleStatModifier(UnitMods(UNIT_MOD_RESISTANCE_START + x), BASE_PCT, float(m_modifier.m_amount), apply);
4845 }
4846 }
4847 }
4848
4849 void Aura::HandleModResistancePercent(bool apply, bool /*Real*/)
4850 {
4851 for(int8 i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; i++)
4852 {
4853 if(m_modifier.m_miscvalue & int32(1<<i))
4854 {
4855 m_target->HandleStatModifier(UnitMods(UNIT_MOD_RESISTANCE_START + i), TOTAL_PCT, float(m_modifier.m_amount), apply);
4856 if(m_target->GetTypeId() == TYPEID_PLAYER || ((Creature*)m_target)->isPet())
4857 {
4858 m_target->ApplyResistanceBuffModsPercentMod(SpellSchools(i), true, m_modifier.m_amount, apply);
4859 m_target->ApplyResistanceBuffModsPercentMod(SpellSchools(i), false, m_modifier.m_amount, apply);
4860 }
4861 }
4862 }
4863 }
4864
4865 void Aura::HandleModBaseResistance(bool apply, bool /*Real*/)
4866 {
4867 // only players have base stats
4868 if(m_target->GetTypeId() != TYPEID_PLAYER)
4869 {
4870 //only pets have base stats
4871 if(((Creature*)m_target)->isPet() && (m_modifier.m_miscvalue & SPELL_SCHOOL_MASK_NORMAL))
4872 m_target->HandleStatModifier(UNIT_MOD_ARMOR, TOTAL_VALUE, float(m_modifier.m_amount), apply);
4873 }
4874 else
4875 {
4876 for(int i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; i++)
4877 if(m_modifier.m_miscvalue & (1<<i))
4878 m_target->HandleStatModifier(UnitMods(UNIT_MOD_RESISTANCE_START + i), TOTAL_VALUE, float(m_modifier.m_amount), apply);
4879 }
4880 }
4881
4882 /********************************/
4883 /*** STAT ***/
4884 /********************************/
4885
4886 void Aura::HandleAuraModStat(bool apply, bool /*Real*/)
4887 {
4888 if (m_modifier.m_miscvalue < -2 || m_modifier.m_miscvalue > 4)
4889 {
4890 sLog.outError("WARNING: Spell %u effect %u have unsupported misc value (%i) for SPELL_AURA_MOD_STAT ",GetId(),GetEffIndex(),m_modifier.m_miscvalue);
4891 return;
4892 }
4893
4894 for(int32 i = STAT_STRENGTH; i < MAX_STATS; i++)
4895 {
4896 // -1 or -2 is all stats ( misc < -2 checked in function beginning )
4897 if (m_modifier.m_miscvalue < 0 || m_modifier.m_miscvalue == i)
4898 {
4899 //m_target->ApplyStatMod(Stats(i), m_modifier.m_amount,apply);
4900 m_target->HandleStatModifier(UnitMods(UNIT_MOD_STAT_START + i), TOTAL_VALUE, float(m_modifier.m_amount), apply);
4901 if(m_target->GetTypeId() == TYPEID_PLAYER || ((Creature*)m_target)->isPet())
4902 m_target->ApplyStatBuffMod(Stats(i), m_modifier.m_amount, apply);
4903 }
4904 }
4905 }
4906
4907 void Aura::HandleModPercentStat(bool apply, bool /*Real*/)
4908 {
4909 if (m_modifier.m_miscvalue < -1 || m_modifier.m_miscvalue > 4)
4910 {
4911 sLog.outError("WARNING: Misc Value for SPELL_AURA_MOD_PERCENT_STAT not valid");
4912 return;
4913 }
4914
4915 // only players have base stats
4916 if (m_target->GetTypeId() != TYPEID_PLAYER)
4917 return;
4918
4919 for (int32 i = STAT_STRENGTH; i < MAX_STATS; ++i)
4920 {
4921 if(m_modifier.m_miscvalue == i || m_modifier.m_miscvalue == -1)
4922 m_target->HandleStatModifier(UnitMods(UNIT_MOD_STAT_START + i), BASE_PCT, float(m_modifier.m_amount), apply);
4923 }
4924 }
4925
4926 void Aura::HandleModSpellDamagePercentFromStat(bool /*apply*/, bool /*Real*/)
4927 {
4928 if(m_target->GetTypeId() != TYPEID_PLAYER)
4929 return;
4930
4931 // Magic damage modifiers implemented in Unit::SpellDamageBonus
4932 // This information for client side use only
4933 // Recalculate bonus
4934 ((Player*)m_target)->UpdateSpellDamageAndHealingBonus();
4935 }
4936
4937 void Aura::HandleModSpellHealingPercentFromStat(bool /*apply*/, bool /*Real*/)
4938 {
4939 if(m_target->GetTypeId() != TYPEID_PLAYER)
4940 return;
4941
4942 // Recalculate bonus
4943 ((Player*)m_target)->UpdateSpellDamageAndHealingBonus();
4944 }
4945
4946 void Aura::HandleAuraModDispelResist(bool apply, bool Real)
4947 {
4948 if(!Real || !apply)
4949 return;
4950
4951 if(GetId() == 33206)
4952 m_target->CastSpell(m_target, 44416, true, NULL, this, GetCasterGUID());
4953 }
4954
4955 void Aura::HandleModSpellDamagePercentFromAttackPower(bool /*apply*/, bool /*Real*/)
4956 {
4957 if(m_target->GetTypeId() != TYPEID_PLAYER)
4958 return;
4959
4960 // Magic damage modifiers implemented in Unit::SpellDamageBonus
4961 // This information for client side use only
4962 // Recalculate bonus
4963 ((Player*)m_target)->UpdateSpellDamageAndHealingBonus();
4964 }
4965
4966 void Aura::HandleModSpellHealingPercentFromAttackPower(bool /*apply*/, bool /*Real*/)
4967 {
4968 if(m_target->GetTypeId() != TYPEID_PLAYER)
4969 return;
4970
4971 // Recalculate bonus
4972 ((Player*)m_target)->UpdateSpellDamageAndHealingBonus();
4973 }
4974
4975 void Aura::HandleModHealingDone(bool /*apply*/, bool /*Real*/)
4976 {
4977 if(m_target->GetTypeId() != TYPEID_PLAYER)
4978 return;
4979 // implemented in Unit::SpellHealingBonus
4980 // this information is for client side only
4981 ((Player*)m_target)->UpdateSpellDamageAndHealingBonus();
4982 }
4983
4984 void Aura::HandleModTotalPercentStat(bool apply, bool /*Real*/)
4985 {
4986 if (m_modifier.m_miscvalue < -1 || m_modifier.m_miscvalue > 4)
4987 {
4988 sLog.outError("WARNING: Misc Value for SPELL_AURA_MOD_PERCENT_STAT not valid");
4989 return;
4990 }
4991
4992 //save current and max HP before applying aura
4993 uint32 curHPValue = m_target->GetHealth();
4994 uint32 maxHPValue = m_target->GetMaxHealth();
4995
4996 for (int32 i = STAT_STRENGTH; i < MAX_STATS; i++)
4997 {
4998 if(m_modifier.m_miscvalue == i || m_modifier.m_miscvalue == -1)
4999 {
5000 m_target->HandleStatModifier(UnitMods(UNIT_MOD_STAT_START + i), TOTAL_PCT, float(m_modifier.m_amount), apply);
5001 if(m_target->GetTypeId() == TYPEID_PLAYER || ((Creature*)m_target)->isPet())
5002 m_target->ApplyStatPercentBuffMod(Stats(i), m_modifier.m_amount, apply );
5003 }
5004 }
5005
5006 //recalculate current HP/MP after applying aura modifications (only for spells with 0x10 flag)
5007 if ((m_modifier.m_miscvalue == STAT_STAMINA) && (maxHPValue > 0) && (m_spellProto->Attributes & 0x10))
5008 {
5009 // newHP = (curHP / maxHP) * newMaxHP = (newMaxHP * curHP) / maxHP -> which is better because no int -> double -> int conversion is needed
5010 uint32 newHPValue = (m_target->GetMaxHealth() * curHPValue) / maxHPValue;
5011 m_target->SetHealth(newHPValue);
5012 }
5013 }
5014
5015 void Aura::HandleAuraModResistenceOfStatPercent(bool /*apply*/, bool /*Real*/)
5016 {
5017 if(m_target->GetTypeId() != TYPEID_PLAYER)
5018 return;
5019
5020 if(m_modifier.m_miscvalue != SPELL_SCHOOL_MASK_NORMAL)
5021 {
5022 // support required adding replace UpdateArmor by loop by UpdateResistence at intellect update
5023 // and include in UpdateResistence same code as in UpdateArmor for aura mod apply.
5024 sLog.outError("Aura SPELL_AURA_MOD_RESISTANCE_OF_STAT_PERCENT(182) need adding support for non-armor resistances!");
5025 return;
5026 }
5027
5028 // Recalculate Armor
5029 m_target->UpdateArmor();
5030 }
5031
5032 /********************************/
5033 /*** HEAL & ENERGIZE ***/
5034 /********************************/
5035 void Aura::HandleAuraModTotalHealthPercentRegen(bool apply, bool /*Real*/)
5036 {
5037 m_isPeriodic = apply;
5038 }
5039
5040 void Aura::HandleAuraModTotalManaPercentRegen(bool apply, bool /*Real*/)
5041 {
5042 if(m_modifier.periodictime == 0)
5043 m_modifier.periodictime = 1000;
5044
5045 m_periodicTimer = m_modifier.periodictime;
5046 m_isPeriodic = apply;
5047 }
5048
5049 void Aura::HandleModRegen(bool apply, bool /*Real*/) // eating
5050 {
5051 if(m_modifier.periodictime == 0)
5052 m_modifier.periodictime = 5000;
5053
5054 m_periodicTimer = 5000;
5055 m_isPeriodic = apply;
5056 }
5057
5058 void Aura::HandleModPowerRegen(bool apply, bool Real) // drinking
5059 {
5060 if (!Real)
5061 return;
5062
5063 Powers pt = m_target->getPowerType();
5064 if(m_modifier.periodictime == 0)
5065 {
5066 // Anger Management (only spell use this aura for rage)
5067 if (pt == POWER_RAGE)
5068 m_modifier.periodictime = 3000;
5069 else
5070 m_modifier.periodictime = 2000;
5071 }
5072
5073 m_periodicTimer = 5000;
5074
5075 if (m_target->GetTypeId() == TYPEID_PLAYER && m_modifier.m_miscvalue == POWER_MANA)
5076 ((Player*)m_target)->UpdateManaRegen();
5077
5078 m_isPeriodic = apply;
5079 }
5080
5081 void Aura::HandleModPowerRegenPCT(bool /*apply*/, bool Real)
5082 {
5083 // spells required only Real aura add/remove
5084 if(!Real)
5085 return;
5086
5087 if (m_target->GetTypeId() != TYPEID_PLAYER)
5088 return;
5089
5090 // Update manaregen value
5091 if (m_modifier.m_miscvalue == POWER_MANA)
5092 ((Player*)m_target)->UpdateManaRegen();
5093 }
5094
5095 void Aura::HandleModManaRegen(bool /*apply*/, bool Real)
5096 {
5097 // spells required only Real aura add/remove
5098 if(!Real)
5099 return;
5100
5101 if (m_target->GetTypeId() != TYPEID_PLAYER)
5102 return;
5103
5104 //Note: an increase in regen does NOT cause threat.
5105 ((Player*)m_target)->UpdateManaRegen();
5106 }
5107
5108 void Aura::HandleComprehendLanguage(bool apply, bool /*Real*/)
5109 {
5110 if(apply)
5111 m_target->SetFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_COMPREHEND_LANG);
5112 else
5113 m_target->RemoveFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_COMPREHEND_LANG);
5114 }
5115
5116 void Aura::HandleAuraModIncreaseHealth(bool apply, bool Real)
5117 {
5118 // Special case with temporary increase max/current health
5119 switch(GetId())
5120 {
5121 case 12976: // Warrior Last Stand triggered spell
5122 case 28726: // Nightmare Seed ( Nightmare Seed )
5123 case 34511: // Valor (Bulwark of Kings, Bulwark of the Ancient Kings)
5124 case 44055: case 55915: case 55917: case 67596: // Tremendous Fortitude (Battlemaster's Alacrity)
5125 case 50322: // Survival Instincts
5126 case 54443: // Demonic Empowerment (Voidwalker)
5127 {
5128 if(Real)
5129 {
5130 if(apply)
5131 {
5132 // Demonic Empowerment (Voidwalker) - special case, store percent in data
5133 // recalculate to full amount at apply for proper remove
5134 if (GetId() == 54443)
5135 m_modifier.m_amount = m_target->GetMaxHealth() * m_modifier.m_amount / 100;
5136
5137 m_target->HandleStatModifier(UNIT_MOD_HEALTH, TOTAL_VALUE, float(m_modifier.m_amount), apply);
5138 m_target->ModifyHealth(m_modifier.m_amount);
5139 }
5140 else
5141 {
5142 if (int32(m_target->GetHealth()) > m_modifier.m_amount)
5143 m_target->ModifyHealth(-m_modifier.m_amount);
5144 else
5145 m_target->SetHealth(1);
5146 m_target->HandleStatModifier(UNIT_MOD_HEALTH, TOTAL_VALUE, float(m_modifier.m_amount), apply);
5147 }
5148 }
5149 return;
5150 }
5151 }
5152
5153 // generic case
5154 m_target->HandleStatModifier(UNIT_MOD_HEALTH, TOTAL_VALUE, float(m_modifier.m_amount), apply);
5155 }
5156
5157 void Aura::HandleAuraModIncreaseMaxHealth(bool apply, bool /*Real*/)
5158 {
5159 uint32 oldhealth = m_target->GetHealth();
5160 double healthPercentage = (double)oldhealth / (double)m_target->GetMaxHealth();
5161
5162 m_target->HandleStatModifier(UNIT_MOD_HEALTH, TOTAL_VALUE, float(m_modifier.m_amount), apply);
5163
5164 // refresh percentage
5165 if(oldhealth > 0)
5166 {
5167 uint32 newhealth = uint32(ceil((double)m_target->GetMaxHealth() * healthPercentage));
5168 if(newhealth==0)
5169 newhealth = 1;
5170
5171 m_target->SetHealth(newhealth);
5172 }
5173 }
5174
5175 void Aura::HandleAuraModIncreaseEnergy(bool apply, bool Real)
5176 {
5177 Powers powerType = m_target->getPowerType();
5178 if(int32(powerType) != m_modifier.m_miscvalue)
5179 return;
5180
5181 UnitMods unitMod = UnitMods(UNIT_MOD_POWER_START + powerType);
5182
5183 // Special case with temporary increase max/current power (percent)
5184 if (GetId()==64904) // Hymn of Hope
5185 {
5186 if(Real)
5187 {
5188 uint32 val = m_target->GetPower(powerType);
5189 m_target->HandleStatModifier(unitMod, TOTAL_PCT, float(m_modifier.m_amount), apply);
5190 m_target->SetPower(powerType, apply ? val*(100+m_modifier.m_amount)/100 : val*100/(100+m_modifier.m_amount));
5191 }
5192 return;
5193 }
5194
5195 // generic flat case
5196 m_target->HandleStatModifier(unitMod, TOTAL_VALUE, float(m_modifier.m_amount), apply);
5197 }
5198
5199 void Aura::HandleAuraModIncreaseEnergyPercent(bool apply, bool /*Real*/)
5200 {
5201 Powers powerType = m_target->getPowerType();
5202 if(int32(powerType) != m_modifier.m_miscvalue)
5203 return;
5204
5205 UnitMods unitMod = UnitMods(UNIT_MOD_POWER_START + powerType);
5206
5207 m_target->HandleStatModifier(unitMod, TOTAL_PCT, float(m_modifier.m_amount), apply);
5208 }
5209
5210 void Aura::HandleAuraModIncreaseHealthPercent(bool apply, bool /*Real*/)
5211 {
5212 m_target->HandleStatModifier(UNIT_MOD_HEALTH, TOTAL_PCT, float(m_modifier.m_amount), apply);
5213 }
5214
5215 void Aura::HandleAuraIncreaseBaseHealthPercent(bool apply, bool /*Real*/)
5216 {
5217 m_target->HandleStatModifier(UNIT_MOD_HEALTH, BASE_PCT, float(m_modifier.m_amount), apply);
5218 }
5219
5220 /********************************/
5221 /*** FIGHT ***/
5222 /********************************/
5223
5224 void Aura::HandleAuraModParryPercent(bool /*apply*/, bool /*Real*/)
5225 {
5226 if(m_target->GetTypeId() != TYPEID_PLAYER)
5227 return;
5228
5229 ((Player*)m_target)->UpdateParryPercentage();
5230 }
5231
5232 void Aura::HandleAuraModDodgePercent(bool /*apply*/, bool /*Real*/)
5233 {
5234 if(m_target->GetTypeId() != TYPEID_PLAYER)
5235 return;
5236
5237 ((Player*)m_target)->UpdateDodgePercentage();
5238 //sLog.outError("BONUS DODGE CHANCE: + %f", float(m_modifier.m_amount));
5239 }
5240
5241 void Aura::HandleAuraModBlockPercent(bool /*apply*/, bool /*Real*/)
5242 {
5243 if(m_target->GetTypeId() != TYPEID_PLAYER)
5244 return;
5245
5246 ((Player*)m_target)->UpdateBlockPercentage();
5247 //sLog.outError("BONUS BLOCK CHANCE: + %f", float(m_modifier.m_amount));
5248 }
5249
5250 void Aura::HandleAuraModRegenInterrupt(bool /*apply*/, bool Real)
5251 {
5252 // spells required only Real aura add/remove
5253 if(!Real)
5254 return;
5255
5256 if(m_target->GetTypeId() != TYPEID_PLAYER)
5257 return;
5258
5259 ((Player*)m_target)->UpdateManaRegen();
5260 }
5261
5262 void Aura::HandleAuraModCritPercent(bool apply, bool Real)
5263 {
5264 if(m_target->GetTypeId() != TYPEID_PLAYER)
5265 return;
5266
5267 // apply item specific bonuses for already equipped weapon
5268 if(Real)
5269 {
5270 for(int i = 0; i < MAX_ATTACK; ++i)
5271 if(Item* pItem = ((Player*)m_target)->GetWeaponForAttack(WeaponAttackType(i),true,false))
5272 ((Player*)m_target)->_ApplyWeaponDependentAuraCritMod(pItem, WeaponAttackType(i), this, apply);
5273 }
5274
5275 // mods must be applied base at equipped weapon class and subclass comparison
5276 // with spell->EquippedItemClass and EquippedItemSubClassMask and EquippedItemInventoryTypeMask
5277 // m_modifier.m_miscvalue comparison with item generated damage types
5278
5279 if (GetSpellProto()->EquippedItemClass == -1)
5280 {
5281 ((Player*)m_target)->HandleBaseModValue(CRIT_PERCENTAGE, FLAT_MOD, float (m_modifier.m_amount), apply);
5282 ((Player*)m_target)->HandleBaseModValue(OFFHAND_CRIT_PERCENTAGE, FLAT_MOD, float (m_modifier.m_amount), apply);
5283 ((Player*)m_target)->HandleBaseModValue(RANGED_CRIT_PERCENTAGE, FLAT_MOD, float (m_modifier.m_amount), apply);
5284 }
5285 else
5286 {
5287 // done in Player::_ApplyWeaponDependentAuraMods
5288 }
5289 }
5290
5291 void Aura::HandleModHitChance(bool apply, bool /*Real*/)
5292 {
5293 if(m_target->GetTypeId() == TYPEID_PLAYER)
5294 {
5295 ((Player*)m_target)->UpdateMeleeHitChances();
5296 ((Player*)m_target)->UpdateRangedHitChances();
5297 }
5298 else
5299 {
5300 m_target->m_modMeleeHitChance += apply ? m_modifier.m_amount : (-m_modifier.m_amount);
5301 m_target->m_modRangedHitChance += apply ? m_modifier.m_amount : (-m_modifier.m_amount);
5302 }
5303 }
5304
5305 void Aura::HandleModSpellHitChance(bool apply, bool /*Real*/)
5306 {
5307 if(m_target->GetTypeId() == TYPEID_PLAYER)
5308 {
5309 ((Player*)m_target)->UpdateSpellHitChances();
5310 }
5311 else
5312 {
5313 m_target->m_modSpellHitChance += apply ? m_modifier.m_amount: (-m_modifier.m_amount);
5314 }
5315 }
5316
5317 void Aura::HandleModSpellCritChance(bool apply, bool Real)
5318 {
5319 // spells required only Real aura add/remove
5320 if(!Real)
5321 return;
5322
5323 if(m_target->GetTypeId() == TYPEID_PLAYER)
5324 {
5325 ((Player*)m_target)->UpdateAllSpellCritChances();
5326 }
5327 else
5328 {
5329 m_target->m_baseSpellCritChance += apply ? m_modifier.m_amount:(-m_modifier.m_amount);
5330 }
5331 }
5332
5333 void Aura::HandleModSpellCritChanceShool(bool /*apply*/, bool Real)
5334 {
5335 // spells required only Real aura add/remove
5336 if(!Real)
5337 return;
5338
5339 if(m_target->GetTypeId() != TYPEID_PLAYER)
5340 return;
5341
5342 for(int school = SPELL_SCHOOL_NORMAL; school < MAX_SPELL_SCHOOL; ++school)
5343 if (m_modifier.m_miscvalue & (1<<school))
5344 ((Player*)m_target)->UpdateSpellCritChance(school);
5345 }
5346
5347 /********************************/
5348 /*** ATTACK SPEED ***/
5349 /********************************/
5350
5351 void Aura::HandleModCastingSpeed(bool apply, bool /*Real*/)
5352 {
5353 m_target->ApplyCastTimePercentMod(m_modifier.m_amount,apply);
5354 }
5355
5356 void Aura::HandleModMeleeRangedSpeedPct(bool apply, bool /*Real*/)
5357 {
5358 m_target->ApplyAttackTimePercentMod(BASE_ATTACK, m_modifier.m_amount, apply);
5359 m_target->ApplyAttackTimePercentMod(OFF_ATTACK, m_modifier.m_amount, apply);
5360 m_target->ApplyAttackTimePercentMod(RANGED_ATTACK, m_modifier.m_amount, apply);
5361 }
5362
5363 void Aura::HandleModCombatSpeedPct(bool apply, bool /*Real*/)
5364 {
5365 m_target->ApplyCastTimePercentMod(m_modifier.m_amount, apply);
5366 m_target->ApplyAttackTimePercentMod(BASE_ATTACK, m_modifier.m_amount, apply);
5367 m_target->ApplyAttackTimePercentMod(OFF_ATTACK, m_modifier.m_amount, apply);
5368 m_target->ApplyAttackTimePercentMod(RANGED_ATTACK, m_modifier.m_amount, apply);
5369 }
5370
5371 void Aura::HandleModAttackSpeed(bool apply, bool /*Real*/)
5372 {
5373 if(!m_target->isAlive() )
5374 return;
5375
5376 m_target->ApplyAttackTimePercentMod(BASE_ATTACK,m_modifier.m_amount,apply);
5377 }
5378
5379 void Aura::HandleHaste(bool apply, bool /*Real*/)
5380 {
5381 m_target->ApplyAttackTimePercentMod(BASE_ATTACK, m_modifier.m_amount, apply);
5382 m_target->ApplyAttackTimePercentMod(OFF_ATTACK, m_modifier.m_amount, apply);
5383 m_target->ApplyAttackTimePercentMod(RANGED_ATTACK, m_modifier.m_amount, apply);
5384 }
5385
5386 void Aura::HandleAuraModRangedHaste(bool apply, bool /*Real*/)
5387 {
5388 m_target->ApplyAttackTimePercentMod(RANGED_ATTACK, m_modifier.m_amount, apply);
5389 }
5390
5391 void Aura::HandleRangedAmmoHaste(bool apply, bool /*Real*/)
5392 {
5393 if(m_target->GetTypeId() != TYPEID_PLAYER)
5394 return;
5395 m_target->ApplyAttackTimePercentMod(RANGED_ATTACK,m_modifier.m_amount, apply);
5396 }
5397
5398 /********************************/
5399 /*** ATTACK POWER ***/
5400 /********************************/
5401
5402 void Aura::HandleAuraModAttackPower(bool apply, bool /*Real*/)
5403 {
5404 m_target->HandleStatModifier(UNIT_MOD_ATTACK_POWER, TOTAL_VALUE, float(m_modifier.m_amount), apply);
5405 }
5406
5407 void Aura::HandleAuraModRangedAttackPower(bool apply, bool /*Real*/)
5408 {
5409 if((m_target->getClassMask() & CLASSMASK_WAND_USERS)!=0)
5410 return;
5411
5412 m_target->HandleStatModifier(UNIT_MOD_ATTACK_POWER_RANGED, TOTAL_VALUE, float(m_modifier.m_amount), apply);
5413 }
5414
5415 void Aura::HandleAuraModAttackPowerPercent(bool apply, bool /*Real*/)
5416 {
5417 //UNIT_FIELD_ATTACK_POWER_MULTIPLIER = multiplier - 1
5418 m_target->HandleStatModifier(UNIT_MOD_ATTACK_POWER, TOTAL_PCT, float(m_modifier.m_amount), apply);
5419 }
5420
5421 void Aura::HandleAuraModRangedAttackPowerPercent(bool apply, bool /*Real*/)
5422 {
5423 if((m_target->getClassMask() & CLASSMASK_WAND_USERS)!=0)
5424 return;
5425
5426 //UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER = multiplier - 1
5427 m_target->HandleStatModifier(UNIT_MOD_ATTACK_POWER_RANGED, TOTAL_PCT, float(m_modifier.m_amount), apply);
5428 }
5429
5430 void Aura::HandleAuraModRangedAttackPowerOfStatPercent(bool /*apply*/, bool Real)
5431 {
5432 // spells required only Real aura add/remove
5433 if(!Real)
5434 return;
5435
5436 // Recalculate bonus
5437 if(m_target->GetTypeId() == TYPEID_PLAYER && !(m_target->getClassMask() & CLASSMASK_WAND_USERS))
5438 ((Player*)m_target)->UpdateAttackPowerAndDamage(true);
5439 }
5440
5441 void Aura::HandleAuraModAttackPowerOfStatPercent(bool /*apply*/, bool Real)
5442 {
5443 // spells required only Real aura add/remove
5444 if(!Real)
5445 return;
5446
5447 // Recalculate bonus
5448 if(m_target->GetTypeId() == TYPEID_PLAYER)
5449 ((Player*)m_target)->UpdateAttackPowerAndDamage(false);
5450 }
5451
5452 void Aura::HandleAuraModAttackPowerOfArmor(bool /*apply*/, bool Real)
5453 {
5454 // spells required only Real aura add/remove
5455 if(!Real)
5456 return;
5457
5458 // Recalculate bonus
5459 if(m_target->GetTypeId() == TYPEID_PLAYER)
5460 ((Player*)m_target)->UpdateAttackPowerAndDamage(false);
5461 }
5462 /********************************/
5463 /*** DAMAGE BONUS ***/
5464 /********************************/
5465 void Aura::HandleModDamageDone(bool apply, bool Real)
5466 {
5467 // apply item specific bonuses for already equipped weapon
5468 if(Real && m_target->GetTypeId() == TYPEID_PLAYER)
5469 {
5470 for(int i = 0; i < MAX_ATTACK; ++i)
5471 if(Item* pItem = ((Player*)m_target)->GetWeaponForAttack(WeaponAttackType(i),true,false))
5472 ((Player*)m_target)->_ApplyWeaponDependentAuraDamageMod(pItem, WeaponAttackType(i), this, apply);
5473 }
5474
5475 // m_modifier.m_miscvalue is bitmask of spell schools
5476 // 1 ( 0-bit ) - normal school damage (SPELL_SCHOOL_MASK_NORMAL)
5477 // 126 - full bitmask all magic damages (SPELL_SCHOOL_MASK_MAGIC) including wands
5478 // 127 - full bitmask any damages
5479 //
5480 // mods must be applied base at equipped weapon class and subclass comparison
5481 // with spell->EquippedItemClass and EquippedItemSubClassMask and EquippedItemInventoryTypeMask
5482 // m_modifier.m_miscvalue comparison with item generated damage types
5483
5484 if((m_modifier.m_miscvalue & SPELL_SCHOOL_MASK_NORMAL) != 0)
5485 {
5486 // apply generic physical damage bonuses including wand case
5487 if (GetSpellProto()->EquippedItemClass == -1 || m_target->GetTypeId() != TYPEID_PLAYER)
5488 {
5489 m_target->HandleStatModifier(UNIT_MOD_DAMAGE_MAINHAND, TOTAL_VALUE, float(m_modifier.m_amount), apply);
5490 m_target->HandleStatModifier(UNIT_MOD_DAMAGE_OFFHAND, TOTAL_VALUE, float(m_modifier.m_amount), apply);
5491 m_target->HandleStatModifier(UNIT_MOD_DAMAGE_RANGED, TOTAL_VALUE, float(m_modifier.m_amount), apply);
5492 }
5493 else
5494 {
5495 // done in Player::_ApplyWeaponDependentAuraMods
5496 }
5497
5498 if(m_target->GetTypeId() == TYPEID_PLAYER)
5499 {
5500 if(m_positive)
5501 m_target->ApplyModUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS, m_modifier.m_amount, apply);
5502 else
5503 m_target->ApplyModUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG, m_modifier.m_amount, apply);
5504 }
5505 }
5506
5507 // Skip non magic case for speedup
5508 if((m_modifier.m_miscvalue & SPELL_SCHOOL_MASK_MAGIC) == 0)
5509 return;
5510
5511 if( GetSpellProto()->EquippedItemClass != -1 || GetSpellProto()->EquippedItemInventoryTypeMask != 0 )
5512 {
5513 // wand magic case (skip generic to all item spell bonuses)
5514 // done in Player::_ApplyWeaponDependentAuraMods
5515
5516 // Skip item specific requirements for not wand magic damage
5517 return;
5518 }
5519
5520 // Magic damage modifiers implemented in Unit::SpellDamageBonus
5521 // This information for client side use only
5522 if(m_target->GetTypeId() == TYPEID_PLAYER)
5523 {
5524 if(m_positive)
5525 {
5526 for(int i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; ++i)
5527 {
5528 if((m_modifier.m_miscvalue & (1<<i)) != 0)
5529 m_target->ApplyModUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + i, m_modifier.m_amount, apply);
5530 }
5531 }
5532 else
5533 {
5534 for(int i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; ++i)
5535 {
5536 if((m_modifier.m_miscvalue & (1<<i)) != 0)
5537 m_target->ApplyModUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + i, m_modifier.m_amount, apply);
5538 }
5539 }
5540 Pet* pet = m_target->GetPet();
5541 if(pet)
5542 pet->UpdateAttackPowerAndDamage();
5543 }
5544 }
5545
5546 void Aura::HandleModDamagePercentDone(bool apply, bool Real)
5547 {
5548 sLog.outDebug("AURA MOD DAMAGE type:%u negative:%u", m_modifier.m_miscvalue, m_positive ? 0 : 1);
5549
5550 // apply item specific bonuses for already equipped weapon
5551 if(Real && m_target->GetTypeId() == TYPEID_PLAYER)
5552 {
5553 for(int i = 0; i < MAX_ATTACK; ++i)
5554 if(Item* pItem = ((Player*)m_target)->GetWeaponForAttack(WeaponAttackType(i),true,false))
5555 ((Player*)m_target)->_ApplyWeaponDependentAuraDamageMod(pItem, WeaponAttackType(i), this, apply);
5556 }
5557
5558 // m_modifier.m_miscvalue is bitmask of spell schools
5559 // 1 ( 0-bit ) - normal school damage (SPELL_SCHOOL_MASK_NORMAL)
5560 // 126 - full bitmask all magic damages (SPELL_SCHOOL_MASK_MAGIC) including wand
5561 // 127 - full bitmask any damages
5562 //
5563 // mods must be applied base at equipped weapon class and subclass comparison
5564 // with spell->EquippedItemClass and EquippedItemSubClassMask and EquippedItemInventoryTypeMask
5565 // m_modifier.m_miscvalue comparison with item generated damage types
5566
5567 if((m_modifier.m_miscvalue & SPELL_SCHOOL_MASK_NORMAL) != 0)
5568 {
5569 // apply generic physical damage bonuses including wand case
5570 if (GetSpellProto()->EquippedItemClass == -1 || m_target->GetTypeId() != TYPEID_PLAYER)
5571 {
5572 m_target->HandleStatModifier(UNIT_MOD_DAMAGE_MAINHAND, TOTAL_PCT, float(m_modifier.m_amount), apply);
5573 m_target->HandleStatModifier(UNIT_MOD_DAMAGE_OFFHAND, TOTAL_PCT, float(m_modifier.m_amount), apply);
5574 m_target->HandleStatModifier(UNIT_MOD_DAMAGE_RANGED, TOTAL_PCT, float(m_modifier.m_amount), apply);
5575 }
5576 else
5577 {
5578 // done in Player::_ApplyWeaponDependentAuraMods
5579 }
5580 // For show in client
5581 if(m_target->GetTypeId() == TYPEID_PLAYER)
5582 m_target->ApplyModSignedFloatValue(PLAYER_FIELD_MOD_DAMAGE_DONE_PCT, m_modifier.m_amount/100.0f, apply);
5583 }
5584
5585 // Skip non magic case for speedup
5586 if((m_modifier.m_miscvalue & SPELL_SCHOOL_MASK_MAGIC) == 0)
5587 return;
5588
5589 if( GetSpellProto()->EquippedItemClass != -1 || GetSpellProto()->EquippedItemInventoryTypeMask != 0 )
5590 {
5591 // wand magic case (skip generic to all item spell bonuses)
5592 // done in Player::_ApplyWeaponDependentAuraMods
5593
5594 // Skip item specific requirements for not wand magic damage
5595 return;
5596 }
5597
5598 // Magic damage percent modifiers implemented in Unit::SpellDamageBonus
5599 // Send info to client
5600 if(m_target->GetTypeId() == TYPEID_PLAYER)
5601 for(int i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; ++i)
5602 m_target->ApplyModSignedFloatValue(PLAYER_FIELD_MOD_DAMAGE_DONE_PCT + i, m_modifier.m_amount/100.0f, apply);
5603 }
5604
5605 void Aura::HandleModOffhandDamagePercent(bool apply, bool Real)
5606 {
5607 // spells required only Real aura add/remove
5608 if(!Real)
5609 return;
5610
5611 sLog.outDebug("AURA MOD OFFHAND DAMAGE");
5612
5613 m_target->HandleStatModifier(UNIT_MOD_DAMAGE_OFFHAND, TOTAL_PCT, float(m_modifier.m_amount), apply);
5614 }
5615
5616 /********************************/
5617 /*** POWER COST ***/
5618 /********************************/
5619
5620 void Aura::HandleModPowerCostPCT(bool apply, bool Real)
5621 {
5622 // spells required only Real aura add/remove
5623 if(!Real)
5624 return;
5625
5626 float amount = m_modifier.m_amount/100.0f;
5627 for(int i = 0; i < MAX_SPELL_SCHOOL; ++i)
5628 if(m_modifier.m_miscvalue & (1<<i))
5629 m_target->ApplyModSignedFloatValue(UNIT_FIELD_POWER_COST_MULTIPLIER + i, amount, apply);
5630 }
5631
5632 void Aura::HandleModPowerCost(bool apply, bool Real)
5633 {
5634 // spells required only Real aura add/remove
5635 if(!Real)
5636 return;
5637
5638 for(int i = 0; i < MAX_SPELL_SCHOOL; ++i)
5639 if(m_modifier.m_miscvalue & (1<<i))
5640 m_target->ApplyModInt32Value(UNIT_FIELD_POWER_COST_MODIFIER + i, m_modifier.m_amount, apply);
5641 }
5642
5643 void Aura::HandleNoReagentUseAura(bool /*Apply*/, bool Real)
5644 {
5645 // spells required only Real aura add/remove
5646 if(!Real)
5647 return;
5648 if(m_target->GetTypeId() != TYPEID_PLAYER)
5649 return;
5650 uint32 mask[3] = {0, 0, 0};
5651 Unit::AuraList const& noReagent = m_target->GetAurasByType(SPELL_AURA_NO_REAGENT_USE);
5652 for(Unit::AuraList::const_iterator i = noReagent.begin(); i != noReagent.end(); ++i)
5653 {
5654 uint32 const *ptr = (*i)->getAuraSpellClassMask();
5655 mask[0] |= ptr[0];
5656 mask[1] |= ptr[1];
5657 mask[2] |= ptr[2];
5658 }
5659
5660 m_target->SetUInt32Value(PLAYER_NO_REAGENT_COST_1+0, mask[0]);
5661 m_target->SetUInt32Value(PLAYER_NO_REAGENT_COST_1+1, mask[1]);
5662 m_target->SetUInt32Value(PLAYER_NO_REAGENT_COST_1+2, mask[2]);
5663 }
5664
5665 /*********************************************************/
5666 /*** OTHERS ***/
5667 /*********************************************************/
5668
5669 void Aura::HandleShapeshiftBoosts(bool apply)
5670 {
5671 uint32 spellId1 = 0;
5672 uint32 spellId2 = 0;
5673 uint32 HotWSpellId = 0;
5674 uint32 MasterShaperSpellId = 0;
5675
5676 uint32 form = GetModifier()->m_miscvalue;
5677
5678 switch(form)
5679 {
5680 case FORM_CAT:
5681 spellId1 = 3025;
5682 HotWSpellId = 24900;
5683 MasterShaperSpellId = 48420;
5684 break;
5685 case FORM_TREE:
5686 spellId1 = 5420;
5687 spellId2 = 34123;
5688 MasterShaperSpellId = 48422;
5689 break;
5690 case FORM_TRAVEL:
5691 spellId1 = 5419;
5692 break;
5693 case FORM_AQUA:
5694 spellId1 = 5421;
5695 break;
5696 case FORM_BEAR:
5697 spellId1 = 1178;
5698 spellId2 = 21178;
5699 HotWSpellId = 24899;
5700 MasterShaperSpellId = 48418;
5701 break;
5702 case FORM_DIREBEAR:
5703 spellId1 = 9635;
5704 spellId2 = 21178;
5705 HotWSpellId = 24899;
5706 MasterShaperSpellId = 48418;
5707 break;
5708 case FORM_BATTLESTANCE:
5709 spellId1 = 21156;
5710 break;
5711 case FORM_DEFENSIVESTANCE:
5712 spellId1 = 7376;
5713 break;
5714 case FORM_BERSERKERSTANCE:
5715 spellId1 = 7381;
5716 break;
5717 case FORM_MOONKIN:
5718 spellId1 = 24905;
5719 MasterShaperSpellId = 48421;
5720 break;
5721 case FORM_FLIGHT:
5722 spellId1 = 33948;
5723 spellId2 = 34764;
5724 break;
5725 case FORM_FLIGHT_EPIC:
5726 spellId1 = 40122;
5727 spellId2 = 40121;
5728 break;
5729 case FORM_METAMORPHOSIS:
5730 spellId1 = 54817;
5731 spellId2 = 54879;
5732 break;
5733 case FORM_SPIRITOFREDEMPTION:
5734 spellId1 = 27792;
5735 spellId2 = 27795; // must be second, this important at aura remove to prevent to early iterator invalidation.
5736 break;
5737 case FORM_SHADOW:
5738 spellId1 = 49868;
5739
5740 if(m_target->GetTypeId() == TYPEID_PLAYER) // Spell 49868 have same category as main form spell and share cooldown
5741 ((Player*)m_target)->RemoveSpellCooldown(49868);
5742 break;
5743 case FORM_GHOSTWOLF:
5744 spellId1 = 67116;
5745 break;
5746 case FORM_AMBIENT:
5747 case FORM_GHOUL:
5748 case FORM_STEALTH:
5749 case FORM_CREATURECAT:
5750 case FORM_CREATUREBEAR:
5751 break;
5752 }
5753
5754 if(apply)
5755 {
5756 if (spellId1)
5757 m_target->CastSpell(m_target, spellId1, true, NULL, this );
5758 if (spellId2)
5759 m_target->CastSpell(m_target, spellId2, true, NULL, this);
5760
5761 if (m_target->GetTypeId() == TYPEID_PLAYER)
5762 {
5763 const PlayerSpellMap& sp_list = ((Player *)m_target)->GetSpellMap();
5764 for (PlayerSpellMap::const_iterator itr = sp_list.begin(); itr != sp_list.end(); ++itr)
5765 {
5766 if (itr->second->state == PLAYERSPELL_REMOVED) continue;
5767 if (itr->first==spellId1 || itr->first==spellId2) continue;
5768 SpellEntry const *spellInfo = sSpellStore.LookupEntry(itr->first);
5769 if (!spellInfo || !(spellInfo->Attributes & (SPELL_ATTR_PASSIVE | (1<<7))))
5770 continue;
5771 if (spellInfo->Stances & (1<<(form-1)))
5772 m_target->CastSpell(m_target, itr->first, true, NULL, this);
5773 }
5774
5775 // Master Shapeshifter
5776 if (MasterShaperSpellId)
5777 {
5778 Unit::AuraList const& ShapeShifterAuras = m_target->GetAurasByType(SPELL_AURA_DUMMY);
5779 for(Unit::AuraList::const_iterator i = ShapeShifterAuras.begin(); i != ShapeShifterAuras.end(); i++)
5780 {
5781 if ((*i)->GetSpellProto()->SpellIconID == 2851)
5782 {
5783 int32 ShiftMod = (*i)->GetModifier()->m_amount;
5784 m_target->CastCustomSpell(m_target, MasterShaperSpellId, &ShiftMod, NULL, NULL, true);
5785 break;
5786 }
5787 }
5788 }
5789
5790 // Leader of the Pack
5791 if (((Player*)m_target)->HasSpell(17007))
5792 {
5793 SpellEntry const *spellInfo = sSpellStore.LookupEntry(24932);
5794 if (spellInfo && spellInfo->Stances & (1<<(form-1)))
5795 m_target->CastSpell(m_target, 24932, true, NULL, this);
5796 }
5797
5798 // Savage Roar
5799 if (form == FORM_CAT && ((Player*)m_target)->HasAura(52610))
5800 m_target->CastSpell(m_target, 62071, true);
5801
5802 // Improved Moonkin Form
5803 if (form == FORM_MOONKIN)
5804 {
5805 Unit::AuraList const& dummyAuras = m_target->GetAurasByType(SPELL_AURA_DUMMY);
5806 for(Unit::AuraList::const_iterator i = dummyAuras.begin(); i != dummyAuras.end(); i++)
5807 {
5808 if ((*i)->GetSpellProto()->SpellFamilyName==SPELLFAMILY_DRUID &&
5809 (*i)->GetSpellProto()->SpellIconID == 2855)
5810 {
5811 uint32 spell_id = 0;
5812 switch((*i)->GetId())
5813 {
5814 case 48384:spell_id=50170;break;//Rank 1
5815 case 48395:spell_id=50171;break;//Rank 2
5816 case 48396:spell_id=50172;break;//Rank 3
5817 default:
5818 sLog.outError("Aura::HandleShapeshiftBoosts: Not handled rank of IMF (Spell: %u)",(*i)->GetId());
5819 break;
5820 }
5821
5822 if(spell_id)
5823 m_target->CastSpell(m_target, spell_id, true, NULL, this);
5824 break;
5825 }
5826 }
5827 }
5828
5829 // Heart of the Wild
5830 if (HotWSpellId)
5831 {
5832 Unit::AuraList const& mModTotalStatPct = m_target->GetAurasByType(SPELL_AURA_MOD_TOTAL_STAT_PERCENTAGE);
5833 for(Unit::AuraList::const_iterator i = mModTotalStatPct.begin(); i != mModTotalStatPct.end(); ++i)
5834 {
5835 if ((*i)->GetSpellProto()->SpellIconID == 240 && (*i)->GetModifier()->m_miscvalue == 3)
5836 {
5837 int32 HotWMod = (*i)->GetModifier()->m_amount;
5838 if(GetModifier()->m_miscvalue == FORM_CAT)
5839 HotWMod /= 2;
5840
5841 m_target->CastCustomSpell(m_target, HotWSpellId, &HotWMod, NULL, NULL, true, NULL, this);
5842 break;
5843 }
5844 }
5845 }
5846 }
5847 }
5848 else
5849 {
5850 if(spellId1)
5851 m_target->RemoveAurasDueToSpell(spellId1);
5852 if(spellId2)
5853 m_target->RemoveAurasDueToSpell(spellId2);
5854 if(MasterShaperSpellId)
5855 m_target->RemoveAurasDueToSpell(MasterShaperSpellId);
5856
5857 Unit::AuraMap& tAuras = m_target->GetAuras();
5858 for (Unit::AuraMap::iterator itr = tAuras.begin(); itr != tAuras.end();)
5859 {
5860 if (itr->second->IsRemovedOnShapeLost())
5861 {
5862 m_target->RemoveAurasDueToSpell(itr->second->GetId());
5863 itr = tAuras.begin();
5864 }
5865 else
5866 ++itr;
5867 }
5868 }
5869 }
5870
5871 void Aura::HandleSpellSpecificBoosts(bool apply)
5872 {
5873 bool cast_at_remove = false; // if spell must be casted at last aura from stack remove
5874 uint32 spellId1 = 0;
5875 uint32 spellId2 = 0;
5876 uint32 spellId3 = 0;
5877 uint32 spellId4 = 0;
5878
5879 switch(GetSpellProto()->SpellFamilyName)
5880 {
5881 case SPELLFAMILY_GENERIC:
5882 {
5883 // Illusionary Barrier
5884 if(GetId() == 57350 && !apply && m_target->getPowerType() == POWER_MANA)
5885 {
5886 cast_at_remove = true;
5887 spellId1 = 60242; // Darkmoon Card: Illusion
5888 }
5889 else
5890 return;
5891 break;
5892 }
5893 case SPELLFAMILY_MAGE:
5894 {
5895 // Ice Barrier (non stacking from one caster)
5896 if (m_spellProto->SpellIconID == 32)
5897 {
5898 if (!apply && (m_removeMode == AURA_REMOVE_BY_DISPEL || (m_removeMode == AURA_REMOVE_BY_DEFAULT && !GetModifier()->m_amount)))
5899 {
5900 Unit::AuraList const& dummyAuras = m_target->GetAurasByType(SPELL_AURA_DUMMY);
5901 for(Unit::AuraList::const_iterator itr = dummyAuras.begin(); itr != dummyAuras.end(); ++itr)
5902 {
5903 // Shattered Barrier
5904 if ((*itr)->GetSpellProto()->SpellIconID == 2945)
5905 {
5906 cast_at_remove = true;
5907 // first rank have 50% chance
5908 if ((*itr)->GetId() != 44745 || roll_chance_i(50))
5909 spellId1 = 55080;
5910 break;
5911 }
5912 }
5913 }
5914 else
5915 return;
5916 }
5917 else
5918 return;
5919 break;
5920 }
5921 case SPELLFAMILY_WARRIOR:
5922 {
5923 if(!apply)
5924 {
5925 // Remove Blood Frenzy only if target no longer has any Deep Wound or Rend (applying is handled by procs)
5926 if (GetSpellProto()->Mechanic != MECHANIC_BLEED)
5927 return;
5928
5929 // If target still has one of Warrior's bleeds, do nothing
5930 Unit::AuraList const& PeriodicDamage = m_target->GetAurasByType(SPELL_AURA_PERIODIC_DAMAGE);
5931 for(Unit::AuraList::const_iterator i = PeriodicDamage.begin(); i != PeriodicDamage.end(); ++i)
5932 if( (*i)->GetCasterGUID() == GetCasterGUID() &&
5933 (*i)->GetSpellProto()->SpellFamilyName == SPELLFAMILY_WARRIOR &&
5934 (*i)->GetSpellProto()->Mechanic == MECHANIC_BLEED)
5935 return;
5936
5937 spellId1 = 30069; // Blood Frenzy (Rank 1)
5938 spellId2 = 30070; // Blood Frenzy (Rank 2)
5939 }
5940 break;
5941 }
5942 case SPELLFAMILY_WARLOCK:
5943 {
5944 // Fear (non stacking)
5945 if (m_spellProto->SpellFamilyFlags & UI64LIT(0x0000040000000000))
5946 {
5947 if(!apply)
5948 {
5949 Unit* caster = GetCaster();
5950 if(!caster)
5951 return;
5952
5953 Unit::AuraList const& dummyAuras = caster->GetAurasByType(SPELL_AURA_DUMMY);
5954 for(Unit::AuraList::const_iterator itr = dummyAuras.begin(); itr != dummyAuras.end(); ++itr)
5955 {
5956 SpellEntry const* dummyEntry = (*itr)->GetSpellProto();
5957 // Improved Fear
5958 if (dummyEntry->SpellFamilyName == SPELLFAMILY_WARLOCK && dummyEntry->SpellIconID == 98)
5959 {
5960 cast_at_remove = true;
5961 switch((*itr)->GetModifier()->m_amount)
5962 {
5963 // Rank 1
5964 case 0: spellId1 = 60946; break;
5965 // Rank 1
5966 case 1: spellId1 = 60947; break;
5967 }
5968 break;
5969 }
5970 }
5971 }
5972 else
5973 return;
5974 }
5975 else
5976 return;
5977 break;
5978 }
5979 case SPELLFAMILY_PRIEST:
5980 {
5981 // Shadow Word: Pain (need visual check fro skip improvement talent) or Vampiric Touch
5982 if (m_spellProto->SpellIconID == 234 && m_spellProto->SpellVisual[0] || m_spellProto->SpellIconID == 2213)
5983 {
5984 if (!apply && m_removeMode == AURA_REMOVE_BY_DISPEL)
5985 {
5986 Unit* caster = GetCaster();
5987 if(!caster)
5988 return;
5989
5990 Unit::AuraList const& dummyAuras = caster->GetAurasByType(SPELL_AURA_DUMMY);
5991 for(Unit::AuraList::const_iterator itr = dummyAuras.begin(); itr != dummyAuras.end(); ++itr)
5992 {
5993 // Shadow Affinity
5994 if ((*itr)->GetSpellProto()->SpellFamilyName == SPELLFAMILY_PRIEST
5995 && (*itr)->GetSpellProto()->SpellIconID == 178)
5996 {
5997 // custom cast code
5998 int32 basepoints0 = (*itr)->GetModifier()->m_amount * caster->GetCreateMana() / 100;
5999 caster->CastCustomSpell(caster, 64103, &basepoints0, NULL, NULL, true, NULL, this);
6000 return;
6001 }
6002 }
6003 }
6004 else
6005 return;
6006 }
6007
6008 switch(GetId())
6009 {
6010 // Abolish Disease (remove 1 more poison effect with Body and Soul)
6011 case 552:
6012 {
6013 if(apply)
6014 {
6015 int chance =0;
6016 Unit::AuraList const& dummyAuras = m_target->GetAurasByType(SPELL_AURA_DUMMY);
6017 for(Unit::AuraList::const_iterator itr = dummyAuras.begin(); itr != dummyAuras.end(); ++itr)
6018 {
6019 SpellEntry const* dummyEntry = (*itr)->GetSpellProto();
6020 // Body and Soul (talent ranks)
6021 if (dummyEntry->SpellFamilyName == SPELLFAMILY_PRIEST && dummyEntry->SpellIconID == 2218 &&
6022 dummyEntry->SpellVisual[0]==0)
6023 {
6024 chance = (*itr)->GetSpellProto()->CalculateSimpleValue(1);
6025 break;
6026 }
6027 }
6028
6029 if(roll_chance_i(chance))
6030 spellId1 = 64134; // Body and Soul (periodic dispel effect)
6031 }
6032 else
6033 spellId1 = 64134; // Body and Soul (periodic dispel effect)
6034 break;
6035 }
6036 // Dispersion mana reg and immunity
6037 case 47585:
6038 spellId1 = 60069; // Dispersion
6039 spellId2 = 63230; // Dispersion
6040 break;
6041 default:
6042 return;
6043 }
6044 break;
6045 }
6046 case SPELLFAMILY_ROGUE:
6047 // Sprint (skip non player casted spells by category)
6048 if (GetSpellProto()->SpellFamilyFlags & UI64LIT(0x0000000000000040) && GetSpellProto()->Category == 44)
6049 {
6050 if(!apply || m_target->HasAura(58039)) // Glyph of Blurred Speed
6051 spellId1 = 61922; // Sprint (waterwalk)
6052 else
6053 return;
6054 }
6055 else
6056 return;
6057 break;
6058 case SPELLFAMILY_HUNTER:
6059 {
6060 // The Beast Within and Bestial Wrath - immunity
6061 if (GetId() == 19574 || GetId() == 34471)
6062 {
6063 spellId1 = 24395;
6064 spellId2 = 24396;
6065 spellId3 = 24397;
6066 spellId4 = 26592;
6067 }
6068 // Aspect of the Dragonhawk dodge
6069 else if (GetSpellProto()->SpellFamilyFlags2 & 0x00001000)
6070 {
6071 spellId1 = 61848;
6072
6073 // triggered spell have same category as main spell and cooldown
6074 if (apply && m_target->GetTypeId()==TYPEID_PLAYER)
6075 ((Player*)m_target)->RemoveSpellCooldown(61848);
6076 }
6077 else
6078 return;
6079 break;
6080 }
6081 case SPELLFAMILY_PALADIN:
6082 {
6083 if (m_spellProto->Id == 31884) // Avenging Wrath
6084 {
6085 if(!apply)
6086 spellId1 = 57318; // Sanctified Wrath (triggered)
6087 else
6088 {
6089 int32 percent = 0;
6090 Unit::AuraList const& dummyAuras = m_target->GetAurasByType(SPELL_AURA_DUMMY);
6091 for(Unit::AuraList::const_iterator itr = dummyAuras.begin(); itr != dummyAuras.end(); ++itr)
6092 {
6093 if ((*itr)->GetSpellProto()->SpellIconID == 3029)
6094 {
6095 percent = (*itr)->GetModifier()->m_amount;
6096 break;
6097 }
6098 }
6099
6100 // apply in special way
6101 if(percent)
6102 {
6103 spellId1 = 57318; // Sanctified Wrath (triggered)
6104 // prevent aura deletion, specially in multi-boost case
6105 SetInUse(true);
6106 m_target->CastCustomSpell(m_target, spellId1, &percent, &percent, NULL, true, NULL, this);
6107 SetInUse(false);
6108 }
6109 return;
6110 }
6111 break;
6112 }
6113
6114 // Only process on player casting paladin aura
6115 // all aura bonuses applied also in aura area effect way to caster
6116 if (GetCasterGUID() != m_target->GetGUID() || !IS_PLAYER_GUID(GetCasterGUID()))
6117 return;
6118
6119 if (GetSpellSpecific(m_spellProto->Id) != SPELL_AURA)
6120 return;
6121
6122 // Sanctified Retribution and Swift Retribution (they share one aura), but not Retribution Aura (already gets modded)
6123 if ((GetSpellProto()->SpellFamilyFlags & UI64LIT(0x0000000000000008))==0)
6124 spellId1 = 63531; // placeholder for talent spell mods
6125 // Improved Concentration Aura (auras bonus)
6126 spellId2 = 63510; // placeholder for talent spell mods
6127 // Improved Devotion Aura (auras bonus)
6128 spellId3 = 63514; // placeholder for talent spell mods
6129 break;
6130 }
6131 case SPELLFAMILY_DEATHKNIGHT:
6132 {
6133 if (GetSpellSpecific(m_spellProto->Id) != SPELL_PRESENCE)
6134 return;
6135
6136 // Frost Presence health
6137 if (GetId() == 48263)
6138 spellId1 = 61261;
6139 // Unholy Presence move speed
6140 else if (GetId() == 48265)
6141 spellId1 = 49772;
6142 else
6143 return;
6144
6145 break;
6146 }
6147 default:
6148 return;
6149 }
6150
6151 // prevent aura deletion, specially in multi-boost case
6152 SetInUse(true);
6153
6154 if (apply || cast_at_remove)
6155 {
6156 if (spellId1)
6157 m_target->CastSpell(m_target, spellId1, true, NULL, this);
6158 if (spellId2 && !IsDeleted())
6159 m_target->CastSpell(m_target, spellId2, true, NULL, this);
6160 if (spellId3 && !IsDeleted())
6161 m_target->CastSpell(m_target, spellId3, true, NULL, this);
6162 if (spellId4 && !IsDeleted())
6163 m_target->CastSpell(m_target, spellId4, true, NULL, this);
6164 }
6165 else
6166 {
6167 if (spellId1)
6168 m_target->RemoveAurasByCasterSpell(spellId1, GetCasterGUID());
6169 if (spellId2)
6170 m_target->RemoveAurasByCasterSpell(spellId2, GetCasterGUID());
6171 if (spellId3)
6172 m_target->RemoveAurasByCasterSpell(spellId3, GetCasterGUID());
6173 if (spellId4)
6174 m_target->RemoveAurasByCasterSpell(spellId4, GetCasterGUID());
6175 }
6176
6177 SetInUse(false);
6178 }
6179
6180 void Aura::HandleAuraEmpathy(bool apply, bool /*Real*/)
6181 {
6182 if(m_target->GetTypeId() != TYPEID_UNIT)
6183 return;
6184
6185 CreatureInfo const * ci = ObjectMgr::GetCreatureTemplate(m_target->GetEntry());
6186 if(ci && ci->type == CREATURE_TYPE_BEAST)
6187 m_target->ApplyModUInt32Value(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_SPECIALINFO, apply);
6188 }
6189
6190 void Aura::HandleAuraUntrackable(bool apply, bool /*Real*/)
6191 {
6192 if(apply)
6193 m_target->SetByteFlag(UNIT_FIELD_BYTES_1, 3, UNIT_BYTE1_FLAG_UNTRACKABLE);
6194 else
6195 m_target->RemoveByteFlag(UNIT_FIELD_BYTES_1, 3, UNIT_BYTE1_FLAG_UNTRACKABLE);
6196 }
6197
6198 void Aura::HandleAuraModPacify(bool apply, bool /*Real*/)
6199 {
6200 if(m_target->GetTypeId() != TYPEID_PLAYER)
6201 return;
6202
6203 if(apply)
6204 m_target->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED);
6205 else
6206 m_target->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED);
6207 }
6208
6209 void Aura::HandleAuraModPacifyAndSilence(bool apply, bool Real)
6210 {
6211 HandleAuraModPacify(apply, Real);
6212 HandleAuraModSilence(apply, Real);
6213 }
6214
6215 void Aura::HandleAuraGhost(bool apply, bool /*Real*/)
6216 {
6217 if(m_target->GetTypeId() != TYPEID_PLAYER)
6218 return;
6219
6220 if(apply)
6221 {
6222 m_target->SetFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST);
6223 }
6224 else
6225 {
6226 m_target->RemoveFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST);
6227 }
6228 }
6229
6230 void Aura::HandleAuraAllowFlight(bool apply, bool Real)
6231 {
6232 // all applied/removed only at real aura add/remove
6233 if(!Real)
6234 return;
6235
6236 // allow fly
6237 WorldPacket data;
6238 if(apply)
6239 data.Initialize(SMSG_MOVE_SET_CAN_FLY, 12);
6240 else
6241 data.Initialize(SMSG_MOVE_UNSET_CAN_FLY, 12);
6242 data.append(m_target->GetPackGUID());
6243 data << uint32(0); // unk
6244 m_target->SendMessageToSet(&data, true);
6245 }
6246
6247 void Aura::HandleModRating(bool apply, bool Real)
6248 {
6249 // spells required only Real aura add/remove
6250 if(!Real)
6251 return;
6252
6253 if(m_target->GetTypeId() != TYPEID_PLAYER)
6254 return;
6255
6256 for (uint32 rating = 0; rating < MAX_COMBAT_RATING; ++rating)
6257 if (m_modifier.m_miscvalue & (1 << rating))
6258 ((Player*)m_target)->ApplyRatingMod(CombatRating(rating), m_modifier.m_amount, apply);
6259 }
6260
6261 void Aura::HandleModRatingFromStat(bool apply, bool Real)
6262 {
6263 // spells required only Real aura add/remove
6264 if(!Real)
6265 return;
6266
6267 if(m_target->GetTypeId() != TYPEID_PLAYER)
6268 return;
6269 // Just recalculate ratings
6270 for (uint32 rating = 0; rating < MAX_COMBAT_RATING; ++rating)
6271 if (m_modifier.m_miscvalue & (1 << rating))
6272 ((Player*)m_target)->ApplyRatingMod(CombatRating(rating), 0, apply);
6273 }
6274
6275 void Aura::HandleForceMoveForward(bool apply, bool Real)
6276 {
6277 if(!Real || m_target->GetTypeId() != TYPEID_PLAYER)
6278 return;
6279 if(apply)
6280 m_target->SetFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_FORCE_MOVE);
6281 else
6282 m_target->RemoveFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_FORCE_MOVE);
6283 }
6284
6285 void Aura::HandleAuraModExpertise(bool /*apply*/, bool /*Real*/)
6286 {
6287 if(m_target->GetTypeId() != TYPEID_PLAYER)
6288 return;
6289
6290 ((Player*)m_target)->UpdateExpertise(BASE_ATTACK);
6291 ((Player*)m_target)->UpdateExpertise(OFF_ATTACK);
6292 }
6293
6294 void Aura::HandleModTargetResistance(bool apply, bool Real)
6295 {
6296 // spells required only Real aura add/remove
6297 if(!Real)
6298 return;
6299 // applied to damage as HandleNoImmediateEffect in Unit::CalcAbsorbResist and Unit::CalcArmorReducedDamage
6300
6301 // show armor penetration
6302 if (m_target->GetTypeId() == TYPEID_PLAYER && (m_modifier.m_miscvalue & SPELL_SCHOOL_MASK_NORMAL))
6303 m_target->ApplyModInt32Value(PLAYER_FIELD_MOD_TARGET_PHYSICAL_RESISTANCE, m_modifier.m_amount, apply);
6304
6305 // show as spell penetration only full spell penetration bonuses (all resistances except armor and holy
6306 if (m_target->GetTypeId() == TYPEID_PLAYER && (m_modifier.m_miscvalue & SPELL_SCHOOL_MASK_SPELL)==SPELL_SCHOOL_MASK_SPELL)
6307 m_target->ApplyModInt32Value(PLAYER_FIELD_MOD_TARGET_RESISTANCE, m_modifier.m_amount, apply);
6308 }
6309
6310 void Aura::HandleShieldBlockValue(bool apply, bool /*Real*/)
6311 {
6312 BaseModType modType = FLAT_MOD;
6313 if(m_modifier.m_auraname == SPELL_AURA_MOD_SHIELD_BLOCKVALUE_PCT)
6314 modType = PCT_MOD;
6315
6316 if(m_target->GetTypeId() == TYPEID_PLAYER)
6317 ((Player*)m_target)->HandleBaseModValue(SHIELD_BLOCK_VALUE, modType, float(m_modifier.m_amount), apply);
6318 }
6319
6320 void Aura::HandleAuraRetainComboPoints(bool apply, bool Real)
6321 {
6322 // spells required only Real aura add/remove
6323 if(!Real)
6324 return;
6325
6326 if(m_target->GetTypeId() != TYPEID_PLAYER)
6327 return;
6328
6329 Player *target = (Player*)m_target;
6330
6331 // combo points was added in SPELL_EFFECT_ADD_COMBO_POINTS handler
6332 // remove only if aura expire by time (in case combo points amount change aura removed without combo points lost)
6333 if( !apply && m_duration==0 && target->GetComboTarget())
6334 if(Unit* unit = ObjectAccessor::GetUnit(*m_target,target->GetComboTarget()))
6335 target->AddComboPoints(unit, -m_modifier.m_amount);
6336 }
6337
6338 void Aura::HandleModUnattackable( bool Apply, bool Real )
6339 {
6340 if(Real && Apply)
6341 {
6342 m_target->CombatStop();
6343 m_target->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_IMMUNE_OR_LOST_SELECTION);
6344 }
6345 m_target->ApplyModFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE,Apply);
6346 }
6347
6348 void Aura::HandleSpiritOfRedemption( bool apply, bool Real )
6349 {
6350 // spells required only Real aura add/remove
6351 if(!Real)
6352 return;
6353
6354 // prepare spirit state
6355 if(apply)
6356 {
6357 if(m_target->GetTypeId()==TYPEID_PLAYER)
6358 {
6359 // disable breath/etc timers
6360 ((Player*)m_target)->StopMirrorTimers();
6361
6362 // set stand state (expected in this form)
6363 if(!m_target->IsStandState())
6364 m_target->SetStandState(UNIT_STAND_STATE_STAND);
6365 }
6366
6367 m_target->SetHealth(1);
6368 }
6369 // die at aura end
6370 else
6371 m_target->DealDamage(m_target, m_target->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, GetSpellProto(), false);
6372 }
6373
6374 void Aura::CleanupTriggeredSpells()
6375 {
6376 uint32 tSpellId = m_spellProto->EffectTriggerSpell[GetEffIndex()];
6377 if(!tSpellId)
6378 return;
6379
6380 SpellEntry const* tProto = sSpellStore.LookupEntry(tSpellId);
6381 if(!tProto)
6382 return;
6383
6384 if(GetSpellDuration(tProto) != -1)
6385 return;
6386
6387 // needed for spell 43680, maybe others
6388 // TODO: is there a spell flag, which can solve this in a more sophisticated way?
6389 if(m_spellProto->EffectApplyAuraName[GetEffIndex()] == SPELL_AURA_PERIODIC_TRIGGER_SPELL &&
6390 GetSpellDuration(m_spellProto) == m_spellProto->EffectAmplitude[GetEffIndex()])
6391 return;
6392 m_target->RemoveAurasDueToSpell(tSpellId);
6393 }
6394
6395 void Aura::HandleSchoolAbsorb(bool apply, bool Real)
6396 {
6397 if(!Real)
6398 return;
6399
6400 Unit* caster = GetCaster();
6401 if(!caster)
6402 return;
6403
6404 if (apply)
6405 {
6406 // prevent double apply bonuses
6407 if (m_target->GetTypeId()!=TYPEID_PLAYER || !((Player*)m_target)->GetSession()->PlayerLoading())
6408 {
6409 float DoneActualBenefit = 0.0f;
6410 switch(m_spellProto->SpellFamilyName)
6411 {
6412 case SPELLFAMILY_PRIEST:
6413 // Power Word: Shield
6414 if (m_spellProto->SpellFamilyFlags & UI64LIT(0x0000000000000001))
6415 //+80.68% from +spell bonus
6416 DoneActualBenefit = caster->SpellBaseHealingBonus(GetSpellSchoolMask(m_spellProto)) * 0.8068f;
6417 break;
6418 case SPELLFAMILY_MAGE:
6419 // Frost Ward, Fire Ward
6420 if (m_spellProto->SpellFamilyFlags & UI64LIT(0x0000000000000108))
6421 //+10% from +spell bonus
6422 DoneActualBenefit = caster->SpellBaseDamageBonus(GetSpellSchoolMask(m_spellProto)) * 0.1f;
6423 // Ice Barrier
6424 else if (m_spellProto->SpellFamilyFlags & UI64LIT(0x0000000100000000))
6425 //+80.67% from +spell bonus
6426 DoneActualBenefit = caster->SpellBaseDamageBonus(GetSpellSchoolMask(m_spellProto)) * 0.8067f;
6427 break;
6428 case SPELLFAMILY_WARLOCK:
6429 // Shadow Ward
6430 if (m_spellProto->SpellFamilyFlags2 & 0x00000040)
6431 //+30% from +spell bonus
6432 DoneActualBenefit = caster->SpellBaseDamageBonus(GetSpellSchoolMask(m_spellProto)) * 0.30f;
6433 break;
6434 case SPELLFAMILY_PALADIN:
6435 // Sacred Shield
6436 // (check not strictly needed, only Sacred Shield has SPELL_AURA_SCHOOL_ABSORB in SPELLFAMILY_PALADIN at this time)
6437 if (m_spellProto->SpellFamilyFlags & UI64LIT(0x0008000000000000))
6438 {
6439 // +75% from spell power
6440 DoneActualBenefit = caster->SpellBaseHealingBonus(GetSpellSchoolMask(m_spellProto)) * 0.75f;
6441 }
6442 break;
6443 default:
6444 break;
6445 }
6446
6447 DoneActualBenefit *= caster->CalculateLevelPenalty(GetSpellProto());
6448
6449 m_modifier.m_amount += (int32)DoneActualBenefit;
6450 }
6451 }
6452 else
6453 {
6454 if (caster &&
6455 // Power Word: Shield
6456 m_spellProto->SpellFamilyName == SPELLFAMILY_PRIEST && m_spellProto->Mechanic == MECHANIC_SHIELD &&
6457 (m_spellProto->SpellFamilyFlags & UI64LIT(0x0000000000000001)) &&
6458 // completely absorbed or dispelled
6459 ((m_removeMode == AURA_REMOVE_BY_DEFAULT && !m_modifier.m_amount) || m_removeMode == AURA_REMOVE_BY_DISPEL))
6460 {
6461 Unit::AuraList const& vDummyAuras = caster->GetAurasByType(SPELL_AURA_DUMMY);
6462 for(Unit::AuraList::const_iterator itr = vDummyAuras.begin(); itr != vDummyAuras.end(); ++itr)
6463 {
6464 SpellEntry const* vSpell = (*itr)->GetSpellProto();
6465
6466 // Rapture (main spell)
6467 if(vSpell->SpellFamilyName == SPELLFAMILY_PRIEST && vSpell->SpellIconID == 2894 && vSpell->Effect[1])
6468 {
6469 switch((*itr)->GetEffIndex())
6470 {
6471 case 0:
6472 {
6473 // energize caster
6474 int32 manapct1000 = 5 * ((*itr)->GetModifier()->m_amount + sSpellMgr.GetSpellRank(vSpell->Id));
6475 int32 basepoints0 = caster->GetMaxPower(POWER_MANA) * manapct1000 / 1000;
6476 caster->CastCustomSpell(caster, 47755, &basepoints0, NULL, NULL, true);
6477 break;
6478 }
6479 case 1:
6480 {
6481 // energize target
6482 if (!roll_chance_i((*itr)->GetModifier()->m_amount) || caster->HasAura(63853))
6483 break;
6484
6485 switch(m_target->getPowerType())
6486 {
6487 case POWER_RUNIC_POWER:
6488 m_target->CastSpell(m_target, 63652, true, NULL, NULL, m_caster_guid);
6489 break;
6490 case POWER_RAGE:
6491 m_target->CastSpell(m_target, 63653, true, NULL, NULL, m_caster_guid);
6492 break;
6493 case POWER_MANA:
6494 {
6495 int32 basepoints0 = m_target->GetMaxPower(POWER_MANA) * 2 / 100;
6496 m_target->CastCustomSpell(m_target, 63654, &basepoints0, NULL, NULL, true);
6497 break;
6498 }
6499 case POWER_ENERGY:
6500 m_target->CastSpell(m_target, 63655, true, NULL, NULL, m_caster_guid);
6501 break;
6502 default:
6503 break;
6504 }
6505
6506 //cooldwon aura
6507 caster->CastSpell(caster, 63853, true);
6508 break;
6509 }
6510 default:
6511 sLog.outError("Changes in R-dummy spell???: effect 3");
6512 break;
6513 }
6514 }
6515 }
6516 }
6517 }
6518 }
6519
6520 void Aura::PeriodicTick()
6521 {
6522 switch(m_modifier.m_auraname)
6523 {
6524 case SPELL_AURA_PERIODIC_DAMAGE:
6525 case SPELL_AURA_PERIODIC_DAMAGE_PERCENT:
6526 {
6527 Unit *pCaster = GetCaster();
6528 if(!pCaster)
6529 return;
6530
6531 if( GetSpellProto()->Effect[GetEffIndex()] == SPELL_EFFECT_PERSISTENT_AREA_AURA &&
6532 pCaster->SpellHitResult(m_target, GetSpellProto(), false) != SPELL_MISS_NONE)
6533 return;
6534
6535 // Check for immune (not use charges)
6536 if(m_target->IsImmunedToDamage(GetSpellSchoolMask(GetSpellProto())))
6537 return;
6538
6539 // some auras remove at specific health level or more
6540 if(m_modifier.m_auraname == SPELL_AURA_PERIODIC_DAMAGE)
6541 {
6542 switch(GetId())
6543 {
6544 case 43093: case 31956: case 38801:
6545 case 35321: case 38363: case 39215:
6546 if(m_target->GetHealth() == m_target->GetMaxHealth() )
6547 {
6548 m_target->RemoveAurasDueToSpell(GetId());
6549 return;
6550 }
6551 break;
6552 case 38772:
6553 {
6554 uint32 percent =
6555 GetEffIndex() < 2 && GetSpellProto()->Effect[GetEffIndex()] == SPELL_EFFECT_DUMMY ?
6556 pCaster->CalculateSpellDamage(GetSpellProto(), GetEffIndex() + 1, GetSpellProto()->EffectBasePoints[GetEffIndex() + 1], m_target) :
6557 100;
6558 if(m_target->GetHealth() * 100 >= m_target->GetMaxHealth() * percent )
6559 {
6560 m_target->RemoveAurasDueToSpell(GetId());
6561 return;
6562 }
6563 break;
6564 }
6565 default:
6566 break;
6567 }
6568 }
6569
6570 uint32 absorb = 0;
6571 uint32 resist = 0;
6572 CleanDamage cleanDamage = CleanDamage(0, BASE_ATTACK, MELEE_HIT_NORMAL );
6573
6574 // ignore non positive values (can be result apply spellmods to aura damage
6575 uint32 amount = m_modifier.m_amount > 0 ? m_modifier.m_amount : 0;
6576
6577 uint32 pdamage;
6578
6579 if(m_modifier.m_auraname == SPELL_AURA_PERIODIC_DAMAGE)
6580 {
6581 pdamage = amount;
6582
6583 // SpellDamageBonus for magic spells
6584 if(GetSpellProto()->DmgClass == SPELL_DAMAGE_CLASS_NONE || GetSpellProto()->DmgClass == SPELL_DAMAGE_CLASS_MAGIC)
6585 pdamage = pCaster->SpellDamageBonus(m_target, GetSpellProto(), pdamage, DOT, GetStackAmount());
6586 // MeleeDamagebonus for weapon based spells
6587 else
6588 {
6589 WeaponAttackType attackType = GetWeaponAttackType(GetSpellProto());
6590 pdamage = pCaster->MeleeDamageBonus(m_target, pdamage, attackType, GetSpellProto(), DOT, GetStackAmount());
6591 }
6592
6593 // Calculate armor mitigation if it is a physical spell
6594 // But not for bleed mechanic spells
6595 if (GetSpellSchoolMask(GetSpellProto()) & SPELL_SCHOOL_MASK_NORMAL &&
6596 GetEffectMechanic(GetSpellProto(), m_effIndex) != MECHANIC_BLEED)
6597 {
6598 uint32 pdamageReductedArmor = pCaster->CalcArmorReducedDamage(m_target, pdamage);
6599 cleanDamage.damage += pdamage - pdamageReductedArmor;
6600 pdamage = pdamageReductedArmor;
6601 }
6602
6603 // Curse of Agony damage-per-tick calculation
6604 if (GetSpellProto()->SpellFamilyName==SPELLFAMILY_WARLOCK && (GetSpellProto()->SpellFamilyFlags & UI64LIT(0x0000000000000400)) && GetSpellProto()->SpellIconID==544)
6605 {
6606 // 1..4 ticks, 1/2 from normal tick damage
6607 if (m_duration >= ((m_maxduration-m_modifier.periodictime) * 2 / 3))
6608 pdamage = pdamage/2;
6609 // 9..12 ticks, 3/2 from normal tick damage
6610 else if(m_duration < ((m_maxduration-m_modifier.periodictime) / 3))
6611 pdamage += (pdamage + 1) / 2; // +1 prevent 0.5 damage possible lost at 1..4 ticks
6612 // 5..8 ticks have normal tick damage
6613 }
6614 }
6615 else
6616 pdamage = uint32(m_target->GetMaxHealth()*amount/100);
6617
6618 // This method can modify pdamage
6619 bool isCrit = IsCritFromAbilityAura(pCaster, pdamage);
6620
6621 // send critical in hit info for threat calculation
6622 if (isCrit)
6623 {
6624 cleanDamage.hitOutCome = MELEE_HIT_CRIT;
6625 // Resilience - reduce crit damage
6626 pdamage -= m_target->GetSpellCritDamageReduction(pdamage);
6627 }
6628
6629 // only from players
6630 // FIXME: need use SpellDamageBonus instead?
6631 if (IS_PLAYER_GUID(m_caster_guid))
6632 pdamage -= m_target->GetSpellDamageReduction(pdamage);
6633
6634 pCaster->CalcAbsorbResist(m_target, GetSpellSchoolMask(GetSpellProto()), DOT, pdamage, &absorb, &resist, !(GetSpellProto()->AttributesEx2 & SPELL_ATTR_EX2_CANT_REFLECTED));
6635
6636 sLog.outDetail("PeriodicTick: %u (TypeId: %u) attacked %u (TypeId: %u) for %u dmg inflicted by %u abs is %u",
6637 GUID_LOPART(GetCasterGUID()), GuidHigh2TypeId(GUID_HIPART(GetCasterGUID())), m_target->GetGUIDLow(), m_target->GetTypeId(), pdamage, GetId(),absorb);
6638
6639 pCaster->DealDamageMods(m_target, pdamage, &absorb);
6640
6641 SpellPeriodicAuraLogInfo pInfo(this, pdamage, 0, absorb, resist, 0.0f, isCrit);
6642 m_target->SendPeriodicAuraLog(&pInfo);
6643
6644 // Set trigger flag
6645 uint32 procAttacker = PROC_FLAG_ON_DO_PERIODIC; // | PROC_FLAG_SUCCESSFUL_HARMFUL_SPELL_HIT;
6646 uint32 procVictim = PROC_FLAG_ON_TAKE_PERIODIC;// | PROC_FLAG_TAKEN_HARMFUL_SPELL_HIT;
6647 pdamage = (pdamage <= absorb + resist) ? 0 : (pdamage - absorb - resist);
6648 if (pdamage)
6649 procVictim|=PROC_FLAG_TAKEN_ANY_DAMAGE;
6650 pCaster->ProcDamageAndSpell(m_target, procAttacker, procVictim, PROC_EX_NORMAL_HIT, pdamage, BASE_ATTACK, GetSpellProto());
6651
6652 pCaster->DealDamage(m_target, pdamage, &cleanDamage, DOT, GetSpellSchoolMask(GetSpellProto()), GetSpellProto(), true);
6653 break;
6654 }
6655 case SPELL_AURA_PERIODIC_LEECH:
6656 case SPELL_AURA_PERIODIC_HEALTH_FUNNEL:
6657 {
6658 Unit *pCaster = GetCaster();
6659 if(!pCaster)
6660 return;
6661
6662 if(!pCaster->isAlive())
6663 return;
6664
6665 if( GetSpellProto()->Effect[GetEffIndex()] == SPELL_EFFECT_PERSISTENT_AREA_AURA &&
6666 pCaster->SpellHitResult(m_target, GetSpellProto(), false) != SPELL_MISS_NONE)
6667 return;
6668
6669 // Check for immune
6670 if(m_target->IsImmunedToDamage(GetSpellSchoolMask(GetSpellProto())))
6671 return;
6672
6673 uint32 absorb=0;
6674 uint32 resist=0;
6675 CleanDamage cleanDamage = CleanDamage(0, BASE_ATTACK, MELEE_HIT_NORMAL );
6676
6677 uint32 pdamage = m_modifier.m_amount > 0 ? m_modifier.m_amount : 0;
6678
6679 //Calculate armor mitigation if it is a physical spell
6680 if (GetSpellSchoolMask(GetSpellProto()) & SPELL_SCHOOL_MASK_NORMAL)
6681 {
6682 uint32 pdamageReductedArmor = pCaster->CalcArmorReducedDamage(m_target, pdamage);
6683 cleanDamage.damage += pdamage - pdamageReductedArmor;
6684 pdamage = pdamageReductedArmor;
6685 }
6686
6687 pdamage = pCaster->SpellDamageBonus(m_target, GetSpellProto(), pdamage, DOT, GetStackAmount());
6688
6689 pCaster->CalcAbsorbResist(m_target, GetSpellSchoolMask(GetSpellProto()), DOT, pdamage, &absorb, &resist, !(GetSpellProto()->AttributesEx2 & SPELL_ATTR_EX2_CANT_REFLECTED));
6690
6691 if(m_target->GetHealth() < pdamage)
6692 pdamage = uint32(m_target->GetHealth());
6693
6694 sLog.outDetail("PeriodicTick: %u (TypeId: %u) health leech of %u (TypeId: %u) for %u dmg inflicted by %u abs is %u",
6695 GUID_LOPART(GetCasterGUID()), GuidHigh2TypeId(GUID_HIPART(GetCasterGUID())), m_target->GetGUIDLow(), m_target->GetTypeId(), pdamage, GetId(),absorb);
6696
6697 pCaster->SendSpellNonMeleeDamageLog(m_target, GetId(), pdamage, GetSpellSchoolMask(GetSpellProto()), absorb, resist, false, 0);
6698
6699 float multiplier = GetSpellProto()->EffectMultipleValue[GetEffIndex()] > 0 ? GetSpellProto()->EffectMultipleValue[GetEffIndex()] : 1;
6700
6701 // Set trigger flag
6702 uint32 procAttacker = PROC_FLAG_ON_DO_PERIODIC; // | PROC_FLAG_SUCCESSFUL_HARMFUL_SPELL_HIT;
6703 uint32 procVictim = PROC_FLAG_ON_TAKE_PERIODIC;// | PROC_FLAG_TAKEN_HARMFUL_SPELL_HIT;
6704 pdamage = (pdamage <= absorb + resist) ? 0 : (pdamage-absorb-resist);
6705 if (pdamage)
6706 procVictim|=PROC_FLAG_TAKEN_ANY_DAMAGE;
6707 pCaster->ProcDamageAndSpell(m_target, procAttacker, procVictim, PROC_EX_NORMAL_HIT, pdamage, BASE_ATTACK, GetSpellProto());
6708 int32 new_damage = pCaster->DealDamage(m_target, pdamage, &cleanDamage, DOT, GetSpellSchoolMask(GetSpellProto()), GetSpellProto(), false);
6709
6710 if (!m_target->isAlive() && pCaster->IsNonMeleeSpellCasted(false))
6711 for (uint32 i = CURRENT_FIRST_NON_MELEE_SPELL; i < CURRENT_MAX_SPELL; ++i)
6712 if (Spell* spell = pCaster->GetCurrentSpell(CurrentSpellTypes(i)))
6713 if (spell->m_spellInfo->Id == GetId())
6714 spell->cancel();
6715
6716
6717 if(Player *modOwner = pCaster->GetSpellModOwner())
6718 modOwner->ApplySpellMod(GetId(), SPELLMOD_MULTIPLE_VALUE, multiplier);
6719
6720 uint32 heal = pCaster->SpellHealingBonus(pCaster, GetSpellProto(), uint32(new_damage * multiplier), DOT, GetStackAmount());
6721
6722 int32 gain = pCaster->DealHeal(pCaster, heal, GetSpellProto());
6723 pCaster->getHostileRefManager().threatAssist(pCaster, gain * 0.5f, GetSpellProto());
6724 break;
6725 }
6726 case SPELL_AURA_PERIODIC_HEAL:
6727 case SPELL_AURA_OBS_MOD_HEALTH:
6728 {
6729 Unit *pCaster = GetCaster();
6730 if(!pCaster)
6731 return;
6732
6733 // heal for caster damage (must be alive)
6734 if(m_target != pCaster && GetSpellProto()->SpellVisual[0] == 163 && !pCaster->isAlive())
6735 return;
6736
6737 // ignore non positive values (can be result apply spellmods to aura damage
6738 uint32 amount = m_modifier.m_amount > 0 ? m_modifier.m_amount : 0;
6739
6740 uint32 pdamage;
6741
6742 if(m_modifier.m_auraname==SPELL_AURA_OBS_MOD_HEALTH)
6743 pdamage = uint32(m_target->GetMaxHealth() * amount / 100);
6744 else
6745 {
6746 pdamage = amount;
6747
6748 // Wild Growth (1/7 - 6 + 2*ramainTicks) %
6749 if (m_spellProto->SpellFamilyName == SPELLFAMILY_DRUID && m_spellProto->SpellIconID == 2864)
6750 {
6751 int32 ticks = m_maxduration/m_modifier.periodictime;
6752 int32 remainingTicks = int32(float(m_duration) / m_modifier.periodictime + 0.5);
6753 pdamage = int32(pdamage) + int32(amount)*ticks*(-6+2*remainingTicks)/100;
6754 }
6755 }
6756
6757 pdamage = pCaster->SpellHealingBonus(m_target, GetSpellProto(), pdamage, DOT, GetStackAmount());
6758
6759 // This method can modify pdamage
6760 bool isCrit = IsCritFromAbilityAura(pCaster, pdamage);
6761
6762 sLog.outDetail("PeriodicTick: %u (TypeId: %u) heal of %u (TypeId: %u) for %u health inflicted by %u",
6763 GUID_LOPART(GetCasterGUID()), GuidHigh2TypeId(GUID_HIPART(GetCasterGUID())), m_target->GetGUIDLow(), m_target->GetTypeId(), pdamage, GetId());
6764
6765 SpellPeriodicAuraLogInfo pInfo(this, pdamage, 0, 0, 0, 0.0f, isCrit);
6766 m_target->SendPeriodicAuraLog(&pInfo);
6767
6768 int32 gain = m_target->ModifyHealth(pdamage);
6769
6770 // Set trigger flag
6771 uint32 procAttacker = PROC_FLAG_ON_DO_PERIODIC;
6772 uint32 procVictim = PROC_FLAG_ON_TAKE_PERIODIC;
6773 pCaster->ProcDamageAndSpell(m_target, procAttacker, procVictim, PROC_EX_NORMAL_HIT, gain, BASE_ATTACK, m_spellProto);
6774
6775 // add HoTs to amount healed in bgs
6776 if( pCaster->GetTypeId() == TYPEID_PLAYER )
6777 if( BattleGround *bg = ((Player*)pCaster)->GetBattleGround() )
6778 bg->UpdatePlayerScore(((Player*)pCaster), SCORE_HEALING_DONE, gain);
6779
6780 m_target->getHostileRefManager().threatAssist(pCaster, float(gain) * 0.5f, GetSpellProto());
6781
6782 SpellEntry const* spellProto = GetSpellProto();
6783
6784 // heal for caster damage
6785 if(m_target != pCaster && spellProto->SpellVisual[0] == 163)
6786 {
6787 uint32 dmg = spellProto->manaPerSecond;
6788 if(pCaster->GetHealth() <= dmg && pCaster->GetTypeId()==TYPEID_PLAYER)
6789 {
6790 pCaster->RemoveAurasDueToSpell(GetId());
6791
6792 // finish current generic/channeling spells, don't affect autorepeat
6793 pCaster->FinishSpell(CURRENT_GENERIC_SPELL);
6794 pCaster->FinishSpell(CURRENT_CHANNELED_SPELL);
6795 }
6796 else
6797 {
6798 uint32 damage = gain;
6799 uint32 absorb = 0;
6800 pCaster->DealDamageMods(pCaster, damage, &absorb);
6801 pCaster->SendSpellNonMeleeDamageLog(pCaster, GetId(), damage, GetSpellSchoolMask(GetSpellProto()), absorb, 0, false, 0, false);
6802
6803 CleanDamage cleanDamage = CleanDamage(0, BASE_ATTACK, MELEE_HIT_NORMAL );
6804 pCaster->DealDamage(pCaster, damage, &cleanDamage, NODAMAGE, GetSpellSchoolMask(GetSpellProto()), GetSpellProto(), true);
6805 }
6806 }
6807
6808 // uint32 procAttacker = PROC_FLAG_ON_DO_PERIODIC;// | PROC_FLAG_SUCCESSFUL_HEAL;
6809 // uint32 procVictim = 0;//ROC_FLAG_ON_TAKE_PERIODIC | PROC_FLAG_TAKEN_HEAL;
6810 // ignore item heals
6811 // if(procSpell && !haveCastItem)
6812 // pCaster->ProcDamageAndSpell(target, procAttacker, procVictim, PROC_EX_NORMAL_HIT, pdamage, BASE_ATTACK, spellProto);
6813 break;
6814 }
6815 case SPELL_AURA_PERIODIC_MANA_LEECH:
6816 {
6817 if(m_modifier.m_miscvalue < 0 || m_modifier.m_miscvalue >= MAX_POWERS)
6818 return;
6819
6820 Powers power = Powers(m_modifier.m_miscvalue);
6821
6822 // power type might have changed between aura applying and tick (druid's shapeshift)
6823 if(m_target->getPowerType() != power)
6824 return;
6825
6826 Unit *pCaster = GetCaster();
6827 if(!pCaster)
6828 return;
6829
6830 if(!pCaster->isAlive())
6831 return;
6832
6833 if( GetSpellProto()->Effect[GetEffIndex()] == SPELL_EFFECT_PERSISTENT_AREA_AURA &&
6834 pCaster->SpellHitResult(m_target, GetSpellProto(), false) != SPELL_MISS_NONE)
6835 return;
6836
6837 // Check for immune (not use charges)
6838 if(m_target->IsImmunedToDamage(GetSpellSchoolMask(GetSpellProto())))
6839 return;
6840
6841 // ignore non positive values (can be result apply spellmods to aura damage
6842 uint32 pdamage = m_modifier.m_amount > 0 ? m_modifier.m_amount : 0;
6843
6844 // Special case: draining x% of mana (up to a maximum of 2*x% of the caster's maximum mana)
6845 // It's mana percent cost spells, m_modifier.m_amount is percent drain from target
6846 if (m_spellProto->ManaCostPercentage)
6847 {
6848 // max value
6849 uint32 maxmana = pCaster->GetMaxPower(power) * pdamage * 2 / 100;
6850 pdamage = m_target->GetMaxPower(power) * pdamage / 100;
6851 if(pdamage > maxmana)
6852 pdamage = maxmana;
6853 }
6854
6855 sLog.outDetail("PeriodicTick: %u (TypeId: %u) power leech of %u (TypeId: %u) for %u dmg inflicted by %u",
6856 GUID_LOPART(GetCasterGUID()), GuidHigh2TypeId(GUID_HIPART(GetCasterGUID())), m_target->GetGUIDLow(), m_target->GetTypeId(), pdamage, GetId());
6857
6858 int32 drain_amount = m_target->GetPower(power) > pdamage ? pdamage : m_target->GetPower(power);
6859
6860 // resilience reduce mana draining effect at spell crit damage reduction (added in 2.4)
6861 if (power == POWER_MANA)
6862 drain_amount -= m_target->GetSpellCritDamageReduction(drain_amount);
6863
6864 m_target->ModifyPower(power, -drain_amount);
6865
6866 float gain_multiplier = 0;
6867
6868 if(pCaster->GetMaxPower(power) > 0)
6869 {
6870 gain_multiplier = GetSpellProto()->EffectMultipleValue[GetEffIndex()];
6871
6872 if(Player *modOwner = pCaster->GetSpellModOwner())
6873 modOwner->ApplySpellMod(GetId(), SPELLMOD_MULTIPLE_VALUE, gain_multiplier);
6874 }
6875
6876 SpellPeriodicAuraLogInfo pInfo(this, drain_amount, 0, 0, 0, gain_multiplier);
6877 m_target->SendPeriodicAuraLog(&pInfo);
6878
6879 int32 gain_amount = int32(drain_amount * gain_multiplier);
6880
6881 if(gain_amount)
6882 {
6883 int32 gain = pCaster->ModifyPower(power, gain_amount);
6884 m_target->AddThreat(pCaster, float(gain) * 0.5f, pInfo.critical, GetSpellSchoolMask(GetSpellProto()), GetSpellProto());
6885 }
6886 break;
6887 }
6888 case SPELL_AURA_PERIODIC_ENERGIZE:
6889 {
6890 // ignore non positive values (can be result apply spellmods to aura damage
6891 uint32 pdamage = m_modifier.m_amount > 0 ? m_modifier.m_amount : 0;
6892
6893 sLog.outDetail("PeriodicTick: %u (TypeId: %u) energize %u (TypeId: %u) for %u dmg inflicted by %u",
6894 GUID_LOPART(GetCasterGUID()), GuidHigh2TypeId(GUID_HIPART(GetCasterGUID())), m_target->GetGUIDLow(), m_target->GetTypeId(), pdamage, GetId());
6895
6896 if(m_modifier.m_miscvalue < 0 || m_modifier.m_miscvalue >= MAX_POWERS)
6897 break;
6898
6899 Powers power = Powers(m_modifier.m_miscvalue);
6900
6901 if(m_target->GetMaxPower(power) == 0)
6902 break;
6903
6904 SpellPeriodicAuraLogInfo pInfo(this, pdamage, 0, 0, 0, 0.0f);
6905 m_target->SendPeriodicAuraLog(&pInfo);
6906
6907 int32 gain = m_target->ModifyPower(power,pdamage);
6908
6909 if(Unit* pCaster = GetCaster())
6910 m_target->getHostileRefManager().threatAssist(pCaster, float(gain) * 0.5f, GetSpellProto());
6911 break;
6912 }
6913 case SPELL_AURA_OBS_MOD_MANA:
6914 {
6915 // ignore non positive values (can be result apply spellmods to aura damage
6916 uint32 amount = m_modifier.m_amount > 0 ? m_modifier.m_amount : 0;
6917
6918 uint32 pdamage = uint32(m_target->GetMaxPower(POWER_MANA) * amount / 100);
6919
6920 sLog.outDetail("PeriodicTick: %u (TypeId: %u) energize %u (TypeId: %u) for %u mana inflicted by %u",
6921 GUID_LOPART(GetCasterGUID()), GuidHigh2TypeId(GUID_HIPART(GetCasterGUID())), m_target->GetGUIDLow(), m_target->GetTypeId(), pdamage, GetId());
6922
6923 if(m_target->GetMaxPower(POWER_MANA) == 0)
6924 break;
6925
6926 SpellPeriodicAuraLogInfo pInfo(this, pdamage, 0, 0, 0, 0.0f);
6927 m_target->SendPeriodicAuraLog(&pInfo);
6928
6929 int32 gain = m_target->ModifyPower(POWER_MANA, pdamage);
6930
6931 if(Unit* pCaster = GetCaster())
6932 m_target->getHostileRefManager().threatAssist(pCaster, float(gain) * 0.5f, GetSpellProto());
6933 break;
6934 }
6935 case SPELL_AURA_POWER_BURN_MANA:
6936 {
6937 Unit *pCaster = GetCaster();
6938 if(!pCaster)
6939 return;
6940
6941 // Check for immune (not use charges)
6942 if(m_target->IsImmunedToDamage(GetSpellSchoolMask(GetSpellProto())))
6943 return;
6944
6945 int32 pdamage = m_modifier.m_amount > 0 ? m_modifier.m_amount : 0;
6946
6947 Powers powerType = Powers(m_modifier.m_miscvalue);
6948
6949 if(!m_target->isAlive() || m_target->getPowerType() != powerType)
6950 return;
6951
6952 // resilience reduce mana draining effect at spell crit damage reduction (added in 2.4)
6953 if (powerType == POWER_MANA)
6954 pdamage -= m_target->GetSpellCritDamageReduction(pdamage);
6955
6956 uint32 gain = uint32(-m_target->ModifyPower(powerType, -pdamage));
6957
6958 gain = uint32(gain * GetSpellProto()->EffectMultipleValue[GetEffIndex()]);
6959
6960 SpellEntry const* spellProto = GetSpellProto();
6961 // maybe has to be sent different to client, but not by SMSG_PERIODICAURALOG
6962 SpellNonMeleeDamage damageInfo(pCaster, m_target, spellProto->Id, spellProto->SchoolMask);
6963 pCaster->CalculateSpellDamage(&damageInfo, gain, spellProto);
6964
6965 pCaster->DealDamageMods(damageInfo.target, damageInfo.damage, &damageInfo.absorb);
6966
6967 pCaster->SendSpellNonMeleeDamageLog(&damageInfo);
6968
6969 // Set trigger flag
6970 uint32 procAttacker = PROC_FLAG_ON_DO_PERIODIC; // | PROC_FLAG_SUCCESSFUL_HARMFUL_SPELL_HIT;
6971 uint32 procVictim = PROC_FLAG_ON_TAKE_PERIODIC;// | PROC_FLAG_TAKEN_HARMFUL_SPELL_HIT;
6972 uint32 procEx = createProcExtendMask(&damageInfo, SPELL_MISS_NONE);
6973 if (damageInfo.damage)
6974 procVictim|=PROC_FLAG_TAKEN_ANY_DAMAGE;
6975
6976 pCaster->ProcDamageAndSpell(damageInfo.target, procAttacker, procVictim, procEx, damageInfo.damage, BASE_ATTACK, spellProto);
6977
6978 pCaster->DealSpellDamage(&damageInfo, true);
6979 break;
6980 }
6981 case SPELL_AURA_MOD_REGEN:
6982 {
6983 int32 gain = m_target->ModifyHealth(m_modifier.m_amount);
6984 if (Unit *caster = GetCaster())
6985 m_target->getHostileRefManager().threatAssist(caster, float(gain) * 0.5f, GetSpellProto());
6986 break;
6987 }
6988 case SPELL_AURA_MOD_POWER_REGEN:
6989 {
6990 Powers pt = m_target->getPowerType();
6991 if(int32(pt) != m_modifier.m_miscvalue)
6992 return;
6993
6994 if ( GetSpellProto()->AuraInterruptFlags & AURA_INTERRUPT_FLAG_NOT_SEATED )
6995 {
6996 // eating anim
6997 m_target->HandleEmoteCommand(EMOTE_ONESHOT_EAT);
6998 }
6999 else if( GetId() == 20577 )
7000 {
7001 // cannibalize anim
7002 m_target->HandleEmoteCommand(EMOTE_STATE_CANNIBALIZE);
7003 }
7004
7005 // Anger Management
7006 // amount = 1+ 16 = 17 = 3,4*5 = 10,2*5/3
7007 // so 17 is rounded amount for 5 sec tick grow ~ 1 range grow in 3 sec
7008 if(pt == POWER_RAGE)
7009 m_target->ModifyPower(pt, m_modifier.m_amount * 3 / 5);
7010 break;
7011 }
7012 // Here tick dummy auras
7013 case SPELL_AURA_DUMMY: // some spells have dummy aura
7014 case SPELL_AURA_PERIODIC_DUMMY:
7015 {
7016 PeriodicDummyTick();
7017 break;
7018 }
7019 case SPELL_AURA_PERIODIC_TRIGGER_SPELL:
7020 {
7021 TriggerSpell();
7022 break;
7023 }
7024 case SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE:
7025 {
7026 TriggerSpellWithValue();
7027 break;
7028 }
7029 default:
7030 break;
7031 }
7032 }
7033
7034 void Aura::PeriodicDummyTick()
7035 {
7036 SpellEntry const* spell = GetSpellProto();
7037 switch (spell->SpellFamilyName)
7038 {
7039 case SPELLFAMILY_GENERIC:
7040 switch (spell->Id)
7041 {
7042 // Drink
7043 case 430:
7044 case 431:
7045 case 432:
7046 case 1133:
7047 case 1135:
7048 case 1137:
7049 case 10250:
7050 case 22734:
7051 case 27089:
7052 case 34291:
7053 case 43182:
7054 case 43183:
7055 case 43706:
7056 case 46755:
7057 case 49472: // Drink Coffee
7058 case 57073:
7059 case 61830:
7060 {
7061 if (m_target->GetTypeId() != TYPEID_PLAYER)
7062 return;
7063 // Search SPELL_AURA_MOD_POWER_REGEN aura for this spell and add bonus
7064 Unit::AuraList const& aura = m_target->GetAurasByType(SPELL_AURA_MOD_POWER_REGEN);
7065 for(Unit::AuraList::const_iterator i = aura.begin(); i != aura.end(); ++i)
7066 {
7067 if ((*i)->GetId() == GetId())
7068 {
7069 (*i)->GetModifier()->m_amount = m_modifier.m_amount;
7070 ((Player*)m_target)->UpdateManaRegen();
7071 // Disable continue
7072 m_isPeriodic = false;
7073 return;
7074 }
7075 }
7076 return;
7077 }
7078 // Forsaken Skills
7079 case 7054:
7080 {
7081 // Possibly need cast one of them (but
7082 // 7038 Forsaken Skill: Swords
7083 // 7039 Forsaken Skill: Axes
7084 // 7040 Forsaken Skill: Daggers
7085 // 7041 Forsaken Skill: Maces
7086 // 7042 Forsaken Skill: Staves
7087 // 7043 Forsaken Skill: Bows
7088 // 7044 Forsaken Skill: Guns
7089 // 7045 Forsaken Skill: 2H Axes
7090 // 7046 Forsaken Skill: 2H Maces
7091 // 7047 Forsaken Skill: 2H Swords
7092 // 7048 Forsaken Skill: Defense
7093 // 7049 Forsaken Skill: Fire
7094 // 7050 Forsaken Skill: Frost
7095 // 7051 Forsaken Skill: Holy
7096 // 7053 Forsaken Skill: Shadow
7097 return;
7098 }
7099 case 7057: // Haunting Spirits
7100 if (roll_chance_i(33))
7101 m_target->CastSpell(m_target,m_modifier.m_amount,true,NULL,this);
7102 return;
7103 // // Panda
7104 // case 19230: break;
7105 // // Gossip NPC Periodic - Talk
7106 // case 33208: break;
7107 // // Gossip NPC Periodic - Despawn
7108 // case 33209: break;
7109 // // Steal Weapon
7110 // case 36207: break;
7111 // // Simon Game START timer, (DND)
7112 // case 39993: break;
7113 // // Knockdown Fel Cannon: break; The Aggro Burst
7114 // case 40119: break;
7115 // // Old Mount Spell
7116 // case 40154: break;
7117 // // Magnetic Pull
7118 // case 40581: break;
7119 // // Ethereal Ring: break; The Bolt Burst
7120 // case 40801: break;
7121 // // Crystal Prison
7122 // case 40846: break;
7123 // // Copy Weapon
7124 // case 41054: break;
7125 // // Dementia
7126 // case 41404: break;
7127 // // Ethereal Ring Visual, Lightning Aura
7128 // case 41477: break;
7129 // // Ethereal Ring Visual, Lightning Aura (Fork)
7130 // case 41525: break;
7131 // // Ethereal Ring Visual, Lightning Jumper Aura
7132 // case 41567: break;
7133 // // No Man's Land
7134 // case 41955: break;
7135 // // Headless Horseman - Fire
7136 // case 42074: break;
7137 // // Headless Horseman - Visual - Large Fire
7138 // case 42075: break;
7139 // // Headless Horseman - Start Fire, Periodic Aura
7140 // case 42140: break;
7141 // // Ram Speed Boost
7142 // case 42152: break;
7143 // // Headless Horseman - Fires Out Victory Aura
7144 // case 42235: break;
7145 // // Pumpkin Life Cycle
7146 // case 42280: break;
7147 // // Brewfest Request Chick Chuck Mug Aura
7148 // case 42537: break;
7149 // // Squashling
7150 // case 42596: break;
7151 // // Headless Horseman Climax, Head: Periodic
7152 // case 42603: break;
7153 // // Fire Bomb
7154 // case 42621: break;
7155 // // Headless Horseman - Conflagrate, Periodic Aura
7156 // case 42637: break;
7157 // // Headless Horseman - Create Pumpkin Treats Aura
7158 // case 42774: break;
7159 // // Headless Horseman Climax - Summoning Rhyme Aura
7160 // case 42879: break;
7161 // // Tricky Treat
7162 // case 42919: break;
7163 // // Giddyup!
7164 // case 42924: break;
7165 // // Ram - Trot
7166 // case 42992: break;
7167 // // Ram - Canter
7168 // case 42993: break;
7169 // // Ram - Gallop
7170 // case 42994: break;
7171 // // Ram Level - Neutral
7172 // case 43310: break;
7173 // // Headless Horseman - Maniacal Laugh, Maniacal, Delayed 17
7174 // case 43884: break;
7175 // // Wretched!
7176 // case 43963: break;
7177 // // Headless Horseman - Maniacal Laugh, Maniacal, other, Delayed 17
7178 // case 44000: break;
7179 // // Energy Feedback
7180 // case 44328: break;
7181 // // Romantic Picnic
7182 // case 45102: break;
7183 // // Romantic Picnic
7184 // case 45123: break;
7185 // // Looking for Love
7186 // case 45124: break;
7187 // // Kite - Lightning Strike Kite Aura
7188 // case 45197: break;
7189 // // Rocket Chicken
7190 // case 45202: break;
7191 // // Copy Offhand Weapon
7192 // case 45205: break;
7193 // // Upper Deck - Kite - Lightning Periodic Aura
7194 // case 45207: break;
7195 // // Kite -Sky Lightning Strike Kite Aura
7196 // case 45251: break;
7197 // // Ribbon Pole Dancer Check Aura
7198 // case 45390: break;
7199 // // Holiday - Midsummer, Ribbon Pole Periodic Visual
7200 // case 45406: break;
7201 // // Parachute
7202 // case 45472: break;
7203 // // Alliance Flag, Extra Damage Debuff
7204 // case 45898: break;
7205 // // Horde Flag, Extra Damage Debuff
7206 // case 45899: break;
7207 // // Ahune - Summoning Rhyme Aura
7208 // case 45926: break;
7209 // // Ahune - Slippery Floor
7210 // case 45945: break;
7211 // // Ahune's Shield
7212 // case 45954: break;
7213 // // Nether Vapor Lightning
7214 // case 45960: break;
7215 // // Darkness
7216 // case 45996: break;
7217 // // Summon Blood Elves Periodic
7218 // case 46041: break;
7219 // // Transform Visual Missile Periodic
7220 // case 46205: break;
7221 // // Find Opening Beam End
7222 // case 46333: break;
7223 // // Ice Spear Control Aura
7224 // case 46371: break;
7225 // // Hailstone Chill
7226 // case 46458: break;
7227 // // Hailstone Chill, Internal
7228 // case 46465: break;
7229 // // Chill, Internal Shifter
7230 // case 46549: break;
7231 // // Summon Ice Spear Knockback Delayer
7232 // case 46878: break;
7233 // // Burninate Effect
7234 // case 47214: break;
7235 // // Fizzcrank Practice Parachute
7236 // case 47228: break;
7237 // // Send Mug Control Aura
7238 // case 47369: break;
7239 // // Direbrew's Disarm (precast)
7240 // case 47407: break;
7241 // // Mole Machine Port Schedule
7242 // case 47489: break;
7243 // case 47941: break; // Crystal Spike
7244 // case 48200: break; // Healer Aura
7245 // case 48630: break; // Summon Gauntlet Mobs Periodic
7246 // case 49313: break; // Proximity Mine Area Aura
7247 // // Mole Machine Portal Schedule
7248 // case 49466: break;
7249 // case 49555: break; // Corpse Explode
7250 // case 49592: break; // Temporal Rift
7251 // case 49957: break; // Cutting Laser
7252 // case 50085: break; // Slow Fall
7253 // // Listening to Music
7254 // case 50493: break;
7255 // // Love Rocket Barrage
7256 // case 50530: break;
7257 // Exist more after, need add later
7258 default:
7259 break;
7260 }
7261 // Prey on the Weak
7262 if (spell->SpellIconID == 2983)
7263 {
7264 Unit *target=m_target->getVictim();
7265 if (target && (m_target->GetHealth() * 100 / m_target->GetMaxHealth() > target->GetHealth() * 100 / target->GetMaxHealth()))
7266 {
7267 if(!m_target->HasAura(58670))
7268 {
7269 int32 basepoints = GetBasePoints();
7270 m_target->CastCustomSpell(m_target, 58670, &basepoints, 0, 0, true);
7271 }
7272 }
7273 else
7274 m_target->RemoveAurasDueToSpell(58670);
7275 }
7276 break;
7277 case SPELLFAMILY_MAGE:
7278 {
7279 // Mirror Image
7280 // if (spell->Id == 55342)
7281 // return;
7282 break;
7283 }
7284 case SPELLFAMILY_DRUID:
7285 {
7286 switch (spell->Id)
7287 {
7288 // Frenzied Regeneration
7289 case 22842:
7290 {
7291 // Converts up to 10 rage per second into health for $d. Each point of rage is converted into ${$m2/10}.1% of max health.
7292 // Should be manauser
7293 if (m_target->getPowerType() != POWER_RAGE)
7294 return;
7295 uint32 rage = m_target->GetPower(POWER_RAGE);
7296 // Nothing todo
7297 if (rage == 0)
7298 return;
7299 int32 mod = (rage < 100) ? rage : 100;
7300 int32 points = m_target->CalculateSpellDamage(spell, 1, spell->EffectBasePoints[1], m_target);
7301 int32 regen = m_target->GetMaxHealth() * (mod * points / 10) / 1000;
7302 m_target->CastCustomSpell(m_target, 22845, &regen, NULL, NULL, true, NULL, this);
7303 m_target->SetPower(POWER_RAGE, rage-mod);
7304 return;
7305 }
7306 // Force of Nature
7307 case 33831:
7308 return;
7309 default:
7310 break;
7311 }
7312 break;
7313 }
7314 case SPELLFAMILY_ROGUE:
7315 {
7316 switch (spell->Id)
7317 {
7318 // Killing Spree
7319 case 51690:
7320 {
7321 if (m_target->hasUnitState(UNIT_STAT_STUNNED) || m_target->HasAuraType(SPELL_AURA_MOD_FEAR))
7322 return;
7323
7324 std::list<Unit*> targets;
7325 {
7326 // eff_radius ==0
7327 float radius = GetSpellMaxRange(sSpellRangeStore.LookupEntry(spell->rangeIndex));
7328
7329 CellPair p(MaNGOS::ComputeCellPair(m_target->GetPositionX(),m_target->GetPositionY()));
7330 Cell cell(p);
7331 cell.data.Part.reserved = ALL_DISTRICT;
7332
7333 MaNGOS::AnyUnfriendlyVisibleUnitInObjectRangeCheck u_check(m_target, m_target, radius);
7334 MaNGOS::UnitListSearcher<MaNGOS::AnyUnfriendlyVisibleUnitInObjectRangeCheck> checker(m_target, targets, u_check);
7335
7336 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyUnfriendlyVisibleUnitInObjectRangeCheck>, GridTypeMapContainer > grid_object_checker(checker);
7337 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyUnfriendlyVisibleUnitInObjectRangeCheck>, WorldTypeMapContainer > world_object_checker(checker);
7338
7339 CellLock<GridReadGuard> cell_lock(cell, p);
7340
7341 cell_lock->Visit(cell_lock, grid_object_checker, *m_target->GetMap(), *m_target, radius);
7342 cell_lock->Visit(cell_lock, world_object_checker, *m_target->GetMap(), *m_target, radius);
7343 }
7344
7345 if(targets.empty())
7346 return;
7347
7348 std::list<Unit*>::const_iterator itr = targets.begin();
7349 std::advance(itr, rand()%targets.size());
7350 Unit* target = *itr;
7351
7352 m_target->CastSpell(target, 57840, true);
7353 m_target->CastSpell(target, 57841, true);
7354 return;
7355 }
7356 default:
7357 break;
7358 }
7359 break;
7360 }
7361 case SPELLFAMILY_HUNTER:
7362 {
7363 // Explosive Shot
7364 if (spell->SpellFamilyFlags & UI64LIT(0x8000000000000000))
7365 {
7366 m_target->CastCustomSpell(m_target, 53352, &m_modifier.m_amount, 0, 0, true, 0, this, GetCasterGUID());
7367 return;
7368 }
7369 switch (spell->Id)
7370 {
7371 // Harpooner's Mark
7372 // case 40084:
7373 // return;
7374 // Feeding Frenzy Rank 1
7375 case 53511:
7376 if ( m_target->GetHealth() * 100 < m_target->GetMaxHealth() * 35 )
7377 m_target->CastSpell(m_target, 60096, true, 0, this);
7378 return;
7379 // Feeding Frenzy Rank 2
7380 case 53512:
7381 if ( m_target->GetHealth() * 100 < m_target->GetMaxHealth() * 35 )
7382 m_target->CastSpell(m_target, 60097, true, 0, this);
7383 return;
7384 default:
7385 break;
7386 }
7387 break;
7388 }
7389 case SPELLFAMILY_SHAMAN:
7390 {
7391 // Astral Shift
7392 if (spell->Id == 52179)
7393 {
7394 // Periodic need for remove visual on stun/fear/silence lost
7395 if (!(m_target->GetUInt32Value(UNIT_FIELD_FLAGS)&(UNIT_FLAG_STUNNED|UNIT_FLAG_FLEEING|UNIT_FLAG_SILENCED)))
7396 m_target->RemoveAurasDueToSpell(52179);
7397 return;
7398 }
7399 break;
7400 }
7401 case SPELLFAMILY_DEATHKNIGHT:
7402 {
7403 // Death and Decay
7404 if (spell->SpellFamilyFlags & UI64LIT(0x0000000000000020))
7405 {
7406 if (Unit *caster = GetCaster())
7407 caster->CastCustomSpell(m_target, 52212, &m_modifier.m_amount, NULL, NULL, true, NULL, this);
7408 return;
7409 }
7410 // Raise Dead
7411 // if (spell->SpellFamilyFlags & UI64LIT(0x0000000000001000))
7412 // return;
7413 // Chains of Ice
7414 if (spell->SpellFamilyFlags & UI64LIT(0x0000400000000000))
7415 {
7416 // Get 0 effect aura
7417 Aura *slow = m_target->GetAura(GetId(), 0);
7418 if (slow)
7419 {
7420 slow->ApplyModifier(false, true);
7421 Modifier *mod = slow->GetModifier();
7422 mod->m_amount+= m_modifier.m_amount;
7423 if (mod->m_amount > 0) mod->m_amount = 0;
7424 slow->ApplyModifier(true, true);
7425 }
7426 return;
7427 }
7428 // Summon Gargoyle
7429 // if (spell->SpellFamilyFlags & UI64LIT(0x0000008000000000))
7430 // return;
7431 // Death Rune Mastery
7432 // if (spell->SpellFamilyFlags & UI64LIT(0x0000000000004000))
7433 // return;
7434 // Bladed Armor
7435 if (spell->SpellIconID == 2653)
7436 {
7437 // Increases your attack power by $s1 for every $s2 armor value you have.
7438 // Calculate AP bonus (from 1 efect of this spell)
7439 int32 apBonus = m_modifier.m_amount * m_target->GetArmor() / m_target->CalculateSpellDamage(spell, 1, spell->EffectBasePoints[1], m_target);
7440 m_target->CastCustomSpell(m_target, 61217, &apBonus, &apBonus, NULL, true, NULL, this);
7441 return;
7442 }
7443 // Reaping
7444 // if (spell->SpellIconID == 22)
7445 // return;
7446 // Blood of the North
7447 // if (spell->SpellIconID == 30412)
7448 // return;
7449 break;
7450 }
7451 default:
7452 break;
7453 }
7454 }
7455
7456 void Aura::HandlePreventFleeing(bool apply, bool Real)
7457 {
7458 if(!Real)
7459 return;
7460
7461 Unit::AuraList const& fearAuras = m_target->GetAurasByType(SPELL_AURA_MOD_FEAR);
7462 if( !fearAuras.empty() )
7463 {
7464 if (apply)
7465 m_target->SetFeared(false, fearAuras.front()->GetCasterGUID());
7466 else
7467 m_target->SetFeared(true);
7468 }
7469 }
7470
7471 void Aura::HandleManaShield(bool apply, bool Real)
7472 {
7473 if(!Real)
7474 return;
7475
7476 // prevent double apply bonuses
7477 if(apply && (m_target->GetTypeId()!=TYPEID_PLAYER || !((Player*)m_target)->GetSession()->PlayerLoading()))
7478 {
7479 if(Unit* caster = GetCaster())
7480 {
7481 float DoneActualBenefit = 0.0f;
7482 switch(m_spellProto->SpellFamilyName)
7483 {
7484 case SPELLFAMILY_MAGE:
7485 if(m_spellProto->SpellFamilyFlags & UI64LIT(0x0000000000008000))
7486 {
7487 // Mana Shield
7488 // +50% from +spd bonus
7489 DoneActualBenefit = caster->SpellBaseDamageBonus(GetSpellSchoolMask(m_spellProto)) * 0.5f;
7490 break;
7491 }
7492 break;
7493 default:
7494 break;
7495 }
7496
7497 DoneActualBenefit *= caster->CalculateLevelPenalty(GetSpellProto());
7498
7499 m_modifier.m_amount += (int32)DoneActualBenefit;
7500 }
7501 }
7502 }
7503
7504 void Aura::HandleArenaPreparation(bool apply, bool Real)
7505 {
7506 if(!Real)
7507 return;
7508
7509 if(apply)
7510 m_target->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PREPARATION);
7511 else
7512 m_target->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PREPARATION);
7513 }
7514
7515 /**
7516 * Such auras are applied from a caster(=player) to a vehicle.
7517 * This has been verified using spell #49256
7518 */
7519 void Aura::HandleAuraControlVehicle(bool apply, bool Real)
7520 {
7521 if(!Real)
7522 return;
7523
7524 Unit *player = GetCaster();
7525 Vehicle *vehicle = dynamic_cast<Vehicle*>(m_target);
7526 if(!player || player->GetTypeId() != TYPEID_PLAYER || !vehicle)
7527 return;
7528
7529 if (apply)
7530 {
7531 if(Pet *pet = player->GetPet())
7532 pet->Remove(PET_SAVE_AS_CURRENT);
7533 ((Player*)player)->EnterVehicle(vehicle);
7534 }
7535 else
7536 {
7537 SpellEntry const *spell = GetSpellProto();
7538
7539 // some SPELL_AURA_CONTROL_VEHICLE auras have a dummy effect on the player - remove them
7540 player->RemoveAurasDueToSpell(spell->Id);
7541
7542 ((Player*)player)->ExitVehicle(vehicle);
7543 }
7544 }
7545
7546 void Aura::HandleAuraConvertRune(bool apply, bool Real)
7547 {
7548 if(!Real)
7549 return;
7550
7551 if(m_target->GetTypeId() != TYPEID_PLAYER)
7552 return;
7553
7554 Player *plr = (Player*)m_target;
7555
7556 if(plr->getClass() != CLASS_DEATH_KNIGHT)
7557 return;
7558
7559 // how to determine what rune need to be converted?
7560 for(uint32 i = 0; i < MAX_RUNES; ++i)
7561 {
7562 if(apply)
7563 {
7564 if(!plr->GetRuneCooldown(i))
7565 {
7566 plr->ConvertRune(i, RuneType(GetSpellProto()->EffectMiscValueB[m_effIndex]));
7567 break;
7568 }
7569 }
7570 else
7571 {
7572 if(plr->GetCurrentRune(i) == RuneType(GetSpellProto()->EffectMiscValueB[m_effIndex]))
7573 {
7574 plr->ConvertRune(i, plr->GetBaseRune(i));
7575 break;
7576 }
7577 }
7578 }
7579 }
7580
7581 void Aura::HandlePhase(bool apply, bool Real)
7582 {
7583 if(!Real)
7584 return;
7585
7586 // always non stackable
7587 if(apply)
7588 {
7589 Unit::AuraList const& phases = m_target->GetAurasByType(SPELL_AURA_PHASE);
7590 if(!phases.empty())
7591 m_target->RemoveAurasDueToSpell(phases.front()->GetId(), this);
7592 }
7593
7594 // no-phase is also phase state so same code for apply and remove
7595
7596 // phase auras normally not expected at BG but anyway better check
7597 if(m_target->GetTypeId() == TYPEID_PLAYER)
7598 {
7599 // drop flag at invisible in bg
7600 if(((Player*)m_target)->InBattleGround())
7601 if(BattleGround *bg = ((Player*)m_target)->GetBattleGround())
7602 bg->EventPlayerDroppedFlag((Player*)m_target);
7603
7604 // GM-mode have mask 0xFFFFFFFF
7605 if(!((Player*)m_target)->isGameMaster())
7606 m_target->SetPhaseMask(apply ? GetMiscValue() : PHASEMASK_NORMAL, false);
7607
7608 ((Player*)m_target)->GetSession()->SendSetPhaseShift(apply ? GetMiscValue() : PHASEMASK_NORMAL);
7609
7610 if(GetEffIndex()==0)
7611 {
7612 SpellAreaForAreaMapBounds saBounds = sSpellMgr.GetSpellAreaForAuraMapBounds(GetId());
7613 if(saBounds.first != saBounds.second)
7614 {
7615 uint32 zone, area;
7616 m_target->GetZoneAndAreaId(zone, area);
7617
7618 for(SpellAreaForAreaMap::const_iterator itr = saBounds.first; itr != saBounds.second; ++itr)
7619 {
7620 // some auras remove at aura remove
7621 if(!itr->second->IsFitToRequirements((Player*)m_target, zone, area))
7622 m_target->RemoveAurasDueToSpell(itr->second->spellId);
7623 // some auras applied at aura apply
7624 else if(itr->second->autocast)
7625 {
7626 if( !m_target->HasAura(itr->second->spellId, 0) )
7627 m_target->CastSpell(m_target, itr->second->spellId, true);
7628 }
7629 }
7630 }
7631 }
7632 }
7633 else
7634 m_target->SetPhaseMask(apply ? GetMiscValue() : PHASEMASK_NORMAL, false);
7635
7636 // need triggering visibility update base at phase update of not GM invisible (other GMs anyway see in any phases)
7637 if(m_target->GetVisibility() != VISIBILITY_OFF)
7638 m_target->SetVisibility(m_target->GetVisibility());
7639 }
7640
7641 void Aura::UnregisterSingleCastAura()
7642 {
7643 if (IsSingleTarget())
7644 {
7645 if(Unit* caster = GetCaster())
7646 {
7647 caster->GetSingleCastAuras().remove(this);
7648 }
7649 else
7650 {
7651 sLog.outError("Couldn't find the caster of the single target aura (SpellId %u), may crash later!", GetId());
7652 assert(false);
7653 }
7654 m_isSingleTargetAura = false;
7655 }
7656 }
7657
7658 void Aura::HandleAuraSafeFall( bool Apply, bool Real )
7659 {
7660 // implemented in WorldSession::HandleMovementOpcodes
7661
7662 // only special case
7663 if(Apply && Real && GetId() == 32474 && m_target->GetTypeId() == TYPEID_PLAYER)
7664 ((Player*)m_target)->ActivateTaxiPathTo(506, GetId());
7665 }
7666
7667 bool Aura::IsCritFromAbilityAura(Unit* caster, uint32& damage)
7668 {
7669 Unit::AuraList const& auras = caster->GetAurasByType(SPELL_AURA_ABILITY_PERIODIC_CRIT);
7670 for(Unit::AuraList::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
7671 {
7672 if (!(*itr)->isAffectedOnSpell(m_spellProto))
7673 continue;
7674 if (!caster->isSpellCrit(m_target, m_spellProto, GetSpellSchoolMask(m_spellProto)))
7675 break;
7676
7677 damage = caster->SpellCriticalDamageBonus(m_spellProto, damage, m_target);
7678 return true;
7679 }
7680 return false;
7681 }
7682
7683 void Aura::HandleModTargetArmorPct(bool apply, bool Real)
7684 {
7685 if(m_target->GetTypeId() != TYPEID_PLAYER)
7686 return;
7687
7688 ((Player*)m_target)->UpdateArmorPenetration();
7689 }
7690
7691 void Aura::HandleAuraModAllCritChance(bool apply, bool Real)
7692 {
7693 // spells required only Real aura add/remove
7694 if(!Real)
7695 return;
7696
7697 if(m_target->GetTypeId() != TYPEID_PLAYER)
7698 return;
7699
7700 ((Player*)m_target)->HandleBaseModValue(CRIT_PERCENTAGE, FLAT_MOD, float (m_modifier.m_amount), apply);
7701 ((Player*)m_target)->HandleBaseModValue(OFFHAND_CRIT_PERCENTAGE, FLAT_MOD, float (m_modifier.m_amount), apply);
7702 ((Player*)m_target)->HandleBaseModValue(RANGED_CRIT_PERCENTAGE, FLAT_MOD, float (m_modifier.m_amount), apply);
7703
7704 // included in Player::UpdateSpellCritChance calculation
7705 ((Player*)m_target)->UpdateAllSpellCritChances();
7706 }
7707
7708 void Aura::HandleAllowOnlyAbility(bool apply, bool Real)
7709 {
7710 if(!Real)
7711 return;
7712
7713 if(apply)
7714 {
7715 m_target->setAttackTimer(BASE_ATTACK,m_duration);
7716 m_target->setAttackTimer(RANGED_ATTACK,m_duration);
7717 m_target->setAttackTimer(OFF_ATTACK,m_duration);
7718 }
7719 else
7720 {
7721 m_target->resetAttackTimer(BASE_ATTACK);
7722 m_target->resetAttackTimer(RANGED_ATTACK);
7723 m_target->resetAttackTimer(OFF_ATTACK);
7724 }
7725
7726 m_target->UpdateDamagePhysical(BASE_ATTACK);
7727 m_target->UpdateDamagePhysical(RANGED_ATTACK);
7728 m_target->UpdateDamagePhysical(OFF_ATTACK);
7729 }
MaNGOS is a free, Open Source implementation of a game server compatible with the original World of Warcraft client.