?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[1852] Applied MaNGOS coding style (see [source:trunk/bcpp.cfg bcpp.cfg]).
[mangos-git.git] / src / game / SpellAuras.cpp
blob9abe9d3938eafeadb78732aeca1e2163b985795d
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
42 pAuraHandler AuraHandler[TOTAL_AURAS]=
43 {
44 &Aura::HandleNULL, //SPELL_AURA_NONE
45 &Aura::HandleNULL, //SPELL_AURA_BIND_SIGHT
46 &Aura::HandleNULL, //SPELL_AURA_MOD_POSSESS = 2,
47 &Aura::HandlePeriodicDamage, //SPELL_AURA_PERIODIC_DAMAGE = 3,
48 &Aura::HandleNULL, //SPELL_AURA_DUMMY //missing 4
49 &Aura::HandleModConfuse, //SPELL_AURA_MOD_CONFUSE = 5,
50 &Aura::HandleNULL, //SPELL_AURA_MOD_CHARM = 6,
51 &Aura::HandleModFear, //SPELL_AURA_MOD_FEAR = 7,
52 &Aura::HandlePeriodicHeal, //SPELL_AURA_PERIODIC_HEAL = 8,
53 &Aura::HandleModAttackSpeed, //SPELL_AURA_MOD_ATTACKSPEED = 9,
54 &Aura::HandleModThreat, //SPELL_AURA_MOD_THREAT = 10,
55 &Aura::HandleNULL, //SPELL_AURA_MOD_TAUNT = 11,
56 &Aura::HandleAuraModStun, //SPELL_AURA_MOD_STUN = 12,
57 &Aura::HandleNULL, //SPELL_AURA_MOD_DAMAGE_DONE = 13,
58 &Aura::HandleNULL, //SPELL_AURA_MOD_DAMAGE_TAKEN = 14,
59 &Aura::HandleAuraDamageShield, //SPELL_AURA_DAMAGE_SHIELD = 15,
60 &Aura::HandleModStealth, //SPELL_AURA_MOD_STEALTH = 16,
61 &Aura::HandleModDetect, //SPELL_AURA_MOD_DETECT = 17,
62 &Aura::HandleInvisibility, //SPELL_AURA_MOD_INVISIBILITY = 18,
63 &Aura::HandleInvisibilityDetect, //SPELL_AURA_MOD_INVISIBILITY_DETECTION = 19,
64 &Aura::HandleNULL, //missing 20,
65 &Aura::HandleNULL, //missing 21
66 &Aura::HandleAuraModResistance, //SPELL_AURA_MOD_RESISTANCE = 22,
67 &Aura::HandlePeriodicTriggerSpell, //SPELL_AURA_PERIODIC_TRIGGER_SPELL = 23,
68 &Aura::HandlePeriodicEnergize, //SPELL_AURA_PERIODIC_ENERGIZE = 24,
69 &Aura::HandleNULL, //SPELL_AURA_MOD_PACIFY = 25,
70 &Aura::HandleAuraModRoot, //SPELL_AURA_MOD_ROOT = 26,
71 &Aura::HandleAuraModSilence, //SPELL_AURA_MOD_SILENCE = 27,
72 &Aura::HandleReflectSpells, //SPELL_AURA_REFLECT_SPELLS = 28,
73 &Aura::HandleAuraModStat, //SPELL_AURA_MOD_STAT = 29,
74 &Aura::HandleAuraModSkill, //SPELL_AURA_MOD_SKILL = 30,
75 &Aura::HandleAuraModIncreaseSpeed, //SPELL_AURA_MOD_INCREASE_SPEED = 31,
76 &Aura::HandleAuraModIncreaseMountedSpeed, //SPELL_AURA_MOD_INCREASE_MOUNTED_SPEED = 32,
77 &Aura::HandleAuraModDecreaseSpeed, //SPELL_AURA_MOD_DECREASE_SPEED = 33,
78 &Aura::HandleAuraModIncreaseHealth, //SPELL_AURA_MOD_INCREASE_HEALTH = 34,
79 &Aura::HandleAuraModIncreaseEnergy, //SPELL_AURA_MOD_INCREASE_ENERGY = 35,
80 &Aura::HandleAuraModShapeshift, //SPELL_AURA_MOD_SHAPESHIFT = 36,
81 &Aura::HandleAuraModEffectImmunity, //SPELL_AURA_EFFECT_IMMUNITY = 37,
82 &Aura::HandleAuraModStateImmunity, //SPELL_AURA_STATE_IMMUNITY = 38,
83 &Aura::HandleAuraModSchoolImmunity, //SPELL_AURA_SCHOOL_IMMUNITY = 39,
84 &Aura::HandleAuraModDmgImmunity, //SPELL_AURA_DAMAGE_IMMUNITY = 40,
85 &Aura::HandleAuraModDispelImmunity, //SPELL_AURA_DISPEL_IMMUNITY = 41,
86 &Aura::HandleAuraProcTriggerSpell, //SPELL_AURA_PROC_TRIGGER_SPELL = 42,
87 &Aura::HandleAuraProcTriggerDamage, //SPELL_AURA_PROC_TRIGGER_DAMAGE = 43,
88 &Aura::HandleAuraTracCreatures, //SPELL_AURA_TRACK_CREATURES = 44,
89 &Aura::HandleAuraTracResources, //SPELL_AURA_TRACK_RESOURCES = 45,
90 &Aura::HandleNULL, //SPELL_AURA_MOD_PARRY_SKILL = 46, obsolete?
91 &Aura::HandleAuraModParryPercent, //SPELL_AURA_MOD_PARRY_PERCENT = 47,
92 &Aura::HandleNULL, //SPELL_AURA_MOD_DODGE_SKILL = 48, obsolete?
93 &Aura::HandleAuraModDodgePercent, //SPELL_AURA_MOD_DODGE_PERCENT = 49,
94 &Aura::HandleNULL, //SPELL_AURA_MOD_BLOCK_SKILL = 50, obsolete?
95 &Aura::HandleAuraModBlockPercent, //SPELL_AURA_MOD_BLOCK_PERCENT = 51,
96 &Aura::HandleAuraModCritPercent, //SPELL_AURA_MOD_CRIT_PERCENT = 52,
97 &Aura::HandlePeriodicLeech, //SPELL_AURA_PERIODIC_LEECH = 53,
98 &Aura::HandleModHitChance, //SPELL_AURA_MOD_HIT_CHANCE = 54,
99 &Aura::HandleModSpellHitChance, //SPELL_AURA_MOD_SPELL_HIT_CHANCE = 55,
100 &Aura::HandleAuraTransform, //SPELL_AURA_TRANSFORM = 56,
101 &Aura::HandleModSpellCritChance, //SPELL_AURA_MOD_SPELL_CRIT_CHANCE = 57,
102 &Aura::HandleAuraModIncreaseSwimSpeed, //SPELL_AURA_MOD_INCREASE_SWIM_SPEED = 58,
103 &Aura::HandleModDamageDoneCreature, //SPELL_AURA_MOD_DAMAGE_DONE_CREATURE = 59,
104 &Aura::HandleNULL, //SPELL_AURA_MOD_PACIFY_SILENCE = 60,
105 &Aura::HandleAuraModScale, //SPELL_AURA_MOD_SCALE = 61,
106 &Aura::HandleNULL, //SPELL_AURA_PERIODIC_HEALTH_FUNNEL = 62,
107 &Aura::HandleNULL, //SPELL_AURA_PERIODIC_MANA_FUNNEL = 63,
108 &Aura::HandlePeriodicManaLeech, //SPELL_AURA_PERIODIC_MANA_LEECH = 64,
109 &Aura::HandleNULL, //SPELL_AURA_MOD_CASTING_SPEED = 65,
110 &Aura::HandleNULL, //SPELL_AURA_FEIGN_DEATH = 66,
111 &Aura::HandleNULL, //SPELL_AURA_MOD_DISARM = 67,
112 &Aura::HandleNULL, //SPELL_AURA_MOD_STALKED = 68,
113 &Aura::HandleAuraSchoolAbsorb, //SPELL_AURA_SCHOOL_ABSORB = 69,
114 &Aura::HandleNULL, //SPELL_AURA_EXTRA_ATTACKS = 70,
115 &Aura::HandleModSpellCritChanceShool, //SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL = 71,
116 &Aura::HandleNULL, //SPELL_AURA_MOD_POWER_COST = 72,
117 &Aura::HandleNULL, //SPELL_AURA_MOD_POWER_COST_SCHOOL = 73,
118 &Aura::HandleReflectSpellsSchool, //SPELL_AURA_REFLECT_SPELLS_SCHOOL = 74,
119 &Aura::HandleNULL, //SPELL_AURA_MOD_LANGUAGE = 75,
120 &Aura::HandleNULL, //SPELL_AURA_FAR_SIGHT = 76,
121 &Aura::HandleModMechanicImmunity, //SPELL_AURA_MECHANIC_IMMUNITY = 77,
122 &Aura::HandleAuraMounted, //SPELL_AURA_MOUNTED = 78,
123 &Aura::HandleModDamagePercentDone, //SPELL_AURA_MOD_DAMAGE_PERCENT_DONE = 79,
124 &Aura::HandleModPercentStat, //SPELL_AURA_MOD_PERCENT_STAT = 80,
125 &Aura::HandleNULL, //SPELL_AURA_SPLIT_DAMAGE = 81,
126 &Aura::HandleWaterBreathing, //SPELL_AURA_WATER_BREATHING = 82,
127 &Aura::HandleModBaseResistance, //SPELL_AURA_MOD_BASE_RESISTANCE = 83,
128 &Aura::HandleModRegen, //SPELL_AURA_MOD_REGEN = 84,
129 &Aura::HandleModPowerRegen, //SPELL_AURA_MOD_POWER_REGEN = 85,
130 &Aura::HandleChannelDeathItem, //SPELL_AURA_CHANNEL_DEATH_ITEM = 86,
131 &Aura::HandleModDamagePCTTaken, //SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN = 87,
132 &Aura::HandleModPCTRegen, //SPELL_AURA_MOD_PERCENT_REGEN = 88,
133 &Aura::HandlePeriodicDamagePCT, //SPELL_AURA_PERIODIC_DAMAGE_PERCENT = 89,
134 &Aura::HandleNULL, //SPELL_AURA_MOD_RESIST_CHANCE = 90,
135 &Aura::HandleNULL, //SPELL_AURA_MOD_DETECT_RANGE = 91,
136 &Aura::HandleNULL, //SPELL_AURA_PREVENTS_FLEEING = 92,
137 &Aura::HandleNULL, //SPELL_AURA_MOD_UNATTACKABLE = 93,
138 &Aura::HandleNULL, //SPELL_AURA_INTERRUPT_REGEN = 94,
139 &Aura::HandleNULL, //SPELL_AURA_GHOST = 95,
140 &Aura::HandleNULL, //SPELL_AURA_SPELL_MAGNET = 96,
141 &Aura::HandleAuraManaShield, //SPELL_AURA_MANA_SHIELD = 97,
142 &Aura::HandleNULL, //SPELL_AURA_MOD_SKILL_TALENT = 98,
143 &Aura::HandleAuraModAttackPower, //SPELL_AURA_MOD_ATTACK_POWER = 99,
144 &Aura::HandleNULL, //SPELL_AURA_AURAS_VISIBLE = 100,
145 &Aura::HandleModResistancePercent, //SPELL_AURA_MOD_RESISTANCE_PCT = 101,
146 &Aura::HandleNULL, //SPELL_AURA_MOD_CREATURE_ATTACK_POWER = 102,
147 &Aura::HandleNULL, //SPELL_AURA_MOD_TOTAL_THREAT = 103,
148 &Aura::HandleAuraWaterWalk, //SPELL_AURA_WATER_WALK = 104,
149 &Aura::HandleAuraFeatherFall, //SPELL_AURA_FEATHER_FALL = 105,
150 &Aura::HandleNULL, //SPELL_AURA_HOVER = 106,
151 &Aura::HandleAddModifier, //SPELL_AURA_ADD_FLAT_MODIFIER = 107,
152 &Aura::HandleAddModifier, //SPELL_AURA_ADD_PCT_MODIFIER = 108,
153 &Aura::HandleNULL, //SPELL_AURA_ADD_TARGET_TRIGGER = 109,
154 &Aura::HandleNULL, //SPELL_AURA_MOD_POWER_REGEN_PERCENT = 110,
155 &Aura::HandleNULL, //SPELL_AURA_ADD_CASTER_HIT_TRIGGER = 111,
156 &Aura::HandleNULL, //SPELL_AURA_OVERRIDE_CLASS_SCRIPTS = 112,
157 &Aura::HandleNULL, //SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN = 113,
158 &Aura::HandleNULL, //SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN_PCT = 114,
159 &Aura::HandleNULL, //SPELL_AURA_MOD_HEALING = 115,
160 &Aura::HandleNULL, //SPELL_AURA_IGNORE_REGEN_INTERRUPT = 116,
161 &Aura::HandleNULL, //SPELL_AURA_MOD_MECHANIC_RESISTANCE = 117,
162 &Aura::HandleNULL, //SPELL_AURA_MOD_HEALING_PCT = 118,
163 &Aura::HandleNULL, //SPELL_AURA_SHARE_PET_TRACKING = 119,
164 &Aura::HandleNULL, //SPELL_AURA_UNTRACKABLE = 120,
165 &Aura::HandleNULL, //SPELL_AURA_EMPATHY = 121,
166 &Aura::HandleNULL, //SPELL_AURA_MOD_OFFHAND_DAMAGE_PCT = 122,
167 &Aura::HandleNULL, //SPELL_AURA_MOD_POWER_COST_PCT = 123,
168 &Aura::HandleAuraModRangedAttackPower, //SPELL_AURA_MOD_RANGED_ATTACK_POWER = 124,
169 &Aura::HandleNULL, //SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN = 125,
170 &Aura::HandleNULL, //SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN_PCT = 126,
171 &Aura::HandleNULL, //SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS = 127,
172 &Aura::HandleNULL, //SPELL_AURA_MOD_POSSESS_PET = 128,
173 &Aura::HandleAuraModIncreaseSpeedAlways, //SPELL_AURA_MOD_INCREASE_SPEED_ALWAYS = 129,
174 &Aura::HandleNULL, //SPELL_AURA_MOD_MOUNTED_SPEED_ALWAYS = 130,
175 &Aura::HandleNULL, //SPELL_AURA_MOD_CREATURE_RANGED_ATTACK_POWER = 131,
176 &Aura::HandleAuraModIncreaseEnergyPercent, //SPELL_AURA_MOD_INCREASE_ENERGY_PERCENT = 132,
177 &Aura::HandleAuraModIncreaseHealthPercent, //SPELL_AURA_MOD_INCREASE_HEALTH_PERCENT = 133,
178 &Aura::HandleNULL, //SPELL_AURA_MOD_MANA_REGEN_INTERRUPT = 134,
179 &Aura::HandleNULL, //SPELL_AURA_MOD_HEALING_DONE = 135,
180 &Aura::HandleNULL, //SPELL_AURA_MOD_HEALING_DONE_PERCENT = 136,
181 &Aura::HandleNULL, //SPELL_AURA_MOD_TOTAL_STAT_PERCENTAGE = 137,
182 &Aura::HandleNULL, //SPELL_AURA_MOD_HASTE = 138,
183 &Aura::HandleForceReaction, //SPELL_AURA_FORCE_REACTION = 139,
184 &Aura::HandleNULL, //SPELL_AURA_MOD_RANGED_HASTE = 140,
185 &Aura::HandleRangedAmmoHaste, //SPELL_AURA_MOD_RANGED_AMMO_HASTE = 141,
186 &Aura::HandleAuraModBaseResistancePCT, //SPELL_AURA_MOD_BASE_RESISTANCE_PCT = 142,
187 &Aura::HandleAuraModResistanceExclusive, //SPELL_AURA_MOD_RESISTANCE_EXCLUSIVE = 143,
188 &Aura::HandleAuraSafeFall, //SPELL_AURA_SAFE_FALL = 144,
189 &Aura::HandleNULL, //SPELL_AURA_CHARISMA = 145,
190 &Aura::HandleNULL, //SPELL_AURA_PERSUADED = 146,
191 &Aura::HandleNULL, //SPELL_AURA_ADD_CREATURE_IMMUNITY = 147,
192 &Aura::HandleNULL, //SPELL_AURA_RETAIN_COMBO_POINTS = 148,
193 &Aura::HandleNULL, //SPELL_AURA_RESIST_PUSHBACK = 149 ,// Resist Pushback
194 &Aura::HandleNULL, //SPELL_AURA_MOD_SHIELD_BLOCK = 150 ,// Mod Shield Block %
195 &Aura::HandleNULL, //SPELL_AURA_TRACK_STEALTHED = 151 ,// Track Stealthed
196 &Aura::HandleNULL, //SPELL_AURA_MOD_DETECTED_RANGE = 152 ,// Mod Detected Range
197 &Aura::HandleNULL, //SPELL_AURA_SPLIT_DAMAGE_FLAT = 153 ,// Split Damage Flat
198 &Aura::HandleNULL, //SPELL_AURA_MOD_STEALTH_LEVEL = 154 ,// Stealth Level Modifier
199 &Aura::HandleNULL, //SPELL_AURA_MOD_WATER_BREATHING = 155 ,// Mod Water Breathing
200 &Aura::HandleNULL, //SPELL_AURA_MOD_REPUTATION_ADJUST = 156 ,// Mod Reputation Gain
201 &Aura::HandleNULL //SPELL_AURA_PET_DAMAGE_MULTI = 157 ,// Mod Pet Damage
202 };
203
204 Aura::Aura(SpellEntry* spellproto, uint32 eff, Unit *caster, Unit *target) :
205 m_procSpell(NULL),m_procdamage(NULL), m_spellId(spellproto->Id), m_effIndex(eff),
206 m_caster(caster), m_target(target), m_auraSlot(0),m_positive(false), m_permanent(false),
207 m_isPeriodic(false), m_isTrigger(false), m_periodicTimer(0), m_PeriodicEventId(0),
208 m_castItem(NULL), m_triggeredByAura(NULL)
209 {
210 assert(target);
211 sLog.outDebug("Aura construct spellid is: %u, auraname is: %u.", spellproto->Id, spellproto->EffectApplyAuraName[eff]);
212 m_duration = GetDuration(spellproto);
213 if(m_duration == -1)
214 m_permanent = true;
215 m_isPassive = IsPassiveSpell(m_spellId);
216
217 switch(spellproto->EffectImplicitTargetA[eff])
218 {
219 case TARGET_S_E:
220 case TARGET_AE_E:
221 case TARGET_AE_E_INSTANT:
222 case TARGET_AC_E:
223 case TARGET_INFRONT:
224 case TARGET_DUELVSPLAYER:
225 case TARGET_AE_E_CHANNEL:
226 case TARGET_AE_SELECTED:
227 m_positive = false;
228 break;
229
230 default:
231 m_positive = (spellproto->AttributesEx & (1<<7)) ? false : true;
232 }
233
234 uint32 type = 0;
235 if(!m_positive)
236 type = 1;
237 uint32 damage;
238 if(!caster)
239 {
240 m_caster = target;
241 damage = spellproto->EffectBasePoints[eff];
242 }
243 else
244 damage = CalculateDamage();
245
246 m_areaAura = spellproto->Effect[eff]==SPELL_EFFECT_APPLY_AREA_AURA ? true : false;
247
248 m_effIndex = eff;
249 SetModifier(spellproto->EffectApplyAuraName[eff], damage, spellproto->EffectAmplitude[eff], spellproto->EffectMiscValue[eff], type);
250 }
251
252 uint32 Aura::CalculateDamage()
253 {
254 SpellEntry* spellproto = GetSpellProto();
255 uint32 value = 0;
256 uint32 level;
257 if(!m_target)
258 return 0;
259 Unit* caster = m_caster;
260 if(!m_caster)
261 caster = m_target;
262 level= caster->getLevel();
263
264 float basePointsPerLevel = spellproto->EffectRealPointsPerLevel[m_effIndex];
265 float randomPointsPerLevel = spellproto->EffectDicePerLevel[m_effIndex];
266 uint32 basePoints = uint32(spellproto->EffectBasePoints[m_effIndex] + level * basePointsPerLevel);
267 uint32 randomPoints = uint32(spellproto->EffectDieSides[m_effIndex] + level * randomPointsPerLevel);
268 float comboDamage = spellproto->EffectPointsPerComboPoint[m_effIndex];
269 uint8 comboPoints=0;
270 if(caster->GetTypeId() == TYPEID_PLAYER)
271 comboPoints = (uint8)((caster->GetUInt32Value(PLAYER_FIELD_BYTES) & 0xFF00) >> 8);
272
273 value += spellproto->EffectBaseDice[m_effIndex];
274 if(randomPoints <= 1)
275 value = basePoints+1;
276 else
277 value = basePoints+rand()%randomPoints;
278
279 if(comboDamage > 0)
280 {
281 value += (uint32)(comboDamage * comboPoints);
282 if(caster->GetTypeId() == TYPEID_PLAYER)
283 caster->SetUInt32Value(PLAYER_FIELD_BYTES,((caster->GetUInt32Value(PLAYER_FIELD_BYTES) & ~(0xFF << 8)) | (0x00 << 8)));
284 }
285
286 return value;
287 }
288
289 void Aura::SetModifier(uint8 t, int32 a, uint32 pt, int32 miscValue, uint32 miscValue2)
290 {
291 m_modifier.m_auraname = t;
292 m_modifier.m_amount = a;
293 m_modifier.m_miscvalue = miscValue;
294 m_modifier.m_miscvalue2 = miscValue2;
295 m_modifier.periodictime = pt;
296
297 if (m_caster->GetTypeId() == TYPEID_PLAYER)
298 ((Player *)m_caster)->ApplySpellMod(m_spellId,SPELLMOD_ALL_EFFECTS, m_modifier.m_amount);
299 }
300
301 void Aura::Update(uint32 diff)
302 {
303 if (m_duration > 0)
304 {
305 m_duration -= diff;
306 if (m_duration < 0)
307 m_duration = 0;
308 if(m_target->isAlive() && m_target->hasUnitState(UNIT_STAT_FLEEING))
309 {
310 float x,y,z,angle,speed,pos_x,pos_y,pos_z;
311 uint32 time;
312 m_target->AttackStop();
313 m_target->RemoveAllAttackers();
314 angle = m_target->GetAngle( m_caster->GetPositionX(), m_caster->GetPositionY() );
315 speed = m_target->GetSpeed();
316 pos_x = m_target->GetPositionX()+speed*diff* cos(-angle)/1000;
317 pos_y = m_target->GetPositionY()+speed*diff* sin(-angle)/1000;
318 uint32 mapid = m_target->GetMapId();
319 pos_z = MapManager::Instance().GetMap(mapid)->GetHeight(pos_x,pos_y);
320 m_target->Relocate(pos_x,pos_y,pos_z,-angle);
321
322 x = m_target->GetPositionX() + speed*m_duration * cos(-angle)/1000;
323 y = m_target->GetPositionY() + speed*m_duration * sin(-angle)/1000;
324 mapid = m_target->GetMapId();
325 z = MapManager::Instance().GetMap(mapid)->GetHeight(x,y);
326 time = uint32(::sqrt(x*x+y*y+z*z)/speed);
327 m_target->SendMonsterMove(x,y,z,false,true,time);
328 }
329 }
330
331 if(m_areaAura && m_caster && m_target)
332 {
333 // update for the caster of the aura
334 if(m_caster->GetTypeId() == TYPEID_PLAYER && m_caster->GetGUID() == m_target->GetGUID())
335 {
336 Group* pGroup = objmgr.GetGroupByLeader(((Player*)m_caster)->GetGroupLeader());
337 float radius = GetRadius(sSpellRadius.LookupEntry(GetSpellProto()->EffectRadiusIndex[m_effIndex]));
338 if(pGroup)
339 {
340 for(uint32 p=0;p<pGroup->GetMembersCount();p++)
341 {
342 Unit* Target = ObjectAccessor::Instance().FindPlayer(pGroup->GetMemberGUID(p));
343 if(!Target || Target->GetGUID() == m_caster->GetGUID())
344 continue;
345 Aura *t_aura = Target->GetAura(m_spellId, m_effIndex);
346
347 if(m_caster->GetDistanceSq(Target) > radius * radius )
348 {
349 // remove auras of the same caster from out of range players
350 if (t_aura)
351 if (t_aura->GetCaster()->GetGUID() == m_caster->GetGUID())
352 Target->RemoveAura(m_spellId, m_effIndex);
353 }
354 else
355 {
356 // apply aura to players in range that dont have it yet
357 if (!t_aura)
358 {
359 Aura *aur = new Aura(GetSpellProto(), m_effIndex, m_caster, Target);
360 Target->AddAura(aur);
361 }
362 }
363 }
364 }
365 }
366 }
367
368 if(m_isPeriodic && m_duration > 0)
369 {
370 if(m_periodicTimer > 0)
371 {
372 if(m_periodicTimer <= diff)
373 m_periodicTimer = 0;
374 else
375 m_periodicTimer -= diff;
376 }
377 if(m_periodicTimer == 0)
378 {
379 // update before applying (aura can be removed in TriggerSpell or PeriodicAuraLog calls)
380 m_periodicTimer = m_modifier.periodictime;
381
382 if(m_isTrigger)
383 {
384 TriggerSpell();
385 }
386 else
387 {
388 if(!m_caster)
389 m_target->PeriodicAuraLog(m_target, GetSpellProto(), &m_modifier);
390 else
391 m_caster->PeriodicAuraLog(m_target, GetSpellProto(), &m_modifier);
392 }
393 }
394 }
395 }
396
397 void Aura::ApplyModifier(bool apply)
398 {
399 uint8 aura = 0;
400 aura = m_modifier.m_auraname;
401 if(aura<TOTAL_AURAS)
402 (*this.*AuraHandler [aura])(apply);
403 }
404
405 void Aura::UpdateAuraDuration()
406 {
407 if(m_target->GetTypeId() != TYPEID_PLAYER)
408 return;
409 if(m_isPassive)
410 return;
411
412 WorldPacket data;
413 data.Initialize(SMSG_UPDATE_AURA_DURATION);
414 data << (uint8)m_auraSlot << (uint32)m_duration;
415 //((Player*)m_target)->SendMessageToSet(&data, true); //GetSession()->SendPacket(&data);
416 ((Player*)m_target)->SendDirectMessage(&data);
417 }
418
419 void Aura::_AddAura()
420 {
421 if (!m_spellId)
422 return;
423 if(!m_target)
424 return;
425
426 bool samespell = false;
427 uint8 slot = 0xFF, i;
428 Aura* aura = NULL;
429
430 for(i = 0; i < 3; i++)
431 {
432 aura = m_target->GetAura(m_spellId, i);
433 if(aura)
434 {
435 if (i != m_effIndex)
436 {
437 samespell = true;
438 slot = aura->GetAuraSlot();
439 }
440 }
441 }
442
443 //m_target->RemoveRankAurasDueToSpell(m_spellId);
444 if (!m_triggeredByAura) // stats could already be removed by triggerer
445 m_target->ApplyStats(false);
446 ApplyModifier(true);
447 if (!m_triggeredByAura)
448 m_target->ApplyStats(true);
449 sLog.outDebug("Aura %u now is in use", m_modifier.m_auraname);
450
451 if(m_isPassive) // passive auras do not get placed in the slots
452 return;
453
454 if(!samespell)
455 {
456 if (IsPositive())
457 {
458 for (i = 0; i < MAX_POSITIVE_AURAS; i++)
459 {
460 if (m_target->GetUInt32Value((uint16)(UNIT_FIELD_AURA + i)) == 0)
461 {
462 slot = i;
463 break;
464 }
465 }
466 }
467 else
468 {
469 for (i = MAX_POSITIVE_AURAS; i < MAX_AURAS; i++)
470 {
471 if (m_target->GetUInt32Value((uint16)(UNIT_FIELD_AURA + i)) == 0)
472 {
473 slot = i;
474 break;
475 }
476 }
477 }
478
479 m_target->SetUInt32Value((uint16)(UNIT_FIELD_AURA + slot), GetId());
480
481 uint8 flagslot = slot >> 3;
482 uint32 value = m_target->GetUInt32Value((uint16)(UNIT_FIELD_AURAFLAGS + flagslot));
483
484 uint8 value1 = (slot & 7) << 2;
485 value |= ((uint32)AFLAG_SET << value1);
486
487 m_target->SetUInt32Value((uint16)(UNIT_FIELD_AURAFLAGS + flagslot), value);
488 }
489
490 SetAuraSlot( slot );
491 if( m_target->GetTypeId() == TYPEID_PLAYER )
492 UpdateAuraDuration();
493 }
494
495 void Aura::_RemoveAura()
496 {
497 if (!m_triggeredByAura) // stats may already be rmoved by triggerer
498 m_target->ApplyStats(false);
499 sLog.outDebug("Aura %u now is remove", m_modifier.m_auraname);
500 ApplyModifier(false);
501 if (!m_triggeredByAura)
502 m_target->ApplyStats(true);
503
504 if(m_isPassive) //passive auras do not get put in slots
505 return;
506
507 uint8 slot = GetAuraSlot();
508 Aura* aura = m_target->GetAura(m_spellId, m_effIndex);
509 if(!aura)
510 return;
511
512 if(m_target->GetUInt32Value((uint16)(UNIT_FIELD_AURA + slot)) == 0)
513 return;
514
515 // only remove icon when the last aura of the spell is removed
516 for(uint32 i = 0; i < 3; i++)
517 {
518 aura = m_target->GetAura(m_spellId, i);
519 if(aura && i != m_effIndex)
520 return;
521 }
522
523 m_target->SetUInt32Value((uint16)(UNIT_FIELD_AURA + slot), 0);
524
525 uint8 flagslot = slot >> 3;
526
527 uint32 value = m_target->GetUInt32Value((uint16)(UNIT_FIELD_AURAFLAGS + flagslot));
528
529 uint8 aurapos = (slot & 7) << 2;
530 uint32 value1 = ~( AFLAG_SET << aurapos );
531 value &= value1;
532
533 m_target->SetUInt32Value((uint16)(UNIT_FIELD_AURAFLAGS + flagslot), value);
534 }
535
536 void Aura::HandleNULL(bool apply)
537 {
538 }
539
540 void HandleDOTEvent(void *obj)
541 {
542 Aura *Aur = ((Aura*)obj);
543 //Aur->GetCaster()->AddPeriodicAura(Aur);
544 Aur->GetCaster()->PeriodicAuraLog(Aur->GetTarget(), Aur->GetSpellProto(), Aur->GetModifier());
545 }
546
547 void Aura::HandlePeriodicDamage(bool apply)
548 {
549 if( apply )
550 {
551 //m_PeriodicEventId = AddEvent(&HandleDOTEvent,(void*)this,m_modifier.periodictime,false,true);
552 m_isPeriodic = true;
553 m_periodicTimer = m_modifier.periodictime;
554 }
555 else
556 {
557 //RemovePeriodicEvent(m_PeriodicEventId);
558 m_isPeriodic = false;
559 m_duration = 0;
560 }
561 }
562
563 void Aura::HandleModConfuse(bool apply)
564 {
565 uint32 apply_stat = UNIT_STAT_CONFUSED;
566 if( apply )
567 {
568 m_target->addUnitState(UNIT_STAT_CONFUSED);
569 m_target->SetFlag(UNIT_FIELD_FLAGS,(apply_stat<<16));
570 }
571 else
572 {
573 m_target->clearUnitState(UNIT_STAT_CONFUSED);
574 m_target->RemoveFlag(UNIT_FIELD_FLAGS,(apply_stat<<16));
575 }
576 }
577
578 void Aura::HandleModFear(bool Apply)
579 {
580 uint32 apply_stat = UNIT_STAT_FLEEING;
581 WorldPacket data;
582 data.Initialize(SMSG_DEATH_NOTIFY_OBSOLETE);
583 if( Apply )
584 {
585 m_target->addUnitState(UNIT_STAT_FLEEING);
586 m_target->SendAttackStop(m_caster->GetGUID());
587 m_caster->SendAttackStop(m_target->GetGUID());
588 m_target->AttackStop();
589 m_target->SetFlag(UNIT_FIELD_FLAGS,(apply_stat<<16));
590
591 data<<m_target->GetGUIDLow();
592 data<<uint8(0);
593 }
594 else
595 {
596 data<<m_target->GetGUIDLow();
597 data<<uint8(1);
598 m_target->clearUnitState(UNIT_STAT_FLEEING);
599 m_target->RemoveFlag(UNIT_FIELD_FLAGS,(apply_stat<<16));
600 }
601 m_target->SendMessageToSet(&data,true);
602 if(m_target->GetTypeId() == TYPEID_PLAYER)
603 m_target->SendUpdateToPlayer((Player*)m_target);
604 }
605
606 void HandleHealEvent(void *obj)
607 {
608 Aura *Aur = ((Aura*)obj);
609 Aur->GetTarget()->PeriodicAuraLog(Aur->GetCaster(), Aur->GetSpellProto(), Aur->GetModifier());
610 }
611
612 void Aura::HandlePeriodicHeal(bool apply)
613 {
614 //Can't heal
615 if(!m_target || (m_target->m_immuneToMechanic & IMMUNE_MECHANIC_HEAL))
616 return;
617 if(apply)
618 {
619 //m_PeriodicEventId = AddEvent(&HandleHealEvent,(void*)this,m_modifier.periodictime,false,true);
620 m_isPeriodic = true;
621 m_periodicTimer = m_modifier.periodictime;
622 }
623 else
624 {
625 //RemovePeriodicEvent(m_PeriodicEventId);
626 m_isPeriodic = false;
627 m_duration = 0;
628 }
629 }
630
631 void Aura::HandleModAttackSpeed(bool apply)
632 {
633 if(!m_target || !m_target->isAlive() || !m_caster->isAlive())
634 return;
635
636 m_target->ApplyPercentModUInt32Value(UNIT_FIELD_BASEATTACKTIME,m_modifier.m_amount,apply);
637 }
638
639 void Aura::HandleModThreat(bool apply)
640 {
641 if(!m_target || !m_target->isAlive() || !m_caster->isAlive())
642 return;
643 m_target->AddHostil(m_caster->GetGUID(),apply ? float(m_modifier.m_amount) : -float(m_modifier.m_amount));
644 }
645
646 void Aura::HandleAuraWaterWalk(bool apply)
647 {
648 WorldPacket data;
649 if(apply)
650 data.Initialize(SMSG_MOVE_WATER_WALK);
651 else
652 data.Initialize(SMSG_MOVE_LAND_WALK);
653 data << uint8(0xFF) << m_target->GetGUID();
654 m_target->SendMessageToSet(&data,true);
655 }
656
657 void Aura::HandleAuraFeatherFall(bool apply)
658 {
659 WorldPacket data;
660 if(apply)
661 data.Initialize(SMSG_MOVE_FEATHER_FALL);
662 else
663 data.Initialize(SMSG_MOVE_NORMAL_FALL);
664 data << uint8(0xFF) << m_target->GetGUID();
665 m_target->SendMessageToSet(&data,true);
666 }
667
668 void Aura::HandleAddModifier(bool apply)
669 {
670 if(m_target->GetTypeId() != TYPEID_PLAYER)
671 return;
672
673 Player *p_target = (Player *)m_target;
674
675 SpellEntry *spellInfo = GetSpellProto();
676 if(!spellInfo) return;
677
678 uint8 op = spellInfo->EffectMiscValue[m_effIndex];
679 int32 value = spellInfo->EffectBasePoints[m_effIndex];
680 uint8 type = spellInfo->EffectApplyAuraName[m_effIndex];
681 uint32 mask = spellInfo->EffectItemType[m_effIndex];
682 if (!op) return;
683 SpellModList *p_mods = p_target->getSpellModList(op);
684 if (!p_mods) return;
685
686 if (apply)
687 {
688 SpellModifier *mod = new SpellModifier;
689 mod->op = op;
690 mod->value = value;
691 mod->type = type;
692 mod->mask = mask;
693 mod->spellId = m_spellId;
694 mod->charges = spellInfo->procCharges;
695 p_mods->push_back(mod);
696
697 uint16 send_val=0, send_mark=0;
698 int16 tmpval=spellInfo->EffectBasePoints[m_effIndex];
699 uint32 shiftdata=0x01, Opcode=SMSG_SET_FLAT_SPELL_MODIFIER;
700
701 if(tmpval != 0)
702 {
703 if(tmpval > 0)
704 {
705 send_val = tmpval+1;
706 send_mark = 0x0;
707 }
708 else
709 {
710 send_val = 0xFFFF + (tmpval+2);
711 send_mark = 0xFFFF;
712 }
713 }
714
715 if (mod->type == SPELLMOD_FLAT) Opcode = SMSG_SET_FLAT_SPELL_MODIFIER;
716 else if (mod->type == SPELLMOD_PCT) Opcode = SMSG_SET_PCT_SPELL_MODIFIER;
717
718 WorldPacket data;
719 for(int eff=0;eff<32;eff++)
720 {
721 if ( mask & shiftdata )
722 {
723 data.Initialize(Opcode);
724 data << uint8(eff);
725 data << uint8(mod->op);
726 data << uint16(send_val);
727 data << uint16(send_mark);
728 p_target->SendDirectMessage(&data);
729 }
730 shiftdata=shiftdata<<1;
731 }
732 }
733 else
734 {
735 SpellModList *p_mods = p_target->getSpellModList(spellInfo->EffectMiscValue[m_effIndex]);
736 for (SpellModList::iterator itr = p_mods->begin(); itr != p_mods->end(); ++itr)
737 {
738 SpellModifier *mod = *itr;
739 if (!mod) continue;
740 if (mod->op != op || mod->value != value || mod->type != type || mod->mask != mask)
741 continue;
742 p_mods->remove(mod);
743 delete mod;
744 break;
745 }
746 }
747 }
748
749 void Aura::HandleAuraModStun(bool apply)
750 {
751 WorldPacket data;
752 if (apply)
753 {
754 m_target->addUnitState(UNIT_STAT_STUNDED);
755 //m_target->SetUInt64Value (UNIT_FIELD_TARGET, 0);
756 if(m_target->GetTypeId() != TYPEID_PLAYER)
757 ((Creature *)m_target)->StopMoving();
758
759 data.Initialize(SMSG_FORCE_MOVE_ROOT);
760 data << uint8(0xFF) << m_target->GetGUID();
761 m_target->SendMessageToSet(&data,true);
762 m_target->SetFlag(UNIT_FIELD_FLAGS, 0x40000);
763 }
764 else
765 {
766 m_target->clearUnitState(UNIT_STAT_STUNDED);
767 m_target->RemoveFlag(UNIT_FIELD_FLAGS, 0x40000);
768
769 data.Initialize(SMSG_FORCE_MOVE_UNROOT);
770 data << uint8(0xFF) << m_target->GetGUID();
771 m_target->SendMessageToSet(&data,true);
772
773 }
774 }
775
776 void Aura::HandleAuraModRangedAttackPower(bool apply)
777 {
778 m_target->ApplyModUInt32Value(UNIT_FIELD_RANGED_ATTACK_POWER_MODS,m_modifier.m_amount,apply);
779 }
780
781 void Aura::HandleAuraModIncreaseEnergyPercent(bool apply)
782 {
783 m_target->ApplyPowerPercentMod(POWER_ENERGY,m_modifier.m_amount,apply);
784 }
785
786 void Aura::HandleAuraModIncreaseHealthPercent(bool apply)
787 {
788 m_target->ApplyMaxHealthPercentMod(m_modifier.m_amount,apply);
789 }
790
791 // FIX-ME!!
792 void HandleTriggerSpellEvent(void *obj)
793 {
794 Aura *Aur = ((Aura*)obj);
795 if(!Aur)
796 return;
797 SpellEntry *spellInfo = sSpellStore.LookupEntry(Aur->GetSpellProto()->EffectTriggerSpell[Aur->GetEffIndex()]);
798
799 if(!spellInfo)
800 {
801 sLog.outError("WORLD: unknown spell id %i\n", Aur->GetSpellProto()->EffectTriggerSpell[Aur->GetEffIndex()]);
802 return;
803 }
804
805 Spell *spell = new Spell(Aur->GetCaster(), spellInfo, true, Aur);
806 SpellCastTargets targets;
807 targets.setUnitTarget(Aur->GetTarget());
808 //WorldPacket dump;
809 //dump.Initialize(0);
810 //dump << uint16(2) << GetUInt32Value(UNIT_FIELD_CHANNEL_OBJECT) << GetUInt32Value(UNIT_FIELD_CHANNEL_OBJECT+1);
811 //targets.read(&dump,this);
812 spell->prepare(&targets);
813
814 /*else if(m_spellProto->EffectApplyAuraName[i] == 23)
815 {
816 unitTarget->tmpAura->SetPeriodicTriggerSpell(m_spellProto->EffectTriggerSpell[i],m_spellProto->EffectAmplitude[i]);
817 }*/
818 }
819
820 void Aura::TriggerSpell()
821 {
822 SpellEntry *spellInfo = sSpellStore.LookupEntry( GetSpellProto()->EffectTriggerSpell[m_effIndex] );
823
824 if(!spellInfo)
825 {
826 sLog.outError("WORLD: unknown spell id %i\n", GetSpellProto()->EffectTriggerSpell[m_effIndex]);
827 return;
828 }
829
830 Spell *spell = new Spell(m_caster, spellInfo, true, this);
831 Unit* target = m_target;
832 if(!target && m_caster->GetTypeId() == TYPEID_PLAYER)
833 {
834 target = ObjectAccessor::Instance().GetUnit(*m_caster, ((Player*)m_caster)->GetSelection());
835 }
836 if(!target)
837 return;
838 SpellCastTargets targets;
839 targets.setUnitTarget(target);
840 spell->prepare(&targets);
841 }
842
843 void Aura::HandlePeriodicTriggerSpell(bool apply)
844 {
845 if(apply)
846 {
847 //m_PeriodicEventId = AddEvent(&HandleTriggerSpellEvent,(void*)this,m_modifier.periodictime,false,true);
848 m_isPeriodic = true;
849 m_isTrigger = true;
850 m_periodicTimer = m_modifier.periodictime;
851 }
852 else
853 {
854 //RemovePeriodicEvent(m_PeriodicEventId);
855 m_isPeriodic = false;
856 m_isTrigger = false;
857 m_duration = 0;
858 //probably it's temporary for taming creature..
859 if(GetSpellProto()->Id == 1515 && m_caster->isAlive())
860 {
861 SpellEntry *spell_proto = sSpellStore.LookupEntry(13481);
862 Spell *spell = new Spell(m_caster, spell_proto, true, 0);
863 Unit* target = NULL;
864 target = m_target;
865 if(!target || !target->isAlive())
866 return;
867 SpellCastTargets targets;
868 targets.setUnitTarget(target);
869 spell->prepare(&targets);
870 }
871 }
872 }
873
874 void Aura::HandlePeriodicEnergize(bool apply)
875 {
876 if(apply)
877 {
878 //m_PeriodicEventId = AddEvent(&HandleTriggerSpellEvent,(void*)this,m_modifier.periodictime,false,true);
879 m_isPeriodic = true;
880 m_periodicTimer = m_modifier.periodictime;
881 }
882 else
883 {
884 //RemovePeriodicEvent(m_PeriodicEventId);
885 m_isPeriodic = false;
886 m_duration = 0;
887 }
888 }
889
890 void Aura::HandleAuraModResistanceExclusive(bool apply)
891 {
892 SpellSchools school = SPELL_SCHOOL_NORMAL;
893 uint16 index2 = 0;
894 switch(m_modifier.m_miscvalue)
895 {
896 case IMMUNE_SCHOOL_PHYSICAL:
897 {
898 school = SPELL_SCHOOL_NORMAL;
899 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE;
900 }break;
901 case IMMUNE_SCHOOL_HOLY:
902 {
903 school = SPELL_SCHOOL_HOLY;
904 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_01 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_01;
905 }break;
906 case IMMUNE_SCHOOL_FIRE:
907 {
908 school = SPELL_SCHOOL_FIRE;
909 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_02 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_02;
910 }break;
911 case IMMUNE_SCHOOL_NATURE:
912 {
913 school = SPELL_SCHOOL_NATURE;
914 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_03 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_03;
915 }break;
916 case IMMUNE_SCHOOL_FROST:
917 {
918 school = SPELL_SCHOOL_FROST;
919 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_04 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_04;
920 }break;
921 case IMMUNE_SCHOOL_SHADOW:
922 {
923 school = SPELL_SCHOOL_SHADOW;
924 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_05 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_05;
925 }break;
926 case IMMUNE_SCHOOL_ARCANE:
927 {
928 school = SPELL_SCHOOL_ARCANE;
929 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_06 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_06;
930 }
931 break;
932 case IMMUNE_SCHOOL_MAGIC:
933 {
934 for(int8 x=0;x < 6;x++)
935 {
936 school = SpellSchools(IMMUNE_SCHOOL_HOLY + x);
937 index2 = m_modifier.m_miscvalue2 == 0 ? PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_01 + x : PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_01 + x;
938
939 m_target->ApplyResistanceMod(school,m_modifier.m_amount,apply);
940 if(m_target->GetTypeId() == TYPEID_PLAYER)
941 m_target->ApplyModUInt32Value(index2,m_modifier.m_amount,apply);
942 }
943 return;
944 }break;
945 default:
946 {
947 sLog.outString("WARNING: Misc Value for SPELL_AURA_MOD_STAT not valid");
948 return;
949 }break;
950 }
951
952 m_target->ApplyResistanceMod(school,m_modifier.m_amount,apply);
953 if(m_target->GetTypeId() == TYPEID_PLAYER)
954 m_target->ApplyModUInt32Value(index2,m_modifier.m_amount,apply);
955 }
956
957 void Aura::HandleAuraSafeFall(bool apply)
958 {
959 WorldPacket data;
960 if(apply)
961 data.Initialize(SMSG_MOVE_FEATHER_FALL);
962 else
963 data.Initialize(SMSG_MOVE_NORMAL_FALL);
964 data << uint8(0xFF) << m_target->GetGUID();
965 m_target->SendMessageToSet(&data,true);
966 }
967
968 void Aura::HandleAuraDamageShield(bool apply)
969 {
970 if(apply)
971 {
972 for(std::list<struct DamageShield>::iterator i = m_target->m_damageShields.begin();i != m_target->m_damageShields.end();i++)
973 if(i->m_spellId == GetId() && i->m_caster == GetCaster())
974 {
975 m_target->m_damageShields.erase(i);
976 break;
977 }
978 DamageShield* ds = new DamageShield();
979 ds->m_caster = GetCaster();
980 ds->m_damage = m_modifier.m_amount;
981 ds->m_spellId = GetId();
982 m_target->m_damageShields.push_back((*ds));
983 }
984 else
985 {
986 for(std::list<struct DamageShield>::iterator i = m_target->m_damageShields.begin();i != m_target->m_damageShields.end();i++)
987 if(i->m_spellId == GetId() && i->m_caster == GetCaster())
988 {
989 m_target->m_damageShields.erase(i);
990 break;
991 }
992 }
993 }
994
995 void Aura::HandleModStealth(bool apply)
996 {
997 if(apply)
998 {
999 m_target->m_stealthvalue = CalculateDamage();
1000 m_target->SetFlag(UNIT_FIELD_BYTES_1, (0x2000000) );
1001 }
1002 else
1003 {
1004 SendCoolDownEvent();
1005 m_target->m_stealthvalue = 0;
1006 m_target->RemoveFlag(UNIT_FIELD_BYTES_1, (0x2000000) );
1007 }
1008 if(m_target->GetTypeId() == TYPEID_PLAYER)
1009 m_target->SendUpdateToPlayer((Player*)m_target);
1010 }
1011
1012 void Aura::HandleModDetect(bool apply)
1013 {
1014 if(apply)
1015 {
1016 m_target->m_detectStealth = CalculateDamage();
1017 }
1018 else
1019 {
1020 m_target->m_detectStealth = 0;
1021 }
1022 }
1023
1024 void Aura::HandleInvisibility(bool Apply)
1025 {
1026 if(Apply)
1027 {
1028 m_target->m_stealthvalue = CalculateDamage();
1029 m_target->SetFlag(UNIT_FIELD_BYTES_1, (0x2000000) );
1030 }
1031 else
1032 {
1033 SendCoolDownEvent();
1034 m_target->m_stealthvalue = 0;
1035 m_target->RemoveFlag(UNIT_FIELD_BYTES_1, (0x2000000) );
1036 }
1037 if(m_target->GetTypeId() == TYPEID_PLAYER)
1038 m_target->SendUpdateToPlayer((Player*)m_target);
1039 }
1040
1041 void Aura::HandleInvisibilityDetect(bool Apply)
1042 {
1043 if(Apply)
1044 {
1045 m_target->m_detectStealth = CalculateDamage();
1046 }
1047 else
1048 {
1049 m_target->m_detectStealth = 0;
1050 }
1051 }
1052
1053 void Aura::HandleAuraModResistance(bool apply)
1054 {
1055 SpellSchools school = SPELL_SCHOOL_NORMAL;
1056 uint16 index2 = 0;
1057 switch(m_modifier.m_miscvalue)
1058 {
1059 case IMMUNE_SCHOOL_PHYSICAL:
1060 {
1061 school = SPELL_SCHOOL_NORMAL;
1062 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE;
1063 }break;
1064 case IMMUNE_SCHOOL_HOLY:
1065 {
1066 school = SPELL_SCHOOL_HOLY;
1067 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_01 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_01;
1068 }break;
1069 case IMMUNE_SCHOOL_FIRE:
1070 {
1071 school = SPELL_SCHOOL_FIRE;
1072 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_02 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_02;
1073 }break;
1074 case IMMUNE_SCHOOL_NATURE:
1075 {
1076 school = SPELL_SCHOOL_NATURE;
1077 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_03 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_03;
1078 }break;
1079 case IMMUNE_SCHOOL_FROST:
1080 {
1081 school = SPELL_SCHOOL_FROST;
1082 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_04 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_04;
1083 }break;
1084 case IMMUNE_SCHOOL_SHADOW:
1085 {
1086 school = SPELL_SCHOOL_SHADOW;
1087 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_05 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_05;
1088 }break;
1089 case IMMUNE_SCHOOL_ARCANE:
1090 {
1091 school = SPELL_SCHOOL_ARCANE;
1092 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_06 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_06;
1093 }
1094 break;
1095 case IMMUNE_SCHOOL_MAGIC:
1096 {
1097 for(int8 x=0;x < 6;x++)
1098 {
1099 school = SpellSchools(IMMUNE_SCHOOL_HOLY + x);
1100 index2 = m_modifier.m_miscvalue2 == 0 ? PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_01 + x : PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_01 + x;
1101
1102 m_target->ApplyResistanceMod(school,m_modifier.m_amount,apply);
1103 if(m_target->GetTypeId() == TYPEID_PLAYER)
1104 m_target->ApplyModUInt32Value(index2,m_modifier.m_amount,apply);
1105 }
1106 return;
1107 }break;
1108 default:
1109 {
1110 sLog.outString("WARNING: Misc Value for SPELL_AURA_MOD_STAT not valid");
1111 return;
1112 }break;
1113 }
1114
1115 m_target->ApplyResistanceMod(school,m_modifier.m_amount,apply);
1116 if(m_target->GetTypeId() == TYPEID_PLAYER)
1117 m_target->ApplyModUInt32Value(index2,m_modifier.m_amount,apply);
1118 }
1119
1120 void Aura::HandleAuraModRoot(bool apply)
1121 {
1122 uint32 apply_stat = UNIT_STAT_ROOT;
1123 if (apply)
1124 {
1125 m_target->addUnitState(UNIT_STAT_ROOT);
1126 m_target->SetUInt64Value (UNIT_FIELD_TARGET, 0);
1127 m_target->SetFlag(UNIT_FIELD_FLAGS,(apply_stat<<16));
1128 if(m_target->GetTypeId() == TYPEID_PLAYER)
1129 {
1130 WorldPacket data;
1131 data.Initialize(SMSG_FORCE_MOVE_ROOT);
1132 data << uint8(0xFF) << m_target->GetGUID() << (uint32)2;
1133 m_target->SendMessageToSet(&data,true);
1134 }
1135 else
1136 ((Creature *)m_target)->StopMoving();
1137 }
1138 else
1139 {
1140 m_target->clearUnitState(UNIT_STAT_ROOT);
1141 m_target->RemoveFlag(UNIT_FIELD_FLAGS,(apply_stat<<16));
1142 WorldPacket data;
1143 if(m_target->GetTypeId() == TYPEID_PLAYER)
1144 {
1145 WorldPacket data;
1146 data.Initialize(SMSG_FORCE_MOVE_UNROOT);
1147 data << uint8(0xFF) << m_target->GetGUID() << (uint32)2;
1148 m_target->SendMessageToSet(&data,true);
1149 }
1150 }
1151 }
1152
1153 void Aura::HandleAuraModSilence(bool apply)
1154 {
1155 apply ? m_target->m_silenced = true : m_target->m_silenced = false;
1156 }
1157
1158 void Aura::HandleReflectSpells(bool apply)
1159 {
1160 if(apply)
1161 {
1162 for(std::list<struct ReflectSpellSchool*>::iterator i = m_target->m_reflectSpellSchool.begin();i != m_target->m_reflectSpellSchool.end();i++)
1163 {
1164 if(GetId() == (*i)->spellId)
1165 {
1166 m_target->m_reflectSpellSchool.erase(i);
1167 }
1168 }
1169 ReflectSpellSchool *rss = new ReflectSpellSchool();
1170
1171 rss->chance = m_modifier.m_amount;
1172 rss->spellId = GetId();
1173 rss->school = -1;
1174 m_target->m_reflectSpellSchool.push_back(rss);
1175 }
1176 else
1177 {
1178 for(std::list<struct ReflectSpellSchool*>::iterator i = m_target->m_reflectSpellSchool.begin();i != m_target->m_reflectSpellSchool.end();i++)
1179 {
1180 if(GetId() == (*i)->spellId)
1181 {
1182 m_target->m_reflectSpellSchool.erase(i);
1183 break;
1184 }
1185 }
1186 }
1187 }
1188
1189 void Aura::HandleAuraModStat(bool apply)
1190 {
1191 Stats stat = STAT_STRENGTH;
1192 uint16 index2 = 0;
1193 switch(m_modifier.m_miscvalue)
1194 {
1195 case 0:
1196 stat = STAT_STRENGTH;
1197 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_POSSTAT0 : index2 = PLAYER_FIELD_NEGSTAT0;
1198 break;
1199 case 1:
1200 stat = STAT_AGILITY;
1201 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_POSSTAT1 : index2 = PLAYER_FIELD_NEGSTAT1;
1202 break;
1203 case 2:
1204 stat = STAT_STAMINA;
1205 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_POSSTAT2 : index2 = PLAYER_FIELD_NEGSTAT2;
1206 break;
1207 case 3:
1208 stat = STAT_INTELLECT;
1209 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_POSSTAT3 : index2 = PLAYER_FIELD_NEGSTAT3;
1210 break;
1211 case 4:
1212 stat = STAT_SPIRIT;
1213 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_POSSTAT4 : index2 = PLAYER_FIELD_NEGSTAT4;
1214 break;
1215 case -1:
1216 {
1217 stat = STAT_STRENGTH;
1218 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_POSSTAT0 : index2 = PLAYER_FIELD_NEGSTAT0;
1219 for(int x=0;x<5;x++)
1220 {
1221 m_target->ApplyStatMod(Stats(stat+x),m_modifier.m_amount,apply);
1222 if(m_target->GetTypeId() == TYPEID_PLAYER)
1223 m_target->ApplyModUInt32Value(index2+x,m_modifier.m_amount,apply);
1224 }
1225 return;
1226 }break;
1227 default:
1228 sLog.outString("WARNING: Misc Value for SPELL_AURA_MOD_STAT not valid");
1229 return;
1230 break;
1231 }
1232
1233 m_target->ApplyStatMod(stat,m_modifier.m_amount,apply);
1234 if(m_target->GetTypeId() == TYPEID_PLAYER)
1235 m_target->ApplyModUInt32Value(index2,m_modifier.m_amount,apply);
1236 }
1237
1238 void Aura::HandleAuraModIncreaseSpeedAlways(bool apply)
1239 {
1240 sLog.outDebug("Current Speed:%f \tmodify:%f", m_target->GetSpeed(MOVE_RUN),(float)m_modifier.m_amount);
1241 if(m_modifier.m_amount<=1)
1242 return;
1243 WorldPacket data;
1244 if(apply)
1245 m_target->SetSpeed( m_target->GetSpeed() * (100.0f + m_modifier.m_amount)/100.0f );
1246 else
1247 m_target->SetSpeed( m_target->GetSpeed() * 100.0f/(100.0f + m_modifier.m_amount) );
1248 data.Initialize(MSG_MOVE_SET_RUN_SPEED);
1249 data << m_target->GetGUID();
1250 data << m_target->GetSpeed( MOVE_RUN );
1251 m_target->SendMessageToSet(&data,true);
1252 sLog.outDebug("ChangeSpeedTo:%f", m_target->GetSpeed(MOVE_RUN));
1253 }
1254
1255 void Aura::HandleAuraModIncreaseSpeed(bool apply)
1256 {
1257 sLog.outDebug("Current Speed:%f \tmodify:%f", m_target->GetSpeed(MOVE_RUN),(float)m_modifier.m_amount);
1258 if(m_modifier.m_amount<=1)
1259 return;
1260 WorldPacket data;
1261 if(apply)
1262 m_target->SetSpeed( m_target->GetSpeed() * (100.0f + m_modifier.m_amount)/100.0f );
1263 else
1264 m_target->SetSpeed( m_target->GetSpeed() * 100.0f/(100.0f + m_modifier.m_amount) );
1265 data.Initialize(SMSG_FORCE_RUN_SPEED_CHANGE);
1266 data << uint8(0xFF);
1267 data << m_target->GetGUID();
1268 data << (uint32)0;
1269 data << m_target->GetSpeed( MOVE_RUN );
1270
1271 m_target->SendMessageToSet(&data,true);
1272 sLog.outDebug("ChangeSpeedTo:%f", m_target->GetSpeed(MOVE_RUN));
1273 }
1274
1275 void Aura::HandleAuraModIncreaseMountedSpeed(bool apply)
1276 {
1277 sLog.outDebug("Current Speed:%f \tmodify:%f", m_target->GetSpeed(MOVE_RUN),(float)m_modifier.m_amount);
1278 if(m_modifier.m_amount<=1)
1279 return;
1280 WorldPacket data;
1281 if(apply)
1282 m_target->SetSpeed( m_target->GetSpeed() * ( m_modifier.m_amount + 100.0f ) / 100.0f );
1283 else
1284 m_target->SetSpeed( m_target->GetSpeed() * 100.0f / ( m_modifier.m_amount + 100.0f ) );
1285 data.Initialize(SMSG_FORCE_RUN_SPEED_CHANGE);
1286 data << uint8(0xFF);
1287 data << m_target->GetGUID();
1288 data << (uint32)0;
1289 data << m_target->GetSpeed( MOVE_RUN );
1290 m_target->SendMessageToSet(&data,true);
1291 sLog.outDebug("ChangeSpeedTo:%f", m_target->GetSpeed(MOVE_RUN));
1292 }
1293
1294 void Aura::HandleAuraModDecreaseSpeed(bool apply)
1295 {
1296 sLog.outDebug("Current Speed:%f \tmodify:%f", m_target->GetSpeed(MOVE_RUN),(float)m_modifier.m_amount);
1297 if(m_modifier.m_amount<=1)
1298 return;
1299 WorldPacket data;
1300 if(apply)
1301 m_target->SetSpeed( m_target->GetSpeed() * m_modifier.m_amount/100.0f );
1302 else
1303 m_target->SetSpeed( m_target->GetSpeed() * 100.0f/m_modifier.m_amount );
1304 data.Initialize(SMSG_FORCE_RUN_SPEED_CHANGE);
1305 data << uint8(0xFF);
1306 data << m_target->GetGUID();
1307 data << (uint32)0;
1308 data << m_target->GetSpeed( MOVE_RUN );
1309 m_target->SendMessageToSet(&data,true);
1310 sLog.outDebug("ChangeSpeedTo:%f", m_target->GetSpeed(MOVE_RUN));
1311 }
1312
1313 void Aura::HandleAuraModIncreaseHealth(bool apply)
1314 {
1315 m_target->ApplyMaxHealthMod(m_modifier.m_amount,apply);
1316 }
1317
1318 void Aura::HandleAuraModIncreaseEnergy(bool apply)
1319 {
1320 Powers powerType = m_target->getPowerType();
1321 if(int32(powerType) != m_modifier.m_miscvalue)
1322 return;
1323
1324 uint32 newValue = m_target->GetPower(powerType);
1325 apply ? newValue += m_modifier.m_amount : newValue -= m_modifier.m_amount;
1326 m_target->SetPower(powerType,newValue);
1327 }
1328
1329 void Aura::HandleAuraModShapeshift(bool apply)
1330 {
1331 if(!m_target)
1332 return;
1333 Unit *unit_target = m_target;
1334 uint32 spellId = 0;
1335 uint32 modelid = 0;
1336 Powers PowerType = POWER_MANA;
1337 uint32 new_bytes_1 = m_modifier.m_miscvalue;
1338 switch(m_modifier.m_miscvalue)
1339 {
1340 case FORM_CAT:
1341 if(unit_target->getRace() == RACE_NIGHT_ELF)
1342 modelid = 892;
1343 else if(unit_target->getRace() == RACE_TAUREN)
1344 modelid = 8571;
1345 PowerType = POWER_ENERGY;
1346 spellId = 3025;
1347 break;
1348 case FORM_TREE:
1349 spellId = 3122;
1350 break;
1351 case FORM_TRAVEL:
1352 modelid = 632;
1353 spellId = 5419;
1354 break;
1355 case FORM_AQUA:
1356 if(unit_target->getRace() == RACE_NIGHT_ELF)
1357 modelid = 2428;
1358 else if(unit_target->getRace() == RACE_TAUREN)
1359 modelid = 2428;
1360 spellId = 5421;
1361 break;
1362 case FORM_BEAR:
1363 if(unit_target->getRace() == RACE_NIGHT_ELF)
1364 modelid = 2281;
1365 else if(unit_target->getRace() == RACE_TAUREN)
1366 modelid = 2289;
1367 PowerType = POWER_RAGE;
1368 spellId = 1178;
1369 break;
1370 case FORM_AMBIENT:
1371 spellId = 0;
1372 break;
1373 case FORM_GHOUL:
1374 if(unit_target->getRace() == RACE_NIGHT_ELF)
1375 modelid = 10045;
1376 spellId = 0;
1377 break;
1378 case FORM_DIREBEAR:
1379 if(unit_target->getRace() == RACE_NIGHT_ELF)
1380 modelid = 2281;
1381 else if(unit_target->getRace() == RACE_TAUREN)
1382 modelid = 2289;
1383 PowerType = POWER_RAGE;
1384 spellId = 9635;
1385 break;
1386 case FORM_CREATUREBEAR:
1387 modelid = 902;
1388 spellId = 2882;
1389 break;
1390 case FORM_GHOSTWOLF:
1391 modelid = 1236;
1392 spellId = 0;
1393 break;
1394 case FORM_BATTLESTANCE:
1395 spellId = 0;
1396 break;
1397 case FORM_DEFENSIVESTANCE:
1398 spellId = 7376;
1399 break;
1400 case FORM_BERSERKERSTANCE:
1401 spellId = 7381;
1402 break;
1403 case FORM_SHADOW:
1404 spellId = 0;
1405 break;
1406 case FORM_STEALTH:
1407 spellId = 0;
1408 break;
1409 case FORM_MOONKIN:
1410 if(unit_target->getRace() == RACE_NIGHT_ELF)
1411 modelid = 15374;
1412 else if(unit_target->getRace() == RACE_TAUREN)
1413 modelid = 15375;
1414 spellId = 24907;
1415 break;
1416 default:
1417 sLog.outString("Unknown Shapeshift Type: %u", m_modifier.m_miscvalue);
1418 }
1419
1420 SpellEntry *spellInfo = sSpellStore.LookupEntry( spellId );
1421
1422 if(apply)
1423 {
1424 if(unit_target->GetTypeId() == TYPEID_PLAYER)
1425 {
1426 if(((Player*)unit_target)->IsInWater())
1427 {
1428 if(m_modifier.m_miscvalue != FORM_AQUA )
1429 return;
1430 }
1431 }
1432 if(unit_target->m_ShapeShiftForm)
1433 unit_target->RemoveAurasDueToSpell(unit_target->m_ShapeShiftForm);
1434
1435 unit_target->SetFlag(UNIT_FIELD_BYTES_1, (new_bytes_1<<16) );
1436 if(modelid > 0)
1437 {
1438 unit_target->SetUInt32Value(UNIT_FIELD_DISPLAYID,modelid);
1439 }
1440 unit_target->setPowerType(PowerType);
1441 unit_target->m_ShapeShiftForm = m_spellId;
1442 unit_target->m_form = m_modifier.m_miscvalue;
1443 if(unit_target->m_form == FORM_DIREBEAR)
1444 if (m_target->getRace() == TAUREN)
1445 {
1446 m_target->SetFloatValue(OBJECT_FIELD_SCALE_X,1.35f);
1447 }
1448 else
1449 m_target->SetFloatValue(OBJECT_FIELD_SCALE_X,1.0f);
1450
1451 if(spellInfo)
1452 {
1453 Spell *p_spell = new Spell(m_caster,spellInfo,true,this);
1454 WPAssert(p_spell);
1455 SpellCastTargets targets;
1456 targets.setUnitTarget(unit_target);
1457 p_spell->prepare(&targets);
1458 }
1459 }
1460 else
1461 {
1462 if (m_target->getRace() == TAUREN)
1463 unit_target->SetFloatValue(OBJECT_FIELD_SCALE_X,1.35f);
1464 else
1465 unit_target->SetFloatValue(OBJECT_FIELD_SCALE_X,1.0f);
1466 unit_target->SetUInt32Value(UNIT_FIELD_DISPLAYID,unit_target->GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
1467 unit_target->RemoveFlag(UNIT_FIELD_BYTES_1, (new_bytes_1<<16) );
1468 if(unit_target->getClass() == CLASS_DRUID)
1469 unit_target->setPowerType(POWER_MANA);
1470 unit_target->m_ShapeShiftForm = 0;
1471 unit_target->m_form = 0;
1472 unit_target->RemoveAurasDueToSpell(spellId);
1473 }
1474 if(unit_target->GetTypeId() == TYPEID_PLAYER)
1475 unit_target->SendUpdateToPlayer((Player*)unit_target);
1476 }
1477
1478 void Aura::HandleModMechanicImmunity(bool apply)
1479 {
1480 apply ? m_target->SetStateFlag(m_target->m_immuneToMechanic,m_modifier.m_miscvalue) : m_target->RemoveStateFlag(m_target->m_immuneToMechanic,m_modifier.m_miscvalue);
1481 }
1482
1483 void Aura::HandleAuraModEffectImmunity(bool apply)
1484 {
1485 apply ? m_target->SetStateFlag(m_target->m_immuneToEffect,m_modifier.m_miscvalue) : m_target->RemoveStateFlag(m_target->m_immuneToEffect,m_modifier.m_miscvalue);
1486 }
1487
1488 void Aura::HandleAuraModStateImmunity(bool apply)
1489 {
1490 apply ? m_target->SetStateFlag(m_target->m_immuneToState,m_modifier.m_miscvalue) : m_target->RemoveStateFlag(m_target->m_immuneToState,m_modifier.m_miscvalue);
1491 }
1492
1493 void Aura::HandleAuraModSchoolImmunity(bool apply)
1494 {
1495 apply ? m_target->SetStateFlag(m_target->m_immuneToSchool,m_modifier.m_miscvalue) : m_target->RemoveStateFlag(m_target->m_immuneToSchool,m_modifier.m_miscvalue);
1496 }
1497
1498 void Aura::HandleAuraModDmgImmunity(bool apply)
1499 {
1500 apply ? m_target->SetStateFlag(m_target->m_immuneToDmg,m_modifier.m_miscvalue) : m_target->RemoveStateFlag(m_target->m_immuneToDmg,m_modifier.m_miscvalue);
1501 }
1502
1503 void Aura::HandleAuraModDispelImmunity(bool apply)
1504 {
1505 apply ? m_target->SetStateFlag(m_target->m_immuneToDispel,m_modifier.m_miscvalue) : m_target->RemoveStateFlag(m_target->m_immuneToDispel,m_modifier.m_miscvalue);
1506 }
1507
1508 void Aura::HandleAuraProcTriggerSpell(bool apply)
1509 {
1510 if(apply)
1511 {
1512 m_procSpell = new ProcTriggerSpell();
1513 m_procSpell->spellId = GetSpellProto()->Id;
1514 m_procSpell->caster = m_caster->GetGUID();
1515 m_procSpell->trigger = GetSpellProto()->EffectTriggerSpell[GetEffIndex()];
1516 m_procSpell->procChance = GetSpellProto()->procChance;
1517 m_procSpell->procFlags = GetSpellProto()->procFlags;
1518 m_procSpell->procCharges = GetSpellProto()->procCharges;
1519 }
1520 else
1521 {
1522 delete m_procSpell;
1523 m_procSpell = NULL;
1524 }
1525 }
1526
1527 void Aura::HandleAuraProcTriggerDamage(bool apply)
1528 {
1529 if(apply)
1530 {
1531 m_procdamage->caster = m_caster->GetGUID();
1532 m_procdamage->procDamage = m_modifier.m_amount;
1533 m_procdamage->procChance = GetSpellProto()->procChance;
1534 m_procdamage->procFlags = GetSpellProto()->procFlags;
1535 m_procdamage->procCharges = GetSpellProto()->procCharges;
1536 }
1537 else
1538 {
1539 m_procdamage = NULL;
1540 }
1541 }
1542
1543 void Aura::HandleAuraTracCreatures(bool apply)
1544 {
1545 m_target->SetUInt32Value(PLAYER_TRACK_CREATURES, apply ? m_modifier.m_miscvalue : 0 );
1546 }
1547
1548 void Aura::HandleAuraTracResources(bool apply)
1549 {
1550 m_target->SetUInt32Value(PLAYER_TRACK_RESOURCES, apply ? ((uint32)1)<<(m_modifier.m_miscvalue-1): 0 );
1551 }
1552
1553 void Aura::HandleAuraModParryPercent(bool apply)
1554 {
1555 m_target->ApplyModFloatValue(PLAYER_PARRY_PERCENTAGE,m_modifier.m_amount,apply);
1556 }
1557
1558 void Aura::HandleAuraModDodgePercent(bool apply)
1559 {
1560 m_target->ApplyModFloatValue(PLAYER_DODGE_PERCENTAGE,m_modifier.m_amount,apply);
1561 }
1562
1563 void Aura::HandleAuraModBlockPercent(bool apply)
1564 {
1565 m_target->ApplyModFloatValue(PLAYER_BLOCK_PERCENTAGE,m_modifier.m_amount,apply);
1566 }
1567
1568 void Aura::HandleAuraModCritPercent(bool apply)
1569 {
1570 m_target->ApplyModFloatValue(PLAYER_CRIT_PERCENTAGE,m_modifier.m_amount,apply);
1571 }
1572
1573 void Aura::HandlePeriodicLeech(bool apply)
1574 {
1575 if(apply)
1576 {
1577 //m_PeriodicEventId = AddEvent(&HandleTriggerSpellEvent,(void*)this,m_modifier.periodictime,false,true);
1578 m_isPeriodic = true;
1579 m_periodicTimer = m_modifier.periodictime;
1580 }
1581 else
1582 {
1583 //RemovePeriodicEvent(m_PeriodicEventId);
1584 m_isPeriodic = false;
1585 m_duration = 0;
1586 }
1587 }
1588
1589 void Aura::HandleModHitChance(bool Apply)
1590 {
1591 m_target->m_modHitChance = Apply?m_modifier.m_amount:0;
1592 }
1593
1594 void Aura::HandleModSpellHitChance(bool Apply)
1595 {
1596 m_target->m_modSpellHitChance = Apply?m_modifier.m_amount:0;
1597 }
1598
1599 void Aura::HandleAuraModScale(bool apply)
1600 {
1601 m_target->ApplyPercentModFloatValue(OBJECT_FIELD_SCALE_X,10,apply);
1602 }
1603
1604 void Aura::HandlePeriodicManaLeech(bool Apply)
1605 {
1606 if(Apply)
1607 {
1608 //m_PeriodicEventId = AddEvent(&HandleTriggerSpellEvent,(void*)this,m_modifier.periodictime,false,true);
1609 m_isPeriodic = true;
1610 m_periodicTimer = m_modifier.periodictime;
1611 }
1612 else
1613 {
1614 //RemovePeriodicEvent(m_PeriodicEventId);
1615 m_isPeriodic = false;
1616 m_duration = 0;
1617 }
1618 }
1619
1620 void Aura::HandleAuraMounted(bool apply)
1621 {
1622 if(apply)
1623 {
1624 CreatureInfo* ci = objmgr.GetCreatureTemplate(m_modifier.m_miscvalue);
1625 if(!ci)return;
1626 uint32 displayId = ci->DisplayID;
1627 if(displayId != 0)
1628 {
1629 m_target->SetUInt32Value( UNIT_FIELD_MOUNTDISPLAYID , displayId);
1630 //m_target->SetFlag( UNIT_FIELD_FLAGS ,UNIT_FLAG_MOVEBLOCKED );
1631 m_target->SetFlag( UNIT_FIELD_FLAGS, UNIT_FLAG_MOUNT );
1632 }
1633 }else
1634 {
1635 m_target->SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID , 0);
1636 m_target->RemoveFlag( UNIT_FIELD_FLAGS, UNIT_FLAG_MOUNT | UNIT_FLAG_DISABLE_MOVE );
1637 }
1638 }
1639
1640 void Aura::HandleWaterBreathing(bool apply)
1641 {
1642 m_target->waterbreath = apply;
1643 }
1644
1645 void Aura::HandleModBaseResistance(bool apply)
1646 {
1647 if(m_modifier.m_miscvalue == 1 || m_modifier.m_miscvalue == 127)
1648 m_target->ApplyArmorMod(m_modifier.m_amount, apply);
1649 if(m_modifier.m_miscvalue == 126 || m_modifier.m_miscvalue == 127)
1650 {
1651 m_target->ApplyResistanceMod(SPELL_SCHOOL_HOLY, m_modifier.m_amount, apply);
1652 m_target->ApplyResistanceMod(SPELL_SCHOOL_FIRE, m_modifier.m_amount, apply);
1653 m_target->ApplyResistanceMod(SPELL_SCHOOL_NATURE, m_modifier.m_amount, apply);
1654 m_target->ApplyResistanceMod(SPELL_SCHOOL_FROST, m_modifier.m_amount, apply);
1655 m_target->ApplyResistanceMod(SPELL_SCHOOL_SHADOW, m_modifier.m_amount, apply);
1656 m_target->ApplyResistanceMod(SPELL_SCHOOL_ARCANE, m_modifier.m_amount, apply);
1657 }
1658 }
1659
1660 void Aura::HandleModRegen(bool apply) // eating
1661 {
1662 if (m_castItem)
1663 if (m_castItem->Class == ITEM_CLASS_CONSUMABLE)
1664 m_target->ApplyModFlag(UNIT_FIELD_BYTES_1,PLAYER_STATE_SIT,apply);
1665 }
1666
1667 void Aura::HandleModPowerRegen(bool apply) // drinking
1668 {
1669 if (m_castItem)
1670 if (m_castItem->Class == ITEM_CLASS_CONSUMABLE)
1671 m_target->ApplyModFlag(UNIT_FIELD_BYTES_1,PLAYER_STATE_SIT,apply);
1672 }
1673
1674 void Aura::HandleChannelDeathItem(bool apply)
1675 {
1676 if(!apply)
1677 {
1678 if(m_caster->GetTypeId() != TYPEID_PLAYER || m_target->isAlive())
1679 return;
1680 SpellEntry *spellInfo = GetSpellProto();
1681 if(spellInfo->EffectItemType[m_effIndex] == 0)
1682 return;
1683 uint16 dest;
1684 uint8 msg = ((Player*)m_caster)->CanStoreNewItem( 0, NULL_SLOT, dest, spellInfo->EffectItemType[m_effIndex], 1, false);
1685 if( msg == EQUIP_ERR_OK )
1686 ((Player*)m_caster)->StoreNewItem(dest, spellInfo->EffectItemType[m_effIndex], 1, true);
1687 else
1688 ((Player*)m_caster)->SendEquipError( msg, NULL, NULL );
1689 }
1690 }
1691
1692 void Aura::HandleModDamagePCTTaken(bool apply)
1693 {
1694 m_target->m_modDamagePCT = apply ? m_modifier.m_amount : 0;
1695 }
1696
1697 void Aura::HandleModPCTRegen(bool apply)
1698 {
1699 m_target->m_RegenPCT = apply ? m_modifier.m_amount : 0;
1700 }
1701
1702 void Aura::HandlePeriodicDamagePCT(bool apply)
1703 {
1704 if(apply)
1705 {
1706 //m_PeriodicEventId = AddEvent(&HandleTriggerSpellEvent,(void*)this,m_modifier.periodictime,false,true);
1707 m_isPeriodic = true;
1708 m_periodicTimer = m_modifier.periodictime;
1709 }
1710 else
1711 {
1712 //RemovePeriodicEvent(m_PeriodicEventId);
1713 m_isPeriodic = false;
1714 m_duration = 0;
1715 }
1716 }
1717
1718 void Aura::HandleAuraModAttackPower(bool apply)
1719 {
1720 m_target->ApplyModUInt32Value(UNIT_FIELD_ATTACK_POWER_MODS, m_modifier.m_amount, apply);
1721 }
1722
1723 void Aura::HandleAuraTransform(bool apply)
1724 {
1725 if(!m_target)
1726 return;
1727 //Can't transform
1728 if (m_target->m_immuneToMechanic & IMMUNE_MECHANIC_POLYMORPH)
1729 return;
1730
1731 if (apply)
1732 {
1733 CreatureInfo* ci = objmgr.GetCreatureTemplate(m_modifier.m_miscvalue);
1734 if(!ci)
1735 return;
1736 m_target->SetUInt32Value (UNIT_FIELD_DISPLAYID, ci->DisplayID);
1737 m_target->setTransForm(GetSpellProto()->Id);
1738 }
1739 else
1740 {
1741 m_target->SetUInt32Value (UNIT_FIELD_DISPLAYID, m_target->GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
1742 m_target->setTransForm(0);
1743 }
1744 if(m_caster->GetTypeId() == TYPEID_PLAYER)
1745 m_target->SendUpdateToPlayer((Player*)m_caster);
1746
1747 /*uint32 id=GetId();
1748 switch (id)
1749 {
1750 case 118:
1751 case 851:
1752 case 5254:
1753 case 12824:
1754 case 12825:
1755 case 12826:
1756 case 13323:
1757 if (apply)
1758 m_target->SetUInt32Value (UNIT_FIELD_DISPLAYID, 856);
1759 else
1760 m_target->SetUInt32Value (UNIT_FIELD_DISPLAYID, m_target->GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
1761 break;
1762 case 228:
1763 if (apply)
1764 m_target->SetUInt32Value (UNIT_FIELD_DISPLAYID, 304);
1765 else
1766 m_target->SetUInt32Value (UNIT_FIELD_DISPLAYID, m_target->GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
1767 break;
1768
1769 case 4060:
1770 if (apply)
1771 m_target->SetUInt32Value (UNIT_FIELD_DISPLAYID, 131);
1772 else
1773 m_target->SetUInt32Value (UNIT_FIELD_DISPLAYID, m_target->GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
1774 break;
1775
1776 case 15534:
1777 if (apply)
1778 m_target->SetUInt32Value (UNIT_FIELD_DISPLAYID, 1141);
1779 else
1780 m_target->SetUInt32Value (UNIT_FIELD_DISPLAYID, m_target->GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
1781 break;
1782
1783 }*/
1784 }
1785
1786 void Aura::HandleModSpellCritChance(bool Apply)
1787 {
1788 m_target->m_baseSpellCritChance += Apply?m_modifier.m_amount:(-m_modifier.m_amount);
1789 }
1790
1791 void Aura::HandleAuraModIncreaseSwimSpeed(bool Apply)
1792 {
1793 sLog.outDebug("Current Speed:%f \tmodify:%f", m_target->GetSpeed(MOVE_SWIM),(float)m_modifier.m_amount);
1794 if(m_modifier.m_amount<=1)
1795 return;
1796 WorldPacket data;
1797 if(Apply)
1798 m_target->SetSpeed( m_target->GetSpeed() * ( m_modifier.m_amount + 100.0f ) / 100.0f );
1799 else
1800 m_target->SetSpeed( m_target->GetSpeed() * 100.0f / ( m_modifier.m_amount + 100.0f ) );
1801 data.Initialize(SMSG_FORCE_RUN_SPEED_CHANGE);
1802 data << uint8(0xFF);
1803 data << m_target->GetGUID();
1804 data << (uint32)0;
1805 data << m_target->GetSpeed( MOVE_SWIM );
1806 m_target->SendMessageToSet(&data,true);
1807 sLog.outDebug("ChangeSpeedTo:%f", m_target->GetSpeed(MOVE_SWIM));
1808 }
1809
1810 void Aura::HandleModDamageDoneCreature(bool Apply)
1811 {
1812 if(Apply)
1813 {
1814
1815 for(std::list<struct DamageDoneCreature*>::iterator i = m_target->m_damageDoneCreature.begin();i != m_target->m_damageDoneCreature.end();i++)
1816 {
1817 if(GetId() == (*i)->spellId)
1818 {
1819 m_target->m_damageDoneCreature.erase(i);
1820 }
1821 }
1822
1823 DamageDoneCreature *ddc = new DamageDoneCreature();
1824
1825 ddc->spellId = GetId();
1826 ddc->damage = m_modifier.m_amount;
1827 ddc->creaturetype = m_modifier.m_miscvalue;
1828 m_target->m_damageDoneCreature.push_back(ddc);
1829 }
1830 else
1831 {
1832 for(std::list<struct DamageDoneCreature*>::iterator i = m_target->m_damageDoneCreature.begin();i != m_target->m_damageDoneCreature.end();i++)
1833 {
1834 if(GetId() == (*i)->spellId)
1835 {
1836 m_target->m_damageDoneCreature.erase(i);
1837 break;
1838 }
1839 }
1840 }
1841 }
1842
1843 void Aura::HandleAuraManaShield(bool apply)
1844 {
1845 if(apply)
1846 {
1847
1848 for(std::list<struct DamageManaShield*>::iterator i = m_target->m_damageManaShield.begin();i != m_target->m_damageManaShield.end();i++)
1849 {
1850 if(GetId() == (*i)->m_spellId)
1851 {
1852 m_target->m_damageManaShield.erase(i);
1853 }
1854 }
1855
1856 DamageManaShield *dms = new DamageManaShield();
1857
1858 dms->m_spellId = GetId();
1859 dms->m_modType = m_modifier.m_auraname;
1860 dms->m_totalAbsorb = m_modifier.m_amount;
1861 dms->m_currAbsorb = 0;
1862 dms->m_schoolType = m_modifier.m_miscvalue;
1863 m_target->m_damageManaShield.push_back(dms);
1864 }
1865 else
1866 {
1867 for(std::list<struct DamageManaShield*>::iterator i = m_target->m_damageManaShield.begin();i != m_target->m_damageManaShield.end();i++)
1868 {
1869 if(GetId() == (*i)->m_spellId)
1870 {
1871 m_target->m_damageManaShield.erase(i);
1872 break;
1873 }
1874 }
1875 }
1876 }
1877
1878 void Aura::HandleAuraSchoolAbsorb(bool apply)
1879 {
1880 if(apply)
1881 {
1882
1883 for(std::list<struct DamageManaShield*>::iterator i = m_target->m_damageManaShield.begin();i != m_target->m_damageManaShield.end();i++)
1884 {
1885 if(GetId() == (*i)->m_spellId)
1886 {
1887 m_target->m_damageManaShield.erase(i);
1888 }
1889 }
1890
1891 DamageManaShield *dms = new DamageManaShield();
1892
1893 dms->m_spellId = GetId();
1894 dms->m_modType = m_modifier.m_auraname;
1895 dms->m_totalAbsorb = m_modifier.m_amount;
1896 dms->m_currAbsorb = 0;
1897 dms->m_schoolType = m_modifier.m_miscvalue;
1898 m_target->m_damageManaShield.push_back(dms);
1899 }
1900 else
1901 {
1902 for(std::list<struct DamageManaShield*>::iterator i = m_target->m_damageManaShield.begin();i != m_target->m_damageManaShield.end();i++)
1903 {
1904 if(GetId() == (*i)->m_spellId)
1905 {
1906 m_target->m_damageManaShield.erase(i);
1907 break;
1908 }
1909 }
1910 }
1911 }
1912
1913 void Aura::HandleModSpellCritChanceShool(bool Apply)
1914 {
1915 if(Apply)
1916 {
1917 for(std::list<struct SpellCritSchool*>::iterator i = m_target->m_spellCritSchool.begin();i != m_target->m_spellCritSchool.end();i++)
1918 {
1919 if(GetId() == (*i)->spellId)
1920 {
1921 m_target->m_spellCritSchool.erase(i);
1922 }
1923 }
1924 SpellCritSchool *scs = new SpellCritSchool();
1925
1926 scs->chance = m_modifier.m_amount;
1927 scs->spellId = GetId();
1928 scs->school = m_modifier.m_miscvalue;
1929 m_target->m_spellCritSchool.push_back(scs);
1930 }
1931 else
1932 {
1933 for(std::list<struct SpellCritSchool*>::iterator i = m_target->m_spellCritSchool.begin();i != m_target->m_spellCritSchool.end();i++)
1934 {
1935 if(GetId() == (*i)->spellId)
1936 {
1937 m_target->m_spellCritSchool.erase(i);
1938 break;
1939 }
1940 }
1941 }
1942 }
1943
1944 void Aura::HandleReflectSpellsSchool(bool apply)
1945 {
1946 if(apply)
1947 {
1948 for(std::list<struct ReflectSpellSchool*>::iterator i = m_target->m_reflectSpellSchool.begin();i != m_target->m_reflectSpellSchool.end();i++)
1949 {
1950 if(GetId() == (*i)->spellId)
1951 {
1952 m_target->m_reflectSpellSchool.erase(i);
1953 }
1954 }
1955 ReflectSpellSchool *rss = new ReflectSpellSchool();
1956
1957 rss->chance = m_modifier.m_amount;
1958 rss->spellId = GetId();
1959 rss->school = m_modifier.m_miscvalue;
1960 m_target->m_reflectSpellSchool.push_back(rss);
1961 }
1962 else
1963 {
1964 for(std::list<struct ReflectSpellSchool*>::iterator i = m_target->m_reflectSpellSchool.begin();i != m_target->m_reflectSpellSchool.end();i++)
1965 {
1966 if(GetId() == (*i)->spellId)
1967 {
1968 m_target->m_reflectSpellSchool.erase(i);
1969 break;
1970 }
1971 }
1972 }
1973 }
1974
1975 void Aura::HandleAuraModSkill(bool apply)
1976 {
1977 if(m_target->GetTypeId() != TYPEID_PLAYER)
1978 return;
1979
1980 SpellEntry* prot=GetSpellProto();
1981
1982 ((Player*)m_target)->ModifySkillBonus(prot->EffectMiscValue[0],
1983 (apply ? (prot->EffectBasePoints[0]+1): (-(prot->EffectBasePoints[0]+1))));
1984 }
1985
1986 void Aura::HandleModDamagePercentDone(bool apply)
1987 {
1988 sLog.outDebug("AURA MOD DAMAGE type:%u type2:%u", m_modifier.m_miscvalue, m_modifier.m_miscvalue2);
1989
1990 if(m_modifier.m_miscvalue == 1)
1991 {
1992 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MINDAMAGE, m_modifier.m_amount, apply );
1993 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MAXDAMAGE, m_modifier.m_amount, apply );
1994 }
1995 if(m_modifier.m_miscvalue == 126)
1996 {
1997 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE, m_modifier.m_amount, apply );
1998 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE, m_modifier.m_amount, apply );
1999 }
2000 if(m_modifier.m_miscvalue == 127)
2001 {
2002 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MINRANGEDDAMAGE, m_modifier.m_amount, apply );
2003 m_target->ApplyPercentModFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE, m_modifier.m_amount, apply );
2004 }
2005 }
2006
2007 void Aura::HandleModPercentStat(bool apply)
2008 {
2009 m_target->ApplyMaxHealthPercentMod(m_modifier.m_amount, apply );
2010 m_target->ApplyMaxPowerPercentMod(POWER_MANA, m_modifier.m_amount, apply );
2011 m_target->ApplyMaxPowerPercentMod(POWER_RAGE, m_modifier.m_amount, apply );
2012 m_target->ApplyMaxPowerPercentMod(POWER_FOCUS, m_modifier.m_amount, apply );
2013 m_target->ApplyMaxPowerPercentMod(POWER_ENERGY, m_modifier.m_amount, apply );
2014 m_target->ApplyMaxPowerPercentMod(POWER_HAPPINESS,m_modifier.m_amount, apply );
2015 if(m_modifier.m_miscvalue == 0 || m_modifier.m_miscvalue == -1)
2016 m_target->ApplyStatPercentMod(STAT_STRENGTH,m_modifier.m_amount, apply );
2017 if(m_modifier.m_miscvalue == 1 || m_modifier.m_miscvalue == -1)
2018 m_target->ApplyStatPercentMod(STAT_AGILITY, m_modifier.m_amount, apply );
2019 if(m_modifier.m_miscvalue == 2 || m_modifier.m_miscvalue == -1)
2020 m_target->ApplyStatPercentMod(STAT_STAMINA, m_modifier.m_amount, apply );
2021 if(m_modifier.m_miscvalue == 3 || m_modifier.m_miscvalue == -1)
2022 m_target->ApplyStatPercentMod(STAT_INTELLECT,m_modifier.m_amount, apply );
2023 if(m_modifier.m_miscvalue == 4 || m_modifier.m_miscvalue == -1)
2024 m_target->ApplyStatPercentMod(STAT_SPIRIT, m_modifier.m_amount, apply );
2025 }
2026
2027 void Aura::HandleModResistancePercent(bool apply)
2028 {
2029 if(m_modifier.m_miscvalue == 1 || m_modifier.m_miscvalue == 127)
2030 m_target->ApplyArmorPercentMod(m_modifier.m_amount, apply );
2031 if(m_modifier.m_miscvalue == 127 || m_modifier.m_miscvalue == 126)
2032 {
2033 m_target->ApplyResistancePercentMod(SPELL_SCHOOL_HOLY, m_modifier.m_amount, apply );
2034 m_target->ApplyResistancePercentMod(SPELL_SCHOOL_FIRE, m_modifier.m_amount, apply );
2035 m_target->ApplyResistancePercentMod(SPELL_SCHOOL_NATURE, m_modifier.m_amount, apply );
2036 m_target->ApplyResistancePercentMod(SPELL_SCHOOL_FROST, m_modifier.m_amount, apply );
2037 m_target->ApplyResistancePercentMod(SPELL_SCHOOL_SHADOW, m_modifier.m_amount, apply );
2038 m_target->ApplyResistancePercentMod(SPELL_SCHOOL_ARCANE, m_modifier.m_amount, apply );
2039 }
2040 }
2041
2042 void Aura::HandleAuraModBaseResistancePCT(bool apply)
2043 {
2044 SpellSchools school = SPELL_SCHOOL_NORMAL;
2045 uint16 index2 = 0;
2046 switch(m_modifier.m_miscvalue)
2047 {
2048 case IMMUNE_SCHOOL_PHYSICAL:
2049 {
2050 school = SPELL_SCHOOL_NORMAL;
2051 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE;
2052 }break;
2053 case IMMUNE_SCHOOL_HOLY:
2054 {
2055 school = SPELL_SCHOOL_HOLY;
2056 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_01 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_01;
2057 }break;
2058 case IMMUNE_SCHOOL_FIRE:
2059 {
2060 school = SPELL_SCHOOL_FIRE;
2061 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_02 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_02;
2062 }break;
2063 case IMMUNE_SCHOOL_NATURE:
2064 {
2065 school = SPELL_SCHOOL_NATURE;
2066 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_03 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_03;
2067 }break;
2068 case IMMUNE_SCHOOL_FROST:
2069 {
2070 school = SPELL_SCHOOL_FROST;
2071 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_04 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_04;
2072 }break;
2073 case IMMUNE_SCHOOL_SHADOW:
2074 {
2075 school = SPELL_SCHOOL_SHADOW;
2076 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_05 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_05;
2077 }break;
2078 case IMMUNE_SCHOOL_ARCANE:
2079 {
2080 school = SPELL_SCHOOL_ARCANE;
2081 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_06 : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_06;
2082 }
2083 break;
2084 case IMMUNE_SCHOOL_MAGIC:
2085 {
2086 for(int8 x=0;x < 6;x++)
2087 {
2088 school = SpellSchools(IMMUNE_SCHOOL_HOLY + x);
2089 m_modifier.m_miscvalue2 == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE_01 + x : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE_01 + x;
2090
2091 m_target->ApplyResistancePercentMod(school,m_modifier.m_amount, apply);
2092 if(m_target->GetTypeId() == TYPEID_PLAYER)
2093 m_target->ApplyPercentModUInt32Value(index2,m_modifier.m_amount, apply);
2094 }
2095 return;
2096 }break;
2097
2098 default:
2099 {
2100 sLog.outString("WARNING: Misc Value for SPELL_AURA_MOD_STAT not valid");
2101 return;
2102 }break;
2103 }
2104
2105 m_target->ApplyResistancePercentMod(school,m_modifier.m_amount,apply);
2106 if(m_target->GetTypeId() == TYPEID_PLAYER)
2107 m_target->ApplyPercentModUInt32Value(index2,m_modifier.m_amount,apply);
2108 }
2109
2110 void Aura::HandleForceReaction(bool Apply)
2111 {
2112 if(m_target->GetTypeId() != TYPEID_PLAYER)
2113 return;
2114
2115 if(Apply)
2116 {
2117 uint32 faction_id = m_modifier.m_miscvalue;
2118
2119 FactionTemplateEntry *factionTemplateEntry;
2120
2121 for(uint32 i = 0; i < sFactionTemplateStore.GetNumRows(); ++i)
2122 {
2123 factionTemplateEntry = sFactionTemplateStore.LookupEntry(i);
2124 if(!factionTemplateEntry)
2125 continue;
2126
2127 if(factionTemplateEntry->faction == faction_id)
2128 break;
2129 }
2130
2131 if(!factionTemplateEntry)
2132 return;
2133
2134 m_target->setFaction(factionTemplateEntry->ID);
2135 }
2136 else
2137 ((Player*)m_target)->setFactionForRace(((Player*)m_target)->getRace());
2138 }
2139
2140 void Aura::HandleRangedAmmoHaste(bool apply)
2141 {
2142 if(m_target->GetTypeId() != TYPEID_PLAYER)
2143 return;
2144 m_target->ApplyPercentModUInt32Value(UNIT_FIELD_RANGEDATTACKTIME,m_modifier.m_amount, apply);
2145 }
2146
2147 void Aura::SendCoolDownEvent()
2148 {
2149 WorldPacket data;
2150 data.Initialize(SMSG_COOLDOWN_EVENT);
2151 data << uint32(m_spellId) << m_caster->GetGUID();
2152 data << uint32(0); //CoolDown Time ?
2153 m_caster->SendMessageToSet(&data,true);
2154 }
2155
2156 bool Aura::IsSingleTarget()
2157 {
2158 SpellEntry *spellInfo = GetSpellProto();
2159 if (!spellInfo) return false;
2160
2161 // cheap shot is an exception
2162 if ( m_spellId == 1833 || m_spellId == 14902 ) return false;
2163
2164 // cannot be cast on another target while not cooled down anyway
2165 if ( GetAuraDuration() < spellInfo->RecoveryTime) return false;
2166 if ( spellInfo->RecoveryTime == 0 && GetAuraDuration() < spellInfo->CategoryRecoveryTime) return false;
2167
2168 // all other single target spells have if it has AttributesEx
2169 if ( spellInfo->AttributesEx & (1<<18) ) return true;
2170
2171 // other single target
2172 //Entangling Roots
2173 if ( (spellInfo->SpellIconID == 20 && spellInfo->SpellVisual == 38)
2174 //Fear
2175 || (spellInfo->SpellIconID == 98 && spellInfo->SpellVisual == 336)
2176 //Banish
2177 || (spellInfo->SpellIconID == 96 && spellInfo->SpellVisual == 1305)
2178 //Mind Control
2179 || (spellInfo->SpellIconID == 235 && spellInfo->SpellVisual == 137)
2180 ) return true;
2181 // all other single target spells have if it has Attributes
2182 //if ( spellInfo->Attributes & (1<<30) ) return true;
2183 return false;
2184 }
Open Source reference implementation for a MMORPG server system