?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[2987] Applied MaNGOS coding style (see trunk/bcpp.cfg).
[mangos-git.git] / src / game / SpellAuras.cpp
blob00cddf17ea2fe79f641f3bc24afae57367865158
1 /*
2 * Copyright (C) 2005,2006 MaNGOS <http://www.mangosproject.org/>
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 "Player.h"
29 #include "Unit.h"
30 #include "Spell.h"
31 #include "SpellAuras.h"
32 #include "EventSystem.h"
33 #include "DynamicObject.h"
34 #include "Group.h"
35 #include "UpdateData.h"
36 #include "MapManager.h"
37 #include "ObjectAccessor.h"
38 #include "RedZoneDistrict.h"
39 #include "CellImpl.h"
40 #include "Policies/SingletonImp.h"
41 #include "Totem.h"
42 #include "Creature.h"
43 #include "ConfusedMovementGenerator.h"
44 #include "Formulas.h"
45
46 pAuraHandler AuraHandler[TOTAL_AURAS]=
47 {
48 &Aura::HandleNULL, //SPELL_AURA_NONE
49 &Aura::HandleBindSight, //SPELL_AURA_BIND_SIGHT
50 &Aura::HandleModPossess, //SPELL_AURA_MOD_POSSESS = 2,
51 &Aura::HandlePeriodicDamage, //SPELL_AURA_PERIODIC_DAMAGE = 3,
52 &Aura::HandleAuraDummy, //SPELL_AURA_DUMMY //missing 4
53 &Aura::HandleModConfuse, //SPELL_AURA_MOD_CONFUSE = 5,
54 &Aura::HandleModCharm, //SPELL_AURA_MOD_CHARM = 6,
55 &Aura::HandleModFear, //SPELL_AURA_MOD_FEAR = 7,
56 &Aura::HandlePeriodicHeal, //SPELL_AURA_PERIODIC_HEAL = 8,
57 &Aura::HandleModAttackSpeed, //SPELL_AURA_MOD_ATTACKSPEED = 9,
58 &Aura::HandleModThreat, //SPELL_AURA_MOD_THREAT = 10,
59 &Aura::HandleNULL, //SPELL_AURA_MOD_TAUNT = 11,
60 &Aura::HandleAuraModStun, //SPELL_AURA_MOD_STUN = 12,
61 &Aura::HandleModDamageDone, //SPELL_AURA_MOD_DAMAGE_DONE = 13,
62 &Aura::HandleModDamageTaken, //SPELL_AURA_MOD_DAMAGE_TAKEN = 14,
63 &Aura::HandleAuraDamageShield, //SPELL_AURA_DAMAGE_SHIELD = 15,
64 &Aura::HandleModStealth, //SPELL_AURA_MOD_STEALTH = 16,
65 &Aura::HandleModDetect, //SPELL_AURA_MOD_DETECT = 17,
66 &Aura::HandleInvisibility, //SPELL_AURA_MOD_INVISIBILITY = 18,
67 &Aura::HandleInvisibilityDetect, //SPELL_AURA_MOD_INVISIBILITY_DETECTION = 19,
68 &Aura::HandleAuraModTotalHealthPercentRegen, //SPELL_AURA_OBS_MOD_HEALTH = 20
69 &Aura::HandleAuraModTotalManaPercentRegen, //SPELL_AURA_OBS_MOD_MANA = 21
70 &Aura::HandleAuraModResistance, //SPELL_AURA_MOD_RESISTANCE = 22,
71 &Aura::HandlePeriodicTriggerSpell, //SPELL_AURA_PERIODIC_TRIGGER_SPELL = 23,
72 &Aura::HandlePeriodicEnergize, //SPELL_AURA_PERIODIC_ENERGIZE = 24,
73 &Aura::HandleNULL, //SPELL_AURA_MOD_PACIFY = 25,
74 &Aura::HandleAuraModRoot, //SPELL_AURA_MOD_ROOT = 26,
75 &Aura::HandleAuraModSilence, //SPELL_AURA_MOD_SILENCE = 27,
76 &Aura::HandleReflectSpells, //SPELL_AURA_REFLECT_SPELLS = 28,
77 &Aura::HandleAuraModStat, //SPELL_AURA_MOD_STAT = 29,
78 &Aura::HandleAuraModSkill, //SPELL_AURA_MOD_SKILL = 30,
79 &Aura::HandleAuraModIncreaseSpeed, //SPELL_AURA_MOD_INCREASE_SPEED = 31,
80 &Aura::HandleAuraModIncreaseMountedSpeed, //SPELL_AURA_MOD_INCREASE_MOUNTED_SPEED = 32,
81 &Aura::HandleAuraModDecreaseSpeed, //SPELL_AURA_MOD_DECREASE_SPEED = 33,
82 &Aura::HandleAuraModIncreaseHealth, //SPELL_AURA_MOD_INCREASE_HEALTH = 34,
83 &Aura::HandleAuraModIncreaseEnergy, //SPELL_AURA_MOD_INCREASE_ENERGY = 35,
84 &Aura::HandleAuraModShapeshift, //SPELL_AURA_MOD_SHAPESHIFT = 36,
85 &Aura::HandleAuraModEffectImmunity, //SPELL_AURA_EFFECT_IMMUNITY = 37,
86 &Aura::HandleAuraModStateImmunity, //SPELL_AURA_STATE_IMMUNITY = 38,
87 &Aura::HandleAuraModSchoolImmunity, //SPELL_AURA_SCHOOL_IMMUNITY = 39,
88 &Aura::HandleAuraModDmgImmunity, //SPELL_AURA_DAMAGE_IMMUNITY = 40,
89 &Aura::HandleAuraModDispelImmunity, //SPELL_AURA_DISPEL_IMMUNITY = 41,
90 &Aura::HandleAuraProcTriggerSpell, //SPELL_AURA_PROC_TRIGGER_SPELL = 42,
91 &Aura::HandleAuraProcTriggerDamage, //SPELL_AURA_PROC_TRIGGER_DAMAGE = 43,
92 &Aura::HandleAuraTracCreatures, //SPELL_AURA_TRACK_CREATURES = 44,
93 &Aura::HandleAuraTracResources, //SPELL_AURA_TRACK_RESOURCES = 45,
94 &Aura::HandleNULL, //SPELL_AURA_MOD_PARRY_SKILL = 46, obsolete?
95 &Aura::HandleAuraModParryPercent, //SPELL_AURA_MOD_PARRY_PERCENT = 47,
96 &Aura::HandleNULL, //SPELL_AURA_MOD_DODGE_SKILL = 48, obsolete?
97 &Aura::HandleAuraModDodgePercent, //SPELL_AURA_MOD_DODGE_PERCENT = 49,
98 &Aura::HandleNULL, //SPELL_AURA_MOD_BLOCK_SKILL = 50, obsolete?
99 &Aura::HandleAuraModBlockPercent, //SPELL_AURA_MOD_BLOCK_PERCENT = 51,
100 &Aura::HandleAuraModCritPercent, //SPELL_AURA_MOD_CRIT_PERCENT = 52,
101 &Aura::HandlePeriodicLeech, //SPELL_AURA_PERIODIC_LEECH = 53,
102 &Aura::HandleModHitChance, //SPELL_AURA_MOD_HIT_CHANCE = 54,
103 &Aura::HandleModSpellHitChance, //SPELL_AURA_MOD_SPELL_HIT_CHANCE = 55,
104 &Aura::HandleAuraTransform, //SPELL_AURA_TRANSFORM = 56,
105 &Aura::HandleModSpellCritChance, //SPELL_AURA_MOD_SPELL_CRIT_CHANCE = 57,
106 &Aura::HandleAuraModIncreaseSwimSpeed, //SPELL_AURA_MOD_INCREASE_SWIM_SPEED = 58,
107 &Aura::HandleModDamageDoneCreature, //SPELL_AURA_MOD_DAMAGE_DONE_CREATURE = 59,
108 &Aura::HandleNULL, //SPELL_AURA_MOD_PACIFY_SILENCE = 60,
109 &Aura::HandleAuraModScale, //SPELL_AURA_MOD_SCALE = 61,
110 &Aura::HandleNULL, //SPELL_AURA_PERIODIC_HEALTH_FUNNEL = 62,
111 &Aura::HandleNULL, //SPELL_AURA_PERIODIC_MANA_FUNNEL = 63,
112 &Aura::HandlePeriodicManaLeech, //SPELL_AURA_PERIODIC_MANA_LEECH = 64,
113 &Aura::HandleModCastingSpeed, //SPELL_AURA_MOD_CASTING_SPEED = 65,
114 &Aura::HandleNULL, //SPELL_AURA_FEIGN_DEATH = 66,
115 &Aura::HandleNULL, //SPELL_AURA_MOD_DISARM = 67,
116 &Aura::HandleNULL, //SPELL_AURA_MOD_STALKED = 68,
117 &Aura::HandleAuraSchoolAbsorb, //SPELL_AURA_SCHOOL_ABSORB = 69,
118 &Aura::HandleNULL, //SPELL_AURA_EXTRA_ATTACKS = 70,// Useless
119 &Aura::HandleModSpellCritChanceShool, //SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL = 71,
120 &Aura::HandleModPowerCost, //SPELL_AURA_MOD_POWER_COST = 72,
121 &Aura::HandleModPowerCostSchool, //SPELL_AURA_MOD_POWER_COST_SCHOOL = 73,
122 &Aura::HandleReflectSpellsSchool, //SPELL_AURA_REFLECT_SPELLS_SCHOOL = 74,
123 &Aura::HandleNULL, //SPELL_AURA_MOD_LANGUAGE = 75,
124 &Aura::HandleFarSight, //SPELL_AURA_FAR_SIGHT = 76,
125 &Aura::HandleModMechanicImmunity, //SPELL_AURA_MECHANIC_IMMUNITY = 77,
126 &Aura::HandleAuraMounted, //SPELL_AURA_MOUNTED = 78,
127 &Aura::HandleModDamagePercentDone, //SPELL_AURA_MOD_DAMAGE_PERCENT_DONE = 79,
128 &Aura::HandleModPercentStat, //SPELL_AURA_MOD_PERCENT_STAT = 80,
129 &Aura::HandleNULL, //SPELL_AURA_SPLIT_DAMAGE = 81,
130 &Aura::HandleWaterBreathing, //SPELL_AURA_WATER_BREATHING = 82,
131 &Aura::HandleModBaseResistance, //SPELL_AURA_MOD_BASE_RESISTANCE = 83,
132 &Aura::HandleModRegen, //SPELL_AURA_MOD_REGEN = 84,
133 &Aura::HandleModPowerRegen, //SPELL_AURA_MOD_POWER_REGEN = 85,
134 &Aura::HandleChannelDeathItem, //SPELL_AURA_CHANNEL_DEATH_ITEM = 86,
135 &Aura::HandleModDamagePCTTaken, //SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN = 87,
136 &Aura::HandleModPCTRegen, //SPELL_AURA_MOD_HEALTH_REGEN_PERCENT = 88,
137 &Aura::HandlePeriodicDamagePCT, //SPELL_AURA_PERIODIC_DAMAGE_PERCENT = 89,
138 &Aura::HandleNULL, //SPELL_AURA_MOD_RESIST_CHANCE = 90,// Useless
139 &Aura::HandleModDetectRange, //SPELL_AURA_MOD_DETECT_RANGE = 91,
140 &Aura::HandleNULL, //SPELL_AURA_PREVENTS_FLEEING = 92,
141 &Aura::HandleNULL, //SPELL_AURA_MOD_UNATTACKABLE = 93,
142 &Aura::HandleNULL, //SPELL_AURA_INTERRUPT_REGEN = 94,
143 &Aura::HandleNULL, //SPELL_AURA_GHOST = 95,
144 &Aura::HandleNULL, //SPELL_AURA_SPELL_MAGNET = 96,
145 &Aura::HandleAuraManaShield, //SPELL_AURA_MANA_SHIELD = 97,
146 &Aura::HandleAuraModSkill, //SPELL_AURA_MOD_SKILL_TALENT = 98,
147 &Aura::HandleAuraModAttackPower, //SPELL_AURA_MOD_ATTACK_POWER = 99,
148 &Aura::HandleNULL, //SPELL_AURA_AURAS_VISIBLE = 100,
149 &Aura::HandleModResistancePercent, //SPELL_AURA_MOD_RESISTANCE_PCT = 101,
150 &Aura::HandleModCreatureAttackPower, //SPELL_AURA_MOD_CREATURE_ATTACK_POWER = 102,
151 &Aura::HandleNULL, //SPELL_AURA_MOD_TOTAL_THREAT = 103,
152 &Aura::HandleAuraWaterWalk, //SPELL_AURA_WATER_WALK = 104,
153 &Aura::HandleAuraFeatherFall, //SPELL_AURA_FEATHER_FALL = 105,
154 &Aura::HandleAuraHover, //SPELL_AURA_HOVER = 106,
155 &Aura::HandleAddModifier, //SPELL_AURA_ADD_FLAT_MODIFIER = 107,
156 &Aura::HandleAddModifier, //SPELL_AURA_ADD_PCT_MODIFIER = 108,
157 &Aura::HandleNULL, //SPELL_AURA_ADD_TARGET_TRIGGER = 109,
158 &Aura::HandleNULL, //SPELL_AURA_MOD_POWER_REGEN_PERCENT = 110,
159 &Aura::HandleNULL, //SPELL_AURA_ADD_CASTER_HIT_TRIGGER = 111,
160 &Aura::HandleNULL, //SPELL_AURA_OVERRIDE_CLASS_SCRIPTS = 112,
161 &Aura::HandleNULL, //SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN = 113,
162 &Aura::HandleNULL, //SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN_PCT = 114,
163 &Aura::HandleNULL, //SPELL_AURA_MOD_HEALING = 115,
164 &Aura::HandleNULL, //SPELL_AURA_IGNORE_REGEN_INTERRUPT = 116,
165 &Aura::HandleNULL, //SPELL_AURA_MOD_MECHANIC_RESISTANCE = 117,
166 &Aura::HandleNULL, //SPELL_AURA_MOD_HEALING_PCT = 118,
167 &Aura::HandleNULL, //SPELL_AURA_SHARE_PET_TRACKING = 119,
168 &Aura::HandleNULL, //SPELL_AURA_UNTRACKABLE = 120,
169 &Aura::HandleAuraEmpathy, //SPELL_AURA_EMPATHY = 121,
170 &Aura::HandleNULL, //SPELL_AURA_MOD_OFFHAND_DAMAGE_PCT = 122,
171 &Aura::HandleNULL, //SPELL_AURA_MOD_POWER_COST_PCT = 123,
172 &Aura::HandleAuraModRangedAttackPower, //SPELL_AURA_MOD_RANGED_ATTACK_POWER = 124,
173 &Aura::HandleNULL, //SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN = 125,
174 &Aura::HandleNULL, //SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN_PCT = 126,
175 &Aura::HandleNULL, //SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS = 127,
176 &Aura::HandleNULL, //SPELL_AURA_MOD_POSSESS_PET = 128,
177 &Aura::HandleAuraModIncreaseSpeedAlways, //SPELL_AURA_MOD_INCREASE_SPEED_ALWAYS = 129,
178 &Aura::HandleNULL, //SPELL_AURA_MOD_MOUNTED_SPEED_ALWAYS = 130,
179 &Aura::HandleNULL, //SPELL_AURA_MOD_CREATURE_RANGED_ATTACK_POWER = 131,
180 &Aura::HandleAuraModIncreaseEnergyPercent, //SPELL_AURA_MOD_INCREASE_ENERGY_PERCENT = 132,
181 &Aura::HandleAuraModIncreaseHealthPercent, //SPELL_AURA_MOD_INCREASE_HEALTH_PERCENT = 133,
182 &Aura::HandleNULL, //SPELL_AURA_MOD_MANA_REGEN_INTERRUPT = 134,
183 &Aura::HandleNULL, //SPELL_AURA_MOD_HEALING_DONE = 135,
184 &Aura::HandleNULL, //SPELL_AURA_MOD_HEALING_DONE_PERCENT = 136,
185 &Aura::HandleModTotalPercentStat, //SPELL_AURA_MOD_TOTAL_STAT_PERCENTAGE = 137,
186 &Aura::HandleHaste, //SPELL_AURA_MOD_HASTE = 138,
187 &Aura::HandleForceReaction, //SPELL_AURA_FORCE_REACTION = 139,
188 &Aura::HandleAuraModRangedHaste, //SPELL_AURA_MOD_RANGED_HASTE = 140,
189 &Aura::HandleRangedAmmoHaste, //SPELL_AURA_MOD_RANGED_AMMO_HASTE = 141,
190 &Aura::HandleAuraModBaseResistancePCT, //SPELL_AURA_MOD_BASE_RESISTANCE_PCT = 142,
191 &Aura::HandleAuraModResistanceExclusive, //SPELL_AURA_MOD_RESISTANCE_EXCLUSIVE = 143,
192 &Aura::HandleAuraSafeFall, //SPELL_AURA_SAFE_FALL = 144,
193 &Aura::HandleNULL, //SPELL_AURA_CHARISMA = 145,
194 &Aura::HandleNULL, //SPELL_AURA_PERSUADED = 146,
195 &Aura::HandleNULL, //SPELL_AURA_ADD_CREATURE_IMMUNITY = 147,
196 &Aura::HandleNULL, //SPELL_AURA_RETAIN_COMBO_POINTS = 148,
197 &Aura::HandleNULL, //SPELL_AURA_RESIST_PUSHBACK = 149 ,// Resist Pushback
198 &Aura::HandleModShieldBlock, //SPELL_AURA_MOD_SHIELD_BLOCK = 150 ,// Mod Shield Block %
199 &Aura::HandleNULL, //SPELL_AURA_TRACK_STEALTHED = 151 ,// Track Stealthed
200 &Aura::HandleNULL, //SPELL_AURA_MOD_DETECTED_RANGE = 152 ,// Mod Detected Range
201 &Aura::HandleNULL, //SPELL_AURA_SPLIT_DAMAGE_FLAT = 153 ,// Split Damage Flat
202 &Aura::HandleNULL, //SPELL_AURA_MOD_STEALTH_LEVEL = 154 ,// Stealth Level Modifier
203 &Aura::HandleNULL, //SPELL_AURA_MOD_WATER_BREATHING = 155 ,// Mod Water Breathing
204 &Aura::HandleModReputationGain, //SPELL_AURA_MOD_REPUTATION_GAIN = 156 ,// Mod Reputation Gain
205 &Aura::HandleNULL, //SPELL_AURA_PET_DAMAGE_MULTI = 157 ,// Mod Pet Damage
206 &Aura::HandleNULL, // = 158 ,//
207 &Aura::HandleNULL, // = 159 ,//
208 &Aura::HandleNULL, // = 160 ,//
209 &Aura::HandleNULL, // = 161 ,//
210 &Aura::HandleNULL // = 162 ,//
211 };
212
213 Aura::Aura(SpellEntry const* spellproto, uint32 eff, Unit *target, Unit *caster, Item* castItem) :
214 m_spellId(spellproto->Id), m_effIndex(eff), m_caster_guid(0), m_target(target),
215 m_timeCla(1000), m_castItem(castItem), m_auraSlot(0),m_positive(false), m_permanent(false),
216 m_isPeriodic(false), m_isTrigger(false), m_periodicTimer(0), m_PeriodicEventId(0),
217 m_procCharges(0), m_absorbDmg(0), m_isPersistent(false), m_removeOnDeath(false),
218 m_isAreaAura(false)
219 {
220 assert(target);
221 m_duration = GetDuration(spellproto);
222 int32 maxduration = GetMaxDuration(spellproto);
223 if(m_duration == -1)
224 m_permanent = true;
225 if( m_duration != maxduration )
226 {
227 uint8 comboPoints=0;
228 if(caster->GetTypeId() == TYPEID_PLAYER)
229 {
230 comboPoints = (uint8)((caster->GetUInt32Value(PLAYER_FIELD_BYTES) & 0xFF00) >> 8);
231 caster->SetUInt32Value(PLAYER_FIELD_BYTES,((caster->GetUInt32Value(PLAYER_FIELD_BYTES) & ~(0xFF << 8)) | (0x00 << 8)));
232 }
233 comboPoints = comboPoints < 5 ? comboPoints : 5;
234 m_duration += int32((maxduration - m_duration) * comboPoints / 5);
235 }
236 m_isPassive = IsPassiveSpell(m_spellId);
237 m_positive = IsPositiveEffect(m_spellId, m_effIndex);
238 m_applyTime = time(NULL);
239
240 sLog.outDebug("Aura: construct Spellid : %u, Aura : %u Duration : %d Target : %d.", spellproto->Id, spellproto->EffectApplyAuraName[eff], m_duration, spellproto->EffectImplicitTargetA[eff]);
241
242 uint32 type = 0;
243 if(!m_positive)
244 type = 1;
245 int32 damage;
246 if(!caster)
247 {
248 m_caster_guid = target->GetGUID();
249 damage = spellproto->EffectBasePoints[eff]+1; // stored value-1
250 }
251 else
252 {
253 m_caster_guid = caster->GetGUID();
254 damage = CalculateDamage();
255 }
256
257 m_effIndex = eff;
258 SetModifier(spellproto->EffectApplyAuraName[eff], damage, spellproto->EffectAmplitude[eff], spellproto->EffectMiscValue[eff], type);
259 }
260
261 Aura::~Aura()
262 {
263 }
264
265 AreaAura::AreaAura(SpellEntry const* spellproto, uint32 eff, Unit *target,
266 Unit *caster, Item* castItem) : Aura(spellproto, eff, target, caster, castItem)
267 {
268 m_isAreaAura = true;
269 }
270
271 AreaAura::~AreaAura()
272 {
273 }
274
275 PersistentAreaAura::PersistentAreaAura(SpellEntry const* spellproto, uint32 eff, Unit *target,
276 Unit *caster, Item* castItem) : Aura(spellproto, eff, target, caster, castItem)
277 {
278 m_isPersistent = true;
279 }
280
281 PersistentAreaAura::~PersistentAreaAura()
282 {
283 }
284
285 Unit* Aura::GetCaster() const
286 {
287 if(m_caster_guid==m_target->GetGUID())
288 return m_target;
289
290 return ObjectAccessor::Instance().GetUnit(*m_target,m_caster_guid);
291 }
292
293 int32 Aura::CalculateDamage()
294 {
295 SpellEntry const* spellproto = GetSpellProto();
296 int32 value = 0;
297 uint32 level = 0;
298 if(!m_target)
299 return 0;
300 Unit* caster = GetCaster();
301 if(!caster)
302 caster = m_target;
303 /*level= caster->getLevel();
304 if( level > spellproto->maxLevel && spellproto->maxLevel > 0)
305 level = spellproto->maxLevel;*/
306
307 float basePointsPerLevel = spellproto->EffectRealPointsPerLevel[m_effIndex];
308 float randomPointsPerLevel = spellproto->EffectDicePerLevel[m_effIndex];
309 int32 basePoints = spellproto->EffectBasePoints[m_effIndex] + level * basePointsPerLevel;
310 int32 randomPoints = spellproto->EffectDieSides[m_effIndex] + level * randomPointsPerLevel;
311 float comboDamage = spellproto->EffectPointsPerComboPoint[m_effIndex];
312 uint8 comboPoints=0;
313 if(caster->GetTypeId() == TYPEID_PLAYER)
314 comboPoints = (uint8)((caster->GetUInt32Value(PLAYER_FIELD_BYTES) & 0xFF00) >> 8);
315
316 value += spellproto->EffectBaseDice[m_effIndex];
317 if(randomPoints <= 1)
318 value = basePoints+1;
319 else
320 value = basePoints+rand()%randomPoints;
321
322 if(comboDamage > 0)
323 {
324 value += (int32)(comboDamage * comboPoints);
325 if(caster->GetTypeId() == TYPEID_PLAYER)
326 caster->SetUInt32Value(PLAYER_FIELD_BYTES,((caster->GetUInt32Value(PLAYER_FIELD_BYTES) & ~(0xFF << 8)) | (0x00 << 8)));
327 }
328
329 return value;
330 }
331
332 void Aura::SetModifier(uint8 t, int32 a, uint32 pt, int32 miscValue, uint32 miscValue2)
333 {
334 m_modifier.m_auraname = t;
335 m_modifier.m_amount = a;
336 m_modifier.m_miscvalue = miscValue;
337 m_modifier.m_miscvalue2 = miscValue2;
338 m_modifier.periodictime = pt;
339
340 Unit* caster = GetCaster();
341 if (caster && caster->GetTypeId() == TYPEID_PLAYER)
342 ((Player *)caster)->ApplySpellMod(m_spellId,SPELLMOD_ALL_EFFECTS, m_modifier.m_amount);
343 }
344
345 void Aura::Update(uint32 diff)
346 {
347 if (m_duration > 0)
348 {
349 m_duration -= diff;
350 if (m_duration < 0)
351 m_duration = 0;
352 m_timeCla -= diff;
353
354 Unit* caster = GetCaster();
355 if(caster && m_timeCla <= 0)
356 {
357 Powers powertype = caster->getPowerType();
358 int32 manaPerSecond = GetSpellProto()->manaPerSecond;
359 int32 manaPerSecondPerLevel = uint32(GetSpellProto()->manaPerSecondPerLevel*caster->getLevel());
360 m_timeCla = 1000;
361 caster->ModifyPower(powertype,-manaPerSecond);
362 caster->ModifyPower(powertype,-manaPerSecondPerLevel);
363 }
364 if(caster && m_target->isAlive() && m_target->HasFlag(UNIT_FIELD_FLAGS,(UNIT_STAT_FLEEING<<16)))
365 {
366 float x,y,z,angle,speed,pos_x,pos_y,pos_z;
367 angle = m_target->GetAngle( caster->GetPositionX(), caster->GetPositionY() );
368 // If the m_target is player,and if the speed is too slow,change it :P
369 speed = m_target->GetSpeed(MOVE_RUN);
370 pos_x = m_target->GetPositionX();
371 pos_y = m_target->GetPositionY();
372 uint32 mapid = m_target->GetMapId();
373 pos_z = MapManager::Instance().GetMap(mapid)->GetHeight(pos_x,pos_y);
374 // Control the max Distance; 20 for temp.
375 if(m_target->IsWithinDist(caster, 20))
376 {
377 if( m_target->GetPositionX() < caster->GetPositionX() || m_target->GetPositionY() > caster->GetPositionY() )
378 x = m_target->GetPositionX() + speed*diff * sin(angle)/1000;
379 else
380 x = m_target->GetPositionX() - speed*diff * sin(angle)/1000;
381 y = m_target->GetPositionY() - speed*diff * cos(angle)/1000;
382 mapid = m_target->GetMapId();
383 z = MapManager::Instance().GetMap(mapid)->GetHeight(x,y);
384 // Control the target to not climb or drop when dz > |x|,x = 1.3 for temp.
385 // fixed me if it needs checking when the position will be in water?
386 if(z<=pos_z+1.3 && z>=pos_z-1.3)
387 {
388 m_target->SendMonsterMove(x,y,z,false,true,diff);
389 if(m_target->GetTypeId() != TYPEID_PLAYER)
390 m_target->Relocate(x,y,z,m_target->GetOrientation());
391 }
392 }
393 }
394 }
395
396 if(m_isPeriodic && (m_duration >= 0 || m_isPassive))
397 {
398 m_periodicTimer -= diff;
399 if(m_periodicTimer < 0)
400 {
401 if( m_modifier.m_auraname == SPELL_AURA_MOD_REGEN ||
402 m_modifier.m_auraname == SPELL_AURA_MOD_POWER_REGEN ||
403 // Cannibalize, eating items and other spells
404 m_modifier.m_auraname == SPELL_AURA_OBS_MOD_HEALTH ||
405 // Eating items and other spells
406 m_modifier.m_auraname == SPELL_AURA_OBS_MOD_MANA )
407 {
408 ApplyModifier(true);
409 return;
410 }
411 // update before applying (aura can be removed in TriggerSpell or PeriodicAuraLog calls)
412 m_periodicTimer += m_modifier.periodictime;
413
414 if(m_isTrigger)
415 {
416 TriggerSpell();
417 }
418 else
419 {
420 if(Unit* caster = GetCaster())
421 caster->PeriodicAuraLog(m_target, GetSpellProto(), &m_modifier);
422 else
423 m_target->PeriodicAuraLog(m_target, GetSpellProto(), &m_modifier);
424 }
425 }
426 }
427 }
428
429 void AreaAura::Update(uint32 diff)
430 {
431 // update for the caster of the aura
432 if(m_caster_guid == m_target->GetGUID())
433 {
434 Unit* caster = m_target;
435
436 Group *pGroup = NULL;
437 if (caster->GetTypeId() == TYPEID_PLAYER)
438 pGroup = ((Player*)caster)->groupInfo.group;
439 else if(((Creature*)caster)->isTotem())
440 {
441 Unit *owner = ((Totem*)caster)->GetOwner();
442 if (owner && owner->GetTypeId() == TYPEID_PLAYER)
443 pGroup = ((Player*)owner)->groupInfo.group;
444 }
445
446 float radius = GetRadius(sSpellRadiusStore.LookupEntry(GetSpellProto()->EffectRadiusIndex[m_effIndex]));
447 if(pGroup)
448 {
449 for(uint32 p=0;p<pGroup->GetMembersCount();p++)
450 {
451 Unit* Target = objmgr.GetPlayer(pGroup->GetMemberGUID(p));
452 if(!Target || Target->GetGUID() == m_caster_guid || !Target->isAlive() || pGroup->SameSubGroup(m_caster_guid, Target->GetGUID()))
453 continue;
454 Aura *t_aura = Target->GetAura(m_spellId, m_effIndex);
455
456 if(caster->IsWithinDist(Target, radius) )
457 {
458 // apply aura to players in range that dont have it yet
459 if (!t_aura)
460 {
461 Aura *aur = new Aura(GetSpellProto(), m_effIndex, Target, caster);
462 Target->AddAura(aur);
463 }
464 }
465 else
466 {
467 // remove auras of the same caster from out of range players
468 if (t_aura)
469 if (t_aura->GetCasterGUID() == m_caster_guid)
470 Target->RemoveAura(m_spellId, m_effIndex);
471 }
472 }
473 }
474 else if (caster->GetTypeId() != TYPEID_PLAYER && ((Creature*)caster)->isTotem())
475 {
476 // add / remove auras from the totem's owner
477 Unit *owner = ((Totem*)caster)->GetOwner();
478 if (owner)
479 {
480 Aura *o_aura = owner->GetAura(m_spellId, m_effIndex);
481 if(caster->IsWithinDist(owner, radius))
482 {
483 if (!o_aura)
484 {
485 Aura *aur = new Aura(GetSpellProto(), m_effIndex, owner, caster);
486 owner->AddAura(aur);
487 }
488 }
489 else
490 {
491 if (o_aura)
492 if (o_aura->GetCasterGUID() == m_caster_guid)
493 owner->RemoveAura(m_spellId, m_effIndex);
494 }
495 }
496 }
497 }
498
499 Aura::Update(diff);
500 }
501
502 void PersistentAreaAura::Update(uint32 diff)
503 {
504 bool remove = false;
505
506 // remove the aura if its caster or the dynamic object causing it was removed
507 // or if the target moves too far from the dynamic object
508 Unit *caster = GetCaster();
509 if (caster)
510 {
511 DynamicObject *dynObj = caster->GetDynObject(GetId(), GetEffIndex());
512 if (dynObj)
513 {
514 if (!m_target->IsWithinDist(dynObj, dynObj->GetRadius()))
515 remove = true;
516 }
517 else
518 remove = true;
519 }
520 else
521 remove = true;
522
523 Aura::Update(diff);
524
525 if(remove)
526 m_target->RemoveAura(GetId(), GetEffIndex());
527 }
528
529 void Aura::ApplyModifier(bool apply, bool Real)
530 {
531 uint8 aura = 0;
532 aura = m_modifier.m_auraname;
533
534 if(aura<TOTAL_AURAS)
535 (*this.*AuraHandler [aura])(apply,Real);
536 }
537
538 void Aura::UpdateAuraDuration()
539 {
540 if(m_target->GetTypeId() != TYPEID_PLAYER)
541 return;
542 if(m_isPassive)
543 return;
544
545 WorldPacket data(SMSG_UPDATE_AURA_DURATION, 5);
546 data << (uint8)m_auraSlot << (uint32)m_duration;
547 //((Player*)m_target)->SendMessageToSet(&data, true); //GetSession()->SendPacket(&data);
548 ((Player*)m_target)->SendDirectMessage(&data);
549 }
550
551 void Aura::DelayPeriodicTimer(int32 delaytime)
552 {
553 m_periodicTimer += delaytime;
554 }
555
556 void Aura::_AddAura()
557 {
558 if (!m_spellId)
559 return;
560 if(!m_target)
561 return;
562
563 bool samespell = false;
564 uint8 slot = 0xFF, i;
565 Aura* aura = NULL;
566
567 for(i = 0; i < 3; i++)
568 {
569 aura = m_target->GetAura(m_spellId, i);
570 if(aura)
571 {
572 //if (i != m_effIndex)
573 {
574 samespell = true;
575 slot = aura->GetAuraSlot();
576 }
577 }
578 }
579
580 // not call total regen auras at adding
581 if( m_modifier.m_auraname==SPELL_AURA_OBS_MOD_HEALTH || m_modifier.m_auraname==SPELL_AURA_OBS_MOD_MANA )
582 m_periodicTimer = m_modifier.periodictime;
583 else
584 if( m_modifier.m_auraname==SPELL_AURA_MOD_REGEN || m_modifier.m_auraname==SPELL_AURA_MOD_POWER_REGEN )
585 m_periodicTimer = 5000;
586
587 m_target->ApplyStats(false);
588 ApplyModifier(true,true);
589 m_target->ApplyStats(true);
590
591 sLog.outDebug("Aura %u now is in use", m_modifier.m_auraname);
592
593 Unit* caster = GetCaster();
594
595 // passive auras (except totem auras) do not get placed in the slots
596 if(!m_isPassive || (caster && caster->GetTypeId() == TYPEID_UNIT && ((Creature*)caster)->isTotem()))
597 {
598 if(!samespell)
599 {
600 if (IsPositive())
601 {
602 for (i = 0; i < MAX_POSITIVE_AURAS; i++)
603 {
604 if (m_target->GetUInt32Value((uint16)(UNIT_FIELD_AURA + i)) == 0)
605 {
606 slot = i;
607 break;
608 }
609 }
610 }
611 else
612 {
613 for (i = MAX_POSITIVE_AURAS; i < MAX_AURAS; i++)
614 {
615 if (m_target->GetUInt32Value((uint16)(UNIT_FIELD_AURA + i)) == 0)
616 {
617 slot = i;
618 break;
619 }
620 }
621 }
622
623 m_target->SetUInt32Value((uint16)(UNIT_FIELD_AURA + slot), GetId());
624
625 uint8 flagslot = slot >> 3;
626 uint32 value = m_target->GetUInt32Value((uint16)(UNIT_FIELD_AURAFLAGS + flagslot));
627
628 uint8 value1 = (slot & 7) << 2;
629 value |= ((uint32)AFLAG_SET << value1);
630
631 m_target->SetUInt32Value((uint16)(UNIT_FIELD_AURAFLAGS + flagslot), value);
632 }
633 else
634 {
635 /* TODO: increase count */
636 }
637
638 if(GetSpellProto()->SpellVisual == 5622)
639 m_target->SetFlag(UNIT_FIELD_AURASTATE, uint32(1<<(AURA_STATE_JUDGEMENT-1)));
640 SetAuraSlot( slot );
641 if( m_target->GetTypeId() == TYPEID_PLAYER )
642 UpdateAuraDuration();
643 }
644
645 }
646
647 void Aura::_RemoveAura()
648 {
649 m_target->ApplyStats(false);
650 sLog.outDebug("Aura %u now is remove", m_modifier.m_auraname);
651 ApplyModifier(false,true);
652 m_target->ApplyStats(true);
653
654 Unit* caster = GetCaster();
655
656 if(caster && IsPersistent())
657 {
658 DynamicObject *dynObj = caster->GetDynObject(GetId(), GetEffIndex());
659 if (dynObj)
660 dynObj->RemoveAffected(m_target);
661 }
662 //passive auras do not get put in slots
663 if(m_isPassive && !(caster && caster->GetTypeId() == TYPEID_UNIT && ((Creature*)caster)->isTotem()))
664 return;
665
666 uint8 slot = GetAuraSlot();
667
668 // Aura added always to m_target
669 //Aura* aura = m_target->GetAura(m_spellId, m_effIndex);
670 //if(!aura)
671 // return;
672
673 if(m_target->GetUInt32Value((uint16)(UNIT_FIELD_AURA + slot)) == 0)
674 return;
675
676 // count all auras from each effect of the spell
677 Unit::AuraMap& t_Auras = m_target->GetAuras();
678 uint8 count[3], totalcount = 0;
679 for(uint8 i = 0; i < 3; i++)
680 {
681 count[i] = t_Auras.count(Unit::spellEffectPair(m_spellId, i));
682 totalcount += count[i];
683 }
684
685 /*
686 count[m_effIndex]--;
687 // all counts should be the same after the last effect of a spell was taken out
688 for(uint8 i = 0; i < 3; i++)
689 if (count[i] > count[m_effIndex])
690 break;
691 if (i == 3)
692 TODO: decrease count for spell
693 */
694
695 // only remove icon when the last aura of the spell is removed (current aura already removed from list)
696 if (totalcount > 0)
697 return;
698
699 m_target->SetUInt32Value((uint16)(UNIT_FIELD_AURA + slot), 0);
700
701 uint8 flagslot = slot >> 3;
702
703 uint32 value = m_target->GetUInt32Value((uint16)(UNIT_FIELD_AURAFLAGS + flagslot));
704
705 uint8 aurapos = (slot & 7) << 2;
706 uint32 value1 = ~( AFLAG_SET << aurapos );
707 value &= value1;
708
709 m_target->SetUInt32Value((uint16)(UNIT_FIELD_AURAFLAGS + flagslot), value);
710 if(GetSpellProto()->SpellVisual == 5622)
711 m_target->RemoveFlag(UNIT_FIELD_AURASTATE, uint32(1<<(AURA_STATE_JUDGEMENT-1)));
712 }
713
714 /*********************************************************/
715 /*** BASIC AURA FUNCTION ***/
716 /*********************************************************/
717
718 void Aura::HandleNULL(bool apply, bool Real)
719 {
720 }
721
722 void Aura::HandleAddModifier(bool apply, bool Real)
723 {
724 if(m_target->GetTypeId() != TYPEID_PLAYER)
725 return;
726
727 Player *p_target = (Player *)m_target;
728
729 SpellEntry const *spellInfo = GetSpellProto();
730 if(!spellInfo) return;
731
732 uint8 op = spellInfo->EffectMiscValue[m_effIndex];
733 int32 value = spellInfo->EffectBasePoints[m_effIndex]+1;
734 uint8 type = spellInfo->EffectApplyAuraName[m_effIndex];
735 uint32 mask = spellInfo->EffectItemType[m_effIndex];
736 if (!op) return;
737 SpellModList *p_mods = p_target->getSpellModList(op);
738 if (!p_mods) return;
739
740 if (apply)
741 {
742 SpellModifier *mod = new SpellModifier;
743 mod->op = op;
744 mod->value = value;
745 mod->type = type;
746 mod->mask = mask;
747 mod->spellId = m_spellId;
748 mod->charges = spellInfo->procCharges;
749 p_mods->push_back(mod);
750 m_spellmod = mod;
751
752 uint16 send_val=0, send_mark=0;
753 int16 tmpval=spellInfo->EffectBasePoints[m_effIndex];
754 uint32 shiftdata=0x01, Opcode=SMSG_SET_FLAT_SPELL_MODIFIER;
755
756 if(tmpval != 0)
757 {
758 if(tmpval > 0)
759 {
760 send_val = tmpval+1;
761 send_mark = 0x0;
762 }
763 else
764 {
765 send_val = 0xFFFF + (tmpval+2);
766 send_mark = 0xFFFF;
767 }
768 }
769
770 if (mod->type == SPELLMOD_FLAT) Opcode = SMSG_SET_FLAT_SPELL_MODIFIER;
771 else if (mod->type == SPELLMOD_PCT) Opcode = SMSG_SET_PCT_SPELL_MODIFIER;
772
773 for(int eff=0;eff<32;eff++)
774 {
775 if ( mask & shiftdata )
776 {
777 WorldPacket data(Opcode, (1+1+2+2));
778 data << uint8(eff);
779 data << uint8(mod->op);
780 data << uint16(send_val);
781 data << uint16(send_mark);
782 p_target->SendDirectMessage(&data);
783 }
784 shiftdata=shiftdata<<1;
785 }
786 }
787 else
788 {
789 SpellModList *p_mods = p_target->getSpellModList(spellInfo->EffectMiscValue[m_effIndex]);
790 p_mods->remove(this->m_spellmod);
791 }
792 }
793
794 void Aura::TriggerSpell()
795 {
796 SpellEntry const *spellInfo = sSpellStore.LookupEntry( GetSpellProto()->EffectTriggerSpell[m_effIndex] );
797
798 if(!spellInfo)
799 {
800 sLog.outError("Auras: unknown TriggerSpell:%i From spell: %i", GetSpellProto()->EffectTriggerSpell[m_effIndex],GetSpellProto()->Id);
801 return;
802 }
803 if(GetSpellProto()->Id == 1515)
804 spellInfo = sSpellStore.LookupEntry( 13481 );
805
806 Unit* caster = GetCaster();
807
808 Spell spell(caster, spellInfo, true, this);
809 Unit* target = m_target;
810 if(!target && caster && caster->GetTypeId() == TYPEID_PLAYER)
811 {
812 target = ObjectAccessor::Instance().GetUnit(*caster, ((Player*)caster)->GetSelection());
813 }
814 if(!target)
815 return;
816 SpellCastTargets targets;
817 targets.setUnitTarget(target);
818 spell.prepare(&targets);
819 }
820
821 /*********************************************************/
822 /*** AURA EFFECTS ***/
823 /*********************************************************/
824
825 void Aura::HandleAuraDummy(bool apply, bool Real)
826 {
827 Unit* caster = GetCaster();
828
829 if(GetSpellProto()->SpellVisual == 5622 && caster && caster->GetTypeId() == TYPEID_PLAYER)
830 {
831 if(GetSpellProto()->SpellIconID == 25 && GetEffIndex() == 0)
832 {
833 Unit::AuraList& tAuraProcTriggerDamage = m_target->GetAurasByType(SPELL_AURA_PROC_TRIGGER_DAMAGE);
834 if(apply)
835 tAuraProcTriggerDamage.push_back(this);
836 else
837 tAuraProcTriggerDamage.remove(this);
838
839 if(apply && !m_procCharges)
840 {
841 m_procCharges = GetSpellProto()->procCharges;
842 if (!m_procCharges)
843 m_procCharges = -1;
844 }
845 }
846 }
847 if(GetSpellProto()->SpellVisual == 7395 && GetSpellProto()->SpellIconID == 278 && caster->GetTypeId() == TYPEID_PLAYER)
848 {
849 Unit::AuraList& tAuraProcTriggerDamage = m_target->GetAurasByType(SPELL_AURA_PROC_TRIGGER_DAMAGE);
850 if(apply)
851 tAuraProcTriggerDamage.push_back(this);
852 else
853 tAuraProcTriggerDamage.remove(this);
854
855 if(apply && !m_procCharges)
856 {
857 m_procCharges = GetSpellProto()->procCharges;
858 if (!m_procCharges)
859 m_procCharges = -1;
860 }
861 }
862 if(GetSpellProto()->SpellVisual == 99 && GetSpellProto()->SpellIconID == 92 && caster
863 && caster->GetTypeId() == TYPEID_PLAYER && m_castItem)
864 {
865 if(m_target && m_target->GetTypeId() == TYPEID_PLAYER)
866 {
867 Player * player = (Player*)m_target;
868 uint32 spellid = 0;
869 uint32 itemflag = m_castItem->GetUInt32Value(ITEM_FIELD_FLAGS);
870 if(apply)
871 {
872 // 1<<20 just a temp value to detect if any one has be stored,
873 // we should find out a field to correctly mask the target.
874 if(itemflag & (1<<20))
875 return;
876 switch(GetId())
877 {
878 case 20707:spellid = 3026;break;
879 case 20762:spellid = 20758;break;
880 case 20763:spellid = 20759;break;
881 case 20764:spellid = 20760;break;
882 case 20765:spellid = 20761;break;
883 default:break;
884 }
885 if(!spellid)
886 return;
887 m_castItem->ApplyModFlag(ITEM_FIELD_FLAGS,(1<<20),true);
888 player->SetSoulStone(m_castItem);
889 player->SetSoulStoneSpell(spellid);
890 }
891 else
892 {
893 m_castItem->ApplyModFlag(ITEM_FIELD_FLAGS,(1<<20),false);
894 }
895 }
896 }
897 if(!apply)
898 {
899 // only at real remove
900 if(Real)
901 {
902 if( IsQuestTameSpell(GetId()) && caster && caster->isAlive() && m_target && m_target->isAlive())
903 {
904 uint32 finalSpelId = 0;
905 switch(GetId())
906 {
907 case 19548: finalSpelId = 19597; break;
908 case 19674: finalSpelId = 19677; break;
909 case 19687: finalSpelId = 19676; break;
910 case 19688: finalSpelId = 19678; break;
911 case 19689: finalSpelId = 19679; break;
912 case 19692: finalSpelId = 19680; break;
913 case 19693: finalSpelId = 19684; break;
914 case 19694: finalSpelId = 19681; break;
915 case 19696: finalSpelId = 19682; break;
916 case 19697: finalSpelId = 19683; break;
917 case 19699: finalSpelId = 19685; break;
918 case 19700: finalSpelId = 19686; break;
919 }
920
921 if(finalSpelId)
922 {
923 SpellEntry const *spell_proto = sSpellStore.LookupEntry(finalSpelId);
924 if(!spell_proto)
925 return;
926
927 Spell spell(caster, spell_proto, true, 0);
928 SpellCastTargets targets;
929 targets.setUnitTarget(m_target);
930 // prevent double stat apply for triggered auras
931 m_target->ApplyStats(true);
932 spell.prepare(&targets);
933 m_target->ApplyStats(false);
934 }
935 }
936 }
937 }
938 }
939
940 void Aura::HandleAuraMounted(bool apply, bool Real)
941 {
942 if(apply)
943 {
944 CreatureInfo const* ci = objmgr.GetCreatureTemplate(m_modifier.m_miscvalue);
945 if(!ci)return;
946 uint32 displayId = ci->randomDisplayID();
947 if(displayId != 0)
948 m_target->Mount(displayId);
949 }else
950 {
951 m_target->Unmount();
952 }
953 }
954
955 void Aura::HandleAuraWaterWalk(bool apply, bool Real)
956 {
957 // only at real add/remove aura
958 if(!Real)
959 return;
960
961 WorldPacket data;
962 if(apply)
963 data.Initialize(SMSG_MOVE_WATER_WALK, 8);
964 else
965 data.Initialize(SMSG_MOVE_LAND_WALK, 8);
966 data.append(m_target->GetPackGUID());
967 m_target->SendMessageToSet(&data,true);
968 }
969
970 void Aura::HandleAuraFeatherFall(bool apply, bool Real)
971 {
972 // only at real add/remove aura
973 if(!Real)
974 return;
975
976 WorldPacket data;
977 if(apply)
978 data.Initialize(SMSG_MOVE_FEATHER_FALL, 8);
979 else
980 data.Initialize(SMSG_MOVE_NORMAL_FALL, 8);
981 data.append(m_target->GetPackGUID());
982 m_target->SendMessageToSet(&data,true);
983 }
984
985 void Aura::HandleAuraHover(bool apply, bool Real)
986 {
987 // only at real add/remove aura
988 if(!Real)
989 return;
990
991 WorldPacket data;
992 if(apply)
993 data.Initialize(SMSG_MOVE_SET_HOVER, 8);
994 else
995 data.Initialize(SMSG_MOVE_UNSET_HOVER, 8);
996 data.append(m_target->GetPackGUID());
997 m_target->SendMessageToSet(&data,true);
998 }
999
1000 void Aura::HandleWaterBreathing(bool apply, bool Real)
1001 {
1002 m_target->waterbreath = apply;
1003 }
1004
1005 void Aura::HandleAuraModShapeshift(bool apply, bool Real)
1006 {
1007 if(!m_target)
1008 return;
1009 Unit *unit_target = m_target;
1010 uint32 modelid = 0;
1011 Powers PowerType = POWER_MANA;
1012 uint32 new_bytes_1 = m_modifier.m_miscvalue;
1013 switch(m_modifier.m_miscvalue)
1014 {
1015 case FORM_CAT:
1016 if(unit_target->getRace() == RACE_NIGHTELF)
1017 modelid = 892;
1018 else if(unit_target->getRace() == RACE_TAUREN)
1019 modelid = 8571;
1020 PowerType = POWER_ENERGY;
1021 break;
1022 case FORM_TRAVEL:
1023 modelid = 632;
1024 break;
1025 case FORM_AQUA:
1026 if(unit_target->getRace() == RACE_NIGHTELF)
1027 modelid = 2428;
1028 else if(unit_target->getRace() == RACE_TAUREN)
1029 modelid = 2428;
1030 break;
1031 case FORM_BEAR:
1032 if(unit_target->getRace() == RACE_NIGHTELF)
1033 modelid = 2281;
1034 else if(unit_target->getRace() == RACE_TAUREN)
1035 modelid = 2289;
1036 PowerType = POWER_RAGE;
1037 break;
1038 case FORM_GHOUL:
1039 if(unit_target->getRace() == RACE_NIGHTELF)
1040 modelid = 10045;
1041 break;
1042 case FORM_DIREBEAR:
1043 if(unit_target->getRace() == RACE_NIGHTELF)
1044 modelid = 2281;
1045 else if(unit_target->getRace() == RACE_TAUREN)
1046 modelid = 2289;
1047 PowerType = POWER_RAGE;
1048 break;
1049 case FORM_CREATUREBEAR:
1050 modelid = 902;
1051 break;
1052 case FORM_GHOSTWOLF:
1053 modelid = 4613;
1054 break;
1055 case FORM_MOONKIN:
1056 if(unit_target->getRace() == RACE_NIGHTELF)
1057 modelid = 15374;
1058 else if(unit_target->getRace() == RACE_TAUREN)
1059 modelid = 15375;
1060 break;
1061 case FORM_AMBIENT:
1062 case FORM_BATTLESTANCE:
1063 case FORM_BERSERKERSTANCE:
1064 case FORM_DEFENSIVESTANCE:
1065 case FORM_SHADOW:
1066 case FORM_STEALTH:
1067 case FORM_TREE:
1068 break;
1069 default:
1070 sLog.outError("Auras: Unknown Shapeshift Type: %u", m_modifier.m_miscvalue);
1071 }
1072
1073 if(apply)
1074 {
1075 unit_target->SetFlag(UNIT_FIELD_BYTES_1, (new_bytes_1<<16) );
1076 if(modelid > 0)
1077 {
1078 unit_target->SetUInt32Value(UNIT_FIELD_DISPLAYID,modelid);
1079 }
1080
1081 if(PowerType != POWER_MANA)
1082 unit_target->setPowerType(PowerType);
1083
1084 unit_target->m_ShapeShiftForm = m_spellId;
1085 unit_target->m_form = m_modifier.m_miscvalue;
1086 if(unit_target->m_form == FORM_DIREBEAR)
1087 if (m_target->getRace() == RACE_TAUREN)
1088 {
1089 m_target->SetFloatValue(OBJECT_FIELD_SCALE_X,1.35f);
1090 }
1091 else
1092 m_target->SetFloatValue(OBJECT_FIELD_SCALE_X,1.0f);
1093 }
1094 else
1095 {
1096 if (m_target->getRace() == RACE_TAUREN)
1097 unit_target->SetFloatValue(OBJECT_FIELD_SCALE_X,1.35f);
1098 else
1099 unit_target->SetFloatValue(OBJECT_FIELD_SCALE_X,1.0f);
1100 unit_target->SetUInt32Value(UNIT_FIELD_DISPLAYID,unit_target->GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
1101 unit_target->RemoveFlag(UNIT_FIELD_BYTES_1, (new_bytes_1<<16) );
1102 if(unit_target->getClass() == CLASS_DRUID)
1103 unit_target->setPowerType(POWER_MANA);
1104 unit_target->m_ShapeShiftForm = 0;
1105 unit_target->m_form = 0;
1106 }
1107 }
1108
1109 void Aura::HandleAuraTransform(bool apply, bool Real)
1110 {
1111 if(!m_target)
1112 return;
1113
1114 if (apply)
1115 {
1116 CreatureInfo const * ci = objmgr.GetCreatureTemplate(m_modifier.m_miscvalue);
1117 if(!ci)
1118 {
1119 //pig pink ^_^
1120 m_target->SetUInt32Value (UNIT_FIELD_DISPLAYID, 16358);
1121 sLog.outError("Auras: unknown creature id = %d (only need its modelid) Form Spell Aura Transform in Spell ID = %d", m_modifier.m_miscvalue, GetSpellProto()->Id);
1122 }
1123 else
1124 {
1125 m_target->SetUInt32Value (UNIT_FIELD_DISPLAYID, ci->randomDisplayID());
1126 }
1127 m_target->setTransForm(GetSpellProto()->Id);
1128 }
1129 else
1130 {
1131 m_target->SetUInt32Value (UNIT_FIELD_DISPLAYID, m_target->GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
1132 m_target->setTransForm(0);
1133 }
1134
1135 Unit* caster = GetCaster();
1136
1137 if(caster && caster->GetTypeId() == TYPEID_PLAYER)
1138 m_target->SendUpdateToPlayer((Player*)caster);
1139 }
1140
1141 void Aura::HandleForceReaction(bool Apply, bool Real)
1142 {
1143 if(m_target->GetTypeId() != TYPEID_PLAYER)
1144 return;
1145
1146 if(Apply)
1147 {
1148 uint32 faction_id = m_modifier.m_miscvalue;
1149
1150 FactionTemplateEntry const *factionTemplateEntry = NULL;
1151
1152 for(uint32 i = 0; i < sFactionTemplateStore.GetNumRows(); ++i)
1153 {
1154 factionTemplateEntry = sFactionTemplateStore.LookupEntry(i);
1155 if(!factionTemplateEntry)
1156 continue;
1157
1158 if(factionTemplateEntry->faction == faction_id)
1159 break;
1160 }
1161
1162 if(!factionTemplateEntry)
1163 return;
1164
1165 m_target->setFaction(factionTemplateEntry->ID);
1166 }
1167 else
1168 ((Player*)m_target)->setFactionForRace(((Player*)m_target)->getRace());
1169 }
1170
1171 void Aura::HandleAuraModSkill(bool apply, bool Real)
1172 {
1173 if(m_target->GetTypeId() != TYPEID_PLAYER)
1174 return;
1175
1176 uint32 prot=GetSpellProto()->EffectMiscValue[m_effIndex];
1177 int32 points = GetSpellProto()->EffectBasePoints[m_effIndex]+1;
1178
1179 ((Player*)m_target)->ModifySkillBonus(prot,(apply ? points: -points));
1180 if(prot == SKILL_DEFENSE)
1181 ((Player*)m_target)->ApplyDefenseBonusesMod(points, apply);
1182 }
1183
1184 void Aura::HandleChannelDeathItem(bool apply, bool Real)
1185 {
1186 if(!apply)
1187 {
1188 Unit* caster = GetCaster();
1189 Unit* victim = GetTarget();
1190 if(!caster || caster->GetTypeId() != TYPEID_PLAYER || !victim || !m_removeOnDeath)
1191 return;
1192
1193 SpellEntry const *spellInfo = GetSpellProto();
1194 if(spellInfo->EffectItemType[m_effIndex] == 0)
1195 return;
1196
1197 // Soul Shard only from non-grey units
1198 if( victim->getLevel() <= MaNGOS::XP::GetGrayLevel(caster->getLevel()) && spellInfo->EffectItemType[m_effIndex] == 6265)
1199 return;
1200
1201 uint16 dest;
1202 uint8 msg = ((Player*)caster)->CanStoreNewItem( NULL_BAG, NULL_SLOT, dest, spellInfo->EffectItemType[m_effIndex], 1, false);
1203 if( msg == EQUIP_ERR_OK )
1204 ((Player*)caster)->StoreNewItem(dest, spellInfo->EffectItemType[m_effIndex], 1, true);
1205 else
1206 ((Player*)caster)->SendEquipError( msg, NULL, NULL );
1207 }
1208 }
1209
1210 void Aura::HandleAuraSafeFall(bool apply, bool Real)
1211 {
1212 // only at real add/remove aura
1213 if(!Real)
1214 return;
1215
1216 WorldPacket data;
1217 if(apply)
1218 data.Initialize(SMSG_MOVE_FEATHER_FALL, 8);
1219 else
1220 data.Initialize(SMSG_MOVE_NORMAL_FALL, 8);
1221 data.append(m_target->GetPackGUID());
1222 m_target->SendMessageToSet(&data,true);
1223 }
1224
1225 void Aura::HandleBindSight(bool apply, bool Real)
1226 {
1227 if(!m_target)
1228 return;
1229
1230 if(m_target->GetTypeId() != TYPEID_PLAYER)
1231 return;
1232
1233 m_target->SetUInt64Value(PLAYER_FARSIGHT,apply ? m_target->GetGUID() : 0);
1234 }
1235
1236 void Aura::HandleFarSight(bool apply, bool Real)
1237 {
1238 if(!m_target)
1239 return;
1240
1241 if(m_target->GetTypeId() != TYPEID_PLAYER)
1242 return;
1243
1244 m_target->SetUInt64Value(PLAYER_FARSIGHT,apply ? m_modifier.m_miscvalue : 0);
1245 }
1246
1247 void Aura::HandleAuraTracCreatures(bool apply, bool Real)
1248 {
1249 if(m_target->GetTypeId()!=TYPEID_PLAYER)
1250 return;
1251
1252 m_target->SetUInt32Value(PLAYER_TRACK_CREATURES, apply ? ((uint32)1)<<(m_modifier.m_miscvalue-1) : 0 );
1253 }
1254
1255 void Aura::HandleAuraTracResources(bool apply, bool Real)
1256 {
1257 if(m_target->GetTypeId()!=TYPEID_PLAYER)
1258 return;
1259
1260 m_target->SetUInt32Value(PLAYER_TRACK_RESOURCES, apply ? ((uint32)1)<<(m_modifier.m_miscvalue-1): 0 );
1261 }
1262
1263 void Aura::HandleAuraModScale(bool apply, bool Real)
1264 {
1265 m_target->ApplyPercentModFloatValue(OBJECT_FIELD_SCALE_X,m_modifier.m_amount,apply);
1266 }
1267
1268 void Aura::HandleModPossess(bool apply, bool Real)
1269 {
1270 if(!m_target)
1271 return;
1272
1273 if(m_target->GetTypeId() != TYPEID_UNIT)
1274 return;
1275
1276 if(!Real)
1277 return;
1278
1279 Creature* creatureTarget = (Creature*)m_target;
1280
1281 if(int32(m_target->getLevel()) <= m_modifier.m_amount)
1282 {
1283 CreatureInfo const *cinfo = ((Creature*)m_target)->GetCreatureInfo();
1284 if( apply )
1285 {
1286 Unit* caster = GetCaster();
1287 if(caster)
1288 {
1289 creatureTarget->AttackStop();
1290 if(caster->getVictim()==creatureTarget)
1291 caster->AttackStop();
1292
1293 creatureTarget->CombatStop();
1294
1295 creatureTarget->SetUInt64Value(UNIT_FIELD_CHARMEDBY,caster->GetGUID());
1296 creatureTarget->SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE,caster->getFaction());
1297 caster->SetCharm(creatureTarget);
1298 creatureTarget->AIM_Initialize();
1299
1300 if(caster->GetTypeId() == TYPEID_PLAYER)
1301 {
1302 ((Player*)caster)->PetSpellInitialize();
1303 }
1304 }
1305 }
1306 else
1307 {
1308 creatureTarget->SetUInt64Value(UNIT_FIELD_CHARMEDBY,0);
1309 creatureTarget->SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE,cinfo->faction);
1310
1311 if(Unit* caster = GetCaster())
1312 {
1313 caster->SetCharm(0);
1314
1315 if(caster->GetTypeId() == TYPEID_PLAYER)
1316 {
1317 WorldPacket data(SMSG_PET_SPELLS, 8);
1318 data << uint64(0);
1319 ((Player*)caster)->GetSession()->SendPacket(&data);
1320 }
1321 }
1322 creatureTarget->AIM_Initialize();
1323 }
1324 }
1325 }
1326
1327 void Aura::HandleModCharm(bool apply, bool Real)
1328 {
1329 if(!m_target)
1330 return;
1331
1332 if(m_target->GetTypeId() != TYPEID_UNIT)
1333 return;
1334
1335 if(!Real)
1336 return;
1337
1338 Creature* creatureTarget = (Creature*)m_target;
1339
1340 if(int32(m_target->getLevel()) <= m_modifier.m_amount)
1341 {
1342 CreatureInfo const *cinfo = ((Creature*)m_target)->GetCreatureInfo();
1343 if( apply )
1344 {
1345 Unit* caster = GetCaster();
1346 if(caster)
1347 {
1348 creatureTarget->AttackStop();
1349 if(caster->getVictim()==creatureTarget)
1350 caster->AttackStop();
1351
1352 creatureTarget->CombatStop();
1353
1354 creatureTarget->SetUInt64Value(UNIT_FIELD_CHARMEDBY,caster->GetGUID());
1355 creatureTarget->SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE,caster->getFaction());
1356 caster->SetCharm(creatureTarget);
1357 creatureTarget->AIM_Initialize();
1358 if(caster->GetTypeId() == TYPEID_PLAYER)
1359 {
1360 ((Player*)caster)->PetSpellInitialize();
1361 }
1362 }
1363 }
1364 else
1365 {
1366 creatureTarget->SetUInt64Value(UNIT_FIELD_CHARMEDBY,0);
1367 creatureTarget->SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE,cinfo->faction);
1368 Unit* caster = GetCaster();
1369 if(caster)
1370 {
1371 caster->SetCharm(0);
1372 if(caster->GetTypeId() == TYPEID_PLAYER)
1373 {
1374 WorldPacket data(SMSG_PET_SPELLS);
1375 data << uint64(0);
1376 ((Player*)caster)->GetSession()->SendPacket(&data);
1377 }
1378 }
1379 creatureTarget->AIM_Initialize();
1380 }
1381 }
1382 }
1383
1384 void Aura::HandleModConfuse(bool apply, bool Real)
1385 {
1386 uint32 apply_stat = UNIT_STAT_CONFUSED;
1387 if( apply )
1388 {
1389 m_target->addUnitState(UNIT_STAT_CONFUSED);
1390 m_target->SetFlag(UNIT_FIELD_FLAGS,(apply_stat<<16));
1391
1392 // only at real add aura
1393 if(Real)
1394 {
1395 if (m_target->GetTypeId() == TYPEID_UNIT)
1396 (*((Creature*)m_target))->Mutate(new ConfusedMovementGenerator(*((Creature*)m_target)));
1397 }
1398 }
1399 else
1400 {
1401 m_target->clearUnitState(UNIT_STAT_CONFUSED);
1402 m_target->RemoveFlag(UNIT_FIELD_FLAGS,(apply_stat<<16));
1403
1404 // only at real remove aura
1405 if(Real)
1406 {
1407 if (m_target->GetTypeId() == TYPEID_UNIT)
1408 (*((Creature*)m_target))->MovementExpired();
1409 }
1410 }
1411 }
1412
1413 void Aura::HandleModFear(bool Apply, bool Real)
1414 {
1415 uint32 apply_stat = UNIT_STAT_FLEEING;
1416 if( Apply )
1417 {
1418 m_target->addUnitState(UNIT_STAT_FLEEING);
1419 // m_target->AttackStop();
1420
1421 m_target->SetFlag(UNIT_FIELD_FLAGS,(apply_stat<<16));
1422
1423 // only at real add aura
1424 if(Real)
1425 {
1426 WorldPacket data(SMSG_DEATH_NOTIFY_OBSOLETE, 9);
1427 data<<m_target->GetGUID();
1428 data<<uint8(0);
1429 m_target->SendMessageToSet(&data,true);
1430 }
1431 }
1432 else
1433 {
1434 m_target->clearUnitState(UNIT_STAT_FLEEING);
1435 m_target->RemoveFlag(UNIT_FIELD_FLAGS,(apply_stat<<16));
1436
1437 // only at real remove aura
1438 if(Real)
1439 {
1440 if(m_target->GetTypeId() != TYPEID_PLAYER)
1441 m_target->Attack(GetCaster());
1442 WorldPacket data(SMSG_DEATH_NOTIFY_OBSOLETE, 9);
1443 data<<m_target->GetGUID();
1444 data<<uint8(1);
1445 m_target->SendMessageToSet(&data,true);
1446 }
1447 }
1448 }
1449
1450 void Aura::HandleAuraModStun(bool apply, bool Real)
1451 {
1452 if (apply)
1453 {
1454 m_target->addUnitState(UNIT_STAT_STUNDED);
1455 m_target->SetUInt64Value (UNIT_FIELD_TARGET, 0);
1456 m_target->SetFlag(UNIT_FIELD_FLAGS, 0x40000);
1457
1458 // only at real add aura
1459 if(Real)
1460 {
1461 if(m_target->GetTypeId() != TYPEID_PLAYER)
1462 ((Creature *)m_target)->StopMoving();
1463
1464 WorldPacket data(SMSG_FORCE_MOVE_ROOT, 8);
1465 data.append(m_target->GetPackGUID());
1466 m_target->SendMessageToSet(&data,true);
1467 }
1468 }
1469 else
1470 {
1471 m_target->clearUnitState(UNIT_STAT_STUNDED);
1472 m_target->RemoveFlag(UNIT_FIELD_FLAGS, 0x40000);
1473
1474 // only at real remove aura
1475 if(Real)
1476 {
1477 WorldPacket data(SMSG_FORCE_MOVE_UNROOT, 8);
1478 data.append(m_target->GetPackGUID());
1479 m_target->SendMessageToSet(&data,true);
1480 }
1481 }
1482 }
1483
1484 void Aura::HandleModStealth(bool apply, bool Real)
1485 {
1486 if(apply)
1487 {
1488 m_target->m_stealthvalue = CalculateDamage();
1489 m_target->SetFlag(UNIT_FIELD_BYTES_1, PLAYER_STATE_FLAG_STEALTH);
1490
1491 // only at real aura add
1492 if(Real)
1493 {
1494 m_target->SetVisibility(VISIBILITY_GROUP);
1495 if(m_target->GetTypeId() == TYPEID_PLAYER)
1496 m_target->SendUpdateToPlayer((Player*)m_target);
1497 }
1498 }
1499 else
1500 {
1501 m_target->m_stealthvalue = 0;
1502 m_target->RemoveFlag(UNIT_FIELD_BYTES_1, PLAYER_STATE_FLAG_STEALTH);
1503
1504 // only at real aura remove
1505 if(Real)
1506 {
1507 SendCoolDownEvent();
1508 m_target->SetVisibility(VISIBILITY_ON);
1509 if(m_target->GetTypeId() == TYPEID_PLAYER)
1510 m_target->SendUpdateToPlayer((Player*)m_target);
1511 }
1512 }
1513 }
1514
1515 void Aura::HandleModDetect(bool apply, bool Real)
1516 {
1517 if(apply)
1518 {
1519 m_target->m_detectStealth = CalculateDamage();
1520 }
1521 else
1522 {
1523 m_target->m_detectStealth = 0;
1524 }
1525 }
1526
1527 void Aura::HandleInvisibility(bool Apply, bool Real)
1528 {
1529 if(Apply)
1530 {
1531 m_target->m_stealthvalue = CalculateDamage();
1532 m_target->SetFlag(UNIT_FIELD_BYTES_1, PLAYER_STATE_FLAG_STEALTH );
1533
1534 // only at real aura add
1535 if(Real)
1536 {
1537 m_target->SetVisibility(VISIBILITY_GROUP);
1538 if(m_target->GetTypeId() == TYPEID_PLAYER)
1539 m_target->SendUpdateToPlayer((Player*)m_target);
1540 }
1541 }
1542 else
1543 {
1544 m_target->m_stealthvalue = 0;
1545 m_target->RemoveFlag(UNIT_FIELD_BYTES_1, PLAYER_STATE_FLAG_STEALTH );
1546
1547 // only at real aura remove
1548 if(Real)
1549 {
1550 SendCoolDownEvent();
1551 m_target->SetVisibility(VISIBILITY_ON);
1552 if(m_target->GetTypeId() == TYPEID_PLAYER)
1553 m_target->SendUpdateToPlayer((Player*)m_target);
1554 }
1555 }
1556 }
1557
1558 void Aura::HandleInvisibilityDetect(bool Apply, bool Real)
1559 {
1560 if(Apply)
1561 {
1562 m_target->m_detectStealth = CalculateDamage();
1563 }
1564 else
1565 {
1566 m_target->m_detectStealth = 0;
1567 }
1568 }
1569
1570 void Aura::HandleAuraModRoot(bool apply, bool Real)
1571 {
1572 uint32 apply_stat = UNIT_STAT_ROOT;
1573 if (apply)
1574 {
1575 m_target->addUnitState(UNIT_STAT_ROOT);
1576 m_target->SetUInt64Value (UNIT_FIELD_TARGET, 0);
1577 m_target->SetFlag(UNIT_FIELD_FLAGS,(apply_stat<<16));
1578
1579 // only at real add aura
1580 if(Real)
1581 {
1582 if(m_target->GetTypeId() == TYPEID_PLAYER)
1583 {
1584 WorldPacket data(SMSG_FORCE_MOVE_ROOT, 10);
1585 data.append(m_target->GetPackGUID());
1586 data << (uint32)2;
1587 m_target->SendMessageToSet(&data,true);
1588 }
1589 else
1590 ((Creature *)m_target)->StopMoving();
1591 }
1592 }
1593 else
1594 {
1595 m_target->clearUnitState(UNIT_STAT_ROOT);
1596 m_target->RemoveFlag(UNIT_FIELD_FLAGS,(apply_stat<<16));
1597
1598 // only at real remove aura
1599 if(Real)
1600 {
1601 if(m_target->GetTypeId() == TYPEID_PLAYER)
1602 {
1603 WorldPacket data(SMSG_FORCE_MOVE_UNROOT, 10);
1604 data.append(m_target->GetPackGUID());
1605 data << (uint32)2;
1606 m_target->SendMessageToSet(&data,true);
1607 }
1608 }
1609 }
1610 }
1611
1612 void Aura::HandleAuraModSilence(bool apply, bool Real)
1613 {
1614 apply ? m_target->m_silenced = true : m_target->m_silenced = false;
1615 }
1616
1617 void Aura::HandleModThreat(bool apply, bool Real)
1618 {
1619 // only at real add/remove aura
1620 if(!Real)
1621 return;
1622
1623 if(!m_target || !m_target->isAlive())
1624 return;
1625
1626 Unit* caster = GetCaster();
1627
1628 if(!caster || !caster->isAlive())
1629 return;
1630
1631 m_target->AddHostil(m_caster_guid,apply ? float(m_modifier.m_amount) : -float(m_modifier.m_amount));
1632 }
1633
1634 /*********************************************************/
1635 /*** MODIDY SPEED ***/
1636 /*********************************************************/
1637
1638 void Aura::HandleAuraModIncreaseSpeedAlways(bool apply, bool Real)
1639 {
1640 // all applied/removed only at real aura add/remove
1641 if(!Real)
1642 return;
1643
1644 sLog.outDebug("HandleAuraModIncreaseSpeedAlways: Current Speed:%f \tmodify percent:%f", m_target->GetSpeed(MOVE_RUN),(float)m_modifier.m_amount);
1645 if(m_modifier.m_amount<=1)
1646 return;
1647
1648 float rate = (100.0f + m_modifier.m_amount)/100.0f;
1649
1650 m_target->ApplySpeedMod(MOVE_RUN, rate, false, apply );
1651 sLog.outDebug("ChangeSpeedTo:%f", m_target->GetSpeed(MOVE_RUN));
1652 }
1653
1654 void Aura::HandleAuraModIncreaseSpeed(bool apply, bool Real)
1655 {
1656 // all applied/removed only at real aura add/remove
1657 if(!Real)
1658 return;
1659
1660 sLog.outDebug("HandleAuraModIncreaseSpeed: Current Speed:%f \tmodify percent:%f", m_target->GetSpeed(MOVE_RUN),(float)m_modifier.m_amount);
1661 if(m_modifier.m_amount<=1)
1662 return;
1663
1664 float rate = (100.0f + m_modifier.m_amount)/100.0f;
1665
1666 m_target->ApplySpeedMod(MOVE_RUN, rate, true, apply );
1667
1668 sLog.outDebug("ChangeSpeedTo:%f", m_target->GetSpeed(MOVE_RUN));
1669 }
1670
1671 void Aura::HandleAuraModIncreaseMountedSpeed(bool apply, bool Real)
1672 {
1673 // all applied/removed only at real aura add/remove
1674 if(!Real)
1675 return;
1676
1677 sLog.outDebug("HandleAuraModIncreaseMountedSpeed: Current Speed:%f \tmodify percent:%f", m_target->GetSpeed(MOVE_RUN),(float)m_modifier.m_amount);
1678 if(m_modifier.m_amount<=1)
1679 return;
1680
1681 float rate = (100.0f + m_modifier.m_amount)/100.0f;
1682
1683 m_target->ApplySpeedMod(MOVE_RUN, rate, true, apply );
1684
1685 sLog.outDebug("ChangeSpeedTo:%f", m_target->GetSpeed(MOVE_RUN));
1686 }
1687
1688 void Aura::HandleAuraModDecreaseSpeed(bool apply, bool Real)
1689 {
1690 // all applied/removed only at real aura add/remove
1691 if(!Real)
1692 return;
1693
1694 sLog.outDebug("HandleAuraModDecreaseSpeed: Current Speed:%f \tmodify percent:%f", m_target->GetSpeed(MOVE_RUN),(float)m_modifier.m_amount);
1695 if(m_modifier.m_amount <= 0)
1696 { //for new spell dbc
1697 float rate = (100.0f + m_modifier.m_amount)/100.0f;
1698
1699 m_target->ApplySpeedMod(MOVE_RUN, rate, true, apply );
1700 }
1701 else
1702 { //for old spell dbc
1703 float rate = m_modifier.m_amount / 100.0f;
1704
1705 m_target->ApplySpeedMod(MOVE_RUN, rate, true, apply );
1706 }
1707 sLog.outDebug("ChangeSpeedTo:%f", m_target->GetSpeed(MOVE_RUN));
1708 }
1709
1710 void Aura::HandleAuraModIncreaseSwimSpeed(bool apply, bool Real)
1711 {
1712 // all applied/removed only at real aura add/remove
1713 if(!Real)
1714 return;
1715
1716 sLog.outDebug("HandleAuraModIncreaseSwimSpeed: Current Speed:%f \tmodify percent:%f", m_target->GetSpeed(MOVE_SWIM),(float)m_modifier.m_amount);
1717 if(m_modifier.m_amount<=1)
1718 return;
1719
1720 float rate = (100.0f + m_modifier.m_amount)/100.0f;
1721
1722 m_target->ApplySpeedMod(MOVE_SWIM, rate, true, apply );
1723
1724 sLog.outDebug("ChangeSpeedTo:%f", m_target->GetSpeed(MOVE_SWIM));
1725 }
1726
1727 /*********************************************************/
1728 /*** IMMUNITY ***/
1729 /*********************************************************/
1730
1731 void Aura::HandleModMechanicImmunity(bool apply, bool Real)
1732 {
1733 m_target->ApplySpellImmune(GetId(),IMMUNITY_MECHANIC,m_modifier.m_miscvalue,apply);
1734 }
1735
1736 void Aura::HandleAuraModEffectImmunity(bool apply, bool Real)
1737 {
1738 m_target->ApplySpellImmune(GetId(),IMMUNITY_EFFECT,m_modifier.m_miscvalue,apply);
1739 }
1740
1741 void Aura::HandleAuraModStateImmunity(bool apply, bool Real)
1742 {
1743 m_target->ApplySpellImmune(GetId(),IMMUNITY_STATE,m_modifier.m_miscvalue,apply);
1744 }
1745
1746 void Aura::HandleAuraModSchoolImmunity(bool apply, bool Real)
1747 {
1748 m_target->ApplySpellImmune(GetId(),IMMUNITY_SCHOOL,m_modifier.m_miscvalue,apply);
1749 }
1750
1751 void Aura::HandleAuraModDmgImmunity(bool apply, bool Real)
1752 {
1753 m_target->ApplySpellImmune(GetId(),IMMUNITY_DAMAGE,m_modifier.m_miscvalue,apply);
1754 }
1755
1756 void Aura::HandleAuraModDispelImmunity(bool apply, bool Real)
1757 {
1758 m_target->ApplySpellImmune(GetId(),IMMUNITY_DISPEL,m_modifier.m_miscvalue,apply);
1759 }
1760
1761 /*********************************************************/
1762 /*** MANA SHIELD ***/
1763 /*********************************************************/
1764
1765 void Aura::HandleAuraDamageShield(bool apply, bool Real)
1766 {
1767 /*if(apply)
1768 {
1769 for(std::list<struct DamageShield>::iterator i = m_target->m_damageShields.begin();i != m_target->m_damageShields.end();i++)
1770 if(i->m_spellId == GetId() && i->m_caster_guid == m_caster_guid)
1771 {
1772 m_target->m_damageShields.erase(i);
1773 break;
1774 }
1775 DamageShield* ds = new DamageShield();
1776 ds->m_caster_guid = m_caster_guid;
1777 ds->m_damage = m_modifier.m_amount;
1778 ds->m_spellId = GetId();
1779 m_target->m_damageShields.push_back((*ds));
1780 }
1781 else
1782 {
1783 for(std::list<struct DamageShield>::iterator i = m_target->m_damageShields.begin();i != m_target->m_damageShields.end();i++)
1784 if(i->m_spellId == GetId() && i->m_caster_guid == m_caster_guid)
1785 {
1786 m_target->m_damageShields.erase(i);
1787 break;
1788 }
1789 }*/
1790 }
1791
1792 void Aura::HandleAuraManaShield(bool apply, bool Real)
1793 {
1794 if (apply && !m_absorbDmg)
1795 m_absorbDmg = m_modifier.m_amount;
1796
1797 /*if(apply)
1798 {
1799
1800 for(std::list<struct DamageManaShield*>::iterator i = m_target->m_damageManaShield.begin();i != m_target->m_damageManaShield.end();i++)
1801 {
1802 if(GetId() == (*i)->m_spellId)
1803 {
1804 delete *i;
1805 m_target->m_damageManaShield.erase(i);
1806 }
1807 }
1808
1809 DamageManaShield *dms = new DamageManaShield();
1810
1811 dms->m_spellId = GetId();
1812 dms->m_modType = m_modifier.m_auraname;
1813 dms->m_totalAbsorb = m_modifier.m_amount;
1814 dms->m_currAbsorb = 0;
1815 dms->m_schoolType = m_modifier.m_miscvalue;
1816 m_target->m_damageManaShield.push_back(dms);
1817 }
1818 else
1819 {
1820 for(std::list<struct DamageManaShield*>::iterator i = m_target->m_damageManaShield.begin();i != m_target->m_damageManaShield.end();i++)
1821 {
1822 if(GetId() == (*i)->m_spellId)
1823 {
1824 delete *i;
1825 m_target->m_damageManaShield.erase(i);
1826 break;
1827 }
1828 }
1829 }*/
1830 }
1831
1832 void Aura::HandleAuraSchoolAbsorb(bool apply, bool Real)
1833 {
1834 if (apply && !m_absorbDmg)
1835 m_absorbDmg = m_modifier.m_amount;
1836 /*if(apply)
1837 {
1838
1839 for(std::list<struct DamageManaShield*>::iterator i = m_target->m_damageManaShield.begin();i != m_target->m_damageManaShield.end();i++)
1840 {
1841 if(GetId() == (*i)->m_spellId)
1842 {
1843 m_target->m_damageManaShield.erase(i);
1844 }
1845 }
1846
1847 DamageManaShield *dms = new DamageManaShield();
1848
1849 dms->m_spellId = GetId();
1850 dms->m_modType = m_modifier.m_auraname;
1851 dms->m_totalAbsorb = m_modifier.m_amount;
1852 dms->m_currAbsorb = 0;
1853 dms->m_schoolType = m_modifier.m_miscvalue;
1854 m_target->m_damageManaShield.push_back(dms);
1855 }
1856 else
1857 {
1858 for(std::list<struct DamageManaShield*>::iterator i = m_target->m_damageManaShield.begin();i != m_target->m_damageManaShield.end();i++)
1859 {
1860 if(GetId() == (*i)->m_spellId)
1861 {
1862 m_target->m_damageManaShield.erase(i);
1863 break;
1864 }
1865 }
1866 }*/
1867 }
1868
1869 /*********************************************************/
1870 /*** REFLECT SPELLS ***/
1871 /*********************************************************/
1872
1873 void Aura::HandleReflectSpells(bool apply, bool Real)
1874 {
1875 // has no immediate effect when adding / removing
1876 }
1877
1878 void Aura::HandleReflectSpellsSchool(bool apply, bool Real)
1879 {
1880 // has no immediate effect when adding / removing
1881 }
1882
1883 /*********************************************************/
1884 /*** PROC TRIGGER ***/
1885 /*********************************************************/
1886
1887 void Aura::HandleAuraProcTriggerSpell(bool apply, bool Real)
1888 {
1889 if(apply && !m_procCharges)
1890 {
1891 m_procCharges = GetSpellProto()->procCharges;
1892 if (!m_procCharges)
1893 m_procCharges = -1;
1894 }
1895 }
1896
1897 void Aura::HandleAuraProcTriggerDamage(bool apply, bool Real)
1898 {
1899 if(apply && !m_procCharges)
1900 {
1901 m_procCharges = GetSpellProto()->procCharges;
1902 if (!m_procCharges)
1903 m_procCharges = -1;
1904 }
1905 }
1906
1907 /*********************************************************/
1908 /*** PERIODIC ***/
1909 /*********************************************************/
1910
1911 void Aura::HandlePeriodicTriggerSpell(bool apply, bool Real)
1912 {
1913 if (m_periodicTimer <= 0)
1914 m_periodicTimer += m_modifier.periodictime;
1915
1916 m_isPeriodic = apply;
1917 m_isTrigger = apply;
1918 }
1919
1920 void Aura::HandlePeriodicEnergize(bool apply, bool Real)
1921 {
1922 if (m_periodicTimer <= 0)
1923 m_periodicTimer += m_modifier.periodictime;
1924
1925 m_isPeriodic = apply;
1926 }
1927
1928 void Aura::HandlePeriodicHeal(bool apply, bool Real)
1929 {
1930 if (m_periodicTimer <= 0)
1931 m_periodicTimer += m_modifier.periodictime;
1932
1933 m_isPeriodic = apply;
1934 }
1935
1936 void Aura::HandlePeriodicDamage(bool apply, bool Real)
1937 {
1938 if (m_periodicTimer <= 0)
1939 m_periodicTimer += m_modifier.periodictime;
1940
1941 m_isPeriodic = apply;
1942 }
1943
1944 void Aura::HandlePeriodicDamagePCT(bool apply, bool Real)
1945 {
1946 if (m_periodicTimer <= 0)
1947 m_periodicTimer += m_modifier.periodictime;
1948
1949 m_isPeriodic = apply;
1950 }
1951
1952 void Aura::HandleModDetectRange(bool apply, bool Real)
1953 {
1954 // has no immediate effect when adding / removing
1955 }
1956
1957 void Aura::HandlePeriodicLeech(bool apply, bool Real)
1958 {
1959 if (m_periodicTimer <= 0)
1960 m_periodicTimer += m_modifier.periodictime;
1961
1962 m_isPeriodic = apply;
1963 }
1964
1965 void Aura::HandlePeriodicManaLeech(bool apply, bool Real)
1966 {
1967 if (m_periodicTimer <= 0)
1968 m_periodicTimer += m_modifier.periodictime;
1969
1970 m_isPeriodic = apply;
1971 }
1972
1973 /*********************************************************/
1974 /*** MODITY STATES ***/
1975 /*********************************************************/
1976
1977 /********************************/
1978 /*** RESISTANCE ***/
1979 /********************************/
1980
1981 void Aura::HandleAuraModResistanceExclusive(bool apply, bool Real)
1982 {
1983 if(m_modifier.m_miscvalue < IMMUNE_SCHOOL_PHYSICAL || m_modifier.m_miscvalue > 127)
1984 {
1985 sLog.outError("WARNING: Misc Value for SPELL_AURA_MOD_BASE_RESISTANCE_PCT not valid");
1986 return;
1987 }
1988
1989 bool positive = m_modifier.m_miscvalue2 == 0;
1990
1991 for(int8 x=0;x < MAX_SPELL_SCHOOOL;x++)
1992 {
1993 if(m_modifier.m_miscvalue & int32(1<<x))
1994 {
1995 SpellSchools school = SpellSchools(SPELL_SCHOOL_NORMAL + x);
1996
1997 m_target->ApplyResistanceMod(school,m_modifier.m_amount, apply);
1998 if(m_target->GetTypeId() == TYPEID_PLAYER)
1999 ((Player*)m_target)->ApplyResistanceBuffModsMod(school,positive,m_modifier.m_amount, apply);
2000 }
2001 }
2002 }
2003
2004 void Aura::HandleAuraModResistance(bool apply, bool Real)
2005 {
2006 if(m_modifier.m_miscvalue < IMMUNE_SCHOOL_PHYSICAL || m_modifier.m_miscvalue > 127)
2007 {
2008 sLog.outError("WARNING: Misc Value for SPELL_AURA_MOD_BASE_RESISTANCE_PCT not valid");
2009 return;
2010 }
2011
2012 bool positive = m_modifier.m_miscvalue2 == 0;
2013
2014 for(int8 x=0;x < MAX_SPELL_SCHOOOL;x++)
2015 {
2016 if(m_modifier.m_miscvalue & int32(1<<x))
2017 {
2018 SpellSchools school = SpellSchools(SPELL_SCHOOL_NORMAL + x);
2019
2020 m_target->ApplyResistanceMod(school,m_modifier.m_amount, apply);
2021 if(m_target->GetTypeId() == TYPEID_PLAYER)
2022 ((Player*)m_target)->ApplyResistanceBuffModsMod(school,positive,m_modifier.m_amount, apply);
2023 }
2024 }
2025 }
2026
2027 void Aura::HandleAuraModBaseResistancePCT(bool apply, bool Real)
2028 {
2029 if(m_modifier.m_miscvalue < IMMUNE_SCHOOL_PHYSICAL || m_modifier.m_miscvalue > 127)
2030 {
2031 sLog.outError("WARNING: Misc Value for SPELL_AURA_MOD_BASE_RESISTANCE_PCT not valid");
2032 return;
2033 }
2034
2035 // only players have base stats
2036 if(m_target->GetTypeId() != TYPEID_PLAYER)
2037 return;
2038 Player *p_target = (Player*)m_target;
2039
2040 for(int8 x=0;x < MAX_SPELL_SCHOOOL;x++)
2041 {
2042 if(m_modifier.m_miscvalue & int32(1<<x))
2043 {
2044 SpellSchools school = SpellSchools(SPELL_SCHOOL_NORMAL + x);
2045 float curRes = p_target->GetResistance(school);
2046 float baseRes = curRes + p_target->GetResistanceBuffMods(school, false) - p_target->GetResistanceBuffMods(school, true);
2047 float baseRes_new = baseRes * (apply?(100.0f+m_modifier.m_amount)/100.0f : 100.0f / (100.0f+m_modifier.m_amount));
2048 p_target->SetResistance(school, curRes + baseRes_new - baseRes);
2049 }
2050 }
2051 }
2052
2053 void Aura::HandleModResistancePercent(bool apply, bool Real)
2054 {
2055 for(int8 i = 0; i < MAX_SPELL_SCHOOOL; i++)
2056 {
2057 if(m_modifier.m_miscvalue & int32(1<<i))
2058 {
2059 m_target->ApplyResistancePercentMod(SpellSchools(i), m_modifier.m_amount, apply );
2060 if(m_target->GetTypeId() == TYPEID_PLAYER)
2061 {
2062 ((Player*)m_target)->ApplyResistanceBuffModsPercentMod(SpellSchools(i),true,m_modifier.m_amount, apply);
2063 ((Player*)m_target)->ApplyResistanceBuffModsPercentMod(SpellSchools(i),false,m_modifier.m_amount, apply);
2064 }
2065 }
2066 }
2067 }
2068
2069 void Aura::HandleModBaseResistance(bool apply, bool Real)
2070 {
2071 // only players have base stats
2072 if(m_target->GetTypeId() != TYPEID_PLAYER)
2073 return;
2074 Player *p_target = (Player*)m_target;
2075
2076 for(int i = 0; i < MAX_SPELL_SCHOOOL; i++)
2077 if(m_modifier.m_miscvalue & (1<<i))
2078 p_target->ApplyResistanceMod(SpellSchools(SPELL_SCHOOL_NORMAL + i),m_modifier.m_amount, apply);
2079 }
2080
2081 /********************************/
2082 /*** STAT ***/
2083 /********************************/
2084
2085 void Aura::HandleAuraModStat(bool apply, bool Real)
2086 {
2087 if (m_modifier.m_miscvalue < -1 || m_modifier.m_miscvalue > 4)
2088 {
2089 sLog.outError("WARNING: Misc Value for SPELL_AURA_MOD_STAT not valid");
2090 return;
2091 }
2092
2093 for(int32 i = 0; i < 5; i++)
2094 {
2095 if (m_modifier.m_miscvalue == -1 || m_modifier.m_miscvalue == i)
2096 {
2097 m_target->ApplyStatMod(Stats(i), m_modifier.m_amount,apply);
2098 if(m_target->GetTypeId() == TYPEID_PLAYER)
2099 {
2100 if (m_modifier.m_miscvalue2 == 0)
2101 ((Player*)m_target)->ApplyPosStatMod(Stats(i),m_modifier.m_amount,apply);
2102 else
2103 ((Player*)m_target)->ApplyNegStatMod(Stats(i),m_modifier.m_amount,apply);
2104 }
2105 }
2106 }
2107 }
2108
2109 void Aura::HandleModPercentStat(bool apply, bool Real)
2110 {
2111 if (m_modifier.m_miscvalue < -1 || m_modifier.m_miscvalue > 4)
2112 {
2113 sLog.outError("WARNING: Misc Value for SPELL_AURA_MOD_PERCENT_STAT not valid");
2114 return;
2115 }
2116
2117 // only players have base stats
2118 if (m_target->GetTypeId() != TYPEID_PLAYER)
2119 return;
2120 Player *p_target = (Player*)m_target;
2121
2122 for (int32 i = 0; i < 5; i++)
2123 {
2124 if(m_modifier.m_miscvalue == i || m_modifier.m_miscvalue == -1)
2125 {
2126 float curStat = p_target->GetStat(Stats(i));
2127 float baseStat = curStat + p_target->GetNegStat(Stats(i)) - p_target->GetPosStat(Stats(i));
2128 float baseStat_new = baseStat * (apply?(100.0f+m_modifier.m_amount)/100.0f : 100.0f / (100.0f+m_modifier.m_amount));
2129 p_target->SetStat(Stats(i), curStat + baseStat_new - baseStat);
2130 p_target->ApplyCreateStatPercentMod(Stats(i), m_modifier.m_amount, apply );
2131 }
2132 }
2133 }
2134
2135 void Aura::HandleModTotalPercentStat(bool apply, bool Real)
2136 {
2137 if (m_modifier.m_miscvalue < -1 || m_modifier.m_miscvalue > 4)
2138 {
2139 sLog.outError("WARNING: Misc Value for SPELL_AURA_MOD_PERCENT_STAT not valid");
2140 return;
2141 }
2142
2143 for (int32 i = 0; i < 5; i++)
2144 {
2145 if(m_modifier.m_miscvalue == i || m_modifier.m_miscvalue == -1)
2146 {
2147 m_target->ApplyStatPercentMod(Stats(i), m_modifier.m_amount, apply );
2148 if (m_target->GetTypeId() == TYPEID_PLAYER)
2149 {
2150 ((Player*)m_target)->ApplyPosStatPercentMod(Stats(i), m_modifier.m_amount, apply );
2151 ((Player*)m_target)->ApplyNegStatPercentMod(Stats(i), m_modifier.m_amount, apply );
2152 ((Player*)m_target)->ApplyCreateStatPercentMod(Stats(i), m_modifier.m_amount, apply );
2153 }
2154 }
2155 }
2156 }
2157
2158 /********************************/
2159 /*** HEAL & ENERGIZE ***/
2160 /********************************/
2161 void Aura::HandleAuraModTotalHealthPercentRegen(bool apply, bool Real)
2162 {
2163 /*
2164 Need additional checking for auras who reduce or increase healing, magic effect like Dumpen Magic,
2165 so this aura not fully working.
2166 */
2167 if ((GetSpellProto()->AuraInterruptFlags & (1 << 18)) != 0)
2168 {
2169 m_target->ApplyModFlag(UNIT_FIELD_BYTES_1,PLAYER_STATE_SIT,apply);
2170 }
2171
2172 if(apply && m_periodicTimer <= 0)
2173 {
2174 m_periodicTimer += m_modifier.periodictime;
2175 float modifier = GetSpellProto()->EffectBasePoints[m_effIndex]+1;
2176 m_modifier.m_amount = uint32(m_target->GetMaxHealth() * modifier/100);
2177
2178 if(m_target->GetHealth() < m_target->GetMaxHealth())
2179 m_target->PeriodicAuraLog(m_target, GetSpellProto(), &m_modifier);
2180 }
2181
2182 m_isPeriodic = apply;
2183 }
2184
2185 void Aura::HandleAuraModTotalManaPercentRegen(bool apply, bool Real)
2186 {
2187 if ((GetSpellProto()->AuraInterruptFlags & (1 << 18)) != 0)
2188 m_target->ApplyModFlag(UNIT_FIELD_BYTES_1,PLAYER_STATE_SIT,apply);
2189
2190 if(apply && m_periodicTimer <= 0 && m_target->getPowerType() == POWER_MANA)
2191 {
2192 m_periodicTimer += m_modifier.periodictime;
2193 if (m_modifier.m_amount)
2194 {
2195 float modifier = GetSpellProto()->EffectBasePoints[m_effIndex]+1;
2196 // take percent (m_modifier.m_amount) max mana
2197 m_modifier.m_amount = uint32((m_target->GetMaxPower(POWER_MANA) * modifier)/100);
2198 }
2199
2200 if(m_target->GetPower(POWER_MANA) < m_target->GetMaxPower(POWER_MANA))
2201 m_target->PeriodicAuraLog(m_target, GetSpellProto(), &m_modifier);
2202 }
2203
2204 m_isPeriodic = apply;
2205 }
2206
2207 void Aura::HandleModRegen(bool apply, bool Real) // eating
2208 {
2209 if ((GetSpellProto()->AuraInterruptFlags & (1 << 18)) != 0)
2210 m_target->ApplyModFlag(UNIT_FIELD_BYTES_1,PLAYER_STATE_SIT,apply);
2211
2212 if(apply && m_periodicTimer <= 0)
2213 {
2214 m_periodicTimer += 5000;
2215 m_target->ModifyHealth(m_modifier.m_amount);
2216 }
2217
2218 m_isPeriodic = apply;
2219 }
2220
2221 void Aura::HandleModPowerRegen(bool apply, bool Real) // drinking
2222 {
2223 if ((GetSpellProto()->AuraInterruptFlags & (1 << 18)) != 0)
2224 m_target->ApplyModFlag(UNIT_FIELD_BYTES_1,PLAYER_STATE_SIT,apply);
2225
2226 if(apply && m_periodicTimer <= 0)
2227 {
2228 m_periodicTimer += 5000;
2229 Powers pt = m_target->getPowerType();
2230 // Prevent rage regeneration in combat with rage loss slowdown warrior talant and 0<->1 switching range out combat.
2231 if( !(pt == POWER_RAGE && (m_target->isInCombat() || m_target->GetPower(POWER_RAGE) == 0)) )
2232 {
2233 m_target->ModifyPower(pt, m_modifier.m_amount);
2234 }
2235 }
2236
2237 m_isPeriodic = apply;
2238 }
2239
2240 void Aura::HandleAuraModIncreaseHealth(bool apply, bool Real)
2241 {
2242 m_target->ApplyMaxHealthMod(m_modifier.m_amount,apply);
2243 }
2244
2245 void Aura::HandleAuraModIncreaseEnergy(bool apply, bool Real)
2246 {
2247 Powers powerType = m_target->getPowerType();
2248 if(int32(powerType) != m_modifier.m_miscvalue)
2249 return;
2250
2251 m_target->ApplyMaxPowerMod(powerType, m_modifier.m_amount,apply);
2252 }
2253
2254 void Aura::HandleAuraModIncreaseEnergyPercent(bool apply, bool Real)
2255 {
2256 Powers powerType = m_target->getPowerType();
2257 if(int32(powerType) != m_modifier.m_miscvalue)
2258 return;
2259
2260 m_target->ApplyMaxPowerPercentMod(powerType,m_modifier.m_amount,apply);
2261 sLog.outDetail("MaxPowerPercentMod %s %d",(apply ? "+" : "-"), m_modifier.m_amount);
2262 }
2263
2264 void Aura::HandleAuraModIncreaseHealthPercent(bool apply, bool Real)
2265 {
2266 m_target->ApplyMaxHealthPercentMod(m_modifier.m_amount,apply);
2267 }
2268
2269 /********************************/
2270 /*** FIGHT ***/
2271 /********************************/
2272
2273 void Aura::HandleAuraModParryPercent(bool apply, bool Real)
2274 {
2275 if(m_target->GetTypeId()!=TYPEID_PLAYER)
2276 return;
2277
2278 m_target->ApplyModFloatValue(PLAYER_PARRY_PERCENTAGE,m_modifier.m_amount,apply);
2279 }
2280
2281 void Aura::HandleAuraModDodgePercent(bool apply, bool Real)
2282 {
2283 if(m_target->GetTypeId()!=TYPEID_PLAYER)
2284 return;
2285
2286 m_target->ApplyModFloatValue(PLAYER_DODGE_PERCENTAGE,m_modifier.m_amount,apply);
2287 }
2288
2289 void Aura::HandleAuraModBlockPercent(bool apply, bool Real)
2290 {
2291 if(m_target->GetTypeId()!=TYPEID_PLAYER)
2292 return;
2293
2294 m_target->ApplyModFloatValue(PLAYER_BLOCK_PERCENTAGE,m_modifier.m_amount,apply);
2295 }
2296
2297 void Aura::HandleAuraModCritPercent(bool apply, bool Real)
2298 {
2299 if(m_target->GetTypeId()!=TYPEID_PLAYER)
2300 return;
2301
2302 m_target->ApplyModFloatValue(PLAYER_CRIT_PERCENTAGE,m_modifier.m_amount,apply);
2303 }
2304
2305 void Aura::HandleModShieldBlock(bool apply, bool Real)
2306 {
2307 if(m_target->GetTypeId() != TYPEID_PLAYER)
2308 return;
2309
2310 ((Player*)m_target)->ApplyBlockValueMod(m_modifier.m_amount,apply);
2311 }
2312
2313 void Aura::HandleModHitChance(bool Apply, bool Real)
2314 {
2315 m_target->m_modHitChance = Apply?m_modifier.m_amount:0;
2316 }
2317
2318 void Aura::HandleModSpellHitChance(bool Apply, bool Real)
2319 {
2320 m_target->m_modSpellHitChance = Apply?m_modifier.m_amount:0;
2321 }
2322
2323 void Aura::HandleModSpellCritChance(bool Apply, bool Real)
2324 {
2325 m_target->m_baseSpellCritChance += Apply?m_modifier.m_amount:(-m_modifier.m_amount);
2326 }
2327
2328 void Aura::HandleModSpellCritChanceShool(bool apply, bool Real)
2329 {
2330 // has no immediate effect when adding / removing
2331 }
2332
2333 /********************************/
2334 /*** ATTACK SPEED ***/
2335 /********************************/
2336
2337 void Aura::HandleModCastingSpeed(bool apply, bool Real)
2338 {
2339 m_target->m_modCastSpeedPct += apply ? m_modifier.m_amount : (-m_modifier.m_amount);
2340 }
2341
2342 void Aura::HandleModAttackSpeed(bool apply, bool Real)
2343 {
2344 if(!m_target || !m_target->isAlive() )
2345 return;
2346
2347 m_target->ApplyAttackTimePercentMod(BASE_ATTACK,m_modifier.m_amount,apply);
2348 }
2349
2350 void Aura::HandleHaste(bool apply, bool Real)
2351 {
2352
2353 if(m_modifier.m_amount >= 0)
2354 {
2355 // v*(1+percent/100)
2356 m_target->ApplyAttackTimePercentMod(BASE_ATTACK, m_modifier.m_amount,apply);
2357 m_target->ApplyAttackTimePercentMod(OFF_ATTACK, m_modifier.m_amount,apply);
2358
2359 if(m_target->GetTypeId()==TYPEID_PLAYER)
2360 ((Player*)m_target)->_ApplyAmmoBonuses(false);
2361
2362 m_target->ApplyAttackTimePercentMod(RANGED_ATTACK,m_modifier.m_amount,apply);
2363
2364 if(m_target->GetTypeId()==TYPEID_PLAYER)
2365 ((Player*)m_target)->_ApplyAmmoBonuses(true);
2366 }
2367 else
2368 {
2369 // v/(1+abs(percent)/100)
2370 m_target->ApplyAttackTimePercentMod(BASE_ATTACK, -m_modifier.m_amount,!apply);
2371 m_target->ApplyAttackTimePercentMod(OFF_ATTACK, -m_modifier.m_amount,!apply);
2372
2373 if(m_target->GetTypeId()==TYPEID_PLAYER)
2374 ((Player*)m_target)->_ApplyAmmoBonuses(false);
2375
2376 m_target->ApplyAttackTimePercentMod(RANGED_ATTACK,-m_modifier.m_amount,!apply);
2377
2378 if(m_target->GetTypeId()==TYPEID_PLAYER)
2379 ((Player*)m_target)->_ApplyAmmoBonuses(true);
2380 }
2381 }
2382
2383 void Aura::HandleAuraModRangedHaste(bool apply, bool Real)
2384 {
2385 if(m_target->GetTypeId()==TYPEID_PLAYER)
2386 ((Player*)m_target)->_ApplyAmmoBonuses(false);
2387
2388 if(m_modifier.m_amount >= 0)
2389 m_target->ApplyAttackTimePercentMod(RANGED_ATTACK, m_modifier.m_amount, apply);
2390 else
2391 m_target->ApplyAttackTimePercentMod(RANGED_ATTACK, -m_modifier.m_amount, !apply);
2392
2393 if(m_target->GetTypeId()==TYPEID_PLAYER)
2394 ((Player*)m_target)->_ApplyAmmoBonuses(true);
2395 }
2396
2397 void Aura::HandleRangedAmmoHaste(bool apply, bool Real)
2398 {
2399 if(m_target->GetTypeId() != TYPEID_PLAYER)
2400 return;
2401 ((Player*)m_target)->_ApplyAmmoBonuses(false);
2402 m_target->ApplyAttackTimePercentMod(RANGED_ATTACK,m_modifier.m_amount, apply);
2403 ((Player*)m_target)->_ApplyAmmoBonuses(true);
2404 }
2405
2406 /********************************/
2407 /*** ATTACK POWER ***/
2408 /********************************/
2409
2410 void Aura::HandleAuraModAttackPower(bool apply, bool Real)
2411 {
2412 m_target->ApplyModUInt32Value(UNIT_FIELD_ATTACK_POWER_MODS, m_modifier.m_amount, apply);
2413 }
2414
2415 void Aura::HandleAuraModRangedAttackPower(bool apply, bool Real)
2416 {
2417 m_target->ApplyModUInt32Value(UNIT_FIELD_RANGED_ATTACK_POWER_MODS,m_modifier.m_amount,apply);
2418 }
2419
2420 /********************************/
2421 /*** DAMAGE BONUS ***/
2422 /********************************/
2423
2424 void Aura::HandleModDamagePCTTaken(bool apply, bool Real)
2425 {
2426 m_target->m_modDamagePCT = apply ? m_modifier.m_amount : 0;
2427 }
2428
2429 void Aura::HandleModPCTRegen(bool apply, bool Real)
2430 {
2431 // has no immediate effect when adding / removing
2432 }
2433
2434 void Aura::HandleModCreatureAttackPower(bool apply, bool Real)
2435 {
2436 // has no immediate effect when adding / removing
2437 }
2438
2439 void Aura::HandleModDamageDoneCreature(bool apply, bool Real)
2440 {
2441 // has no immediate effect when adding / removing
2442 }
2443
2444 void Aura::HandleModDamageDone(bool apply, bool Real)
2445 {
2446 // physical damage modifier is applied to damage fields
2447 if(m_modifier.m_miscvalue & (int32)(1<<SPELL_SCHOOL_NORMAL))
2448 {
2449 m_target->ApplyModFloatValue(UNIT_FIELD_MINDAMAGE,m_modifier.m_amount,apply);
2450 m_target->ApplyModFloatValue(UNIT_FIELD_MAXDAMAGE,m_modifier.m_amount,apply);
2451 // TODO: add ranged support and maybe offhand ?
2452 // not completely sure how this should work
2453 if(m_target->GetTypeId() == TYPEID_PLAYER)
2454 {
2455 if(m_modifier.m_miscvalue2)
2456 m_target->ApplyModFloatValue(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG,m_modifier.m_amount,apply);
2457 else
2458 m_target->ApplyModFloatValue(PLAYER_FIELD_MOD_DAMAGE_DONE_POS,m_modifier.m_amount,apply);
2459 }
2460 }
2461 }
2462
2463 void Aura::HandleModDamageTaken(bool apply, bool Real)
2464 {
2465 // has no immediate effect when adding / removing
2466 }
2467
2468 void Aura::HandleModDamagePercentDone(bool apply, bool Real)
2469 {
2470 sLog.outDebug("AURA MOD DAMAGE type:%u type2:%u", m_modifier.m_miscvalue, m_modifier.m_miscvalue2);
2471
2472 // FIX ME: This is wrong code.
2473 // It not work with 20218 18791 spells
2474
2475 // m_modifier.m_miscvalue is bitmask of spell schools
2476 // 1 ( 0-bit ) - normal school damage
2477 // 126 - full bitmask all magic damages
2478 // 127 - full bitmask any damages
2479 //
2480 // mods must be applied base at equiped weapon class and subclass comparison
2481 // with spell->EquippedItemClass and EquippedItemSubClassMask and EquippedItemInventoryTypeMask
2482 // m_modifier.m_miscvalue comparison with item generated damage types
2483 if (!m_target)
2484 return;
2485
2486 if((m_modifier.m_miscvalue & 1) != 0)
2487 {
2488 if (GetSpellProto()->EquippedItemClass == -1 || m_target->GetTypeId() != TYPEID_PLAYER)
2489 {
2490 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MINRANGEDDAMAGE, m_modifier.m_amount, apply );
2491 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE, m_modifier.m_amount, apply );
2492 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE, m_modifier.m_amount, apply );
2493 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE, m_modifier.m_amount, apply );
2494 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MINDAMAGE, m_modifier.m_amount, apply );
2495 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MAXDAMAGE, m_modifier.m_amount, apply );
2496 }
2497 else
2498 {
2499 Item* pItem = ((Player*)m_target)->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);
2500 if (pItem)
2501 {
2502 if (pItem->IsFitToSpellRequirements(GetSpellProto()))
2503 {
2504 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MINDAMAGE, m_modifier.m_amount, apply );
2505 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MAXDAMAGE, m_modifier.m_amount, apply );
2506 }
2507 }
2508 pItem = ((Player*)m_target)->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
2509 if (pItem)
2510 {
2511 if (pItem->IsFitToSpellRequirements(GetSpellProto()))
2512 {
2513 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE, m_modifier.m_amount, apply );
2514 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE, m_modifier.m_amount, apply );
2515 }
2516 }
2517 pItem = ((Player*)m_target)->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_RANGED);
2518 if (pItem)
2519 {
2520 if (pItem->IsFitToSpellRequirements(GetSpellProto()))
2521 {
2522 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MINRANGEDDAMAGE, m_modifier.m_amount, apply );
2523 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE, m_modifier.m_amount, apply );
2524 }
2525 }
2526 }
2527 }
2528
2529 // Magic damage percent modifiers implemented in Unit::SpellDamageBonus
2530 }
2531
2532 /********************************/
2533 /*** POWER COST ***/
2534 /********************************/
2535
2536 void Aura::HandleModPowerCost(bool apply, bool Real)
2537 {
2538 m_target->ApplyModUInt32Value(UNIT_FIELD_POWER_COST_MODIFIER, m_modifier.m_amount, apply);
2539 }
2540
2541 void Aura::HandleModPowerCostSchool(bool apply, bool Real)
2542 {
2543 // has no immediate effect when adding / removing
2544 }
2545
2546 /*********************************************************/
2547 /*** OTHERS ***/
2548 /*********************************************************/
2549
2550 void Aura::HandleModReputationGain(bool apply, bool Real)
2551 {
2552 // has no immediate effect when adding / removing
2553 }
2554
2555 void Aura::SendCoolDownEvent()
2556 {
2557 Unit* caster = GetCaster();
2558 if(caster)
2559 {
2560 WorldPacket data(SMSG_COOLDOWN_EVENT, (4+8+4));
2561 data << uint32(m_spellId) << m_caster_guid;
2562 data << uint32(0); //CoolDown Time ?
2563 caster->SendMessageToSet(&data,true);
2564 }
2565 }
2566
2567 // FIX-ME!!
2568 void HandleTriggerSpellEvent(void *obj)
2569 {
2570 Aura *Aur = ((Aura*)obj);
2571 if(!Aur)
2572 return;
2573 SpellEntry const *spellInfo = sSpellStore.LookupEntry(Aur->GetSpellProto()->EffectTriggerSpell[Aur->GetEffIndex()]);
2574
2575 if(!spellInfo)
2576 {
2577 sLog.outError("WORLD: unknown spell id %i\n", Aur->GetSpellProto()->EffectTriggerSpell[Aur->GetEffIndex()]);
2578 return;
2579 }
2580
2581 Spell spell(Aur->GetCaster(), spellInfo, true, Aur);
2582 SpellCastTargets targets;
2583 targets.setUnitTarget(Aur->GetTarget());
2584 //WorldPacket dump;
2585 //dump.Initialize(0);
2586 //dump << uint16(2) << GetUInt32Value(UNIT_FIELD_CHANNEL_OBJECT) << GetUInt32Value(UNIT_FIELD_CHANNEL_OBJECT+1);
2587 //targets.read(&dump,this);
2588 spell.prepare(&targets);
2589
2590 /*else if(m_spellProto->EffectApplyAuraName[i] == 23)
2591 {
2592 unitTarget->tmpAura->SetPeriodicTriggerSpell(m_spellProto->EffectTriggerSpell[i],m_spellProto->EffectAmplitude[i]);
2593 }*/
2594 }
2595
2596 void HandleDOTEvent(void *obj)
2597 {
2598 Aura *Aur = ((Aura*)obj);
2599 //Aur->GetCaster()->AddPeriodicAura(Aur);
2600 if(Unit* caster = Aur->GetCaster())
2601 caster->PeriodicAuraLog(Aur->GetTarget(), Aur->GetSpellProto(), Aur->GetModifier());
2602 }
2603
2604 void HandleHealEvent(void *obj)
2605 {
2606 Aura *Aur = ((Aura*)obj);
2607 if(Unit* caster = Aur->GetCaster())
2608 Aur->GetTarget()->PeriodicAuraLog(caster, Aur->GetSpellProto(), Aur->GetModifier());
2609 }
2610
2611 void Aura::HandleShapeshiftBoosts(bool apply)
2612 {
2613 if(!m_target)
2614 return;
2615
2616 uint32 spellId = 0;
2617 uint32 spellId2 = 0;
2618
2619 switch(GetModifier()->m_miscvalue)
2620 {
2621 case FORM_CAT:
2622 spellId = 3025;
2623 break;
2624 case FORM_TREE:
2625 spellId = 3122;
2626 break;
2627 case FORM_TRAVEL:
2628 spellId = 5419;
2629 break;
2630 case FORM_AQUA:
2631 spellId = 5421;
2632 break;
2633 case FORM_BEAR:
2634 spellId = 1178;
2635 break;
2636 case FORM_DIREBEAR:
2637 spellId = 9635;
2638 break;
2639 case FORM_CREATUREBEAR:
2640 spellId = 2882;
2641 break;
2642 case FORM_BATTLESTANCE:
2643 spellId = 21156;
2644 break;
2645 case FORM_DEFENSIVESTANCE:
2646 spellId = 7376;
2647 break;
2648 case FORM_BERSERKERSTANCE:
2649 spellId = 7381;
2650 break;
2651 case FORM_MOONKIN:
2652 spellId = 24905;
2653 // aura from effect trigger spell
2654 spellId2 = 24907;
2655 break;
2656 case FORM_GHOSTWOLF:
2657 case FORM_AMBIENT:
2658 case FORM_GHOUL:
2659 case FORM_SHADOW:
2660 case FORM_STEALTH:
2661 spellId = 0;
2662 break;
2663 }
2664
2665 uint32 form = GetModifier()->m_miscvalue-1;
2666
2667 if(apply)
2668 {
2669 if(m_target->m_ShapeShiftForm)
2670 {
2671 m_target->RemoveAurasDueToSpell(m_target->m_ShapeShiftForm);
2672 }
2673
2674 if (spellId) m_target->CastSpell(m_target, spellId, true);
2675 if (spellId2) m_target->CastSpell(m_target, spellId2, true);
2676
2677 if(m_target->GetTypeId() == TYPEID_PLAYER)
2678 {
2679 const PlayerSpellMap& sp_list = ((Player *)m_target)->GetSpellMap();
2680 for (PlayerSpellMap::const_iterator itr = sp_list.begin(); itr != sp_list.end(); ++itr)
2681 {
2682 if(itr->second->state == PLAYERSPELL_REMOVED) continue;
2683 SpellEntry const *spellInfo = sSpellStore.LookupEntry(itr->first);
2684 if (!spellInfo || !IsPassiveSpell(itr->first)) continue;
2685 if (spellInfo->Stances & (1<<form))
2686 m_target->CastSpell(m_target, itr->first, true);
2687 }
2688 }
2689 }
2690 else
2691 {
2692 m_target->RemoveAurasDueToSpell(spellId);
2693 m_target->RemoveAurasDueToSpell(spellId2);
2694
2695 Unit::AuraMap& tAuras = m_target->GetAuras();
2696 for (Unit::AuraMap::iterator itr = tAuras.begin(); itr != tAuras.end();)
2697 {
2698 if ((*itr).second->GetSpellProto()->Stances & uint32(1<<form))
2699 m_target->RemoveAura(itr);
2700 else
2701 ++itr;
2702 }
2703 }
2704
2705 double healthPercentage = (double)m_target->GetHealth() / (double)m_target->GetMaxHealth();
2706 m_target->SetHealth(uint32(ceil((double)m_target->GetMaxHealth() * healthPercentage)));
2707 }
2708
2709 void Aura::HandleAuraEmpathy(bool apply, bool Real)
2710 {
2711 if(m_target->GetTypeId()!=TYPEID_UNIT)
2712 return;
2713
2714 CreatureInfo const * ci = objmgr.GetCreatureTemplate(m_target->GetEntry());
2715 if(ci && ci->type == CREATURE_TYPE_BEAST)
2716 {
2717 m_target->ApplyModUInt32Value(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_SPECIALINFO, apply);
2718 }
2719 }
Open Source reference implementation for a MMORPG server system