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