Context Navigation

SpellEffects.cpp @ 79

Revision 79, 237.1 kB (checked in by yumileroy, 17 years ago)

[svn] * Minor code fixes
* Move account related functions from ObjectMgr? to AccountMgr? and drop duplicate functions - source mangos
* recognize the dummy spells 38637, 38638 and 38639 as negative - source mangos
* added new command ".reload all_locales". Now all locales_* tables can be reloaded - source mangos

Original author: KingPin?
Date: 2008-10-20 12:59:45-05:00

Line
1	/*
2	* Copyright (C) 2008 Trinity <http://www.trinitycore.org/>
3	*
4	* Thanks to the original authors: MaNGOS <http://www.mangosproject.org/>
5	*
6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	*/
20
21	#include "Common.h"
22	#include "SharedDefines.h"
23	#include "Database/DatabaseEnv.h"
24	#include "WorldPacket.h"
25	#include "WorldSession.h"
26	#include "Opcodes.h"
27	#include "Log.h"
28	#include "UpdateMask.h"
29	#include "World.h"
30	#include "ObjectMgr.h"
31	#include "SpellMgr.h"
32	#include "Player.h"
33	#include "SkillExtraItems.h"
34	#include "Unit.h"
35	#include "CreatureAI.h"
36	#include "Spell.h"
37	#include "DynamicObject.h"
38	#include "SpellAuras.h"
39	#include "Group.h"
40	#include "UpdateData.h"
41	#include "MapManager.h"
42	#include "ObjectAccessor.h"
43	#include "SharedDefines.h"
44	#include "Pet.h"
45	#include "GameObject.h"
46	#include "GossipDef.h"
47	#include "Creature.h"
48	#include "Totem.h"
49	#include "CreatureAI.h"
50	#include "BattleGround.h"
51	#include "BattleGroundEY.h"
52	#include "BattleGroundWS.h"
53	#include "OutdoorPvPMgr.h"
54	#include "VMapFactory.h"
55	#include "Language.h"
56	#include "SocialMgr.h"
57	#include "Util.h"
58	#include "TemporarySummon.h"
59
60
61	pEffect SpellEffects[TOTAL_SPELL_EFFECTS]=
62	{
63	&Spell::EffectNULL, // 0
64	&Spell::EffectInstaKill, // 1 SPELL_EFFECT_INSTAKILL
65	&Spell::EffectSchoolDMG, // 2 SPELL_EFFECT_SCHOOL_DAMAGE
66	&Spell::EffectDummy, // 3 SPELL_EFFECT_DUMMY
67	&Spell::EffectUnused, // 4 SPELL_EFFECT_PORTAL_TELEPORT unused
68	&Spell::EffectTeleportUnits, // 5 SPELL_EFFECT_TELEPORT_UNITS
69	&Spell::EffectApplyAura, // 6 SPELL_EFFECT_APPLY_AURA
70	&Spell::EffectEnvirinmentalDMG, // 7 SPELL_EFFECT_ENVIRONMENTAL_DAMAGE
71	&Spell::EffectPowerDrain, // 8 SPELL_EFFECT_POWER_DRAIN
72	&Spell::EffectHealthLeech, // 9 SPELL_EFFECT_HEALTH_LEECH
73	&Spell::EffectHeal, // 10 SPELL_EFFECT_HEAL
74	&Spell::EffectUnused, // 11 SPELL_EFFECT_BIND
75	&Spell::EffectNULL, // 12 SPELL_EFFECT_PORTAL
76	&Spell::EffectUnused, // 13 SPELL_EFFECT_RITUAL_BASE unused
77	&Spell::EffectUnused, // 14 SPELL_EFFECT_RITUAL_SPECIALIZE unused
78	&Spell::EffectUnused, // 15 SPELL_EFFECT_RITUAL_ACTIVATE_PORTAL unused
79	&Spell::EffectQuestComplete, // 16 SPELL_EFFECT_QUEST_COMPLETE
80	&Spell::EffectWeaponDmg, // 17 SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL
81	&Spell::EffectResurrect, // 18 SPELL_EFFECT_RESURRECT
82	&Spell::EffectAddExtraAttacks, // 19 SPELL_EFFECT_ADD_EXTRA_ATTACKS
83	&Spell::EffectUnused, // 20 SPELL_EFFECT_DODGE one spell: Dodge
84	&Spell::EffectUnused, // 21 SPELL_EFFECT_EVADE one spell: Evade (DND)
85	&Spell::EffectParry, // 22 SPELL_EFFECT_PARRY
86	&Spell::EffectBlock, // 23 SPELL_EFFECT_BLOCK one spell: Block
87	&Spell::EffectCreateItem, // 24 SPELL_EFFECT_CREATE_ITEM
88	&Spell::EffectUnused, // 25 SPELL_EFFECT_WEAPON
89	&Spell::EffectUnused, // 26 SPELL_EFFECT_DEFENSE one spell: Defense
90	&Spell::EffectPersistentAA, // 27 SPELL_EFFECT_PERSISTENT_AREA_AURA
91	&Spell::EffectSummonType, // 28 SPELL_EFFECT_SUMMON
92	&Spell::EffectMomentMove, // 29 SPELL_EFFECT_LEAP
93	&Spell::EffectEnergize, // 30 SPELL_EFFECT_ENERGIZE
94	&Spell::EffectWeaponDmg, // 31 SPELL_EFFECT_WEAPON_PERCENT_DAMAGE
95	&Spell::EffectTriggerMissileSpell, // 32 SPELL_EFFECT_TRIGGER_MISSILE
96	&Spell::EffectOpenLock, // 33 SPELL_EFFECT_OPEN_LOCK
97	&Spell::EffectSummonChangeItem, // 34 SPELL_EFFECT_SUMMON_CHANGE_ITEM
98	&Spell::EffectApplyAreaAura, // 35 SPELL_EFFECT_APPLY_AREA_AURA_PARTY
99	&Spell::EffectLearnSpell, // 36 SPELL_EFFECT_LEARN_SPELL
100	&Spell::EffectUnused, // 37 SPELL_EFFECT_SPELL_DEFENSE one spell: SPELLDEFENSE (DND)
101	&Spell::EffectDispel, // 38 SPELL_EFFECT_DISPEL
102	&Spell::EffectUnused, // 39 SPELL_EFFECT_LANGUAGE
103	&Spell::EffectDualWield, // 40 SPELL_EFFECT_DUAL_WIELD
104	&Spell::EffectSummonWild, // 41 SPELL_EFFECT_SUMMON_WILD
105	&Spell::EffectSummonGuardian, // 42 SPELL_EFFECT_SUMMON_GUARDIAN
106	&Spell::EffectTeleUnitsFaceCaster, // 43 SPELL_EFFECT_TELEPORT_UNITS_FACE_CASTER
107	&Spell::EffectLearnSkill, // 44 SPELL_EFFECT_SKILL_STEP
108	&Spell::EffectAddHonor, // 45 SPELL_EFFECT_ADD_HONOR honor/pvp related
109	&Spell::EffectNULL, // 46 SPELL_EFFECT_SPAWN we must spawn pet there
110	&Spell::EffectTradeSkill, // 47 SPELL_EFFECT_TRADE_SKILL
111	&Spell::EffectUnused, // 48 SPELL_EFFECT_STEALTH one spell: Base Stealth
112	&Spell::EffectUnused, // 49 SPELL_EFFECT_DETECT one spell: Detect
113	&Spell::EffectTransmitted, // 50 SPELL_EFFECT_TRANS_DOOR
114	&Spell::EffectUnused, // 51 SPELL_EFFECT_FORCE_CRITICAL_HIT unused
115	&Spell::EffectUnused, // 52 SPELL_EFFECT_GUARANTEE_HIT one spell: zzOLDCritical Shot
116	&Spell::EffectEnchantItemPerm, // 53 SPELL_EFFECT_ENCHANT_ITEM
117	&Spell::EffectEnchantItemTmp, // 54 SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY
118	&Spell::EffectTameCreature, // 55 SPELL_EFFECT_TAMECREATURE
119	&Spell::EffectSummonPet, // 56 SPELL_EFFECT_SUMMON_PET
120	&Spell::EffectLearnPetSpell, // 57 SPELL_EFFECT_LEARN_PET_SPELL
121	&Spell::EffectWeaponDmg, // 58 SPELL_EFFECT_WEAPON_DAMAGE
122	&Spell::EffectOpenSecretSafe, // 59 SPELL_EFFECT_OPEN_LOCK_ITEM
123	&Spell::EffectProficiency, // 60 SPELL_EFFECT_PROFICIENCY
124	&Spell::EffectSendEvent, // 61 SPELL_EFFECT_SEND_EVENT
125	&Spell::EffectPowerBurn, // 62 SPELL_EFFECT_POWER_BURN
126	&Spell::EffectThreat, // 63 SPELL_EFFECT_THREAT
127	&Spell::EffectTriggerSpell, // 64 SPELL_EFFECT_TRIGGER_SPELL
128	&Spell::EffectUnused, // 65 SPELL_EFFECT_HEALTH_FUNNEL unused
129	&Spell::EffectUnused, // 66 SPELL_EFFECT_POWER_FUNNEL unused
130	&Spell::EffectHealMaxHealth, // 67 SPELL_EFFECT_HEAL_MAX_HEALTH
131	&Spell::EffectInterruptCast, // 68 SPELL_EFFECT_INTERRUPT_CAST
132	&Spell::EffectDistract, // 69 SPELL_EFFECT_DISTRACT
133	&Spell::EffectPull, // 70 SPELL_EFFECT_PULL one spell: Distract Move
134	&Spell::EffectPickPocket, // 71 SPELL_EFFECT_PICKPOCKET
135	&Spell::EffectAddFarsight, // 72 SPELL_EFFECT_ADD_FARSIGHT
136	&Spell::EffectSummonGuardian, // 73 SPELL_EFFECT_SUMMON_POSSESSED
137	&Spell::EffectSummonTotem, // 74 SPELL_EFFECT_SUMMON_TOTEM
138	&Spell::EffectHealMechanical, // 75 SPELL_EFFECT_HEAL_MECHANICAL one spell: Mechanical Patch Kit
139	&Spell::EffectSummonObjectWild, // 76 SPELL_EFFECT_SUMMON_OBJECT_WILD
140	&Spell::EffectScriptEffect, // 77 SPELL_EFFECT_SCRIPT_EFFECT
141	&Spell::EffectUnused, // 78 SPELL_EFFECT_ATTACK
142	&Spell::EffectSanctuary, // 79 SPELL_EFFECT_SANCTUARY
143	&Spell::EffectAddComboPoints, // 80 SPELL_EFFECT_ADD_COMBO_POINTS
144	&Spell::EffectUnused, // 81 SPELL_EFFECT_CREATE_HOUSE one spell: Create House (TEST)
145	&Spell::EffectNULL, // 82 SPELL_EFFECT_BIND_SIGHT
146	&Spell::EffectDuel, // 83 SPELL_EFFECT_DUEL
147	&Spell::EffectStuck, // 84 SPELL_EFFECT_STUCK
148	&Spell::EffectSummonPlayer, // 85 SPELL_EFFECT_SUMMON_PLAYER
149	&Spell::EffectActivateObject, // 86 SPELL_EFFECT_ACTIVATE_OBJECT
150	&Spell::EffectSummonTotem, // 87 SPELL_EFFECT_SUMMON_TOTEM_SLOT1
151	&Spell::EffectSummonTotem, // 88 SPELL_EFFECT_SUMMON_TOTEM_SLOT2
152	&Spell::EffectSummonTotem, // 89 SPELL_EFFECT_SUMMON_TOTEM_SLOT3
153	&Spell::EffectSummonTotem, // 90 SPELL_EFFECT_SUMMON_TOTEM_SLOT4
154	&Spell::EffectUnused, // 91 SPELL_EFFECT_THREAT_ALL one spell: zzOLDBrainwash
155	&Spell::EffectEnchantHeldItem, // 92 SPELL_EFFECT_ENCHANT_HELD_ITEM
156	&Spell::EffectUnused, // 93 SPELL_EFFECT_SUMMON_PHANTASM
157	&Spell::EffectSelfResurrect, // 94 SPELL_EFFECT_SELF_RESURRECT
158	&Spell::EffectSkinning, // 95 SPELL_EFFECT_SKINNING
159	&Spell::EffectCharge, // 96 SPELL_EFFECT_CHARGE
160	&Spell::EffectSummonCritter, // 97 SPELL_EFFECT_SUMMON_CRITTER
161	&Spell::EffectKnockBack, // 98 SPELL_EFFECT_KNOCK_BACK
162	&Spell::EffectDisEnchant, // 99 SPELL_EFFECT_DISENCHANT
163	&Spell::EffectInebriate, //100 SPELL_EFFECT_INEBRIATE
164	&Spell::EffectFeedPet, //101 SPELL_EFFECT_FEED_PET
165	&Spell::EffectDismissPet, //102 SPELL_EFFECT_DISMISS_PET
166	&Spell::EffectReputation, //103 SPELL_EFFECT_REPUTATION
167	&Spell::EffectSummonObject, //104 SPELL_EFFECT_SUMMON_OBJECT_SLOT1
168	&Spell::EffectSummonObject, //105 SPELL_EFFECT_SUMMON_OBJECT_SLOT2
169	&Spell::EffectSummonObject, //106 SPELL_EFFECT_SUMMON_OBJECT_SLOT3
170	&Spell::EffectSummonObject, //107 SPELL_EFFECT_SUMMON_OBJECT_SLOT4
171	&Spell::EffectDispelMechanic, //108 SPELL_EFFECT_DISPEL_MECHANIC
172	&Spell::EffectSummonDeadPet, //109 SPELL_EFFECT_SUMMON_DEAD_PET
173	&Spell::EffectDestroyAllTotems, //110 SPELL_EFFECT_DESTROY_ALL_TOTEMS
174	&Spell::EffectDurabilityDamage, //111 SPELL_EFFECT_DURABILITY_DAMAGE
175	&Spell::EffectSummonDemon, //112 SPELL_EFFECT_SUMMON_DEMON
176	&Spell::EffectResurrectNew, //113 SPELL_EFFECT_RESURRECT_NEW
177	&Spell::EffectTaunt, //114 SPELL_EFFECT_ATTACK_ME
178	&Spell::EffectDurabilityDamagePCT, //115 SPELL_EFFECT_DURABILITY_DAMAGE_PCT
179	&Spell::EffectSkinPlayerCorpse, //116 SPELL_EFFECT_SKIN_PLAYER_CORPSE one spell: Remove Insignia, bg usage, required special corpse flags...
180	&Spell::EffectSpiritHeal, //117 SPELL_EFFECT_SPIRIT_HEAL one spell: Spirit Heal
181	&Spell::EffectSkill, //118 SPELL_EFFECT_SKILL professions and more
182	&Spell::EffectApplyAreaAura, //119 SPELL_EFFECT_APPLY_AREA_AURA_PET
183	&Spell::EffectUnused, //120 SPELL_EFFECT_TELEPORT_GRAVEYARD one spell: Graveyard Teleport Test
184	&Spell::EffectWeaponDmg, //121 SPELL_EFFECT_NORMALIZED_WEAPON_DMG
185	&Spell::EffectUnused, //122 SPELL_EFFECT_122 unused
186	&Spell::EffectSendTaxi, //123 SPELL_EFFECT_SEND_TAXI taxi/flight related (misc value is taxi path id)
187	&Spell::EffectPlayerPull, //124 SPELL_EFFECT_PLAYER_PULL opposite of knockback effect (pulls player twoard caster)
188	&Spell::EffectModifyThreatPercent, //125 SPELL_EFFECT_MODIFY_THREAT_PERCENT
189	&Spell::EffectStealBeneficialBuff, //126 SPELL_EFFECT_STEAL_BENEFICIAL_BUFF spell steal effect?
190	&Spell::EffectProspecting, //127 SPELL_EFFECT_PROSPECTING Prospecting spell
191	&Spell::EffectApplyAreaAura, //128 SPELL_EFFECT_APPLY_AREA_AURA_FRIEND
192	&Spell::EffectApplyAreaAura, //129 SPELL_EFFECT_APPLY_AREA_AURA_ENEMY
193	&Spell::EffectNULL, //130 SPELL_EFFECT_REDIRECT_THREAT
194	&Spell::EffectUnused, //131 SPELL_EFFECT_131 used in some test spells
195	&Spell::EffectNULL, //132 SPELL_EFFECT_PLAY_MUSIC sound id in misc value
196	&Spell::EffectUnlearnSpecialization, //133 SPELL_EFFECT_UNLEARN_SPECIALIZATION unlearn profession specialization
197	&Spell::EffectKillCredit, //134 SPELL_EFFECT_KILL_CREDIT misc value is creature entry
198	&Spell::EffectNULL, //135 SPELL_EFFECT_CALL_PET
199	&Spell::EffectHealPct, //136 SPELL_EFFECT_HEAL_PCT
200	&Spell::EffectEnergisePct, //137 SPELL_EFFECT_ENERGIZE_PCT
201	&Spell::EffectNULL, //138 SPELL_EFFECT_138 Leap
202	&Spell::EffectUnused, //139 SPELL_EFFECT_139 unused
203	&Spell::EffectForceCast, //140 SPELL_EFFECT_FORCE_CAST
204	&Spell::EffectNULL, //141 SPELL_EFFECT_141 damage and reduce speed?
205	&Spell::EffectTriggerSpellWithValue, //142 SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE
206	&Spell::EffectApplyAreaAura, //143 SPELL_EFFECT_APPLY_AREA_AURA_OWNER
207	&Spell::EffectNULL, //144 SPELL_EFFECT_144 Spectral Blast
208	&Spell::EffectNULL, //145 SPELL_EFFECT_145 Black Hole Effect
209	&Spell::EffectUnused, //146 SPELL_EFFECT_146 unused
210	&Spell::EffectQuestFail, //147 SPELL_EFFECT_QUEST_FAIL quest fail
211	&Spell::EffectUnused, //148 SPELL_EFFECT_148 unused
212	&Spell::EffectNULL, //149 SPELL_EFFECT_149 swoop
213	&Spell::EffectUnused, //150 SPELL_EFFECT_150 unused
214	&Spell::EffectTriggerRitualOfSummoning, //151 SPELL_EFFECT_TRIGGER_SPELL_2
215	&Spell::EffectNULL, //152 SPELL_EFFECT_152 summon Refer-a-Friend
216	&Spell::EffectNULL, //153 SPELL_EFFECT_CREATE_PET misc value is creature entry
217	};
218
219	void Spell::EffectNULL(uint32 /i/)
220	{
221	sLog.outDebug("WORLD: Spell Effect DUMMY");
222	}
223
224	void Spell::EffectUnused(uint32 /i/)
225	{
226	// NOT USED BY ANY SPELL OR USELESS OR IMPLEMENTED IN DIFFERENT WAY IN TRINITY
227	}
228
229	void Spell::EffectResurrectNew(uint32 i)
230	{
231	if(!unitTarget \|\| unitTarget->isAlive())
232	return;
233
234	if(unitTarget->GetTypeId() != TYPEID_PLAYER)
235	return;
236
237	if(!unitTarget->IsInWorld())
238	return;
239
240	Player* pTarget = ((Player*)unitTarget);
241
242	if(pTarget->isRessurectRequested()) // already have one active request
243	return;
244
245	uint32 health = damage;
246	uint32 mana = m_spellInfo->EffectMiscValue[i];
247	pTarget->setResurrectRequestData(m_caster->GetGUID(), m_caster->GetMapId(), m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ(), health, mana);
248	SendResurrectRequest(pTarget);
249	}
250
251	void Spell::EffectInstaKill(uint32 /i/)
252	{
253	if( !unitTarget \|\| !unitTarget->isAlive() )
254	return;
255
256	// Demonic Sacrifice
257	if(m_spellInfo->Id==18788 && unitTarget->GetTypeId()==TYPEID_UNIT)
258	{
259	uint32 entry = unitTarget->GetEntry();
260	uint32 spellID;
261	switch(entry)
262	{
263	case 416: spellID=18789; break; //imp
264	case 417: spellID=18792; break; //fellhunter
265	case 1860: spellID=18790; break; //void
266	case 1863: spellID=18791; break; //succubus
267	case 17252: spellID=35701; break; //fellguard
268	default:
269	sLog.outError("EffectInstaKill: Unhandled creature entry (%u) case.",entry);
270	return;
271	}
272
273	m_caster->CastSpell(m_caster,spellID,true);
274	}
275
276	if(m_caster==unitTarget) // prevent interrupt message
277	finish();
278
279	uint32 health = unitTarget->GetHealth();
280	m_caster->DealDamage(unitTarget, health, NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
281	}
282
283	void Spell::EffectEnvirinmentalDMG(uint32 i)
284	{
285	uint32 absorb = 0;
286	uint32 resist = 0;
287
288	// Note: this hack with damage replace required until GO casting not implemented
289	// environment damage spells already have around enemies targeting but this not help in case not existed GO casting support
290	// currently each enemy selected explicitly and self cast damage, we prevent apply self casted spell bonuses/etc
291	damage = m_spellInfo->EffectBasePoints[i]+m_spellInfo->EffectBaseDice[i];
292
293	m_caster->CalcAbsorbResist(m_caster,GetSpellSchoolMask(m_spellInfo), SPELL_DIRECT_DAMAGE, damage, &absorb, &resist);
294
295	m_caster->SendSpellNonMeleeDamageLog(m_caster, m_spellInfo->Id, damage, GetSpellSchoolMask(m_spellInfo), absorb, resist, false, 0, false);
296	if(m_caster->GetTypeId() == TYPEID_PLAYER)
297	((Player*)m_caster)->EnvironmentalDamage(m_caster->GetGUID(),DAMAGE_FIRE,damage);
298	}
299
300	void Spell::EffectSchoolDMG(uint32 effect_idx)
301	{
302	if( unitTarget && unitTarget->isAlive())
303	{
304	switch(m_spellInfo->SpellFamilyName)
305	{
306	case SPELLFAMILY_GENERIC:
307	{
308	//Gore
309	if(m_spellInfo->SpellIconID == 2269 )
310	{
311	damage+= rand()%2 ? damage : 0;
312	}
313
314	switch(m_spellInfo->Id) // better way to check unknown
315	{
316	// Meteor like spells (divided damage to targets)
317	case 24340: case 26558: case 28884: // Meteor
318	case 36837: case 38903: case 41276: // Meteor
319	case 26789: // Shard of the Fallen Star
320	case 31436: // Malevolent Cleave
321	case 35181: // Dive Bomb
322	case 40810: case 43267: case 43268: // Saber Lash
323	case 42384: // Brutal Swipe
324	case 45150: // Meteor Slash
325	{
326	uint32 count = 0;
327	for(std::list<TargetInfo>::iterator ihit= m_UniqueTargetInfo.begin();ihit != m_UniqueTargetInfo.end();++ihit)
328	if(ihit->effectMask & (1<<effect_idx))
329	++count;
330
331	damage /= count; // divide to all targets
332	break;
333	}
334	// percent from health with min
335	case 25599: // Thundercrash
336	{
337	damage = unitTarget->GetHealth() / 2;
338	if(damage < 200)
339	damage = 200;
340	break;
341	}
342	// must only affect demons
343	case 45072:
344	{
345	if(unitTarget->GetCreatureType() != CREATURE_TYPE_DEMON)
346	return;
347	break;
348	}
349	}
350	break;
351	}
352
353	case SPELLFAMILY_MAGE:
354	{
355	// Arcane Blast
356	if(m_spellInfo->SpellFamilyFlags & 0x20000000LL)
357	{
358	m_caster->CastSpell(m_caster,36032,true);
359	}
360	break;
361	}
362	case SPELLFAMILY_WARRIOR:
363	{
364	// Bloodthirst
365	if(m_spellInfo->SpellFamilyFlags & 0x40000000000LL)
366	{
367	damage = uint32(damage * (m_caster->GetTotalAttackPowerValue(BASE_ATTACK)) / 100);
368	}
369	// Shield Slam
370	else if(m_spellInfo->SpellFamilyFlags & 0x100000000LL)
371	damage += int32(m_caster->GetShieldBlockValue());
372	// Victory Rush
373	else if(m_spellInfo->SpellFamilyFlags & 0x10000000000LL)
374	{
375	damage = uint32(damage * m_caster->GetTotalAttackPowerValue(BASE_ATTACK) / 100);
376	m_caster->ModifyAuraState(AURA_STATE_WARRIOR_VICTORY_RUSH, false);
377	}
378	break;
379	}
380	case SPELLFAMILY_WARLOCK:
381	{
382	// Incinerate Rank 1 & 2
383	if((m_spellInfo->SpellFamilyFlags & 0x00004000000000LL) && m_spellInfo->SpellIconID==2128)
384	{
385	// Incinerate does more dmg (dmg*0.25) if the target is Immolated.
386	if(unitTarget->HasAuraState(AURA_STATE_IMMOLATE))
387	damage += int32(damage*0.25);
388	}
389	break;
390	}
391	case SPELLFAMILY_DRUID:
392	{
393	// Ferocious Bite
394	if((m_spellInfo->SpellFamilyFlags & 0x000800000) && m_spellInfo->SpellVisual==6587)
395	{
396	// converts each extra point of energy into ($f1+$AP/630) additional damage
397	float multiple = m_caster->GetTotalAttackPowerValue(BASE_ATTACK) / 630 + m_spellInfo->DmgMultiplier[effect_idx];
398	damage += int32(m_caster->GetPower(POWER_ENERGY) * multiple);
399	m_caster->SetPower(POWER_ENERGY,0);
400	}
401	// Rake
402	else if(m_spellInfo->SpellFamilyFlags & 0x0000000000001000LL)
403	{
404	damage += int32(m_caster->GetTotalAttackPowerValue(BASE_ATTACK) / 100);
405	}
406	// Swipe
407	else if(m_spellInfo->SpellFamilyFlags & 0x0010000000000000LL)
408	{
409	damage += int32(m_caster->GetTotalAttackPowerValue(BASE_ATTACK)*0.08f);
410	}
411	// Starfire
412	else if ( m_spellInfo->SpellFamilyFlags & 0x0004LL )
413	{
414	Unit::AuraList const& m_OverrideClassScript = m_caster->GetAurasByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
415	for(Unit::AuraList::const_iterator i = m_OverrideClassScript.begin(); i != m_OverrideClassScript.end(); ++i)
416	{
417	// Starfire Bonus (caster)
418	switch((*i)->GetModifier()->m_miscvalue)
419	{
420	case 5481: // Nordrassil Regalia - bonus
421	{
422	Unit::AuraList const& m_periodicDamageAuras = unitTarget->GetAurasByType(SPELL_AURA_PERIODIC_DAMAGE);
423	for(Unit::AuraList::const_iterator itr = m_periodicDamageAuras.begin(); itr != m_periodicDamageAuras.end(); ++itr)
424	{
425	// Moonfire or Insect Swarm (target debuff from any casters)
426	if ( (*itr)->GetSpellProto()->SpellFamilyFlags & 0x00200002LL )
427	{
428	int32 mod = (*i)->GetModifier()->m_amount;
429	damage += damage*mod/100;
430	break;
431	}
432	}
433	break;
434	}
435	case 5148: //Improved Starfire - Ivory Idol of the Moongoddes Aura
436	{
437	damage += (*i)->GetModifier()->m_amount;
438	break;
439	}
440	}
441	}
442	}
443	//Mangle Bonus for the initial damage of Lacerate and Rake
444	if((m_spellInfo->SpellFamilyFlags==0x0000000000001000LL && m_spellInfo->SpellIconID==494) \|\|
445	(m_spellInfo->SpellFamilyFlags==0x0000010000000000LL && m_spellInfo->SpellIconID==2246))
446	{
447	Unit::AuraList const& mDummyAuras = unitTarget->GetAurasByType(SPELL_AURA_DUMMY);
448	for(Unit::AuraList::const_iterator i = mDummyAuras.begin(); i != mDummyAuras.end(); ++i)
449	if((i)->GetSpellProto()->SpellFamilyFlags & 0x0000044000000000LL && (i)->GetSpellProto()->SpellFamilyName==SPELLFAMILY_DRUID)
450	{
451	damage = int32(damage(100.0f+(i)->GetModifier()->m_amount)/100.0f);
452	break;
453	}
454	}
455	break;
456	}
457	case SPELLFAMILY_ROGUE:
458	{
459	// Envenom
460	if(m_caster->GetTypeId()==TYPEID_PLAYER && (m_spellInfo->SpellFamilyFlags & 0x800000000LL))
461	{
462	// consume from stack dozes not more that have combo-points
463	if(uint32 combo = ((Player*)m_caster)->GetComboPoints())
464	{
465	// count consumed deadly poison doses at target
466	uint32 doses = 0;
467
468	// remove consumed poison doses
469	Unit::AuraList const& auras = unitTarget->GetAurasByType(SPELL_AURA_PERIODIC_DAMAGE);
470	for(Unit::AuraList::const_iterator itr = auras.begin(); itr!=auras.end() && combo;)
471	{
472	// Deadly poison (only attacker applied)
473	if( (itr)->GetSpellProto()->SpellFamilyName==SPELLFAMILY_ROGUE && ((itr)->GetSpellProto()->SpellFamilyFlags & 0x10000) &&
474	(itr)->GetSpellProto()->SpellVisual==5100 && (itr)->GetCasterGUID()==m_caster->GetGUID() )
475	{
476	--combo;
477	++doses;
478
479	unitTarget->RemoveSingleAuraFromStack((itr)->GetId(), (itr)->GetEffIndex());
480
481	itr = auras.begin();
482	}
483	else
484	++itr;
485	}
486
487	damage *= doses;
488	damage += int32(((Player)m_caster)->GetTotalAttackPowerValue(BASE_ATTACK) 0.03f * doses);
489
490	// Eviscerate and Envenom Bonus Damage (item set effect)
491	if(m_caster->GetDummyAura(37169))
492	damage += ((Player)m_caster)->GetComboPoints()40;
493	}
494	}
495	// Eviscerate
496	else if((m_spellInfo->SpellFamilyFlags & 0x00020000LL) && m_caster->GetTypeId()==TYPEID_PLAYER)
497	{
498	if(uint32 combo = ((Player*)m_caster)->GetComboPoints())
499	{
500	damage += int32(m_caster->GetTotalAttackPowerValue(BASE_ATTACK) * combo * 0.03f);
501
502	// Eviscerate and Envenom Bonus Damage (item set effect)
503	if(m_caster->GetDummyAura(37169))
504	damage += combo*40;
505	}
506	}
507	break;
508	}
509	case SPELLFAMILY_HUNTER:
510	{
511	// Mongoose Bite
512	if((m_spellInfo->SpellFamilyFlags & 0x000000002) && m_spellInfo->SpellVisual==342)
513	{
514	damage += int32(m_caster->GetTotalAttackPowerValue(BASE_ATTACK)*0.2);
515	}
516	// Arcane Shot
517	else if((m_spellInfo->SpellFamilyFlags & 0x00000800) && m_spellInfo->maxLevel > 0)
518	{
519	damage += int32(m_caster->GetTotalAttackPowerValue(RANGED_ATTACK)*0.15);
520	}
521	// Steady Shot
522	else if(m_spellInfo->SpellFamilyFlags & 0x100000000LL)
523	{
524	int32 base = irand((int32)m_caster->GetWeaponDamageRange(RANGED_ATTACK, MINDAMAGE),(int32)m_caster->GetWeaponDamageRange(RANGED_ATTACK, MAXDAMAGE));
525	damage += int32(float(base)/m_caster->GetAttackTime(RANGED_ATTACK)2800 + m_caster->GetTotalAttackPowerValue(RANGED_ATTACK)0.2f);
526	}
527	//Explosive Trap Effect
528	else if(m_spellInfo->SpellFamilyFlags & 0x00000004)
529	{
530	damage += int32(m_caster->GetTotalAttackPowerValue(RANGED_ATTACK)*0.1);
531	}
532	break;
533	}
534	case SPELLFAMILY_PALADIN:
535	{
536	//Judgement of Vengeance
537	if((m_spellInfo->SpellFamilyFlags & 0x800000000LL) && m_spellInfo->SpellIconID==2292)
538	{
539	uint32 stacks = 0;
540	Unit::AuraList const& auras = unitTarget->GetAurasByType(SPELL_AURA_PERIODIC_DAMAGE);
541	for(Unit::AuraList::const_iterator itr = auras.begin(); itr!=auras.end(); ++itr)
542	if((itr)->GetId() == 31803 && (itr)->GetCasterGUID()==m_caster->GetGUID())
543	++stacks;
544	if(!stacks)
545	//No damage if the target isn't affected by this
546	damage = -1;
547	else
548	damage *= stacks;
549	}
550	break;
551	}
552	}
553
554	if(damage >= 0)
555	{
556	uint32 finalDamage;
557	if(m_originalCaster) // m_caster only passive source of cast
558	finalDamage = m_originalCaster->SpellNonMeleeDamageLog(unitTarget, m_spellInfo->Id, damage, m_IsTriggeredSpell, true);
559	else
560	finalDamage = m_caster->SpellNonMeleeDamageLog(unitTarget, m_spellInfo->Id, damage, m_IsTriggeredSpell, true);
561
562	// post effects
563	switch(m_spellInfo->SpellFamilyName)
564	{
565	case SPELLFAMILY_WARRIOR:
566	{
567	// Bloodthirst
568	if(m_spellInfo->SpellFamilyFlags & 0x40000000000LL)
569	{
570	uint32 BTAura = 0;
571	switch(m_spellInfo->Id)
572	{
573	case 23881: BTAura = 23885; break;
574	case 23892: BTAura = 23886; break;
575	case 23893: BTAura = 23887; break;
576	case 23894: BTAura = 23888; break;
577	case 25251: BTAura = 25252; break;
578	case 30335: BTAura = 30339; break;
579	default:
580	sLog.outError("Spell::EffectSchoolDMG: Spell %u not handled in BTAura",m_spellInfo->Id);
581	break;
582	}
583
584	if (BTAura)
585	m_caster->CastSpell(m_caster,BTAura,true);
586	}
587	break;
588	}
589	case SPELLFAMILY_PRIEST:
590	{
591	// Shadow Word: Death
592	if(finalDamage > 0 && (m_spellInfo->SpellFamilyFlags & 0x0000000200000000LL) && unitTarget->isAlive())
593	// deals damage equal to damage done to caster if victim is not killed
594	m_caster->SpellNonMeleeDamageLog( m_caster, m_spellInfo->Id, finalDamage, m_IsTriggeredSpell, false);
595
596	break;
597	}
598	case SPELLFAMILY_PALADIN:
599	{
600	// Judgement of Blood
601	if(finalDamage > 0 && (m_spellInfo->SpellFamilyFlags & 0x0000000800000000LL) && m_spellInfo->SpellIconID==153)
602	{
603	int32 damagePoint = finalDamage * 33 / 100;
604	m_caster->CastCustomSpell(m_caster, 32220, &damagePoint, NULL, NULL, true);
605	}
606	break;
607	}
608	}
609	}
610	}
611	}
612
613	void Spell::EffectDummy(uint32 i)
614	{
615	if(!unitTarget && !gameObjTarget && !itemTarget)
616	return;
617
618	// selection by spell family
619	switch(m_spellInfo->SpellFamilyName)
620	{
621	case SPELLFAMILY_GENERIC:
622	// Gnomish Poultryizer trinket
623	switch(m_spellInfo->Id )
624	{
625	case 8063: // Deviate Fish
626	{
627	if(m_caster->GetTypeId() != TYPEID_PLAYER)
628	return;
629
630	uint32 spell_id = 0;
631	switch(urand(1,5))
632	{
633	case 1: spell_id = 8064; break; // Sleepy
634	case 2: spell_id = 8065; break; // Invigorate
635	case 3: spell_id = 8066; break; // Shrink
636	case 4: spell_id = 8067; break; // Party Time!
637	case 5: spell_id = 8068; break; // Healthy Spirit
638	}
639	m_caster->CastSpell(m_caster,spell_id,true,NULL);
640	return;
641	}
642	case 8213: // Savory Deviate Delight
643	{
644	if(m_caster->GetTypeId() != TYPEID_PLAYER)
645	return;
646
647	uint32 spell_id = 0;
648	switch(urand(1,2))
649	{
650	// Flip Out - ninja
651	case 1: spell_id = (m_caster->getGender() == GENDER_MALE ? 8219 : 8220); break;
652	// Yaaarrrr - pirate
653	case 2: spell_id = (m_caster->getGender() == GENDER_MALE ? 8221 : 8222); break;
654	}
655	m_caster->CastSpell(m_caster,spell_id,true,NULL);
656	return;
657	}
658	case 8593: // Symbol of life (restore creature to life)
659	case 31225: // Shimmering Vessel (restore creature to life)
660	{
661	if(!unitTarget \|\| unitTarget->GetTypeId()!=TYPEID_UNIT)
662	return;
663	((Creature*)unitTarget)->setDeathState(JUST_ALIVED);
664	return;
665	}
666	case 12162: // Deep wounds
667	case 12850: // (now good common check for this spells)
668	case 12868:
669	{
670	if(!unitTarget)
671	return;
672
673	float damage;
674	// DW should benefit of attack power, damage percent mods etc.
675	// TODO: check if using offhand damage is correct and if it should be divided by 2
676	if (m_caster->haveOffhandWeapon() && m_caster->getAttackTimer(BASE_ATTACK) > m_caster->getAttackTimer(OFF_ATTACK))
677	damage = (m_caster->GetFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE) + m_caster->GetFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE))/2;
678	else
679	damage = (m_caster->GetFloatValue(UNIT_FIELD_MINDAMAGE) + m_caster->GetFloatValue(UNIT_FIELD_MAXDAMAGE))/2;
680
681	switch (m_spellInfo->Id)
682	{
683	case 12850: damage *= 0.2f; break;
684	case 12162: damage *= 0.4f; break;
685	case 12868: damage *= 0.6f; break;
686	default:
687	sLog.outError("Spell::EffectDummy: Spell %u not handled in DW",m_spellInfo->Id);
688	return;
689	};
690
691	int32 deepWoundsDotBasePoints0 = int32(damage / 4);
692	m_caster->CastCustomSpell(unitTarget, 12721, &deepWoundsDotBasePoints0, NULL, NULL, true, NULL);
693	return;
694	}
695	case 12975: //Last Stand
696	{
697	int32 healthModSpellBasePoints0 = int32(m_caster->GetMaxHealth()*0.3);
698	m_caster->CastCustomSpell(m_caster, 12976, &healthModSpellBasePoints0, NULL, NULL, true, NULL);
699	return;
700	}
701	case 13120: // net-o-matic
702	{
703	if(!unitTarget)
704	return;
705
706	uint32 spell_id = 0;
707
708	uint32 roll = urand(0, 99);
709
710	if(roll < 2) // 2% for 30 sec self root (off-like chance unknown)
711	spell_id = 16566;
712	else if(roll < 4) // 2% for 20 sec root, charge to target (off-like chance unknown)
713	spell_id = 13119;
714	else // normal root
715	spell_id = 13099;
716
717	m_caster->CastSpell(unitTarget,spell_id,true,NULL);
718	return;
719	}
720	case 13567: // Dummy Trigger
721	{
722	// can be used for different aura triggreing, so select by aura
723	if(!m_triggeredByAuraSpell \|\| !unitTarget)
724	return;
725
726	switch(m_triggeredByAuraSpell->Id)
727	{
728	case 26467: // Persistent Shield
729	m_caster->CastCustomSpell(unitTarget, 26470, &damage, NULL, NULL, true);
730	break;
731	default:
732	sLog.outError("EffectDummy: Non-handled case for spell 13567 for triggered aura %u",m_triggeredByAuraSpell->Id);
733	break;
734	}
735	return;
736	}
737	case 14185: // Preparation Rogue
738	{
739	if(m_caster->GetTypeId()!=TYPEID_PLAYER)
740	return;
741
742	//immediately finishes the cooldown on certain Rogue abilities
743	const PlayerSpellMap& sp_list = ((Player *)m_caster)->GetSpellMap();
744	for (PlayerSpellMap::const_iterator itr = sp_list.begin(); itr != sp_list.end(); ++itr)
745	{
746	uint32 classspell = itr->first;
747	SpellEntry const *spellInfo = sSpellStore.LookupEntry(classspell);
748
749	if (spellInfo->SpellFamilyName == SPELLFAMILY_ROGUE && (spellInfo->SpellFamilyFlags & 0x26000000860LL))
750	{
751	((Player*)m_caster)->RemoveSpellCooldown(classspell);
752
753	WorldPacket data(SMSG_CLEAR_COOLDOWN, (4+8));
754	data << uint32(classspell);
755	data << uint64(m_caster->GetGUID());
756	((Player*)m_caster)->GetSession()->SendPacket(&data);
757	}
758	}
759	return;
760	}
761	case 15998: // Capture Worg Pup
762	case 29435: // Capture Female Kaliri Hatchling
763	{
764	if(!unitTarget \|\| unitTarget->GetTypeId() != TYPEID_UNIT)
765	return;
766
767	Creature* creatureTarget = (Creature*)unitTarget;
768	creatureTarget->setDeathState(JUST_DIED);
769	creatureTarget->RemoveCorpse();
770	creatureTarget->SetHealth(0); // just for nice GM-mode view
771	return;
772	}
773	case 16589: // Noggenfogger Elixir
774	{
775	if(m_caster->GetTypeId()!=TYPEID_PLAYER)
776	return;
777
778	uint32 spell_id = 0;
779	switch(urand(1,3))
780	{
781	case 1: spell_id = 16595; break;
782	case 2: spell_id = 16593; break;
783	default:spell_id = 16591; break;
784	}
785
786	m_caster->CastSpell(m_caster,spell_id,true,NULL);
787	return;
788	}
789	case 17251: // Spirit Healer Res
790	{
791	if(!unitTarget \|\| !m_originalCaster)
792	return;
793
794	if(m_originalCaster->GetTypeId() == TYPEID_PLAYER)
795	{
796	WorldPacket data(SMSG_SPIRIT_HEALER_CONFIRM, 8);
797	data << unitTarget->GetGUID();
798	((Player*)m_originalCaster)->GetSession()->SendPacket( &data );
799	}
800	return;
801	}
802	case 17271: // Test Fetid Skull
803	{
804	if(!itemTarget && m_caster->GetTypeId()!=TYPEID_PLAYER)
805	return;
806
807	uint32 spell_id = roll_chance_i(50) ? 17269 : 17270;
808
809	m_caster->CastSpell(m_caster,spell_id,true,NULL);
810	return;
811	}
812	case 20577: // Cannibalize
813	if (unitTarget)
814	m_caster->CastSpell(m_caster,20578,false,NULL);
815	return;
816	case 23019: // Crystal Prison Dummy DND
817	{
818	if(!unitTarget \|\| !unitTarget->isAlive() \|\| unitTarget->GetTypeId() != TYPEID_UNIT \|\| ((Creature*)unitTarget)->isPet())
819	return;
820
821	Creature* creatureTarget = (Creature*)unitTarget;
822	if(creatureTarget->isPet())
823	return;
824
825	creatureTarget->setDeathState(JUST_DIED);
826	creatureTarget->RemoveCorpse();
827	creatureTarget->SetHealth(0); // just for nice GM-mode view
828
829	GameObject* Crystal_Prison = m_caster->SummonGameObject(179644, creatureTarget->GetPositionX(), creatureTarget->GetPositionY(), creatureTarget->GetPositionZ(), creatureTarget->GetOrientation(), 0, 0, 0, 0, creatureTarget->GetRespawnTime()-time(NULL));
830	sLog.outDebug("SummonGameObject at SpellEfects.cpp EffectDummy for Spell 23019\n");
831	WorldPacket data(SMSG_GAMEOBJECT_SPAWN_ANIM_OBSOLETE, 8);
832	data << uint64(Crystal_Prison->GetGUID());
833	m_caster->SendMessageToSet(&data,true);
834
835	return;
836	}
837	case 23074: // Arc. Dragonling
838	if (!m_CastItem) return;
839	m_caster->CastSpell(m_caster,19804,true,m_CastItem);
840	return;
841	case 23075: // Mithril Mechanical Dragonling
842	if (!m_CastItem) return;
843	m_caster->CastSpell(m_caster,12749,true,m_CastItem);
844	return;
845	case 23076: // Mechanical Dragonling
846	if (!m_CastItem) return;
847	m_caster->CastSpell(m_caster,4073,true,m_CastItem);
848	return;
849	case 23133: // Gnomish Battle Chicken
850	if (!m_CastItem) return;
851	m_caster->CastSpell(m_caster,13166,true,m_CastItem);
852	return;
853	case 23448: // Ultrasafe Transporter: Gadgetzan - backfires
854	{
855	int32 r = irand(0, 119);
856	if ( r < 20 ) // 1/6 polymorph
857	m_caster->CastSpell(m_caster,23444,true);
858	else if ( r < 100 ) // 4/6 evil twin
859	m_caster->CastSpell(m_caster,23445,true);
860	else // 1/6 miss the target
861	m_caster->CastSpell(m_caster,36902,true);
862	return;
863	}
864	case 23453: // Ultrasafe Transporter: Gadgetzan
865	if ( roll_chance_i(50) ) // success
866	m_caster->CastSpell(m_caster,23441,true);
867	else // failure
868	m_caster->CastSpell(m_caster,23446,true);
869	return;
870	case 23645: // Hourglass Sand
871	m_caster->RemoveAurasDueToSpell(23170);
872	return;
873	case 23725: // Gift of Life (warrior bwl trinket)
874	m_caster->CastSpell(m_caster,23782,true);
875	m_caster->CastSpell(m_caster,23783,true);
876	return;
877	case 25860: // Reindeer Transformation
878	{
879	if (!m_caster->HasAuraType(SPELL_AURA_MOUNTED))
880	return;
881
882	float flyspeed = m_caster->GetSpeedRate(MOVE_FLY);
883	float speed = m_caster->GetSpeedRate(MOVE_RUN);
884
885	m_caster->RemoveSpellsCausingAura(SPELL_AURA_MOUNTED);
886
887	//5 different spells used depending on mounted speed and if mount can fly or not
888	if (flyspeed >= 4.1f)
889	m_caster->CastSpell(m_caster, 44827, true); //310% flying Reindeer
890	else if (flyspeed >= 3.8f)
891	m_caster->CastSpell(m_caster, 44825, true); //280% flying Reindeer
892	else if (flyspeed >= 1.6f)
893	m_caster->CastSpell(m_caster, 44824, true); //60% flying Reindeer
894	else if (speed >= 2.0f)
895	m_caster->CastSpell(m_caster, 25859, true); //100% ground Reindeer
896	else
897	m_caster->CastSpell(m_caster, 25858, true); //60% ground Reindeer
898
899	return;
900	}
901	//case 26074: // Holiday Cheer
902	// return; -- implemented at client side
903	case 28006: // Arcane Cloaking
904	{
905	if( unitTarget->GetTypeId() == TYPEID_PLAYER )
906	m_caster->CastSpell(unitTarget,29294,true);
907	return;
908	}
909	case 28730: // Arcane Torrent (Mana)
910	{
911	int32 count = 0;
912	Unit::AuraList const& m_dummyAuras = m_caster->GetAurasByType(SPELL_AURA_DUMMY);
913	for(Unit::AuraList::const_iterator i = m_dummyAuras.begin(); i != m_dummyAuras.end(); ++i)
914	if ((*i)->GetId() == 28734)
915	++count;
916	if (count)
917	{
918	m_caster->RemoveAurasDueToSpell(28734);
919	int32 bp = damage * count;
920	m_caster->CastCustomSpell(m_caster, 28733, &bp, NULL, NULL, true);
921	}
922	return;
923	}
924	case 29200: // Purify Helboar Meat
925	{
926	if( m_caster->GetTypeId() != TYPEID_PLAYER )
927	return;
928
929	uint32 spell_id = roll_chance_i(50) ? 29277 : 29278;
930
931	m_caster->CastSpell(m_caster,spell_id,true,NULL);
932	return;
933	}
934	case 29858: // Soulshatter
935	if (unitTarget && unitTarget->GetTypeId() == TYPEID_UNIT && unitTarget->IsHostileTo(m_caster))
936	m_caster->CastSpell(unitTarget,32835,true);
937	return;
938	case 30458: // Nigh Invulnerability
939	if (!m_CastItem) return;
940	if(roll_chance_i(86)) // success
941	m_caster->CastSpell(m_caster, 30456, true, m_CastItem);
942	else // backfire in 14% casts
943	m_caster->CastSpell(m_caster, 30457, true, m_CastItem);
944	return;
945	case 30507: // Poultryizer
946	if (!m_CastItem) return;
947	if(roll_chance_i(80)) // success
948	m_caster->CastSpell(unitTarget, 30501, true, m_CastItem);
949	else // backfire 20%
950	m_caster->CastSpell(unitTarget, 30504, true, m_CastItem);
951	return;
952	case 33060: // Make a Wish
953	{
954	if(m_caster->GetTypeId()!=TYPEID_PLAYER)
955	return;
956
957	uint32 spell_id = 0;
958
959	switch(urand(1,5))
960	{
961	case 1: spell_id = 33053; break;
962	case 2: spell_id = 33057; break;
963	case 3: spell_id = 33059; break;
964	case 4: spell_id = 33062; break;
965	case 5: spell_id = 33064; break;
966	}
967
968	m_caster->CastSpell(m_caster,spell_id,true,NULL);
969	return;
970	}
971	case 35745:
972	{
973	uint32 spell_id;
974	switch(m_caster->GetAreaId())
975	{
976	case 3900: spell_id = 35743; break;
977	case 3742: spell_id = 35744; break;
978	default: return;
979	}
980
981	m_caster->CastSpell(m_caster,spell_id,true);
982	return;
983	}
984	case 37674: // Chaos Blast
985	if(unitTarget)
986	m_caster->CastSpell(unitTarget,37675,true);
987	return;
988	case 44875: // Complete Raptor Capture
989	{
990	if(!unitTarget \|\| unitTarget->GetTypeId() != TYPEID_UNIT)
991	return;
992
993	Creature* creatureTarget = (Creature*)unitTarget;
994
995	creatureTarget->setDeathState(JUST_DIED);
996	creatureTarget->RemoveCorpse();
997	creatureTarget->SetHealth(0); // just for nice GM-mode view
998
999	//cast spell Raptor Capture Credit
1000	m_caster->CastSpell(m_caster,42337,true,NULL);
1001	return;
1002	}
1003	case 37573: //Temporal Phase Modulator
1004	{
1005	if(!unitTarget)
1006	return;
1007
1008	TemporarySummon* tempSummon = dynamic_cast<TemporarySummon*>(unitTarget);
1009	if(!tempSummon)
1010	return;
1011
1012	uint32 health = tempSummon->GetHealth();
1013	const uint32 entry_list[6] = {21821, 21820, 21817};
1014
1015	float x = tempSummon->GetPositionX();
1016	float y = tempSummon->GetPositionY();
1017	float z = tempSummon->GetPositionZ();
1018	float o = tempSummon->GetOrientation();
1019
1020	tempSummon->UnSummon();
1021
1022	Creature* pCreature = m_caster->SummonCreature(entry_list[urand(0, 2)], x, y, z, o,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,180000);
1023	if (!pCreature)
1024	return;
1025
1026	pCreature->SetHealth(health);
1027
1028	if(pCreature->AI())
1029	pCreature->AI()->AttackStart(m_caster);
1030
1031	return;
1032	}
1033	case 34665: //Administer Antidote
1034	{
1035	if(!unitTarget \|\| m_caster->GetTypeId() != TYPEID_PLAYER )
1036	return;
1037
1038	if(!unitTarget)
1039	return;
1040
1041	TemporarySummon* tempSummon = dynamic_cast<TemporarySummon*>(unitTarget);
1042	if(!tempSummon)
1043	return;
1044
1045	uint32 health = tempSummon->GetHealth();
1046
1047	float x = tempSummon->GetPositionX();
1048	float y = tempSummon->GetPositionY();
1049	float z = tempSummon->GetPositionZ();
1050	float o = tempSummon->GetOrientation();
1051	tempSummon->UnSummon();
1052
1053	Creature* pCreature = m_caster->SummonCreature(16992, x, y, z, o,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,180000);
1054	if (!pCreature)
1055	return;
1056
1057	pCreature->SetHealth(health);
1058	((Player*)m_caster)->KilledMonster(16992,pCreature->GetGUID());
1059
1060	if (pCreature->AI())
1061	pCreature->AI()->AttackStart(m_caster);
1062
1063	return;
1064	}
1065	case 44997: // Converting Sentry
1066	{
1067	//Converted Sentry Credit
1068	m_caster->CastSpell(m_caster, 45009, true);
1069	return;
1070	}
1071	case 45030: // Impale Emissary
1072	{
1073	// Emissary of Hate Credit
1074	m_caster->CastSpell(m_caster, 45088, true);
1075	return;
1076	}
1077	case 50243: // Teach Language
1078	{
1079	if(m_caster->GetTypeId() != TYPEID_PLAYER)
1080	return;
1081
1082	// spell has a 1/3 chance to trigger one of the below
1083	if(roll_chance_i(66))
1084	return;
1085	if(((Player*)m_caster)->GetTeam() == ALLIANCE)
1086	{
1087	// 1000001 - gnomish binary
1088	m_caster->CastSpell(m_caster, 50242, true);
1089	}
1090	else
1091	{
1092	// 01001000 - goblin binary
1093	m_caster->CastSpell(m_caster, 50246, true);
1094	}
1095
1096	return;
1097	}
1098	case 51582: //Rocket Boots Engaged (Rocket Boots Xtreme and Rocket Boots Xtreme Lite)
1099	{
1100	if(m_caster->GetTypeId() != TYPEID_PLAYER)
1101	return;
1102
1103	if(BattleGround* bg = ((Player*)m_caster)->GetBattleGround())
1104	bg->EventPlayerDroppedFlag((Player*)m_caster);
1105
1106	m_caster->CastSpell(m_caster, 30452, true, NULL);
1107	return;
1108	}
1109	}
1110
1111	//All IconID Check in there
1112	switch(m_spellInfo->SpellIconID)
1113	{
1114	// Berserking (troll racial traits)
1115	case 1661:
1116	{
1117	uint32 healthPerc = uint32((float(m_caster->GetHealth())/m_caster->GetMaxHealth())*100);
1118	int32 melee_mod = 10;
1119	if (healthPerc <= 40)
1120	melee_mod = 30;
1121	if (healthPerc < 100 && healthPerc > 40)
1122	melee_mod = 10+(100-healthPerc)/3;
1123
1124	int32 hasteModBasePoints0 = melee_mod; // (EffectBasePoints[0]+1)-1+(5-melee_mod) = (melee_mod-1+1)-1+5-melee_mod = 5-1
1125	int32 hasteModBasePoints1 = (5-melee_mod);
1126	int32 hasteModBasePoints2 = 5;
1127
1128	// FIXME: custom spell required this aura state by some unknown reason, we not need remove it anyway
1129	m_caster->ModifyAuraState(AURA_STATE_BERSERKING,true);
1130	m_caster->CastCustomSpell(m_caster,26635,&hasteModBasePoints0,&hasteModBasePoints1,&hasteModBasePoints2,true,NULL);
1131	return;
1132	}
1133	}
1134	break;
1135	case SPELLFAMILY_MAGE:
1136	switch(m_spellInfo->Id )
1137	{
1138	case 11958: // Cold Snap
1139	{
1140	if(m_caster->GetTypeId()!=TYPEID_PLAYER)
1141	return;
1142
1143	// immediately finishes the cooldown on Frost spells
1144	const PlayerSpellMap& sp_list = ((Player *)m_caster)->GetSpellMap();
1145	for (PlayerSpellMap::const_iterator itr = sp_list.begin(); itr != sp_list.end(); ++itr)
1146	{
1147	if (itr->second->state == PLAYERSPELL_REMOVED)
1148	continue;
1149
1150	uint32 classspell = itr->first;
1151	SpellEntry const *spellInfo = sSpellStore.LookupEntry(classspell);
1152
1153	if( spellInfo->SpellFamilyName == SPELLFAMILY_MAGE &&
1154	(GetSpellSchoolMask(spellInfo) & SPELL_SCHOOL_MASK_FROST) &&
1155	spellInfo->Id != 11958 && GetSpellRecoveryTime(spellInfo) > 0 )
1156	{
1157	((Player*)m_caster)->RemoveSpellCooldown(classspell);
1158
1159	WorldPacket data(SMSG_CLEAR_COOLDOWN, (4+8));
1160	data << uint32(classspell);
1161	data << uint64(m_caster->GetGUID());
1162	((Player*)m_caster)->GetSession()->SendPacket(&data);
1163	}
1164	}
1165	return;
1166	}
1167	case 32826:
1168	{
1169	if ( unitTarget && unitTarget->GetTypeId() == TYPEID_UNIT )
1170	{
1171	//Polymorph Cast Visual Rank 1
1172	const uint32 spell_list[6] = {32813, 32816, 32817, 32818, 32819, 32820};
1173	unitTarget->CastSpell( unitTarget, spell_list[urand(0, 5)], true);
1174	}
1175	return;
1176	}
1177	}
1178	break;
1179	case SPELLFAMILY_WARRIOR:
1180	// Charge
1181	if(m_spellInfo->SpellFamilyFlags & 0x1 && m_spellInfo->SpellVisual == 867)
1182	{
1183	int32 chargeBasePoints0 = damage;
1184	m_caster->CastCustomSpell(m_caster,34846,&chargeBasePoints0,NULL,NULL,true);
1185	return;
1186	}
1187	// Execute
1188	if(m_spellInfo->SpellFamilyFlags & 0x20000000)
1189	{
1190	if(!unitTarget)
1191	return;
1192
1193	int32 basePoints0 = damage+int32(m_caster->GetPower(POWER_RAGE) * m_spellInfo->DmgMultiplier[i]);
1194	m_caster->CastCustomSpell(unitTarget, 20647, &basePoints0, NULL, NULL, true, 0);
1195	m_caster->SetPower(POWER_RAGE,0);
1196	return;
1197	}
1198	if(m_spellInfo->Id==21977) //Warrior's Wrath
1199	{
1200	if(!unitTarget)
1201	return;
1202
1203	m_caster->CastSpell(unitTarget,21887,true); // spell mod
1204	return;
1205	}
1206	break;
1207	case SPELLFAMILY_WARLOCK:
1208	//Life Tap (only it have this with dummy effect)
1209	if (m_spellInfo->SpellFamilyFlags == 0x40000)
1210	{
1211	float cost = m_currentBasePoints[0]+1;
1212
1213	if(Player* modOwner = m_caster->GetSpellModOwner())
1214	modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_COST, cost,this);
1215
1216	int32 dmg = m_caster->SpellDamageBonus(m_caster, m_spellInfo,uint32(cost > 0 ? cost : 0), SPELL_DIRECT_DAMAGE);
1217
1218	if(int32(m_caster->GetHealth()) > dmg)
1219	{
1220	// Shouldn't Appear in Combat Log
1221	m_caster->ModifyHealth(-dmg);
1222
1223	int32 mana = dmg;
1224
1225	Unit::AuraList const& auraDummy = m_caster->GetAurasByType(SPELL_AURA_DUMMY);
1226	for(Unit::AuraList::const_iterator itr = auraDummy.begin(); itr != auraDummy.end(); ++itr)
1227	{
1228	// only Imp. Life Tap have this in combination with dummy aura
1229	if((itr)->GetSpellProto()->SpellFamilyName==SPELLFAMILY_WARLOCK && (itr)->GetSpellProto()->SpellIconID == 208)
1230	mana = ((itr)->GetModifier()->m_amount + 100) mana / 100;
1231	}
1232
1233	m_caster->CastCustomSpell(m_caster,31818,&mana,NULL,NULL,true,NULL);
1234
1235	// Mana Feed
1236	int32 manaFeedVal = m_caster->CalculateSpellDamage(m_spellInfo,1, m_spellInfo->EffectBasePoints[1],m_caster);
1237	manaFeedVal = manaFeedVal * mana / 100;
1238	if(manaFeedVal > 0)
1239	m_caster->CastCustomSpell(m_caster,32553,&manaFeedVal,NULL,NULL,true,NULL);
1240	}
1241	else
1242	SendCastResult(SPELL_FAILED_FIZZLE);
1243	return;
1244	}
1245	break;
1246	case SPELLFAMILY_PRIEST:
1247	switch(m_spellInfo->Id )
1248	{
1249	case 28598: // Touch of Weakness triggered spell
1250	{
1251	if(!unitTarget \|\| !m_triggeredByAuraSpell)
1252	return;
1253
1254	uint32 spellid = 0;
1255	switch(m_triggeredByAuraSpell->Id)
1256	{
1257	case 2652: spellid = 2943; break; // Rank 1
1258	case 19261: spellid = 19249; break; // Rank 2
1259	case 19262: spellid = 19251; break; // Rank 3
1260	case 19264: spellid = 19252; break; // Rank 4
1261	case 19265: spellid = 19253; break; // Rank 5
1262	case 19266: spellid = 19254; break; // Rank 6
1263	case 25461: spellid = 25460; break; // Rank 7
1264	default:
1265	sLog.outError("Spell::EffectDummy: Spell 28598 triggered by unhandeled spell %u",m_triggeredByAuraSpell->Id);
1266	return;
1267	}
1268	m_caster->CastSpell(unitTarget, spellid, true, NULL);
1269	return;
1270	}
1271	}
1272	break;
1273	case SPELLFAMILY_DRUID:
1274	switch(m_spellInfo->Id )
1275	{
1276	case 5420: // Tree of Life passive
1277	{
1278	// Tree of Life area effect
1279	int32 health_mod = int32(m_caster->GetStat(STAT_SPIRIT)/4);
1280	m_caster->CastCustomSpell(m_caster,34123,&health_mod,NULL,NULL,true,NULL);
1281	return;
1282	}
1283	}
1284	break;
1285	case SPELLFAMILY_ROGUE:
1286	switch(m_spellInfo->Id )
1287	{
1288	case 31231: // Cheat Death
1289	{
1290	m_caster->CastSpell(m_caster,45182,true);
1291	return;
1292	}
1293	case 5938: // Shiv
1294	{
1295	if(m_caster->GetTypeId() != TYPEID_PLAYER)
1296	return;
1297
1298	Player pCaster = ((Player)m_caster);
1299
1300	Item *item = pCaster->GetWeaponForAttack(OFF_ATTACK);
1301	if(!item)
1302	return;
1303
1304	// all poison enchantments is temporary
1305	uint32 enchant_id = item->GetEnchantmentId(TEMP_ENCHANTMENT_SLOT);
1306	if(!enchant_id)
1307	return;
1308
1309	SpellItemEnchantmentEntry const *pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
1310	if(!pEnchant)
1311	return;
1312
1313	for (int s=0;s<3;s++)
1314	{
1315	if(pEnchant->type[s]!=ITEM_ENCHANTMENT_TYPE_COMBAT_SPELL)
1316	continue;
1317
1318	SpellEntry const* combatEntry = sSpellStore.LookupEntry(pEnchant->spellid[s]);
1319	if(!combatEntry \|\| combatEntry->Dispel != DISPEL_POISON)
1320	continue;
1321
1322	m_caster->CastSpell(unitTarget, combatEntry, true, item);
1323	}
1324
1325	m_caster->CastSpell(unitTarget, 5940, true);
1326	return;
1327	}
1328	}
1329	break;
1330	case SPELLFAMILY_HUNTER:
1331	// Steady Shot
1332	if(m_spellInfo->SpellFamilyFlags & 0x100000000LL)
1333	{
1334	if( !unitTarget \|\| !unitTarget->isAlive())
1335	return;
1336
1337	bool found = false;
1338
1339	// check dazed affect
1340	Unit::AuraList const& decSpeedList = unitTarget->GetAurasByType(SPELL_AURA_MOD_DECREASE_SPEED);
1341	for(Unit::AuraList::const_iterator iter = decSpeedList.begin(); iter != decSpeedList.end(); ++iter)
1342	{
1343	if((iter)->GetSpellProto()->SpellIconID==15 && (iter)->GetSpellProto()->Dispel==0)
1344	{
1345	found = true;
1346	break;
1347	}
1348	}
1349
1350	if(found)
1351	m_caster->SpellNonMeleeDamageLog(unitTarget, m_spellInfo->Id, damage, m_IsTriggeredSpell, true);
1352	return;
1353	}
1354	// Kill command
1355	if(m_spellInfo->SpellFamilyFlags & 0x00080000000000LL)
1356	{
1357	if(m_caster->getClass()!=CLASS_HUNTER)
1358	return;
1359
1360	// clear hunter crit aura state
1361	m_caster->ModifyAuraState(AURA_STATE_HUNTER_CRIT_STRIKE,false);
1362
1363	// additional damage from pet to pet target
1364	Pet* pet = m_caster->GetPet();
1365	if(!pet \|\| !pet->getVictim())
1366	return;
1367
1368	uint32 spell_id = 0;
1369	switch (m_spellInfo->Id)
1370	{
1371	case 34026: spell_id = 34027; break; // rank 1
1372	default:
1373	sLog.outError("Spell::EffectDummy: Spell %u not handled in KC",m_spellInfo->Id);
1374	return;
1375	}
1376
1377	pet->CastSpell(pet->getVictim(), spell_id, true);
1378	return;
1379	}
1380
1381	switch(m_spellInfo->Id)
1382	{
1383	case 23989: //Readiness talent
1384	{
1385	if(m_caster->GetTypeId()!=TYPEID_PLAYER)
1386	return;
1387
1388	//immediately finishes the cooldown for hunter abilities
1389	const PlayerSpellMap& sp_list = ((Player *)m_caster)->GetSpellMap();
1390	for (PlayerSpellMap::const_iterator itr = sp_list.begin(); itr != sp_list.end(); ++itr)
1391	{
1392	uint32 classspell = itr->first;
1393	SpellEntry const *spellInfo = sSpellStore.LookupEntry(classspell);
1394
1395	if (spellInfo->SpellFamilyName == SPELLFAMILY_HUNTER && spellInfo->Id != 23989 && GetSpellRecoveryTime(spellInfo) > 0 )
1396	{
1397	((Player*)m_caster)->RemoveSpellCooldown(classspell);
1398
1399	WorldPacket data(SMSG_CLEAR_COOLDOWN, (4+8));
1400	data << uint32(classspell);
1401	data << uint64(m_caster->GetGUID());
1402	((Player*)m_caster)->GetSession()->SendPacket(&data);
1403	}
1404	}
1405	return;
1406	}
1407	case 37506: // Scatter Shot
1408	{
1409	if (m_caster->GetTypeId()!=TYPEID_PLAYER)
1410	return;
1411
1412	// break Auto Shot and autohit
1413	m_caster->InterruptSpell(CURRENT_AUTOREPEAT_SPELL);
1414	m_caster->AttackStop();
1415	((Player*)m_caster)->SendAttackSwingCancelAttack();
1416	return;
1417	}
1418	}
1419	break;
1420	case SPELLFAMILY_PALADIN:
1421	switch(m_spellInfo->SpellIconID)
1422	{
1423	case 156: // Holy Shock
1424	{
1425	if(!unitTarget)
1426	return;
1427
1428	int hurt = 0;
1429	int heal = 0;
1430
1431	switch(m_spellInfo->Id)
1432	{
1433	case 20473: hurt = 25912; heal = 25914; break;
1434	case 20929: hurt = 25911; heal = 25913; break;
1435	case 20930: hurt = 25902; heal = 25903; break;
1436	case 27174: hurt = 27176; heal = 27175; break;
1437	case 33072: hurt = 33073; heal = 33074; break;
1438	default:
1439	sLog.outError("Spell::EffectDummy: Spell %u not handled in HS",m_spellInfo->Id);
1440	return;
1441	}
1442
1443	if(m_caster->IsFriendlyTo(unitTarget))
1444	m_caster->CastSpell(unitTarget, heal, true, 0);
1445	else
1446	m_caster->CastSpell(unitTarget, hurt, true, 0);
1447
1448	return;
1449	}
1450	case 561: // Judgement of command
1451	{
1452	if(!unitTarget)
1453	return;
1454
1455	uint32 spell_id = m_currentBasePoints[i]+1;
1456	SpellEntry const* spell_proto = sSpellStore.LookupEntry(spell_id);
1457	if(!spell_proto)
1458	return;
1459
1460	if( !unitTarget->hasUnitState(UNIT_STAT_STUNNED) && m_caster->GetTypeId()==TYPEID_PLAYER)
1461	{
1462	// decreased damage (/2) for non-stunned target.
1463	SpellModifier *mod = new SpellModifier;
1464	mod->op = SPELLMOD_DAMAGE;
1465	mod->value = -50;
1466	mod->type = SPELLMOD_PCT;
1467	mod->spellId = m_spellInfo->Id;
1468	mod->effectId = i;
1469	mod->lastAffected = NULL;
1470	mod->mask = 0x0000020000000000LL;
1471	mod->charges = 0;
1472
1473	((Player*)m_caster)->AddSpellMod(mod, true);
1474	m_caster->CastSpell(unitTarget,spell_proto,true,NULL);
1475	// mod deleted
1476	((Player*)m_caster)->AddSpellMod(mod, false);
1477	}
1478	else
1479	m_caster->CastSpell(unitTarget,spell_proto,true,NULL);
1480
1481	return;
1482	}
1483	}
1484
1485	switch(m_spellInfo->Id)
1486	{
1487	case 31789: // Righteous Defense (step 1)
1488	{
1489	// 31989 -> dummy effect (step 1) + dummy effect (step 2) -> 31709 (taunt like spell for each target)
1490
1491	// non-standard cast requirement check
1492	if (!unitTarget \|\| unitTarget->getAttackers().empty())
1493	{
1494	// clear cooldown at fail
1495	if(m_caster->GetTypeId()==TYPEID_PLAYER)
1496	{
1497	((Player*)m_caster)->RemoveSpellCooldown(m_spellInfo->Id);
1498
1499	WorldPacket data(SMSG_CLEAR_COOLDOWN, (4+8));
1500	data << uint32(m_spellInfo->Id);
1501	data << uint64(m_caster->GetGUID());
1502	((Player*)m_caster)->GetSession()->SendPacket(&data);
1503	}
1504
1505	SendCastResult(SPELL_FAILED_TARGET_AFFECTING_COMBAT);
1506	return;
1507	}
1508
1509	// Righteous Defense (step 2) (in old version 31980 dummy effect)
1510	// Clear targets for eff 1
1511	for(std::list<TargetInfo>::iterator ihit= m_UniqueTargetInfo.begin();ihit != m_UniqueTargetInfo.end();++ihit)
1512	ihit->effectMask &= ~(1<<1);
1513
1514	// not empty (checked)
1515	Unit::AttackerSet const& attackers = unitTarget->getAttackers();
1516
1517	// chance to be selected from list
1518	float chance = 100.0f/attackers.size();
1519	uint32 count=0;
1520	for(Unit::AttackerSet::const_iterator aItr = attackers.begin(); aItr != attackers.end() && count < 3; ++aItr)
1521	{
1522	if(!roll_chance_f(chance))
1523	continue;
1524	++count;
1525	AddUnitTarget((*aItr), 1);
1526	}
1527
1528	// now let next effect cast spell at each target.
1529	return;
1530	}
1531	case 37877: // Blessing of Faith
1532	{
1533	if(!unitTarget)
1534	return;
1535
1536	uint32 spell_id = 0;
1537	switch(unitTarget->getClass())
1538	{
1539	case CLASS_DRUID: spell_id = 37878; break;
1540	case CLASS_PALADIN: spell_id = 37879; break;
1541	case CLASS_PRIEST: spell_id = 37880; break;
1542	case CLASS_SHAMAN: spell_id = 37881; break;
1543	default: return; // ignore for not healing classes
1544	}
1545
1546	m_caster->CastSpell(m_caster,spell_id,true);
1547	return;
1548	}
1549	}
1550	break;
1551	case SPELLFAMILY_SHAMAN:
1552	//Shaman Rockbiter Weapon
1553	if (m_spellInfo->SpellFamilyFlags == 0x400000)
1554	{
1555	uint32 spell_id = 0;
1556	switch(m_spellInfo->Id)
1557	{
1558	case 8017: spell_id = 36494; break; // Rank 1
1559	case 8018: spell_id = 36750; break; // Rank 2
1560	case 8019: spell_id = 36755; break; // Rank 3
1561	case 10399: spell_id = 36759; break; // Rank 4
1562	case 16314: spell_id = 36763; break; // Rank 5
1563	case 16315: spell_id = 36766; break; // Rank 6
1564	case 16316: spell_id = 36771; break; // Rank 7
1565	case 25479: spell_id = 36775; break; // Rank 8
1566	case 25485: spell_id = 36499; break; // Rank 9
1567	default:
1568	sLog.outError("Spell::EffectDummy: Spell %u not handled in RW",m_spellInfo->Id);
1569	return;
1570	}
1571
1572	SpellEntry const *spellInfo = sSpellStore.LookupEntry( spell_id );
1573
1574	if(!spellInfo)
1575	{
1576	sLog.outError("WORLD: unknown spell id %i\n", spell_id);
1577	return;
1578	}
1579
1580	if(m_caster->GetTypeId() != TYPEID_PLAYER)
1581	return;
1582
1583	for(int i = BASE_ATTACK; i <= OFF_ATTACK; ++i)
1584	{
1585	if(Item* item = ((Player*)m_caster)->GetWeaponForAttack(WeaponAttackType(i)))
1586	{
1587	if(item->IsFitToSpellRequirements(m_spellInfo))
1588	{
1589	Spell *spell = new Spell(m_caster, spellInfo, true);
1590
1591	// enchanting spell selected by calculated damage-per-sec in enchanting effect
1592	// at calculation applied affect from Elemental Weapons talent
1593	// real enchantment damage-1
1594	spell->m_currentBasePoints[1] = damage-1;
1595
1596	SpellCastTargets targets;
1597	targets.setItemTarget( item );
1598	spell->prepare(&targets);
1599	}
1600	}
1601	}
1602	return;
1603	}
1604
1605	if(m_spellInfo->Id == 39610) // Mana-Tide Totem effect
1606	{
1607	if(!unitTarget \|\| unitTarget->getPowerType() != POWER_MANA)
1608	return;
1609
1610	// Regenerate 6% of Total Mana Every 3 secs
1611	int32 EffectBasePoints0 = unitTarget->GetMaxPower(POWER_MANA) * damage / 100;
1612	m_caster->CastCustomSpell(unitTarget,39609,&EffectBasePoints0,NULL,NULL,true,NULL,NULL,m_originalCasterGUID);
1613	return;
1614	}
1615
1616	break;
1617	}
1618
1619	// pet auras
1620	if(PetAura const* petSpell = spellmgr.GetPetAura(m_spellInfo->Id))
1621	{
1622	m_caster->AddPetAura(petSpell);
1623	return;
1624	}
1625	}
1626
1627	void Spell::EffectTriggerSpellWithValue(uint32 i)
1628	{
1629	uint32 triggered_spell_id = m_spellInfo->EffectTriggerSpell[i];
1630
1631	// normal case
1632	SpellEntry const *spellInfo = sSpellStore.LookupEntry( triggered_spell_id );
1633
1634	if(!spellInfo)
1635	{
1636	sLog.outError("EffectTriggerSpellWithValue of spell %u: triggering unknown spell id %i\n", m_spellInfo->Id,triggered_spell_id);
1637	return;
1638	}
1639
1640	int32 bp = damage;
1641	m_caster->CastCustomSpell(unitTarget,triggered_spell_id,&bp,&bp,&bp,true,NULL,NULL,m_originalCasterGUID);
1642	}
1643
1644	void Spell::EffectTriggerRitualOfSummoning(uint32 i)
1645	{
1646	uint32 triggered_spell_id = m_spellInfo->EffectTriggerSpell[i];
1647	SpellEntry const *spellInfo = sSpellStore.LookupEntry( triggered_spell_id );
1648
1649	if(!spellInfo)
1650	{
1651	sLog.outError("EffectTriggerRitualOfSummoning of spell %u: triggering unknown spell id %i", m_spellInfo->Id,triggered_spell_id);
1652	return;
1653	}
1654
1655	finish();
1656	Spell *spell = new Spell(m_caster, spellInfo, true);
1657
1658	SpellCastTargets targets;
1659	targets.setUnitTarget( unitTarget);
1660	spell->prepare(&targets);
1661
1662	m_caster->SetCurrentCastedSpell(spell);
1663	spell->m_selfContainer = &(m_caster->m_currentSpells[spell->GetCurrentContainer()]);
1664
1665	}
1666
1667	void Spell::EffectForceCast(uint32 i)
1668	{
1669	if( !unitTarget )
1670	return;
1671
1672	uint32 triggered_spell_id = m_spellInfo->EffectTriggerSpell[i];
1673
1674	// normal case
1675	SpellEntry const *spellInfo = sSpellStore.LookupEntry( triggered_spell_id );
1676
1677	if(!spellInfo)
1678	{
1679	sLog.outError("EffectForceCast of spell %u: triggering unknown spell id %i", m_spellInfo->Id,triggered_spell_id);
1680	return;
1681	}
1682
1683	unitTarget->CastSpell(unitTarget,spellInfo,true,NULL,NULL,m_originalCasterGUID);
1684	}
1685
1686	void Spell::EffectTriggerSpell(uint32 i)
1687	{
1688	uint32 triggered_spell_id = m_spellInfo->EffectTriggerSpell[i];
1689
1690	// special cases
1691	switch(triggered_spell_id)
1692	{
1693	// Vanish
1694	case 18461:
1695	{
1696	m_caster->RemoveSpellsCausingAura(SPELL_AURA_MOD_ROOT);
1697	m_caster->RemoveSpellsCausingAura(SPELL_AURA_MOD_DECREASE_SPEED);
1698	m_caster->RemoveSpellsCausingAura(SPELL_AURA_MOD_STALKED);
1699
1700	// if this spell is given to NPC it must handle rest by it's own AI
1701	if ( m_caster->GetTypeId() != TYPEID_PLAYER )
1702	return;
1703
1704	// get highest rank of the Stealth spell
1705	uint32 spellId = 0;
1706	const PlayerSpellMap& sp_list = ((Player*)m_caster)->GetSpellMap();
1707	for (PlayerSpellMap::const_iterator itr = sp_list.begin(); itr != sp_list.end(); ++itr)
1708	{
1709	// only highest rank is shown in spell book, so simply check if shown in spell book
1710	if(!itr->second->active \|\| itr->second->disabled \|\| itr->second->state == PLAYERSPELL_REMOVED)
1711	continue;
1712
1713	SpellEntry const *spellInfo = sSpellStore.LookupEntry(itr->first);
1714	if (!spellInfo)
1715	continue;
1716
1717	if (spellInfo->SpellFamilyName == SPELLFAMILY_ROGUE && spellInfo->SpellFamilyFlags & SPELLFAMILYFLAG_ROGUE_STEALTH)
1718	{
1719	spellId = spellInfo->Id;
1720	break;
1721	}
1722	}
1723
1724	// no Stealth spell found
1725	if (!spellId)
1726	return;
1727
1728	// reset cooldown on it if needed
1729	if(((Player*)m_caster)->HasSpellCooldown(spellId))
1730	((Player*)m_caster)->RemoveSpellCooldown(spellId);
1731
1732	m_caster->CastSpell(m_caster, spellId, true);
1733	return;
1734	}
1735	// just skip
1736	case 23770: // Sayge's Dark Fortune of *
1737	// not exist, common cooldown can be implemented in scripts if need.
1738	return;
1739	// Brittle Armor - (need add max stack of 24575 Brittle Armor)
1740	case 29284:
1741	{
1742	const SpellEntry *spell = sSpellStore.LookupEntry(24575);
1743	if (!spell)
1744	return;
1745
1746	for (int i=0; i < spell->StackAmount; ++i)
1747	m_caster->CastSpell(unitTarget,spell->Id, true, m_CastItem, NULL, m_originalCasterGUID);
1748	return;
1749	}
1750	// Mercurial Shield - (need add max stack of 26464 Mercurial Shield)
1751	case 29286:
1752	{
1753	const SpellEntry *spell = sSpellStore.LookupEntry(26464);
1754	if (!spell)
1755	return;
1756
1757	for (int i=0; i < spell->StackAmount; ++i)
1758	m_caster->CastSpell(unitTarget,spell->Id, true, m_CastItem, NULL, m_originalCasterGUID);
1759	return;
1760	}
1761	// Righteous Defense
1762	case 31980:
1763	{
1764	m_caster->CastSpell(unitTarget, 31790, true,m_CastItem,NULL,m_originalCasterGUID);
1765	return;
1766	}
1767	// Cloak of Shadows
1768	case 35729 :
1769	{
1770	Unit::AuraMap& Auras = m_caster->GetAuras();
1771	for(Unit::AuraMap::iterator iter = Auras.begin(); iter != Auras.end(); ++iter)
1772	{
1773	// remove all harmful spells on you...
1774	if( // ignore positive and passive auras
1775	!iter->second->IsPositive() && !iter->second->IsPassive() &&
1776	// ignore physical auras
1777	(GetSpellSchoolMask(iter->second->GetSpellProto()) & SPELL_SCHOOL_MASK_NORMAL)==0 &&
1778	// ignore immunity persistent spells
1779	!( iter->second->GetSpellProto()->AttributesEx & 0x10000 ) )
1780	{
1781	m_caster->RemoveAurasDueToSpell(iter->second->GetSpellProto()->Id);
1782	iter = Auras.begin();
1783	}
1784	}
1785	return;
1786	}
1787	// Priest Shadowfiend (34433) need apply mana gain trigger aura on pet
1788	case 41967:
1789	{
1790	if (Unit *pet = m_caster->GetPet())
1791	pet->CastSpell(pet, 28305, true);
1792	return;
1793	}
1794	}
1795
1796	// normal case
1797	SpellEntry const *spellInfo = sSpellStore.LookupEntry( triggered_spell_id );
1798
1799	if(!spellInfo)
1800	{
1801	sLog.outError("EffectTriggerSpell of spell %u: triggering unknown spell id %i", m_spellInfo->Id,triggered_spell_id);
1802	return;
1803	}
1804
1805	// some triggered spells require specific equipment
1806	if(spellInfo->EquippedItemClass >=0 && m_caster->GetTypeId()==TYPEID_PLAYER)
1807	{
1808	// main hand weapon required
1809	if(spellInfo->AttributesEx3 & SPELL_ATTR_EX3_MAIN_HAND)
1810	{
1811	Item* item = ((Player*)m_caster)->GetWeaponForAttack(BASE_ATTACK);
1812
1813	// skip spell if no weapon in slot or broken
1814	if(!item \|\| item->IsBroken() )
1815	return;
1816
1817	// skip spell if weapon not fit to triggered spell
1818	if(!item->IsFitToSpellRequirements(spellInfo))
1819	return;
1820	}
1821
1822	// offhand hand weapon required
1823	if(spellInfo->AttributesEx3 & SPELL_ATTR_EX3_REQ_OFFHAND)
1824	{
1825	Item* item = ((Player*)m_caster)->GetWeaponForAttack(OFF_ATTACK);
1826
1827	// skip spell if no weapon in slot or broken
1828	if(!item \|\| item->IsBroken() )
1829	return;
1830
1831	// skip spell if weapon not fit to triggered spell
1832	if(!item->IsFitToSpellRequirements(spellInfo))
1833	return;
1834	}
1835	}
1836
1837	// some triggered spells must be casted instantly (for example, if next effect case instant kill caster)
1838	bool instant = false;
1839	for(uint32 j = i+1; j < 3; ++j)
1840	{
1841	if(m_spellInfo->Effect[j]==SPELL_EFFECT_INSTAKILL && m_spellInfo->EffectImplicitTargetA[j]==TARGET_SELF)
1842	{
1843	instant = true;
1844	break;
1845	}
1846	}
1847
1848	if(instant)
1849	{
1850	if (unitTarget)
1851	m_caster->CastSpell(unitTarget,spellInfo,true,m_CastItem,NULL,m_originalCasterGUID);
1852	}
1853	else
1854	m_TriggerSpells.push_back(spellInfo);
1855	}
1856
1857	void Spell::EffectTriggerMissileSpell(uint32 effect_idx)
1858	{
1859	uint32 triggered_spell_id = m_spellInfo->EffectTriggerSpell[effect_idx];
1860
1861	// normal case
1862	SpellEntry const *spellInfo = sSpellStore.LookupEntry( triggered_spell_id );
1863
1864	if(!spellInfo)
1865	{
1866	sLog.outError("EffectTriggerMissileSpell of spell %u: triggering unknown spell id %effect_idx", m_spellInfo->Id,triggered_spell_id);
1867	return;
1868	}
1869
1870	if (m_CastItem)
1871	DEBUG_LOG("WORLD: cast Item spellId - %i", spellInfo->Id);
1872
1873	Spell *spell = new Spell(m_caster, spellInfo, true, m_originalCasterGUID );
1874
1875	SpellCastTargets targets;
1876	targets.setDestination(m_targets.m_destX,m_targets.m_destY,m_targets.m_destZ);
1877	spell->m_CastItem = m_CastItem;
1878	spell->prepare(&targets, NULL);
1879	}
1880
1881	void Spell::EffectTeleportUnits(uint32 i)
1882	{
1883	if(!unitTarget \|\| unitTarget->isInFlight())
1884	return;
1885
1886	switch (m_spellInfo->EffectImplicitTargetB[i])
1887	{
1888	case TARGET_INNKEEPER_COORDINATES:
1889	{
1890	// Only players can teleport to innkeeper
1891	if (unitTarget->GetTypeId() != TYPEID_PLAYER)
1892	return;
1893
1894	((Player)unitTarget)->TeleportTo(((Player)unitTarget)->m_homebindMapId,((Player)unitTarget)->m_homebindX,((Player)unitTarget)->m_homebindY,((Player*)unitTarget)->m_homebindZ,unitTarget->GetOrientation(),unitTarget==m_caster ? TELE_TO_SPELL : 0);
1895	return;
1896	}
1897	case TARGET_TABLE_X_Y_Z_COORDINATES:
1898	{
1899	// TODO: Only players can teleport?
1900	if (unitTarget->GetTypeId() != TYPEID_PLAYER)
1901	return;
1902	SpellTargetPosition const* st = spellmgr.GetSpellTargetPosition(m_spellInfo->Id);
1903	if(!st)
1904	{
1905	sLog.outError( "Spell::EffectTeleportUnits - unknown Teleport coordinates for spell ID %u\n", m_spellInfo->Id );
1906	return;
1907	}
1908	((Player*)unitTarget)->TeleportTo(st->target_mapId,st->target_X,st->target_Y,st->target_Z,st->target_Orientation,unitTarget==m_caster ? TELE_TO_SPELL : 0);
1909	break;
1910	}
1911	default:
1912	{
1913	// If not exist data for dest location - return
1914	if(!(m_targets.m_targetMask & TARGET_FLAG_DEST_LOCATION))
1915	{
1916	sLog.outError( "Spell::EffectTeleportUnits - unknown EffectImplicitTargetB[%u] = %u for spell ID %u\n", i, m_spellInfo->EffectImplicitTargetB[i], m_spellInfo->Id );
1917	return;
1918	}
1919	// Init dest coordinates
1920	uint32 mapid = m_caster->GetMapId();
1921	float x = m_targets.m_destX;
1922	float y = m_targets.m_destY;
1923	float z = m_targets.m_destZ;
1924	float orientation = unitTarget->GetOrientation();
1925	// Teleport
1926	if(unitTarget->GetTypeId() == TYPEID_PLAYER)
1927	((Player*)unitTarget)->TeleportTo(mapid, x, y, z, orientation, TELE_TO_NOT_LEAVE_COMBAT \| TELE_TO_NOT_UNSUMMON_PET \| (unitTarget==m_caster ? TELE_TO_SPELL : 0));
1928	else
1929	{
1930	MapManager::Instance().GetMap(mapid, m_caster)->CreatureRelocation((Creature*)unitTarget, x, y, z, orientation);
1931	WorldPacket data;
1932	unitTarget->BuildTeleportAckMsg(&data, x, y, z, orientation);
1933	unitTarget->SendMessageToSet(&data, false);
1934	}
1935	return;
1936	}
1937	}
1938
1939	// post effects for TARGET_TABLE_X_Y_Z_COORDINATES
1940	switch ( m_spellInfo->Id )
1941	{
1942	// Dimensional Ripper - Everlook
1943	case 23442:
1944	{
1945	int32 r = irand(0, 119);
1946	if ( r >= 70 ) // 7/12 success
1947	{
1948	if ( r < 100 ) // 4/12 evil twin
1949	m_caster->CastSpell(m_caster,23445,true);
1950	else // 1/12 fire
1951	m_caster->CastSpell(m_caster,23449,true);
1952	}
1953	return;
1954	}
1955	// Ultrasafe Transporter: Toshley's Station
1956	case 36941:
1957	{
1958	if ( roll_chance_i(50) ) // 50% success
1959	{
1960	int32 rand_eff = urand(1,7);
1961	switch ( rand_eff )
1962	{
1963	case 1:
1964	// soul split - evil
1965	m_caster->CastSpell(m_caster,36900,true);
1966	break;
1967	case 2:
1968	// soul split - good
1969	m_caster->CastSpell(m_caster,36901,true);
1970	break;
1971	case 3:
1972	// Increase the size
1973	m_caster->CastSpell(m_caster,36895,true);
1974	break;
1975	case 4:
1976	// Decrease the size
1977	m_caster->CastSpell(m_caster,36893,true);
1978	break;
1979	case 5:
1980	// Transform
1981	{
1982	if (((Player*)m_caster)->GetTeam() == ALLIANCE )
1983	m_caster->CastSpell(m_caster,36897,true);
1984	else
1985	m_caster->CastSpell(m_caster,36899,true);
1986	break;
1987	}
1988	case 6:
1989	// chicken
1990	m_caster->CastSpell(m_caster,36940,true);
1991	break;
1992	case 7:
1993	// evil twin
1994	m_caster->CastSpell(m_caster,23445,true);
1995	break;
1996	}
1997	}
1998	return;
1999	}
2000	// Dimensional Ripper - Area 52
2001	case 36890:
2002	{
2003	if ( roll_chance_i(50) ) // 50% success
2004	{
2005	int32 rand_eff = urand(1,4);
2006	switch ( rand_eff )
2007	{
2008	case 1:
2009	// soul split - evil
2010	m_caster->CastSpell(m_caster,36900,true);
2011	break;
2012	case 2:
2013	// soul split - good
2014	m_caster->CastSpell(m_caster,36901,true);
2015	break;
2016	case 3:
2017	// Increase the size
2018	m_caster->CastSpell(m_caster,36895,true);
2019	break;
2020	case 4:
2021	// Transform
2022	{
2023	if (((Player*)m_caster)->GetTeam() == ALLIANCE )
2024	m_caster->CastSpell(m_caster,36897,true);
2025	else
2026	m_caster->CastSpell(m_caster,36899,true);
2027	break;
2028	}
2029	}
2030	}
2031	return;
2032	}
2033	}
2034	}
2035
2036	void Spell::EffectApplyAura(uint32 i)
2037	{
2038	if(!unitTarget)
2039	return;
2040
2041	SpellImmuneList const& list = unitTarget->m_spellImmune[IMMUNITY_STATE];
2042	for(SpellImmuneList::const_iterator itr = list.begin(); itr != list.end(); ++itr)
2043	if(itr->type == m_spellInfo->EffectApplyAuraName[i])
2044	return;
2045
2046	// ghost spell check, allow apply any auras at player loading in ghost mode (will be cleanup after load)
2047	if( !unitTarget->isAlive() && m_spellInfo->Id != 20584 && m_spellInfo->Id != 8326 &&
2048	(unitTarget->GetTypeId()!=TYPEID_PLAYER \|\| !((Player*)unitTarget)->GetSession()->PlayerLoading()) )
2049	return;
2050
2051	Unit* caster = m_originalCasterGUID ? m_originalCaster : m_caster;
2052	if(!caster)
2053	return;
2054
2055	sLog.outDebug("Spell: Aura is: %u", m_spellInfo->EffectApplyAuraName[i]);
2056
2057	Aura* Aur = CreateAura(m_spellInfo, i, &m_currentBasePoints[i], unitTarget, caster, m_CastItem);
2058
2059	// Now Reduce spell duration using data received at spell hit
2060	int32 duration = Aur->GetAuraMaxDuration();
2061	unitTarget->ApplyDiminishingToDuration(m_diminishGroup,duration,m_caster,m_diminishLevel);
2062	Aur->setDiminishGroup(m_diminishGroup);
2063
2064	// if Aura removed and deleted, do not continue.
2065	if(duration== 0 && !(Aur->IsPermanent()))
2066	{
2067	delete Aur;
2068	return;
2069	}
2070
2071	if(duration != Aur->GetAuraMaxDuration())
2072	{
2073	Aur->SetAuraMaxDuration(duration);
2074	Aur->SetAuraDuration(duration);
2075	}
2076
2077	bool added = unitTarget->AddAura(Aur);
2078
2079	// Aura not added and deleted in AddAura call;
2080	if (!added)
2081	return;
2082
2083	// found crash at character loading, broken pointer to Aur...
2084	// Aur was deleted in AddAura()...
2085	if(!Aur)
2086	return;
2087
2088	// TODO Make a way so it works for every related spell!
2089	if(unitTarget->GetTypeId()==TYPEID_PLAYER) // Negative buff should only be applied on players
2090	{
2091	uint32 spellId = 0;
2092	if(m_spellInfo->CasterAuraStateNot==AURA_STATE_WEAKENED_SOUL \|\| m_spellInfo->TargetAuraStateNot==AURA_STATE_WEAKENED_SOUL)
2093	spellId = 6788; // Weakened Soul
2094	else if(m_spellInfo->CasterAuraStateNot==AURA_STATE_FORBEARANCE \|\| m_spellInfo->TargetAuraStateNot==AURA_STATE_FORBEARANCE)
2095	spellId = 25771; // Forbearance
2096	else if(m_spellInfo->CasterAuraStateNot==AURA_STATE_HYPOTHERMIA)
2097	spellId = 41425; // Hypothermia
2098	else if (m_spellInfo->Mechanic == MECHANIC_BANDAGE) // Bandages
2099	spellId = 11196; // Recently Bandaged
2100	else if( (m_spellInfo->AttributesEx & 0x20) && (m_spellInfo->AttributesEx2 & 0x20000) )
2101	spellId = 23230; // Blood Fury - Healing Reduction
2102
2103	SpellEntry const *AdditionalSpellInfo = sSpellStore.LookupEntry(spellId);
2104	if (AdditionalSpellInfo)
2105	{
2106	// applied at target by target
2107	Aura* AdditionalAura = CreateAura(AdditionalSpellInfo, 0, &m_currentBasePoints[0], unitTarget,unitTarget, 0);
2108	unitTarget->AddAura(AdditionalAura);
2109	sLog.outDebug("Spell: Additional Aura is: %u", AdditionalSpellInfo->EffectApplyAuraName[0]);
2110	}
2111	}
2112
2113	// Prayer of Mending (jump animation), we need formal caster instead original for correct animation
2114	if( m_spellInfo->SpellFamilyName == SPELLFAMILY_PRIEST && (m_spellInfo->SpellFamilyFlags & 0x00002000000000LL))
2115	m_caster->CastSpell(unitTarget,41637,true,NULL,Aur);
2116	}
2117
2118	void Spell::EffectUnlearnSpecialization( uint32 i )
2119	{
2120	if(!unitTarget \|\| unitTarget->GetTypeId() != TYPEID_PLAYER)
2121	return;
2122
2123	Player _player = (Player)unitTarget;
2124	uint32 spellToUnlearn = m_spellInfo->EffectTriggerSpell[i];
2125
2126	_player->removeSpell(spellToUnlearn);
2127
2128	sLog.outDebug( "Spell: Player %u have unlearned spell %u from NpcGUID: %u", _player->GetGUIDLow(), spellToUnlearn, m_caster->GetGUIDLow() );
2129	}
2130
2131	void Spell::EffectPowerDrain(uint32 i)
2132	{
2133	if(m_spellInfo->EffectMiscValue[i] < 0 \|\| m_spellInfo->EffectMiscValue[i] >= MAX_POWERS)
2134	return;
2135
2136	Powers drain_power = Powers(m_spellInfo->EffectMiscValue[i]);
2137
2138	if(!unitTarget)
2139	return;
2140	if(!unitTarget->isAlive())
2141	return;
2142	if(unitTarget->getPowerType() != drain_power)
2143	return;
2144	if(damage < 0)
2145	return;
2146
2147	uint32 curPower = unitTarget->GetPower(drain_power);
2148
2149	//add spell damage bonus
2150	damage=m_caster->SpellDamageBonus(unitTarget,m_spellInfo,uint32(damage),SPELL_DIRECT_DAMAGE);
2151
2152	// resilience reduce mana draining effect at spell crit damage reduction (added in 2.4)
2153	uint32 power = damage;
2154	if ( drain_power == POWER_MANA && unitTarget->GetTypeId() == TYPEID_PLAYER )
2155	power -= ((Player*)unitTarget)->GetSpellCritDamageReduction(power);
2156
2157	int32 new_damage;
2158	if(curPower < power)
2159	new_damage = curPower;
2160	else
2161	new_damage = power;
2162
2163	unitTarget->ModifyPower(drain_power,-new_damage);
2164
2165	if(drain_power == POWER_MANA)
2166	{
2167	float manaMultiplier = m_spellInfo->EffectMultipleValue[i];
2168	if(manaMultiplier==0)
2169	manaMultiplier = 1;
2170
2171	if(Player *modOwner = m_caster->GetSpellModOwner())
2172	modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_MULTIPLE_VALUE, manaMultiplier);
2173
2174	int32 gain = int32(new_damage*manaMultiplier);
2175
2176	m_caster->ModifyPower(POWER_MANA,gain);
2177	//send log
2178	m_caster->SendEnergizeSpellLog(m_caster, m_spellInfo->Id,gain,POWER_MANA,false);
2179	}
2180	}
2181
2182	void Spell::EffectSendEvent(uint32 EffectIndex)
2183	{
2184	if (m_caster->GetTypeId() == TYPEID_PLAYER && ((Player*)m_caster)->InBattleGround())
2185	{
2186	BattleGround* bg = ((Player *)m_caster)->GetBattleGround();
2187	if(bg && bg->GetStatus() == STATUS_IN_PROGRESS)
2188	{
2189	switch(m_spellInfo->Id)
2190	{
2191	case 23333: // Pickup Horde Flag
2192	/*do not uncomment .
2193	if(bg->GetTypeID()==BATTLEGROUND_WS)
2194	bg->EventPlayerClickedOnFlag((Player*)m_caster, this->gameObjTarget);
2195	sLog.outDebug("Send Event Horde Flag Picked Up");
2196	break;
2197	/* not used :
2198	case 23334: // Drop Horde Flag
2199	if(bg->GetTypeID()==BATTLEGROUND_WS)
2200	bg->EventPlayerDroppedFlag((Player*)m_caster);
2201	sLog.outDebug("Drop Horde Flag");
2202	break;
2203	*/
2204	case 23335: // Pickup Alliance Flag
2205	/*do not uncomment ... (it will cause crash, because of null targetobject!) anyway this is a bad way to call that event, because it would cause recursion
2206	if(bg->GetTypeID()==BATTLEGROUND_WS)
2207	bg->EventPlayerClickedOnFlag((Player*)m_caster, this->gameObjTarget);
2208	sLog.outDebug("Send Event Alliance Flag Picked Up");
2209	break;
2210	/* not used :
2211	case 23336: // Drop Alliance Flag
2212	if(bg->GetTypeID()==BATTLEGROUND_WS)
2213	bg->EventPlayerDroppedFlag((Player*)m_caster);
2214	sLog.outDebug("Drop Alliance Flag");
2215	break;
2216	case 23385: // Alliance Flag Returns
2217	if(bg->GetTypeID()==BATTLEGROUND_WS)
2218	bg->EventPlayerClickedOnFlag((Player*)m_caster, this->gameObjTarget);
2219	sLog.outDebug("Alliance Flag Returned");
2220	break;
2221	case 23386: // Horde Flag Returns
2222	if(bg->GetTypeID()==BATTLEGROUND_WS)
2223	bg->EventPlayerClickedOnFlag((Player*)m_caster, this->gameObjTarget);
2224	sLog.outDebug("Horde Flag Returned");
2225	break;*/
2226	case 34976:
2227	/*
2228	if(bg->GetTypeID()==BATTLEGROUND_EY)
2229	bg->EventPlayerClickedOnFlag((Player*)m_caster, this->gameObjTarget);
2230	*/
2231	break;
2232	default:
2233	sLog.outDebug("Unknown spellid %u in BG event", m_spellInfo->Id);
2234	break;
2235	}
2236	}
2237	}
2238	sLog.outDebug("Spell ScriptStart %u for spellid %u in EffectSendEvent ", m_spellInfo->EffectMiscValue[EffectIndex], m_spellInfo->Id);
2239	sWorld.ScriptsStart(sEventScripts, m_spellInfo->EffectMiscValue[EffectIndex], m_caster, focusObject);
2240	}
2241
2242	void Spell::EffectPowerBurn(uint32 i)
2243	{
2244	if(m_spellInfo->EffectMiscValue[i] < 0 \|\| m_spellInfo->EffectMiscValue[i] >= MAX_POWERS)
2245	return;
2246
2247	Powers powertype = Powers(m_spellInfo->EffectMiscValue[i]);
2248
2249	if(!unitTarget)
2250	return;
2251	if(!unitTarget->isAlive())
2252	return;
2253	if(unitTarget->getPowerType()!=powertype)
2254	return;
2255	if(damage < 0)
2256	return;
2257
2258	int32 curPower = int32(unitTarget->GetPower(powertype));
2259
2260	// resilience reduce mana draining effect at spell crit damage reduction (added in 2.4)
2261	uint32 power = damage;
2262	if ( powertype == POWER_MANA && unitTarget->GetTypeId() == TYPEID_PLAYER )
2263	power -= ((Player*)unitTarget)->GetSpellCritDamageReduction(power);
2264
2265	int32 new_damage = (curPower < power) ? curPower : power;
2266
2267	unitTarget->ModifyPower(powertype,-new_damage);
2268	float multiplier = m_spellInfo->EffectMultipleValue[i];
2269
2270	if(Player *modOwner = m_caster->GetSpellModOwner())
2271	modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_MULTIPLE_VALUE, multiplier);
2272
2273	new_damage = int32(new_damage*multiplier);
2274	m_caster->SpellNonMeleeDamageLog(unitTarget, m_spellInfo->Id, new_damage, m_IsTriggeredSpell, true);
2275	}
2276
2277	void Spell::EffectHeal( uint32 /i/ )
2278	{
2279	if( unitTarget && unitTarget->isAlive() && damage >= 0)
2280	{
2281	// Try to get original caster
2282	Unit *caster = m_originalCasterGUID ? m_originalCaster : m_caster;
2283
2284	// Skip if m_originalCaster not available
2285	if (!caster)
2286	return;
2287
2288	int32 addhealth = damage;
2289
2290	// Vessel of the Naaru (Vial of the Sunwell trinket)
2291	if (m_spellInfo->Id == 45064)
2292	{
2293	// Amount of heal - depends from stacked Holy Energy
2294	int damageAmount = 0;
2295	Unit::AuraList const& mDummyAuras = m_caster->GetAurasByType(SPELL_AURA_DUMMY);
2296	for(Unit::AuraList::const_iterator i = mDummyAuras.begin();i != mDummyAuras.end(); ++i)
2297	if((*i)->GetId() == 45062)
2298	damageAmount+=(*i)->GetModifier()->m_amount;
2299	if (damageAmount)
2300	m_caster->RemoveAurasDueToSpell(45062);
2301
2302	addhealth += damageAmount;
2303	}
2304	// Swiftmend - consumes Regrowth or Rejuvenation
2305	else if (m_spellInfo->TargetAuraState == AURA_STATE_SWIFTMEND && unitTarget->HasAuraState(AURA_STATE_SWIFTMEND))
2306	{
2307	Unit::AuraList const& RejorRegr = unitTarget->GetAurasByType(SPELL_AURA_PERIODIC_HEAL);
2308	// find most short by duration
2309	Aura *targetAura = NULL;
2310	for(Unit::AuraList::const_iterator i = RejorRegr.begin(); i != RejorRegr.end(); ++i)
2311	{
2312	if((*i)->GetSpellProto()->SpellFamilyName == SPELLFAMILY_DRUID
2313	&& ((i)->GetSpellProto()->SpellFamilyFlags == 0x40 \|\| (i)->GetSpellProto()->SpellFamilyFlags == 0x10) )
2314	{
2315	if(!targetAura \|\| (*i)->GetAuraDuration() < targetAura->GetAuraDuration())
2316	targetAura = *i;
2317	}
2318	}
2319
2320	if(!targetAura)
2321	{
2322	sLog.outError("Target(GUID:" I64FMTD ") has aurastate AURA_STATE_SWIFTMEND but no matching aura.", unitTarget->GetGUID());
2323	return;
2324	}
2325	int idx = 0;
2326	while(idx < 3)
2327	{
2328	if(targetAura->GetSpellProto()->EffectApplyAuraName[idx] == SPELL_AURA_PERIODIC_HEAL)
2329	break;
2330	idx++;
2331	}
2332
2333	int32 tickheal = caster->SpellHealingBonus(targetAura->GetSpellProto(), targetAura->GetModifier()->m_amount, DOT, unitTarget);
2334	int32 tickcount = GetSpellDuration(targetAura->GetSpellProto()) / targetAura->GetSpellProto()->EffectAmplitude[idx];
2335	unitTarget->RemoveAurasDueToSpell(targetAura->GetId());
2336
2337	addhealth += tickheal * tickcount;
2338	}
2339	else
2340	addhealth = caster->SpellHealingBonus(m_spellInfo, addhealth,HEAL, unitTarget);
2341
2342	bool crit = caster->isSpellCrit(unitTarget, m_spellInfo, m_spellSchoolMask, m_attackType);
2343	if (crit)
2344	addhealth = caster->SpellCriticalBonus(m_spellInfo, addhealth, unitTarget);
2345	caster->SendHealSpellLog(unitTarget, m_spellInfo->Id, addhealth, crit);
2346
2347	int32 gain = unitTarget->ModifyHealth( int32(addhealth) );
2348	unitTarget->getHostilRefManager().threatAssist(m_caster, float(gain) * 0.5f, m_spellInfo);
2349
2350	if(caster->GetTypeId()==TYPEID_PLAYER)
2351	if(BattleGround bg = ((Player)caster)->GetBattleGround())
2352	bg->UpdatePlayerScore(((Player*)caster), SCORE_HEALING_DONE, gain);
2353
2354	// ignore item heals
2355	if(m_CastItem)
2356	return;
2357
2358	uint32 procHealer = PROC_FLAG_HEAL;
2359	if (crit)
2360	procHealer \|= PROC_FLAG_CRIT_HEAL;
2361
2362	m_caster->ProcDamageAndSpell(unitTarget,procHealer,PROC_FLAG_HEALED,addhealth,SPELL_SCHOOL_MASK_NONE,m_spellInfo,m_IsTriggeredSpell);
2363	}
2364	}
2365
2366	void Spell::EffectHealPct( uint32 /i/ )
2367	{
2368	if( unitTarget && unitTarget->isAlive() && damage >= 0)
2369	{
2370	// Try to get original caster
2371	Unit *caster = m_originalCasterGUID ? m_originalCaster : m_caster;
2372
2373	// Skip if m_originalCaster not available
2374	if (!caster)
2375	return;
2376
2377	uint32 addhealth = unitTarget->GetMaxHealth() * damage / 100;
2378	caster->SendHealSpellLog(unitTarget, m_spellInfo->Id, addhealth, false);
2379
2380	int32 gain = unitTarget->ModifyHealth( int32(addhealth) );
2381	unitTarget->getHostilRefManager().threatAssist(m_caster, float(gain) * 0.5f, m_spellInfo);
2382
2383	if(caster->GetTypeId()==TYPEID_PLAYER)
2384	if(BattleGround bg = ((Player)caster)->GetBattleGround())
2385	bg->UpdatePlayerScore(((Player*)caster), SCORE_HEALING_DONE, gain);
2386	}
2387	}
2388
2389	void Spell::EffectHealMechanical( uint32 /i/ )
2390	{
2391	// Mechanic creature type should be correctly checked by targetCreatureType field
2392	if( unitTarget && unitTarget->isAlive() && damage >= 0)
2393	{
2394	// Try to get original caster
2395	Unit *caster = m_originalCasterGUID ? m_originalCaster : m_caster;
2396
2397	// Skip if m_originalCaster not available
2398	if (!caster)
2399	return;
2400
2401	uint32 addhealth = caster->SpellHealingBonus(m_spellInfo, uint32(damage), HEAL, unitTarget);
2402	caster->SendHealSpellLog(unitTarget, m_spellInfo->Id, addhealth, false);
2403	unitTarget->ModifyHealth( int32(damage) );
2404	}
2405	}
2406
2407	void Spell::EffectHealthLeech(uint32 i)
2408	{
2409	if(!unitTarget)
2410	return;
2411	if(!unitTarget->isAlive())
2412	return;
2413
2414	if(damage < 0)
2415	return;
2416
2417	sLog.outDebug("HealthLeech :%i", damage);
2418
2419	float multiplier = m_spellInfo->EffectMultipleValue[i];
2420
2421	if(Player *modOwner = m_caster->GetSpellModOwner())
2422	modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_MULTIPLE_VALUE, multiplier);
2423
2424	int32 new_damage = int32(damage*multiplier);
2425	uint32 curHealth = unitTarget->GetHealth();
2426	new_damage = m_caster->SpellNonMeleeDamageLog(unitTarget, m_spellInfo->Id, new_damage, m_IsTriggeredSpell, true);
2427	if(curHealth < new_damage)
2428	new_damage = curHealth;
2429
2430	if(m_caster->isAlive())
2431	{
2432	new_damage = m_caster->SpellHealingBonus(m_spellInfo, new_damage, HEAL, m_caster);
2433
2434	m_caster->ModifyHealth(new_damage);
2435
2436	if(m_caster->GetTypeId() == TYPEID_PLAYER)
2437	m_caster->SendHealSpellLog(m_caster, m_spellInfo->Id, uint32(new_damage));
2438	}
2439	}
2440
2441	void Spell::DoCreateItem(uint32 i, uint32 itemtype)
2442	{
2443	if (!unitTarget \|\| unitTarget->GetTypeId() != TYPEID_PLAYER)
2444	return;
2445
2446	Player* player = (Player*)unitTarget;
2447
2448	uint32 newitemid = itemtype;
2449	ItemPrototype const *pProto = objmgr.GetItemPrototype( newitemid );
2450	if(!pProto)
2451	{
2452	player->SendEquipError( EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
2453	return;
2454	}
2455
2456	uint32 num_to_add;
2457
2458	// TODO: maybe all this can be replaced by using correct calculated `damage` value
2459	if(pProto->Class != ITEM_CLASS_CONSUMABLE \|\| m_spellInfo->SpellFamilyName != SPELLFAMILY_MAGE)
2460	{
2461	int32 basePoints = m_currentBasePoints[i];
2462	int32 randomPoints = m_spellInfo->EffectDieSides[i];
2463	if (randomPoints)
2464	num_to_add = basePoints + irand(1, randomPoints);
2465	else
2466	num_to_add = basePoints + 1;
2467	}
2468	else if (pProto->MaxCount == 1)
2469	num_to_add = 1;
2470	else if(player->getLevel() >= m_spellInfo->spellLevel)
2471	{
2472	int32 basePoints = m_currentBasePoints[i];
2473	float pointPerLevel = m_spellInfo->EffectRealPointsPerLevel[i];
2474	num_to_add = basePoints + 1 + uint32((player->getLevel() - m_spellInfo->spellLevel)*pointPerLevel);
2475	}
2476	else
2477	num_to_add = 2;
2478
2479	if (num_to_add < 1)
2480	num_to_add = 1;
2481	if (num_to_add > pProto->Stackable)
2482	num_to_add = pProto->Stackable;
2483
2484	// init items_count to 1, since 1 item will be created regardless of specialization
2485	int items_count=1;
2486	// the chance to create additional items
2487	float additionalCreateChance=0.0f;
2488	// the maximum number of created additional items
2489	uint8 additionalMaxNum=0;
2490	// get the chance and maximum number for creating extra items
2491	if ( canCreateExtraItems(player, m_spellInfo->Id, additionalCreateChance, additionalMaxNum) )
2492	{
2493	// roll with this chance till we roll not to create or we create the max num
2494	while ( roll_chance_f(additionalCreateChance) && items_count<=additionalMaxNum )
2495	++items_count;
2496	}
2497
2498	// really will be created more items
2499	num_to_add *= items_count;
2500
2501	// can the player store the new item?
2502	ItemPosCountVec dest;
2503	uint32 no_space = 0;
2504	uint8 msg = player->CanStoreNewItem( NULL_BAG, NULL_SLOT, dest, newitemid, num_to_add, &no_space );
2505	if( msg != EQUIP_ERR_OK )
2506	{
2507	// convert to possible store amount
2508	if( msg == EQUIP_ERR_INVENTORY_FULL \|\| msg == EQUIP_ERR_CANT_CARRY_MORE_OF_THIS )
2509	num_to_add -= no_space;
2510	else
2511	{
2512	// if not created by another reason from full inventory or unique items amount limitation
2513	player->SendEquipError( msg, NULL, NULL );
2514	return;
2515	}
2516	}
2517
2518	if(num_to_add)
2519	{
2520	// create the new item and store it
2521	Item* pItem = player->StoreNewItem( dest, newitemid, true, Item::GenerateItemRandomPropertyId(newitemid));
2522
2523	// was it successful? return error if not
2524	if(!pItem)
2525	{
2526	player->SendEquipError( EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
2527	return;
2528	}
2529
2530	// set the "Crafted by ..." property of the item
2531	if( pItem->GetProto()->Class != ITEM_CLASS_CONSUMABLE && pItem->GetProto()->Class != ITEM_CLASS_QUEST)
2532	pItem->SetUInt32Value(ITEM_FIELD_CREATOR,player->GetGUIDLow());
2533
2534	// send info to the client
2535	if(pItem)
2536	player->SendNewItem(pItem, num_to_add, true, true);
2537
2538	// we succeeded in creating at least one item, so a levelup is possible
2539	player->UpdateCraftSkill(m_spellInfo->Id);
2540	}
2541
2542	// for battleground marks send by mail if not add all expected
2543	if(no_space > 0 )
2544	{
2545	BattleGroundTypeId bgType;
2546	switch(m_spellInfo->Id)
2547	{
2548	case SPELL_AV_MARK_WINNER:
2549	case SPELL_AV_MARK_LOSER:
2550	bgType = BATTLEGROUND_AV;
2551	break;
2552	case SPELL_WS_MARK_WINNER:
2553	case SPELL_WS_MARK_LOSER:
2554	bgType = BATTLEGROUND_WS;
2555	break;
2556	case SPELL_AB_MARK_WINNER:
2557	case SPELL_AB_MARK_LOSER:
2558	bgType = BATTLEGROUND_AB;
2559	break;
2560	default:
2561	return;
2562	}
2563
2564	if(BattleGround* bg = sBattleGroundMgr.GetBattleGroundTemplate(bgType))
2565	bg->SendRewardMarkByMail(player,newitemid,no_space);
2566	}
2567	}
2568
2569	void Spell::EffectCreateItem(uint32 i)
2570	{
2571	DoCreateItem(i,m_spellInfo->EffectItemType[i]);
2572	}
2573
2574	void Spell::EffectPersistentAA(uint32 i)
2575	{
2576	float radius = GetSpellRadius(sSpellRadiusStore.LookupEntry(m_spellInfo->EffectRadiusIndex[i]));
2577
2578	if(Player* modOwner = m_caster->GetSpellModOwner())
2579	modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_RADIUS, radius);
2580
2581	int32 duration = GetSpellDuration(m_spellInfo);
2582	DynamicObject* dynObj = new DynamicObject;
2583	if(!dynObj->Create(objmgr.GenerateLowGuid(HIGHGUID_DYNAMICOBJECT), m_caster, m_spellInfo->Id, i, m_targets.m_destX, m_targets.m_destY, m_targets.m_destZ, duration, radius))
2584	{
2585	delete dynObj;
2586	return;
2587	}
2588	dynObj->SetUInt32Value(OBJECT_FIELD_TYPE, 65);
2589	dynObj->SetUInt32Value(GAMEOBJECT_DISPLAYID, 368003);
2590	dynObj->SetUInt32Value(DYNAMICOBJECT_BYTES, 0x01eeeeee);
2591	m_caster->AddDynObject(dynObj);
2592	MapManager::Instance().GetMap(dynObj->GetMapId(), dynObj)->Add(dynObj);
2593	}
2594
2595	void Spell::EffectEnergize(uint32 i)
2596	{
2597	if(!unitTarget)
2598	return;
2599	if(!unitTarget->isAlive())
2600	return;
2601
2602	if(m_spellInfo->EffectMiscValue[i] < 0 \|\| m_spellInfo->EffectMiscValue[i] >= MAX_POWERS)
2603	return;
2604
2605	// Some level depends spells
2606	int multipler = 0;
2607	int level_diff = 0;
2608	switch (m_spellInfo->Id)
2609	{
2610	// Restore Energy
2611	case 9512:
2612	level_diff = m_caster->getLevel() - 40;
2613	multipler = 2;
2614	break;
2615	// Blood Fury
2616	case 24571:
2617	level_diff = m_caster->getLevel() - 60;
2618	multipler = 10;
2619	break;
2620	// Burst of Energy
2621	case 24532:
2622	level_diff = m_caster->getLevel() - 60;
2623	multipler = 4;
2624	break;
2625	default:
2626	break;
2627	}
2628
2629	if (level_diff > 0)
2630	damage -= multipler * level_diff;
2631
2632	if(damage < 0)
2633	return;
2634
2635	Powers power = Powers(m_spellInfo->EffectMiscValue[i]);
2636
2637	if(unitTarget->GetMaxPower(power) == 0)
2638	return;
2639
2640	unitTarget->ModifyPower(power,damage);
2641	m_caster->SendEnergizeSpellLog(unitTarget, m_spellInfo->Id, damage, power);
2642
2643	// Mad Alchemist's Potion
2644	if (m_spellInfo->Id == 45051)
2645	{
2646	// find elixirs on target
2647	uint32 elixir_mask = 0;
2648	Unit::AuraMap& Auras = unitTarget->GetAuras();
2649	for(Unit::AuraMap::iterator itr = Auras.begin(); itr != Auras.end(); ++itr)
2650	{
2651	uint32 spell_id = itr->second->GetId();
2652	if(uint32 mask = spellmgr.GetSpellElixirMask(spell_id))
2653	elixir_mask \|= mask;
2654	}
2655
2656	// get available elixir mask any not active type from battle/guardian (and flask if no any)
2657	elixir_mask = (elixir_mask & ELIXIR_FLASK_MASK) ^ ELIXIR_FLASK_MASK;
2658
2659	// get all available elixirs by mask and spell level
2660	std::vector<uint32> elixirs;
2661	SpellElixirMap const& m_spellElixirs = spellmgr.GetSpellElixirMap();
2662	for(SpellElixirMap::const_iterator itr = m_spellElixirs.begin(); itr != m_spellElixirs.end(); ++itr)
2663	{
2664	if (itr->second & elixir_mask)
2665	{
2666	if (itr->second & (ELIXIR_UNSTABLE_MASK \| ELIXIR_SHATTRATH_MASK))
2667	continue;
2668
2669	SpellEntry const *spellInfo = sSpellStore.LookupEntry(itr->first);
2670	if (spellInfo && (spellInfo->spellLevel < m_spellInfo->spellLevel \|\| spellInfo->spellLevel > unitTarget->getLevel()))
2671	continue;
2672
2673	elixirs.push_back(itr->first);
2674	}
2675	}
2676
2677	if (!elixirs.empty())
2678	{
2679	// cast random elixir on target
2680	uint32 rand_spell = urand(0,elixirs.size()-1);
2681	m_caster->CastSpell(unitTarget,elixirs[rand_spell],true,m_CastItem);
2682	}
2683	}
2684	}
2685
2686	void Spell::EffectEnergisePct(uint32 i)
2687	{
2688	if(!unitTarget)
2689	return;
2690	if(!unitTarget->isAlive())
2691	return;
2692
2693	if(m_spellInfo->EffectMiscValue[i] < 0 \|\| m_spellInfo->EffectMiscValue[i] >= MAX_POWERS)
2694	return;
2695
2696	Powers power = Powers(m_spellInfo->EffectMiscValue[i]);
2697
2698	uint32 maxPower = unitTarget->GetMaxPower(power);
2699	if(maxPower == 0)
2700	return;
2701
2702	uint32 gain = damage * maxPower / 100;
2703	unitTarget->ModifyPower(power, gain);
2704	m_caster->SendEnergizeSpellLog(unitTarget, m_spellInfo->Id, damage, power);
2705	}
2706
2707	void Spell::SendLoot(uint64 guid, LootType loottype)
2708	{
2709	Player* player = (Player*)m_caster;
2710	if (!player)
2711	return;
2712
2713	if (gameObjTarget)
2714	{
2715	switch (gameObjTarget->GetGoType())
2716	{
2717	case GAMEOBJECT_TYPE_DOOR:
2718	case GAMEOBJECT_TYPE_BUTTON:
2719	gameObjTarget->UseDoorOrButton();
2720	sWorld.ScriptsStart(sGameObjectScripts, gameObjTarget->GetDBTableGUIDLow(), player, gameObjTarget);
2721	return;
2722
2723	case GAMEOBJECT_TYPE_QUESTGIVER:
2724	// start or end quest
2725	player->PrepareQuestMenu(guid);
2726	player->SendPreparedQuest(guid);
2727	return;
2728
2729	case GAMEOBJECT_TYPE_SPELL_FOCUS:
2730	// triggering linked GO
2731	if(uint32 trapEntry = gameObjTarget->GetGOInfo()->spellFocus.linkedTrapId)
2732	gameObjTarget->TriggeringLinkedGameObject(trapEntry,m_caster);
2733	return;
2734
2735	case GAMEOBJECT_TYPE_GOOBER:
2736	// goober_scripts can be triggered if the player don't have the quest
2737	if (gameObjTarget->GetGOInfo()->goober.eventId)
2738	{
2739	sLog.outDebug("Goober ScriptStart id %u for GO %u", gameObjTarget->GetGOInfo()->goober.eventId,gameObjTarget->GetDBTableGUIDLow());
2740	sWorld.ScriptsStart(sEventScripts, gameObjTarget->GetGOInfo()->goober.eventId, player, gameObjTarget);
2741	}
2742
2743	// cast goober spell
2744	if (gameObjTarget->GetGOInfo()->goober.questId)
2745	///Quest require to be active for GO using
2746	if(player->GetQuestStatus(gameObjTarget->GetGOInfo()->goober.questId) != QUEST_STATUS_INCOMPLETE)
2747	return;
2748
2749	gameObjTarget->AddUniqueUse(player);
2750	gameObjTarget->SetLootState(GO_JUST_DEACTIVATED);
2751
2752	//TODO? Objective counting called without spell check but with quest objective check
2753	// if send spell id then this line will duplicate to spell casting call (double counting)
2754	// So we or have this line and not required in quest_template have reqSpellIdN
2755	// or must remove this line and required in DB have data in quest_template have reqSpellIdN for all quest using cases.
2756	player->CastedCreatureOrGO(gameObjTarget->GetEntry(), gameObjTarget->GetGUID(), 0);
2757
2758	// triggering linked GO
2759	if(uint32 trapEntry = gameObjTarget->GetGOInfo()->goober.linkedTrapId)
2760	gameObjTarget->TriggeringLinkedGameObject(trapEntry,m_caster);
2761
2762	return;
2763
2764	case GAMEOBJECT_TYPE_CHEST:
2765	// TODO: possible must be moved to loot release (in different from linked triggering)
2766	if (gameObjTarget->GetGOInfo()->chest.eventId)
2767	{
2768	sLog.outDebug("Chest ScriptStart id %u for GO %u", gameObjTarget->GetGOInfo()->chest.eventId,gameObjTarget->GetDBTableGUIDLow());
2769	sWorld.ScriptsStart(sEventScripts, gameObjTarget->GetGOInfo()->chest.eventId, player, gameObjTarget);
2770	}
2771
2772	// triggering linked GO
2773	if(uint32 trapEntry = gameObjTarget->GetGOInfo()->chest.linkedTrapId)
2774	gameObjTarget->TriggeringLinkedGameObject(trapEntry,m_caster);
2775
2776	// Don't return, let loots been taken
2777	}
2778	}
2779
2780	// Send loot
2781	player->SendLoot(guid, loottype);
2782	}
2783
2784	void Spell::EffectOpenLock(uint32 /i/)
2785	{
2786	if(!m_caster \|\| m_caster->GetTypeId() != TYPEID_PLAYER)
2787	{
2788	sLog.outDebug( "WORLD: Open Lock - No Player Caster!");
2789	return;
2790	}
2791
2792	Player* player = (Player*)m_caster;
2793
2794	LootType loottype = LOOT_CORPSE;
2795	uint32 lockId = 0;
2796	uint64 guid = 0;
2797
2798	// Get lockId
2799	if(gameObjTarget)
2800	{
2801	GameObjectInfo const* goInfo = gameObjTarget->GetGOInfo();
2802	// Arathi Basin banner opening !
2803	if( goInfo->type == GAMEOBJECT_TYPE_BUTTON && goInfo->button.noDamageImmune \|\|
2804	goInfo->type == GAMEOBJECT_TYPE_GOOBER && goInfo->goober.losOK )
2805	{
2806	//isAllowUseBattleGroundObject() already called in CanCast()
2807	// in battleground check
2808	if(BattleGround *bg = player->GetBattleGround())
2809	{
2810	// check if it's correct bg
2811	if(bg && bg->GetTypeID() == BATTLEGROUND_AB)
2812	bg->EventPlayerClickedOnFlag(player, gameObjTarget);
2813	return;
2814	}
2815	}
2816	else if (goInfo->type == GAMEOBJECT_TYPE_FLAGSTAND)
2817	{
2818	//isAllowUseBattleGroundObject() already called in CanCast()
2819	// in battleground check
2820	if(BattleGround *bg = player->GetBattleGround())
2821	{
2822	if(bg->GetTypeID() == BATTLEGROUND_EY)
2823	bg->EventPlayerClickedOnFlag(player, gameObjTarget);
2824	return;
2825	}
2826	}
2827	// handle outdoor pvp object opening, return true if go was registered for handling
2828	// these objects must have been spawned by outdoorpvp!
2829	else if(gameObjTarget->GetGOInfo()->type == GAMEOBJECT_TYPE_GOOBER && sOutdoorPvPMgr.HandleOpenGo(player, gameObjTarget->GetGUID()))
2830	return;
2831	lockId = gameObjTarget->GetLockId();
2832	guid = gameObjTarget->GetGUID();
2833	}
2834	else if(itemTarget)
2835	{
2836	lockId = itemTarget->GetProto()->LockID;
2837	guid = itemTarget->GetGUID();
2838	}
2839	else
2840	{
2841	sLog.outDebug( "WORLD: Open Lock - No GameObject/Item Target!");
2842	return;
2843	}
2844
2845	if(!lockId) // possible case for GO and maybe for items.
2846	{
2847	SendLoot(guid, loottype);
2848	return;
2849	}
2850
2851	// Get LockInfo
2852	LockEntry const *lockInfo = sLockStore.LookupEntry(lockId);
2853
2854	if (!lockInfo)
2855	{
2856	sLog.outError( "Spell::EffectOpenLock: %s [guid = %u] has an unknown lockId: %u!",
2857	(gameObjTarget ? "gameobject" : "item"), GUID_LOPART(guid), lockId);
2858	SendCastResult(SPELL_FAILED_BAD_TARGETS);
2859	return;
2860	}
2861
2862	// check key
2863	for(int i = 0; i < 5; ++i)
2864	{
2865	// type==1 This means lockInfo->key[i] is an item
2866	if(lockInfo->keytype[i]==LOCK_KEY_ITEM && lockInfo->key[i] && m_CastItem && m_CastItem->GetEntry()==lockInfo->key[i])
2867	{
2868	SendLoot(guid, loottype);
2869	return;
2870	}
2871	}
2872
2873	uint32 SkillId = 0;
2874	// Check and skill-up skill
2875	if( m_spellInfo->Effect[1] == SPELL_EFFECT_SKILL )
2876	SkillId = m_spellInfo->EffectMiscValue[1];
2877	// pickpocketing spells
2878	else if( m_spellInfo->EffectMiscValue[0] == LOCKTYPE_PICKLOCK )
2879	SkillId = SKILL_LOCKPICKING;
2880
2881	// skill bonus provided by casting spell (mostly item spells)
2882	uint32 spellSkillBonus = uint32(m_currentBasePoints[0]+1);
2883
2884	uint32 reqSkillValue = lockInfo->requiredminingskill;
2885
2886	if(lockInfo->requiredlockskill) // required pick lock skill applying
2887	{
2888	if(SkillId != SKILL_LOCKPICKING) // wrong skill (cheating?)
2889	{
2890	SendCastResult(SPELL_FAILED_FIZZLE);
2891	return;
2892	}
2893
2894	reqSkillValue = lockInfo->requiredlockskill;
2895	}
2896	else if(SkillId == SKILL_LOCKPICKING) // apply picklock skill to wrong target
2897	{
2898	SendCastResult(SPELL_FAILED_BAD_TARGETS);
2899	return;
2900	}
2901
2902	if ( SkillId )
2903	{
2904	loottype = LOOT_SKINNING;
2905	if ( player->GetSkillValue(SkillId) + spellSkillBonus < reqSkillValue )
2906	{
2907	SendCastResult(SPELL_FAILED_LOW_CASTLEVEL);
2908	return;
2909	}
2910
2911	// update skill if really known
2912	uint32 SkillValue = player->GetPureSkillValue(SkillId);
2913	if(SkillValue) // non only item base skill
2914	{
2915	if(gameObjTarget)
2916	{
2917	// Allow one skill-up until respawned
2918	if ( !gameObjTarget->IsInSkillupList( player->GetGUIDLow() ) &&
2919	player->UpdateGatherSkill(SkillId, SkillValue, reqSkillValue) )
2920	gameObjTarget->AddToSkillupList( player->GetGUIDLow() );
2921	}
2922	else if(itemTarget)
2923	{
2924	// Do one skill-up
2925	uint32 SkillValue = player->GetPureSkillValue(SkillId);
2926	player->UpdateGatherSkill(SkillId, SkillValue, reqSkillValue);
2927	}
2928	}
2929	}
2930
2931	SendLoot(guid, loottype);
2932	}
2933
2934	void Spell::EffectSummonChangeItem(uint32 i)
2935	{
2936	if(m_caster->GetTypeId() != TYPEID_PLAYER)
2937	return;
2938
2939	Player player = (Player)m_caster;
2940
2941	// applied only to using item
2942	if(!m_CastItem)
2943	return;
2944
2945	// ... only to item in own inventory/bank/equip_slot
2946	if(m_CastItem->GetOwnerGUID()!=player->GetGUID())
2947	return;
2948
2949	uint32 newitemid = m_spellInfo->EffectItemType[i];
2950	if(!newitemid)
2951	return;
2952
2953	uint16 pos = m_CastItem->GetPos();
2954
2955	Item *pNewItem = Item::CreateItem( newitemid, 1, player);
2956	if( !pNewItem )
2957	return;
2958
2959	for(uint8 i= PERM_ENCHANTMENT_SLOT; i<=TEMP_ENCHANTMENT_SLOT; ++i)
2960	{
2961	if(m_CastItem->GetEnchantmentId(EnchantmentSlot(i)))
2962	pNewItem->SetEnchantment(EnchantmentSlot(i), m_CastItem->GetEnchantmentId(EnchantmentSlot(i)), m_CastItem->GetEnchantmentDuration(EnchantmentSlot(i)), m_CastItem->GetEnchantmentCharges(EnchantmentSlot(i)));
2963	}
2964
2965	if(m_CastItem->GetUInt32Value(ITEM_FIELD_DURABILITY) < m_CastItem->GetUInt32Value(ITEM_FIELD_MAXDURABILITY))
2966	{
2967	double loosePercent = 1 - m_CastItem->GetUInt32Value(ITEM_FIELD_DURABILITY) / double(m_CastItem->GetUInt32Value(ITEM_FIELD_MAXDURABILITY));
2968	player->DurabilityLoss(pNewItem, loosePercent);
2969	}
2970
2971	if( player->IsInventoryPos( pos ) )
2972	{
2973	ItemPosCountVec dest;
2974	uint8 msg = player->CanStoreItem( m_CastItem->GetBagSlot(), m_CastItem->GetSlot(), dest, pNewItem, true );
2975	if( msg == EQUIP_ERR_OK )
2976	{
2977	player->DestroyItem(m_CastItem->GetBagSlot(), m_CastItem->GetSlot(),true);
2978
2979	// prevent crash at access and unexpected charges counting with item update queue corrupt
2980	if(m_CastItem==m_targets.getItemTarget())
2981	m_targets.setItemTarget(NULL);
2982
2983	m_CastItem = NULL;
2984
2985	player->StoreItem( dest, pNewItem, true);
2986	return;
2987	}
2988	}
2989	else if( player->IsBankPos ( pos ) )
2990	{
2991	ItemPosCountVec dest;
2992	uint8 msg = player->CanBankItem( m_CastItem->GetBagSlot(), m_CastItem->GetSlot(), dest, pNewItem, true );
2993	if( msg == EQUIP_ERR_OK )
2994	{
2995	player->DestroyItem(m_CastItem->GetBagSlot(), m_CastItem->GetSlot(),true);
2996
2997	// prevent crash at access and unexpected charges counting with item update queue corrupt
2998	if(m_CastItem==m_targets.getItemTarget())
2999	m_targets.setItemTarget(NULL);
3000
3001	m_CastItem = NULL;
3002
3003	player->BankItem( dest, pNewItem, true);
3004	return;
3005	}
3006	}
3007	else if( player->IsEquipmentPos ( pos ) )
3008	{
3009	uint16 dest;
3010	uint8 msg = player->CanEquipItem( m_CastItem->GetSlot(), dest, pNewItem, true );
3011	if( msg == EQUIP_ERR_OK )
3012	{
3013	player->DestroyItem(m_CastItem->GetBagSlot(), m_CastItem->GetSlot(),true);
3014
3015	// prevent crash at access and unexpected charges counting with item update queue corrupt
3016	if(m_CastItem==m_targets.getItemTarget())
3017	m_targets.setItemTarget(NULL);
3018
3019	m_CastItem = NULL;
3020
3021	player->EquipItem( dest, pNewItem, true);
3022	player->AutoUnequipOffhandIfNeed();
3023	return;
3024	}
3025	}
3026
3027	// fail
3028	delete pNewItem;
3029	}
3030
3031	void Spell::EffectOpenSecretSafe(uint32 i)
3032	{
3033	EffectOpenLock(i); //no difference for now
3034	}
3035
3036	void Spell::EffectProficiency(uint32 /i/)
3037	{
3038	if (!unitTarget \|\| unitTarget->GetTypeId() != TYPEID_PLAYER)
3039	return;
3040	Player p_target = (Player)unitTarget;
3041
3042	uint32 subClassMask = m_spellInfo->EquippedItemSubClassMask;
3043	if(m_spellInfo->EquippedItemClass == 2 && !(p_target->GetWeaponProficiency() & subClassMask))
3044	{
3045	p_target->AddWeaponProficiency(subClassMask);
3046	p_target->SendProficiency(uint8(0x02),p_target->GetWeaponProficiency());
3047	}
3048	if(m_spellInfo->EquippedItemClass == 4 && !(p_target->GetArmorProficiency() & subClassMask))
3049	{
3050	p_target->AddArmorProficiency(subClassMask);
3051	p_target->SendProficiency(uint8(0x04),p_target->GetArmorProficiency());
3052	}
3053	}
3054
3055	void Spell::EffectApplyAreaAura(uint32 i)
3056	{
3057	if(!unitTarget)
3058	return;
3059	if(!unitTarget->isAlive())
3060	return;
3061
3062	AreaAura* Aur = new AreaAura(m_spellInfo, i, &m_currentBasePoints[i], unitTarget, m_caster, m_CastItem);
3063	unitTarget->AddAura(Aur);
3064	}
3065
3066	void Spell::EffectSummonType(uint32 i)
3067	{
3068	switch(m_spellInfo->EffectMiscValueB[i])
3069	{
3070	case SUMMON_TYPE_GUARDIAN:
3071	case SUMMON_TYPE_POSESSED:
3072	case SUMMON_TYPE_POSESSED2:
3073	EffectSummonGuardian(i);
3074	break;
3075	case SUMMON_TYPE_WILD:
3076	EffectSummonWild(i);
3077	break;
3078	case SUMMON_TYPE_DEMON:
3079	EffectSummonDemon(i);
3080	break;
3081	case SUMMON_TYPE_SUMMON:
3082	EffectSummon(i);
3083	break;
3084	case SUMMON_TYPE_CRITTER:
3085	case SUMMON_TYPE_CRITTER2:
3086	case SUMMON_TYPE_CRITTER3:
3087	EffectSummonCritter(i);
3088	break;
3089	case SUMMON_TYPE_TOTEM_SLOT1:
3090	case SUMMON_TYPE_TOTEM_SLOT2:
3091	case SUMMON_TYPE_TOTEM_SLOT3:
3092	case SUMMON_TYPE_TOTEM_SLOT4:
3093	case SUMMON_TYPE_TOTEM:
3094	EffectSummonTotem(i);
3095	break;
3096	case SUMMON_TYPE_UNKNOWN1:
3097	case SUMMON_TYPE_UNKNOWN2:
3098	case SUMMON_TYPE_UNKNOWN3:
3099	case SUMMON_TYPE_UNKNOWN4:
3100	case SUMMON_TYPE_UNKNOWN5:
3101	break;
3102	default:
3103	sLog.outError("EffectSummonType: Unhandled summon type %u", m_spellInfo->EffectMiscValueB[i]);
3104	break;
3105	}
3106	}
3107
3108	void Spell::EffectSummon(uint32 i)
3109	{
3110	if(m_caster->GetPetGUID())
3111	return;
3112
3113	if(!unitTarget)
3114	return;
3115	uint32 pet_entry = m_spellInfo->EffectMiscValue[i];
3116	if(!pet_entry)
3117	return;
3118	uint32 level = m_caster->getLevel();
3119	Pet* spawnCreature = new Pet(SUMMON_PET);
3120
3121	if(spawnCreature->LoadPetFromDB(m_caster,pet_entry))
3122	{
3123	// set timer for unsummon
3124	int32 duration = GetSpellDuration(m_spellInfo);
3125	if(duration > 0)
3126	spawnCreature->SetDuration(duration);
3127
3128	return;
3129	}
3130
3131	Map *map = m_caster->GetMap();
3132	uint32 pet_number = objmgr.GeneratePetNumber();
3133	if(!spawnCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_PET),map,m_spellInfo->EffectMiscValue[i], pet_number))
3134	{
3135	sLog.outErrorDb("Spell::EffectSummon: no such creature entry %u",m_spellInfo->EffectMiscValue[i]);
3136	delete spawnCreature;
3137	return;
3138	}
3139
3140	// Summon in dest location
3141	float x,y,z;
3142	if(m_targets.m_targetMask & TARGET_FLAG_DEST_LOCATION)
3143	{
3144	x = m_targets.m_destX;
3145	y = m_targets.m_destY;
3146	z = m_targets.m_destZ;
3147	}
3148	else
3149	m_caster->GetClosePoint(x,y,z,spawnCreature->GetObjectSize());
3150
3151	spawnCreature->Relocate(x,y,z,-m_caster->GetOrientation());
3152
3153	if(!spawnCreature->IsPositionValid())
3154	{
3155	sLog.outError("ERROR: Pet (guidlow %d, entry %d) not summoned. Suggested coordinates isn't valid (X: %d Y: ^%d)", spawnCreature->GetGUIDLow(), spawnCreature->GetEntry(), spawnCreature->GetPositionX(), spawnCreature->GetPositionY());
3156	delete spawnCreature;
3157	return;
3158	}
3159
3160	// set timer for unsummon
3161	int32 duration = GetSpellDuration(m_spellInfo);
3162	if(duration > 0)
3163	spawnCreature->SetDuration(duration);
3164
3165	spawnCreature->SetUInt64Value(UNIT_FIELD_SUMMONEDBY,m_caster->GetGUID());
3166	spawnCreature->SetUInt32Value(UNIT_NPC_FLAGS , 0);
3167	spawnCreature->setPowerType(POWER_MANA);
3168	spawnCreature->SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE,m_caster->getFaction());
3169	spawnCreature->SetUInt32Value(UNIT_FIELD_FLAGS,0);
3170	spawnCreature->SetUInt32Value(UNIT_FIELD_BYTES_0,2048);
3171	spawnCreature->SetUInt32Value(UNIT_FIELD_BYTES_1,0);
3172	spawnCreature->SetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP,0);
3173	spawnCreature->SetUInt32Value(UNIT_FIELD_PETEXPERIENCE,0);
3174	spawnCreature->SetUInt32Value(UNIT_FIELD_PETNEXTLEVELEXP,1000);
3175	spawnCreature->SetUInt64Value(UNIT_FIELD_CREATEDBY, m_caster->GetGUID());
3176	spawnCreature->SetUInt32Value(UNIT_CREATED_BY_SPELL, m_spellInfo->Id);
3177
3178	spawnCreature->InitStatsForLevel(level);
3179
3180	spawnCreature->GetCharmInfo()->SetPetNumber(pet_number, false);
3181
3182	spawnCreature->AIM_Initialize();
3183	spawnCreature->InitPetCreateSpells();
3184	spawnCreature->SetHealth(spawnCreature->GetMaxHealth());
3185	spawnCreature->SetPower(POWER_MANA, spawnCreature->GetMaxPower(POWER_MANA));
3186
3187	std::string name = m_caster->GetName();
3188	name.append(petTypeSuffix[spawnCreature->getPetType()]);
3189	spawnCreature->SetName( name );
3190
3191	map->Add((Creature*)spawnCreature);
3192
3193	if(m_caster->GetTypeId() == TYPEID_PLAYER)
3194	{
3195	m_caster->SetPet(spawnCreature);
3196	spawnCreature->GetCharmInfo()->SetReactState( REACT_DEFENSIVE );
3197	spawnCreature->SavePetToDB(PET_SAVE_AS_CURRENT);
3198	((Player*)m_caster)->PetSpellInitialize();
3199	}
3200	}
3201
3202	void Spell::EffectLearnSpell(uint32 i)
3203	{
3204	if(!unitTarget)
3205	return;
3206
3207	if(unitTarget->GetTypeId() != TYPEID_PLAYER)
3208	{
3209	if(m_caster->GetTypeId() == TYPEID_PLAYER)
3210	EffectLearnPetSpell(i);
3211
3212	return;
3213	}
3214
3215	Player player = (Player)unitTarget;
3216
3217	uint32 spellToLearn = (m_spellInfo->Id==SPELL_ID_GENERIC_LEARN) ? damage : m_spellInfo->EffectTriggerSpell[i];
3218	player->learnSpell(spellToLearn);
3219
3220	sLog.outDebug( "Spell: Player %u have learned spell %u from NpcGUID=%u", player->GetGUIDLow(), spellToLearn, m_caster->GetGUIDLow() );
3221	}
3222
3223	void Spell::EffectDispel(uint32 i)
3224	{
3225	if(!unitTarget)
3226	return;
3227
3228	// Fill possible dispell list
3229	std::vector <Aura *> dispel_list;
3230
3231	// Create dispel mask by dispel type
3232	uint32 dispel_type = m_spellInfo->EffectMiscValue[i];
3233	uint32 dispelMask = GetDispellMask( DispelType(dispel_type) );
3234	Unit::AuraMap const& auras = unitTarget->GetAuras();
3235	for(Unit::AuraMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
3236	{
3237	Aura aur = (itr).second;
3238	if (aur && (1<<aur->GetSpellProto()->Dispel) & dispelMask)
3239	{
3240	if(aur->GetSpellProto()->Dispel == DISPEL_MAGIC)
3241	{
3242	bool positive = true;
3243	if (!aur->IsPositive())
3244	positive = false;
3245	else
3246	positive = (aur->GetSpellProto()->AttributesEx & SPELL_ATTR_EX_NEGATIVE)==0;
3247
3248	// do not remove positive auras if friendly target
3249	// negative auras if non-friendly target
3250	if(positive == unitTarget->IsFriendlyTo(m_caster))
3251	continue;
3252	}
3253	// Add aura to dispel list
3254	dispel_list.push_back(aur);
3255	}
3256	}
3257	// Ok if exist some buffs for dispel try dispel it
3258	if (!dispel_list.empty())
3259	{
3260	std::list < std::pair<uint32,uint64> > success_list;// (spell_id,casterGuid)
3261	std::list < uint32 > fail_list; // spell_id
3262	int32 list_size = dispel_list.size();
3263	// Dispell N = damage buffs (or while exist buffs for dispel)
3264	for (int32 count=0; count < damage && list_size > 0; ++count)
3265	{
3266	// Random select buff for dispel
3267	Aura *aur = dispel_list[urand(0, list_size-1)];
3268
3269	SpellEntry const* spellInfo = aur->GetSpellProto();
3270	// Base dispel chance
3271	// TODO: possible chance depend from spell level??
3272	int32 miss_chance = 0;
3273	// Apply dispel mod from aura caster
3274	if (Unit *caster = aur->GetCaster())
3275	{
3276	if ( Player* modOwner = caster->GetSpellModOwner() )
3277	modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_RESIST_DISPEL_CHANCE, miss_chance, this);
3278	}
3279	// Try dispel
3280	if (roll_chance_i(miss_chance))
3281	fail_list.push_back(aur->GetId());
3282	else
3283	success_list.push_back(std::pair<uint32,uint64>(aur->GetId(),aur->GetCasterGUID()));
3284	// Remove buff from list for prevent doubles
3285	for (std::vector<Aura *>::iterator j = dispel_list.begin(); j != dispel_list.end(); )
3286	{
3287	Aura dispeled = j;
3288	if (dispeled->GetId() == aur->GetId() && dispeled->GetCasterGUID() == aur->GetCasterGUID())
3289	{
3290	j = dispel_list.erase(j);
3291	--list_size;
3292	}
3293	else
3294	++j;
3295	}
3296	}
3297	// Send success log and really remove auras
3298	if (!success_list.empty())
3299	{
3300	int32 count = success_list.size();
3301	WorldPacket data(SMSG_SPELLDISPELLOG, 8+8+4+1+4+count*5);
3302	data.append(unitTarget->GetPackGUID()); // Victim GUID
3303	data.append(m_caster->GetPackGUID()); // Caster GUID
3304	data << uint32(m_spellInfo->Id); // Dispell spell id
3305	data << uint8(0); // not used
3306	data << uint32(count); // count
3307	for (std::list<std::pair<uint32,uint64> >::iterator j = success_list.begin(); j != success_list.end(); ++j)
3308	{
3309	SpellEntry const* spellInfo = sSpellStore.LookupEntry(j->first);
3310	data << uint32(spellInfo->Id); // Spell Id
3311	data << uint8(0); // 0 - dispeled !=0 cleansed
3312	unitTarget->RemoveAurasDueToSpellByDispel(spellInfo->Id, j->second, m_caster);
3313	}
3314	m_caster->SendMessageToSet(&data, true);
3315
3316	// On succes dispel
3317	// Devour Magic
3318	if (m_spellInfo->SpellFamilyName == SPELLFAMILY_WARLOCK && m_spellInfo->Category == 12)
3319	{
3320	uint32 heal_spell = 0;
3321	switch (m_spellInfo->Id)
3322	{
3323	case 19505: heal_spell = 19658; break;
3324	case 19731: heal_spell = 19732; break;
3325	case 19734: heal_spell = 19733; break;
3326	case 19736: heal_spell = 19735; break;
3327	case 27276: heal_spell = 27278; break;
3328	case 27277: heal_spell = 27279; break;
3329	default:
3330	sLog.outDebug("Spell for Devour Magic %d not handled in Spell::EffectDispel", m_spellInfo->Id);
3331	break;
3332	}
3333	if (heal_spell)
3334	m_caster->CastSpell(m_caster, heal_spell, true);
3335	}
3336	}
3337	// Send fail log to client
3338	if (!fail_list.empty())
3339	{
3340	// Failed to dispell
3341	WorldPacket data(SMSG_DISPEL_FAILED, 8+8+4+4*fail_list.size());
3342	data << uint64(m_caster->GetGUID()); // Caster GUID
3343	data << uint64(unitTarget->GetGUID()); // Victim GUID
3344	data << uint32(m_spellInfo->Id); // Dispell spell id
3345	for (std::list< uint32 >::iterator j = fail_list.begin(); j != fail_list.end(); ++j)
3346	data << uint32(*j); // Spell Id
3347	m_caster->SendMessageToSet(&data, true);
3348	}
3349	}
3350	}
3351
3352	void Spell::EffectDualWield(uint32 /i/)
3353	{
3354	if (unitTarget->GetTypeId() == TYPEID_PLAYER)
3355	((Player*)unitTarget)->SetCanDualWield(true);
3356	}
3357
3358	void Spell::EffectPull(uint32 /i/)
3359	{
3360	// TODO: create a proper pull towards distract spell center for distract
3361	sLog.outDebug("WORLD: Spell Effect DUMMY");
3362	}
3363
3364	void Spell::EffectDistract(uint32 /i/)
3365	{
3366	// Check for possible target
3367	if (!unitTarget \|\| unitTarget->isInCombat())
3368	return;
3369
3370	// target must be OK to do this
3371	if( unitTarget->hasUnitState(UNIT_STAT_CONFUSED \| UNIT_STAT_STUNNED \| UNIT_STAT_FLEEING ) )
3372	return;
3373
3374	float angle = unitTarget->GetAngle(m_targets.m_destX, m_targets.m_destY);
3375
3376	if ( unitTarget->GetTypeId() == TYPEID_PLAYER )
3377	{
3378	// For players just turn them
3379	WorldPacket data;
3380	((Player*)unitTarget)->BuildTeleportAckMsg(&data, unitTarget->GetPositionX(), unitTarget->GetPositionY(), unitTarget->GetPositionZ(), angle);
3381	((Player*)unitTarget)->GetSession()->SendPacket( &data );
3382	((Player*)unitTarget)->SetPosition(unitTarget->GetPositionX(), unitTarget->GetPositionY(), unitTarget->GetPositionZ(), angle, false);
3383	}
3384	else
3385	{
3386	// Set creature Distracted, Stop it, And turn it
3387	unitTarget->SetOrientation(angle);
3388	unitTarget->StopMoving();
3389	unitTarget->GetMotionMaster()->MoveDistract(damage*1000);
3390	}
3391	}
3392
3393	void Spell::EffectPickPocket(uint32 /i/)
3394	{
3395	if( m_caster->GetTypeId() != TYPEID_PLAYER )
3396	return;
3397
3398	// victim must be creature and attackable
3399	if( !unitTarget \|\| unitTarget->GetTypeId() != TYPEID_UNIT \|\| m_caster->IsFriendlyTo(unitTarget) )
3400	return;
3401
3402	// victim have to be alive and humanoid or undead
3403	if( unitTarget->isAlive() && (unitTarget->GetCreatureTypeMask() &CREATURE_TYPEMASK_HUMANOID_OR_UNDEAD) != 0)
3404	{
3405	int32 chance = 10 + int32(m_caster->getLevel()) - int32(unitTarget->getLevel());
3406
3407	if (chance > irand(0, 19))
3408	{
3409	// Stealing successful
3410	//sLog.outDebug("Sending loot from pickpocket");
3411	((Player*)m_caster)->SendLoot(unitTarget->GetGUID(),LOOT_PICKPOCKETING);
3412	}
3413	else
3414	{
3415	// Reveal action + get attack
3416	m_caster->RemoveSpellsCausingAura(SPELL_AURA_MOD_STEALTH);
3417	if (((Creature*)unitTarget)->AI())
3418	((Creature*)unitTarget)->AI()->AttackStart(m_caster);
3419	}
3420	}
3421	}
3422
3423	void Spell::EffectAddFarsight(uint32 i)
3424	{
3425	float radius = GetSpellRadius(sSpellRadiusStore.LookupEntry(m_spellInfo->EffectRadiusIndex[i]));
3426	int32 duration = GetSpellDuration(m_spellInfo);
3427	DynamicObject* dynObj = new DynamicObject;
3428	if(!dynObj->Create(objmgr.GenerateLowGuid(HIGHGUID_DYNAMICOBJECT), m_caster, m_spellInfo->Id, i, m_targets.m_destX, m_targets.m_destY, m_targets.m_destZ, duration, radius))
3429	{
3430	delete dynObj;
3431	return;
3432	}
3433	dynObj->SetUInt32Value(OBJECT_FIELD_TYPE, 65);
3434	dynObj->SetUInt32Value(DYNAMICOBJECT_BYTES, 0x80000002);
3435	m_caster->AddDynObject(dynObj);
3436	MapManager::Instance().GetMap(dynObj->GetMapId(), dynObj)->Add(dynObj);
3437	m_caster->SetUInt64Value(PLAYER_FARSIGHT, dynObj->GetGUID());
3438	}
3439
3440	void Spell::EffectSummonWild(uint32 i)
3441	{
3442	uint32 creature_entry = m_spellInfo->EffectMiscValue[i];
3443	if(!creature_entry)
3444	return;
3445
3446	uint32 level = m_caster->getLevel();
3447
3448	// level of creature summoned using engineering item based at engineering skill level
3449	if(m_caster->GetTypeId()==TYPEID_PLAYER && m_CastItem)
3450	{
3451	ItemPrototype const *proto = m_CastItem->GetProto();
3452	if(proto && proto->RequiredSkill == SKILL_ENGINERING)
3453	{
3454	uint16 skill202 = ((Player*)m_caster)->GetSkillValue(SKILL_ENGINERING);
3455	if(skill202)
3456	{
3457	level = skill202/5;
3458	}
3459	}
3460	}
3461
3462	// select center of summon position
3463	float center_x = m_targets.m_destX;
3464	float center_y = m_targets.m_destY;
3465	float center_z = m_targets.m_destZ;
3466
3467	float radius = GetSpellRadius(sSpellRadiusStore.LookupEntry(m_spellInfo->EffectRadiusIndex[i]));
3468
3469	int32 amount = damage > 0 ? damage : 1;
3470
3471	for(int32 count = 0; count < amount; ++count)
3472	{
3473	float px, py, pz;
3474	// If dest location if present
3475	if (m_targets.m_targetMask & TARGET_FLAG_DEST_LOCATION)
3476	{
3477	// Summon 1 unit in dest location
3478	if (count == 0)
3479	{
3480	px = m_targets.m_destX;
3481	py = m_targets.m_destY;
3482	pz = m_targets.m_destZ;
3483	}
3484	// Summon in random point all other units if location present
3485	else
3486	m_caster->GetRandomPoint(center_x,center_y,center_z,radius,px,py,pz);
3487	}
3488	// Summon if dest location not present near caster
3489	else
3490	m_caster->GetClosePoint(px,py,pz,3.0f);
3491
3492	int32 duration = GetSpellDuration(m_spellInfo);
3493
3494	TempSummonType summonType = (duration == 0) ? TEMPSUMMON_DEAD_DESPAWN : TEMPSUMMON_TIMED_OR_DEAD_DESPAWN;
3495
3496	m_caster->SummonCreature(creature_entry,px,py,pz,m_caster->GetOrientation(),summonType,duration);
3497	}
3498	}
3499
3500	void Spell::EffectSummonGuardian(uint32 i)
3501	{
3502	uint32 pet_entry = m_spellInfo->EffectMiscValue[i];
3503	if(!pet_entry)
3504	return;
3505
3506	// Jewelery statue case (totem like)
3507	if(m_spellInfo->SpellIconID==2056)
3508	{
3509	EffectSummonTotem(i);
3510	return;
3511	}
3512
3513	// set timer for unsummon
3514	int32 duration = GetSpellDuration(m_spellInfo);
3515
3516	// Search old Guardian only for players (if casted spell not have duration or cooldown)
3517	// FIXME: some guardians have control spell applied and controlled by player and anyway player can't summon in this time
3518	// so this code hack in fact
3519	if( m_caster->GetTypeId() == TYPEID_PLAYER && (duration <= 0 \|\| GetSpellRecoveryTime(m_spellInfo)==0) )
3520	if(((Player*)m_caster)->HasGuardianWithEntry(pet_entry))
3521	return; // find old guardian, ignore summon
3522
3523	// in another case summon new
3524	uint32 level = m_caster->getLevel();
3525
3526	// level of pet summoned using engineering item based at engineering skill level
3527	if(m_caster->GetTypeId()==TYPEID_PLAYER && m_CastItem)
3528	{
3529	ItemPrototype const *proto = m_CastItem->GetProto();
3530	if(proto && proto->RequiredSkill == SKILL_ENGINERING)
3531	{
3532	uint16 skill202 = ((Player*)m_caster)->GetSkillValue(SKILL_ENGINERING);
3533	if(skill202)
3534	{
3535	level = skill202/5;
3536	}
3537	}
3538	}
3539
3540	// select center of summon position
3541	float center_x = m_targets.m_destX;
3542	float center_y = m_targets.m_destY;
3543	float center_z = m_targets.m_destZ;
3544
3545	float radius = GetSpellRadius(sSpellRadiusStore.LookupEntry(m_spellInfo->EffectRadiusIndex[i]));
3546
3547	int32 amount = damage > 0 ? damage : 1;
3548
3549	for(int32 count = 0; count < amount; ++count)
3550	{
3551	Pet* spawnCreature = new Pet(GUARDIAN_PET);
3552
3553	Map *map = m_caster->GetMap();
3554	uint32 pet_number = objmgr.GeneratePetNumber();
3555	if(!spawnCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_PET), map,m_spellInfo->EffectMiscValue[i], pet_number))
3556	{
3557	sLog.outError("no such creature entry %u",m_spellInfo->EffectMiscValue[i]);
3558	delete spawnCreature;
3559	return;
3560	}
3561
3562	float px, py, pz;
3563	// If dest location if present
3564	if (m_targets.m_targetMask & TARGET_FLAG_DEST_LOCATION)
3565	{
3566	// Summon 1 unit in dest location
3567	if (count == 0)
3568	{
3569	px = m_targets.m_destX;
3570	py = m_targets.m_destY;
3571	pz = m_targets.m_destZ;
3572	}
3573	// Summon in random point all other units if location present
3574	else
3575	m_caster->GetRandomPoint(center_x,center_y,center_z,radius,px,py,pz);
3576	}
3577	// Summon if dest location not present near caster
3578	else
3579	m_caster->GetClosePoint(px,py,pz,spawnCreature->GetObjectSize());
3580
3581	spawnCreature->Relocate(px,py,pz,m_caster->GetOrientation());
3582
3583	if(!spawnCreature->IsPositionValid())
3584	{
3585	sLog.outError("ERROR: Pet (guidlow %d, entry %d) not created base at creature. Suggested coordinates isn't valid (X: %d Y: ^%d)", spawnCreature->GetGUIDLow(), spawnCreature->GetEntry(), spawnCreature->GetPositionX(), spawnCreature->GetPositionY());
3586	delete spawnCreature;
3587	return;
3588	}
3589
3590	if(duration > 0)
3591	spawnCreature->SetDuration(duration);
3592
3593	spawnCreature->SetUInt64Value(UNIT_FIELD_SUMMONEDBY,m_caster->GetGUID());
3594	spawnCreature->setPowerType(POWER_MANA);
3595	spawnCreature->SetUInt32Value(UNIT_NPC_FLAGS , 0);
3596	spawnCreature->SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE,m_caster->getFaction());
3597	spawnCreature->SetUInt32Value(UNIT_FIELD_FLAGS,0);
3598	spawnCreature->SetUInt32Value(UNIT_FIELD_BYTES_1,0);
3599	spawnCreature->SetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP,0);
3600	spawnCreature->SetUInt64Value(UNIT_FIELD_CREATEDBY, m_caster->GetGUID());
3601	spawnCreature->SetUInt32Value(UNIT_CREATED_BY_SPELL, m_spellInfo->Id);
3602
3603	spawnCreature->InitStatsForLevel(level);
3604	spawnCreature->GetCharmInfo()->SetPetNumber(pet_number, false);
3605
3606	spawnCreature->AIM_Initialize();
3607
3608	if(m_caster->GetTypeId()==TYPEID_PLAYER)
3609	((Player*)m_caster)->AddGuardian(spawnCreature);
3610
3611	map->Add((Creature*)spawnCreature);
3612	}
3613	}
3614
3615	void Spell::EffectTeleUnitsFaceCaster(uint32 i)
3616	{
3617	if(!unitTarget)
3618	return;
3619
3620	if(unitTarget->isInFlight())
3621	return;
3622
3623	uint32 mapid = m_caster->GetMapId();
3624	float dis = GetSpellRadius(sSpellRadiusStore.LookupEntry(m_spellInfo->EffectRadiusIndex[i]));
3625
3626	float fx,fy,fz;
3627	m_caster->GetClosePoint(fx,fy,fz,unitTarget->GetObjectSize(),dis);
3628
3629	if(unitTarget->GetTypeId() == TYPEID_PLAYER)
3630	((Player*)unitTarget)->TeleportTo(mapid, fx, fy, fz, -m_caster->GetOrientation(), TELE_TO_NOT_LEAVE_COMBAT \| TELE_TO_NOT_UNSUMMON_PET \| (unitTarget==m_caster ? TELE_TO_SPELL : 0));
3631	else
3632	MapManager::Instance().GetMap(mapid, m_caster)->CreatureRelocation((Creature*)m_caster, fx, fy, fz, -m_caster->GetOrientation());
3633	}
3634
3635	void Spell::EffectLearnSkill(uint32 i)
3636	{
3637	if(unitTarget->GetTypeId() != TYPEID_PLAYER)
3638	return;
3639
3640	if(damage < 0)
3641	return;
3642
3643	uint32 skillid = m_spellInfo->EffectMiscValue[i];
3644	uint16 skillval = ((Player*)unitTarget)->GetPureSkillValue(skillid);
3645	((Player)unitTarget)->SetSkill(skillid, skillval?skillval:1, damage75);
3646	}
3647
3648	void Spell::EffectAddHonor(uint32 /i/)
3649	{
3650	if(unitTarget->GetTypeId() != TYPEID_PLAYER)
3651	return;
3652
3653	sLog.outDebug("SpellEffect::AddHonor called for spell_id %u , that rewards %d honor points to player: %u", m_spellInfo->Id, this->damage, ((Player*)unitTarget)->GetGUIDLow());
3654
3655	// TODO: find formula for honor reward based on player's level!
3656
3657	// now fixed only for level 70 players:
3658	if (((Player*)unitTarget)->getLevel() == 70)
3659	((Player*)unitTarget)->RewardHonor(NULL, 1, this->damage);
3660	}
3661
3662	void Spell::EffectTradeSkill(uint32 /i/)
3663	{
3664	if(unitTarget->GetTypeId() != TYPEID_PLAYER)
3665	return;
3666	// uint32 skillid = m_spellInfo->EffectMiscValue[i];
3667	// uint16 skillmax = ((Player*)unitTarget)->(skillid);
3668	// ((Player*)unitTarget)->SetSkill(skillid,skillval?skillval:1,skillmax+75);
3669	}
3670
3671	void Spell::EffectEnchantItemPerm(uint32 i)
3672	{
3673	if(m_caster->GetTypeId() != TYPEID_PLAYER)
3674	return;
3675	if (!itemTarget)
3676	return;
3677
3678	Player* p_caster = (Player*)m_caster;
3679
3680	p_caster->UpdateCraftSkill(m_spellInfo->Id);
3681
3682	if (m_spellInfo->EffectMiscValue[i])
3683	{
3684	uint32 enchant_id = m_spellInfo->EffectMiscValue[i];
3685
3686	SpellItemEnchantmentEntry const *pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
3687	if(!pEnchant)
3688	return;
3689
3690	// item can be in trade slot and have owner diff. from caster
3691	Player* item_owner = itemTarget->GetOwner();
3692	if(!item_owner)
3693	return;
3694
3695	if(item_owner!=p_caster && p_caster->GetSession()->GetSecurity() > SEC_PLAYER && sWorld.getConfig(CONFIG_GM_LOG_TRADE) )
3696	sLog.outCommand("GM %s (Account: %u) enchanting(perm): %s (Entry: %d) for player: %s (Account: %u)",
3697	p_caster->GetName(),p_caster->GetSession()->GetAccountId(),
3698	itemTarget->GetProto()->Name1,itemTarget->GetEntry(),
3699	item_owner->GetName(),item_owner->GetSession()->GetAccountId());
3700
3701	// remove old enchanting before applying new if equipped
3702	item_owner->ApplyEnchantment(itemTarget,PERM_ENCHANTMENT_SLOT,false);
3703
3704	itemTarget->SetEnchantment(PERM_ENCHANTMENT_SLOT, enchant_id, 0, 0);
3705
3706	// add new enchanting if equipped
3707	item_owner->ApplyEnchantment(itemTarget,PERM_ENCHANTMENT_SLOT,true);
3708	}
3709	}
3710
3711	void Spell::EffectEnchantItemTmp(uint32 i)
3712	{
3713	if(m_caster->GetTypeId() != TYPEID_PLAYER)
3714	return;
3715
3716	Player* p_caster = (Player*)m_caster;
3717
3718	if(!itemTarget)
3719	return;
3720
3721	uint32 enchant_id = m_spellInfo->EffectMiscValue[i];
3722
3723	// Shaman Rockbiter Weapon
3724	if(i==0 && m_spellInfo->Effect[1]==SPELL_EFFECT_DUMMY)
3725	{
3726	int32 enchnting_damage = m_currentBasePoints[1]+1;
3727
3728	// enchanting id selected by calculated damage-per-sec stored in Effect[1] base value
3729	// with already applied percent bonus from Elemental Weapons talent
3730	// Note: damage calculated (correctly) with rounding int32(float(v)) but
3731	// RW enchantments applied damage int32(float(v)+0.5), this create 0..1 difference sometime
3732	switch(enchnting_damage)
3733	{
3734	// Rank 1
3735	case 2: enchant_id = 29; break; // 0% [ 7% == 2, 14% == 2, 20% == 2]
3736	// Rank 2
3737	case 4: enchant_id = 6; break; // 0% [ 7% == 4, 14% == 4]
3738	case 5: enchant_id = 3025; break; // 20%
3739	// Rank 3
3740	case 6: enchant_id = 1; break; // 0% [ 7% == 6, 14% == 6]
3741	case 7: enchant_id = 3027; break; // 20%
3742	// Rank 4
3743	case 9: enchant_id = 3032; break; // 0% [ 7% == 6]
3744	case 10: enchant_id = 503; break; // 14%
3745	case 11: enchant_id = 3031; break; // 20%
3746	// Rank 5
3747	case 15: enchant_id = 3035; break; // 0%
3748	case 16: enchant_id = 1663; break; // 7%
3749	case 17: enchant_id = 3033; break; // 14%
3750	case 18: enchant_id = 3034; break; // 20%
3751	// Rank 6
3752	case 28: enchant_id = 3038; break; // 0%
3753	case 29: enchant_id = 683; break; // 7%
3754	case 31: enchant_id = 3036; break; // 14%
3755	case 33: enchant_id = 3037; break; // 20%
3756	// Rank 7
3757	case 40: enchant_id = 3041; break; // 0%
3758	case 42: enchant_id = 1664; break; // 7%
3759	case 45: enchant_id = 3039; break; // 14%
3760	case 48: enchant_id = 3040; break; // 20%
3761	// Rank 8
3762	case 49: enchant_id = 3044; break; // 0%
3763	case 52: enchant_id = 2632; break; // 7%
3764	case 55: enchant_id = 3042; break; // 14%
3765	case 58: enchant_id = 3043; break; // 20%
3766	// Rank 9
3767	case 62: enchant_id = 2633; break; // 0%
3768	case 66: enchant_id = 3018; break; // 7%
3769	case 70: enchant_id = 3019; break; // 14%
3770	case 74: enchant_id = 3020; break; // 20%
3771	default:
3772	sLog.outError("Spell::EffectEnchantItemTmp: Damage %u not handled in S'RW",enchnting_damage);
3773	return;
3774	}
3775	}
3776
3777	if (!enchant_id)
3778	{
3779	sLog.outError("Spell %u Effect %u (SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY) have 0 as enchanting id",m_spellInfo->Id,i);
3780	return;
3781	}
3782
3783	SpellItemEnchantmentEntry const *pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
3784	if(!pEnchant)
3785	{
3786	sLog.outError("Spell %u Effect %u (SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY) have not existed enchanting id %u ",m_spellInfo->Id,i,enchant_id);
3787	return;
3788	}
3789
3790	// select enchantment duration
3791	uint32 duration;
3792
3793	// rogue family enchantments exception by duration
3794	if(m_spellInfo->Id==38615)
3795	duration = 1800; // 30 mins
3796	// other rogue family enchantments always 1 hour (some have spell damage=0, but some have wrong data in EffBasePoints)
3797	else if(m_spellInfo->SpellFamilyName==SPELLFAMILY_ROGUE)
3798	duration = 3600; // 1 hour
3799	// shaman family enchantments
3800	else if(m_spellInfo->SpellFamilyName==SPELLFAMILY_SHAMAN)
3801	duration = 1800; // 30 mins
3802	// other cases with this SpellVisual already selected
3803	else if(m_spellInfo->SpellVisual==215)
3804	duration = 1800; // 30 mins
3805	// some fishing pole bonuses
3806	else if(m_spellInfo->SpellVisual==563)
3807	duration = 600; // 10 mins
3808	// shaman rockbiter enchantments
3809	else if(m_spellInfo->SpellVisual==0)
3810	duration = 1800; // 30 mins
3811	else if(m_spellInfo->Id==29702)
3812	duration = 300; // 5 mins
3813	else if(m_spellInfo->Id==37360)
3814	duration = 300; // 5 mins
3815	// default case
3816	else
3817	duration = 3600; // 1 hour
3818
3819	// item can be in trade slot and have owner diff. from caster
3820	Player* item_owner = itemTarget->GetOwner();
3821	if(!item_owner)
3822	return;
3823
3824	if(item_owner!=p_caster && p_caster->GetSession()->GetSecurity() > SEC_PLAYER && sWorld.getConfig(CONFIG_GM_LOG_TRADE) )
3825	sLog.outCommand("GM %s (Account: %u) enchanting(temp): %s (Entry: %d) for player: %s (Account: %u)",
3826	p_caster->GetName(),p_caster->GetSession()->GetAccountId(),
3827	itemTarget->GetProto()->Name1,itemTarget->GetEntry(),
3828	item_owner->GetName(),item_owner->GetSession()->GetAccountId());
3829
3830	// remove old enchanting before applying new if equipped
3831	item_owner->ApplyEnchantment(itemTarget,TEMP_ENCHANTMENT_SLOT,false);
3832
3833	itemTarget->SetEnchantment(TEMP_ENCHANTMENT_SLOT, enchant_id, duration*1000, 0);
3834
3835	// add new enchanting if equipped
3836	item_owner->ApplyEnchantment(itemTarget,TEMP_ENCHANTMENT_SLOT,true);
3837	}
3838
3839	void Spell::EffectTameCreature(uint32 /i/)
3840	{
3841	if(m_caster->GetPetGUID())
3842	return;
3843
3844	if(!unitTarget)
3845	return;
3846
3847	if(unitTarget->GetTypeId() == TYPEID_PLAYER)
3848	return;
3849
3850	Creature* creatureTarget = (Creature*)unitTarget;
3851
3852	if(creatureTarget->isPet())
3853	return;
3854
3855	if(m_caster->getClass() == CLASS_HUNTER)
3856	{
3857	// cast finish successfully
3858	//SendChannelUpdate(0);
3859	finish();
3860
3861	Pet* pet = new Pet(HUNTER_PET);
3862
3863	if(!pet->CreateBaseAtCreature(creatureTarget))
3864	{
3865	delete pet;
3866	return;
3867	}
3868
3869	creatureTarget->setDeathState(JUST_DIED);
3870	creatureTarget->RemoveCorpse();
3871	creatureTarget->SetHealth(0); // just for nice GM-mode view
3872
3873	pet->SetUInt64Value(UNIT_FIELD_SUMMONEDBY, m_caster->GetGUID());
3874	pet->SetUInt64Value(UNIT_FIELD_CREATEDBY, m_caster->GetGUID());
3875	pet->SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE,m_caster->getFaction());
3876	pet->SetUInt32Value(UNIT_CREATED_BY_SPELL, m_spellInfo->Id);
3877
3878	if(!pet->InitStatsForLevel(creatureTarget->getLevel()))
3879	{
3880	sLog.outError("ERROR: InitStatsForLevel() in EffectTameCreature failed! Pet deleted.");
3881	delete pet;
3882	return;
3883	}
3884
3885	// prepare visual effect for levelup
3886	pet->SetUInt32Value(UNIT_FIELD_LEVEL,creatureTarget->getLevel()-1);
3887
3888	pet->GetCharmInfo()->SetPetNumber(objmgr.GeneratePetNumber(), true);
3889	// this enables pet details window (Shift+P)
3890	pet->AIM_Initialize();
3891	pet->InitPetCreateSpells();
3892	pet->SetHealth(pet->GetMaxHealth());
3893
3894	MapManager::Instance().GetMap(pet->GetMapId(), pet)->Add((Creature*)pet);
3895
3896	// visual effect for levelup
3897	pet->SetUInt32Value(UNIT_FIELD_LEVEL,creatureTarget->getLevel());
3898
3899	if(m_caster->GetTypeId() == TYPEID_PLAYER)
3900	{
3901	m_caster->SetPet(pet);
3902	pet->SavePetToDB(PET_SAVE_AS_CURRENT);
3903	((Player*)m_caster)->PetSpellInitialize();
3904	}
3905	}
3906	}
3907
3908	void Spell::EffectSummonPet(uint32 i)
3909	{
3910	uint32 petentry = m_spellInfo->EffectMiscValue[i];
3911
3912	Pet *OldSummon = m_caster->GetPet();
3913
3914	// if pet requested type already exist
3915	if( OldSummon )
3916	{
3917	if(petentry == 0 \|\| OldSummon->GetEntry() == petentry)
3918	{
3919	// pet in corpse state can't be summoned
3920	if( OldSummon->isDead() )
3921	return;
3922
3923	MapManager::Instance().GetMap(OldSummon->GetMapId(), OldSummon)->Remove((Creature*)OldSummon,false);
3924	OldSummon->SetMapId(m_caster->GetMapId());
3925
3926	float px, py, pz;
3927	m_caster->GetClosePoint(px, py, pz, OldSummon->GetObjectSize());
3928
3929	OldSummon->Relocate(px, py, pz, OldSummon->GetOrientation());
3930	MapManager::Instance().GetMap(m_caster->GetMapId(), m_caster)->Add((Creature*)OldSummon);
3931
3932	if(m_caster->GetTypeId() == TYPEID_PLAYER && OldSummon->isControlled() )
3933	{
3934	((Player*)m_caster)->PetSpellInitialize();
3935	}
3936	return;
3937	}
3938
3939	if(m_caster->GetTypeId() == TYPEID_PLAYER)
3940	((Player*)m_caster)->RemovePet(OldSummon,(OldSummon->getPetType()==HUNTER_PET ? PET_SAVE_AS_DELETED : PET_SAVE_NOT_IN_SLOT),false);
3941	else
3942	return;
3943	}
3944
3945	Pet* NewSummon = new Pet;
3946
3947	// petentry==0 for hunter "call pet" (current pet summoned if any)
3948	if(NewSummon->LoadPetFromDB(m_caster,petentry))
3949	{
3950	if(NewSummon->getPetType()==SUMMON_PET)
3951	{
3952	// Remove Demonic Sacrifice auras (known pet)
3953	Unit::AuraList const& auraClassScripts = m_caster->GetAurasByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
3954	for(Unit::AuraList::const_iterator itr = auraClassScripts.begin();itr!=auraClassScripts.end();)
3955	{
3956	if((*itr)->GetModifier()->m_miscvalue==2228)
3957	{
3958	m_caster->RemoveAurasDueToSpell((*itr)->GetId());
3959	itr = auraClassScripts.begin();
3960	}
3961	else
3962	++itr;
3963	}
3964	}
3965
3966	return;
3967	}
3968
3969	// not error in case fail hunter call pet
3970	if(!petentry)
3971	{
3972	delete NewSummon;
3973	return;
3974	}
3975
3976	CreatureInfo const* cInfo = sCreatureStorage.LookupEntry<CreatureInfo>(petentry);
3977
3978	if(!cInfo)
3979	{
3980	sLog.outError("EffectSummonPet: creature entry %u not found.",petentry);
3981	delete NewSummon;
3982	return;
3983	}
3984
3985	Map *map = m_caster->GetMap();
3986	uint32 pet_number = objmgr.GeneratePetNumber();
3987	if(!NewSummon->Create(objmgr.GenerateLowGuid(HIGHGUID_PET), map, petentry, pet_number))
3988	{
3989	delete NewSummon;
3990	return;
3991	}
3992
3993	float px, py, pz;
3994	m_caster->GetClosePoint(px, py, pz, NewSummon->GetObjectSize());
3995
3996	NewSummon->Relocate(px, py, pz, m_caster->GetOrientation());
3997
3998	if(!NewSummon->IsPositionValid())
3999	{
4000	sLog.outError("ERROR: Pet (guidlow %d, entry %d) not summoned. Suggested coordinates isn't valid (X: %d Y: ^%d)", NewSummon->GetGUIDLow(), NewSummon->GetEntry(), NewSummon->GetPositionX(), NewSummon->GetPositionY());
4001	delete NewSummon;
4002	return;
4003	}
4004
4005	uint32 petlevel = m_caster->getLevel();
4006	NewSummon->setPetType(SUMMON_PET);
4007
4008	uint32 faction = m_caster->getFaction();
4009	if(m_caster->GetTypeId() == TYPEID_UNIT && ((Creature*)m_caster)->isTotem())
4010	{
4011	Unit* owner = ((Totem*)m_caster)->GetOwner();
4012	if(owner)
4013	faction = owner->getFaction();
4014	NewSummon->GetCharmInfo()->SetReactState(REACT_AGGRESSIVE);
4015	}
4016
4017	NewSummon->SetUInt64Value(UNIT_FIELD_SUMMONEDBY, m_caster->GetGUID());
4018	NewSummon->SetUInt64Value(UNIT_FIELD_CREATEDBY, m_caster->GetGUID());
4019	NewSummon->SetUInt32Value(UNIT_NPC_FLAGS , 0);
4020	NewSummon->SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE, faction);
4021	NewSummon->SetUInt32Value(UNIT_FIELD_BYTES_0,2048);
4022	NewSummon->SetUInt32Value(UNIT_FIELD_BYTES_1,0);
4023	NewSummon->SetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP,time(NULL));
4024	NewSummon->SetUInt32Value(UNIT_FIELD_PETEXPERIENCE,0);
4025	NewSummon->SetUInt32Value(UNIT_FIELD_PETNEXTLEVELEXP,1000);
4026	NewSummon->SetUInt32Value(UNIT_CREATED_BY_SPELL, m_spellInfo->Id);
4027
4028	NewSummon->GetCharmInfo()->SetPetNumber(pet_number, true);
4029	// this enables pet details window (Shift+P)
4030
4031	// this enables popup window (pet dismiss, cancel), hunter pet additional flags set later
4032	NewSummon->SetUInt32Value(UNIT_FIELD_FLAGS,UNIT_FLAG_PVP_ATTACKABLE);
4033
4034	NewSummon->InitStatsForLevel( petlevel);
4035	NewSummon->InitPetCreateSpells();
4036
4037	if(NewSummon->getPetType()==SUMMON_PET)
4038	{
4039	// Remove Demonic Sacrifice auras (new pet)
4040	Unit::AuraList const& auraClassScripts = m_caster->GetAurasByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
4041	for(Unit::AuraList::const_iterator itr = auraClassScripts.begin();itr!=auraClassScripts.end();)
4042	{
4043	if((*itr)->GetModifier()->m_miscvalue==2228)
4044	{
4045	m_caster->RemoveAurasDueToSpell((*itr)->GetId());
4046	itr = auraClassScripts.begin();
4047	}
4048	else
4049	++itr;
4050	}
4051
4052	// generate new name for summon pet
4053	std::string new_name=objmgr.GeneratePetName(petentry);
4054	if(!new_name.empty())
4055	NewSummon->SetName(new_name);
4056	}
4057	else if(NewSummon->getPetType()==HUNTER_PET)
4058	NewSummon->SetByteValue(UNIT_FIELD_BYTES_2, 2, UNIT_RENAME_NOT_ALLOWED);
4059
4060	NewSummon->AIM_Initialize();
4061	NewSummon->SetHealth(NewSummon->GetMaxHealth());
4062	NewSummon->SetPower(POWER_MANA, NewSummon->GetMaxPower(POWER_MANA));
4063
4064	map->Add((Creature*)NewSummon);
4065
4066	m_caster->SetPet(NewSummon);
4067	sLog.outDebug("New Pet has guid %u", NewSummon->GetGUIDLow());
4068
4069	if(m_caster->GetTypeId() == TYPEID_PLAYER)
4070	{
4071	NewSummon->SavePetToDB(PET_SAVE_AS_CURRENT);
4072	((Player*)m_caster)->PetSpellInitialize();
4073	}
4074	}
4075
4076	void Spell::EffectLearnPetSpell(uint32 i)
4077	{
4078	if(m_caster->GetTypeId() != TYPEID_PLAYER)
4079	return;
4080
4081	Player _player = (Player)m_caster;
4082
4083	Pet *pet = _player->GetPet();
4084	if(!pet)
4085	return;
4086	if(!pet->isAlive())
4087	return;
4088
4089	SpellEntry const *learn_spellproto = sSpellStore.LookupEntry(m_spellInfo->EffectTriggerSpell[i]);
4090	if(!learn_spellproto)
4091	return;
4092
4093	pet->SetTP(pet->m_TrainingPoints - pet->GetTPForSpell(learn_spellproto->Id));
4094	pet->learnSpell(learn_spellproto->Id);
4095
4096	pet->SavePetToDB(PET_SAVE_AS_CURRENT);
4097	_player->PetSpellInitialize();
4098	}
4099
4100	void Spell::EffectTaunt(uint32 /i/)
4101	{
4102	// this effect use before aura Taunt apply for prevent taunt already attacking target
4103	// for spell as marked "non effective at already attacking target"
4104	if(unitTarget && unitTarget->GetTypeId() != TYPEID_PLAYER)
4105	{
4106	if(unitTarget->getVictim()==m_caster)
4107	{
4108	SendCastResult(SPELL_FAILED_DONT_REPORT);
4109	return;
4110	}
4111	}
4112
4113	// Also use this effect to set the taunter's threat to the taunted creature's highest value
4114	if(unitTarget->CanHaveThreatList() && unitTarget->getThreatManager().getCurrentVictim())
4115	unitTarget->getThreatManager().addThreat(m_caster,unitTarget->getThreatManager().getCurrentVictim()->getThreat());
4116	}
4117
4118	void Spell::EffectWeaponDmg(uint32 i)
4119	{
4120	if(!unitTarget)
4121	return;
4122	if(!unitTarget->isAlive())
4123	return;
4124
4125	// multiple weapon dmg effect workaround
4126	// execute only the last weapon damage
4127	// and handle all effects at once
4128	for (int j = 0; j < 3; j++)
4129	{
4130	switch(m_spellInfo->Effect[j])
4131	{
4132	case SPELL_EFFECT_WEAPON_DAMAGE:
4133	case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
4134	case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:
4135	case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:
4136	if (j < i) // we must calculate only at last weapon effect
4137	return;
4138	break;
4139	}
4140	}
4141
4142	// some spell specific modifiers
4143	bool customBonusDamagePercentMod = false;
4144	float bonusDamagePercentMod = 1.0f; // applied to fixed effect damage bonus if set customBonusDamagePercentMod
4145	float weaponDamagePercentMod = 1.0f; // applied to weapon damage (and to fixed effect damage bonus if customBonusDamagePercentMod not set
4146	float totalDamagePercentMod = 1.0f; // applied to final bonus+weapon damage
4147	bool normalized = false;
4148
4149	int32 spell_bonus = 0; // bonus specific for spell
4150	switch(m_spellInfo->SpellFamilyName)
4151	{
4152	case SPELLFAMILY_WARRIOR:
4153	{
4154	// Whirlwind, single only spell with 2 weapon white damage apply if have
4155	if(m_caster->GetTypeId()==TYPEID_PLAYER && (m_spellInfo->SpellFamilyFlags & 0x00000400000000LL))
4156	{
4157	if(((Player*)m_caster)->GetWeaponForAttack(OFF_ATTACK,true))
4158	spell_bonus += m_caster->CalculateDamage (OFF_ATTACK, normalized);
4159	}
4160	// Devastate bonus and sunder armor refresh
4161	else if(m_spellInfo->SpellVisual == 671 && m_spellInfo->SpellIconID == 1508)
4162	{
4163	customBonusDamagePercentMod = true;
4164	bonusDamagePercentMod = 0.0f; // only applied if auras found
4165
4166	Unit::AuraList const& list = unitTarget->GetAurasByType(SPELL_AURA_MOD_RESISTANCE);
4167	for(Unit::AuraList::const_iterator itr=list.begin();itr!=list.end();++itr)
4168	{
4169	SpellEntry const proto = (itr)->GetSpellProto();
4170	if(proto->SpellVisual == 406 && proto->SpellIconID == 565)
4171	{
4172	int32 duration = GetSpellDuration(proto);
4173	(*itr)->SetAuraDuration(duration);
4174	(*itr)->UpdateAuraDuration();
4175	bonusDamagePercentMod += 1.0f; // +100%
4176	}
4177	}
4178	}
4179	break;
4180	}
4181	case SPELLFAMILY_ROGUE:
4182	{
4183	// Ambush
4184	if(m_spellInfo->SpellFamilyFlags & 0x00000200LL)
4185	{
4186	customBonusDamagePercentMod = true;
4187	bonusDamagePercentMod = 2.5f; // 250%
4188	}
4189	// Mutilate (for each hand)
4190	else if(m_spellInfo->SpellFamilyFlags & 0x600000000LL)
4191	{
4192	bool found = false;
4193	// fast check
4194	if(unitTarget->HasAuraState(AURA_STATE_DEADLY_POISON))
4195	found = true;
4196	// full aura scan
4197	else
4198	{
4199	Unit::AuraMap const& auras = unitTarget->GetAuras();
4200	for(Unit::AuraMap::const_iterator itr = auras.begin(); itr!=auras.end(); ++itr)
4201	{
4202	if(itr->second->GetSpellProto()->Dispel == DISPEL_POISON)
4203	{
4204	found = true;
4205	break;
4206	}
4207	}
4208	}
4209
4210	if(found)
4211	totalDamagePercentMod *= 1.5f; // 150% if poisoned
4212	}
4213	break;
4214	}
4215	case SPELLFAMILY_PALADIN:
4216	{
4217	// Seal of Command - receive benefit from Spell Damage and Healing
4218	if(m_spellInfo->SpellFamilyFlags & 0x00000002000000LL)
4219	{
4220	spell_bonus += int32(0.20f*m_caster->SpellBaseDamageBonus(GetSpellSchoolMask(m_spellInfo)));
4221	spell_bonus += int32(0.29f*m_caster->SpellBaseDamageBonusForVictim(GetSpellSchoolMask(m_spellInfo), unitTarget));
4222	}
4223	break;
4224	}
4225	case SPELLFAMILY_SHAMAN:
4226	{
4227	// Skyshatter Harness item set bonus
4228	// Stormstrike
4229	if(m_spellInfo->SpellFamilyFlags & 0x001000000000LL)
4230	{
4231	Unit::AuraList const& m_OverrideClassScript = m_caster->GetAurasByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
4232	for(Unit::AuraList::const_iterator i = m_OverrideClassScript.begin(); i != m_OverrideClassScript.end(); ++i)
4233	{
4234	// Stormstrike AP Buff
4235	if ( (*i)->GetModifier()->m_miscvalue == 5634 )
4236	{
4237	m_caster->CastSpell(m_caster,38430,true,NULL,*i);
4238	break;
4239	}
4240	}
4241	}
4242	}
4243	}
4244
4245	int32 fixed_bonus = 0;
4246	for (int j = 0; j < 3; j++)
4247	{
4248	switch(m_spellInfo->Effect[j])
4249	{
4250	case SPELL_EFFECT_WEAPON_DAMAGE:
4251	case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
4252	fixed_bonus += CalculateDamage(j,unitTarget);
4253	break;
4254	case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:
4255	fixed_bonus += CalculateDamage(j,unitTarget);
4256	normalized = true;
4257	break;
4258	case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:
4259	weaponDamagePercentMod *= float(CalculateDamage(j,unitTarget)) / 100.0f;
4260
4261	// applied only to prev.effects fixed damage
4262	if(customBonusDamagePercentMod)
4263	fixed_bonus = int32(fixed_bonus*bonusDamagePercentMod);
4264	else
4265	fixed_bonus = int32(fixed_bonus*weaponDamagePercentMod);
4266	break;
4267	default:
4268	break; // not weapon damage effect, just skip
4269	}
4270	}
4271
4272	// non-weapon damage
4273	int32 bonus = spell_bonus + fixed_bonus;
4274
4275	// apply to non-weapon bonus weapon total pct effect, weapon total flat effect included in weapon damage
4276	if(bonus)
4277	{
4278	UnitMods unitMod;
4279	switch(m_attackType)
4280	{
4281	default:
4282	case BASE_ATTACK: unitMod = UNIT_MOD_DAMAGE_MAINHAND; break;
4283	case OFF_ATTACK: unitMod = UNIT_MOD_DAMAGE_OFFHAND; break;
4284	case RANGED_ATTACK: unitMod = UNIT_MOD_DAMAGE_RANGED; break;
4285	}
4286
4287	float weapon_total_pct = m_caster->GetModifierValue(unitMod, TOTAL_PCT);
4288	bonus = int32(bonus*weapon_total_pct);
4289	}
4290
4291	// + weapon damage with applied weapon% dmg to base weapon damage in call
4292	bonus += int32(m_caster->CalculateDamage(m_attackType, normalized)*weaponDamagePercentMod);
4293
4294	// total damage
4295	bonus = int32(bonus*totalDamagePercentMod);
4296
4297	// prevent negative damage
4298	uint32 eff_damage = uint32(bonus > 0 ? bonus : 0);
4299
4300	const uint32 nohitMask = HITINFO_ABSORB \| HITINFO_RESIST \| HITINFO_MISS;
4301
4302	uint32 hitInfo = 0;
4303	VictimState victimState = VICTIMSTATE_NORMAL;
4304	uint32 blocked_dmg = 0;
4305	uint32 absorbed_dmg = 0;
4306	uint32 resisted_dmg = 0;
4307	CleanDamage cleanDamage = CleanDamage(0, BASE_ATTACK, MELEE_HIT_NORMAL );
4308
4309	m_caster->DoAttackDamage(unitTarget, &eff_damage, &cleanDamage, &blocked_dmg, m_spellSchoolMask, &hitInfo, &victimState, &absorbed_dmg, &resisted_dmg, m_attackType, m_spellInfo, m_IsTriggeredSpell);
4310
4311	if ((hitInfo & nohitMask) && m_attackType != RANGED_ATTACK) // not send ranged miss/etc
4312	m_caster->SendAttackStateUpdate(hitInfo & nohitMask, unitTarget, 1, m_spellSchoolMask, eff_damage, absorbed_dmg, resisted_dmg, VICTIMSTATE_NORMAL, blocked_dmg);
4313
4314	bool criticalhit = (hitInfo & HITINFO_CRITICALHIT);
4315	m_caster->SendSpellNonMeleeDamageLog(unitTarget, m_spellInfo->Id, eff_damage, m_spellSchoolMask, absorbed_dmg, resisted_dmg, false, blocked_dmg, criticalhit);
4316
4317	if (eff_damage > (absorbed_dmg + resisted_dmg + blocked_dmg))
4318	{
4319	eff_damage -= (absorbed_dmg + resisted_dmg + blocked_dmg);
4320	}
4321	else
4322	{
4323	cleanDamage.damage += eff_damage;
4324	eff_damage = 0;
4325	}
4326
4327	// SPELL_SCHOOL_NORMAL use for weapon-like threat and rage calculation
4328	m_caster->DealDamage(unitTarget, eff_damage, &cleanDamage, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, true);
4329
4330	// Hemorrhage
4331	if(m_spellInfo->SpellFamilyName==SPELLFAMILY_ROGUE && (m_spellInfo->SpellFamilyFlags & 0x2000000))
4332	{
4333	if(m_caster->GetTypeId()==TYPEID_PLAYER)
4334	((Player*)m_caster)->AddComboPoints(unitTarget, 1);
4335	}
4336	// Mangle (Cat): CP
4337	if(m_spellInfo->SpellFamilyName==SPELLFAMILY_DRUID && (m_spellInfo->SpellFamilyFlags==0x0000040000000000LL))
4338	{
4339	if(m_caster->GetTypeId()==TYPEID_PLAYER)
4340	((Player*)m_caster)->AddComboPoints(unitTarget,1);
4341	}
4342
4343
4344	// take ammo
4345	if(m_attackType == RANGED_ATTACK && m_caster->GetTypeId() == TYPEID_PLAYER)
4346	{
4347	Item pItem = ((Player)m_caster)->GetWeaponForAttack( RANGED_ATTACK );
4348
4349	// wands don't have ammo
4350	if(!pItem \|\| pItem->IsBroken() \|\| pItem->GetProto()->SubClass==ITEM_SUBCLASS_WEAPON_WAND)
4351	return;
4352
4353	if( pItem->GetProto()->InventoryType == INVTYPE_THROWN )
4354	{
4355	if(pItem->GetMaxStackCount()==1)
4356	{
4357	// decrease durability for non-stackable throw weapon
4358	((Player*)m_caster)->DurabilityPointLossForEquipSlot(EQUIPMENT_SLOT_RANGED);
4359	}
4360	else
4361	{
4362	// decrease items amount for stackable throw weapon
4363	uint32 count = 1;
4364	((Player*)m_caster)->DestroyItemCount( pItem, count, true);
4365	}
4366	}
4367	else if(uint32 ammo = ((Player*)m_caster)->GetUInt32Value(PLAYER_AMMO_ID))
4368	((Player*)m_caster)->DestroyItemCount(ammo, 1, true);
4369	}
4370	}
4371
4372	void Spell::EffectThreat(uint32 /i/)
4373	{
4374	if(!unitTarget \|\| !unitTarget->isAlive() \|\| !m_caster->isAlive())
4375	return;
4376
4377	if(!unitTarget->CanHaveThreatList())
4378	return;
4379
4380	unitTarget->AddThreat(m_caster, float(damage));
4381	}
4382
4383	void Spell::EffectHealMaxHealth(uint32 /i/)
4384	{
4385	if(!unitTarget)
4386	return;
4387	if(!unitTarget->isAlive())
4388	return;
4389
4390	uint32 heal = m_caster->GetMaxHealth();
4391
4392	int32 gain = unitTarget->ModifyHealth(heal);
4393	unitTarget->getHostilRefManager().threatAssist(m_caster, float(gain) * 0.5f, m_spellInfo);
4394
4395	m_caster->SendHealSpellLog(unitTarget, m_spellInfo->Id, heal);
4396	}
4397
4398	void Spell::EffectInterruptCast(uint32 /i/)
4399	{
4400	if(!unitTarget)
4401	return;
4402	if(!unitTarget->isAlive())
4403	return;
4404
4405	// TODO: not all spells that used this effect apply cooldown at school spells
4406	// also exist case: apply cooldown to interrupted cast only and to all spells
4407	for (uint32 i = CURRENT_FIRST_NON_MELEE_SPELL; i < CURRENT_MAX_SPELL; i++)
4408	{
4409	if (unitTarget->m_currentSpells[i])
4410	{
4411	// check if we can interrupt spell
4412	if ( unitTarget->m_currentSpells[i]->m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_INTERRUPT && unitTarget->m_currentSpells[i]->m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE )
4413	{
4414	unitTarget->ProhibitSpellScholl(GetSpellSchoolMask(unitTarget->m_currentSpells[i]->m_spellInfo), GetSpellDuration(m_spellInfo));
4415	unitTarget->InterruptSpell(i,false);
4416	}
4417	}
4418	}
4419	}
4420
4421	void Spell::EffectSummonObjectWild(uint32 i)
4422	{
4423	uint32 gameobject_id = m_spellInfo->EffectMiscValue[i];
4424
4425	GameObject* pGameObj = new GameObject;
4426
4427	WorldObject* target = focusObject;
4428	if( !target )
4429	target = m_caster;
4430
4431	float x,y,z;
4432	if(m_targets.m_targetMask & TARGET_FLAG_DEST_LOCATION)
4433	{
4434	x = m_targets.m_destX;
4435	y = m_targets.m_destY;
4436	z = m_targets.m_destZ;
4437	}
4438	else
4439	m_caster->GetClosePoint(x,y,z,DEFAULT_WORLD_OBJECT_SIZE);
4440
4441	Map *map = target->GetMap();
4442
4443	if(!pGameObj->Create(objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT), gameobject_id, map,
4444	x, y, z, target->GetOrientation(), 0, 0, 0, 0, 100, 1))
4445	{
4446	delete pGameObj;
4447	return;
4448	}
4449
4450	int32 duration = GetSpellDuration(m_spellInfo);
4451	pGameObj->SetRespawnTime(duration > 0 ? duration/1000 : 0);
4452	pGameObj->SetSpellId(m_spellInfo->Id);
4453
4454	if(pGameObj->GetGoType() != GAMEOBJECT_TYPE_FLAGDROP) // make dropped flag clickable for other players (not set owner guid (created by) for this)...
4455	m_caster->AddGameObject(pGameObj);
4456	map->Add(pGameObj);
4457
4458	if(pGameObj->GetMapId() == 489 && pGameObj->GetGoType() == GAMEOBJECT_TYPE_FLAGDROP) //WS
4459	{
4460	if(m_caster->GetTypeId() == TYPEID_PLAYER)
4461	{
4462	Player pl = (Player)m_caster;
4463	BattleGround* bg = ((Player *)m_caster)->GetBattleGround();
4464	if(bg && bg->GetTypeID()==BATTLEGROUND_WS && bg->GetStatus() == STATUS_IN_PROGRESS)
4465	{
4466	uint32 team = ALLIANCE;
4467
4468	if(pl->GetTeam() == team)
4469	team = HORDE;
4470
4471	((BattleGroundWS*)bg)->SetDroppedFlagGUID(pGameObj->GetGUID(),team);
4472	}
4473	}
4474	}
4475
4476	if(pGameObj->GetMapId() == 566 && pGameObj->GetGoType() == GAMEOBJECT_TYPE_FLAGDROP) //EY
4477	{
4478	if(m_caster->GetTypeId() == TYPEID_PLAYER)
4479	{
4480	BattleGround* bg = ((Player *)m_caster)->GetBattleGround();
4481	if(bg && bg->GetTypeID()==BATTLEGROUND_EY && bg->GetStatus() == STATUS_IN_PROGRESS)
4482	{
4483	((BattleGroundEY*)bg)->SetDroppedFlagGUID(pGameObj->GetGUID());
4484	}
4485	}
4486	}
4487
4488	if(uint32 linkedEntry = pGameObj->GetLinkedGameObjectEntry())
4489	{
4490	GameObject* linkedGO = new GameObject;
4491	if(linkedGO->Create(objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT), linkedEntry, map,
4492	x, y, z, target->GetOrientation(), 0, 0, 0, 0, 100, 1))
4493	{
4494	linkedGO->SetRespawnTime(duration > 0 ? duration/1000 : 0);
4495	linkedGO->SetSpellId(m_spellInfo->Id);
4496
4497	m_caster->AddGameObject(linkedGO);
4498	map->Add(linkedGO);
4499	}
4500	else
4501	{
4502	delete linkedGO;
4503	linkedGO = NULL;
4504	return;
4505	}
4506	}
4507	}
4508
4509	void Spell::EffectScriptEffect(uint32 effIndex)
4510	{
4511	// TODO: we must implement hunter pet summon at login there (spell 6962)
4512
4513	// by spell id
4514	switch(m_spellInfo->Id)
4515	{
4516	// Bending Shinbone
4517	case 8856:
4518	{
4519	if(!itemTarget && m_caster->GetTypeId()!=TYPEID_PLAYER)
4520	return;
4521
4522	uint32 spell_id = 0;
4523	switch(urand(1,5))
4524	{
4525	case 1: spell_id = 8854; break;
4526	default: spell_id = 8855; break;
4527	}
4528
4529	m_caster->CastSpell(m_caster,spell_id,true,NULL);
4530	return;
4531	}
4532
4533	// Healthstone creating spells
4534	case 6201:
4535	case 6202:
4536	case 5699:
4537	case 11729:
4538	case 11730:
4539	case 27230:
4540	{
4541	uint32 itemtype;
4542	uint32 rank = 0;
4543	Unit::AuraList const& mDummyAuras = unitTarget->GetAurasByType(SPELL_AURA_DUMMY);
4544	for(Unit::AuraList::const_iterator i = mDummyAuras.begin();i != mDummyAuras.end(); ++i)
4545	{
4546	if((*i)->GetId() == 18692)
4547	{
4548	rank = 1;
4549	break;
4550	}
4551	else if((*i)->GetId() == 18693)
4552	{
4553	rank = 2;
4554	break;
4555	}
4556	}
4557
4558	static uint32 const itypes[6][3] = {
4559	{ 5512,19004,19005}, // Minor Healthstone
4560	{ 5511,19006,19007}, // Lesser Healthstone
4561	{ 5509,19008,19009}, // Healthstone
4562	{ 5510,19010,19011}, // Greater Healthstone
4563	{ 9421,19012,19013}, // Major Healthstone
4564	{22103,22104,22105} // Master Healthstone
4565	};
4566
4567	switch(m_spellInfo->Id)
4568	{
4569	case 6201: itemtype=itypes[0][rank];break; // Minor Healthstone
4570	case 6202: itemtype=itypes[1][rank];break; // Lesser Healthstone
4571	case 5699: itemtype=itypes[2][rank];break; // Healthstone
4572	case 11729: itemtype=itypes[3][rank];break; // Greater Healthstone
4573	case 11730: itemtype=itypes[4][rank];break; // Major Healthstone
4574	case 27230: itemtype=itypes[5][rank];break; // Master Healthstone
4575	default:
4576	return;
4577	}
4578	DoCreateItem( effIndex, itemtype );
4579	return;
4580	}
4581	// Brittle Armor - need remove one 24575 Brittle Armor aura
4582	case 24590:
4583	unitTarget->RemoveSingleAuraFromStack(24575, 0);
4584	unitTarget->RemoveSingleAuraFromStack(24575, 1);
4585	return;
4586	// Mercurial Shield - need remove one 26464 Mercurial Shield aura
4587	case 26465:
4588	unitTarget->RemoveSingleAuraFromStack(26464, 0);
4589	return;
4590	// Orb teleport spells
4591	case 25140:
4592	case 25143:
4593	case 25650:
4594	case 25652:
4595	case 29128:
4596	case 29129:
4597	case 35376:
4598	case 35727:
4599	{
4600	if(!unitTarget)
4601	return;
4602
4603	uint32 spellid;
4604	switch(m_spellInfo->Id)
4605	{
4606	case 25140: spellid = 32571; break;
4607	case 25143: spellid = 32572; break;
4608	case 25650: spellid = 30140; break;
4609	case 25652: spellid = 30141; break;
4610	case 29128: spellid = 32568; break;
4611	case 29129: spellid = 32569; break;
4612	case 35376: spellid = 25649; break;
4613	case 35727: spellid = 35730; break;
4614	default:
4615	return;
4616	}
4617
4618	unitTarget->CastSpell(unitTarget,spellid,false);
4619	return;
4620	}
4621
4622	// Shadow Flame (All script effects, not just end ones to prevent player from dodging the last triggered spell)
4623	case 22539:
4624	case 22972:
4625	case 22975:
4626	case 22976:
4627	case 22977:
4628	case 22978:
4629	case 22979:
4630	case 22980:
4631	case 22981:
4632	case 22982:
4633	case 22983:
4634	case 22984:
4635	case 22985:
4636	{
4637	if(!unitTarget \|\| !unitTarget->isAlive())
4638	return;
4639
4640	// Onyxia Scale Cloak
4641	if(unitTarget->GetDummyAura(22683))
4642	return;
4643
4644	// Shadow Flame
4645	m_caster->CastSpell(unitTarget, 22682, true);
4646	return;
4647	}
4648	break;
4649
4650	// Summon Black Qiraji Battle Tank
4651	case 26656:
4652	{
4653	if(!unitTarget)
4654	return;
4655
4656	// Prevent stacking of mounts
4657	unitTarget->RemoveSpellsCausingAura(SPELL_AURA_MOUNTED);
4658
4659	// Two separate mounts depending on area id (allows use both in and out of specific instance)
4660	if (unitTarget->GetAreaId() == 3428)
4661	unitTarget->CastSpell(unitTarget, 25863, false);
4662	else
4663	unitTarget->CastSpell(unitTarget, 26655, false);
4664	break;
4665	}
4666	// Piccolo of the Flaming Fire
4667	case 17512:
4668	{
4669	if(!unitTarget \|\| unitTarget->GetTypeId() != TYPEID_PLAYER)
4670	return;
4671	unitTarget->HandleEmoteCommand(EMOTE_STATE_DANCE);
4672	break;
4673	}
4674
4675	// Netherbloom
4676	case 28702:
4677	{
4678	if(!unitTarget)
4679	return;
4680	// 25% chance of casting a random buff
4681	if(roll_chance_i(75))
4682	return;
4683
4684	// triggered spells are 28703 to 28707
4685	// Note: some sources say, that there was the possibility of
4686	// receiving a debuff. However, this seems to be removed by a patch.
4687	const uint32 spellid = 28703;
4688
4689	// don't overwrite an existing aura
4690	for(uint8 i=0; i<5; i++)
4691	if(unitTarget->HasAura(spellid+i, 0))
4692	return;
4693	unitTarget->CastSpell(unitTarget, spellid+urand(0, 4), true);
4694	break;
4695	}
4696
4697	// Nightmare Vine
4698	case 28720:
4699	{
4700	if(!unitTarget)
4701	return;
4702	// 25% chance of casting Nightmare Pollen
4703	if(roll_chance_i(75))
4704	return;
4705	unitTarget->CastSpell(unitTarget, 28721, true);
4706	break;
4707	}
4708
4709	// Mirren's Drinking Hat
4710	case 29830:
4711	{
4712	uint32 item = 0;
4713	switch ( urand(1,6) )
4714	{
4715	case 1: case 2: case 3: item = 23584; break;// Loch Modan Lager
4716	case 4: case 5: item = 23585; break;// Stouthammer Lite
4717	case 6: item = 23586; break;// Aerie Peak Pale Ale
4718	}
4719	if (item)
4720	DoCreateItem(effIndex,item);
4721	break;
4722	}
4723	// Improved Sprint
4724	case 30918:
4725	{
4726	// Removes snares and roots.
4727	uint32 mechanic_mask = (1<<MECHANIC_ROOT) \| (1<<MECHANIC_SNARE);
4728	Unit::AuraMap& Auras = unitTarget->GetAuras();
4729	for(Unit::AuraMap::iterator iter = Auras.begin(), next; iter != Auras.end(); iter = next)
4730	{
4731	next = iter;
4732	++next;
4733	Aura *aur = iter->second;
4734	if (!aur->IsPositive()) //only remove negative spells
4735	{
4736	// check for mechanic mask
4737	if(GetSpellMechanicMask(aur->GetSpellProto(), aur->GetEffIndex()) & mechanic_mask)
4738	{
4739	unitTarget->RemoveAurasDueToSpell(aur->GetId());
4740	if(Auras.empty())
4741	break;
4742	else
4743	next = Auras.begin();
4744	}
4745	}
4746	}
4747	break;
4748	}
4749
4750	// Goblin Weather Machine
4751	case 46203:
4752	{
4753	if(!unitTarget)
4754	return;
4755
4756	uint32 spellId;
4757	switch(rand()%4)
4758	{
4759	case 0:
4760	spellId=46740;
4761	break;
4762	case 1:
4763	spellId=46739;
4764	break;
4765	case 2:
4766	spellId=46738;
4767	break;
4768	case 3:
4769	spellId=46736;
4770	break;
4771	}
4772	unitTarget->CastSpell(unitTarget, spellId, true);
4773	break;
4774	}
4775
4776	}
4777
4778	if(!unitTarget \|\| !unitTarget->isAlive()) // can we remove this check?
4779	{
4780	sLog.outError("Spell %u in EffectScriptEffect does not have unitTarget", m_spellInfo->Id);
4781	return;
4782	}
4783
4784	switch(m_spellInfo->Id)
4785	{
4786	// Dreaming Glory
4787	case 28698: unitTarget->CastSpell(unitTarget, 28694, true); break;
4788	// Needle Spine
4789	case 39835: unitTarget->CastSpell(unitTarget, 39968, true); break;
4790	// Draw Soul
4791	case 40904: unitTarget->CastSpell(m_caster, 40903, true); break;
4792	// Flame Crash
4793	case 41126: unitTarget->CastSpell(unitTarget, 41131, true); break;
4794	// Force Cast - Portal Effect: Sunwell Isle
4795	case 44876: unitTarget->CastSpell(unitTarget, 44870, true); break;
4796	//5,000 Gold
4797	case 46642:
4798	{
4799	if(unitTarget->GetTypeId() == TYPEID_PLAYER)
4800	((Player*)unitTarget)->ModifyMoney(50000000);
4801	break;
4802	}
4803	}
4804
4805	if( m_spellInfo->SpellFamilyName == SPELLFAMILY_PALADIN )
4806	{
4807	switch(m_spellInfo->SpellFamilyFlags)
4808	{
4809	// Judgement
4810	case 0x800000:
4811	{
4812	uint32 spellId2 = 0;
4813
4814	// all seals have aura dummy
4815	Unit::AuraList const& m_dummyAuras = m_caster->GetAurasByType(SPELL_AURA_DUMMY);
4816	for(Unit::AuraList::const_iterator itr = m_dummyAuras.begin(); itr != m_dummyAuras.end(); ++itr)
4817	{
4818	SpellEntry const spellInfo = (itr)->GetSpellProto();
4819
4820	// search seal (all seals have judgement's aura dummy spell id in 2 effect
4821	if ( !spellInfo \|\| !IsSealSpell((itr)->GetSpellProto()) \|\| (itr)->GetEffIndex() != 2 )
4822	continue;
4823
4824	// must be calculated base at raw base points in spell proto, GetModifier()->m_value for S.Righteousness modified by SPELLMOD_DAMAGE
4825	spellId2 = (*itr)->GetSpellProto()->EffectBasePoints[2]+1;
4826
4827	if(spellId2 <= 1)
4828	continue;
4829
4830	// found, remove seal
4831	m_caster->RemoveAurasDueToSpell((*itr)->GetId());
4832
4833	// Sanctified Judgement
4834	Unit::AuraList const& m_auras = m_caster->GetAurasByType(SPELL_AURA_DUMMY);
4835	for(Unit::AuraList::const_iterator i = m_auras.begin(); i != m_auras.end(); ++i)
4836	{
4837	if ((i)->GetSpellProto()->SpellIconID == 205 && (i)->GetSpellProto()->Attributes == 0x01D0LL)
4838	{
4839	int32 chance = (*i)->GetModifier()->m_amount;
4840	if ( roll_chance_i(chance) )
4841	{
4842	int32 mana = spellInfo->manaCost;
4843	if ( Player* modOwner = m_caster->GetSpellModOwner() )
4844	modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_COST, mana);
4845	mana = int32(mana* 0.8f);
4846	m_caster->CastCustomSpell(m_caster,31930,&mana,NULL,NULL,true,NULL,*i);
4847	}
4848	break;
4849	}
4850	}
4851
4852	break;
4853	}
4854
4855	m_caster->CastSpell(unitTarget,spellId2,true);
4856	return;
4857	}
4858	}
4859	}
4860
4861	// normal DB scripted effect
4862	sLog.outDebug("Spell ScriptStart spellid %u in EffectScriptEffect ", m_spellInfo->Id);
4863	sWorld.ScriptsStart(sSpellScripts, m_spellInfo->Id, m_caster, unitTarget);
4864	}
4865
4866	void Spell::EffectSanctuary(uint32 /i/)
4867	{
4868	if(!unitTarget)
4869	return;
4870	//unitTarget->CombatStop();
4871
4872	unitTarget->CombatStop();
4873	unitTarget->getHostilRefManager().deleteReferences(); // stop all fighting
4874	// Vanish allows to remove all threat and cast regular stealth so other spells can be used
4875	if(m_spellInfo->SpellFamilyName == SPELLFAMILY_ROGUE && (m_spellInfo->SpellFamilyFlags & SPELLFAMILYFLAG_ROGUE_VANISH))
4876	{
4877	((Player *)m_caster)->RemoveSpellsCausingAura(SPELL_AURA_MOD_ROOT);
4878	}
4879	}
4880
4881	void Spell::EffectAddComboPoints(uint32 /i/)
4882	{
4883	if(!unitTarget)
4884	return;
4885
4886	if(m_caster->GetTypeId() != TYPEID_PLAYER)
4887	return;
4888
4889	if(damage <= 0)
4890	return;
4891
4892	((Player*)m_caster)->AddComboPoints(unitTarget, damage);
4893	}
4894
4895	void Spell::EffectDuel(uint32 i)
4896	{
4897	if(!m_caster \|\| !unitTarget \|\| m_caster->GetTypeId() != TYPEID_PLAYER \|\| unitTarget->GetTypeId() != TYPEID_PLAYER)
4898	return;
4899
4900	Player caster = (Player)m_caster;
4901	Player target = (Player)unitTarget;
4902
4903	// caster or target already have requested duel
4904	if( caster->duel \|\| target->duel \|\| target->GetSocial()->HasIgnore(caster->GetGUIDLow()) )
4905	return;
4906
4907	// Players can only fight a duel with each other outside (=not inside dungeons and not in capital cities)
4908	// Don't have to check the target's map since you cannot challenge someone across maps
4909	if( caster->GetMapId() != 0 && caster->GetMapId() != 1 && caster->GetMapId() != 530)
4910	{
4911	SendCastResult(SPELL_FAILED_NO_DUELING); // Dueling isn't allowed here
4912	return;
4913	}
4914
4915	AreaTableEntry const* casterAreaEntry = GetAreaEntryByAreaID(caster->GetZoneId());
4916	if(casterAreaEntry && (casterAreaEntry->flags & AREA_FLAG_CAPITAL) )
4917	{
4918	SendCastResult(SPELL_FAILED_NO_DUELING); // Dueling isn't allowed here
4919	return;
4920	}
4921
4922	AreaTableEntry const* targetAreaEntry = GetAreaEntryByAreaID(target->GetZoneId());
4923	if(targetAreaEntry && (targetAreaEntry->flags & AREA_FLAG_CAPITAL) )
4924	{
4925	SendCastResult(SPELL_FAILED_NO_DUELING); // Dueling isn't allowed here
4926	return;
4927	}
4928
4929	//CREATE DUEL FLAG OBJECT
4930	GameObject* pGameObj = new GameObject;
4931
4932	uint32 gameobject_id = m_spellInfo->EffectMiscValue[i];
4933
4934	Map *map = m_caster->GetMap();
4935	if(!pGameObj->Create(objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT), gameobject_id, map,
4936	m_caster->GetPositionX()+(unitTarget->GetPositionX()-m_caster->GetPositionX())/2 ,
4937	m_caster->GetPositionY()+(unitTarget->GetPositionY()-m_caster->GetPositionY())/2 ,
4938	m_caster->GetPositionZ(),
4939	m_caster->GetOrientation(), 0, 0, 0, 0, 0, 1))
4940	{
4941	delete pGameObj;
4942	return;
4943	}
4944
4945	pGameObj->SetUInt32Value(GAMEOBJECT_FACTION, m_caster->getFaction() );
4946	pGameObj->SetUInt32Value(GAMEOBJECT_LEVEL, m_caster->getLevel()+1 );
4947	int32 duration = GetSpellDuration(m_spellInfo);
4948	pGameObj->SetRespawnTime(duration > 0 ? duration/1000 : 0);
4949	pGameObj->SetSpellId(m_spellInfo->Id);
4950
4951	m_caster->AddGameObject(pGameObj);
4952	map->Add(pGameObj);
4953	//END
4954
4955	// Send request
4956	WorldPacket data(SMSG_DUEL_REQUESTED, 16);
4957	data << pGameObj->GetGUID();
4958	data << caster->GetGUID();
4959	caster->GetSession()->SendPacket(&data);
4960	target->GetSession()->SendPacket(&data);
4961
4962	// create duel-info
4963	DuelInfo *duel = new DuelInfo;
4964	duel->initiator = caster;
4965	duel->opponent = target;
4966	duel->startTime = 0;
4967	duel->startTimer = 0;
4968	caster->duel = duel;
4969
4970	DuelInfo *duel2 = new DuelInfo;
4971	duel2->initiator = caster;
4972	duel2->opponent = caster;
4973	duel2->startTime = 0;
4974	duel2->startTimer = 0;
4975	target->duel = duel2;
4976
4977	caster->SetUInt64Value(PLAYER_DUEL_ARBITER,pGameObj->GetGUID());
4978	target->SetUInt64Value(PLAYER_DUEL_ARBITER,pGameObj->GetGUID());
4979	}
4980
4981	void Spell::EffectStuck(uint32 /i/)
4982	{
4983	if(!unitTarget \|\| unitTarget->GetTypeId() != TYPEID_PLAYER)
4984	return;
4985
4986	if(!sWorld.getConfig(CONFIG_CAST_UNSTUCK))
4987	return;
4988
4989	Player* pTarget = (Player*)unitTarget;
4990
4991	sLog.outDebug("Spell Effect: Stuck");
4992	sLog.outDetail("Player %s (guid %u) used auto-unstuck future at map %u (%f, %f, %f)", pTarget->GetName(), pTarget->GetGUIDLow(), m_caster->GetMapId(), m_caster->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ());
4993
4994	if(pTarget->isInFlight())
4995	return;
4996
4997	// homebind location is loaded always
4998	pTarget->TeleportTo(pTarget->m_homebindMapId,pTarget->m_homebindX,pTarget->m_homebindY,pTarget->m_homebindZ,pTarget->GetOrientation(), (unitTarget==m_caster ? TELE_TO_SPELL : 0));
4999
5000	// Stuck spell trigger Hearthstone cooldown
5001	SpellEntry const *spellInfo = sSpellStore.LookupEntry(8690);
5002	if(!spellInfo)
5003	return;
5004	Spell spell(pTarget,spellInfo,true,0);
5005	spell.SendSpellCooldown();
5006	}
5007
5008	void Spell::EffectSummonPlayer(uint32 /i/)
5009	{
5010	if(!unitTarget \|\| unitTarget->GetTypeId() != TYPEID_PLAYER)
5011	return;
5012
5013	// Evil Twin (ignore player summon, but hide this for summoner)
5014	if(unitTarget->GetDummyAura(23445))
5015	return;
5016
5017	float x,y,z;
5018	m_caster->GetClosePoint(x,y,z,unitTarget->GetObjectSize());
5019
5020	((Player*)unitTarget)->SetSummonPoint(m_caster->GetMapId(),x,y,z);
5021
5022	WorldPacket data(SMSG_SUMMON_REQUEST, 8+4+4);
5023	data << uint64(m_caster->GetGUID()); // summoner guid
5024	data << uint32(m_caster->GetZoneId()); // summoner zone
5025	data << uint32(MAX_PLAYER_SUMMON_DELAY*1000); // auto decline after msecs
5026	((Player*)unitTarget)->GetSession()->SendPacket(&data);
5027	}
5028
5029	static ScriptInfo generateActivateCommand()
5030	{
5031	ScriptInfo si;
5032	si.command = SCRIPT_COMMAND_ACTIVATE_OBJECT;
5033	return si;
5034	}
5035
5036	void Spell::EffectActivateObject(uint32 effect_idx)
5037	{
5038	if(!gameObjTarget)
5039	return;
5040
5041	static ScriptInfo activateCommand = generateActivateCommand();
5042
5043	int32 delay_secs = m_spellInfo->EffectMiscValue[effect_idx];
5044
5045	sWorld.ScriptCommandStart(activateCommand, delay_secs, m_caster, gameObjTarget);
5046	}
5047
5048	void Spell::EffectSummonTotem(uint32 i)
5049	{
5050	uint8 slot = 0;
5051	switch(m_spellInfo->EffectMiscValueB[i])
5052	{
5053	case SUMMON_TYPE_TOTEM_SLOT1: slot = 0; break;
5054	case SUMMON_TYPE_TOTEM_SLOT2: slot = 1; break;
5055	case SUMMON_TYPE_TOTEM_SLOT3: slot = 2; break;
5056	case SUMMON_TYPE_TOTEM_SLOT4: slot = 3; break;
5057	// Battle standard case
5058	case SUMMON_TYPE_TOTEM: slot = 254; break;
5059	// jewelery statue case, like totem without slot
5060	case SUMMON_TYPE_GUARDIAN: slot = 255; break;
5061	default: return;
5062	}
5063
5064	if(slot < MAX_TOTEM)
5065	{
5066	uint64 guid = m_caster->m_TotemSlot[slot];
5067	if(guid != 0)
5068	{
5069	Creature OldTotem = ObjectAccessor::GetCreature(m_caster, guid);
5070	if(OldTotem && OldTotem->isTotem())
5071	((Totem*)OldTotem)->UnSummon();
5072	}
5073	}
5074
5075	uint32 team = 0;
5076	if (m_caster->GetTypeId()==TYPEID_PLAYER)
5077	team = ((Player*)m_caster)->GetTeam();
5078
5079	Totem* pTotem = new Totem;
5080
5081	if(!pTotem->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), m_caster->GetMap(), m_spellInfo->EffectMiscValue[i], team ))
5082	{
5083	delete pTotem;
5084	return;
5085	}
5086
5087	float angle = slot < MAX_TOTEM ? M_PI/MAX_TOTEM - (slot2M_PI/MAX_TOTEM) : 0;
5088
5089	float x,y,z;
5090	m_caster->GetClosePoint(x,y,z,pTotem->GetObjectSize(),2.0f,angle);
5091
5092	// totem must be at same Z in case swimming caster and etc.
5093	if( fabs( z - m_caster->GetPositionZ() ) > 5 )
5094	z = m_caster->GetPositionZ();
5095
5096	pTotem->Relocate(x, y, z, m_caster->GetOrientation());
5097
5098	if(slot < MAX_TOTEM)
5099	m_caster->m_TotemSlot[slot] = pTotem->GetGUID();
5100
5101	pTotem->SetOwner(m_caster->GetGUID());
5102	pTotem->SetTypeBySummonSpell(m_spellInfo); // must be after Create call where m_spells initilized
5103
5104	int32 duration=GetSpellDuration(m_spellInfo);
5105	if(Player* modOwner = m_caster->GetSpellModOwner())
5106	modOwner->ApplySpellMod(m_spellInfo->Id,SPELLMOD_DURATION, duration);
5107	pTotem->SetDuration(duration);
5108
5109	if (damage) // if not spell info, DB values used
5110	{
5111	pTotem->SetMaxHealth(damage);
5112	pTotem->SetHealth(damage);
5113	}
5114
5115	pTotem->SetUInt32Value(UNIT_CREATED_BY_SPELL,m_spellInfo->Id);
5116	pTotem->SetFlag(UNIT_FIELD_FLAGS,UNIT_FLAG_PVP_ATTACKABLE);
5117
5118	pTotem->ApplySpellImmune(m_spellInfo->Id,IMMUNITY_STATE,SPELL_AURA_MOD_FEAR,true);
5119	pTotem->ApplySpellImmune(m_spellInfo->Id,IMMUNITY_STATE,SPELL_AURA_TRANSFORM,true);
5120
5121	pTotem->Summon(m_caster);
5122
5123	if(slot < MAX_TOTEM && m_caster->GetTypeId() == TYPEID_PLAYER)
5124	{
5125	WorldPacket data(SMSG_TOTEM_CREATED, 1+8+4+4);
5126	data << uint8(slot);
5127	data << uint64(pTotem->GetGUID());
5128	data << uint32(duration);
5129	data << uint32(m_spellInfo->Id);
5130	((Player*)m_caster)->SendDirectMessage(&data);
5131	}
5132	}
5133
5134	void Spell::EffectEnchantHeldItem(uint32 i)
5135	{
5136	// this is only item spell effect applied to main-hand weapon of target player (players in area)
5137	if(!unitTarget \|\| unitTarget->GetTypeId() != TYPEID_PLAYER)
5138	return;
5139
5140	Player* item_owner = (Player*)unitTarget;
5141	Item* item = item_owner->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);
5142
5143	if(!item )
5144	return;
5145
5146	// must be equipped
5147	if(!item ->IsEquipped())
5148	return;
5149
5150	if (m_spellInfo->EffectMiscValue[i])
5151	{
5152	uint32 enchant_id = m_spellInfo->EffectMiscValue[i];
5153	int32 duration = GetSpellDuration(m_spellInfo); //Try duration index first ..
5154	if(!duration)
5155	duration = m_currentBasePoints[i]+1; //Base points after ..
5156	if(!duration)
5157	duration = 10; //10 seconds for enchants which don't have listed duration
5158
5159	SpellItemEnchantmentEntry const *pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
5160	if(!pEnchant)
5161	return;
5162
5163	// Always go to temp enchantment slot
5164	EnchantmentSlot slot = TEMP_ENCHANTMENT_SLOT;
5165
5166	// Enchantment will not be applied if a different one already exists
5167	if(item->GetEnchantmentId(slot) && item->GetEnchantmentId(slot) != enchant_id)
5168	return;
5169
5170	// Apply the temporary enchantment
5171	item->SetEnchantment(slot, enchant_id, duration*1000, 0);
5172	item_owner->ApplyEnchantment(item,slot,true);
5173	}
5174	}
5175
5176	void Spell::EffectDisEnchant(uint32 /i/)
5177	{
5178	if(m_caster->GetTypeId() != TYPEID_PLAYER)
5179	return;
5180
5181	Player* p_caster = (Player*)m_caster;
5182	if(!itemTarget \|\| !itemTarget->GetProto()->DisenchantID)
5183	return;
5184
5185	p_caster->UpdateCraftSkill(m_spellInfo->Id);
5186
5187	((Player*)m_caster)->SendLoot(itemTarget->GetGUID(),LOOT_DISENCHANTING);
5188
5189	// item will be removed at disenchanting end
5190	}
5191
5192	void Spell::EffectInebriate(uint32 /i/)
5193	{
5194	if(!unitTarget \|\| unitTarget->GetTypeId() != TYPEID_PLAYER)
5195	return;
5196
5197	Player player = (Player)unitTarget;
5198	uint16 currentDrunk = player->GetDrunkValue();
5199	uint16 drunkMod = damage * 256;
5200	if (currentDrunk + drunkMod > 0xFFFF)
5201	currentDrunk = 0xFFFF;
5202	else
5203	currentDrunk += drunkMod;
5204	player->SetDrunkValue(currentDrunk, m_CastItem?m_CastItem->GetEntry():0);
5205	}
5206
5207	void Spell::EffectFeedPet(uint32 i)
5208	{
5209	if(m_caster->GetTypeId() != TYPEID_PLAYER)
5210	return;
5211
5212	Player _player = (Player)m_caster;
5213
5214	if(!itemTarget)
5215	return;
5216
5217	Pet *pet = _player->GetPet();
5218	if(!pet)
5219	return;
5220
5221	if(!pet->isAlive())
5222	return;
5223
5224	int32 benefit = pet->GetCurrentFoodBenefitLevel(itemTarget->GetProto()->ItemLevel);
5225	if(benefit <= 0)
5226	return;
5227
5228	uint32 count = 1;
5229	_player->DestroyItemCount(itemTarget,count,true);
5230	// TODO: fix crash when a spell has two effects, both pointed at the same item target
5231
5232	m_caster->CastCustomSpell(m_caster,m_spellInfo->EffectTriggerSpell[i],&benefit,NULL,NULL,true);
5233	}
5234
5235	void Spell::EffectDismissPet(uint32 /i/)
5236	{
5237	if(m_caster->GetTypeId() != TYPEID_PLAYER)
5238	return;
5239
5240	Pet* pet = m_caster->GetPet();
5241
5242	// not let dismiss dead pet
5243	if(!pet\|\|!pet->isAlive())
5244	return;
5245
5246	((Player*)m_caster)->RemovePet(pet,PET_SAVE_NOT_IN_SLOT);
5247	}
5248
5249	void Spell::EffectSummonObject(uint32 i)
5250	{
5251	uint32 go_id = m_spellInfo->EffectMiscValue[i];
5252
5253	uint8 slot = 0;
5254	switch(m_spellInfo->Effect[i])
5255	{
5256	case SPELL_EFFECT_SUMMON_OBJECT_SLOT1: slot = 0; break;
5257	case SPELL_EFFECT_SUMMON_OBJECT_SLOT2: slot = 1; break;
5258	case SPELL_EFFECT_SUMMON_OBJECT_SLOT3: slot = 2; break;
5259	case SPELL_EFFECT_SUMMON_OBJECT_SLOT4: slot = 3; break;
5260	default: return;
5261	}
5262
5263	uint64 guid = m_caster->m_ObjectSlot[slot];
5264	if(guid != 0)
5265	{
5266	GameObject* obj = NULL;
5267	if( m_caster )
5268	obj = ObjectAccessor::GetGameObject(*m_caster, guid);
5269
5270	if(obj) obj->Delete();
5271	m_caster->m_ObjectSlot[slot] = 0;
5272	}
5273
5274	GameObject* pGameObj = new GameObject;
5275
5276	float rot2 = sin(m_caster->GetOrientation()/2);
5277	float rot3 = cos(m_caster->GetOrientation()/2);
5278
5279	float x,y,z;
5280	// If dest location if present
5281	if (m_targets.m_targetMask & TARGET_FLAG_DEST_LOCATION)
5282	{
5283	x = m_targets.m_destX;
5284	y = m_targets.m_destY;
5285	z = m_targets.m_destZ;
5286	}
5287	// Summon in random point all other units if location present
5288	else
5289	m_caster->GetClosePoint(x,y,z,DEFAULT_WORLD_OBJECT_SIZE);
5290
5291	Map *map = m_caster->GetMap();
5292	if(!pGameObj->Create(objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT), go_id, map, x, y, z, m_caster->GetOrientation(), 0, 0, rot2, rot3, 0, 1))
5293	{
5294	delete pGameObj;
5295	return;
5296	}
5297
5298	pGameObj->SetUInt32Value(GAMEOBJECT_LEVEL,m_caster->getLevel());
5299	int32 duration = GetSpellDuration(m_spellInfo);
5300	pGameObj->SetRespawnTime(duration > 0 ? duration/1000 : 0);
5301	pGameObj->SetSpellId(m_spellInfo->Id);
5302	m_caster->AddGameObject(pGameObj);
5303
5304	map->Add(pGameObj);
5305	WorldPacket data(SMSG_GAMEOBJECT_SPAWN_ANIM_OBSOLETE, 8);
5306	data << pGameObj->GetGUID();
5307	m_caster->SendMessageToSet(&data,true);
5308
5309	m_caster->m_ObjectSlot[slot] = pGameObj->GetGUID();
5310	}
5311
5312	void Spell::EffectResurrect(uint32 i)
5313	{
5314	if(!unitTarget)
5315	return;
5316	if(unitTarget->GetTypeId() != TYPEID_PLAYER)
5317	return;
5318
5319	if(unitTarget->isAlive())
5320	return;
5321	if(!unitTarget->IsInWorld())
5322	return;
5323
5324	switch (m_spellInfo->Id)
5325	{
5326	// Defibrillate (Goblin Jumper Cables) have 33% chance on success
5327	case 8342:
5328	if (roll_chance_i(67))
5329	{
5330	m_caster->CastSpell(m_caster, 8338, true, m_CastItem);
5331	return;
5332	}
5333	break;
5334	// Defibrillate (Goblin Jumper Cables XL) have 50% chance on success
5335	case 22999:
5336	if (roll_chance_i(50))
5337	{
5338	m_caster->CastSpell(m_caster, 23055, true, m_CastItem);
5339	return;
5340	}
5341	break;
5342	default:
5343	break;
5344	}
5345
5346	Player* pTarget = ((Player*)unitTarget);
5347
5348	if(pTarget->isRessurectRequested()) // already have one active request
5349	return;
5350
5351	uint32 health = pTarget->GetMaxHealth() * damage / 100;
5352	uint32 mana = pTarget->GetMaxPower(POWER_MANA) * damage / 100;
5353
5354	pTarget->setResurrectRequestData(m_caster->GetGUID(), m_caster->GetMapId(), m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ(), health, mana);
5355	SendResurrectRequest(pTarget);
5356	}
5357
5358	void Spell::EffectAddExtraAttacks(uint32 /i/)
5359	{
5360	if(!unitTarget \|\| !unitTarget->isAlive())
5361	return;
5362
5363	if( unitTarget->m_extraAttacks )
5364	return;
5365
5366	unitTarget->m_extraAttacks = damage;
5367	}
5368
5369	void Spell::EffectParry(uint32 /i/)
5370	{
5371	if (unitTarget->GetTypeId() == TYPEID_PLAYER)
5372	{
5373	((Player*)unitTarget)->SetCanParry(true);
5374	}
5375	}
5376
5377	void Spell::EffectBlock(uint32 /i/)
5378	{
5379	if (unitTarget->GetTypeId() != TYPEID_PLAYER)
5380	return;
5381
5382	((Player*)unitTarget)->SetCanBlock(true);
5383	}
5384
5385	void Spell::EffectMomentMove(uint32 i)
5386	{
5387	if(unitTarget->isInFlight())
5388	return;
5389
5390	if( m_spellInfo->rangeIndex== 1) //self range
5391	{
5392	uint32 mapid = m_caster->GetMapId();
5393	float dis = GetSpellRadius(sSpellRadiusStore.LookupEntry(m_spellInfo->EffectRadiusIndex[i]));
5394
5395	// before caster
5396	float fx,fy,fz;
5397	unitTarget->GetClosePoint(fx,fy,fz,unitTarget->GetObjectSize(),dis);
5398	float ox,oy,oz;
5399	unitTarget->GetPosition(ox,oy,oz);
5400
5401	float fx2,fy2,fz2; // getObjectHitPos overwrite last args in any result case
5402	if(VMAP::VMapFactory::createOrGetVMapManager()->getObjectHitPos(mapid, ox,oy,oz+0.5, fx,fy,oz+0.5,fx2,fy2,fz2, -0.5))
5403	{
5404	fx = fx2;
5405	fy = fy2;
5406	fz = fz2;
5407	unitTarget->UpdateGroundPositionZ(fx,fy,fz);
5408	}
5409
5410	if(unitTarget->GetTypeId() == TYPEID_PLAYER)
5411	((Player*)unitTarget)->TeleportTo(mapid, fx, fy, fz, unitTarget->GetOrientation(), TELE_TO_NOT_LEAVE_COMBAT \| TELE_TO_NOT_UNSUMMON_PET \| (unitTarget==m_caster ? TELE_TO_SPELL : 0));
5412	else
5413	MapManager::Instance().GetMap(mapid, unitTarget)->CreatureRelocation((Creature*)unitTarget, fx, fy, fz, unitTarget->GetOrientation());
5414	}
5415	}
5416
5417	void Spell::EffectReputation(uint32 i)
5418	{
5419	if(!unitTarget \|\| unitTarget->GetTypeId() != TYPEID_PLAYER)
5420	return;
5421
5422	Player _player = (Player)unitTarget;
5423
5424	int32 rep_change = m_currentBasePoints[i]+1; // field store reputation change -1
5425
5426	uint32 faction_id = m_spellInfo->EffectMiscValue[i];
5427
5428	FactionEntry const* factionEntry = sFactionStore.LookupEntry(faction_id);
5429
5430	if(!factionEntry)
5431	return;
5432
5433	_player->ModifyFactionReputation(factionEntry,rep_change);
5434	}
5435
5436	void Spell::EffectQuestComplete(uint32 i)
5437	{
5438	if(m_caster->GetTypeId() != TYPEID_PLAYER)
5439	return;
5440
5441	Player _player = (Player)m_caster;
5442
5443	uint32 quest_id = m_spellInfo->EffectMiscValue[i];
5444	_player->AreaExploredOrEventHappens(quest_id);
5445	}
5446
5447	void Spell::EffectSelfResurrect(uint32 i)
5448	{
5449	if(!unitTarget \|\| unitTarget->isAlive())
5450	return;
5451	if(unitTarget->GetTypeId() != TYPEID_PLAYER)
5452	return;
5453	if(!unitTarget->IsInWorld())
5454	return;
5455
5456	uint32 health = 0;
5457	uint32 mana = 0;
5458
5459	// flat case
5460	if(damage < 0)
5461	{
5462	health = uint32(-damage);
5463	mana = m_spellInfo->EffectMiscValue[i];
5464	}
5465	// percent case
5466	else
5467	{
5468	health = uint32(damage/100.0f*unitTarget->GetMaxHealth());
5469	if(unitTarget->GetMaxPower(POWER_MANA) > 0)
5470	mana = uint32(damage/100.0f*unitTarget->GetMaxPower(POWER_MANA));
5471	}
5472
5473	Player plr = ((Player)unitTarget);
5474	plr->ResurrectPlayer(0.0f);
5475
5476	plr->SetHealth( health );
5477	plr->SetPower(POWER_MANA, mana );
5478	plr->SetPower(POWER_RAGE, 0 );
5479	plr->SetPower(POWER_ENERGY, plr->GetMaxPower(POWER_ENERGY) );
5480
5481	plr->SpawnCorpseBones();
5482
5483	plr->SaveToDB();
5484	}
5485
5486	void Spell::EffectSkinning(uint32 /i/)
5487	{
5488	if(unitTarget->GetTypeId() != TYPEID_UNIT )
5489	return;
5490	if(!m_caster \|\| m_caster->GetTypeId() != TYPEID_PLAYER)
5491	return;
5492
5493	Creature* creature = (Creature*) unitTarget;
5494	int32 targetLevel = creature->getLevel();
5495
5496	uint32 skill;
5497	if(creature->GetCreatureInfo()->flag1 & 256)
5498	skill = SKILL_HERBALISM; // special case
5499	else if(creature->GetCreatureInfo()->flag1 & 512)
5500	skill = SKILL_MINING; // special case
5501	else
5502	skill = SKILL_SKINNING; // normal case
5503
5504	((Player*)m_caster)->SendLoot(creature->GetGUID(),LOOT_SKINNING);
5505	creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE);
5506
5507	int32 reqValue = targetLevel < 10 ? 0 : targetLevel < 20 ? (targetLevel-10)10 : targetLevel5;
5508
5509	int32 skillValue = ((Player*)m_caster)->GetPureSkillValue(skill);
5510
5511	// Double chances for elites
5512	((Player*)m_caster)->UpdateGatherSkill(skill, skillValue, reqValue, creature->isElite() ? 2 : 1 );
5513	}
5514
5515	void Spell::EffectCharge(uint32 /i/)
5516	{
5517	if(!unitTarget \|\| !m_caster)
5518	return;
5519
5520	float x, y, z;
5521	unitTarget->GetContactPoint(m_caster, x, y, z);
5522	if(unitTarget->GetTypeId() != TYPEID_PLAYER)
5523	((Creature *)unitTarget)->StopMoving();
5524
5525	// Only send MOVEMENTFLAG_WALK_MODE, client has strange issues with other move flags
5526	m_caster->SendMonsterMove(x, y, z, 0, MOVEMENTFLAG_WALK_MODE, 1);
5527
5528	if(m_caster->GetTypeId() != TYPEID_PLAYER)
5529	MapManager::Instance().GetMap(m_caster->GetMapId(), m_caster)->CreatureRelocation((Creature*)m_caster,x,y,z,m_caster->GetOrientation());
5530
5531	// not all charge effects used in negative spells
5532	if ( !IsPositiveSpell(m_spellInfo->Id))
5533	m_caster->Attack(unitTarget,true);
5534	}
5535
5536	void Spell::EffectSummonCritter(uint32 i)
5537	{
5538	if(m_caster->GetTypeId() != TYPEID_PLAYER)
5539	return;
5540	Player* player = (Player*)m_caster;
5541
5542	uint32 pet_entry = m_spellInfo->EffectMiscValue[i];
5543	if(!pet_entry)
5544	return;
5545
5546	Pet* old_critter = player->GetMiniPet();
5547
5548	// for same pet just despawn
5549	if(old_critter && old_critter->GetEntry() == pet_entry)
5550	{
5551	player->RemoveMiniPet();
5552	return;
5553	}
5554
5555	// despawn old pet before summon new
5556	if(old_critter)
5557	player->RemoveMiniPet();
5558
5559	// summon new pet
5560	Pet* critter = new Pet(MINI_PET);
5561
5562	Map *map = m_caster->GetMap();
5563	uint32 pet_number = objmgr.GeneratePetNumber();
5564	if(!critter->Create(objmgr.GenerateLowGuid(HIGHGUID_PET),
5565	map, pet_entry, pet_number))
5566	{
5567	sLog.outError("Spell::EffectSummonCritter, spellid %u: no such creature entry %u", m_spellInfo->Id, pet_entry);
5568	delete critter;
5569	return;
5570	}
5571
5572	float x,y,z;
5573	// If dest location if present
5574	if (m_targets.m_targetMask & TARGET_FLAG_DEST_LOCATION)
5575	{
5576	x = m_targets.m_destX;
5577	y = m_targets.m_destY;
5578	z = m_targets.m_destZ;
5579	}
5580	// Summon if dest location not present near caster
5581	else
5582	m_caster->GetClosePoint(x,y,z,critter->GetObjectSize());
5583
5584	critter->Relocate(x,y,z,m_caster->GetOrientation());
5585
5586	if(!critter->IsPositionValid())
5587	{
5588	sLog.outError("ERROR: Pet (guidlow %d, entry %d) not summoned. Suggested coordinates isn't valid (X: %d Y: ^%d)", critter->GetGUIDLow(), critter->GetEntry(), critter->GetPositionX(), critter->GetPositionY());
5589	delete critter;
5590	return;
5591	}
5592
5593	critter->SetUInt64Value(UNIT_FIELD_SUMMONEDBY,m_caster->GetGUID());
5594	critter->SetUInt64Value(UNIT_FIELD_CREATEDBY,m_caster->GetGUID());
5595	critter->SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE,m_caster->getFaction());
5596	critter->SetUInt32Value(UNIT_CREATED_BY_SPELL, m_spellInfo->Id);
5597
5598	critter->AIM_Initialize();
5599	critter->InitPetCreateSpells(); // e.g. disgusting oozeling has a create spell as critter...
5600	critter->SetMaxHealth(1);
5601	critter->SetHealth(1);
5602	critter->SetLevel(1);
5603
5604	// set timer for unsummon
5605	int32 duration = GetSpellDuration(m_spellInfo);
5606	if(duration > 0)
5607	critter->SetDuration(duration);
5608
5609	std::string name = player->GetName();
5610	name.append(petTypeSuffix[critter->getPetType()]);
5611	critter->SetName( name );
5612	player->SetMiniPet(critter);
5613
5614	map->Add((Creature*)critter);
5615	}
5616
5617	void Spell::EffectKnockBack(uint32 i)
5618	{
5619	if(!unitTarget \|\| !m_caster)
5620	return;
5621
5622	// Effect only works on players
5623	if(unitTarget->GetTypeId()!=TYPEID_PLAYER)
5624	return;
5625
5626	float vsin = sin(m_caster->GetAngle(unitTarget));
5627	float vcos = cos(m_caster->GetAngle(unitTarget));
5628
5629	WorldPacket data(SMSG_MOVE_KNOCK_BACK, (8+4+4+4+4+4));
5630	data.append(unitTarget->GetPackGUID());
5631	data << uint32(0); // Sequence
5632	data << float(vcos); // x direction
5633	data << float(vsin); // y direction
5634	data << float(m_spellInfo->EffectMiscValue[i])/10; // Horizontal speed
5635	data << float(damage/-10); // Z Movement speed (vertical)
5636
5637	((Player*)unitTarget)->GetSession()->SendPacket(&data);
5638	}
5639
5640	void Spell::EffectSendTaxi(uint32 i)
5641	{
5642	if(!unitTarget \|\| unitTarget->GetTypeId() != TYPEID_PLAYER)
5643	return;
5644
5645	TaxiPathEntry const* entry = sTaxiPathStore.LookupEntry(m_spellInfo->EffectMiscValue[i]);
5646	if(!entry)
5647	return;
5648
5649	std::vector<uint32> nodes;
5650
5651	nodes.resize(2);
5652	nodes[0] = entry->from;
5653	nodes[1] = entry->to;
5654
5655	uint32 mountid = 0;
5656	switch(m_spellInfo->Id)
5657	{
5658	case 31606: //Stormcrow Amulet
5659	mountid = 17447;
5660	break;
5661	case 45071: //Quest - Sunwell Daily - Dead Scar Bombing Run
5662	case 45113: //Quest - Sunwell Daily - Ship Bombing Run
5663	case 45353: //Quest - Sunwell Daily - Ship Bombing Run Return
5664	mountid = 22840;
5665	break;
5666	case 34905: //Stealth Flight
5667	mountid = 6851;
5668	break;
5669	}
5670
5671	((Player*)unitTarget)->ActivateTaxiPathTo(nodes,mountid);
5672
5673	}
5674
5675	void Spell::EffectPlayerPull(uint32 i)
5676	{
5677	if(!unitTarget \|\| !m_caster)
5678	return;
5679
5680	// Effect only works on players
5681	if(unitTarget->GetTypeId()!=TYPEID_PLAYER)
5682	return;
5683
5684	float vsin = sin(unitTarget->GetAngle(m_caster));
5685	float vcos = cos(unitTarget->GetAngle(m_caster));
5686
5687	WorldPacket data(SMSG_MOVE_KNOCK_BACK, (8+4+4+4+4+4));
5688	data.append(unitTarget->GetPackGUID());
5689	data << uint32(0); // Sequence
5690	data << float(vcos); // x direction
5691	data << float(vsin); // y direction
5692	// Horizontal speed
5693	data << float(damage ? damage : unitTarget->GetDistance2d(m_caster));
5694	data << float(m_spellInfo->EffectMiscValue[i])/-10; // Z Movement speed
5695
5696	((Player*)unitTarget)->GetSession()->SendPacket(&data);
5697	}
5698
5699	void Spell::EffectDispelMechanic(uint32 i)
5700	{
5701	if(!unitTarget)
5702	return;
5703
5704	uint32 mechanic = m_spellInfo->EffectMiscValue[i];
5705
5706	Unit::AuraMap& Auras = unitTarget->GetAuras();
5707	for(Unit::AuraMap::iterator iter = Auras.begin(), next; iter != Auras.end(); iter = next)
5708	{
5709	next = iter;
5710	++next;
5711	SpellEntry const *spell = sSpellStore.LookupEntry(iter->second->GetSpellProto()->Id);
5712	if(spell->Mechanic == mechanic \|\| spell->EffectMechanic[iter->second->GetEffIndex()] == mechanic)
5713	{
5714	unitTarget->RemoveAurasDueToSpell(spell->Id);
5715	if(Auras.empty())
5716	break;
5717	else
5718	next = Auras.begin();
5719	}
5720	}
5721	return;
5722	}
5723
5724	void Spell::EffectSummonDeadPet(uint32 /i/)
5725	{
5726	if(m_caster->GetTypeId() != TYPEID_PLAYER)
5727	return;
5728	Player _player = (Player)m_caster;
5729	Pet *pet = _player->GetPet();
5730	if(!pet)
5731	return;
5732	if(pet->isAlive())
5733	return;
5734	if(damage < 0)
5735	return;
5736	pet->SetUInt32Value(UNIT_DYNAMIC_FLAGS, 0);
5737	pet->RemoveFlag (UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE);
5738	pet->setDeathState( ALIVE );
5739	pet->clearUnitState(UNIT_STAT_ALL_STATE);
5740	pet->SetHealth( uint32(pet->GetMaxHealth()*(float(damage)/100)));
5741
5742	pet->AIM_Initialize();
5743
5744	_player->PetSpellInitialize();
5745	pet->SavePetToDB(PET_SAVE_AS_CURRENT);
5746	}
5747
5748	void Spell::EffectDestroyAllTotems(uint32 /i/)
5749	{
5750	float mana = 0;
5751	for(int slot = 0; slot < MAX_TOTEM; ++slot)
5752	{
5753	if(!m_caster->m_TotemSlot[slot])
5754	continue;
5755
5756	Creature* totem = ObjectAccessor::GetCreature(*m_caster,m_caster->m_TotemSlot[slot]);
5757	if(totem && totem->isTotem())
5758	{
5759	uint32 spell_id = totem->GetUInt32Value(UNIT_CREATED_BY_SPELL);
5760	SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell_id);
5761	if(spellInfo)
5762	mana += spellInfo->manaCost * damage / 100;
5763	((Totem*)totem)->UnSummon();
5764	}
5765	}
5766
5767	int32 gain = m_caster->ModifyPower(POWER_MANA,int32(mana));
5768	m_caster->SendEnergizeSpellLog(m_caster, m_spellInfo->Id, gain, POWER_MANA);
5769	}
5770
5771	void Spell::EffectDurabilityDamage(uint32 i)
5772	{
5773	if(!unitTarget \|\| unitTarget->GetTypeId() != TYPEID_PLAYER)
5774	return;
5775
5776	int32 slot = m_spellInfo->EffectMiscValue[i];
5777
5778	// FIXME: some spells effects have value -1/-2
5779	// Possibly its mean -1 all player equipped items and -2 all items
5780	if(slot < 0)
5781	{
5782	((Player*)unitTarget)->DurabilityPointsLossAll(damage,(slot < -1));
5783	return;
5784	}
5785
5786	// invalid slot value
5787	if(slot >= INVENTORY_SLOT_BAG_END)
5788	return;
5789
5790	if(Item* item = ((Player*)unitTarget)->GetItemByPos(INVENTORY_SLOT_BAG_0,slot))
5791	((Player*)unitTarget)->DurabilityPointsLoss(item,damage);
5792	}
5793
5794	void Spell::EffectDurabilityDamagePCT(uint32 i)
5795	{
5796	if(!unitTarget \|\| unitTarget->GetTypeId() != TYPEID_PLAYER)
5797	return;
5798
5799	int32 slot = m_spellInfo->EffectMiscValue[i];
5800
5801	// FIXME: some spells effects have value -1/-2
5802	// Possibly its mean -1 all player equipped items and -2 all items
5803	if(slot < 0)
5804	{
5805	((Player*)unitTarget)->DurabilityLossAll(double(damage)/100.0f,(slot < -1));
5806	return;
5807	}
5808
5809	// invalid slot value
5810	if(slot >= INVENTORY_SLOT_BAG_END)
5811	return;
5812
5813	if(damage <= 0)
5814	return;
5815
5816	if(Item* item = ((Player*)unitTarget)->GetItemByPos(INVENTORY_SLOT_BAG_0,slot))
5817	((Player*)unitTarget)->DurabilityLoss(item,double(damage)/100.0f);
5818	}
5819
5820	void Spell::EffectModifyThreatPercent(uint32 /effIndex/)
5821	{
5822	if(!unitTarget)
5823	return;
5824
5825	unitTarget->getThreatManager().modifyThreatPercent(m_caster, damage);
5826	}
5827
5828	void Spell::EffectTransmitted(uint32 effIndex)
5829	{
5830	uint32 name_id = m_spellInfo->EffectMiscValue[effIndex];
5831
5832	GameObjectInfo const* goinfo = objmgr.GetGameObjectInfo(name_id);
5833
5834	if (!goinfo)
5835	{
5836	sLog.outErrorDb("Gameobject (Entry: %u) not exist and not created at spell (ID: %u) cast",name_id, m_spellInfo->Id);
5837	return;
5838	}
5839
5840	float fx,fy,fz;
5841
5842	if(m_targets.m_targetMask & TARGET_FLAG_DEST_LOCATION)
5843	{
5844	fx = m_targets.m_destX;
5845	fy = m_targets.m_destY;
5846	fz = m_targets.m_destZ;
5847	}
5848	//FIXME: this can be better check for most objects but still hack
5849	else if(m_spellInfo->EffectRadiusIndex[effIndex] && m_spellInfo->speed==0)
5850	{
5851	float dis = GetSpellRadius(sSpellRadiusStore.LookupEntry(m_spellInfo->EffectRadiusIndex[effIndex]));
5852	m_caster->GetClosePoint(fx,fy,fz,DEFAULT_WORLD_OBJECT_SIZE, dis);
5853	}
5854	else
5855	{
5856	float min_dis = GetSpellMinRange(sSpellRangeStore.LookupEntry(m_spellInfo->rangeIndex));
5857	float max_dis = GetSpellMaxRange(sSpellRangeStore.LookupEntry(m_spellInfo->rangeIndex));
5858	float dis = rand_norm() * (max_dis - min_dis) + min_dis;
5859
5860	m_caster->GetClosePoint(fx,fy,fz,DEFAULT_WORLD_OBJECT_SIZE, dis);
5861	}
5862
5863	Map *cMap = m_caster->GetMap();
5864
5865	if(goinfo->type==GAMEOBJECT_TYPE_FISHINGNODE)
5866	{
5867	if ( !cMap->IsInWater(fx,fy,fz-0.5f)) // Hack to prevent fishing bobber from failing to land on fishing hole
5868	{ // but this is not proper, we really need to ignore not materialized objects
5869	SendCastResult(SPELL_FAILED_NOT_HERE);
5870	SendChannelUpdate(0);
5871	return;
5872	}
5873
5874	// replace by water level in this case
5875	fz = cMap->GetWaterLevel(fx,fy);
5876	}
5877	// if gameobject is summoning object, it should be spawned right on caster's position
5878	else if(goinfo->type==GAMEOBJECT_TYPE_SUMMONING_RITUAL)
5879	{
5880	m_caster->GetPosition(fx,fy,fz);
5881	}
5882
5883	GameObject* pGameObj = new GameObject;
5884
5885	if(!pGameObj->Create(objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT), name_id, cMap,
5886	fx, fy, fz, m_caster->GetOrientation(), 0, 0, 0, 0, 100, 1))
5887	{
5888	delete pGameObj;
5889	return;
5890	}
5891
5892	int32 duration = GetSpellDuration(m_spellInfo);
5893
5894	switch(goinfo->type)
5895	{
5896	case GAMEOBJECT_TYPE_FISHINGNODE:
5897	{
5898	m_caster->SetUInt64Value(UNIT_FIELD_CHANNEL_OBJECT,pGameObj->GetGUID());
5899	// Orientation3
5900	pGameObj->SetFloatValue(GAMEOBJECT_ROTATION + 2, 0.88431775569915771 );
5901	// Orientation4
5902	pGameObj->SetFloatValue(GAMEOBJECT_ROTATION + 3, -0.4668855369091033 );
5903	m_caster->AddGameObject(pGameObj); // will removed at spell cancel
5904
5905	// end time of range when possible catch fish (FISHING_BOBBER_READY_TIME..GetDuration(m_spellInfo))
5906	// start time == fish-FISHING_BOBBER_READY_TIME (0..GetDuration(m_spellInfo)-FISHING_BOBBER_READY_TIME)
5907	int32 lastSec;
5908	switch(urand(0, 3))
5909	{
5910	case 0: lastSec = 3; break;
5911	case 1: lastSec = 7; break;
5912	case 2: lastSec = 13; break;
5913	case 3: lastSec = 17; break;
5914	}
5915
5916	duration = duration - lastSec1000 + FISHING_BOBBER_READY_TIME1000;
5917	break;
5918	}
5919	case GAMEOBJECT_TYPE_SUMMONING_RITUAL:
5920	{
5921	if(m_caster->GetTypeId()==TYPEID_PLAYER)
5922	{
5923	pGameObj->AddUniqueUse((Player*)m_caster);
5924	m_caster->AddGameObject(pGameObj); // will removed at spell cancel
5925	}
5926	break;
5927	}
5928	case GAMEOBJECT_TYPE_FISHINGHOLE:
5929	case GAMEOBJECT_TYPE_CHEST:
5930	default:
5931	{
5932	break;
5933	}
5934	}
5935
5936	pGameObj->SetRespawnTime(duration > 0 ? duration/1000 : 0);
5937
5938	pGameObj->SetOwnerGUID(m_caster->GetGUID() );
5939
5940	pGameObj->SetUInt32Value(GAMEOBJECT_LEVEL, m_caster->getLevel() );
5941	pGameObj->SetSpellId(m_spellInfo->Id);
5942
5943	DEBUG_LOG("AddObject at SpellEfects.cpp EffectTransmitted\n");
5944	//m_caster->AddGameObject(pGameObj);
5945	//m_ObjToDel.push_back(pGameObj);
5946
5947	cMap->Add(pGameObj);
5948
5949	WorldPacket data(SMSG_GAMEOBJECT_SPAWN_ANIM_OBSOLETE, 8);
5950	data << uint64(pGameObj->GetGUID());
5951	m_caster->SendMessageToSet(&data,true);
5952
5953	if(uint32 linkedEntry = pGameObj->GetLinkedGameObjectEntry())
5954	{
5955	GameObject* linkedGO = new GameObject;
5956	if(linkedGO->Create(objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT), linkedEntry, cMap,
5957	fx, fy, fz, m_caster->GetOrientation(), 0, 0, 0, 0, 100, 1))
5958	{
5959	linkedGO->SetRespawnTime(duration > 0 ? duration/1000 : 0);
5960	linkedGO->SetUInt32Value(GAMEOBJECT_LEVEL, m_caster->getLevel() );
5961	linkedGO->SetSpellId(m_spellInfo->Id);
5962	linkedGO->SetOwnerGUID(m_caster->GetGUID() );
5963
5964	MapManager::Instance().GetMap(linkedGO->GetMapId(), linkedGO)->Add(linkedGO);
5965	}
5966	else
5967	{
5968	delete linkedGO;
5969	linkedGO = NULL;
5970	return;
5971	}
5972	}
5973	}
5974
5975	void Spell::EffectProspecting(uint32 /i/)
5976	{
5977	if(m_caster->GetTypeId() != TYPEID_PLAYER)
5978	return;
5979
5980	Player* p_caster = (Player*)m_caster;
5981	if(!itemTarget \|\| !(itemTarget->GetProto()->BagFamily & BAG_FAMILY_MASK_MINING_SUPP))
5982	return;
5983
5984	if(itemTarget->GetCount() < 5)
5985	return;
5986
5987	if( sWorld.getConfig(CONFIG_SKILL_PROSPECTING))
5988	{
5989	uint32 SkillValue = p_caster->GetPureSkillValue(SKILL_JEWELCRAFTING);
5990	uint32 reqSkillValue = itemTarget->GetProto()->RequiredSkillRank;
5991	p_caster->UpdateGatherSkill(SKILL_JEWELCRAFTING, SkillValue, reqSkillValue);
5992	}
5993
5994	((Player*)m_caster)->SendLoot(itemTarget->GetGUID(), LOOT_PROSPECTING);
5995	}
5996
5997	void Spell::EffectSkill(uint32 /i/)
5998	{
5999	sLog.outDebug("WORLD: SkillEFFECT");
6000	}
6001
6002	void Spell::EffectSummonDemon(uint32 i)
6003	{
6004	float px = m_targets.m_destX;
6005	float py = m_targets.m_destY;
6006	float pz = m_targets.m_destZ;
6007
6008	Creature* Charmed = m_caster->SummonCreature(m_spellInfo->EffectMiscValue[i], px, py, pz, m_caster->GetOrientation(),TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,3600000);
6009	if (!Charmed)
6010	return;
6011
6012	// might not always work correctly, maybe the creature that dies from CoD casts the effect on itself and is therefore the caster?
6013	Charmed->SetLevel(m_caster->getLevel());
6014
6015	// TODO: Add damage/mana/hp according to level
6016
6017	if (m_spellInfo->EffectMiscValue[i] == 89) // Inferno summon
6018	{
6019	// Enslave demon effect, without mana cost and cooldown
6020	m_caster->CastSpell(Charmed, 20882, true); // FIXME: enslave does not scale with level, level 62+ minions cannot be enslaved
6021
6022	// Inferno effect
6023	Charmed->CastSpell(Charmed, 22703, true, 0);
6024	}
6025	}
6026
6027	/* There is currently no need for this effect. We handle it in BattleGround.cpp
6028	If we would handle the resurrection here, the spiritguide would instantly disappear as the
6029	player revives, and so we wouldn't see the spirit heal visual effect on the npc.
6030	This is why we use a half sec delay between the visual effect and the resurrection itself */
6031	void Spell::EffectSpiritHeal(uint32 /i/)
6032	{
6033	/*
6034	if(!unitTarget \|\| unitTarget->isAlive())
6035	return;
6036	if(unitTarget->GetTypeId() != TYPEID_PLAYER)
6037	return;
6038	if(!unitTarget->IsInWorld())
6039	return;
6040
6041	//m_spellInfo->EffectBasePoints[i]; == 99 (percent?)
6042	//((Player*)unitTarget)->setResurrect(m_caster->GetGUID(), unitTarget->GetPositionX(), unitTarget->GetPositionY(), unitTarget->GetPositionZ(), unitTarget->GetMaxHealth(), unitTarget->GetMaxPower(POWER_MANA));
6043	((Player*)unitTarget)->ResurrectPlayer(1.0f);
6044	((Player*)unitTarget)->SpawnCorpseBones();
6045	*/
6046	}
6047
6048	// remove insignia spell effect
6049	void Spell::EffectSkinPlayerCorpse(uint32 /i/)
6050	{
6051	sLog.outDebug("Effect: SkinPlayerCorpse");
6052	if ( (m_caster->GetTypeId() != TYPEID_PLAYER) \|\| (unitTarget->GetTypeId() != TYPEID_PLAYER) \|\| (unitTarget->isAlive()) )
6053	return;
6054
6055	((Player)unitTarget)->RemovedInsignia( (Player)m_caster );
6056	}
6057
6058	void Spell::EffectStealBeneficialBuff(uint32 i)
6059	{
6060	sLog.outDebug("Effect: StealBeneficialBuff");
6061
6062	if(!unitTarget \|\| unitTarget==m_caster) // can't steal from self
6063	return;
6064
6065	std::vector <Aura *> steal_list;
6066	// Create dispel mask by dispel type
6067	uint32 dispelMask = GetDispellMask( DispelType(m_spellInfo->EffectMiscValue[i]) );
6068	Unit::AuraMap const& auras = unitTarget->GetAuras();
6069	for(Unit::AuraMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
6070	{
6071	Aura aur = (itr).second;
6072	if (aur && (1<<aur->GetSpellProto()->Dispel) & dispelMask)
6073	{
6074	// Need check for passive? this
6075	if (aur->IsPositive() && !aur->IsPassive())
6076	steal_list.push_back(aur);
6077	}
6078	}
6079	// Ok if exist some buffs for dispel try dispel it
6080	if (!steal_list.empty())
6081	{
6082	std::list < std::pair<uint32,uint64> > success_list;
6083	int32 list_size = steal_list.size();
6084	// Dispell N = damage buffs (or while exist buffs for dispel)
6085	for (int32 count=0; count < damage && list_size > 0; ++count)
6086	{
6087	// Random select buff for dispel
6088	Aura *aur = steal_list[urand(0, list_size-1)];
6089	// Not use chance for steal
6090	// TODO possible need do it
6091	success_list.push_back( std::pair<uint32,uint64>(aur->GetId(),aur->GetCasterGUID()));
6092
6093	// Remove buff from list for prevent doubles
6094	for (std::vector<Aura *>::iterator j = steal_list.begin(); j != steal_list.end(); )
6095	{
6096	Aura stealed = j;
6097	if (stealed->GetId() == aur->GetId() && stealed->GetCasterGUID() == aur->GetCasterGUID())
6098	{
6099	j = steal_list.erase(j);
6100	--list_size;
6101	}
6102	else
6103	++j;
6104	}
6105	}
6106	// Really try steal and send log
6107	if (!success_list.empty())
6108	{
6109	int32 count = success_list.size();
6110	WorldPacket data(SMSG_SPELLSTEALLOG, 8+8+4+1+4+count*5);
6111	data.append(unitTarget->GetPackGUID()); // Victim GUID
6112	data.append(m_caster->GetPackGUID()); // Caster GUID
6113	data << uint32(m_spellInfo->Id); // Dispell spell id
6114	data << uint8(0); // not used
6115	data << uint32(count); // count
6116	for (std::list<std::pair<uint32,uint64> >::iterator j = success_list.begin(); j != success_list.end(); ++j)
6117	{
6118	SpellEntry const* spellInfo = sSpellStore.LookupEntry(j->first);
6119	data << uint32(spellInfo->Id); // Spell Id
6120	data << uint8(0); // 0 - steals !=0 transfers
6121	unitTarget->RemoveAurasDueToSpellBySteal(spellInfo->Id, j->second, m_caster);
6122	}
6123	m_caster->SendMessageToSet(&data, true);
6124	}
6125	}
6126	}
6127
6128	void Spell::EffectKillCredit(uint32 i)
6129	{
6130	if(!unitTarget \|\| unitTarget->GetTypeId() != TYPEID_PLAYER)
6131	return;
6132
6133	((Player*)unitTarget)->KilledMonster(m_spellInfo->EffectMiscValue[i], 0);
6134	}
6135
6136	void Spell::EffectQuestFail(uint32 i)
6137	{
6138	if(!unitTarget \|\| unitTarget->GetTypeId() != TYPEID_PLAYER)
6139	return;
6140
6141	((Player*)unitTarget)->FailQuest(m_spellInfo->EffectMiscValue[i]);
6142	}

Note: See TracBrowser for help on using the browser.

Context Navigation

root/trunk/src/game/SpellEffects.cpp @ 79

Download in other formats: