Context Navigation

SpellMgr.cpp @ 40

Revision 2, 83.1 kB (checked in by yumileroy, 17 years ago)

[svn] * Proper SVN structure

Original author: Neo2003
Date: 2008-10-02 16:23:55-05:00

Line
1	/*
2	* Copyright (C) 2005-2008 MaNGOS <http://www.mangosproject.org/>
3	*
4	* This program is free software; you can redistribute it and/or modify
5	* it under the terms of the GNU General Public License as published by
6	* the Free Software Foundation; either version 2 of the License, or
7	* (at your option) any later version.
8	*
9	* This program is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	* GNU General Public License for more details.
13	*
14	* You should have received a copy of the GNU General Public License
15	* along with this program; if not, write to the Free Software
16	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17	*/
18
19	#include "SpellMgr.h"
20	#include "ObjectMgr.h"
21	#include "SpellAuraDefines.h"
22	#include "ProgressBar.h"
23	#include "Database/DBCStores.h"
24	#include "World.h"
25	#include "Chat.h"
26	#include "Spell.h"
27
28	SpellMgr::SpellMgr()
29	{
30	}
31
32	SpellMgr::~SpellMgr()
33	{
34	}
35
36	SpellMgr& SpellMgr::Instance()
37	{
38	static SpellMgr spellMgr;
39	return spellMgr;
40	}
41
42	int32 GetSpellDuration(SpellEntry const *spellInfo)
43	{
44	if(!spellInfo)
45	return 0;
46	SpellDurationEntry const *du = sSpellDurationStore.LookupEntry(spellInfo->DurationIndex);
47	if(!du)
48	return 0;
49	return (du->Duration[0] == -1) ? -1 : abs(du->Duration[0]);
50	}
51
52	int32 GetSpellMaxDuration(SpellEntry const *spellInfo)
53	{
54	if(!spellInfo)
55	return 0;
56	SpellDurationEntry const *du = sSpellDurationStore.LookupEntry(spellInfo->DurationIndex);
57	if(!du)
58	return 0;
59	return (du->Duration[2] == -1) ? -1 : abs(du->Duration[2]);
60	}
61
62	uint32 GetSpellCastTime(SpellEntry const* spellInfo, Spell const* spell)
63	{
64	SpellCastTimesEntry const *spellCastTimeEntry = sSpellCastTimesStore.LookupEntry(spellInfo->CastingTimeIndex);
65
66	// not all spells have cast time index and this is all is pasiive abilities
67	if(!spellCastTimeEntry)
68	return 0;
69
70	int32 castTime = spellCastTimeEntry->CastTime;
71
72	if (spell)
73	{
74	if(Player* modOwner = spell->GetCaster()->GetSpellModOwner())
75	modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_CASTING_TIME, castTime, spell);
76
77	if( !(spellInfo->Attributes & (SPELL_ATTR_UNK4\|SPELL_ATTR_UNK5)) )
78	castTime = int32(castTime * spell->GetCaster()->GetFloatValue(UNIT_MOD_CAST_SPEED));
79	else
80	{
81	if (spell->IsRangedSpell() && !spell->IsAutoRepeat())
82	castTime = int32(castTime * spell->GetCaster()->m_modAttackSpeedPct[RANGED_ATTACK]);
83	}
84	}
85
86	if (spellInfo->Attributes & SPELL_ATTR_RANGED && (!spell \|\| !(spell->IsAutoRepeat())))
87	castTime += 500;
88
89	return (castTime > 0) ? uint32(castTime) : 0;
90	}
91
92	bool IsPassiveSpell(uint32 spellId)
93	{
94	SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId);
95	if (!spellInfo)
96	return false;
97	return (spellInfo->Attributes & SPELL_ATTR_PASSIVE) != 0;
98	}
99
100	bool IsNoStackAuraDueToAura(uint32 spellId_1, uint32 effIndex_1, uint32 spellId_2, uint32 effIndex_2)
101	{
102	SpellEntry const *spellInfo_1 = sSpellStore.LookupEntry(spellId_1);
103	SpellEntry const *spellInfo_2 = sSpellStore.LookupEntry(spellId_2);
104	if(!spellInfo_1 \|\| !spellInfo_2) return false;
105	if(spellInfo_1->Id == spellId_2) return false;
106
107	if (spellInfo_1->Effect[effIndex_1] != spellInfo_2->Effect[effIndex_2] \|\|
108	spellInfo_1->EffectItemType[effIndex_1] != spellInfo_2->EffectItemType[effIndex_2] \|\|
109	spellInfo_1->EffectMiscValue[effIndex_1] != spellInfo_2->EffectMiscValue[effIndex_2] \|\|
110	spellInfo_1->EffectApplyAuraName[effIndex_1] != spellInfo_2->EffectApplyAuraName[effIndex_2])
111	return false;
112
113	return true;
114	}
115
116	int32 CompareAuraRanks(uint32 spellId_1, uint32 effIndex_1, uint32 spellId_2, uint32 effIndex_2)
117	{
118	SpellEntry const*spellInfo_1 = sSpellStore.LookupEntry(spellId_1);
119	SpellEntry const*spellInfo_2 = sSpellStore.LookupEntry(spellId_2);
120	if(!spellInfo_1 \|\| !spellInfo_2) return 0;
121	if (spellId_1 == spellId_2) return 0;
122
123	int32 diff = spellInfo_1->EffectBasePoints[effIndex_1] - spellInfo_2->EffectBasePoints[effIndex_2];
124	if (spellInfo_1->EffectBasePoints[effIndex_1]+1 < 0 && spellInfo_2->EffectBasePoints[effIndex_2]+1 < 0) return -diff;
125	else return diff;
126	}
127
128	SpellSpecific GetSpellSpecific(uint32 spellId)
129	{
130	SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId);
131	if(!spellInfo)
132	return SPELL_NORMAL;
133
134	switch(spellInfo->SpellFamilyName)
135	{
136	case SPELLFAMILY_MAGE:
137	{
138	// family flags 18(Molten), 25(Frost/Ice), 28(Mage)
139	if (spellInfo->SpellFamilyFlags & 0x12040000)
140	return SPELL_MAGE_ARMOR;
141
142	if ((spellInfo->SpellFamilyFlags & 0x1000000) && spellInfo->EffectApplyAuraName[0]==SPELL_AURA_MOD_CONFUSE)
143	return SPELL_MAGE_POLYMORPH;
144
145	break;
146	}
147	case SPELLFAMILY_WARRIOR:
148	{
149	if (spellInfo->SpellFamilyFlags & 0x00008000010000LL)
150	return SPELL_POSITIVE_SHOUT;
151
152	break;
153	}
154	case SPELLFAMILY_WARLOCK:
155	{
156	// only warlock curses have this
157	if (spellInfo->Dispel == DISPEL_CURSE)
158	return SPELL_CURSE;
159
160	// family flag 37 (only part spells have family name)
161	if (spellInfo->SpellFamilyFlags & 0x2000000000LL)
162	return SPELL_WARLOCK_ARMOR;
163
164	break;
165	}
166	case SPELLFAMILY_HUNTER:
167	{
168	// only hunter stings have this
169	if (spellInfo->Dispel == DISPEL_POISON)
170	return SPELL_STING;
171
172	break;
173	}
174	case SPELLFAMILY_PALADIN:
175	{
176	if (IsSealSpell(spellInfo))
177	return SPELL_SEAL;
178
179	if (spellInfo->SpellFamilyFlags & 0x10000100LL)
180	return SPELL_BLESSING;
181
182	if ((spellInfo->SpellFamilyFlags & 0x00000820180400LL) && (spellInfo->AttributesEx3 & 0x200))
183	return SPELL_JUDGEMENT;
184
185	for (int i = 0; i < 3; i++)
186	{
187	// only paladin auras have this
188	if (spellInfo->Effect[i] == SPELL_EFFECT_APPLY_AREA_AURA_PARTY)
189	return SPELL_AURA;
190	}
191	break;
192	}
193	case SPELLFAMILY_SHAMAN:
194	{
195	if (IsElementalShield(spellInfo))
196	return SPELL_ELEMENTAL_SHIELD;
197
198	break;
199	}
200
201	case SPELLFAMILY_POTION:
202	return spellmgr.GetSpellElixirSpecific(spellInfo->Id);
203	}
204
205	// only warlock armor/skin have this (in additional to family cases)
206	if( spellInfo->SpellVisual == 130 && spellInfo->SpellIconID == 89)
207	{
208	return SPELL_WARLOCK_ARMOR;
209	}
210
211	// only hunter aspects have this (but not all aspects in hunter family)
212	if( spellInfo->activeIconID == 122 && (GetSpellSchoolMask(spellInfo) & SPELL_SCHOOL_MASK_NATURE) &&
213	(spellInfo->Attributes & 0x50000) != 0 && (spellInfo->Attributes & 0x9000010) == 0)
214	{
215	return SPELL_ASPECT;
216	}
217
218	for(int i = 0; i < 3; i++)
219	if( spellInfo->Effect[i] == SPELL_EFFECT_APPLY_AURA && (
220	spellInfo->EffectApplyAuraName[i] == SPELL_AURA_TRACK_CREATURES \|\|
221	spellInfo->EffectApplyAuraName[i] == SPELL_AURA_TRACK_RESOURCES \|\|
222	spellInfo->EffectApplyAuraName[i] == SPELL_AURA_TRACK_STEALTHED ) )
223	return SPELL_TRACKER;
224
225	// elixirs can have different families, but potion most ofc.
226	if(SpellSpecific sp = spellmgr.GetSpellElixirSpecific(spellInfo->Id))
227	return sp;
228
229	return SPELL_NORMAL;
230	}
231
232	bool IsSingleFromSpellSpecificPerCaster(uint32 spellSpec1,uint32 spellSpec2)
233	{
234	switch(spellSpec1)
235	{
236	case SPELL_SEAL:
237	case SPELL_BLESSING:
238	case SPELL_AURA:
239	case SPELL_STING:
240	case SPELL_CURSE:
241	case SPELL_ASPECT:
242	case SPELL_TRACKER:
243	case SPELL_WARLOCK_ARMOR:
244	case SPELL_MAGE_ARMOR:
245	case SPELL_MAGE_POLYMORPH:
246	case SPELL_POSITIVE_SHOUT:
247	case SPELL_JUDGEMENT:
248	return spellSpec1==spellSpec2;
249	case SPELL_BATTLE_ELIXIR:
250	return spellSpec2==SPELL_BATTLE_ELIXIR
251	\|\| spellSpec2==SPELL_FLASK_ELIXIR;
252	case SPELL_GUARDIAN_ELIXIR:
253	return spellSpec2==SPELL_GUARDIAN_ELIXIR
254	\|\| spellSpec2==SPELL_FLASK_ELIXIR;
255	case SPELL_FLASK_ELIXIR:
256	return spellSpec2==SPELL_BATTLE_ELIXIR
257	\|\| spellSpec2==SPELL_GUARDIAN_ELIXIR
258	\|\| spellSpec2==SPELL_FLASK_ELIXIR;
259	default:
260	return false;
261	}
262	}
263
264	bool IsPositiveTarget(uint32 targetA, uint32 targetB)
265	{
266	// non-positive targets
267	switch(targetA)
268	{
269	case TARGET_CHAIN_DAMAGE:
270	case TARGET_ALL_ENEMY_IN_AREA:
271	case TARGET_ALL_ENEMY_IN_AREA_INSTANT:
272	case TARGET_IN_FRONT_OF_CASTER:
273	case TARGET_ALL_ENEMY_IN_AREA_CHANNELED:
274	case TARGET_CURRENT_ENEMY_COORDINATES:
275	case TARGET_SINGLE_ENEMY:
276	return false;
277	case TARGET_ALL_AROUND_CASTER:
278	return (targetB == TARGET_ALL_PARTY \|\| targetB == TARGET_ALL_FRIENDLY_UNITS_AROUND_CASTER);
279	default:
280	break;
281	}
282	if (targetB)
283	return IsPositiveTarget(targetB, 0);
284	return true;
285	}
286
287	bool IsPositiveEffect(uint32 spellId, uint32 effIndex)
288	{
289	SpellEntry const *spellproto = sSpellStore.LookupEntry(spellId);
290	if (!spellproto) return false;
291
292	switch(spellId)
293	{
294	case 23333: // BG spell
295	case 23335: // BG spell
296	case 34976: // BG spell
297	return true;
298	case 28441: // not positive dummy spell
299	case 37675: // Chaos Blast
300	return false;
301	}
302
303	switch(spellproto->Effect[effIndex])
304	{
305	// always positive effects (check before target checks that provided non-positive result in some case for positive effects)
306	case SPELL_EFFECT_HEAL:
307	case SPELL_EFFECT_LEARN_SPELL:
308	case SPELL_EFFECT_SKILL_STEP:
309	case SPELL_EFFECT_HEAL_PCT:
310	case SPELL_EFFECT_ENERGIZE_PCT:
311	return true;
312
313	// non-positive aura use
314	case SPELL_EFFECT_APPLY_AURA:
315	case SPELL_EFFECT_APPLY_AREA_AURA_FRIEND:
316	{
317	switch(spellproto->EffectApplyAuraName[effIndex])
318	{
319	case SPELL_AURA_DUMMY:
320	{
321	// dummy aura can be positive or negative dependent from casted spell
322	switch(spellproto->Id)
323	{
324	case 13139: // net-o-matic special effect
325	case 23445: // evil twin
326	return false;
327	default:
328	break;
329	}
330	} break;
331	case SPELL_AURA_MOD_STAT:
332	case SPELL_AURA_MOD_DAMAGE_DONE: // dependent from bas point sign (negative -> negative)
333	case SPELL_AURA_MOD_HEALING_DONE:
334	{
335	if(spellproto->EffectBasePoints[effIndex]+int32(spellproto->EffectBaseDice[effIndex]) < 0)
336	return false;
337	break;
338	}
339	case SPELL_AURA_ADD_TARGET_TRIGGER:
340	return true;
341	case SPELL_AURA_PERIODIC_TRIGGER_SPELL:
342	if(spellId != spellproto->EffectTriggerSpell[effIndex])
343	{
344	uint32 spellTriggeredId = spellproto->EffectTriggerSpell[effIndex];
345	SpellEntry const *spellTriggeredProto = sSpellStore.LookupEntry(spellTriggeredId);
346
347	if(spellTriggeredProto)
348	{
349	// non-positive targets of main spell return early
350	for(int i = 0; i < 3; ++i)
351	{
352	// if non-positive trigger cast targeted to positive target this main cast is non-positive
353	// this will place this spell auras as debuffs
354	if(IsPositiveTarget(spellTriggeredProto->EffectImplicitTargetA[effIndex],spellTriggeredProto->EffectImplicitTargetB[effIndex]) && !IsPositiveEffect(spellTriggeredId,i))
355	return false;
356	}
357	}
358	}
359	break;
360	case SPELL_AURA_PROC_TRIGGER_SPELL:
361	// many positive auras have negative triggered spells at damage for example and this not make it negative (it can be canceled for example)
362	break;
363	case SPELL_AURA_MOD_STUN: //have positive and negative spells, we can't sort its correctly at this moment.
364	if(effIndex==0 && spellproto->Effect[1]==0 && spellproto->Effect[2]==0)
365	return false; // but all single stun aura spells is negative
366
367	// Petrification
368	if(spellproto->Id == 17624)
369	return false;
370	break;
371	case SPELL_AURA_MOD_ROOT:
372	case SPELL_AURA_MOD_SILENCE:
373	case SPELL_AURA_GHOST:
374	case SPELL_AURA_PERIODIC_LEECH:
375	case SPELL_AURA_MOD_PACIFY_SILENCE:
376	case SPELL_AURA_MOD_STALKED:
377	case SPELL_AURA_PERIODIC_DAMAGE_PERCENT:
378	return false;
379	case SPELL_AURA_PERIODIC_DAMAGE: // used in positive spells also.
380	// part of negative spell if casted at self (prevent cancel)
381	if(spellproto->EffectImplicitTargetA[effIndex] == TARGET_SELF)
382	return false;
383	break;
384	case SPELL_AURA_MOD_DECREASE_SPEED: // used in positive spells also
385	// part of positive spell if casted at self
386	if(spellproto->EffectImplicitTargetA[effIndex] != TARGET_SELF)
387	return false;
388	// but not this if this first effect (don't found batter check)
389	if(spellproto->Attributes & 0x4000000 && effIndex==0)
390	return false;
391	break;
392	case SPELL_AURA_TRANSFORM:
393	// some spells negative
394	switch(spellproto->Id)
395	{
396	case 36897: // Transporter Malfunction (race mutation to horde)
397	case 36899: // Transporter Malfunction (race mutation to alliance)
398	return false;
399	}
400	break;
401	case SPELL_AURA_MOD_SCALE:
402	// some spells negative
403	switch(spellproto->Id)
404	{
405	case 36900: // Soul Split: Evil!
406	case 36901: // Soul Split: Good
407	case 36893: // Transporter Malfunction (decrease size case)
408	case 36895: // Transporter Malfunction (increase size case)
409	return false;
410	}
411	break;
412	case SPELL_AURA_MECHANIC_IMMUNITY:
413	{
414	// non-positive immunities
415	switch(spellproto->EffectMiscValue[effIndex])
416	{
417	case MECHANIC_BANDAGE:
418	case MECHANIC_SHIELD:
419	case MECHANIC_MOUNT:
420	case MECHANIC_INVULNERABILITY:
421	return false;
422	default:
423	break;
424	}
425	} break;
426	case SPELL_AURA_ADD_FLAT_MODIFIER: // mods
427	case SPELL_AURA_ADD_PCT_MODIFIER:
428	{
429	// non-positive mods
430	switch(spellproto->EffectMiscValue[effIndex])
431	{
432	case SPELLMOD_COST: // dependent from bas point sign (negative -> positive)
433	if(spellproto->EffectBasePoints[effIndex]+int32(spellproto->EffectBaseDice[effIndex]) > 0)
434	return false;
435	break;
436	default:
437	break;
438	}
439	} break;
440	case SPELL_AURA_MOD_HEALING_PCT:
441	if(spellproto->EffectBasePoints[effIndex]+int32(spellproto->EffectBaseDice[effIndex]) < 0)
442	return false;
443	break;
444	case SPELL_AURA_MOD_SKILL:
445	if(spellproto->EffectBasePoints[effIndex]+int32(spellproto->EffectBaseDice[effIndex]) < 0)
446	return false;
447	break;
448	case SPELL_AURA_FORCE_REACTION:
449	if(spellproto->Id==42792) // Recently Dropped Flag (prevent cancel)
450	return false;
451	break;
452	default:
453	break;
454	}
455	break;
456	}
457	default:
458	break;
459	}
460
461	// non-positive targets
462	if(!IsPositiveTarget(spellproto->EffectImplicitTargetA[effIndex],spellproto->EffectImplicitTargetB[effIndex]))
463	return false;
464
465	// AttributesEx check
466	if(spellproto->AttributesEx & (1<<7))
467	return false;
468
469	// ok, positive
470	return true;
471	}
472
473	bool IsPositiveSpell(uint32 spellId)
474	{
475	SpellEntry const *spellproto = sSpellStore.LookupEntry(spellId);
476	if (!spellproto) return false;
477
478	// spells with atleast one negative effect are considered negative
479	// some self-applied spells have negative effects but in self casting case negative check ignored.
480	for (int i = 0; i < 3; i++)
481	if (!IsPositiveEffect(spellId, i))
482	return false;
483	return true;
484	}
485
486	bool IsSingleTargetSpell(SpellEntry const *spellInfo)
487	{
488	// all other single target spells have if it has AttributesEx5
489	if ( spellInfo->AttributesEx5 & SPELL_ATTR_EX5_SINGLE_TARGET_SPELL )
490	return true;
491
492	// TODO - need found Judgements rule
493	switch(GetSpellSpecific(spellInfo->Id))
494	{
495	case SPELL_JUDGEMENT:
496	return true;
497	}
498
499	// single target triggered spell.
500	// Not real client side single target spell, but it' not triggered until prev. aura expired.
501	// This is allow store it in single target spells list for caster for spell proc checking
502	if(spellInfo->Id==38324) // Regeneration (triggered by 38299 (HoTs on Heals))
503	return true;
504
505	return false;
506	}
507
508	bool IsSingleTargetSpells(SpellEntry const spellInfo1, SpellEntry const spellInfo2)
509	{
510	// TODO - need better check
511	// Equal icon and spellfamily
512	if( spellInfo1->SpellFamilyName == spellInfo2->SpellFamilyName &&
513	spellInfo1->SpellIconID == spellInfo2->SpellIconID )
514	return true;
515
516	// TODO - need found Judgements rule
517	SpellSpecific spec1 = GetSpellSpecific(spellInfo1->Id);
518	// spell with single target specific types
519	switch(spec1)
520	{
521	case SPELL_JUDGEMENT:
522	if(GetSpellSpecific(spellInfo2->Id) == spec1)
523	return true;
524	break;
525	}
526
527	return false;
528	}
529
530	uint8 GetErrorAtShapeshiftedCast (SpellEntry const *spellInfo, uint32 form)
531	{
532	// talents that learn spells can have stance requirements that need ignore
533	// (this requirement only for client-side stance show in talent description)
534	if( GetTalentSpellCost(spellInfo->Id) > 0 &&
535	(spellInfo->Effect[0]==SPELL_EFFECT_LEARN_SPELL \|\| spellInfo->Effect[1]==SPELL_EFFECT_LEARN_SPELL \|\| spellInfo->Effect[2]==SPELL_EFFECT_LEARN_SPELL) )
536	return 0;
537
538	uint32 stanceMask = (form ? 1 << (form - 1) : 0);
539
540	if (stanceMask & spellInfo->StancesNot) // can explicitly not be casted in this stance
541	return SPELL_FAILED_NOT_SHAPESHIFT;
542
543	if (stanceMask & spellInfo->Stances) // can explicitly be casted in this stance
544	return 0;
545
546	bool actAsShifted = false;
547	if (form > 0)
548	{
549	SpellShapeshiftEntry const *shapeInfo = sSpellShapeshiftStore.LookupEntry(form);
550	if (!shapeInfo)
551	{
552	sLog.outError("GetErrorAtShapeshiftedCast: unknown shapeshift %u", form);
553	return 0;
554	}
555	actAsShifted = !(shapeInfo->flags1 & 1); // shapeshift acts as normal form for spells
556	}
557
558	if(actAsShifted)
559	{
560	if (spellInfo->Attributes & SPELL_ATTR_NOT_SHAPESHIFT) // not while shapeshifted
561	return SPELL_FAILED_NOT_SHAPESHIFT;
562	else if (spellInfo->Stances != 0) // needs other shapeshift
563	return SPELL_FAILED_ONLY_SHAPESHIFT;
564	}
565	else
566	{
567	// needs shapeshift
568	if(!(spellInfo->AttributesEx2 & SPELL_ATTR_EX2_NOT_NEED_SHAPESHIFT) && spellInfo->Stances != 0)
569	return SPELL_FAILED_ONLY_SHAPESHIFT;
570	}
571
572	return 0;
573	}
574
575	void SpellMgr::LoadSpellTargetPositions()
576	{
577	mSpellTargetPositions.clear(); // need for reload case
578
579	uint32 count = 0;
580
581	// 0 1 2 3 4 5
582	QueryResult *result = WorldDatabase.Query("SELECT id, target_map, target_position_x, target_position_y, target_position_z, target_orientation FROM spell_target_position");
583	if( !result )
584	{
585
586	barGoLink bar( 1 );
587
588	bar.step();
589
590	sLog.outString();
591	sLog.outString( ">> Loaded %u spell target coordinates", count );
592	return;
593	}
594
595	barGoLink bar( result->GetRowCount() );
596
597	do
598	{
599	Field *fields = result->Fetch();
600
601	bar.step();
602
603	++count;
604
605	uint32 Spell_ID = fields[0].GetUInt32();
606
607	SpellTargetPosition st;
608
609	st.target_mapId = fields[1].GetUInt32();
610	st.target_X = fields[2].GetFloat();
611	st.target_Y = fields[3].GetFloat();
612	st.target_Z = fields[4].GetFloat();
613	st.target_Orientation = fields[5].GetFloat();
614
615	SpellEntry const* spellInfo = sSpellStore.LookupEntry(Spell_ID);
616	if(!spellInfo)
617	{
618	sLog.outErrorDb("Spell (ID:%u) listed in `spell_target_position` does not exist.",Spell_ID);
619	continue;
620	}
621
622	bool found = false;
623	for(int i = 0; i < 3; ++i)
624	{
625	if( spellInfo->EffectImplicitTargetA[i]==TARGET_TABLE_X_Y_Z_COORDINATES \|\| spellInfo->EffectImplicitTargetB[i]==TARGET_TABLE_X_Y_Z_COORDINATES )
626	{
627	found = true;
628	break;
629	}
630	}
631	if(!found)
632	{
633	sLog.outErrorDb("Spell (Id: %u) listed in `spell_target_position` does not have target TARGET_TABLE_X_Y_Z_COORDINATES (17).",Spell_ID);
634	continue;
635	}
636
637	MapEntry const* mapEntry = sMapStore.LookupEntry(st.target_mapId);
638	if(!mapEntry)
639	{
640	sLog.outErrorDb("Spell (ID:%u) target map (ID: %u) does not exist in `Map.dbc`.",Spell_ID,st.target_mapId);
641	continue;
642	}
643
644	if(st.target_X==0 && st.target_Y==0 && st.target_Z==0)
645	{
646	sLog.outErrorDb("Spell (ID:%u) target coordinates not provided.",Spell_ID);
647	continue;
648	}
649
650	mSpellTargetPositions[Spell_ID] = st;
651
652	} while( result->NextRow() );
653
654	delete result;
655
656	sLog.outString();
657	sLog.outString( ">> Loaded %u spell teleport coordinates", count );
658	}
659
660	void SpellMgr::LoadSpellAffects()
661	{
662	mSpellAffectMap.clear(); // need for reload case
663
664	uint32 count = 0;
665
666	// 0 1 2
667	QueryResult *result = WorldDatabase.Query("SELECT entry, effectId, SpellFamilyMask FROM spell_affect");
668	if( !result )
669	{
670
671	barGoLink bar( 1 );
672
673	bar.step();
674
675	sLog.outString();
676	sLog.outString( ">> Loaded %u spell affect definitions", count );
677	return;
678	}
679
680	barGoLink bar( result->GetRowCount() );
681
682	do
683	{
684	Field *fields = result->Fetch();
685
686	bar.step();
687
688	uint16 entry = fields[0].GetUInt16();
689	uint8 effectId = fields[1].GetUInt8();
690
691	SpellEntry const* spellInfo = sSpellStore.LookupEntry(entry);
692
693	if (!spellInfo)
694	{
695	sLog.outErrorDb("Spell %u listed in `spell_affect` does not exist", entry);
696	continue;
697	}
698
699	if (effectId >= 3)
700	{
701	sLog.outErrorDb("Spell %u listed in `spell_affect` have invalid effect index (%u)", entry,effectId);
702	continue;
703	}
704
705	if( spellInfo->Effect[effectId] != SPELL_EFFECT_APPLY_AURA \|\|
706	spellInfo->EffectApplyAuraName[effectId] != SPELL_AURA_ADD_FLAT_MODIFIER &&
707	spellInfo->EffectApplyAuraName[effectId] != SPELL_AURA_ADD_PCT_MODIFIER &&
708	spellInfo->EffectApplyAuraName[effectId] != SPELL_AURA_ADD_TARGET_TRIGGER )
709	{
710	sLog.outErrorDb("Spell %u listed in `spell_affect` have not SPELL_AURA_ADD_FLAT_MODIFIER (%u) or SPELL_AURA_ADD_PCT_MODIFIER (%u) or SPELL_AURA_ADD_TARGET_TRIGGER (%u) for effect index (%u)", entry,SPELL_AURA_ADD_FLAT_MODIFIER,SPELL_AURA_ADD_PCT_MODIFIER,SPELL_AURA_ADD_TARGET_TRIGGER,effectId);
711	continue;
712	}
713
714	uint64 spellAffectMask = fields[2].GetUInt64();
715
716	// Spell.dbc have own data for low part of SpellFamilyMask
717	if( spellInfo->EffectItemType[effectId])
718	{
719	if(spellInfo->EffectItemType[effectId] == spellAffectMask)
720	{
721	sLog.outErrorDb("Spell %u listed in `spell_affect` have redundant (same with EffectItemType%d) data for effect index (%u) and not needed, skipped.", entry,effectId+1,effectId);
722	continue;
723	}
724
725	// 24429 have wrong data in EffectItemType and overwrites by DB, possible bug in client
726	if(spellInfo->Id!=24429 && spellInfo->EffectItemType[effectId] != spellAffectMask)
727	{
728	sLog.outErrorDb("Spell %u listed in `spell_affect` have different low part from EffectItemType%d for effect index (%u) and not needed, skipped.", entry,effectId+1,effectId);
729	continue;
730	}
731	}
732
733	mSpellAffectMap.insert(SpellAffectMap::value_type((entry<<8) + effectId,spellAffectMask));
734
735	++count;
736	} while( result->NextRow() );
737
738	delete result;
739
740	sLog.outString();
741	sLog.outString( ">> Loaded %u spell affect definitions", count );
742
743	/*
744	// Commented for now, as it still produces many errors (still quite many spells miss spell_affect)
745	for (uint32 id = 0; id < sSpellStore.GetNumRows(); ++id)
746	{
747	SpellEntry const* spellInfo = sSpellStore.LookupEntry(id);
748	if (!spellInfo)
749	continue;
750
751	for (int effectId = 0; effectId < 3; ++effectId)
752	{
753	if( spellInfo->Effect[effectId] != SPELL_EFFECT_APPLY_AURA \|\|
754	(spellInfo->EffectApplyAuraName[effectId] != SPELL_AURA_ADD_FLAT_MODIFIER &&
755	spellInfo->EffectApplyAuraName[effectId] != SPELL_AURA_ADD_PCT_MODIFIER &&
756	spellInfo->EffectApplyAuraName[effectId] != SPELL_AURA_ADD_TARGET_TRIGGER) )
757	continue;
758
759	if(spellInfo->EffectItemType[effectId] != 0)
760	continue;
761
762	if(mSpellAffectMap.find((id<<8) + effectId) != mSpellAffectMap.end())
763	continue;
764
765	sLog.outErrorDb("Spell %u (%s) misses spell_affect for effect %u",id,spellInfo->SpellName[sWorld.GetDBClang()], effectId);
766	}
767	}
768	*/
769	}
770
771	bool SpellMgr::IsAffectedBySpell(SpellEntry const *spellInfo, uint32 spellId, uint8 effectId, uint64 familyFlags) const
772	{
773	// false for spellInfo == NULL
774	if (!spellInfo)
775	return false;
776
777	SpellEntry const *affect_spell = sSpellStore.LookupEntry(spellId);
778	// false for affect_spell == NULL
779	if (!affect_spell)
780	return false;
781
782	// False if spellFamily not equal
783	if (affect_spell->SpellFamilyName != spellInfo->SpellFamilyName)
784	return false;
785
786	// If familyFlags == 0
787	if (!familyFlags)
788	{
789	// Get it from spellAffect table
790	familyFlags = GetSpellAffectMask(spellId,effectId);
791	// false if familyFlags == 0
792	if (!familyFlags)
793	return false;
794	}
795
796	// true
797	if (familyFlags & spellInfo->SpellFamilyFlags)
798	return true;
799
800	return false;
801	}
802
803	void SpellMgr::LoadSpellProcEvents()
804	{
805	mSpellProcEventMap.clear(); // need for reload case
806
807	uint32 count = 0;
808
809	// 0 1 2 3 4 5 6 7 8
810	QueryResult *result = WorldDatabase.Query("SELECT entry, SchoolMask, Category, SkillID, SpellFamilyName, SpellFamilyMask, procFlags, ppmRate, cooldown FROM spell_proc_event");
811	if( !result )
812	{
813
814	barGoLink bar( 1 );
815
816	bar.step();
817
818	sLog.outString();
819	sLog.outString( ">> Loaded %u spell proc event conditions", count );
820	return;
821	}
822
823	barGoLink bar( result->GetRowCount() );
824
825	do
826	{
827	Field *fields = result->Fetch();
828
829	bar.step();
830
831	uint16 entry = fields[0].GetUInt16();
832
833	if (!sSpellStore.LookupEntry(entry))
834	{
835	sLog.outErrorDb("Spell %u listed in `spell_proc_event` does not exist", entry);
836	continue;
837	}
838
839	SpellProcEventEntry spe;
840
841	spe.schoolMask = fields[1].GetUInt32();
842	spe.category = fields[2].GetUInt32();
843	spe.skillId = fields[3].GetUInt32();
844	spe.spellFamilyName = fields[4].GetUInt32();
845	spe.spellFamilyMask = fields[5].GetUInt64();
846	spe.procFlags = fields[6].GetUInt32();
847	spe.ppmRate = fields[7].GetFloat();
848	spe.cooldown = fields[8].GetUInt32();
849
850	mSpellProcEventMap[entry] = spe;
851
852	++count;
853	} while( result->NextRow() );
854
855	delete result;
856
857	sLog.outString();
858	sLog.outString( ">> Loaded %u spell proc event conditions", count );
859
860	/*
861	// Commented for now, as it still produces many errors (still quite many spells miss spell_proc_event)
862	for (uint32 id = 0; id < sSpellStore.GetNumRows(); ++id)
863	{
864	SpellEntry const* spellInfo = sSpellStore.LookupEntry(id);
865	if (!spellInfo)
866	continue;
867
868	bool found = false;
869	for (int effectId = 0; effectId < 3; ++effectId)
870	{
871	// at this moment check only SPELL_AURA_PROC_TRIGGER_SPELL
872	if( spellInfo->EffectApplyAuraName[effectId] == SPELL_AURA_PROC_TRIGGER_SPELL )
873	{
874	found = true;
875	break;
876	}
877	}
878
879	if(!found)
880	continue;
881
882	if(GetSpellProcEvent(id))
883	continue;
884
885	sLog.outErrorDb("Spell %u (%s) misses spell_proc_event",id,spellInfo->SpellName[sWorld.GetDBClang()]);
886	}
887	*/
888	}
889
890	bool SpellMgr::IsSpellProcEventCanTriggeredBy( SpellProcEventEntry const * spellProcEvent, SpellEntry const * procSpell, uint32 procFlags )
891	{
892	if((procFlags & spellProcEvent->procFlags) == 0)
893	return false;
894
895	// Additional checks in case spell cast/hit/crit is the event
896	// Check (if set) school, category, skill line, spell talent mask
897	if(spellProcEvent->schoolMask && (!procSpell \|\| (GetSpellSchoolMask(procSpell) & spellProcEvent->schoolMask) == 0))
898	return false;
899	if(spellProcEvent->category && (!procSpell \|\| procSpell->Category != spellProcEvent->category))
900	return false;
901	if(spellProcEvent->skillId)
902	{
903	if (!procSpell)
904	return false;
905
906	SkillLineAbilityMap::const_iterator lower = spellmgr.GetBeginSkillLineAbilityMap(procSpell->Id);
907	SkillLineAbilityMap::const_iterator upper = spellmgr.GetEndSkillLineAbilityMap(procSpell->Id);
908
909	bool found = false;
910	for(SkillLineAbilityMap::const_iterator _spell_idx = lower; _spell_idx != upper; ++_spell_idx)
911	{
912	if(_spell_idx->second->skillId == spellProcEvent->skillId)
913	{
914	found = true;
915	break;
916	}
917	}
918	if (!found)
919	return false;
920	}
921	if(spellProcEvent->spellFamilyName && (!procSpell \|\| spellProcEvent->spellFamilyName != procSpell->SpellFamilyName))
922	return false;
923	if(spellProcEvent->spellFamilyMask && (!procSpell \|\| (spellProcEvent->spellFamilyMask & procSpell->SpellFamilyFlags) == 0))
924	return false;
925
926	return true;
927	}
928
929	void SpellMgr::LoadSpellElixirs()
930	{
931	mSpellElixirs.clear(); // need for reload case
932
933	uint32 count = 0;
934
935	// 0 1
936	QueryResult *result = WorldDatabase.Query("SELECT entry, mask FROM spell_elixir");
937	if( !result )
938	{
939
940	barGoLink bar( 1 );
941
942	bar.step();
943
944	sLog.outString();
945	sLog.outString( ">> Loaded %u spell elixir definitions", count );
946	return;
947	}
948
949	barGoLink bar( result->GetRowCount() );
950
951	do
952	{
953	Field *fields = result->Fetch();
954
955	bar.step();
956
957	uint16 entry = fields[0].GetUInt16();
958	uint8 mask = fields[1].GetUInt8();
959
960	SpellEntry const* spellInfo = sSpellStore.LookupEntry(entry);
961
962	if (!spellInfo)
963	{
964	sLog.outErrorDb("Spell %u listed in `spell_elixir` does not exist", entry);
965	continue;
966	}
967
968	mSpellElixirs[entry] = mask;
969
970	++count;
971	} while( result->NextRow() );
972
973	delete result;
974
975	sLog.outString();
976	sLog.outString( ">> Loaded %u spell elixir definitions", count );
977	}
978
979	void SpellMgr::LoadSpellThreats()
980	{
981	sSpellThreatStore.Free(); // for reload
982
983	sSpellThreatStore.Load();
984
985	sLog.outString( ">> Loaded %u aggro generating spells", sSpellThreatStore.RecordCount );
986	sLog.outString();
987	}
988
989	bool SpellMgr::IsRankSpellDueToSpell(SpellEntry const *spellInfo_1,uint32 spellId_2) const
990	{
991	SpellEntry const *spellInfo_2 = sSpellStore.LookupEntry(spellId_2);
992	if(!spellInfo_1 \|\| !spellInfo_2) return false;
993	if(spellInfo_1->Id == spellId_2) return false;
994
995	return GetFirstSpellInChain(spellInfo_1->Id)==GetFirstSpellInChain(spellId_2);
996	}
997
998	bool SpellMgr::canStackSpellRanks(SpellEntry const *spellInfo)
999	{
1000	if(spellInfo->powerType != POWER_MANA && spellInfo->powerType != POWER_HEALTH)
1001	return false;
1002	if(IsProfessionSpell(spellInfo->Id))
1003	return false;
1004
1005	// All stance spells. if any better way, change it.
1006	for (int i = 0; i < 3; i++)
1007	{
1008	// Paladin aura Spell
1009	if(spellInfo->SpellFamilyName == SPELLFAMILY_PALADIN
1010	&& spellInfo->Effect[i]==SPELL_EFFECT_APPLY_AREA_AURA_PARTY)
1011	return false;
1012	// Druid form Spell
1013	if(spellInfo->SpellFamilyName == SPELLFAMILY_DRUID
1014	&& spellInfo->Effect[i]==SPELL_EFFECT_APPLY_AURA
1015	&& spellInfo->EffectApplyAuraName[i] == SPELL_AURA_MOD_SHAPESHIFT)
1016	return false;
1017	// Rogue Stealth
1018	if(spellInfo->SpellFamilyName == SPELLFAMILY_ROGUE
1019	&& spellInfo->Effect[i]==SPELL_EFFECT_APPLY_AURA
1020	&& spellInfo->EffectApplyAuraName[i] == SPELL_AURA_MOD_SHAPESHIFT)
1021	return false;
1022	}
1023	return true;
1024	}
1025
1026	bool SpellMgr::IsNoStackSpellDueToSpell(uint32 spellId_1, uint32 spellId_2) const
1027	{
1028	SpellEntry const *spellInfo_1 = sSpellStore.LookupEntry(spellId_1);
1029	SpellEntry const *spellInfo_2 = sSpellStore.LookupEntry(spellId_2);
1030
1031	if(!spellInfo_1 \|\| !spellInfo_2)
1032	return false;
1033
1034	if(spellInfo_1->Id == spellId_2)
1035	return false;
1036
1037	//I think we don't check this correctly because i need a exception for spell:
1038	//72,11327,18461...(called from 1856,1857...) Call Aura 16,31, after trigger another spell who call aura 77 and 77 remove 16 and 31, this should not happen.
1039	if(spellInfo_2->SpellFamilyFlags == 2048)
1040	return false;
1041
1042	// Resurrection sickness
1043	if((spellInfo_1->Id == SPELL_ID_PASSIVE_RESURRECTION_SICKNESS) != (spellInfo_2->Id==SPELL_ID_PASSIVE_RESURRECTION_SICKNESS))
1044	return false;
1045
1046	// Specific spell family spells
1047	switch(spellInfo_1->SpellFamilyName)
1048	{
1049	case SPELLFAMILY_GENERIC:
1050	switch(spellInfo_2->SpellFamilyName)
1051	{
1052	case SPELLFAMILY_GENERIC: // same family case
1053	{
1054	// Thunderfury
1055	if( spellInfo_1->Id == 21992 && spellInfo_2->Id == 27648 \|\| spellInfo_2->Id == 21992 && spellInfo_1->Id == 27648 )
1056	return false;
1057
1058	// Lightning Speed (Mongoose) and Fury of the Crashing Waves (Tsunami Talisman)
1059	if( spellInfo_1->Id == 28093 && spellInfo_2->Id == 42084 \|\|
1060	spellInfo_2->Id == 28093 && spellInfo_1->Id == 42084 )
1061	return false;
1062
1063	// Soulstone Resurrection and Twisting Nether (resurrector)
1064	if( spellInfo_1->SpellIconID == 92 && spellInfo_2->SpellIconID == 92 && (
1065	spellInfo_1->SpellVisual == 99 && spellInfo_2->SpellVisual == 0 \|\|
1066	spellInfo_2->SpellVisual == 99 && spellInfo_1->SpellVisual == 0 ) )
1067	return false;
1068
1069	// Heart of the Wild and (Primal Instinct (Idol of Terror) triggering spell or Agility)
1070	if( spellInfo_1->SpellIconID == 240 && spellInfo_2->SpellIconID == 240 && (
1071	spellInfo_1->SpellVisual == 0 && spellInfo_2->SpellVisual == 78 \|\|
1072	spellInfo_2->SpellVisual == 0 && spellInfo_1->SpellVisual == 78 ) )
1073	return false;
1074
1075	// Personalized Weather (thunder effect should overwrite rainy aura)
1076	if(spellInfo_1->SpellIconID == 2606 && spellInfo_2->SpellIconID == 2606)
1077	return false;
1078
1079	// Brood Affliction: Bronze
1080	if( (spellInfo_1->Id == 23170 && spellInfo_2->Id == 23171) \|\|
1081	(spellInfo_2->Id == 23170 && spellInfo_1->Id == 23171) )
1082	return false;
1083
1084	break;
1085	}
1086	case SPELLFAMILY_WARRIOR:
1087	{
1088	// Scroll of Protection and Defensive Stance (multi-family check)
1089	if( spellInfo_1->SpellIconID == 276 && spellInfo_1->SpellVisual == 196 && spellInfo_2->Id == 71)
1090	return false;
1091
1092	// Improved Hamstring -> Hamstring (multi-family check)
1093	if( (spellInfo_2->SpellFamilyFlags & 2) && spellInfo_1->Id == 23694 )
1094	return false;
1095
1096	break;
1097	}
1098	case SPELLFAMILY_DRUID:
1099	{
1100	// Scroll of Stamina and Leader of the Pack (multi-family check)
1101	if( spellInfo_1->SpellIconID == 312 && spellInfo_1->SpellVisual == 216 && spellInfo_2->Id == 24932 )
1102	return false;
1103
1104	// Dragonmaw Illusion (multi-family check)
1105	if (spellId_1 == 40216 && spellId_2 == 42016 )
1106	return false;
1107
1108	break;
1109	}
1110	case SPELLFAMILY_ROGUE:
1111	{
1112	// Garrote-Silence -> Garrote (multi-family check)
1113	if( spellInfo_1->SpellIconID == 498 && spellInfo_1->SpellVisual == 0 && spellInfo_2->SpellIconID == 498 )
1114	return false;
1115
1116	break;
1117	}
1118	case SPELLFAMILY_HUNTER:
1119	{
1120	// Concussive Shot and Imp. Concussive Shot (multi-family check)
1121	if( spellInfo_1->Id == 19410 && spellInfo_2->Id == 5116 )
1122	return false;
1123
1124	// Improved Wing Clip -> Wing Clip (multi-family check)
1125	if( (spellInfo_2->SpellFamilyFlags & 0x40) && spellInfo_1->Id == 19229 )
1126	return false;
1127	break;
1128	}
1129	case SPELLFAMILY_PALADIN:
1130	{
1131	// Unstable Currents and other -> *Sanctity Aura (multi-family check)
1132	if( spellInfo_2->SpellIconID==502 && spellInfo_1->SpellIconID==502 && spellInfo_1->SpellVisual==969 )
1133	return false;
1134
1135	// *Band of Eternal Champion and Seal of Command(multi-family check)
1136	if( spellId_1 == 35081 && spellInfo_2->SpellIconID==561 && spellInfo_2->SpellVisual==7992)
1137	return false;
1138
1139	break;
1140	}
1141	}
1142	break;
1143	case SPELLFAMILY_MAGE:
1144	if( spellInfo_2->SpellFamilyName == SPELLFAMILY_MAGE )
1145	{
1146	// Blizzard & Chilled (and some other stacked with blizzard spells
1147	if( (spellInfo_1->SpellFamilyFlags & 0x80) && (spellInfo_2->SpellFamilyFlags & 0x100000) \|\|
1148	(spellInfo_2->SpellFamilyFlags & 0x80) && (spellInfo_1->SpellFamilyFlags & 0x100000) )
1149	return false;
1150
1151	// Blink & Improved Blink
1152	if( (spellInfo_1->SpellFamilyFlags & 0x0000000000010000LL) && (spellInfo_2->SpellVisual == 72 && spellInfo_2->SpellIconID == 1499) \|\|
1153	(spellInfo_2->SpellFamilyFlags & 0x0000000000010000LL) && (spellInfo_1->SpellVisual == 72 && spellInfo_1->SpellIconID == 1499) )
1154	return false;
1155	}
1156	// Detect Invisibility and Mana Shield (multi-family check)
1157	if( spellInfo_2->Id == 132 && spellInfo_1->SpellIconID == 209 && spellInfo_1->SpellVisual == 968 )
1158	return false;
1159
1160	// Combustion and Fire Protection Aura (multi-family check)
1161	if( spellInfo_1->Id == 11129 && spellInfo_2->SpellIconID == 33 && spellInfo_2->SpellVisual == 321 )
1162	return false;
1163
1164	break;
1165	case SPELLFAMILY_WARLOCK:
1166	if( spellInfo_2->SpellFamilyName == SPELLFAMILY_WARLOCK )
1167	{
1168	// Siphon Life and Drain Life
1169	if( spellInfo_1->SpellIconID == 152 && spellInfo_2->SpellIconID == 546 \|\|
1170	spellInfo_2->SpellIconID == 152 && spellInfo_1->SpellIconID == 546 )
1171	return false;
1172
1173	//Corruption & Seed of corruption
1174	if( spellInfo_1->SpellIconID == 313 && spellInfo_2->SpellIconID == 1932 \|\|
1175	spellInfo_2->SpellIconID == 313 && spellInfo_1->SpellIconID == 1932 )
1176	if(spellInfo_1->SpellVisual != 0 && spellInfo_2->SpellVisual != 0)
1177	return true; // can't be stacked
1178
1179	// Corruption and Unstable Affliction
1180	if( spellInfo_1->SpellIconID == 313 && spellInfo_2->SpellIconID == 2039 \|\|
1181	spellInfo_2->SpellIconID == 313 && spellInfo_1->SpellIconID == 2039 )
1182	return false;
1183
1184	// (Corruption or Unstable Affliction) and (Curse of Agony or Curse of Doom)
1185	if( (spellInfo_1->SpellIconID == 313 \|\| spellInfo_1->SpellIconID == 2039) && (spellInfo_2->SpellIconID == 544 \|\| spellInfo_2->SpellIconID == 91) \|\|
1186	(spellInfo_2->SpellIconID == 313 \|\| spellInfo_2->SpellIconID == 2039) && (spellInfo_1->SpellIconID == 544 \|\| spellInfo_1->SpellIconID == 91) )
1187	return false;
1188	}
1189	// Detect Invisibility and Mana Shield (multi-family check)
1190	if( spellInfo_1->Id == 132 && spellInfo_2->SpellIconID == 209 && spellInfo_2->SpellVisual == 968 )
1191	return false;
1192	break;
1193	case SPELLFAMILY_WARRIOR:
1194	if( spellInfo_2->SpellFamilyName == SPELLFAMILY_WARRIOR )
1195	{
1196	// Rend and Deep Wound
1197	if( (spellInfo_1->SpellFamilyFlags & 0x20) && (spellInfo_2->SpellFamilyFlags & 0x1000000000LL) \|\|
1198	(spellInfo_2->SpellFamilyFlags & 0x20) && (spellInfo_1->SpellFamilyFlags & 0x1000000000LL) )
1199	return false;
1200
1201	// Battle Shout and Rampage
1202	if( (spellInfo_1->SpellIconID == 456 && spellInfo_2->SpellIconID == 2006) \|\|
1203	(spellInfo_2->SpellIconID == 456 && spellInfo_1->SpellIconID == 2006) )
1204	return false;
1205	}
1206
1207	// Hamstring -> Improved Hamstring (multi-family check)
1208	if( (spellInfo_1->SpellFamilyFlags & 2) && spellInfo_2->Id == 23694 )
1209	return false;
1210
1211	// Defensive Stance and Scroll of Protection (multi-family check)
1212	if( spellInfo_1->Id == 71 && spellInfo_2->SpellIconID == 276 && spellInfo_2->SpellVisual == 196 )
1213	return false;
1214
1215	// Bloodlust and Bloodthirst (multi-family check)
1216	if( spellInfo_2->Id == 2825 && spellInfo_1->SpellIconID == 38 && spellInfo_1->SpellVisual == 0 )
1217	return false;
1218
1219	break;
1220	case SPELLFAMILY_PRIEST:
1221	if( spellInfo_2->SpellFamilyName == SPELLFAMILY_PRIEST )
1222	{
1223	//Devouring Plague and Shadow Vulnerability
1224	if( (spellInfo_1->SpellFamilyFlags & 0x2000000) && (spellInfo_2->SpellFamilyFlags & 0x800000000LL) \|\|
1225	(spellInfo_2->SpellFamilyFlags & 0x2000000) && (spellInfo_1->SpellFamilyFlags & 0x800000000LL) )
1226	return false;
1227
1228	//StarShards and Shadow Word: Pain
1229	if( (spellInfo_1->SpellFamilyFlags & 0x200000) && (spellInfo_2->SpellFamilyFlags & 0x8000) \|\|
1230	(spellInfo_2->SpellFamilyFlags & 0x200000) && (spellInfo_1->SpellFamilyFlags & 0x8000) )
1231	return false;
1232	}
1233	break;
1234	case SPELLFAMILY_DRUID:
1235	if( spellInfo_2->SpellFamilyName == SPELLFAMILY_DRUID )
1236	{
1237	//Omen of Clarity and Blood Frenzy
1238	if( (spellInfo_1->SpellFamilyFlags == 0x0 && spellInfo_1->SpellIconID == 108) && (spellInfo_2->SpellFamilyFlags & 0x20000000000000LL) \|\|
1239	(spellInfo_2->SpellFamilyFlags == 0x0 && spellInfo_2->SpellIconID == 108) && (spellInfo_1->SpellFamilyFlags & 0x20000000000000LL) )
1240	return false;
1241
1242	// Tree of Life (Shapeshift) and 34123 Tree of Life (Passive)
1243	if ((spellId_1 == 33891 && spellId_2 == 34123) \|\|
1244	(spellId_2 == 33891 && spellId_1 == 34123))
1245	return false;
1246
1247	// Wrath of Elune and Nature's Grace
1248	if( spellInfo_1->Id == 16886 && spellInfo_2->Id == 46833 \|\| spellInfo_2->Id == 16886 && spellInfo_1->Id == 46833 )
1249	return false;
1250
1251	// Bear Rage (Feral T4 (2)) and Omen of Clarity
1252	if( spellInfo_1->Id == 16864 && spellInfo_2->Id == 37306 \|\| spellInfo_2->Id == 16864 && spellInfo_1->Id == 37306 )
1253	return false;
1254
1255	// Cat Energy (Feral T4 (2)) and Omen of Clarity
1256	if( spellInfo_1->Id == 16864 && spellInfo_2->Id == 37311 \|\| spellInfo_2->Id == 16864 && spellInfo_1->Id == 37311 )
1257	return false;
1258	}
1259
1260	// Leader of the Pack and Scroll of Stamina (multi-family check)
1261	if( spellInfo_1->Id == 24932 && spellInfo_2->SpellIconID == 312 && spellInfo_2->SpellVisual == 216 )
1262	return false;
1263
1264	// Dragonmaw Illusion (multi-family check)
1265	if (spellId_1 == 42016 && spellId_2 == 40216 )
1266	return false;
1267
1268	break;
1269	case SPELLFAMILY_ROGUE:
1270	if( spellInfo_2->SpellFamilyName == SPELLFAMILY_ROGUE )
1271	{
1272	// Master of Subtlety
1273	if (spellId_1 == 31665 && spellId_2 == 31666 \|\| spellId_1 == 31666 && spellId_2 == 31665 )
1274	return false;
1275	}
1276
1277	// Garrote -> Garrote-Silence (multi-family check)
1278	if( spellInfo_1->SpellIconID == 498 && spellInfo_2->SpellIconID == 498 && spellInfo_2->SpellVisual == 0 )
1279	return false;
1280	break;
1281	case SPELLFAMILY_HUNTER:
1282	if( spellInfo_2->SpellFamilyName == SPELLFAMILY_HUNTER )
1283	{
1284	// Rapid Fire & Quick Shots
1285	if( (spellInfo_1->SpellFamilyFlags & 0x20) && (spellInfo_2->SpellFamilyFlags & 0x20000000000LL) \|\|
1286	(spellInfo_2->SpellFamilyFlags & 0x20) && (spellInfo_1->SpellFamilyFlags & 0x20000000000LL) )
1287	return false;
1288
1289	// Serpent Sting & (Immolation/Explosive Trap Effect)
1290	if( (spellInfo_1->SpellFamilyFlags & 0x4) && (spellInfo_2->SpellFamilyFlags & 0x00000004000LL) \|\|
1291	(spellInfo_2->SpellFamilyFlags & 0x4) && (spellInfo_1->SpellFamilyFlags & 0x00000004000LL) )
1292	return false;
1293
1294	// Bestial Wrath
1295	if( spellInfo_1->SpellIconID == 1680 && spellInfo_2->SpellIconID == 1680 )
1296	return false;
1297	}
1298
1299	// Wing Clip -> Improved Wing Clip (multi-family check)
1300	if( (spellInfo_1->SpellFamilyFlags & 0x40) && spellInfo_2->Id == 19229 )
1301	return false;
1302
1303	// Concussive Shot and Imp. Concussive Shot (multi-family check)
1304	if( spellInfo_2->Id == 19410 && spellInfo_1->Id == 5116 )
1305	return false;
1306	break;
1307	case SPELLFAMILY_PALADIN:
1308	if( spellInfo_2->SpellFamilyName == SPELLFAMILY_PALADIN )
1309	{
1310	// Paladin Seals
1311	if( IsSealSpell(spellInfo_1) && IsSealSpell(spellInfo_2) )
1312	return true;
1313	}
1314	// Combustion and Fire Protection Aura (multi-family check)
1315	if( spellInfo_2->Id == 11129 && spellInfo_1->SpellIconID == 33 && spellInfo_1->SpellVisual == 321 )
1316	return false;
1317
1318	// *Sanctity Aura -> Unstable Currents and other (multi-family check)
1319	if( spellInfo_1->SpellIconID==502 && spellInfo_2->SpellFamilyName == SPELLFAMILY_GENERIC && spellInfo_2->SpellIconID==502 && spellInfo_2->SpellVisual==969 )
1320	return false;
1321
1322	// *Seal of Command and Band of Eternal Champion (multi-family check)
1323	if( spellInfo_1->SpellIconID==561 && spellInfo_1->SpellVisual==7992 && spellId_2 == 35081)
1324	return false;
1325	break;
1326	case SPELLFAMILY_SHAMAN:
1327	if( spellInfo_2->SpellFamilyName == SPELLFAMILY_SHAMAN )
1328	{
1329	// shaman shields
1330	if( IsElementalShield(spellInfo_1) && IsElementalShield(spellInfo_2) )
1331	return true;
1332
1333	// Windfury weapon
1334	if( spellInfo_1->SpellIconID==220 && spellInfo_2->SpellIconID==220 &&
1335	spellInfo_1->SpellFamilyFlags != spellInfo_2->SpellFamilyFlags )
1336	return false;
1337	}
1338	// Bloodlust and Bloodthirst (multi-family check)
1339	if( spellInfo_1->Id == 2825 && spellInfo_2->SpellIconID == 38 && spellInfo_2->SpellVisual == 0 )
1340	return false;
1341	break;
1342	default:
1343	break;
1344	}
1345
1346	// more generic checks
1347	if (spellInfo_1->SpellIconID == spellInfo_2->SpellIconID &&
1348	spellInfo_1->SpellIconID != 0 && spellInfo_2->SpellIconID != 0)
1349	{
1350	bool isModifier = false;
1351	for (int i = 0; i < 3; i++)
1352	{
1353	if (spellInfo_1->EffectApplyAuraName[i] == SPELL_AURA_ADD_FLAT_MODIFIER \|\|
1354	spellInfo_1->EffectApplyAuraName[i] == SPELL_AURA_ADD_PCT_MODIFIER \|\|
1355	spellInfo_2->EffectApplyAuraName[i] == SPELL_AURA_ADD_FLAT_MODIFIER \|\|
1356	spellInfo_2->EffectApplyAuraName[i] == SPELL_AURA_ADD_PCT_MODIFIER )
1357	isModifier = true;
1358	}
1359
1360	if (!isModifier)
1361	return true;
1362	}
1363
1364	if (IsRankSpellDueToSpell(spellInfo_1, spellId_2))
1365	return true;
1366
1367	if (spellInfo_1->SpellFamilyName == 0 \|\| spellInfo_2->SpellFamilyName == 0)
1368	return false;
1369
1370	if (spellInfo_1->SpellFamilyName != spellInfo_2->SpellFamilyName)
1371	return false;
1372
1373	for (int i = 0; i < 3; ++i)
1374	if (spellInfo_1->Effect[i] != spellInfo_2->Effect[i] \|\|
1375	spellInfo_1->EffectItemType[i] != spellInfo_2->EffectItemType[i] \|\|
1376	spellInfo_1->EffectMiscValue[i] != spellInfo_2->EffectMiscValue[i] \|\|
1377	spellInfo_1->EffectApplyAuraName[i] != spellInfo_2->EffectApplyAuraName[i])
1378	return false;
1379
1380	return true;
1381	}
1382
1383	bool SpellMgr::IsProfessionSpell(uint32 spellId)
1384	{
1385	SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId);
1386	if(!spellInfo)
1387	return false;
1388
1389	if(spellInfo->Effect[1] != SPELL_EFFECT_SKILL)
1390	return false;
1391
1392	uint32 skill = spellInfo->EffectMiscValue[1];
1393
1394	return IsProfessionSkill(skill);
1395	}
1396
1397	bool SpellMgr::IsPrimaryProfessionSpell(uint32 spellId)
1398	{
1399	SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId);
1400	if(!spellInfo)
1401	return false;
1402
1403	if(spellInfo->Effect[1] != SPELL_EFFECT_SKILL)
1404	return false;
1405
1406	uint32 skill = spellInfo->EffectMiscValue[1];
1407
1408	return IsPrimaryProfessionSkill(skill);
1409	}
1410
1411	bool SpellMgr::IsPrimaryProfessionFirstRankSpell(uint32 spellId) const
1412	{
1413	return IsPrimaryProfessionSpell(spellId) && GetSpellRank(spellId)==1;
1414	}
1415
1416	SpellEntry const* SpellMgr::SelectAuraRankForPlayerLevel(SpellEntry const* spellInfo, uint32 playerLevel) const
1417	{
1418	// ignore passive spells
1419	if(IsPassiveSpell(spellInfo->Id))
1420	return spellInfo;
1421
1422	bool needRankSelection = false;
1423	for(int i=0;i<3;i++)
1424	{
1425	if( IsPositiveEffect(spellInfo->Id, i) && (
1426	spellInfo->Effect[i] == SPELL_EFFECT_APPLY_AURA \|\|
1427	spellInfo->Effect[i] == SPELL_EFFECT_APPLY_AREA_AURA_PARTY
1428	) )
1429	{
1430	needRankSelection = true;
1431	break;
1432	}
1433	}
1434
1435	// not required
1436	if(!needRankSelection)
1437	return spellInfo;
1438
1439	for(uint32 nextSpellId = spellInfo->Id; nextSpellId != 0; nextSpellId = GetPrevSpellInChain(nextSpellId))
1440	{
1441	SpellEntry const *nextSpellInfo = sSpellStore.LookupEntry(nextSpellId);
1442	if(!nextSpellInfo)
1443	break;
1444
1445	// if found appropriate level
1446	if(playerLevel + 10 >= nextSpellInfo->spellLevel)
1447	return nextSpellInfo;
1448
1449	// one rank less then
1450	}
1451
1452	// not found
1453	return NULL;
1454	}
1455
1456	void SpellMgr::LoadSpellChains()
1457	{
1458	mSpellChains.clear(); // need for reload case
1459	mSpellChainsNext.clear(); // need for reload case
1460
1461	QueryResult *result = WorldDatabase.PQuery("SELECT spell_id, prev_spell, first_spell, rank, req_spell FROM spell_chain");
1462	if(result == NULL)
1463	{
1464	barGoLink bar( 1 );
1465	bar.step();
1466
1467	sLog.outString();
1468	sLog.outString( ">> Loaded 0 spell chain records" );
1469	sLog.outErrorDb("`spell_chains` table is empty!");
1470	return;
1471	}
1472
1473	uint32 count = 0;
1474
1475	barGoLink bar( result->GetRowCount() );
1476	do
1477	{
1478	bar.step();
1479	Field *fields = result->Fetch();
1480
1481	uint32 spell_id = fields[0].GetUInt32();
1482
1483	SpellChainNode node;
1484	node.prev = fields[1].GetUInt32();
1485	node.first = fields[2].GetUInt32();
1486	node.rank = fields[3].GetUInt8();
1487	node.req = fields[4].GetUInt32();
1488
1489	if(!sSpellStore.LookupEntry(spell_id))
1490	{
1491	sLog.outErrorDb("Spell %u listed in `spell_chain` does not exist",spell_id);
1492	continue;
1493	}
1494
1495	if(node.prev!=0 && !sSpellStore.LookupEntry(node.prev))
1496	{
1497	sLog.outErrorDb("Spell %u (prev: %u, first: %u, rank: %d, req: %u) listed in `spell_chain` has not existed previous rank spell.",
1498	spell_id,node.prev,node.first,node.rank,node.req);
1499	continue;
1500	}
1501
1502	if(!sSpellStore.LookupEntry(node.first))
1503	{
1504	sLog.outErrorDb("Spell %u (prev: %u, first: %u, rank: %d, req: %u) listed in `spell_chain` has not existing first rank spell.",
1505	spell_id,node.prev,node.first,node.rank,node.req);
1506	continue;
1507	}
1508
1509	// check basic spell chain data integrity (note: rank can be equal 0 or 1 for first/single spell)
1510	if( (spell_id == node.first) != (node.rank <= 1) \|\|
1511	(spell_id == node.first) != (node.prev == 0) \|\|
1512	(node.rank <= 1) != (node.prev == 0) )
1513	{
1514	sLog.outErrorDb("Spell %u (prev: %u, first: %u, rank: %d, req: %u) listed in `spell_chain` has not compatible chain data.",
1515	spell_id,node.prev,node.first,node.rank,node.req);
1516	continue;
1517	}
1518
1519	if(node.req!=0 && !sSpellStore.LookupEntry(node.req))
1520	{
1521	sLog.outErrorDb("Spell %u (prev: %u, first: %u, rank: %d, req: %u) listed in `spell_chain` has not existing required spell.",
1522	spell_id,node.prev,node.first,node.rank,node.req);
1523	continue;
1524	}
1525
1526	// talents not required data in spell chain for work, but must be checked if present for intergrity
1527	if(TalentSpellPos const* pos = GetTalentSpellPos(spell_id))
1528	{
1529	if(node.rank!=pos->rank+1)
1530	{
1531	sLog.outErrorDb("Talent %u (prev: %u, first: %u, rank: %d, req: %u) listed in `spell_chain` has wrong rank.",
1532	spell_id,node.prev,node.first,node.rank,node.req);
1533	continue;
1534	}
1535
1536	if(TalentEntry const* talentEntry = sTalentStore.LookupEntry(pos->talent_id))
1537	{
1538	if(node.first!=talentEntry->RankID[0])
1539	{
1540	sLog.outErrorDb("Talent %u (prev: %u, first: %u, rank: %d, req: %u) listed in `spell_chain` has wrong first rank spell.",
1541	spell_id,node.prev,node.first,node.rank,node.req);
1542	continue;
1543	}
1544
1545	if(node.rank > 1 && node.prev != talentEntry->RankID[node.rank-1-1])
1546	{
1547	sLog.outErrorDb("Talent %u (prev: %u, first: %u, rank: %d, req: %u) listed in `spell_chain` has wrong prev rank spell.",
1548	spell_id,node.prev,node.first,node.rank,node.req);
1549	continue;
1550	}
1551
1552	if(node.req!=talentEntry->DependsOnSpell)
1553	{
1554	sLog.outErrorDb("Talent %u (prev: %u, first: %u, rank: %d, req: %u) listed in `spell_chain` has wrong required spell.",
1555	spell_id,node.prev,node.first,node.rank,node.req);
1556	continue;
1557	}
1558	}
1559	}
1560
1561	mSpellChains[spell_id] = node;
1562
1563	if(node.prev)
1564	mSpellChainsNext.insert(SpellChainMapNext::value_type(node.prev,spell_id));
1565
1566	if(node.req)
1567	mSpellChainsNext.insert(SpellChainMapNext::value_type(node.req,spell_id));
1568
1569	++count;
1570	} while( result->NextRow() );
1571
1572	// additional integrity checks
1573	for(SpellChainMap::iterator i = mSpellChains.begin(); i != mSpellChains.end(); ++i)
1574	{
1575	if(i->second.prev)
1576	{
1577	SpellChainMap::iterator i_prev = mSpellChains.find(i->second.prev);
1578	if(i_prev == mSpellChains.end())
1579	{
1580	sLog.outErrorDb("Spell %u (prev: %u, first: %u, rank: %d, req: %u) listed in `spell_chain` has not found previous rank spell in table.",
1581	i->first,i->second.prev,i->second.first,i->second.rank,i->second.req);
1582	}
1583	else if( i_prev->second.first != i->second.first )
1584	{
1585	sLog.outErrorDb("Spell %u (prev: %u, first: %u, rank: %d, req: %u) listed in `spell_chain` has different first spell in chain compared to previous rank spell (prev: %u, first: %u, rank: %d, req: %u).",
1586	i->first,i->second.prev,i->second.first,i->second.rank,i->second.req,
1587	i_prev->second.prev,i_prev->second.first,i_prev->second.rank,i_prev->second.req);
1588	}
1589	else if( i_prev->second.rank+1 != i->second.rank )
1590	{
1591	sLog.outErrorDb("Spell %u (prev: %u, first: %u, rank: %d, req: %u) listed in `spell_chain` has different rank compared to previous rank spell (prev: %u, first: %u, rank: %d, req: %u).",
1592	i->first,i->second.prev,i->second.first,i->second.rank,i->second.req,
1593	i_prev->second.prev,i_prev->second.first,i_prev->second.rank,i_prev->second.req);
1594	}
1595	}
1596
1597	if(i->second.req)
1598	{
1599	SpellChainMap::iterator i_req = mSpellChains.find(i->second.req);
1600	if(i_req == mSpellChains.end())
1601	{
1602	sLog.outErrorDb("Spell %u (prev: %u, first: %u, rank: %d, req: %u) listed in `spell_chain` has not found required rank spell in table.",
1603	i->first,i->second.prev,i->second.first,i->second.rank,i->second.req);
1604	}
1605	else if( i_req->second.first == i->second.first )
1606	{
1607	sLog.outErrorDb("Spell %u (prev: %u, first: %u, rank: %d, req: %u) listed in `spell_chain` has required rank spell from same spell chain (prev: %u, first: %u, rank: %d, req: %u).",
1608	i->first,i->second.prev,i->second.first,i->second.rank,i->second.req,
1609	i_req->second.prev,i_req->second.first,i_req->second.rank,i_req->second.req);
1610	}
1611	else if( i_req->second.req )
1612	{
1613	sLog.outErrorDb("Spell %u (prev: %u, first: %u, rank: %d, req: %u) listed in `spell_chain` has required rank spell with required spell (prev: %u, first: %u, rank: %d, req: %u).",
1614	i->first,i->second.prev,i->second.first,i->second.rank,i->second.req,
1615	i_req->second.prev,i_req->second.first,i_req->second.rank,i_req->second.req);
1616	}
1617	}
1618	}
1619
1620	delete result;
1621
1622	sLog.outString();
1623	sLog.outString( ">> Loaded %u spell chain records", count );
1624	}
1625
1626	void SpellMgr::LoadSpellLearnSkills()
1627	{
1628	mSpellLearnSkills.clear(); // need for reload case
1629
1630	// search auto-learned skills and add its to map also for use in unlearn spells/talents
1631	uint32 dbc_count = 0;
1632	for(uint32 spell = 0; spell < sSpellStore.GetNumRows(); ++spell)
1633	{
1634	SpellEntry const* entry = sSpellStore.LookupEntry(spell);
1635
1636	if(!entry)
1637	continue;
1638
1639	for(int i = 0; i < 3; ++i)
1640	{
1641	if(entry->Effect[i]==SPELL_EFFECT_SKILL)
1642	{
1643	SpellLearnSkillNode dbc_node;
1644	dbc_node.skill = entry->EffectMiscValue[i];
1645	if ( dbc_node.skill != SKILL_RIDING )
1646	dbc_node.value = 1;
1647	else
1648	dbc_node.value = (entry->EffectBasePoints[i]+1)*75;
1649	dbc_node.maxvalue = (entry->EffectBasePoints[i]+1)*75;
1650
1651	SpellLearnSkillNode const* db_node = GetSpellLearnSkill(spell);
1652
1653	mSpellLearnSkills[spell] = dbc_node;
1654	++dbc_count;
1655	break;
1656	}
1657	}
1658	}
1659
1660	sLog.outString();
1661	sLog.outString( ">> Loaded %u Spell Learn Skills from DBC", dbc_count );
1662	}
1663
1664	void SpellMgr::LoadSpellLearnSpells()
1665	{
1666	mSpellLearnSpells.clear(); // need for reload case
1667
1668	QueryResult *result = WorldDatabase.PQuery("SELECT entry, SpellID FROM spell_learn_spell");
1669	if(!result)
1670	{
1671	barGoLink bar( 1 );
1672	bar.step();
1673
1674	sLog.outString();
1675	sLog.outString( ">> Loaded 0 spell learn spells" );
1676	sLog.outErrorDb("`spell_learn_spell` table is empty!");
1677	return;
1678	}
1679
1680	uint32 count = 0;
1681
1682	barGoLink bar( result->GetRowCount() );
1683	do
1684	{
1685	bar.step();
1686	Field *fields = result->Fetch();
1687
1688	uint32 spell_id = fields[0].GetUInt32();
1689
1690	SpellLearnSpellNode node;
1691	node.spell = fields[1].GetUInt32();
1692	node.autoLearned= false;
1693
1694	if(!sSpellStore.LookupEntry(spell_id))
1695	{
1696	sLog.outErrorDb("Spell %u listed in `spell_learn_spell` does not exist",spell_id);
1697	continue;
1698	}
1699
1700	if(!sSpellStore.LookupEntry(node.spell))
1701	{
1702	sLog.outErrorDb("Spell %u listed in `spell_learn_spell` does not exist",node.spell);
1703	continue;
1704	}
1705
1706	mSpellLearnSpells.insert(SpellLearnSpellMap::value_type(spell_id,node));
1707
1708	++count;
1709	} while( result->NextRow() );
1710
1711	delete result;
1712
1713	// search auto-learned spells and add its to map also for use in unlearn spells/talents
1714	uint32 dbc_count = 0;
1715	for(uint32 spell = 0; spell < sSpellStore.GetNumRows(); ++spell)
1716	{
1717	SpellEntry const* entry = sSpellStore.LookupEntry(spell);
1718
1719	if(!entry)
1720	continue;
1721
1722	for(int i = 0; i < 3; ++i)
1723	{
1724	if(entry->Effect[i]==SPELL_EFFECT_LEARN_SPELL)
1725	{
1726	SpellLearnSpellNode dbc_node;
1727	dbc_node.spell = entry->EffectTriggerSpell[i];
1728	dbc_node.autoLearned = true;
1729
1730	SpellLearnSpellMap::const_iterator db_node_begin = GetBeginSpellLearnSpell(spell);
1731	SpellLearnSpellMap::const_iterator db_node_end = GetEndSpellLearnSpell(spell);
1732
1733	bool found = false;
1734	for(SpellLearnSpellMap::const_iterator itr = db_node_begin; itr != db_node_end; ++itr)
1735	{
1736	if(itr->second.spell == dbc_node.spell)
1737	{
1738	sLog.outErrorDb("Spell %u auto-learn spell %u in spell.dbc then the record in `spell_learn_spell` is redundant, please fix DB.",
1739	spell,dbc_node.spell);
1740	found = true;
1741	break;
1742	}
1743	}
1744
1745	if(!found) // add new spell-spell pair if not found
1746	{
1747	mSpellLearnSpells.insert(SpellLearnSpellMap::value_type(spell,dbc_node));
1748	++dbc_count;
1749	}
1750	}
1751	}
1752	}
1753
1754	sLog.outString();
1755	sLog.outString( ">> Loaded %u spell learn spells + %u found in DBC", count, dbc_count );
1756	}
1757
1758	void SpellMgr::LoadSpellScriptTarget()
1759	{
1760	mSpellScriptTarget.clear(); // need for reload case
1761
1762	uint32 count = 0;
1763
1764	QueryResult *result = WorldDatabase.Query("SELECT entry,type,targetEntry FROM spell_script_target");
1765
1766	if(!result)
1767	{
1768	barGoLink bar(1);
1769
1770	bar.step();
1771
1772	sLog.outString();
1773	sLog.outErrorDb(">> Loaded 0 SpellScriptTarget. DB table `spell_script_target` is empty.");
1774	return;
1775	}
1776
1777	barGoLink bar(result->GetRowCount());
1778
1779	do
1780	{
1781	Field *fields = result->Fetch();
1782	bar.step();
1783
1784	uint32 spellId = fields[0].GetUInt32();
1785	uint32 type = fields[1].GetUInt32();
1786	uint32 targetEntry = fields[2].GetUInt32();
1787
1788	SpellEntry const* spellProto = sSpellStore.LookupEntry(spellId);
1789
1790	if(!spellProto)
1791	{
1792	sLog.outErrorDb("Table `spell_script_target`: spellId %u listed for TargetEntry %u does not exist.",spellId,targetEntry);
1793	continue;
1794	}
1795
1796	bool targetfound = false;
1797	for(int i = 0; i <3; ++i)
1798	{
1799	if( spellProto->EffectImplicitTargetA[i]==TARGET_SCRIPT \|\|
1800	spellProto->EffectImplicitTargetB[i]==TARGET_SCRIPT \|\|
1801	spellProto->EffectImplicitTargetA[i]==TARGET_SCRIPT_COORDINATES \|\|
1802	spellProto->EffectImplicitTargetB[i]==TARGET_SCRIPT_COORDINATES )
1803	{
1804	targetfound = true;
1805	break;
1806	}
1807	}
1808	if(!targetfound)
1809	{
1810	sLog.outErrorDb("Table `spell_script_target`: spellId %u listed for TargetEntry %u does not have any implicit target TARGET_SCRIPT(38) or TARGET_SCRIPT_COORDINATES (46).",spellId,targetEntry);
1811	continue;
1812	}
1813
1814	if( type >= MAX_SPELL_TARGET_TYPE )
1815	{
1816	sLog.outErrorDb("Table `spell_script_target`: target type %u for TargetEntry %u is incorrect.",type,targetEntry);
1817	continue;
1818	}
1819
1820	switch(type)
1821	{
1822	case SPELL_TARGET_TYPE_GAMEOBJECT:
1823	{
1824	if( targetEntry==0 )
1825	break;
1826
1827	if(!sGOStorage.LookupEntry<GameObjectInfo>(targetEntry))
1828	{
1829	sLog.outErrorDb("Table `spell_script_target`: gameobject template entry %u does not exist.",targetEntry);
1830	continue;
1831	}
1832	break;
1833	}
1834	default:
1835	{
1836	if( targetEntry==0 )
1837	{
1838	sLog.outErrorDb("Table `spell_script_target`: target entry == 0 for not GO target type (%u).",type);
1839	continue;
1840	}
1841	if(!sCreatureStorage.LookupEntry<CreatureInfo>(targetEntry))
1842	{
1843	sLog.outErrorDb("Table `spell_script_target`: creature template entry %u does not exist.",targetEntry);
1844	continue;
1845	}
1846	const CreatureInfo* cInfo = sCreatureStorage.LookupEntry<CreatureInfo>(targetEntry);
1847
1848	if(spellId == 30427 && !cInfo->SkinLootId)
1849	{
1850	sLog.outErrorDb("Table `spell_script_target` has creature %u as a target of spellid 30427, but this creature has no skinlootid. Gas extraction will not work!", cInfo->Entry);
1851	continue;
1852	}
1853	break;
1854	}
1855	}
1856
1857	mSpellScriptTarget.insert(SpellScriptTarget::value_type(spellId,SpellTargetEntry(SpellTargetType(type),targetEntry)));
1858
1859	++count;
1860	} while (result->NextRow());
1861
1862	delete result;
1863
1864	// Check all spells
1865	/* Disabled (lot errors at this moment)
1866	for(uint32 i = 1; i < sSpellStore.nCount; ++i)
1867	{
1868	SpellEntry const * spellInfo = sSpellStore.LookupEntry(i);
1869	if(!spellInfo)
1870	continue;
1871
1872	bool found = false;
1873	for(int j=0; j<3; ++j)
1874	{
1875	if( spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT \|\| spellInfo->EffectImplicitTargetA[j] != TARGET_SELF && spellInfo->EffectImplicitTargetB[j] == TARGET_SCRIPT )
1876	{
1877	SpellScriptTarget::const_iterator lower = spellmgr.GetBeginSpellScriptTarget(spellInfo->Id);
1878	SpellScriptTarget::const_iterator upper = spellmgr.GetEndSpellScriptTarget(spellInfo->Id);
1879	if(lower==upper)
1880	{
1881	sLog.outErrorDb("Spell (ID: %u) has effect EffectImplicitTargetA/EffectImplicitTargetB = %u (TARGET_SCRIPT), but does not have record in `spell_script_target`",spellInfo->Id,TARGET_SCRIPT);
1882	break; // effects of spell
1883	}
1884	}
1885	}
1886	}
1887	*/
1888
1889	sLog.outString();
1890	sLog.outString(">> Loaded %u Spell Script Targets", count);
1891	}
1892
1893	void SpellMgr::LoadSpellPetAuras()
1894	{
1895	mSpellPetAuraMap.clear(); // need for reload case
1896
1897	uint32 count = 0;
1898
1899	// 0 1 2
1900	QueryResult *result = WorldDatabase.Query("SELECT spell, pet, aura FROM spell_pet_auras");
1901	if( !result )
1902	{
1903
1904	barGoLink bar( 1 );
1905
1906	bar.step();
1907
1908	sLog.outString();
1909	sLog.outString( ">> Loaded %u spell pet auras", count );
1910	return;
1911	}
1912
1913	barGoLink bar( result->GetRowCount() );
1914
1915	do
1916	{
1917	Field *fields = result->Fetch();
1918
1919	bar.step();
1920
1921	uint16 spell = fields[0].GetUInt16();
1922	uint16 pet = fields[1].GetUInt16();
1923	uint16 aura = fields[2].GetUInt16();
1924
1925	SpellPetAuraMap::iterator itr = mSpellPetAuraMap.find(spell);
1926	if(itr != mSpellPetAuraMap.end())
1927	{
1928	itr->second.AddAura(pet, aura);
1929	}
1930	else
1931	{
1932	SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell);
1933	if (!spellInfo)
1934	{
1935	sLog.outErrorDb("Spell %u listed in `spell_pet_auras` does not exist", spell);
1936	continue;
1937	}
1938	int i = 0;
1939	for(; i < 3; ++i)
1940	if((spellInfo->Effect[i] == SPELL_EFFECT_APPLY_AURA &&
1941	spellInfo->EffectApplyAuraName[i] == SPELL_AURA_DUMMY) \|\|
1942	spellInfo->Effect[i] == SPELL_EFFECT_DUMMY)
1943	break;
1944
1945	if(i == 3)
1946	{
1947	sLog.outError("Spell %u listed in `spell_pet_auras` does not have dummy aura or dummy effect", spell);
1948	continue;
1949	}
1950
1951	SpellEntry const* spellInfo2 = sSpellStore.LookupEntry(aura);
1952	if (!spellInfo2)
1953	{
1954	sLog.outErrorDb("Aura %u listed in `spell_pet_auras` does not exist", aura);
1955	continue;
1956	}
1957
1958	PetAura pa(pet, aura, spellInfo->EffectImplicitTargetA[i] == TARGET_PET, spellInfo->EffectBasePoints[i] + spellInfo->EffectBaseDice[i]);
1959	mSpellPetAuraMap[spell] = pa;
1960	}
1961
1962	++count;
1963	} while( result->NextRow() );
1964
1965	delete result;
1966
1967	sLog.outString();
1968	sLog.outString( ">> Loaded %u spell pet auras", count );
1969	}
1970
1971	/// Some checks for spells, to prevent adding depricated/broken spells for trainers, spell book, etc
1972	bool SpellMgr::IsSpellValid(SpellEntry const* spellInfo, Player* pl, bool msg)
1973	{
1974	// not exist
1975	if(!spellInfo)
1976	return false;
1977
1978	bool need_check_reagents = false;
1979
1980	// check effects
1981	for(int i=0; i<3; ++i)
1982	{
1983	switch(spellInfo->Effect[i])
1984	{
1985	case 0:
1986	continue;
1987
1988	// craft spell for crafting non-existed item (break client recipes list show)
1989	case SPELL_EFFECT_CREATE_ITEM:
1990	{
1991	if(!ObjectMgr::GetItemPrototype( spellInfo->EffectItemType[i] ))
1992	{
1993	if(msg)
1994	{
1995	if(pl)
1996	ChatHandler(pl).PSendSysMessage("Craft spell %u create not-exist in DB item (Entry: %u) and then...",spellInfo->Id,spellInfo->EffectItemType[i]);
1997	else
1998	sLog.outErrorDb("Craft spell %u create not-exist in DB item (Entry: %u) and then...",spellInfo->Id,spellInfo->EffectItemType[i]);
1999	}
2000	return false;
2001	}
2002
2003	need_check_reagents = true;
2004	break;
2005	}
2006	case SPELL_EFFECT_LEARN_SPELL:
2007	{
2008	SpellEntry const* spellInfo2 = sSpellStore.LookupEntry(spellInfo->EffectTriggerSpell[0]);
2009	if( !IsSpellValid(spellInfo2,pl,msg) )
2010	{
2011	if(msg)
2012	{
2013	if(pl)
2014	ChatHandler(pl).PSendSysMessage("Spell %u learn to broken spell %u, and then...",spellInfo->Id,spellInfo->EffectTriggerSpell[0]);
2015	else
2016	sLog.outErrorDb("Spell %u learn to invalid spell %u, and then...",spellInfo->Id,spellInfo->EffectTriggerSpell[0]);
2017	}
2018	return false;
2019	}
2020	break;
2021	}
2022	}
2023	}
2024
2025	if(need_check_reagents)
2026	{
2027	for(int j = 0; j < 8; ++j)
2028	{
2029	if(spellInfo->Reagent[j] > 0 && !ObjectMgr::GetItemPrototype( spellInfo->Reagent[j] ))
2030	{
2031	if(msg)
2032	{
2033	if(pl)
2034	ChatHandler(pl).PSendSysMessage("Craft spell %u have not-exist reagent in DB item (Entry: %u) and then...",spellInfo->Id,spellInfo->Reagent[j]);
2035	else
2036	sLog.outErrorDb("Craft spell %u have not-exist reagent in DB item (Entry: %u) and then...",spellInfo->Id,spellInfo->Reagent[j]);
2037	}
2038	return false;
2039	}
2040	}
2041	}
2042
2043	return true;
2044	}
2045
2046	bool IsSpellAllowedInLocation(SpellEntry const *spellInfo,uint32 map_id,uint32 zone_id,uint32 area_id)
2047	{
2048	// normal case
2049	if( spellInfo->AreaId && spellInfo->AreaId != zone_id && spellInfo->AreaId != area_id )
2050	return false;
2051
2052	// elixirs (all area dependent elixirs have family SPELLFAMILY_POTION, use this for speedup)
2053	if(spellInfo->SpellFamilyName==SPELLFAMILY_POTION)
2054	{
2055	if(uint32 mask = spellmgr.GetSpellElixirMask(spellInfo->Id))
2056	{
2057	if(mask & ELIXIR_UNSTABLE_MASK)
2058	{
2059	// in the Blade's Edge Mountains Plateaus and Gruul's Lair.
2060	return zone_id ==3522 \|\| map_id==565;
2061	}
2062	if(mask & ELIXIR_UNSTABLE_MASK)
2063	{
2064	// in Tempest Keep, Serpentshrine Cavern, Caverns of Time: Mount Hyjal, Black Temple
2065	// TODO: and the Sunwell Plateau
2066	if(zone_id ==3607 \|\| map_id==534 \|\| map_id==564)
2067	return true;
2068
2069	MapEntry const* mapEntry = sMapStore.LookupEntry(map_id);
2070	if(!mapEntry)
2071	return false;
2072
2073	return mapEntry->multimap_id==206;
2074	}
2075
2076	// elixirs not have another limitations
2077	return true;
2078	}
2079	}
2080
2081	// special cases zone check (maps checked by multimap common id)
2082	switch(spellInfo->Id)
2083	{
2084	case 41618:
2085	case 41620:
2086	{
2087	MapEntry const* mapEntry = sMapStore.LookupEntry(map_id);
2088	if(!mapEntry)
2089	return false;
2090
2091	return mapEntry->multimap_id==206;
2092	}
2093
2094	case 41617:
2095	case 41619:
2096	{
2097	MapEntry const* mapEntry = sMapStore.LookupEntry(map_id);
2098	if(!mapEntry)
2099	return false;
2100
2101	return mapEntry->multimap_id==207;
2102	}
2103	// Dragonmaw Illusion
2104	case 40216:
2105	case 42016:
2106	{
2107	if ( area_id != 3759 && area_id != 3966 && area_id != 3939 )
2108	return false;
2109	break;
2110	}
2111	}
2112
2113	return true;
2114	}
2115
2116	void SpellMgr::LoadSkillLineAbilityMap()
2117	{
2118	mSkillLineAbilityMap.clear();
2119
2120	uint32 count = 0;
2121
2122	for (uint32 i = 0; i < sSkillLineAbilityStore.GetNumRows(); i++)
2123	{
2124	SkillLineAbilityEntry const *SkillInfo = sSkillLineAbilityStore.LookupEntry(i);
2125	if(!SkillInfo)
2126	continue;
2127
2128	mSkillLineAbilityMap.insert(SkillLineAbilityMap::value_type(SkillInfo->spellId,SkillInfo));
2129	++count;
2130	}
2131
2132	sLog.outString();
2133	sLog.outString(">> Loaded %u SkillLineAbility MultiMap", count);
2134	}
2135
2136	DiminishingGroup GetDiminishingReturnsGroupForSpell(SpellEntry const* spellproto, bool triggered)
2137	{
2138	// Explicit Diminishing Groups
2139	switch(spellproto->SpellFamilyName)
2140	{
2141	case SPELLFAMILY_MAGE:
2142	{
2143	// Polymorph
2144	if ((spellproto->SpellFamilyFlags & 0x00001000000LL) && spellproto->EffectApplyAuraName[0]==SPELL_AURA_MOD_CONFUSE)
2145	return DIMINISHING_POLYMORPH;
2146	break;
2147	}
2148	case SPELLFAMILY_ROGUE:
2149	{
2150	// Kidney Shot
2151	if (spellproto->SpellFamilyFlags & 0x00000200000LL)
2152	return DIMINISHING_KIDNEYSHOT;
2153	// Blind
2154	else if (spellproto->SpellFamilyFlags & 0x00001000000LL)
2155	return DIMINISHING_BLIND_CYCLONE;
2156	break;
2157	}
2158	case SPELLFAMILY_WARLOCK:
2159	{
2160	// Death Coil
2161	if (spellproto->SpellFamilyFlags & 0x00000080000LL)
2162	return DIMINISHING_DEATHCOIL;
2163	// Fear
2164	else if (spellproto->SpellFamilyFlags & 0x40840000000LL)
2165	return DIMINISHING_WARLOCK_FEAR;
2166	// Curses/etc
2167	else if (spellproto->SpellFamilyFlags & 0x00080000000LL)
2168	return DIMINISHING_LIMITONLY;
2169	break;
2170	}
2171	case SPELLFAMILY_DRUID:
2172	{
2173	// Cyclone
2174	if (spellproto->SpellFamilyFlags & 0x02000000000LL)
2175	return DIMINISHING_BLIND_CYCLONE;
2176	break;
2177	}
2178	case SPELLFAMILY_WARRIOR:
2179	{
2180	// Hamstring - limit duration to 10s in PvP
2181	if (spellproto->SpellFamilyFlags & 0x00000000002LL)
2182	return DIMINISHING_LIMITONLY;
2183	break;
2184	}
2185	default:
2186	break;
2187	}
2188
2189	// Get by mechanic
2190	for (uint8 i=0;i<3;++i)
2191	{
2192	if (spellproto->Mechanic == MECHANIC_STUN \|\| spellproto->EffectMechanic[i] == MECHANIC_STUN)
2193	return triggered ? DIMINISHING_TRIGGER_STUN : DIMINISHING_CONTROL_STUN;
2194	else if (spellproto->Mechanic == MECHANIC_SLEEP \|\| spellproto->EffectMechanic[i] == MECHANIC_SLEEP)
2195	return DIMINISHING_SLEEP;
2196	else if (spellproto->Mechanic == MECHANIC_ROOT \|\| spellproto->EffectMechanic[i] == MECHANIC_ROOT)
2197	return triggered ? DIMINISHING_TRIGGER_ROOT : DIMINISHING_CONTROL_ROOT;
2198	else if (spellproto->Mechanic == MECHANIC_FEAR \|\| spellproto->EffectMechanic[i] == MECHANIC_FEAR)
2199	return DIMINISHING_FEAR;
2200	else if (spellproto->Mechanic == MECHANIC_CHARM \|\| spellproto->EffectMechanic[i] == MECHANIC_CHARM)
2201	return DIMINISHING_CHARM;
2202	else if (spellproto->Mechanic == MECHANIC_SILENCE \|\| spellproto->EffectMechanic[i] == MECHANIC_SILENCE)
2203	return DIMINISHING_SILENCE;
2204	else if (spellproto->Mechanic == MECHANIC_DISARM \|\| spellproto->EffectMechanic[i] == MECHANIC_DISARM)
2205	return DIMINISHING_DISARM;
2206	else if (spellproto->Mechanic == MECHANIC_FREEZE \|\| spellproto->EffectMechanic[i] == MECHANIC_FREEZE)
2207	return DIMINISHING_FREEZE;
2208	else if (spellproto->Mechanic == MECHANIC_KNOCKOUT\|\| spellproto->EffectMechanic[i] == MECHANIC_KNOCKOUT \|\|
2209	spellproto->Mechanic == MECHANIC_SAPPED \|\| spellproto->EffectMechanic[i] == MECHANIC_SAPPED)
2210	return DIMINISHING_KNOCKOUT;
2211	else if (spellproto->Mechanic == MECHANIC_BANISH \|\| spellproto->EffectMechanic[i] == MECHANIC_BANISH)
2212	return DIMINISHING_BANISH;
2213	}
2214
2215	return DIMINISHING_NONE;
2216	}
2217
2218	bool IsDiminishingReturnsGroupDurationLimited(DiminishingGroup group)
2219	{
2220	switch(group)
2221	{
2222	case DIMINISHING_CONTROL_STUN:
2223	case DIMINISHING_TRIGGER_STUN:
2224	case DIMINISHING_KIDNEYSHOT:
2225	case DIMINISHING_SLEEP:
2226	case DIMINISHING_CONTROL_ROOT:
2227	case DIMINISHING_TRIGGER_ROOT:
2228	case DIMINISHING_FEAR:
2229	case DIMINISHING_WARLOCK_FEAR:
2230	case DIMINISHING_CHARM:
2231	case DIMINISHING_POLYMORPH:
2232	case DIMINISHING_FREEZE:
2233	case DIMINISHING_KNOCKOUT:
2234	case DIMINISHING_BLIND_CYCLONE:
2235	case DIMINISHING_BANISH:
2236	case DIMINISHING_LIMITONLY:
2237	return true;
2238	}
2239	return false;
2240	}
2241
2242	DiminishingReturnsType GetDiminishingReturnsGroupType(DiminishingGroup group)
2243	{
2244	switch(group)
2245	{
2246	case DIMINISHING_BLIND_CYCLONE:
2247	case DIMINISHING_CONTROL_STUN:
2248	case DIMINISHING_TRIGGER_STUN:
2249	case DIMINISHING_KIDNEYSHOT:
2250	return DRTYPE_ALL;
2251	case DIMINISHING_SLEEP:
2252	case DIMINISHING_CONTROL_ROOT:
2253	case DIMINISHING_TRIGGER_ROOT:
2254	case DIMINISHING_FEAR:
2255	case DIMINISHING_CHARM:
2256	case DIMINISHING_POLYMORPH:
2257	case DIMINISHING_SILENCE:
2258	case DIMINISHING_DISARM:
2259	case DIMINISHING_DEATHCOIL:
2260	case DIMINISHING_FREEZE:
2261	case DIMINISHING_BANISH:
2262	case DIMINISHING_WARLOCK_FEAR:
2263	case DIMINISHING_KNOCKOUT:
2264	return DRTYPE_PLAYER;
2265	}
2266
2267	return DRTYPE_NONE;
2268	}

Note: See TracBrowser for help on using the browser.

Context Navigation

root/trunk/src/game/SpellMgr.cpp @ 40

Download in other formats: