[7986] MaNGOS 0.13 release.
[getmangos.git] / src / game / Spell.cpp
blobcfdb2978be189c09732fd326bf3a0b2490168224
1 /*
2 * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
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.
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.
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
19 #include "Common.h"
20 #include "Database/DatabaseEnv.h"
21 #include "WorldPacket.h"
22 #include "WorldSession.h"
23 #include "GridNotifiers.h"
24 #include "GridNotifiersImpl.h"
25 #include "Opcodes.h"
26 #include "Log.h"
27 #include "UpdateMask.h"
28 #include "World.h"
29 #include "ObjectMgr.h"
30 #include "SpellMgr.h"
31 #include "Player.h"
32 #include "Pet.h"
33 #include "Unit.h"
34 #include "Spell.h"
35 #include "DynamicObject.h"
36 #include "Group.h"
37 #include "UpdateData.h"
38 #include "MapManager.h"
39 #include "ObjectAccessor.h"
40 #include "CellImpl.h"
41 #include "Policies/SingletonImp.h"
42 #include "SharedDefines.h"
43 #include "LootMgr.h"
44 #include "VMapFactory.h"
45 #include "BattleGround.h"
46 #include "Util.h"
48 #define SPELL_CHANNEL_UPDATE_INTERVAL (1 * IN_MILISECONDS)
50 extern pEffect SpellEffects[TOTAL_SPELL_EFFECTS];
52 class PrioritizeManaPlayerWraper
54 friend struct PrioritizeMana;
56 public:
57 explicit PrioritizeManaPlayerWraper(Player* player) : player(player)
59 uint32 maxmana = player->GetMaxPower(POWER_MANA);
60 percentMana = maxmana ? player->GetPower(POWER_MANA) * 100 / maxmana : 101;
62 Player* getPlayer() const { return player; }
63 private:
64 Player* player;
65 uint32 percentMana;
68 struct PrioritizeMana
70 int operator()( PrioritizeManaPlayerWraper const& x, PrioritizeManaPlayerWraper const& y ) const
72 return x.percentMana < y.percentMana;
77 bool IsQuestTameSpell(uint32 spellId)
79 SpellEntry const *spellproto = sSpellStore.LookupEntry(spellId);
80 if (!spellproto) return false;
82 return spellproto->Effect[0] == SPELL_EFFECT_THREAT
83 && spellproto->Effect[1] == SPELL_EFFECT_APPLY_AURA && spellproto->EffectApplyAuraName[1] == SPELL_AURA_DUMMY;
86 SpellCastTargets::SpellCastTargets()
88 m_unitTarget = NULL;
89 m_itemTarget = NULL;
90 m_GOTarget = NULL;
92 m_unitTargetGUID = 0;
93 m_GOTargetGUID = 0;
94 m_CorpseTargetGUID = 0;
95 m_itemTargetGUID = 0;
96 m_itemTargetEntry = 0;
98 m_srcX = m_srcY = m_srcZ = m_destX = m_destY = m_destZ = 0;
99 m_strTarget = "";
100 m_targetMask = 0;
103 SpellCastTargets::~SpellCastTargets()
107 void SpellCastTargets::setUnitTarget(Unit *target)
109 if (!target)
110 return;
112 m_destX = target->GetPositionX();
113 m_destY = target->GetPositionY();
114 m_destZ = target->GetPositionZ();
115 m_unitTarget = target;
116 m_unitTargetGUID = target->GetGUID();
117 m_targetMask |= TARGET_FLAG_UNIT;
120 void SpellCastTargets::setDestination(float x, float y, float z)
122 m_destX = x;
123 m_destY = y;
124 m_destZ = z;
125 m_targetMask |= TARGET_FLAG_DEST_LOCATION;
128 void SpellCastTargets::setSource(float x, float y, float z)
130 m_srcX = x;
131 m_srcY = y;
132 m_srcZ = z;
133 m_targetMask |= TARGET_FLAG_SOURCE_LOCATION;
136 void SpellCastTargets::setGOTarget(GameObject *target)
138 m_GOTarget = target;
139 m_GOTargetGUID = target->GetGUID();
140 // m_targetMask |= TARGET_FLAG_OBJECT;
143 void SpellCastTargets::setItemTarget(Item* item)
145 if(!item)
146 return;
148 m_itemTarget = item;
149 m_itemTargetGUID = item->GetGUID();
150 m_itemTargetEntry = item->GetEntry();
151 m_targetMask |= TARGET_FLAG_ITEM;
154 void SpellCastTargets::setCorpseTarget(Corpse* corpse)
156 m_CorpseTargetGUID = corpse->GetGUID();
159 void SpellCastTargets::Update(Unit* caster)
161 m_GOTarget = m_GOTargetGUID ? caster->GetMap()->GetGameObject(m_GOTargetGUID) : NULL;
162 m_unitTarget = m_unitTargetGUID ?
163 ( m_unitTargetGUID == caster->GetGUID() ? caster : ObjectAccessor::GetUnit(*caster, m_unitTargetGUID) ) :
164 NULL;
166 m_itemTarget = NULL;
167 if(caster->GetTypeId() == TYPEID_PLAYER)
169 if(m_targetMask & TARGET_FLAG_ITEM)
170 m_itemTarget = ((Player*)caster)->GetItemByGuid(m_itemTargetGUID);
171 else
173 Player* pTrader = ((Player*)caster)->GetTrader();
174 if(pTrader && m_itemTargetGUID < TRADE_SLOT_COUNT)
175 m_itemTarget = pTrader->GetItemByPos(pTrader->GetItemPosByTradeSlot(m_itemTargetGUID));
177 if(m_itemTarget)
178 m_itemTargetEntry = m_itemTarget->GetEntry();
182 bool SpellCastTargets::read ( WorldPacket * data, Unit *caster )
184 if(data->rpos() + 4 > data->size())
185 return false;
187 *data >> m_targetMask;
189 if(m_targetMask == TARGET_FLAG_SELF)
191 m_destX = caster->GetPositionX();
192 m_destY = caster->GetPositionY();
193 m_destZ = caster->GetPositionZ();
194 m_unitTarget = caster;
195 m_unitTargetGUID = caster->GetGUID();
196 return true;
199 // TARGET_FLAG_UNK2 is used for non-combat pets, maybe other?
200 if( m_targetMask & ( TARGET_FLAG_UNIT | TARGET_FLAG_UNK2 ))
201 if(!data->readPackGUID(m_unitTargetGUID))
202 return false;
204 if( m_targetMask & ( TARGET_FLAG_OBJECT ))
205 if(!data->readPackGUID(m_GOTargetGUID))
206 return false;
208 if(( m_targetMask & ( TARGET_FLAG_ITEM | TARGET_FLAG_TRADE_ITEM )) && caster->GetTypeId() == TYPEID_PLAYER)
209 if(!data->readPackGUID(m_itemTargetGUID))
210 return false;
212 if( m_targetMask & (TARGET_FLAG_CORPSE | TARGET_FLAG_PVP_CORPSE ) )
213 if(!data->readPackGUID(m_CorpseTargetGUID))
214 return false;
216 if( m_targetMask & TARGET_FLAG_SOURCE_LOCATION )
218 if(data->rpos() + 4 + 4 + 4 > data->size())
219 return false;
221 *data >> m_srcX >> m_srcY >> m_srcZ;
222 if(!MaNGOS::IsValidMapCoord(m_srcX, m_srcY, m_srcZ))
223 return false;
226 if( m_targetMask & TARGET_FLAG_DEST_LOCATION )
228 if(data->rpos() + 1 + 4 + 4 + 4 > data->size())
229 return false;
231 if(!data->readPackGUID(m_unitTargetGUID))
232 return false;
234 *data >> m_destX >> m_destY >> m_destZ;
235 if(!MaNGOS::IsValidMapCoord(m_destX, m_destY, m_destZ))
236 return false;
239 if( m_targetMask & TARGET_FLAG_STRING )
241 if(data->rpos() + 1 > data->size())
242 return false;
244 *data >> m_strTarget;
247 // find real units/GOs
248 Update(caster);
249 return true;
252 void SpellCastTargets::write ( WorldPacket * data )
254 *data << uint32(m_targetMask);
256 if( m_targetMask & ( TARGET_FLAG_UNIT | TARGET_FLAG_PVP_CORPSE | TARGET_FLAG_OBJECT | TARGET_FLAG_CORPSE | TARGET_FLAG_UNK2 ) )
258 if(m_targetMask & TARGET_FLAG_UNIT)
260 if(m_unitTarget)
261 data->append(m_unitTarget->GetPackGUID());
262 else
263 *data << uint8(0);
265 else if( m_targetMask & TARGET_FLAG_OBJECT )
267 if(m_GOTarget)
268 data->append(m_GOTarget->GetPackGUID());
269 else
270 *data << uint8(0);
272 else if( m_targetMask & ( TARGET_FLAG_CORPSE | TARGET_FLAG_PVP_CORPSE ) )
273 data->appendPackGUID(m_CorpseTargetGUID);
274 else
275 *data << uint8(0);
278 if( m_targetMask & ( TARGET_FLAG_ITEM | TARGET_FLAG_TRADE_ITEM ) )
280 if(m_itemTarget)
281 data->append(m_itemTarget->GetPackGUID());
282 else
283 *data << uint8(0);
286 if( m_targetMask & TARGET_FLAG_SOURCE_LOCATION )
287 *data << m_srcX << m_srcY << m_srcZ;
289 if( m_targetMask & TARGET_FLAG_DEST_LOCATION )
291 if(m_unitTarget)
292 data->append(m_unitTarget->GetPackGUID());
293 else
294 *data << uint8(0);
296 *data << m_destX << m_destY << m_destZ;
299 if( m_targetMask & TARGET_FLAG_STRING )
300 *data << m_strTarget;
303 Spell::Spell( Unit* Caster, SpellEntry const *info, bool triggered, uint64 originalCasterGUID, Spell** triggeringContainer )
305 ASSERT( Caster != NULL && info != NULL );
306 ASSERT( info == sSpellStore.LookupEntry( info->Id ) && "`info` must be pointer to sSpellStore element");
308 m_spellInfo = info;
309 m_caster = Caster;
310 m_selfContainer = NULL;
311 m_triggeringContainer = triggeringContainer;
312 m_referencedFromCurrentSpell = false;
313 m_executedCurrently = false;
314 m_delayStart = 0;
315 m_delayAtDamageCount = 0;
317 m_applyMultiplierMask = 0;
319 // Get data for type of attack
320 switch (m_spellInfo->DmgClass)
322 case SPELL_DAMAGE_CLASS_MELEE:
323 if (m_spellInfo->AttributesEx3 & SPELL_ATTR_EX3_REQ_OFFHAND)
324 m_attackType = OFF_ATTACK;
325 else
326 m_attackType = BASE_ATTACK;
327 break;
328 case SPELL_DAMAGE_CLASS_RANGED:
329 m_attackType = RANGED_ATTACK;
330 break;
331 default:
332 // Wands
333 if (m_spellInfo->AttributesEx2 & SPELL_ATTR_EX2_AUTOREPEAT_FLAG)
334 m_attackType = RANGED_ATTACK;
335 else
336 m_attackType = BASE_ATTACK;
337 break;
340 m_spellSchoolMask = GetSpellSchoolMask(info); // Can be override for some spell (wand shoot for example)
342 if(m_attackType == RANGED_ATTACK)
344 // wand case
345 if((m_caster->getClassMask() & CLASSMASK_WAND_USERS) != 0 && m_caster->GetTypeId() == TYPEID_PLAYER)
347 if(Item* pItem = ((Player*)m_caster)->GetWeaponForAttack(RANGED_ATTACK))
348 m_spellSchoolMask = SpellSchoolMask(1 << pItem->GetProto()->Damage[0].DamageType);
351 // Set health leech amount to zero
352 m_healthLeech = 0;
354 if(originalCasterGUID)
355 m_originalCasterGUID = originalCasterGUID;
356 else
357 m_originalCasterGUID = m_caster->GetGUID();
359 if(m_originalCasterGUID == m_caster->GetGUID())
360 m_originalCaster = m_caster;
361 else
363 m_originalCaster = ObjectAccessor::GetUnit(*m_caster, m_originalCasterGUID);
364 if(m_originalCaster && !m_originalCaster->IsInWorld()) m_originalCaster = NULL;
367 for(int i=0; i <3; ++i)
368 m_currentBasePoints[i] = m_spellInfo->EffectBasePoints[i];
370 m_spellState = SPELL_STATE_NULL;
372 m_castPositionX = m_castPositionY = m_castPositionZ = 0;
373 m_TriggerSpells.clear();
374 m_IsTriggeredSpell = triggered;
375 //m_AreaAura = false;
376 m_CastItem = NULL;
378 unitTarget = NULL;
379 itemTarget = NULL;
380 gameObjTarget = NULL;
381 focusObject = NULL;
382 m_cast_count = 0;
383 m_glyphIndex = 0;
384 m_preCastSpell = 0;
385 m_triggeredByAuraSpell = NULL;
387 //Auto Shot & Shoot (wand)
388 m_autoRepeat = IsAutoRepeatRangedSpell(m_spellInfo);
390 m_runesState = 0;
391 m_powerCost = 0; // setup to correct value in Spell::prepare, don't must be used before.
392 m_casttime = 0; // setup to correct value in Spell::prepare, don't must be used before.
393 m_timer = 0; // will set to castime in prepare
395 m_needAliveTargetMask = 0;
397 // determine reflection
398 m_canReflect = false;
400 if(m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MAGIC && !(m_spellInfo->AttributesEx2 & SPELL_ATTR_EX2_CANT_REFLECTED))
402 for(int j = 0;j < 3; ++j)
404 if (m_spellInfo->Effect[j] == 0)
405 continue;
407 if(!IsPositiveTarget(m_spellInfo->EffectImplicitTargetA[j], m_spellInfo->EffectImplicitTargetB[j]))
408 m_canReflect = true;
409 else
410 m_canReflect = (m_spellInfo->AttributesEx & SPELL_ATTR_EX_NEGATIVE) ? true : false;
412 if(m_canReflect)
413 continue;
414 else
415 break;
419 CleanupTargetList();
422 Spell::~Spell()
426 template<typename T>
427 WorldObject* Spell::FindCorpseUsing()
429 // non-standard target selection
430 SpellRangeEntry const* srange = sSpellRangeStore.LookupEntry(m_spellInfo->rangeIndex);
431 float max_range = GetSpellMaxRange(srange);
433 CellPair p(MaNGOS::ComputeCellPair(m_caster->GetPositionX(), m_caster->GetPositionY()));
434 Cell cell(p);
435 cell.data.Part.reserved = ALL_DISTRICT;
436 cell.SetNoCreate();
438 WorldObject* result = NULL;
440 T u_check(m_caster, max_range);
441 MaNGOS::WorldObjectSearcher<T> searcher(m_caster, result, u_check);
443 TypeContainerVisitor<MaNGOS::WorldObjectSearcher<T>, GridTypeMapContainer > grid_searcher(searcher);
444 CellLock<GridReadGuard> cell_lock(cell, p);
445 cell_lock->Visit(cell_lock, grid_searcher, *m_caster->GetMap());
447 if (!result)
449 TypeContainerVisitor<MaNGOS::WorldObjectSearcher<T>, WorldTypeMapContainer > world_searcher(searcher);
450 cell_lock->Visit(cell_lock, world_searcher, *m_caster->GetMap());
453 return result;
456 void Spell::FillTargetMap()
458 // TODO: ADD the correct target FILLS!!!!!!
460 for(uint32 i = 0; i < 3; ++i)
462 // not call for empty effect.
463 // Also some spells use not used effect targets for store targets for dummy effect in triggered spells
464 if(m_spellInfo->Effect[i] == 0)
465 continue;
467 // targets for TARGET_SCRIPT_COORDINATES (A) and TARGET_SCRIPT filled in Spell::CheckCast call
468 if( m_spellInfo->EffectImplicitTargetA[i] == TARGET_SCRIPT_COORDINATES ||
469 m_spellInfo->EffectImplicitTargetA[i] == TARGET_SCRIPT ||
470 m_spellInfo->EffectImplicitTargetB[i] == TARGET_SCRIPT && m_spellInfo->EffectImplicitTargetA[i] != TARGET_SELF )
471 continue;
473 // TODO: find a way so this is not needed?
474 // for area auras always add caster as target (needed for totems for example)
475 if(IsAreaAuraEffect(m_spellInfo->Effect[i]))
476 AddUnitTarget(m_caster, i);
478 std::list<Unit*> tmpUnitMap;
480 // TargetA/TargetB dependent from each other, we not switch to full support this dependences
481 // but need it support in some know cases
482 switch(m_spellInfo->EffectImplicitTargetA[i])
484 case TARGET_SELF:
485 switch(m_spellInfo->EffectImplicitTargetB[i])
487 case 0:
488 SetTargetMap(i, m_spellInfo->EffectImplicitTargetA[i], tmpUnitMap);
489 break;
490 case TARGET_AREAEFFECT_INSTANT: // use B case that not dependent from from A in fact
491 if((m_targets.m_targetMask & TARGET_FLAG_DEST_LOCATION) == 0)
492 m_targets.setDestination(m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ());
493 SetTargetMap(i, m_spellInfo->EffectImplicitTargetB[i], tmpUnitMap);
494 break;
495 case TARGET_BEHIND_VICTIM: // use B case that not dependent from from A in fact
496 SetTargetMap(i, m_spellInfo->EffectImplicitTargetB[i], tmpUnitMap);
497 break;
498 default:
499 SetTargetMap(i, m_spellInfo->EffectImplicitTargetA[i], tmpUnitMap);
500 SetTargetMap(i, m_spellInfo->EffectImplicitTargetB[i], tmpUnitMap);
501 break;
503 break;
504 case TARGET_CASTER_COORDINATES:
505 // Note: this hack with search required until GO casting not implemented
506 // environment damage spells already have around enemies targeting but this not help in case not existed GO casting support
507 // currently each enemy selected explicitly and self cast damage
508 if(m_spellInfo->EffectImplicitTargetB[i] == TARGET_ALL_ENEMY_IN_AREA && m_spellInfo->Effect[i] == SPELL_EFFECT_ENVIRONMENTAL_DAMAGE)
510 if(m_targets.getUnitTarget())
511 tmpUnitMap.push_back(m_targets.getUnitTarget());
513 else
515 SetTargetMap(i, m_spellInfo->EffectImplicitTargetA[i], tmpUnitMap);
516 SetTargetMap(i, m_spellInfo->EffectImplicitTargetB[i], tmpUnitMap);
518 break;
519 case TARGET_TABLE_X_Y_Z_COORDINATES:
520 switch(m_spellInfo->EffectImplicitTargetB[i])
522 case 0:
523 SetTargetMap(i, m_spellInfo->EffectImplicitTargetA[i], tmpUnitMap);
525 // need some target for proccesing
526 if(m_targets.getUnitTarget())
527 tmpUnitMap.push_back(m_targets.getUnitTarget());
528 else
529 tmpUnitMap.push_back(m_caster);
530 break;
531 case TARGET_AREAEFFECT_INSTANT: // All 17/7 pairs used for dest teleportation, A processed in effect code
532 SetTargetMap(i, m_spellInfo->EffectImplicitTargetB[i], tmpUnitMap);
533 break;
534 default:
535 SetTargetMap(i, m_spellInfo->EffectImplicitTargetA[i], tmpUnitMap);
536 SetTargetMap(i, m_spellInfo->EffectImplicitTargetB[i], tmpUnitMap);
537 break;
539 break;
540 default:
541 switch(m_spellInfo->EffectImplicitTargetB[i])
543 case 0:
544 SetTargetMap(i, m_spellInfo->EffectImplicitTargetA[i], tmpUnitMap);
545 break;
546 case TARGET_SCRIPT_COORDINATES: // B case filled in CheckCast but we need fill unit list base at A case
547 SetTargetMap(i, m_spellInfo->EffectImplicitTargetA[i], tmpUnitMap);
548 break;
549 default:
550 SetTargetMap(i, m_spellInfo->EffectImplicitTargetA[i], tmpUnitMap);
551 SetTargetMap(i, m_spellInfo->EffectImplicitTargetB[i], tmpUnitMap);
552 break;
554 break;
557 if( (m_spellInfo->EffectImplicitTargetA[i] == 0 || m_spellInfo->EffectImplicitTargetA[i] == TARGET_EFFECT_SELECT) &&
558 (m_spellInfo->EffectImplicitTargetB[i] == 0 || m_spellInfo->EffectImplicitTargetB[i] == TARGET_EFFECT_SELECT) )
560 // add here custom effects that need default target.
561 // FOR EVERY TARGET TYPE THERE IS A DIFFERENT FILL!!
562 switch(m_spellInfo->Effect[i])
564 case SPELL_EFFECT_DUMMY:
566 switch(m_spellInfo->Id)
568 case 20577: // Cannibalize
570 WorldObject* result = FindCorpseUsing<MaNGOS::CannibalizeObjectCheck> ();
572 if(result)
574 switch(result->GetTypeId())
576 case TYPEID_UNIT:
577 case TYPEID_PLAYER:
578 tmpUnitMap.push_back((Unit*)result);
579 break;
580 case TYPEID_CORPSE:
581 m_targets.setCorpseTarget((Corpse*)result);
582 if(Player* owner = ObjectAccessor::FindPlayer(((Corpse*)result)->GetOwnerGUID()))
583 tmpUnitMap.push_back(owner);
584 break;
587 else
589 // clear cooldown at fail
590 if(m_caster->GetTypeId() == TYPEID_PLAYER)
591 ((Player*)m_caster)->RemoveSpellCooldown(m_spellInfo->Id, true);
592 SendCastResult(SPELL_FAILED_NO_EDIBLE_CORPSES);
593 finish(false);
595 break;
597 default:
598 if(m_targets.getUnitTarget())
599 tmpUnitMap.push_back(m_targets.getUnitTarget());
600 break;
602 break;
604 case SPELL_EFFECT_RESURRECT:
605 case SPELL_EFFECT_PARRY:
606 case SPELL_EFFECT_BLOCK:
607 case SPELL_EFFECT_CREATE_ITEM:
608 case SPELL_EFFECT_TRIGGER_SPELL:
609 case SPELL_EFFECT_TRIGGER_MISSILE:
610 case SPELL_EFFECT_LEARN_SPELL:
611 case SPELL_EFFECT_SKILL_STEP:
612 case SPELL_EFFECT_PROFICIENCY:
613 case SPELL_EFFECT_SUMMON_OBJECT_WILD:
614 case SPELL_EFFECT_SELF_RESURRECT:
615 case SPELL_EFFECT_REPUTATION:
616 case SPELL_EFFECT_SEND_TAXI:
617 if(m_targets.getUnitTarget())
618 tmpUnitMap.push_back(m_targets.getUnitTarget());
619 // Triggered spells have additional spell targets - cast them even if no explicit unit target is given (required for spell 50516 for example)
620 else if(m_spellInfo->Effect[i] == SPELL_EFFECT_TRIGGER_SPELL)
621 tmpUnitMap.push_back(m_caster);
622 break;
623 case SPELL_EFFECT_SUMMON_PLAYER:
624 if(m_caster->GetTypeId()==TYPEID_PLAYER && ((Player*)m_caster)->GetSelection())
626 Player* target = objmgr.GetPlayer(((Player*)m_caster)->GetSelection());
627 if(target)
628 tmpUnitMap.push_back(target);
630 break;
631 case SPELL_EFFECT_RESURRECT_NEW:
632 if(m_targets.getUnitTarget())
633 tmpUnitMap.push_back(m_targets.getUnitTarget());
634 if(m_targets.getCorpseTargetGUID())
636 Corpse *corpse = ObjectAccessor::GetCorpse(*m_caster, m_targets.getCorpseTargetGUID());
637 if(corpse)
639 Player* owner = ObjectAccessor::FindPlayer(corpse->GetOwnerGUID());
640 if(owner)
641 tmpUnitMap.push_back(owner);
644 break;
645 case SPELL_EFFECT_SUMMON:
646 if(m_spellInfo->EffectMiscValueB[i] == SUMMON_TYPE_POSESSED || m_spellInfo->EffectMiscValueB[i] == SUMMON_TYPE_POSESSED2)
648 if(m_targets.getUnitTarget())
649 tmpUnitMap.push_back(m_targets.getUnitTarget());
651 else
652 tmpUnitMap.push_back(m_caster);
653 break;
654 case SPELL_EFFECT_SUMMON_CHANGE_ITEM:
655 case SPELL_EFFECT_TRANS_DOOR:
656 case SPELL_EFFECT_ADD_FARSIGHT:
657 case SPELL_EFFECT_APPLY_GLYPH:
658 case SPELL_EFFECT_STUCK:
659 case SPELL_EFFECT_FEED_PET:
660 case SPELL_EFFECT_DESTROY_ALL_TOTEMS:
661 case SPELL_EFFECT_SKILL:
662 tmpUnitMap.push_back(m_caster);
663 break;
664 case SPELL_EFFECT_LEARN_PET_SPELL:
665 if(Pet* pet = m_caster->GetPet())
666 tmpUnitMap.push_back(pet);
667 break;
668 case SPELL_EFFECT_ENCHANT_ITEM:
669 case SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY:
670 case SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC:
671 case SPELL_EFFECT_DISENCHANT:
672 case SPELL_EFFECT_PROSPECTING:
673 case SPELL_EFFECT_MILLING:
674 if(m_targets.getItemTarget())
675 AddItemTarget(m_targets.getItemTarget(), i);
676 break;
677 case SPELL_EFFECT_APPLY_AURA:
678 switch(m_spellInfo->EffectApplyAuraName[i])
680 case SPELL_AURA_ADD_FLAT_MODIFIER: // some spell mods auras have 0 target modes instead expected TARGET_SELF(1) (and present for other ranks for same spell for example)
681 case SPELL_AURA_ADD_PCT_MODIFIER:
682 tmpUnitMap.push_back(m_caster);
683 break;
684 default: // apply to target in other case
685 if(m_targets.getUnitTarget())
686 tmpUnitMap.push_back(m_targets.getUnitTarget());
687 break;
689 break;
690 case SPELL_EFFECT_APPLY_AREA_AURA_PARTY:
691 // AreaAura
692 if(m_spellInfo->Attributes == 0x9050000 || m_spellInfo->Attributes == 0x10000)
693 SetTargetMap(i,TARGET_AREAEFFECT_PARTY, tmpUnitMap);
694 break;
695 case SPELL_EFFECT_SKIN_PLAYER_CORPSE:
696 if(m_targets.getUnitTarget())
698 tmpUnitMap.push_back(m_targets.getUnitTarget());
700 else if (m_targets.getCorpseTargetGUID())
702 Corpse *corpse = ObjectAccessor::GetCorpse(*m_caster,m_targets.getCorpseTargetGUID());
703 if(corpse)
705 Player* owner = ObjectAccessor::FindPlayer(corpse->GetOwnerGUID());
706 if(owner)
707 tmpUnitMap.push_back(owner);
710 break;
711 default:
712 break;
716 if(m_caster->GetTypeId() == TYPEID_PLAYER)
718 Player *me = (Player*)m_caster;
719 for (std::list<Unit*>::const_iterator itr = tmpUnitMap.begin(); itr != tmpUnitMap.end(); ++itr)
721 Unit *owner = (*itr)->GetOwner();
722 Unit *u = owner ? owner : (*itr);
723 if(u!=m_caster && u->IsPvP() && (!me->duel || me->duel->opponent != u))
725 me->UpdatePvP(true);
726 me->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
727 break;
732 for (std::list<Unit*>::iterator itr = tmpUnitMap.begin(); itr != tmpUnitMap.end();)
734 if (!CheckTarget (*itr, i))
736 itr = tmpUnitMap.erase(itr);
737 continue;
739 else
740 ++itr;
743 for(std::list<Unit*>::const_iterator iunit = tmpUnitMap.begin(); iunit != tmpUnitMap.end(); ++iunit)
744 AddUnitTarget((*iunit), i);
748 void Spell::prepareDataForTriggerSystem()
750 //==========================================================================================
751 // Now fill data for trigger system, need know:
752 // an spell trigger another or not ( m_canTrigger )
753 // Create base triggers flags for Attacker and Victim ( m_procAttacker and m_procVictim)
754 //==========================================================================================
755 // Fill flag can spell trigger or not
756 // TODO: possible exist spell attribute for this
757 m_canTrigger = false;
759 if (m_CastItem)
760 m_canTrigger = false; // Do not trigger from item cast spell
761 else if (!m_IsTriggeredSpell)
762 m_canTrigger = true; // Normal cast - can trigger
763 else if (!m_triggeredByAuraSpell)
764 m_canTrigger = true; // Triggered from SPELL_EFFECT_TRIGGER_SPELL - can trigger
766 if (!m_canTrigger) // Exceptions (some periodic triggers)
768 switch (m_spellInfo->SpellFamilyName)
770 case SPELLFAMILY_MAGE: // Arcane Missles / Blizzard triggers need do it
771 if (m_spellInfo->SpellFamilyFlags & UI64LIT(0x0000000000200080))
772 m_canTrigger = true;
773 break;
774 case SPELLFAMILY_WARLOCK: // For Hellfire Effect / Rain of Fire / Seed of Corruption triggers need do it
775 if (m_spellInfo->SpellFamilyFlags & UI64LIT(0x0000800000000060))
776 m_canTrigger = true;
777 break;
778 case SPELLFAMILY_PRIEST: // For Penance heal/damage triggers need do it
779 if (m_spellInfo->SpellFamilyFlags & UI64LIT(0x0001800000000000))
780 m_canTrigger = true;
781 break;
782 case SPELLFAMILY_ROGUE: // For poisons need do it
783 if (m_spellInfo->SpellFamilyFlags & UI64LIT(0x000000101001E000))
784 m_canTrigger = true;
785 break;
786 case SPELLFAMILY_HUNTER: // Hunter Rapid Killing/Explosive Trap Effect/Immolation Trap Effect/Frost Trap Aura/Snake Trap Effect/Explosive Shot
787 if ((m_spellInfo->SpellFamilyFlags & UI64LIT(0x0100200000000214)) ||
788 m_spellInfo->SpellFamilyFlags2 & 0x200)
789 m_canTrigger = true;
790 break;
791 case SPELLFAMILY_PALADIN: // For Judgements (all) / Holy Shock triggers need do it
792 if (m_spellInfo->SpellFamilyFlags & UI64LIT(0x0001000900B80400))
793 m_canTrigger = true;
794 break;
795 default:
796 break;
800 // Get data for type of attack and fill base info for trigger
801 switch (m_spellInfo->DmgClass)
803 case SPELL_DAMAGE_CLASS_MELEE:
804 m_procAttacker = PROC_FLAG_SUCCESSFUL_MELEE_SPELL_HIT;
805 m_procVictim = PROC_FLAG_TAKEN_MELEE_SPELL_HIT;
806 break;
807 case SPELL_DAMAGE_CLASS_RANGED:
808 // Auto attack
809 if (m_spellInfo->AttributesEx2 & SPELL_ATTR_EX2_AUTOREPEAT_FLAG)
811 m_procAttacker = PROC_FLAG_SUCCESSFUL_RANGED_HIT;
812 m_procVictim = PROC_FLAG_TAKEN_RANGED_HIT;
814 else // Ranged spell attack
816 m_procAttacker = PROC_FLAG_SUCCESSFUL_RANGED_SPELL_HIT;
817 m_procVictim = PROC_FLAG_TAKEN_RANGED_SPELL_HIT;
819 break;
820 default:
821 if (IsPositiveSpell(m_spellInfo->Id)) // Check for positive spell
823 m_procAttacker = PROC_FLAG_SUCCESSFUL_POSITIVE_SPELL;
824 m_procVictim = PROC_FLAG_TAKEN_POSITIVE_SPELL;
826 else if (m_spellInfo->AttributesEx2 & SPELL_ATTR_EX2_AUTOREPEAT_FLAG) // Wands auto attack
828 m_procAttacker = PROC_FLAG_SUCCESSFUL_RANGED_HIT;
829 m_procVictim = PROC_FLAG_TAKEN_RANGED_HIT;
831 else // Negative spell
833 m_procAttacker = PROC_FLAG_SUCCESSFUL_NEGATIVE_SPELL_HIT;
834 m_procVictim = PROC_FLAG_TAKEN_NEGATIVE_SPELL_HIT;
836 break;
838 // Hunter traps spells (for Entrapment trigger)
839 // Gives your Immolation Trap, Frost Trap, Explosive Trap, and Snake Trap ....
840 if (m_spellInfo->SpellFamilyName == SPELLFAMILY_HUNTER && (m_spellInfo->SpellFamilyFlags & UI64LIT(0x000020000000001C)))
841 m_procAttacker |= PROC_FLAG_ON_TRAP_ACTIVATION;
844 void Spell::CleanupTargetList()
846 m_UniqueTargetInfo.clear();
847 m_UniqueGOTargetInfo.clear();
848 m_UniqueItemInfo.clear();
849 m_delayMoment = 0;
852 void Spell::AddUnitTarget(Unit* pVictim, uint32 effIndex)
854 if( m_spellInfo->Effect[effIndex] == 0 )
855 return;
857 // Check for effect immune skip if immuned
858 bool immuned = pVictim->IsImmunedToSpellEffect(m_spellInfo, effIndex);
860 uint64 targetGUID = pVictim->GetGUID();
862 // Lookup target in already in list
863 for(std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
865 if (targetGUID == ihit->targetGUID) // Found in list
867 if (!immuned)
868 ihit->effectMask |= 1 << effIndex; // Add only effect mask if not immuned
869 return;
873 // This is new target calculate data for him
875 // Get spell hit result on target
876 TargetInfo target;
877 target.targetGUID = targetGUID; // Store target GUID
878 target.effectMask = immuned ? 0 : 1 << effIndex; // Store index of effect if not immuned
879 target.processed = false; // Effects not apply on target
881 // Calculate hit result
882 target.missCondition = m_caster->SpellHitResult(pVictim, m_spellInfo, m_canReflect);
884 // Spell have speed - need calculate incoming time
885 if (m_spellInfo->speed > 0.0f)
887 // calculate spell incoming interval
888 float dist = m_caster->GetDistance(pVictim->GetPositionX(), pVictim->GetPositionY(), pVictim->GetPositionZ());
889 if (dist < 5.0f) dist = 5.0f;
890 target.timeDelay = (uint64) floor(dist / m_spellInfo->speed * 1000.0f);
892 // Calculate minimum incoming time
893 if (m_delayMoment == 0 || m_delayMoment>target.timeDelay)
894 m_delayMoment = target.timeDelay;
896 else
897 target.timeDelay = UI64LIT(0);
899 // If target reflect spell back to caster
900 if (target.missCondition == SPELL_MISS_REFLECT)
902 // Calculate reflected spell result on caster
903 target.reflectResult = m_caster->SpellHitResult(m_caster, m_spellInfo, m_canReflect);
905 if (target.reflectResult == SPELL_MISS_REFLECT) // Impossible reflect again, so simply deflect spell
906 target.reflectResult = SPELL_MISS_PARRY;
908 // Increase time interval for reflected spells by 1.5
909 target.timeDelay += target.timeDelay >> 1;
911 else
912 target.reflectResult = SPELL_MISS_NONE;
914 // Add target to list
915 m_UniqueTargetInfo.push_back(target);
918 void Spell::AddUnitTarget(uint64 unitGUID, uint32 effIndex)
920 Unit* unit = m_caster->GetGUID() == unitGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, unitGUID);
921 if (unit)
922 AddUnitTarget(unit, effIndex);
925 void Spell::AddGOTarget(GameObject* pVictim, uint32 effIndex)
927 if( m_spellInfo->Effect[effIndex] == 0 )
928 return;
930 uint64 targetGUID = pVictim->GetGUID();
932 // Lookup target in already in list
933 for(std::list<GOTargetInfo>::iterator ihit = m_UniqueGOTargetInfo.begin(); ihit != m_UniqueGOTargetInfo.end(); ++ihit)
935 if (targetGUID == ihit->targetGUID) // Found in list
937 ihit->effectMask |= 1 << effIndex; // Add only effect mask
938 return;
942 // This is new target calculate data for him
944 GOTargetInfo target;
945 target.targetGUID = targetGUID;
946 target.effectMask = 1 << effIndex;
947 target.processed = false; // Effects not apply on target
949 // Spell have speed - need calculate incoming time
950 if (m_spellInfo->speed > 0.0f)
952 // calculate spell incoming interval
953 float dist = m_caster->GetDistance(pVictim->GetPositionX(), pVictim->GetPositionY(), pVictim->GetPositionZ());
954 if (dist < 5.0f) dist = 5.0f;
955 target.timeDelay = (uint64) floor(dist / m_spellInfo->speed * 1000.0f);
956 if (m_delayMoment==0 || m_delayMoment>target.timeDelay)
957 m_delayMoment = target.timeDelay;
959 else
960 target.timeDelay = UI64LIT(0);
962 // Add target to list
963 m_UniqueGOTargetInfo.push_back(target);
966 void Spell::AddGOTarget(uint64 goGUID, uint32 effIndex)
968 GameObject* go = m_caster->GetMap()->GetGameObject(goGUID);
969 if (go)
970 AddGOTarget(go, effIndex);
973 void Spell::AddItemTarget(Item* pitem, uint32 effIndex)
975 if( m_spellInfo->Effect[effIndex] == 0 )
976 return;
978 // Lookup target in already in list
979 for(std::list<ItemTargetInfo>::iterator ihit = m_UniqueItemInfo.begin(); ihit != m_UniqueItemInfo.end(); ++ihit)
981 if (pitem == ihit->item) // Found in list
983 ihit->effectMask |= 1<<effIndex; // Add only effect mask
984 return;
988 // This is new target add data
990 ItemTargetInfo target;
991 target.item = pitem;
992 target.effectMask = 1 << effIndex;
993 m_UniqueItemInfo.push_back(target);
996 void Spell::DoAllEffectOnTarget(TargetInfo *target)
998 if (target->processed) // Check target
999 return;
1000 target->processed = true; // Target checked in apply effects procedure
1002 // Get mask of effects for target
1003 uint32 mask = target->effectMask;
1005 Unit* unit = m_caster->GetGUID()==target->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster,target->targetGUID);
1006 if (!unit)
1007 return;
1009 // Get original caster (if exist) and calculate damage/healing from him data
1010 Unit *caster = m_originalCaster ? m_originalCaster : m_caster;
1012 // Skip if m_originalCaster not available
1013 if (!caster)
1014 return;
1016 SpellMissInfo missInfo = target->missCondition;
1017 // Need init unitTarget by default unit (can changed in code on reflect)
1018 // Or on missInfo!=SPELL_MISS_NONE unitTarget undefined (but need in trigger subsystem)
1019 unitTarget = unit;
1021 // Reset damage/healing counter
1022 m_damage = 0;
1023 m_healing = 0;
1025 // Fill base trigger info
1026 uint32 procAttacker = m_procAttacker;
1027 uint32 procVictim = m_procVictim;
1028 uint32 procEx = PROC_EX_NONE;
1030 if (missInfo==SPELL_MISS_NONE) // In case spell hit target, do all effect on that target
1031 DoSpellHitOnUnit(unit, mask);
1032 else if (missInfo == SPELL_MISS_REFLECT) // In case spell reflect from target, do all effect on caster (if hit)
1034 if (target->reflectResult == SPELL_MISS_NONE) // If reflected spell hit caster -> do all effect on him
1035 DoSpellHitOnUnit(m_caster, mask);
1038 // All calculated do it!
1039 // Do healing and triggers
1040 if (m_healing)
1042 bool crit = caster->isSpellCrit(NULL, m_spellInfo, m_spellSchoolMask);
1043 uint32 addhealth = m_healing;
1044 if (crit)
1046 procEx |= PROC_EX_CRITICAL_HIT;
1047 addhealth = caster->SpellCriticalHealingBonus(m_spellInfo, addhealth, NULL);
1049 else
1050 procEx |= PROC_EX_NORMAL_HIT;
1052 // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge)
1053 if (m_canTrigger && missInfo != SPELL_MISS_REFLECT)
1054 caster->ProcDamageAndSpell(unitTarget, procAttacker, procVictim, procEx, addhealth, m_attackType, m_spellInfo);
1056 int32 gain = caster->DealHeal(unitTarget, addhealth, m_spellInfo, crit);
1057 unitTarget->getHostilRefManager().threatAssist(caster, float(gain) * 0.5f, m_spellInfo);
1059 // Do damage and triggers
1060 else if (m_damage)
1062 // Fill base damage struct (unitTarget - is real spell target)
1063 SpellNonMeleeDamage damageInfo(caster, unitTarget, m_spellInfo->Id, m_spellSchoolMask);
1065 // Add bonuses and fill damageInfo struct
1066 caster->CalculateSpellDamage(&damageInfo, m_damage, m_spellInfo);
1067 caster->DealDamageMods(damageInfo.target, damageInfo.damage, &damageInfo.absorb);
1069 // Send log damage message to client
1070 caster->SendSpellNonMeleeDamageLog(&damageInfo);
1072 procEx = createProcExtendMask(&damageInfo, missInfo);
1073 procVictim |= PROC_FLAG_TAKEN_ANY_DAMAGE;
1075 // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge)
1076 if (m_canTrigger && missInfo != SPELL_MISS_REFLECT)
1077 caster->ProcDamageAndSpell(unitTarget, procAttacker, procVictim, procEx, damageInfo.damage, m_attackType, m_spellInfo);
1079 caster->DealSpellDamage(&damageInfo, true);
1081 // Judgement of Blood
1082 if (m_spellInfo->SpellFamilyName == SPELLFAMILY_PALADIN && (m_spellInfo->SpellFamilyFlags & UI64LIT(0x0000000800000000)) && m_spellInfo->SpellIconID==153)
1084 int32 damagePoint = damageInfo.damage * 33 / 100;
1085 m_caster->CastCustomSpell(m_caster, 32220, &damagePoint, NULL, NULL, true);
1088 // Passive spell hits/misses or active spells only misses (only triggers)
1089 else
1091 // Fill base damage struct (unitTarget - is real spell target)
1092 SpellNonMeleeDamage damageInfo(caster, unitTarget, m_spellInfo->Id, m_spellSchoolMask);
1093 procEx = createProcExtendMask(&damageInfo, missInfo);
1094 // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge)
1095 if (m_canTrigger && missInfo != SPELL_MISS_REFLECT)
1096 caster->ProcDamageAndSpell(unit, procAttacker, procVictim, procEx, 0, m_attackType, m_spellInfo);
1099 // Call scripted function for AI if this spell is casted upon a creature
1100 if(unit->GetTypeId()==TYPEID_UNIT)
1102 // cast at creature (or GO) quest objectives update at successful cast finished (+channel finished)
1103 // ignore pets or autorepeat/melee casts for speed (not exist quest for spells (hm... )
1104 if( !((Creature*)unit)->isPet() && !IsAutoRepeat() && !IsNextMeleeSwingSpell() && !IsChannelActive() )
1106 if ( Player* p = m_caster->GetCharmerOrOwnerPlayerOrPlayerItself() )
1107 p->CastedCreatureOrGO(unit->GetEntry(), unit->GetGUID(), m_spellInfo->Id);
1110 if(((Creature*)unit)->AI())
1111 ((Creature*)unit)->AI()->SpellHit(m_caster ,m_spellInfo);
1114 // Call scripted function for AI if this spell is casted by a creature
1115 if(m_caster->GetTypeId()==TYPEID_UNIT && ((Creature*)m_caster)->AI())
1116 ((Creature*)m_caster)->AI()->SpellHitTarget(unit, m_spellInfo);
1119 void Spell::DoSpellHitOnUnit(Unit *unit, const uint32 effectMask)
1121 if(!unit || !effectMask)
1122 return;
1124 // Recheck immune (only for delayed spells)
1125 if( m_spellInfo->speed && (
1126 unit->IsImmunedToDamage(GetSpellSchoolMask(m_spellInfo)) ||
1127 unit->IsImmunedToSpell(m_spellInfo)))
1129 m_caster->SendSpellMiss(unit, m_spellInfo->Id, SPELL_MISS_IMMUNE);
1130 return;
1133 if (unit->GetTypeId() == TYPEID_PLAYER)
1135 ((Player*)unit)->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, m_spellInfo->Id);
1136 ((Player*)unit)->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2, m_spellInfo->Id);
1139 if(m_caster->GetTypeId() == TYPEID_PLAYER)
1141 ((Player*)m_caster)->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2, m_spellInfo->Id, 0, unit);
1144 if( m_caster != unit )
1146 // Recheck UNIT_FLAG_NON_ATTACKABLE for delayed spells
1147 if (m_spellInfo->speed > 0.0f &&
1148 unit->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE) &&
1149 unit->GetCharmerOrOwnerGUID() != m_caster->GetGUID())
1151 m_caster->SendSpellMiss(unit, m_spellInfo->Id, SPELL_MISS_EVADE);
1152 return;
1155 if( !m_caster->IsFriendlyTo(unit) )
1157 // for delayed spells ignore not visible explicit target
1158 if(m_spellInfo->speed > 0.0f && unit == m_targets.getUnitTarget() && !unit->isVisibleForOrDetect(m_caster,false))
1160 m_caster->SendSpellMiss(unit, m_spellInfo->Id, SPELL_MISS_EVADE);
1161 return;
1164 unit->RemoveSpellsCausingAura(SPELL_AURA_MOD_STEALTH);
1166 if( !(m_spellInfo->AttributesEx & SPELL_ATTR_EX_NO_INITIAL_AGGRO) )
1168 if(!unit->IsStandState() && !unit->hasUnitState(UNIT_STAT_STUNNED))
1169 unit->SetStandState(UNIT_STAND_STATE_STAND);
1171 if(!unit->isInCombat() && unit->GetTypeId() != TYPEID_PLAYER && ((Creature*)unit)->AI())
1172 ((Creature*)unit)->AI()->AttackedBy(m_caster);
1174 unit->AddThreat(m_caster, 0.0f);
1175 unit->SetInCombatWith(m_caster);
1176 m_caster->SetInCombatWith(unit);
1178 if(Player *attackedPlayer = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
1180 m_caster->SetContestedPvP(attackedPlayer);
1184 else
1186 // for delayed spells ignore negative spells (after duel end) for friendly targets
1187 if(m_spellInfo->speed > 0.0f && !IsPositiveSpell(m_spellInfo->Id))
1189 m_caster->SendSpellMiss(unit, m_spellInfo->Id, SPELL_MISS_EVADE);
1190 return;
1193 // assisting case, healing and resurrection
1194 if(unit->hasUnitState(UNIT_STAT_ATTACK_PLAYER))
1195 m_caster->SetContestedPvP();
1196 if( unit->isInCombat() && !(m_spellInfo->AttributesEx & SPELL_ATTR_EX_NO_INITIAL_AGGRO) )
1198 m_caster->SetInCombatState(unit->GetCombatTimer() > 0);
1199 unit->getHostilRefManager().threatAssist(m_caster, 0.0f);
1204 // Get Data Needed for Diminishing Returns, some effects may have multiple auras, so this must be done on spell hit, not aura add
1205 m_diminishGroup = GetDiminishingReturnsGroupForSpell(m_spellInfo,m_triggeredByAuraSpell);
1206 m_diminishLevel = unit->GetDiminishing(m_diminishGroup);
1207 // Increase Diminishing on unit, current informations for actually casts will use values above
1208 if((GetDiminishingReturnsGroupType(m_diminishGroup) == DRTYPE_PLAYER && unit->GetTypeId() == TYPEID_PLAYER) || GetDiminishingReturnsGroupType(m_diminishGroup) == DRTYPE_ALL)
1209 unit->IncrDiminishing(m_diminishGroup);
1211 // Apply additional spell effects to target
1212 if (m_preCastSpell)
1213 m_caster->CastSpell(unit, m_preCastSpell, true, m_CastItem);
1215 for(uint32 effectNumber = 0; effectNumber < 3; ++effectNumber)
1217 if (effectMask & (1 << effectNumber))
1219 HandleEffects(unit, NULL, NULL, effectNumber, m_damageMultipliers[effectNumber]);
1220 if ( m_applyMultiplierMask & (1 << effectNumber) )
1222 // Get multiplier
1223 float multiplier = m_spellInfo->DmgMultiplier[effectNumber];
1224 // Apply multiplier mods
1225 if(Player* modOwner = m_originalCaster->GetSpellModOwner())
1226 modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_EFFECT_PAST_FIRST, multiplier, this);
1227 m_damageMultipliers[effectNumber] *= multiplier;
1233 void Spell::DoAllEffectOnTarget(GOTargetInfo *target)
1235 if (target->processed) // Check target
1236 return;
1237 target->processed = true; // Target checked in apply effects procedure
1239 uint32 effectMask = target->effectMask;
1240 if(!effectMask)
1241 return;
1243 GameObject* go = m_caster->GetMap()->GetGameObject(target->targetGUID);
1244 if(!go)
1245 return;
1247 for(uint32 effectNumber = 0; effectNumber < 3; ++effectNumber)
1248 if (effectMask & (1 << effectNumber))
1249 HandleEffects(NULL, NULL, go, effectNumber);
1251 // cast at creature (or GO) quest objectives update at successful cast finished (+channel finished)
1252 // ignore autorepeat/melee casts for speed (not exist quest for spells (hm... )
1253 if( !IsAutoRepeat() && !IsNextMeleeSwingSpell() && !IsChannelActive() )
1255 if ( Player* p = m_caster->GetCharmerOrOwnerPlayerOrPlayerItself() )
1256 p->CastedCreatureOrGO(go->GetEntry(), go->GetGUID(), m_spellInfo->Id);
1260 void Spell::DoAllEffectOnTarget(ItemTargetInfo *target)
1262 uint32 effectMask = target->effectMask;
1263 if(!target->item || !effectMask)
1264 return;
1266 for(uint32 effectNumber = 0; effectNumber < 3; ++effectNumber)
1267 if (effectMask & (1 << effectNumber))
1268 HandleEffects(NULL, target->item, NULL, effectNumber);
1271 bool Spell::IsAliveUnitPresentInTargetList()
1273 // Not need check return true
1274 if (m_needAliveTargetMask == 0)
1275 return true;
1277 uint8 needAliveTargetMask = m_needAliveTargetMask;
1279 for(std::list<TargetInfo>::const_iterator ihit= m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
1281 if( ihit->missCondition == SPELL_MISS_NONE && (needAliveTargetMask & ihit->effectMask) )
1283 Unit *unit = m_caster->GetGUID() == ihit->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID);
1285 if (unit && unit->isAlive())
1286 needAliveTargetMask &= ~ihit->effectMask; // remove from need alive mask effect that have alive target
1290 // is all effects from m_needAliveTargetMask have alive targets
1291 return needAliveTargetMask == 0;
1294 // Helper for Chain Healing
1295 // Spell target first
1296 // Raidmates then descending by injury suffered (MaxHealth - Health)
1297 // Other players/mobs then descending by injury suffered (MaxHealth - Health)
1298 struct ChainHealingOrder : public std::binary_function<const Unit*, const Unit*, bool>
1300 const Unit* MainTarget;
1301 ChainHealingOrder(Unit const* Target) : MainTarget(Target) {};
1302 // functor for operator ">"
1303 bool operator()(Unit const* _Left, Unit const* _Right) const
1305 return (ChainHealingHash(_Left) < ChainHealingHash(_Right));
1307 int32 ChainHealingHash(Unit const* Target) const
1309 if (Target == MainTarget)
1310 return 0;
1311 else if (Target->GetTypeId() == TYPEID_PLAYER && MainTarget->GetTypeId() == TYPEID_PLAYER &&
1312 ((Player const*)Target)->IsInSameRaidWith((Player const*)MainTarget))
1314 if (Target->GetHealth() == Target->GetMaxHealth())
1315 return 40000;
1316 else
1317 return 20000 - Target->GetMaxHealth() + Target->GetHealth();
1319 else
1320 return 40000 - Target->GetMaxHealth() + Target->GetHealth();
1324 class ChainHealingFullHealth: std::unary_function<const Unit*, bool>
1326 public:
1327 const Unit* MainTarget;
1328 ChainHealingFullHealth(const Unit* Target) : MainTarget(Target) {};
1330 bool operator()(const Unit* Target)
1332 return (Target != MainTarget && Target->GetHealth() == Target->GetMaxHealth());
1336 // Helper for targets nearest to the spell target
1337 // The spell target is always first unless there is a target at _completely_ the same position (unbelievable case)
1338 struct TargetDistanceOrder : public std::binary_function<const Unit, const Unit, bool>
1340 const Unit* MainTarget;
1341 TargetDistanceOrder(const Unit* Target) : MainTarget(Target) {};
1342 // functor for operator ">"
1343 bool operator()(const Unit* _Left, const Unit* _Right) const
1345 return MainTarget->GetDistanceOrder(_Left,_Right);
1349 void Spell::SetTargetMap(uint32 i,uint32 cur,UnitList& TagUnitMap)
1351 float radius;
1352 if (m_spellInfo->EffectRadiusIndex[i])
1353 radius = GetSpellRadius(sSpellRadiusStore.LookupEntry(m_spellInfo->EffectRadiusIndex[i]));
1354 else
1355 radius = GetSpellMaxRange(sSpellRangeStore.LookupEntry(m_spellInfo->rangeIndex));
1357 if(m_originalCaster)
1358 if(Player* modOwner = m_originalCaster->GetSpellModOwner())
1359 modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_RADIUS, radius, this);
1361 uint32 EffectChainTarget = m_spellInfo->EffectChainTarget[i];
1362 if(m_originalCaster)
1363 if(Player* modOwner = m_originalCaster->GetSpellModOwner())
1364 modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_JUMP_TARGETS, EffectChainTarget, this);
1366 // Get spell max affected targets
1367 uint32 unMaxTargets = m_spellInfo->MaxAffectedTargets;
1369 // custom target amount cases
1370 switch(m_spellInfo->SpellFamilyName)
1372 case SPELLFAMILY_DRUID:
1373 // Starfall
1374 if (m_spellInfo->SpellFamilyFlags2 & UI64LIT(0x00000100))
1375 unMaxTargets = 2;
1376 break;
1377 default:
1378 break;
1381 Unit::AuraList const& mod = m_caster->GetAurasByType(SPELL_AURA_MOD_MAX_AFFECTED_TARGETS);
1382 for(Unit::AuraList::const_iterator m = mod.begin(); m != mod.end(); ++m)
1384 if (!(*m)->isAffectedOnSpell(m_spellInfo))
1385 continue;
1386 unMaxTargets+=(*m)->GetModifier()->m_amount;
1389 switch(cur)
1391 case TARGET_TOTEM_EARTH:
1392 case TARGET_TOTEM_WATER:
1393 case TARGET_TOTEM_AIR:
1394 case TARGET_TOTEM_FIRE:
1395 case TARGET_SELF:
1396 case TARGET_SELF2:
1397 case TARGET_DYNAMIC_OBJECT:
1398 case TARGET_AREAEFFECT_CUSTOM:
1399 case TARGET_AREAEFFECT_CUSTOM_2:
1400 case TARGET_SUMMON:
1402 TagUnitMap.push_back(m_caster);
1403 break;
1405 case TARGET_RANDOM_ENEMY_CHAIN_IN_AREA:
1407 m_targets.m_targetMask = 0;
1408 unMaxTargets = EffectChainTarget;
1409 float max_range = radius + unMaxTargets * CHAIN_SPELL_JUMP_RADIUS;
1411 CellPair p(MaNGOS::ComputeCellPair(m_caster->GetPositionX(), m_caster->GetPositionY()));
1412 Cell cell(p);
1413 cell.data.Part.reserved = ALL_DISTRICT;
1414 cell.SetNoCreate();
1416 std::list<Unit *> tempUnitMap;
1419 MaNGOS::AnyAoETargetUnitInObjectRangeCheck u_check(m_caster, m_caster, max_range);
1420 MaNGOS::UnitListSearcher<MaNGOS::AnyAoETargetUnitInObjectRangeCheck> searcher(m_caster, tempUnitMap, u_check);
1422 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyAoETargetUnitInObjectRangeCheck>, WorldTypeMapContainer > world_unit_searcher(searcher);
1423 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyAoETargetUnitInObjectRangeCheck>, GridTypeMapContainer > grid_unit_searcher(searcher);
1425 CellLock<GridReadGuard> cell_lock(cell, p);
1426 cell_lock->Visit(cell_lock, world_unit_searcher, *m_caster->GetMap());
1427 cell_lock->Visit(cell_lock, grid_unit_searcher, *m_caster->GetMap());
1430 if(tempUnitMap.empty())
1431 break;
1433 tempUnitMap.sort(TargetDistanceOrder(m_caster));
1435 //Now to get us a random target that's in the initial range of the spell
1436 uint32 t = 0;
1437 std::list<Unit *>::iterator itr = tempUnitMap.begin();
1438 while(itr!= tempUnitMap.end() && (*itr)->IsWithinDist(m_caster,radius))
1439 ++t, ++itr;
1441 if(!t)
1442 break;
1444 itr = tempUnitMap.begin();
1445 std::advance(itr, rand()%t);
1446 Unit *pUnitTarget = *itr;
1447 TagUnitMap.push_back(pUnitTarget);
1449 tempUnitMap.erase(itr);
1451 tempUnitMap.sort(TargetDistanceOrder(pUnitTarget));
1453 t = unMaxTargets - 1;
1454 Unit *prev = pUnitTarget;
1455 std::list<Unit*>::iterator next = tempUnitMap.begin();
1457 while(t && next != tempUnitMap.end() )
1459 if(!prev->IsWithinDist(*next,CHAIN_SPELL_JUMP_RADIUS))
1460 break;
1462 if(!prev->IsWithinLOSInMap(*next))
1464 ++next;
1465 continue;
1468 prev = *next;
1469 TagUnitMap.push_back(prev);
1470 tempUnitMap.erase(next);
1471 tempUnitMap.sort(TargetDistanceOrder(prev));
1472 next = tempUnitMap.begin();
1474 --t;
1476 }break;
1477 case TARGET_RANDOM_FRIEND_CHAIN_IN_AREA:
1479 m_targets.m_targetMask = 0;
1480 unMaxTargets = EffectChainTarget;
1481 float max_range = radius + unMaxTargets * CHAIN_SPELL_JUMP_RADIUS;
1482 CellPair p(MaNGOS::ComputeCellPair(m_caster->GetPositionX(), m_caster->GetPositionY()));
1483 Cell cell(p);
1484 cell.data.Part.reserved = ALL_DISTRICT;
1485 cell.SetNoCreate();
1486 std::list<Unit *> tempUnitMap;
1488 MaNGOS::AnyFriendlyUnitInObjectRangeCheck u_check(m_caster, m_caster, max_range);
1489 MaNGOS::UnitListSearcher<MaNGOS::AnyFriendlyUnitInObjectRangeCheck> searcher(m_caster, tempUnitMap, u_check);
1491 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyFriendlyUnitInObjectRangeCheck>, WorldTypeMapContainer > world_unit_searcher(searcher);
1492 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyFriendlyUnitInObjectRangeCheck>, GridTypeMapContainer > grid_unit_searcher(searcher);
1494 CellLock<GridReadGuard> cell_lock(cell, p);
1495 cell_lock->Visit(cell_lock, world_unit_searcher, *m_caster->GetMap());
1496 cell_lock->Visit(cell_lock, grid_unit_searcher, *m_caster->GetMap());
1499 if(tempUnitMap.empty())
1500 break;
1502 tempUnitMap.sort(TargetDistanceOrder(m_caster));
1504 //Now to get us a random target that's in the initial range of the spell
1505 uint32 t = 0;
1506 std::list<Unit *>::iterator itr = tempUnitMap.begin();
1507 while(itr!= tempUnitMap.end() && (*itr)->IsWithinDist(m_caster,radius))
1508 ++t, ++itr;
1510 if(!t)
1511 break;
1513 itr = tempUnitMap.begin();
1514 std::advance(itr, rand()%t);
1515 Unit *pUnitTarget = *itr;
1516 TagUnitMap.push_back(pUnitTarget);
1518 tempUnitMap.erase(itr);
1520 tempUnitMap.sort(TargetDistanceOrder(pUnitTarget));
1522 t = unMaxTargets - 1;
1523 Unit *prev = pUnitTarget;
1524 std::list<Unit*>::iterator next = tempUnitMap.begin();
1526 while(t && next != tempUnitMap.end() )
1528 if(!prev->IsWithinDist(*next,CHAIN_SPELL_JUMP_RADIUS))
1529 break;
1531 if(!prev->IsWithinLOSInMap(*next))
1533 ++next;
1534 continue;
1536 prev = *next;
1537 TagUnitMap.push_back(prev);
1538 tempUnitMap.erase(next);
1539 tempUnitMap.sort(TargetDistanceOrder(prev));
1540 next = tempUnitMap.begin();
1541 --t;
1543 }break;
1544 case TARGET_PET:
1546 Pet* tmpUnit = m_caster->GetPet();
1547 if (!tmpUnit) break;
1548 TagUnitMap.push_back(tmpUnit);
1549 break;
1551 case TARGET_CHAIN_DAMAGE:
1553 if (EffectChainTarget <= 1)
1555 if(Unit* pUnitTarget = m_caster->SelectMagnetTarget(m_targets.getUnitTarget(), m_spellInfo))
1557 m_targets.setUnitTarget(pUnitTarget);
1558 TagUnitMap.push_back(pUnitTarget);
1561 else
1563 Unit* pUnitTarget = m_targets.getUnitTarget();
1564 Unit* originalCaster = GetOriginalCaster();
1565 if(!pUnitTarget || !originalCaster)
1566 break;
1568 unMaxTargets = EffectChainTarget;
1570 float max_range;
1571 if(m_spellInfo->DmgClass==SPELL_DAMAGE_CLASS_MELEE)
1572 max_range = radius; //
1573 else
1574 //FIXME: This very like horrible hack and wrong for most spells
1575 max_range = radius + unMaxTargets * CHAIN_SPELL_JUMP_RADIUS;
1577 CellPair p(MaNGOS::ComputeCellPair(m_caster->GetPositionX(), m_caster->GetPositionY()));
1578 Cell cell(p);
1579 cell.data.Part.reserved = ALL_DISTRICT;
1580 cell.SetNoCreate();
1582 std::list<Unit *> tempUnitMap;
1584 MaNGOS::AnyAoETargetUnitInObjectRangeCheck u_check(pUnitTarget, originalCaster, max_range, false);
1585 MaNGOS::UnitListSearcher<MaNGOS::AnyAoETargetUnitInObjectRangeCheck> searcher(m_caster, tempUnitMap, u_check);
1586 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyAoETargetUnitInObjectRangeCheck>, WorldTypeMapContainer> world_unit_searcher(searcher);
1587 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyAoETargetUnitInObjectRangeCheck>, GridTypeMapContainer> grid_unit_searcher(searcher);
1588 CellLock<GridReadGuard> cell_lock(cell, p);
1590 cell_lock->Visit(cell_lock, world_unit_searcher, *m_caster->GetMap());
1591 cell_lock->Visit(cell_lock, grid_unit_searcher, *m_caster->GetMap());
1593 if (tempUnitMap.empty())
1594 break;
1596 tempUnitMap.sort(TargetDistanceOrder(pUnitTarget));
1598 if (*tempUnitMap.begin() == pUnitTarget)
1599 tempUnitMap.erase (tempUnitMap.begin());
1601 TagUnitMap.push_back(pUnitTarget);
1602 uint32 t = unMaxTargets - 1;
1603 Unit *prev = pUnitTarget;
1604 std::list<Unit*>::iterator next = tempUnitMap.begin();
1606 while (t && next != tempUnitMap.end())
1608 if (!prev->IsWithinDist (*next,CHAIN_SPELL_JUMP_RADIUS))
1609 break;
1610 if (!prev->IsWithinLOSInMap (*next))
1612 ++next;
1613 continue;
1615 prev = *next;
1616 TagUnitMap.push_back(prev);
1617 tempUnitMap.erase(next);
1618 tempUnitMap.sort (TargetDistanceOrder(prev));
1619 next = tempUnitMap.begin();
1620 --t;
1623 }break;
1624 case TARGET_ALL_ENEMY_IN_AREA:
1626 FillAreaTargets(TagUnitMap,m_targets.m_destX, m_targets.m_destY,radius,PUSH_DEST_CENTER,SPELL_TARGETS_AOE_DAMAGE);
1627 break;
1629 case TARGET_AREAEFFECT_INSTANT:
1631 SpellTargets targetB = SPELL_TARGETS_AOE_DAMAGE;
1632 // Select friendly targets for positive effect
1633 if (IsPositiveEffect(m_spellInfo->Id, i))
1634 targetB = SPELL_TARGETS_FRIENDLY;
1636 FillAreaTargets(TagUnitMap,m_caster->GetPositionX(), m_caster->GetPositionY(),radius, PUSH_DEST_CENTER, targetB);
1638 // exclude caster
1639 TagUnitMap.remove(m_caster);
1641 case TARGET_ALL_ENEMY_IN_AREA_INSTANT:
1643 // targets the ground, not the units in the area
1644 if (m_spellInfo->Effect[i]!=SPELL_EFFECT_PERSISTENT_AREA_AURA)
1646 FillAreaTargets(TagUnitMap,m_targets.m_destX, m_targets.m_destY,radius,PUSH_DEST_CENTER,SPELL_TARGETS_AOE_DAMAGE);
1648 // exclude caster (this can be important if this not original caster)
1649 TagUnitMap.remove(m_caster);
1651 }break;
1652 case TARGET_DUELVSPLAYER_COORDINATES:
1654 if(Unit* currentTarget = m_targets.getUnitTarget())
1656 m_targets.setDestination(currentTarget->GetPositionX(), currentTarget->GetPositionY(), currentTarget->GetPositionZ());
1657 TagUnitMap.push_back(currentTarget);
1659 }break;
1660 case TARGET_ALL_PARTY_AROUND_CASTER:
1661 case TARGET_ALL_PARTY_AROUND_CASTER_2:
1662 case TARGET_ALL_PARTY:
1664 Player *pTarget = m_caster->GetCharmerOrOwnerPlayerOrPlayerItself();
1665 Group *pGroup = pTarget ? pTarget->GetGroup() : NULL;
1667 if(pGroup)
1669 uint8 subgroup = pTarget->GetSubGroup();
1671 for(GroupReference *itr = pGroup->GetFirstMember(); itr != NULL; itr = itr->next())
1673 Player* Target = itr->getSource();
1675 // IsHostileTo check duel and controlled by enemy
1676 if( Target && Target->GetSubGroup()==subgroup && !m_caster->IsHostileTo(Target) )
1678 if( m_caster->IsWithinDistInMap(Target, radius) )
1679 TagUnitMap.push_back(Target);
1681 if(Pet* pet = Target->GetPet())
1682 if( m_caster->IsWithinDistInMap(pet, radius) )
1683 TagUnitMap.push_back(pet);
1687 else
1689 Unit* ownerOrSelf = pTarget ? pTarget : m_caster->GetCharmerOrOwnerOrSelf();
1690 if(ownerOrSelf==m_caster || m_caster->IsWithinDistInMap(ownerOrSelf, radius))
1691 TagUnitMap.push_back(ownerOrSelf);
1692 if(Pet* pet = ownerOrSelf->GetPet())
1693 if( m_caster->IsWithinDistInMap(pet, radius) )
1694 TagUnitMap.push_back(pet);
1696 break;
1698 case TARGET_ALL_RAID_AROUND_CASTER:
1700 Player *pTarget = m_caster->GetCharmerOrOwnerPlayerOrPlayerItself();
1701 Group *pGroup = pTarget ? pTarget->GetGroup() : NULL;
1703 if(m_spellInfo->Id == 57669) // Replenishment (special target selection)
1705 if(pGroup)
1707 typedef std::priority_queue<PrioritizeManaPlayerWraper, std::vector<PrioritizeManaPlayerWraper>, PrioritizeMana> Top10;
1708 Top10 manaUsers;
1710 for(GroupReference *itr = pGroup->GetFirstMember(); itr != NULL && manaUsers.size() < 10; itr = itr->next())
1712 Player* Target = itr->getSource();
1713 if (m_caster->GetGUID() != Target->GetGUID() && Target->getPowerType() == POWER_MANA &&
1714 !Target->isDead() && m_caster->IsWithinDistInMap(Target, radius))
1716 PrioritizeManaPlayerWraper WTarget(Target);
1717 manaUsers.push(WTarget);
1721 while(!manaUsers.empty())
1723 TagUnitMap.push_back(manaUsers.top().getPlayer());
1724 manaUsers.pop();
1727 else
1729 Unit* ownerOrSelf = pTarget ? pTarget : m_caster->GetCharmerOrOwnerOrSelf();
1730 if ((ownerOrSelf==m_caster || m_caster->IsWithinDistInMap(ownerOrSelf, radius)) &&
1731 ownerOrSelf->getPowerType() == POWER_MANA)
1732 TagUnitMap.push_back(ownerOrSelf);
1734 if(Pet* pet = ownerOrSelf->GetPet())
1735 if( m_caster->IsWithinDistInMap(pet, radius) && pet->getPowerType() == POWER_MANA )
1736 TagUnitMap.push_back(pet);
1739 if (m_spellInfo->Id==52759) //Ancestral Awakening (special target selection)
1741 float lowestPerc = (float)m_caster->GetHealth() / (float)m_caster->GetMaxHealth();
1742 Unit* lowestTarget = m_caster;
1744 if (pGroup)
1746 Group::MemberSlotList const& members = pGroup->GetMemberSlots();
1747 Group::MemberSlotList::const_iterator itr = members.begin();
1748 for(; itr != members.end(); ++itr)
1750 if (Unit* member = ObjectAccessor::GetPlayer(*m_caster, (*itr).guid))
1752 if (member == m_caster || member->isDead() || m_caster->IsHostileTo(member) || !m_caster->IsWithinDistInMap(member, radius))
1753 continue;
1755 float perc = (float)member->GetHealth() / (float)member->GetMaxHealth();
1756 if (perc <= lowestPerc)
1758 lowestPerc = perc;
1759 lowestTarget = member;
1764 TagUnitMap.push_back(lowestTarget);
1766 else
1768 if(pGroup)
1770 for(GroupReference *itr = pGroup->GetFirstMember(); itr != NULL; itr = itr->next())
1772 Player* Target = itr->getSource();
1774 // IsHostileTo check duel and controlled by enemy
1775 if( Target && !m_caster->IsHostileTo(Target) )
1777 if( m_caster->IsWithinDistInMap(Target, radius) )
1778 TagUnitMap.push_back(Target);
1780 if(Pet* pet = Target->GetPet())
1781 if( m_caster->IsWithinDistInMap(pet, radius) )
1782 TagUnitMap.push_back(pet);
1786 else
1788 Unit* ownerOrSelf = pTarget ? pTarget : m_caster->GetCharmerOrOwnerOrSelf();
1789 if(ownerOrSelf==m_caster || m_caster->IsWithinDistInMap(ownerOrSelf, radius))
1790 TagUnitMap.push_back(ownerOrSelf);
1791 if(Pet* pet = ownerOrSelf->GetPet())
1792 if( m_caster->IsWithinDistInMap(pet, radius) )
1793 TagUnitMap.push_back(pet);
1796 break;
1798 case TARGET_SINGLE_FRIEND:
1799 case TARGET_SINGLE_FRIEND_2:
1801 if(m_targets.getUnitTarget())
1802 TagUnitMap.push_back(m_targets.getUnitTarget());
1803 }break;
1804 case TARGET_NONCOMBAT_PET:
1806 if(Unit* target = m_targets.getUnitTarget())
1807 if( target->GetTypeId() == TYPEID_UNIT && ((Creature*)target)->isPet() && ((Pet*)target)->getPetType() == MINI_PET)
1808 TagUnitMap.push_back(target);
1809 }break;
1810 case TARGET_CASTER_COORDINATES:
1812 // Check original caster is GO - set its coordinates as dst cast
1813 WorldObject *caster = NULL;
1814 if (IS_GAMEOBJECT_GUID(m_originalCasterGUID))
1815 caster = m_caster->GetMap()->GetGameObject(m_originalCasterGUID);
1816 if (!caster)
1817 caster = m_caster;
1818 // Set dest for targets
1819 m_targets.setDestination(caster->GetPositionX(), caster->GetPositionY(), caster->GetPositionZ());
1820 }break;
1821 case TARGET_ALL_FRIENDLY_UNITS_AROUND_CASTER:
1822 FillAreaTargets(TagUnitMap, m_targets.m_destX, m_targets.m_destY, radius, PUSH_SELF_CENTER, SPELL_TARGETS_FRIENDLY);
1823 break;
1824 case TARGET_ALL_FRIENDLY_UNITS_IN_AREA:
1825 FillAreaTargets(TagUnitMap, m_targets.m_destX, m_targets.m_destY, radius, PUSH_DEST_CENTER, SPELL_TARGETS_FRIENDLY);
1826 break;
1827 // TARGET_SINGLE_PARTY means that the spells can only be casted on a party member and not on the caster (some seals, fire shield from imp, etc..)
1828 case TARGET_SINGLE_PARTY:
1830 Unit *target = m_targets.getUnitTarget();
1831 // Thoses spells apparently can't be casted on the caster.
1832 if( target && target != m_caster)
1834 // Can only be casted on group's members or its pets
1835 Group *pGroup = NULL;
1837 Unit* owner = m_caster->GetCharmerOrOwner();
1838 Unit *targetOwner = target->GetCharmerOrOwner();
1839 if(owner)
1841 if(owner->GetTypeId() == TYPEID_PLAYER)
1843 if( target == owner )
1845 TagUnitMap.push_back(target);
1846 break;
1848 pGroup = ((Player*)owner)->GetGroup();
1851 else if (m_caster->GetTypeId() == TYPEID_PLAYER)
1853 if( targetOwner == m_caster && target->GetTypeId() == TYPEID_UNIT && ((Creature*)target)->isPet())
1855 TagUnitMap.push_back(target);
1856 break;
1858 pGroup = ((Player*)m_caster)->GetGroup();
1861 if(pGroup)
1863 // Our target can also be a player's pet who's grouped with us or our pet. But can't be controlled player
1864 if(targetOwner)
1866 if( targetOwner->GetTypeId() == TYPEID_PLAYER &&
1867 target->GetTypeId() == TYPEID_UNIT && (((Creature*)target)->isPet()) &&
1868 target->GetOwnerGUID() == targetOwner->GetGUID() &&
1869 pGroup->IsMember(((Player*)targetOwner)->GetGUID()))
1871 TagUnitMap.push_back(target);
1874 // 1Our target can be a player who is on our group
1875 else if (target->GetTypeId() == TYPEID_PLAYER && pGroup->IsMember(((Player*)target)->GetGUID()))
1877 TagUnitMap.push_back(target);
1881 }break;
1882 case TARGET_GAMEOBJECT:
1884 if(m_targets.getGOTarget())
1885 AddGOTarget(m_targets.getGOTarget(), i);
1886 }break;
1887 case TARGET_IN_FRONT_OF_CASTER:
1889 bool inFront = m_spellInfo->SpellVisual[0] != 3879;
1890 FillAreaTargets(TagUnitMap,m_caster->GetPositionX(), m_caster->GetPositionY(),radius,inFront ? PUSH_IN_FRONT : PUSH_IN_BACK,SPELL_TARGETS_AOE_DAMAGE);
1891 break;
1893 case TARGET_DUELVSPLAYER:
1895 Unit *target = m_targets.getUnitTarget();
1896 if(target)
1898 if(m_caster->IsFriendlyTo(target))
1900 TagUnitMap.push_back(target);
1902 else
1904 if(Unit* pUnitTarget = m_caster->SelectMagnetTarget(m_targets.getUnitTarget(), m_spellInfo))
1906 m_targets.setUnitTarget(pUnitTarget);
1907 TagUnitMap.push_back(pUnitTarget);
1911 }break;
1912 case TARGET_GAMEOBJECT_ITEM:
1914 if(m_targets.getGOTargetGUID())
1915 AddGOTarget(m_targets.getGOTarget(), i);
1916 else if(m_targets.getItemTarget())
1917 AddItemTarget(m_targets.getItemTarget(), i);
1918 break;
1920 case TARGET_MASTER:
1922 if(Unit* owner = m_caster->GetCharmerOrOwner())
1923 TagUnitMap.push_back(owner);
1924 break;
1926 case TARGET_ALL_ENEMY_IN_AREA_CHANNELED:
1928 // targets the ground, not the units in the area
1929 if (m_spellInfo->Effect[i]!=SPELL_EFFECT_PERSISTENT_AREA_AURA)
1930 FillAreaTargets(TagUnitMap, m_targets.m_destX, m_targets.m_destY, radius, PUSH_DEST_CENTER, SPELL_TARGETS_AOE_DAMAGE);
1931 break;
1933 case TARGET_MINION:
1935 if(m_spellInfo->Effect[i] != SPELL_EFFECT_DUEL)
1936 TagUnitMap.push_back(m_caster);
1937 }break;
1938 case TARGET_SINGLE_ENEMY:
1940 if(Unit* pUnitTarget = m_caster->SelectMagnetTarget(m_targets.getUnitTarget(), m_spellInfo))
1942 m_targets.setUnitTarget(pUnitTarget);
1943 TagUnitMap.push_back(pUnitTarget);
1945 }break;
1946 case TARGET_AREAEFFECT_PARTY:
1948 Unit* owner = m_caster->GetCharmerOrOwner();
1949 Player *pTarget = NULL;
1951 if(owner)
1953 TagUnitMap.push_back(m_caster);
1954 if(owner->GetTypeId() == TYPEID_PLAYER)
1955 pTarget = (Player*)owner;
1957 else if (m_caster->GetTypeId() == TYPEID_PLAYER)
1959 if(Unit* target = m_targets.getUnitTarget())
1961 if( target->GetTypeId() != TYPEID_PLAYER)
1963 if(((Creature*)target)->isPet())
1965 Unit *targetOwner = target->GetOwner();
1966 if(targetOwner->GetTypeId() == TYPEID_PLAYER)
1967 pTarget = (Player*)targetOwner;
1970 else
1971 pTarget = (Player*)target;
1975 Group* pGroup = pTarget ? pTarget->GetGroup() : NULL;
1977 if(pGroup)
1979 uint8 subgroup = pTarget->GetSubGroup();
1981 for(GroupReference *itr = pGroup->GetFirstMember(); itr != NULL; itr = itr->next())
1983 Player* Target = itr->getSource();
1985 // IsHostileTo check duel and controlled by enemy
1986 if(Target && Target->GetSubGroup()==subgroup && !m_caster->IsHostileTo(Target))
1988 if( pTarget->IsWithinDistInMap(Target, radius) )
1989 TagUnitMap.push_back(Target);
1991 if(Pet* pet = Target->GetPet())
1992 if( pTarget->IsWithinDistInMap(pet, radius) )
1993 TagUnitMap.push_back(pet);
1997 else if (owner)
1999 if(m_caster->IsWithinDistInMap(owner, radius))
2000 TagUnitMap.push_back(owner);
2002 else if(pTarget)
2004 TagUnitMap.push_back(pTarget);
2006 if(Pet* pet = pTarget->GetPet())
2007 if( m_caster->IsWithinDistInMap(pet, radius) )
2008 TagUnitMap.push_back(pet);
2011 }break;
2012 case TARGET_SCRIPT:
2014 if(m_targets.getUnitTarget())
2015 TagUnitMap.push_back(m_targets.getUnitTarget());
2016 if(m_targets.getItemTarget())
2017 AddItemTarget(m_targets.getItemTarget(), i);
2018 }break;
2019 case TARGET_SELF_FISHING:
2021 TagUnitMap.push_back(m_caster);
2022 }break;
2023 case TARGET_CHAIN_HEAL:
2025 Unit* pUnitTarget = m_targets.getUnitTarget();
2026 if(!pUnitTarget)
2027 break;
2029 if (EffectChainTarget <= 1)
2030 TagUnitMap.push_back(pUnitTarget);
2031 else
2033 unMaxTargets = EffectChainTarget;
2034 float max_range = radius + unMaxTargets * CHAIN_SPELL_JUMP_RADIUS;
2036 UnitList tempUnitMap;
2038 FillAreaTargets(tempUnitMap, m_caster->GetPositionX(), m_caster->GetPositionY(), max_range, PUSH_SELF_CENTER, SPELL_TARGETS_FRIENDLY);
2040 if(m_caster != pUnitTarget && std::find(tempUnitMap.begin(),tempUnitMap.end(), m_caster) == tempUnitMap.end() )
2041 tempUnitMap.push_front(m_caster);
2043 tempUnitMap.sort(TargetDistanceOrder(pUnitTarget));
2045 if(tempUnitMap.empty())
2046 break;
2048 if(*tempUnitMap.begin() == pUnitTarget)
2049 tempUnitMap.erase(tempUnitMap.begin());
2051 TagUnitMap.push_back(pUnitTarget);
2052 uint32 t = unMaxTargets - 1;
2053 Unit *prev = pUnitTarget;
2054 std::list<Unit*>::iterator next = tempUnitMap.begin();
2056 while(t && next != tempUnitMap.end() )
2058 if(!prev->IsWithinDist(*next, CHAIN_SPELL_JUMP_RADIUS))
2059 break;
2061 if(!prev->IsWithinLOSInMap(*next))
2063 ++next;
2064 continue;
2067 if((*next)->GetHealth() == (*next)->GetMaxHealth())
2069 next = tempUnitMap.erase(next);
2070 continue;
2073 prev = *next;
2074 TagUnitMap.push_back(prev);
2075 tempUnitMap.erase(next);
2076 tempUnitMap.sort(TargetDistanceOrder(prev));
2077 next = tempUnitMap.begin();
2079 --t;
2082 }break;
2083 case TARGET_CURRENT_ENEMY_COORDINATES:
2085 Unit* currentTarget = m_targets.getUnitTarget();
2086 if(currentTarget)
2088 TagUnitMap.push_back(currentTarget);
2089 m_targets.setDestination(currentTarget->GetPositionX(), currentTarget->GetPositionY(), currentTarget->GetPositionZ());
2090 if(m_spellInfo->EffectImplicitTargetB[i]==TARGET_ALL_ENEMY_IN_AREA_INSTANT)
2091 FillAreaTargets(TagUnitMap, currentTarget->GetPositionX(), currentTarget->GetPositionY(), radius, PUSH_TARGET_CENTER, SPELL_TARGETS_AOE_DAMAGE);
2093 break;
2095 case TARGET_AREAEFFECT_PARTY_AND_CLASS:
2097 Player* targetPlayer = m_targets.getUnitTarget() && m_targets.getUnitTarget()->GetTypeId() == TYPEID_PLAYER
2098 ? (Player*)m_targets.getUnitTarget() : NULL;
2100 Group* pGroup = targetPlayer ? targetPlayer->GetGroup() : NULL;
2101 if(pGroup)
2103 for(GroupReference *itr = pGroup->GetFirstMember(); itr != NULL; itr = itr->next())
2105 Player* Target = itr->getSource();
2107 // IsHostileTo check duel and controlled by enemy
2108 if( Target && targetPlayer->IsWithinDistInMap(Target, radius) &&
2109 targetPlayer->getClass() == Target->getClass() &&
2110 !m_caster->IsHostileTo(Target) )
2112 TagUnitMap.push_back(Target);
2116 else if(m_targets.getUnitTarget())
2117 TagUnitMap.push_back(m_targets.getUnitTarget());
2118 break;
2120 case TARGET_TABLE_X_Y_Z_COORDINATES:
2122 SpellTargetPosition const* st = spellmgr.GetSpellTargetPosition(m_spellInfo->Id);
2123 if(st)
2125 if (st->target_mapId == m_caster->GetMapId())
2126 m_targets.setDestination(st->target_X, st->target_Y, st->target_Z);
2127 else
2128 sLog.outError( "SPELL: wrong map (%u instead %u) target coordinates for spell ID %u", st->target_mapId, m_caster->GetMapId(), m_spellInfo->Id );
2130 else
2131 sLog.outError( "SPELL: unknown target coordinates for spell ID %u", m_spellInfo->Id );
2132 }break;
2133 case TARGET_BEHIND_VICTIM:
2135 Unit *pTarget = NULL;
2137 // explicit cast data from client or server-side cast
2138 // some spell at client send caster
2139 if(m_targets.getUnitTarget() && m_targets.getUnitTarget()!=m_caster)
2140 pTarget = m_targets.getUnitTarget();
2141 else if(m_caster->getVictim())
2142 pTarget = m_caster->getVictim();
2143 else if(m_caster->GetTypeId() == TYPEID_PLAYER)
2144 pTarget = ObjectAccessor::GetUnit(*m_caster, ((Player*)m_caster)->GetSelection());
2146 if(pTarget)
2148 float _target_x, _target_y, _target_z;
2149 pTarget->GetClosePoint(_target_x, _target_y, _target_z, m_caster->GetObjectSize(), CONTACT_DISTANCE, M_PI);
2150 if(pTarget->IsWithinLOS(_target_x, _target_y, _target_z))
2152 TagUnitMap.push_back(m_caster);
2153 m_targets.setDestination(_target_x, _target_y, _target_z);
2156 break;
2158 case TARGET_DYNAMIC_OBJECT_COORDINATES:
2160 // if parent spell create dynamic object extract area from it
2161 if(DynamicObject* dynObj = m_caster->GetDynObject(m_triggeredByAuraSpell ? m_triggeredByAuraSpell->Id : m_spellInfo->Id))
2162 m_targets.setDestination(dynObj->GetPositionX(), dynObj->GetPositionY(), dynObj->GetPositionZ());
2163 break;
2165 case TARGET_DIRECTLY_FORWARD:
2167 if (!(m_targets.m_targetMask & TARGET_FLAG_DEST_LOCATION))
2169 SpellRangeEntry const* rEntry = sSpellRangeStore.LookupEntry(m_spellInfo->rangeIndex);
2170 float minRange = GetSpellMinRange(rEntry);
2171 float maxRange = GetSpellMaxRange(rEntry);
2172 float dist = minRange+ rand_norm()*(maxRange-minRange);
2174 float _target_x, _target_y, _target_z;
2175 m_caster->GetClosePoint(_target_x, _target_y, _target_z, m_caster->GetObjectSize(), dist);
2176 m_targets.setDestination(_target_x, _target_y, _target_z);
2179 TagUnitMap.push_back(m_caster);
2180 break;
2182 default:
2183 break;
2186 if (unMaxTargets && TagUnitMap.size() > unMaxTargets)
2188 // make sure one unit is always removed per iteration
2189 uint32 removed_utarget = 0;
2190 for (UnitList::iterator itr = TagUnitMap.begin(), next; itr != TagUnitMap.end(); itr = next)
2192 next = itr;
2193 ++next;
2194 if (!*itr) continue;
2195 if ((*itr) == m_targets.getUnitTarget())
2197 TagUnitMap.erase(itr);
2198 removed_utarget = 1;
2199 // break;
2202 // remove random units from the map
2203 while (TagUnitMap.size() > unMaxTargets - removed_utarget)
2205 uint32 poz = urand(0, TagUnitMap.size()-1);
2206 for (UnitList::iterator itr = TagUnitMap.begin(); itr != TagUnitMap.end(); ++itr, --poz)
2208 if (!*itr) continue;
2210 if (!poz)
2212 TagUnitMap.erase(itr);
2213 break;
2217 // the player's target will always be added to the map
2218 if (removed_utarget && m_targets.getUnitTarget())
2219 TagUnitMap.push_back(m_targets.getUnitTarget());
2223 void Spell::prepare(SpellCastTargets const* targets, Aura* triggeredByAura)
2225 m_targets = *targets;
2227 m_spellState = SPELL_STATE_PREPARING;
2229 m_castPositionX = m_caster->GetPositionX();
2230 m_castPositionY = m_caster->GetPositionY();
2231 m_castPositionZ = m_caster->GetPositionZ();
2232 m_castOrientation = m_caster->GetOrientation();
2234 if(triggeredByAura)
2235 m_triggeredByAuraSpell = triggeredByAura->GetSpellProto();
2237 // create and add update event for this spell
2238 SpellEvent* Event = new SpellEvent(this);
2239 m_caster->m_Events.AddEvent(Event, m_caster->m_Events.CalculateTime(1));
2241 //Prevent casting at cast another spell (ServerSide check)
2242 if(m_caster->IsNonMeleeSpellCasted(false, true, true) && m_cast_count)
2244 SendCastResult(SPELL_FAILED_SPELL_IN_PROGRESS);
2245 finish(false);
2246 return;
2249 // Fill cost data
2250 m_powerCost = CalculatePowerCost();
2252 SpellCastResult result = CheckCast(true);
2253 if(result != SPELL_CAST_OK && !IsAutoRepeat()) //always cast autorepeat dummy for triggering
2255 if(triggeredByAura)
2257 SendChannelUpdate(0);
2258 triggeredByAura->SetAuraDuration(0);
2260 SendCastResult(result);
2261 finish(false);
2262 return;
2265 // Prepare data for triggers
2266 prepareDataForTriggerSystem();
2268 // calculate cast time (calculated after first CheckCast check to prevent charge counting for first CheckCast fail)
2269 m_casttime = GetSpellCastTime(m_spellInfo, this);
2271 // set timer base at cast time
2272 ReSetTimer();
2274 // stealth must be removed at cast starting (at show channel bar)
2275 // skip triggered spell (item equip spell casting and other not explicit character casts/item uses)
2276 if ( !m_IsTriggeredSpell && isSpellBreakStealth(m_spellInfo) )
2278 m_caster->RemoveSpellsCausingAura(SPELL_AURA_MOD_STEALTH);
2279 m_caster->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
2282 if(m_IsTriggeredSpell)
2283 cast(true);
2284 else
2286 m_caster->SetCurrentCastedSpell( this );
2287 m_selfContainer = &(m_caster->m_currentSpells[GetCurrentContainer()]);
2288 SendSpellStart();
2292 void Spell::cancel()
2294 if(m_spellState == SPELL_STATE_FINISHED)
2295 return;
2297 m_autoRepeat = false;
2298 switch (m_spellState)
2300 case SPELL_STATE_PREPARING:
2301 case SPELL_STATE_DELAYED:
2303 SendInterrupted(0);
2304 SendCastResult(SPELL_FAILED_INTERRUPTED);
2305 } break;
2307 case SPELL_STATE_CASTING:
2309 for(std::list<TargetInfo>::const_iterator ihit= m_UniqueTargetInfo.begin();ihit != m_UniqueTargetInfo.end();++ihit)
2311 if( ihit->missCondition == SPELL_MISS_NONE )
2313 Unit* unit = m_caster->GetGUID()==(*ihit).targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID);
2314 if( unit && unit->isAlive() )
2315 unit->RemoveAurasDueToSpell(m_spellInfo->Id);
2319 m_caster->RemoveAurasDueToSpell(m_spellInfo->Id);
2320 SendChannelUpdate(0);
2321 SendInterrupted(0);
2322 SendCastResult(SPELL_FAILED_INTERRUPTED);
2323 } break;
2325 default:
2327 } break;
2330 finish(false);
2331 m_caster->RemoveDynObject(m_spellInfo->Id);
2332 m_caster->RemoveGameObject(m_spellInfo->Id,true);
2335 void Spell::cast(bool skipCheck)
2337 SetExecutedCurrently(true);
2339 // update pointers base at GUIDs to prevent access to non-existed already object
2340 UpdatePointers();
2342 // cancel at lost main target unit
2343 if(!m_targets.getUnitTarget() && m_targets.getUnitTargetGUID() && m_targets.getUnitTargetGUID() != m_caster->GetGUID())
2345 cancel();
2346 SetExecutedCurrently(false);
2347 return;
2350 if(m_caster->GetTypeId() != TYPEID_PLAYER && m_targets.getUnitTarget() && m_targets.getUnitTarget() != m_caster)
2351 m_caster->SetInFront(m_targets.getUnitTarget());
2353 SpellCastResult castResult = CheckPower();
2354 if(castResult != SPELL_CAST_OK)
2356 SendCastResult(castResult);
2357 finish(false);
2358 SetExecutedCurrently(false);
2359 return;
2362 // triggered cast called from Spell::prepare where it was already checked
2363 if(!skipCheck)
2365 castResult = CheckCast(false);
2366 if(castResult != SPELL_CAST_OK)
2368 SendCastResult(castResult);
2369 finish(false);
2370 SetExecutedCurrently(false);
2371 return;
2375 switch(m_spellInfo->SpellFamilyName)
2377 case SPELLFAMILY_GENERIC:
2379 if (m_spellInfo->Mechanic == MECHANIC_BANDAGE) // Bandages
2380 m_preCastSpell = 11196; // Recently Bandaged
2381 else if(m_spellInfo->SpellIconID == 1662 && m_spellInfo->AttributesEx & 0x20) // Blood Fury (Racial)
2382 m_preCastSpell = 23230; // Blood Fury - Healing Reduction
2383 break;
2385 case SPELLFAMILY_MAGE:
2387 // Ice Block
2388 if (m_spellInfo->SpellFamilyFlags & UI64LIT(0x0000008000000000))
2389 m_preCastSpell = 41425; // Hypothermia
2390 break;
2392 case SPELLFAMILY_PRIEST:
2394 if (m_spellInfo->Mechanic == MECHANIC_SHIELD &&
2395 m_spellInfo->SpellIconID == 566) // Power Word: Shield
2396 m_preCastSpell = 6788; // Weakened Soul
2397 if (m_spellInfo->Id == 47585) // Dispersion (transform)
2398 m_preCastSpell = 60069; // Dispersion (mana regen)
2399 break;
2401 case SPELLFAMILY_PALADIN:
2403 // Divine Shield, Divine Protection or Hand of Protection
2404 if (m_spellInfo->SpellFamilyFlags & UI64LIT(0x0000000000400080))
2405 m_preCastSpell = 25771; // Forbearance
2406 break;
2408 case SPELLFAMILY_SHAMAN:
2410 if (m_spellInfo->Id == 2825) // Bloodlust
2411 m_preCastSpell = 57724; // Sated
2412 else if (m_spellInfo->Id == 32182) // Heroism
2413 m_preCastSpell = 57723; // Exhaustion
2414 break;
2416 default:
2417 break;
2420 // Conflagrate - consumes immolate
2421 if ((m_spellInfo->TargetAuraState == AURA_STATE_IMMOLATE) && m_targets.getUnitTarget())
2423 // for caster applied auras only
2424 Unit::AuraList const &mPeriodic = m_targets.getUnitTarget()->GetAurasByType(SPELL_AURA_PERIODIC_DAMAGE);
2425 for(Unit::AuraList::const_iterator i = mPeriodic.begin(); i != mPeriodic.end(); ++i)
2427 if( (*i)->GetSpellProto()->SpellFamilyName == SPELLFAMILY_WARLOCK && ((*i)->GetSpellProto()->SpellFamilyFlags & 4) &&
2428 (*i)->GetCasterGUID()==m_caster->GetGUID() )
2430 m_targets.getUnitTarget()->RemoveAura((*i)->GetId(), (*i)->GetEffIndex());
2431 break;
2436 // traded items have trade slot instead of guid in m_itemTargetGUID
2437 // set to real guid to be sent later to the client
2438 m_targets.updateTradeSlotItem();
2440 if (m_caster->GetTypeId() == TYPEID_PLAYER)
2442 if (!m_IsTriggeredSpell && m_CastItem)
2443 ((Player*)m_caster)->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM, m_CastItem->GetEntry());
2445 ((Player*)m_caster)->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL, m_spellInfo->Id);
2448 FillTargetMap();
2450 if(m_spellState == SPELL_STATE_FINISHED) // stop cast if spell marked as finish somewhere in FillTargetMap
2452 SetExecutedCurrently(false);
2453 return;
2456 // CAST SPELL
2457 SendSpellCooldown();
2459 TakePower();
2460 TakeReagents(); // we must remove reagents before HandleEffects to allow place crafted item in same slot
2462 SendCastResult(castResult);
2463 SendSpellGo(); // we must send smsg_spell_go packet before m_castItem delete in TakeCastItem()...
2465 // Okay, everything is prepared. Now we need to distinguish between immediate and evented delayed spells
2466 if (m_spellInfo->speed > 0.0f)
2469 // Remove used for cast item if need (it can be already NULL after TakeReagents call
2470 // in case delayed spell remove item at cast delay start
2471 TakeCastItem();
2473 // Okay, maps created, now prepare flags
2474 m_immediateHandled = false;
2475 m_spellState = SPELL_STATE_DELAYED;
2476 SetDelayStart(0);
2478 else
2480 // Immediate spell, no big deal
2481 handle_immediate();
2484 SetExecutedCurrently(false);
2487 void Spell::handle_immediate()
2489 // start channeling if applicable
2490 if(IsChanneledSpell(m_spellInfo))
2492 int32 duration = GetSpellDuration(m_spellInfo);
2493 if (duration)
2495 // Apply duration mod
2496 if(Player* modOwner = m_caster->GetSpellModOwner())
2497 modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_DURATION, duration);
2498 m_spellState = SPELL_STATE_CASTING;
2499 SendChannelStart(duration);
2503 // process immediate effects (items, ground, etc.) also initialize some variables
2504 _handle_immediate_phase();
2506 for(std::list<TargetInfo>::iterator ihit= m_UniqueTargetInfo.begin();ihit != m_UniqueTargetInfo.end();++ihit)
2507 DoAllEffectOnTarget(&(*ihit));
2509 for(std::list<GOTargetInfo>::iterator ihit= m_UniqueGOTargetInfo.begin();ihit != m_UniqueGOTargetInfo.end();++ihit)
2510 DoAllEffectOnTarget(&(*ihit));
2512 // spell is finished, perform some last features of the spell here
2513 _handle_finish_phase();
2515 // Remove used for cast item if need (it can be already NULL after TakeReagents call
2516 TakeCastItem();
2518 if(m_spellState != SPELL_STATE_CASTING)
2519 finish(true); // successfully finish spell cast (not last in case autorepeat or channel spell)
2522 uint64 Spell::handle_delayed(uint64 t_offset)
2524 uint64 next_time = 0;
2526 if (!m_immediateHandled)
2528 _handle_immediate_phase();
2529 m_immediateHandled = true;
2532 // now recheck units targeting correctness (need before any effects apply to prevent adding immunity at first effect not allow apply second spell effect and similar cases)
2533 for(std::list<TargetInfo>::iterator ihit= m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end();++ihit)
2535 if (ihit->processed == false)
2537 if ( ihit->timeDelay <= t_offset )
2538 DoAllEffectOnTarget(&(*ihit));
2539 else if( next_time == 0 || ihit->timeDelay < next_time )
2540 next_time = ihit->timeDelay;
2544 // now recheck gameobject targeting correctness
2545 for(std::list<GOTargetInfo>::iterator ighit= m_UniqueGOTargetInfo.begin(); ighit != m_UniqueGOTargetInfo.end();++ighit)
2547 if (ighit->processed == false)
2549 if ( ighit->timeDelay <= t_offset )
2550 DoAllEffectOnTarget(&(*ighit));
2551 else if( next_time == 0 || ighit->timeDelay < next_time )
2552 next_time = ighit->timeDelay;
2555 // All targets passed - need finish phase
2556 if (next_time == 0)
2558 // spell is finished, perform some last features of the spell here
2559 _handle_finish_phase();
2561 finish(true); // successfully finish spell cast
2563 // return zero, spell is finished now
2564 return 0;
2566 else
2568 // spell is unfinished, return next execution time
2569 return next_time;
2573 void Spell::_handle_immediate_phase()
2575 // handle some immediate features of the spell here
2576 HandleThreatSpells(m_spellInfo->Id);
2578 m_needSpellLog = IsNeedSendToClient();
2579 for(uint32 j = 0; j < 3; ++j)
2581 if(m_spellInfo->Effect[j] == 0)
2582 continue;
2584 // apply Send Event effect to ground in case empty target lists
2585 if( m_spellInfo->Effect[j] == SPELL_EFFECT_SEND_EVENT && !HaveTargetsForEffect(j) )
2587 HandleEffects(NULL, NULL, NULL, j);
2588 continue;
2591 // Don't do spell log, if is school damage spell
2592 if(m_spellInfo->Effect[j] == SPELL_EFFECT_SCHOOL_DAMAGE || m_spellInfo->Effect[j] == 0)
2593 m_needSpellLog = false;
2595 uint32 EffectChainTarget = m_spellInfo->EffectChainTarget[j];
2596 if(m_originalCaster)
2597 if(Player* modOwner = m_originalCaster->GetSpellModOwner())
2598 modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_JUMP_TARGETS, EffectChainTarget, this);
2600 // initialize multipliers
2601 m_damageMultipliers[j] = 1.0f;
2602 if( (m_spellInfo->EffectImplicitTargetA[j] == TARGET_CHAIN_DAMAGE || m_spellInfo->EffectImplicitTargetA[j] == TARGET_CHAIN_HEAL) &&
2603 (EffectChainTarget > 1) )
2604 m_applyMultiplierMask |= 1 << j;
2607 // initialize Diminishing Returns Data
2608 m_diminishLevel = DIMINISHING_LEVEL_1;
2609 m_diminishGroup = DIMINISHING_NONE;
2611 // process items
2612 for(std::list<ItemTargetInfo>::iterator ihit= m_UniqueItemInfo.begin();ihit != m_UniqueItemInfo.end();++ihit)
2613 DoAllEffectOnTarget(&(*ihit));
2615 // process ground
2616 for(uint32 j = 0; j < 3; ++j)
2618 // persistent area auras target only the ground
2619 if(m_spellInfo->Effect[j] == SPELL_EFFECT_PERSISTENT_AREA_AURA)
2620 HandleEffects(NULL, NULL, NULL, j);
2624 void Spell::_handle_finish_phase()
2626 // spell log
2627 if(m_needSpellLog)
2628 SendLogExecute();
2631 void Spell::SendSpellCooldown()
2633 if(m_caster->GetTypeId() != TYPEID_PLAYER)
2634 return;
2636 Player* _player = (Player*)m_caster;
2638 // mana/health/etc potions, disabled by client (until combat out as declarate)
2639 if (m_CastItem && m_CastItem->IsPotion())
2641 // need in some way provided data for Spell::finish SendCooldownEvent
2642 _player->SetLastPotionId(m_CastItem->GetEntry());
2643 return;
2646 // have infinity cooldown but set at aura apply
2647 if(m_spellInfo->Attributes & SPELL_ATTR_DISABLED_WHILE_ACTIVE)
2648 return;
2650 _player->AddSpellAndCategoryCooldowns(m_spellInfo,m_CastItem ? m_CastItem->GetEntry() : 0, this);
2653 void Spell::update(uint32 difftime)
2655 // update pointers based at it's GUIDs
2656 UpdatePointers();
2658 if(m_targets.getUnitTargetGUID() && !m_targets.getUnitTarget())
2660 cancel();
2661 return;
2664 // check if the player caster has moved before the spell finished
2665 if ((m_caster->GetTypeId() == TYPEID_PLAYER && m_timer != 0) &&
2666 (m_castPositionX != m_caster->GetPositionX() || m_castPositionY != m_caster->GetPositionY() || m_castPositionZ != m_caster->GetPositionZ()) &&
2667 (m_spellInfo->Effect[0] != SPELL_EFFECT_STUCK || !m_caster->HasUnitMovementFlag(MOVEMENTFLAG_FALLING)))
2669 // always cancel for channeled spells
2670 if( m_spellState == SPELL_STATE_CASTING )
2671 cancel();
2672 // don't cancel for melee, autorepeat, triggered and instant spells
2673 else if(!IsNextMeleeSwingSpell() && !IsAutoRepeat() && !m_IsTriggeredSpell && (m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_MOVEMENT))
2674 cancel();
2677 switch(m_spellState)
2679 case SPELL_STATE_PREPARING:
2681 if(m_timer)
2683 if(difftime >= m_timer)
2684 m_timer = 0;
2685 else
2686 m_timer -= difftime;
2689 if(m_timer == 0 && !IsNextMeleeSwingSpell() && !IsAutoRepeat())
2690 cast();
2691 } break;
2692 case SPELL_STATE_CASTING:
2694 if(m_timer > 0)
2696 if( m_caster->GetTypeId() == TYPEID_PLAYER )
2698 // check if player has jumped before the channeling finished
2699 if(m_caster->HasUnitMovementFlag(MOVEMENTFLAG_JUMPING))
2700 cancel();
2702 // check for incapacitating player states
2703 if( m_caster->hasUnitState(UNIT_STAT_STUNNED | UNIT_STAT_CONFUSED))
2704 cancel();
2706 // check if player has turned if flag is set
2707 if( m_spellInfo->ChannelInterruptFlags & CHANNEL_FLAG_TURNING && m_castOrientation != m_caster->GetOrientation() )
2708 cancel();
2711 // check if there are alive targets left
2712 if (!IsAliveUnitPresentInTargetList())
2714 SendChannelUpdate(0);
2715 finish();
2718 if(difftime >= m_timer)
2719 m_timer = 0;
2720 else
2721 m_timer -= difftime;
2724 if(m_timer == 0)
2726 SendChannelUpdate(0);
2728 // channeled spell processed independently for quest targeting
2729 // cast at creature (or GO) quest objectives update at successful cast channel finished
2730 // ignore autorepeat/melee casts for speed (not exist quest for spells (hm... )
2731 if( !IsAutoRepeat() && !IsNextMeleeSwingSpell() )
2733 if ( Player* p = m_caster->GetCharmerOrOwnerPlayerOrPlayerItself() )
2735 for(std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
2737 TargetInfo* target = &*ihit;
2738 if(!IS_CREATURE_GUID(target->targetGUID))
2739 continue;
2741 Unit* unit = m_caster->GetGUID() == target->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, target->targetGUID);
2742 if (unit == NULL)
2743 continue;
2745 p->CastedCreatureOrGO(unit->GetEntry(), unit->GetGUID(), m_spellInfo->Id);
2748 for(std::list<GOTargetInfo>::iterator ihit = m_UniqueGOTargetInfo.begin(); ihit != m_UniqueGOTargetInfo.end(); ++ihit)
2750 GOTargetInfo* target = &*ihit;
2752 GameObject* go = m_caster->GetMap()->GetGameObject(target->targetGUID);
2753 if(!go)
2754 continue;
2756 p->CastedCreatureOrGO(go->GetEntry(), go->GetGUID(), m_spellInfo->Id);
2761 finish();
2763 } break;
2764 default:
2766 }break;
2770 void Spell::finish(bool ok)
2772 if(!m_caster)
2773 return;
2775 if(m_spellState == SPELL_STATE_FINISHED)
2776 return;
2778 m_spellState = SPELL_STATE_FINISHED;
2780 // other code related only to successfully finished spells
2781 if(!ok)
2782 return;
2784 //remove spell mods
2785 if (m_caster->GetTypeId() == TYPEID_PLAYER)
2786 ((Player*)m_caster)->RemoveSpellMods(this);
2788 // handle SPELL_AURA_ADD_TARGET_TRIGGER auras
2789 Unit::AuraList const& targetTriggers = m_caster->GetAurasByType(SPELL_AURA_ADD_TARGET_TRIGGER);
2790 for(Unit::AuraList::const_iterator i = targetTriggers.begin(); i != targetTriggers.end(); ++i)
2792 if (!(*i)->isAffectedOnSpell(m_spellInfo))
2793 continue;
2794 for(std::list<TargetInfo>::const_iterator ihit= m_UniqueTargetInfo.begin();ihit != m_UniqueTargetInfo.end();++ihit)
2795 if( ihit->missCondition == SPELL_MISS_NONE )
2797 // check m_caster->GetGUID() let load auras at login and speedup most often case
2798 Unit *unit = m_caster->GetGUID()== ihit->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID);
2799 if (unit && unit->isAlive())
2801 SpellEntry const *auraSpellInfo = (*i)->GetSpellProto();
2802 uint32 auraSpellIdx = (*i)->GetEffIndex();
2803 // Calculate chance at that moment (can be depend for example from combo points)
2804 int32 chance = m_caster->CalculateSpellDamage(auraSpellInfo, auraSpellIdx, (*i)->GetBasePoints(),unit);
2805 if(roll_chance_i(chance))
2806 m_caster->CastSpell(unit, auraSpellInfo->EffectTriggerSpell[auraSpellIdx], true, NULL, (*i));
2811 // Heal caster for all health leech from all targets
2812 if (m_healthLeech)
2813 m_caster->DealHeal(m_caster, uint32(m_healthLeech), m_spellInfo);
2815 if (IsMeleeAttackResetSpell())
2817 m_caster->resetAttackTimer(BASE_ATTACK);
2818 if(m_caster->haveOffhandWeapon())
2819 m_caster->resetAttackTimer(OFF_ATTACK);
2822 /*if (IsRangedAttackResetSpell())
2823 m_caster->resetAttackTimer(RANGED_ATTACK);*/
2825 // Clear combo at finish state
2826 if(m_caster->GetTypeId() == TYPEID_PLAYER && NeedsComboPoints(m_spellInfo))
2828 // Not drop combopoints if negative spell and if any miss on enemy exist
2829 bool needDrop = true;
2830 if (!IsPositiveSpell(m_spellInfo->Id))
2831 for(std::list<TargetInfo>::const_iterator ihit= m_UniqueTargetInfo.begin();ihit != m_UniqueTargetInfo.end();++ihit)
2832 if (ihit->missCondition != SPELL_MISS_NONE && ihit->targetGUID!=m_caster->GetGUID())
2834 needDrop = false;
2835 break;
2837 if (needDrop)
2838 ((Player*)m_caster)->ClearComboPoints();
2841 // potions disabled by client, send event "not in combat" if need
2842 if (m_caster->GetTypeId() == TYPEID_PLAYER)
2843 ((Player*)m_caster)->UpdatePotionCooldown(this);
2845 // call triggered spell only at successful cast (after clear combo points -> for add some if need)
2846 if(!m_TriggerSpells.empty())
2847 TriggerSpell();
2849 // Stop Attack for some spells
2850 if( m_spellInfo->Attributes & SPELL_ATTR_STOP_ATTACK_TARGET )
2851 m_caster->AttackStop();
2854 void Spell::SendCastResult(SpellCastResult result)
2856 if(result == SPELL_CAST_OK)
2857 return;
2859 if (m_caster->GetTypeId() != TYPEID_PLAYER)
2860 return;
2862 if(((Player*)m_caster)->GetSession()->PlayerLoading()) // don't send cast results at loading time
2863 return;
2865 SendCastResult((Player*)m_caster,m_spellInfo,m_cast_count,result);
2868 void Spell::SendCastResult(Player* caster, SpellEntry const* spellInfo, uint8 cast_count, SpellCastResult result)
2870 if(result == SPELL_CAST_OK)
2871 return;
2873 WorldPacket data(SMSG_CAST_FAILED, (4+1+1));
2874 data << uint8(cast_count); // single cast or multi 2.3 (0/1)
2875 data << uint32(spellInfo->Id);
2876 data << uint8(result); // problem
2877 switch (result)
2879 case SPELL_FAILED_REQUIRES_SPELL_FOCUS:
2880 data << uint32(spellInfo->RequiresSpellFocus);
2881 break;
2882 case SPELL_FAILED_REQUIRES_AREA:
2883 // hardcode areas limitation case
2884 switch(spellInfo->Id)
2886 case 41617: // Cenarion Mana Salve
2887 case 41619: // Cenarion Healing Salve
2888 data << uint32(3905);
2889 break;
2890 case 41618: // Bottled Nethergon Energy
2891 case 41620: // Bottled Nethergon Vapor
2892 data << uint32(3842);
2893 break;
2894 case 45373: // Bloodberry Elixir
2895 data << uint32(4075);
2896 break;
2897 default: // default case (don't must be)
2898 data << uint32(0);
2899 break;
2901 break;
2902 case SPELL_FAILED_TOTEMS:
2903 if(spellInfo->Totem[0])
2904 data << uint32(spellInfo->Totem[0]);
2905 if(spellInfo->Totem[1])
2906 data << uint32(spellInfo->Totem[1]);
2907 break;
2908 case SPELL_FAILED_TOTEM_CATEGORY:
2909 if(spellInfo->TotemCategory[0])
2910 data << uint32(spellInfo->TotemCategory[0]);
2911 if(spellInfo->TotemCategory[1])
2912 data << uint32(spellInfo->TotemCategory[1]);
2913 break;
2914 case SPELL_FAILED_EQUIPPED_ITEM_CLASS:
2915 data << uint32(spellInfo->EquippedItemClass);
2916 data << uint32(spellInfo->EquippedItemSubClassMask);
2917 //data << uint32(spellInfo->EquippedItemInventoryTypeMask);
2918 break;
2919 default:
2920 break;
2922 caster->GetSession()->SendPacket(&data);
2925 void Spell::SendSpellStart()
2927 if(!IsNeedSendToClient())
2928 return;
2930 sLog.outDebug("Sending SMSG_SPELL_START id=%u", m_spellInfo->Id);
2932 uint32 castFlags = CAST_FLAG_UNKNOWN1;
2933 if(IsRangedSpell())
2934 castFlags |= CAST_FLAG_AMMO;
2936 if(m_spellInfo->runeCostID)
2937 castFlags |= CAST_FLAG_UNKNOWN10;
2939 WorldPacket data(SMSG_SPELL_START, (8+8+4+4+2));
2940 if(m_CastItem)
2941 data.append(m_CastItem->GetPackGUID());
2942 else
2943 data.append(m_caster->GetPackGUID());
2945 data.append(m_caster->GetPackGUID());
2946 data << uint8(m_cast_count); // pending spell cast?
2947 data << uint32(m_spellInfo->Id); // spellId
2948 data << uint32(castFlags); // cast flags
2949 data << uint32(m_timer); // delay?
2951 m_targets.write(&data);
2953 if ( castFlags & CAST_FLAG_UNKNOWN6 ) // predicted power?
2954 data << uint32(0);
2956 if ( castFlags & CAST_FLAG_UNKNOWN7 ) // rune cooldowns list
2958 uint8 v1 = 0;//m_runesState;
2959 uint8 v2 = 0;//((Player*)m_caster)->GetRunesState();
2960 data << uint8(v1); // runes state before
2961 data << uint8(v2); // runes state after
2962 for(uint8 i = 0; i < MAX_RUNES; ++i)
2964 uint8 m = (1 << i);
2965 if(m & v1) // usable before...
2966 if(!(m & v2)) // ...but on cooldown now...
2967 data << uint8(0); // some unknown byte (time?)
2971 if ( castFlags & CAST_FLAG_AMMO )
2972 WriteAmmoToPacket(&data);
2974 m_caster->SendMessageToSet(&data, true);
2977 void Spell::SendSpellGo()
2979 // not send invisible spell casting
2980 if(!IsNeedSendToClient())
2981 return;
2983 sLog.outDebug("Sending SMSG_SPELL_GO id=%u", m_spellInfo->Id);
2985 uint32 castFlags = CAST_FLAG_UNKNOWN3;
2986 if(IsRangedSpell())
2987 castFlags |= CAST_FLAG_AMMO; // arrows/bullets visual
2989 if((m_caster->GetTypeId() == TYPEID_PLAYER) && (m_caster->getClass() == CLASS_DEATH_KNIGHT) && m_spellInfo->runeCostID)
2991 castFlags |= CAST_FLAG_UNKNOWN10; // same as in SMSG_SPELL_START
2992 castFlags |= CAST_FLAG_UNKNOWN6; // makes cooldowns visible
2993 castFlags |= CAST_FLAG_UNKNOWN7; // rune cooldowns list
2996 WorldPacket data(SMSG_SPELL_GO, 50); // guess size
2998 if(m_CastItem)
2999 data.append(m_CastItem->GetPackGUID());
3000 else
3001 data.append(m_caster->GetPackGUID());
3003 data.append(m_caster->GetPackGUID());
3004 data << uint8(m_cast_count); // pending spell cast?
3005 data << uint32(m_spellInfo->Id); // spellId
3006 data << uint32(castFlags); // cast flags
3007 data << uint32(getMSTime()); // timestamp
3009 WriteSpellGoTargets(&data);
3011 m_targets.write(&data);
3013 if ( castFlags & CAST_FLAG_UNKNOWN6 ) // unknown wotlk, predicted power?
3014 data << uint32(0);
3016 if ( castFlags & CAST_FLAG_UNKNOWN7 ) // rune cooldowns list
3018 uint8 v1 = m_runesState;
3019 uint8 v2 = ((Player*)m_caster)->GetRunesState();
3020 data << uint8(v1); // runes state before
3021 data << uint8(v2); // runes state after
3022 for(uint8 i = 0; i < MAX_RUNES; ++i)
3024 uint8 m = (1 << i);
3025 if(m & v1) // usable before...
3026 if(!(m & v2)) // ...but on cooldown now...
3027 data << uint8(0); // some unknown byte (time?)
3031 if ( castFlags & CAST_FLAG_UNKNOWN4 ) // unknown wotlk
3033 data << float(0);
3034 data << uint32(0);
3037 if ( castFlags & CAST_FLAG_AMMO )
3038 WriteAmmoToPacket(&data);
3040 if ( castFlags & CAST_FLAG_UNKNOWN5 ) // unknown wotlk
3042 data << uint32(0);
3043 data << uint32(0);
3046 if ( m_targets.m_targetMask & TARGET_FLAG_DEST_LOCATION )
3048 data << uint8(0);
3051 m_caster->SendMessageToSet(&data, true);
3054 void Spell::WriteAmmoToPacket( WorldPacket * data )
3056 uint32 ammoInventoryType = 0;
3057 uint32 ammoDisplayID = 0;
3059 if (m_caster->GetTypeId() == TYPEID_PLAYER)
3061 Item *pItem = ((Player*)m_caster)->GetWeaponForAttack( RANGED_ATTACK );
3062 if(pItem)
3064 ammoInventoryType = pItem->GetProto()->InventoryType;
3065 if( ammoInventoryType == INVTYPE_THROWN )
3066 ammoDisplayID = pItem->GetProto()->DisplayInfoID;
3067 else
3069 uint32 ammoID = ((Player*)m_caster)->GetUInt32Value(PLAYER_AMMO_ID);
3070 if(ammoID)
3072 ItemPrototype const *pProto = objmgr.GetItemPrototype( ammoID );
3073 if(pProto)
3075 ammoDisplayID = pProto->DisplayInfoID;
3076 ammoInventoryType = pProto->InventoryType;
3079 else if(m_caster->GetDummyAura(46699)) // Requires No Ammo
3081 ammoDisplayID = 5996; // normal arrow
3082 ammoInventoryType = INVTYPE_AMMO;
3087 else
3089 for (uint8 i = 0; i < 3; ++i)
3091 if(uint32 item_id = m_caster->GetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + i))
3093 if(ItemEntry const * itemEntry = sItemStore.LookupEntry(item_id))
3095 if(itemEntry->Class==ITEM_CLASS_WEAPON)
3097 switch(itemEntry->SubClass)
3099 case ITEM_SUBCLASS_WEAPON_THROWN:
3100 ammoDisplayID = itemEntry->DisplayId;
3101 ammoInventoryType = itemEntry->InventoryType;
3102 break;
3103 case ITEM_SUBCLASS_WEAPON_BOW:
3104 case ITEM_SUBCLASS_WEAPON_CROSSBOW:
3105 ammoDisplayID = 5996; // is this need fixing?
3106 ammoInventoryType = INVTYPE_AMMO;
3107 break;
3108 case ITEM_SUBCLASS_WEAPON_GUN:
3109 ammoDisplayID = 5998; // is this need fixing?
3110 ammoInventoryType = INVTYPE_AMMO;
3111 break;
3114 if(ammoDisplayID)
3115 break;
3122 *data << uint32(ammoDisplayID);
3123 *data << uint32(ammoInventoryType);
3126 void Spell::WriteSpellGoTargets( WorldPacket * data )
3128 // This function also fill data for channeled spells:
3129 // m_needAliveTargetMask req for stop channelig if one target die
3130 uint32 hit = m_UniqueGOTargetInfo.size(); // Always hits on GO
3131 uint32 miss = 0;
3132 for(std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
3134 if ((*ihit).effectMask == 0) // No effect apply - all immuned add state
3136 // possibly SPELL_MISS_IMMUNE2 for this??
3137 ihit->missCondition = SPELL_MISS_IMMUNE2;
3138 ++miss;
3140 else if ((*ihit).missCondition == SPELL_MISS_NONE)
3141 ++hit;
3142 else
3143 ++miss;
3146 *data << (uint8)hit;
3147 for(std::list<TargetInfo>::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
3149 if ((*ihit).missCondition == SPELL_MISS_NONE) // Add only hits
3151 *data << uint64(ihit->targetGUID);
3152 m_needAliveTargetMask |=ihit->effectMask;
3156 for(std::list<GOTargetInfo>::const_iterator ighit = m_UniqueGOTargetInfo.begin(); ighit != m_UniqueGOTargetInfo.end(); ++ighit)
3157 *data << uint64(ighit->targetGUID); // Always hits
3159 *data << (uint8)miss;
3160 for(std::list<TargetInfo>::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
3162 if( ihit->missCondition != SPELL_MISS_NONE ) // Add only miss
3164 *data << uint64(ihit->targetGUID);
3165 *data << uint8(ihit->missCondition);
3166 if( ihit->missCondition == SPELL_MISS_REFLECT )
3167 *data << uint8(ihit->reflectResult);
3170 // Reset m_needAliveTargetMask for non channeled spell
3171 if(!IsChanneledSpell(m_spellInfo))
3172 m_needAliveTargetMask = 0;
3175 void Spell::SendLogExecute()
3177 Unit *target = m_targets.getUnitTarget() ? m_targets.getUnitTarget() : m_caster;
3179 WorldPacket data(SMSG_SPELLLOGEXECUTE, (8+4+4+4+4+8));
3181 if(m_caster->GetTypeId() == TYPEID_PLAYER)
3182 data.append(m_caster->GetPackGUID());
3183 else
3184 data.append(target->GetPackGUID());
3186 data << uint32(m_spellInfo->Id);
3187 uint32 count1 = 1;
3188 data << uint32(count1); // count1 (effect count?)
3189 for(uint32 i = 0; i < count1; ++i)
3191 data << uint32(m_spellInfo->Effect[0]); // spell effect
3192 uint32 count2 = 1;
3193 data << uint32(count2); // count2 (target count?)
3194 for(uint32 j = 0; j < count2; ++j)
3196 switch(m_spellInfo->Effect[0])
3198 case SPELL_EFFECT_POWER_DRAIN:
3199 if(Unit *unit = m_targets.getUnitTarget())
3200 data.append(unit->GetPackGUID());
3201 else
3202 data << uint8(0);
3203 data << uint32(0);
3204 data << uint32(0);
3205 data << float(0);
3206 break;
3207 case SPELL_EFFECT_ADD_EXTRA_ATTACKS:
3208 if(Unit *unit = m_targets.getUnitTarget())
3209 data.append(unit->GetPackGUID());
3210 else
3211 data << uint8(0);
3212 data << uint32(0); // count?
3213 break;
3214 case SPELL_EFFECT_INTERRUPT_CAST:
3215 if(Unit *unit = m_targets.getUnitTarget())
3216 data.append(unit->GetPackGUID());
3217 else
3218 data << uint8(0);
3219 data << uint32(0); // spellid
3220 break;
3221 case SPELL_EFFECT_DURABILITY_DAMAGE:
3222 if(Unit *unit = m_targets.getUnitTarget())
3223 data.append(unit->GetPackGUID());
3224 else
3225 data << uint8(0);
3226 data << uint32(0);
3227 data << uint32(0);
3228 break;
3229 case SPELL_EFFECT_OPEN_LOCK:
3230 case SPELL_EFFECT_OPEN_LOCK_ITEM:
3231 if(Item *item = m_targets.getItemTarget())
3232 data.append(item->GetPackGUID());
3233 else
3234 data << uint8(0);
3235 break;
3236 case SPELL_EFFECT_CREATE_ITEM:
3237 case SPELL_EFFECT_CREATE_ITEM_2:
3238 data << uint32(m_spellInfo->EffectItemType[0]);
3239 break;
3240 case SPELL_EFFECT_SUMMON:
3241 case SPELL_EFFECT_TRANS_DOOR:
3242 case SPELL_EFFECT_SUMMON_PET:
3243 case SPELL_EFFECT_SUMMON_OBJECT_WILD:
3244 case SPELL_EFFECT_CREATE_HOUSE:
3245 case SPELL_EFFECT_DUEL:
3246 case SPELL_EFFECT_SUMMON_OBJECT_SLOT1:
3247 case SPELL_EFFECT_SUMMON_OBJECT_SLOT2:
3248 case SPELL_EFFECT_SUMMON_OBJECT_SLOT3:
3249 case SPELL_EFFECT_SUMMON_OBJECT_SLOT4:
3250 if(Unit *unit = m_targets.getUnitTarget())
3251 data.append(unit->GetPackGUID());
3252 else if(m_targets.getItemTargetGUID())
3253 data.appendPackGUID(m_targets.getItemTargetGUID());
3254 else if(GameObject *go = m_targets.getGOTarget())
3255 data.append(go->GetPackGUID());
3256 else
3257 data << uint8(0); // guid
3258 break;
3259 case SPELL_EFFECT_FEED_PET:
3260 data << uint32(m_targets.getItemTargetEntry());
3261 break;
3262 case SPELL_EFFECT_DISMISS_PET:
3263 if(Unit *unit = m_targets.getUnitTarget())
3264 data.append(unit->GetPackGUID());
3265 else
3266 data << uint8(0);
3267 break;
3268 case SPELL_EFFECT_RESURRECT:
3269 case SPELL_EFFECT_RESURRECT_NEW:
3270 if(Unit *unit = m_targets.getUnitTarget())
3271 data.append(unit->GetPackGUID());
3272 else
3273 data << uint8(0);
3274 break;
3275 default:
3276 return;
3281 m_caster->SendMessageToSet(&data, true);
3284 void Spell::SendInterrupted(uint8 result)
3286 WorldPacket data(SMSG_SPELL_FAILURE, (8+4+1));
3287 data.append(m_caster->GetPackGUID());
3288 data << uint8(m_cast_count);
3289 data << uint32(m_spellInfo->Id);
3290 data << uint8(result);
3291 m_caster->SendMessageToSet(&data, true);
3293 data.Initialize(SMSG_SPELL_FAILED_OTHER, (8+4));
3294 data.append(m_caster->GetPackGUID());
3295 data << uint8(m_cast_count);
3296 data << uint32(m_spellInfo->Id);
3297 data << uint8(result);
3298 m_caster->SendMessageToSet(&data, true);
3301 void Spell::SendChannelUpdate(uint32 time)
3303 if(time == 0)
3305 m_caster->SetUInt64Value(UNIT_FIELD_CHANNEL_OBJECT, 0);
3306 m_caster->SetUInt32Value(UNIT_CHANNEL_SPELL, 0);
3309 if (m_caster->GetTypeId() != TYPEID_PLAYER)
3310 return;
3312 WorldPacket data( MSG_CHANNEL_UPDATE, 8+4 );
3313 data.append(m_caster->GetPackGUID());
3314 data << uint32(time);
3316 ((Player*)m_caster)->GetSession()->SendPacket( &data );
3319 void Spell::SendChannelStart(uint32 duration)
3321 WorldObject* target = NULL;
3323 // select first not resisted target from target list for _0_ effect
3324 if(!m_UniqueTargetInfo.empty())
3326 for(std::list<TargetInfo>::const_iterator itr = m_UniqueTargetInfo.begin(); itr != m_UniqueTargetInfo.end(); ++itr)
3328 if( (itr->effectMask & (1 << 0)) && itr->reflectResult == SPELL_MISS_NONE && itr->targetGUID != m_caster->GetGUID())
3330 target = ObjectAccessor::GetUnit(*m_caster, itr->targetGUID);
3331 break;
3335 else if(!m_UniqueGOTargetInfo.empty())
3337 for(std::list<GOTargetInfo>::const_iterator itr = m_UniqueGOTargetInfo.begin(); itr != m_UniqueGOTargetInfo.end(); ++itr)
3339 if(itr->effectMask & (1 << 0) )
3341 target = m_caster->GetMap()->GetGameObject(itr->targetGUID);
3342 break;
3347 if (m_caster->GetTypeId() == TYPEID_PLAYER)
3349 WorldPacket data( MSG_CHANNEL_START, (8+4+4) );
3350 data.append(m_caster->GetPackGUID());
3351 data << uint32(m_spellInfo->Id);
3352 data << uint32(duration);
3354 ((Player*)m_caster)->GetSession()->SendPacket( &data );
3357 m_timer = duration;
3358 if(target)
3359 m_caster->SetUInt64Value(UNIT_FIELD_CHANNEL_OBJECT, target->GetGUID());
3360 m_caster->SetUInt32Value(UNIT_CHANNEL_SPELL, m_spellInfo->Id);
3363 void Spell::SendResurrectRequest(Player* target)
3365 // Both players and NPCs can resurrect using spells - have a look at creature 28487 for example
3366 // However, the packet structure differs slightly
3368 const char* sentName = m_caster->GetTypeId() == TYPEID_PLAYER ? "" : m_caster->GetNameForLocaleIdx(target->GetSession()->GetSessionDbLocaleIndex());
3370 WorldPacket data(SMSG_RESURRECT_REQUEST, (8+4+strlen(sentName)+1+1+1));
3371 data << uint64(m_caster->GetGUID());
3372 data << uint32(strlen(sentName) + 1);
3374 data << sentName;
3375 data << uint8(0);
3377 data << uint8(m_caster->GetTypeId() == TYPEID_PLAYER ? 0 : 1);
3378 target->GetSession()->SendPacket(&data);
3381 void Spell::SendPlaySpellVisual(uint32 SpellID)
3383 if (m_caster->GetTypeId() != TYPEID_PLAYER)
3384 return;
3386 WorldPacket data(SMSG_PLAY_SPELL_VISUAL, 8 + 4);
3387 data << uint64(m_caster->GetGUID());
3388 data << uint32(SpellID); // spell visual id?
3389 ((Player*)m_caster)->GetSession()->SendPacket(&data);
3392 void Spell::TakeCastItem()
3394 if(!m_CastItem || m_caster->GetTypeId() != TYPEID_PLAYER)
3395 return;
3397 // not remove cast item at triggered spell (equipping, weapon damage, etc)
3398 if(m_IsTriggeredSpell)
3399 return;
3401 ItemPrototype const *proto = m_CastItem->GetProto();
3403 if(!proto)
3405 // This code is to avoid a crash
3406 // I'm not sure, if this is really an error, but I guess every item needs a prototype
3407 sLog.outError("Cast item has no item prototype highId=%d, lowId=%d",m_CastItem->GetGUIDHigh(), m_CastItem->GetGUIDLow());
3408 return;
3411 bool expendable = false;
3412 bool withoutCharges = false;
3414 for (int i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
3416 if (proto->Spells[i].SpellId)
3418 // item has limited charges
3419 if (proto->Spells[i].SpellCharges)
3421 if (proto->Spells[i].SpellCharges < 0)
3422 expendable = true;
3424 int32 charges = m_CastItem->GetSpellCharges(i);
3426 // item has charges left
3427 if (charges)
3429 (charges > 0) ? --charges : ++charges; // abs(charges) less at 1 after use
3430 if (proto->Stackable == 1)
3431 m_CastItem->SetSpellCharges(i, charges);
3432 m_CastItem->SetState(ITEM_CHANGED, (Player*)m_caster);
3435 // all charges used
3436 withoutCharges = (charges == 0);
3441 if (expendable && withoutCharges)
3443 uint32 count = 1;
3444 ((Player*)m_caster)->DestroyItemCount(m_CastItem, count, true);
3446 // prevent crash at access to deleted m_targets.getItemTarget
3447 if(m_CastItem==m_targets.getItemTarget())
3448 m_targets.setItemTarget(NULL);
3450 m_CastItem = NULL;
3454 void Spell::TakePower()
3456 if(m_CastItem || m_triggeredByAuraSpell)
3457 return;
3459 // health as power used
3460 if(m_spellInfo->powerType == POWER_HEALTH)
3462 m_caster->ModifyHealth( -(int32)m_powerCost );
3463 return;
3466 if(m_spellInfo->powerType >= MAX_POWERS)
3468 sLog.outError("Spell::TakePower: Unknown power type '%d'", m_spellInfo->powerType);
3469 return;
3472 Powers powerType = Powers(m_spellInfo->powerType);
3474 if(powerType == POWER_RUNE)
3476 TakeRunePower();
3477 return;
3480 m_caster->ModifyPower(powerType, -(int32)m_powerCost);
3482 // Set the five second timer
3483 if (powerType == POWER_MANA && m_powerCost > 0)
3484 m_caster->SetLastManaUse(getMSTime());
3487 SpellCastResult Spell::CheckRuneCost(uint32 runeCostID)
3489 if(m_caster->GetTypeId() != TYPEID_PLAYER)
3490 return SPELL_CAST_OK;
3492 Player *plr = (Player*)m_caster;
3494 if(plr->getClass() != CLASS_DEATH_KNIGHT)
3495 return SPELL_CAST_OK;
3497 SpellRuneCostEntry const *src = sSpellRuneCostStore.LookupEntry(runeCostID);
3499 if(!src)
3500 return SPELL_CAST_OK;
3502 if(src->NoRuneCost())
3503 return SPELL_CAST_OK;
3505 int32 runeCost[NUM_RUNE_TYPES]; // blood, frost, unholy, death
3507 for(uint32 i = 0; i < RUNE_DEATH; ++i)
3508 runeCost[i] = src->RuneCost[i];
3510 runeCost[RUNE_DEATH] = MAX_RUNES; // calculated later
3512 for(uint32 i = 0; i < MAX_RUNES; ++i)
3514 uint8 rune = plr->GetCurrentRune(i);
3515 if((plr->GetRuneCooldown(i) == 0) && (runeCost[rune] > 0))
3516 runeCost[rune]--;
3519 for(uint32 i = 0; i < RUNE_DEATH; ++i)
3520 if(runeCost[i] > 0)
3521 runeCost[RUNE_DEATH] += runeCost[i];
3523 if(runeCost[RUNE_DEATH] > MAX_RUNES)
3524 return SPELL_FAILED_NO_POWER; // not sure if result code is correct
3526 return SPELL_CAST_OK;
3529 void Spell::TakeRunePower()
3531 if(m_caster->GetTypeId() != TYPEID_PLAYER)
3532 return;
3534 Player *plr = (Player*)m_caster;
3536 if(plr->getClass() != CLASS_DEATH_KNIGHT)
3537 return;
3539 SpellRuneCostEntry const *src = sSpellRuneCostStore.LookupEntry(m_spellInfo->runeCostID);
3541 if(!src || (src->NoRuneCost() && src->NoRunicPowerGain()))
3542 return;
3544 m_runesState = plr->GetRunesState(); // store previous state
3546 int32 runeCost[NUM_RUNE_TYPES]; // blood, frost, unholy, death
3548 for(uint32 i = 0; i < RUNE_DEATH; ++i)
3550 runeCost[i] = src->RuneCost[i];
3553 runeCost[RUNE_DEATH] = 0; // calculated later
3555 for(uint32 i = 0; i < MAX_RUNES; ++i)
3557 uint8 rune = plr->GetCurrentRune(i);
3558 if((plr->GetRuneCooldown(i) == 0) && (runeCost[rune] > 0))
3560 plr->SetRuneCooldown(i, RUNE_COOLDOWN); // 5*2=10 sec
3561 runeCost[rune]--;
3565 runeCost[RUNE_DEATH] = runeCost[RUNE_BLOOD] + runeCost[RUNE_UNHOLY] + runeCost[RUNE_FROST];
3567 if(runeCost[RUNE_DEATH] > 0)
3569 for(uint32 i = 0; i < MAX_RUNES; ++i)
3571 uint8 rune = plr->GetCurrentRune(i);
3572 if((plr->GetRuneCooldown(i) == 0) && (rune == RUNE_DEATH))
3574 plr->SetRuneCooldown(i, RUNE_COOLDOWN); // 5*2=10 sec
3575 runeCost[rune]--;
3576 plr->ConvertRune(i, plr->GetBaseRune(i));
3577 if(runeCost[RUNE_DEATH] == 0)
3578 break;
3583 // you can gain some runic power when use runes
3584 float rp = src->runePowerGain;;
3585 rp *= sWorld.getRate(RATE_POWER_RUNICPOWER_INCOME);
3586 plr->ModifyPower(POWER_RUNIC_POWER, (int32)rp);
3589 void Spell::TakeReagents()
3591 if(m_IsTriggeredSpell) // reagents used in triggered spell removed by original spell or don't must be removed.
3592 return;
3594 if (m_caster->GetTypeId() != TYPEID_PLAYER)
3595 return;
3597 Player* p_caster = (Player*)m_caster;
3598 if (p_caster->CanNoReagentCast(m_spellInfo))
3599 return;
3601 for(uint32 x = 0; x < 8; ++x)
3603 if(m_spellInfo->Reagent[x] <= 0)
3604 continue;
3606 uint32 itemid = m_spellInfo->Reagent[x];
3607 uint32 itemcount = m_spellInfo->ReagentCount[x];
3609 // if CastItem is also spell reagent
3610 if (m_CastItem)
3612 ItemPrototype const *proto = m_CastItem->GetProto();
3613 if( proto && proto->ItemId == itemid )
3615 for(int s = 0; s < MAX_ITEM_PROTO_SPELLS; ++s)
3617 // CastItem will be used up and does not count as reagent
3618 int32 charges = m_CastItem->GetSpellCharges(s);
3619 if (proto->Spells[s].SpellCharges < 0 && abs(charges) < 2)
3621 ++itemcount;
3622 break;
3626 m_CastItem = NULL;
3630 // if getItemTarget is also spell reagent
3631 if (m_targets.getItemTargetEntry() == itemid)
3632 m_targets.setItemTarget(NULL);
3634 p_caster->DestroyItemCount(itemid, itemcount, true);
3638 void Spell::HandleThreatSpells(uint32 spellId)
3640 if(!m_targets.getUnitTarget() || !spellId)
3641 return;
3643 if(!m_targets.getUnitTarget()->CanHaveThreatList())
3644 return;
3646 SpellThreatEntry const *threatSpell = sSpellThreatStore.LookupEntry<SpellThreatEntry>(spellId);
3647 if(!threatSpell)
3648 return;
3650 m_targets.getUnitTarget()->AddThreat(m_caster, float(threatSpell->threat));
3652 DEBUG_LOG("Spell %u, rank %u, added an additional %i threat", spellId, spellmgr.GetSpellRank(spellId), threatSpell->threat);
3655 void Spell::HandleEffects(Unit *pUnitTarget,Item *pItemTarget,GameObject *pGOTarget,uint32 i, float DamageMultiplier)
3657 unitTarget = pUnitTarget;
3658 itemTarget = pItemTarget;
3659 gameObjTarget = pGOTarget;
3661 uint8 eff = m_spellInfo->Effect[i];
3663 damage = int32(CalculateDamage((uint8)i, unitTarget) * DamageMultiplier);
3665 sLog.outDebug( "Spell: Effect : %u", eff);
3667 if(eff<TOTAL_SPELL_EFFECTS)
3669 //sLog.outDebug( "WORLD: Spell FX %d < TOTAL_SPELL_EFFECTS ", eff);
3670 (*this.*SpellEffects[eff])(i);
3673 else
3675 sLog.outDebug( "WORLD: Spell FX %d > TOTAL_SPELL_EFFECTS ", eff);
3676 if (m_CastItem)
3677 EffectEnchantItemTmp(i);
3678 else
3680 sLog.outError("SPELL: unknown effect %u spell id %u",
3681 eff, m_spellInfo->Id);
3687 void Spell::TriggerSpell()
3689 for(TriggerSpells::const_iterator si=m_TriggerSpells.begin(); si!=m_TriggerSpells.end(); ++si)
3691 Spell* spell = new Spell(m_caster, (*si), true, m_originalCasterGUID, m_selfContainer);
3692 spell->prepare(&m_targets); // use original spell original targets
3696 SpellCastResult Spell::CheckCast(bool strict)
3698 // check cooldowns to prevent cheating
3699 if(m_caster->GetTypeId()==TYPEID_PLAYER && ((Player*)m_caster)->HasSpellCooldown(m_spellInfo->Id))
3701 if(m_triggeredByAuraSpell)
3702 return SPELL_FAILED_DONT_REPORT;
3703 else
3704 return SPELL_FAILED_NOT_READY;
3707 // only allow triggered spells if at an ended battleground
3708 if( !m_IsTriggeredSpell && m_caster->GetTypeId() == TYPEID_PLAYER)
3709 if(BattleGround * bg = ((Player*)m_caster)->GetBattleGround())
3710 if(bg->GetStatus() == STATUS_WAIT_LEAVE)
3711 return SPELL_FAILED_DONT_REPORT;
3713 // only check at first call, Stealth auras are already removed at second call
3714 // for now, ignore triggered spells
3715 if( strict && !m_IsTriggeredSpell)
3717 bool checkForm = true;
3718 // Ignore form req aura
3719 Unit::AuraList const& ignore = m_caster->GetAurasByType(SPELL_AURA_MOD_IGNORE_SHAPESHIFT);
3720 for(Unit::AuraList::const_iterator i = ignore.begin(); i != ignore.end(); ++i)
3722 if (!(*i)->isAffectedOnSpell(m_spellInfo))
3723 continue;
3724 checkForm = false;
3725 break;
3727 if (checkForm)
3729 // Cannot be used in this stance/form
3730 SpellCastResult shapeError = GetErrorAtShapeshiftedCast(m_spellInfo, m_caster->m_form);
3731 if(shapeError != SPELL_CAST_OK)
3732 return shapeError;
3734 if ((m_spellInfo->Attributes & SPELL_ATTR_ONLY_STEALTHED) && !(m_caster->HasStealthAura()))
3735 return SPELL_FAILED_ONLY_STEALTHED;
3739 // caster state requirements
3740 if(m_spellInfo->CasterAuraState && !m_caster->HasAuraState(AuraState(m_spellInfo->CasterAuraState)))
3741 return SPELL_FAILED_CASTER_AURASTATE;
3742 if(m_spellInfo->CasterAuraStateNot && m_caster->HasAuraState(AuraState(m_spellInfo->CasterAuraStateNot)))
3743 return SPELL_FAILED_CASTER_AURASTATE;
3745 // Caster aura req check if need
3746 if(m_spellInfo->casterAuraSpell && !m_caster->HasAura(m_spellInfo->casterAuraSpell))
3747 return SPELL_FAILED_CASTER_AURASTATE;
3748 if(m_spellInfo->excludeCasterAuraSpell && m_caster->HasAura(m_spellInfo->excludeCasterAuraSpell))
3749 return SPELL_FAILED_CASTER_AURASTATE;
3751 // cancel autorepeat spells if cast start when moving
3752 // (not wand currently autorepeat cast delayed to moving stop anyway in spell update code)
3753 if( m_caster->GetTypeId()==TYPEID_PLAYER && ((Player*)m_caster)->isMoving() )
3755 // skip stuck spell to allow use it in falling case and apply spell limitations at movement
3756 if( (!m_caster->HasUnitMovementFlag(MOVEMENTFLAG_FALLING) || m_spellInfo->Effect[0] != SPELL_EFFECT_STUCK) &&
3757 (IsAutoRepeat() || (m_spellInfo->AuraInterruptFlags & AURA_INTERRUPT_FLAG_NOT_SEATED) != 0) )
3758 return SPELL_FAILED_MOVING;
3761 if(Unit *target = m_targets.getUnitTarget())
3763 // target state requirements (not allowed state), apply to self also
3764 if(m_spellInfo->TargetAuraStateNot && target->HasAuraState(AuraState(m_spellInfo->TargetAuraStateNot)))
3765 return SPELL_FAILED_TARGET_AURASTATE;
3767 // Target aura req check if need
3768 if(m_spellInfo->targetAuraSpell && !target->HasAura(m_spellInfo->targetAuraSpell))
3769 return SPELL_FAILED_CASTER_AURASTATE;
3770 if(m_spellInfo->excludeTargetAuraSpell && target->HasAura(m_spellInfo->excludeTargetAuraSpell))
3771 return SPELL_FAILED_CASTER_AURASTATE;
3773 if(target != m_caster)
3775 // target state requirements (apply to non-self only), to allow cast affects to self like Dirty Deeds
3776 if(m_spellInfo->TargetAuraState && !target->HasAuraState(AuraState(m_spellInfo->TargetAuraState)))
3777 return SPELL_FAILED_TARGET_AURASTATE;
3779 // Not allow casting on flying player
3780 if (target->isInFlight())
3781 return SPELL_FAILED_BAD_TARGETS;
3783 if(!m_IsTriggeredSpell && VMAP::VMapFactory::checkSpellForLoS(m_spellInfo->Id) && !m_caster->IsWithinLOSInMap(target))
3784 return SPELL_FAILED_LINE_OF_SIGHT;
3786 // auto selection spell rank implemented in WorldSession::HandleCastSpellOpcode
3787 // this case can be triggered if rank not found (too low-level target for first rank)
3788 if(m_caster->GetTypeId() == TYPEID_PLAYER && !IsPassiveSpell(m_spellInfo->Id) && !m_CastItem)
3789 for(int i=0;i<3;++i)
3790 if(IsPositiveEffect(m_spellInfo->Id, i) && m_spellInfo->Effect[i] == SPELL_EFFECT_APPLY_AURA)
3791 if(target->getLevel() + 10 < m_spellInfo->spellLevel)
3792 return SPELL_FAILED_LOWLEVEL;
3794 else if (m_caster->GetTypeId() == TYPEID_PLAYER) // Target - is player caster
3796 // Additional check for some spells
3797 // If 0 spell effect empty - client not send target data (need use selection)
3798 // TODO: check it on next client version
3799 if (m_targets.m_targetMask == TARGET_FLAG_SELF &&
3800 m_spellInfo->EffectImplicitTargetA[1] == TARGET_CHAIN_DAMAGE)
3802 if (target = m_caster->GetUnit(*m_caster, ((Player *)m_caster)->GetSelection()))
3803 m_targets.setUnitTarget(target);
3804 else
3805 return SPELL_FAILED_BAD_TARGETS;
3809 // check pet presents
3810 for(int j = 0; j < 3; ++j)
3812 if(m_spellInfo->EffectImplicitTargetA[j] == TARGET_PET)
3814 target = m_caster->GetPet();
3815 if(!target)
3817 if(m_triggeredByAuraSpell) // not report pet not existence for triggered spells
3818 return SPELL_FAILED_DONT_REPORT;
3819 else
3820 return SPELL_FAILED_NO_PET;
3822 break;
3826 //check creature type
3827 //ignore self casts (including area casts when caster selected as target)
3828 if(target != m_caster)
3830 if(!CheckTargetCreatureType(target))
3832 if(target->GetTypeId() == TYPEID_PLAYER)
3833 return SPELL_FAILED_TARGET_IS_PLAYER;
3834 else
3835 return SPELL_FAILED_BAD_TARGETS;
3839 // TODO: this check can be applied and for player to prevent cheating when IsPositiveSpell will return always correct result.
3840 // check target for pet/charmed casts (not self targeted), self targeted cast used for area effects and etc
3841 if(m_caster != target && m_caster->GetTypeId() == TYPEID_UNIT && m_caster->GetCharmerOrOwnerGUID())
3843 // check correctness positive/negative cast target (pet cast real check and cheating check)
3844 if(IsPositiveSpell(m_spellInfo->Id))
3846 if(m_caster->IsHostileTo(target))
3847 return SPELL_FAILED_BAD_TARGETS;
3849 else
3851 if(m_caster->IsFriendlyTo(target))
3852 return SPELL_FAILED_BAD_TARGETS;
3856 if(IsPositiveSpell(m_spellInfo->Id))
3857 if(target->IsImmunedToSpell(m_spellInfo))
3858 return SPELL_FAILED_TARGET_AURASTATE;
3860 //Must be behind the target.
3861 if( m_spellInfo->AttributesEx2 == 0x100000 && (m_spellInfo->AttributesEx & 0x200) == 0x200 && target->HasInArc(M_PI, m_caster) )
3863 //Exclusion for Pounce: Facing Limitation was removed in 2.0.1, but it still uses the same, old Ex-Flags
3864 //Exclusion for Mutilate:Facing Limitation was removed in 2.0.1 and 3.0.3, but they still use the same, old Ex-Flags
3865 if ((m_spellInfo->SpellFamilyName != SPELLFAMILY_DRUID || (m_spellInfo->SpellFamilyFlags != UI64LIT(0x0000000000020000))) &&
3866 (m_spellInfo->SpellFamilyName != SPELLFAMILY_ROGUE || (m_spellInfo->SpellFamilyFlags != UI64LIT(0x0020000000000000))))
3868 SendInterrupted(2);
3869 return SPELL_FAILED_NOT_BEHIND;
3873 //Target must be facing you.
3874 if((m_spellInfo->Attributes == 0x150010) && !target->HasInArc(M_PI, m_caster) )
3876 SendInterrupted(2);
3877 return SPELL_FAILED_NOT_INFRONT;
3880 // check if target is in combat
3881 if (target != m_caster && (m_spellInfo->AttributesEx & SPELL_ATTR_EX_NOT_IN_COMBAT_TARGET) && target->isInCombat())
3882 return SPELL_FAILED_TARGET_AFFECTING_COMBAT;
3885 // Spell casted only on battleground
3886 if((m_spellInfo->AttributesEx3 & SPELL_ATTR_EX3_BATTLEGROUND) && m_caster->GetTypeId() == TYPEID_PLAYER)
3887 if(!((Player*)m_caster)->InBattleGround())
3888 return SPELL_FAILED_ONLY_BATTLEGROUNDS;
3890 // do not allow spells to be cast in arenas
3891 // - with greater than 15 min CD without SPELL_ATTR_EX4_USABLE_IN_ARENA flag
3892 // - with SPELL_ATTR_EX4_NOT_USABLE_IN_ARENA flag
3893 if( (m_spellInfo->AttributesEx4 & SPELL_ATTR_EX4_NOT_USABLE_IN_ARENA) ||
3894 GetSpellRecoveryTime(m_spellInfo) > 15 * MINUTE * IN_MILISECONDS && !(m_spellInfo->AttributesEx4 & SPELL_ATTR_EX4_USABLE_IN_ARENA) )
3895 if(MapEntry const* mapEntry = sMapStore.LookupEntry(m_caster->GetMapId()))
3896 if(mapEntry->IsBattleArena())
3897 return SPELL_FAILED_NOT_IN_ARENA;
3899 // zone check
3900 uint32 zone, area;
3901 m_caster->GetZoneAndAreaId(zone, area);
3903 SpellCastResult locRes= spellmgr.GetSpellAllowedInLocationError(m_spellInfo,m_caster->GetMapId(),zone,area,
3904 m_caster->GetTypeId() == TYPEID_PLAYER ? ((Player*)m_caster) : NULL);
3905 if(locRes != SPELL_CAST_OK)
3906 return locRes;
3908 // not let players cast spells at mount (and let do it to creatures)
3909 if( m_caster->IsMounted() && m_caster->GetTypeId()==TYPEID_PLAYER && !m_IsTriggeredSpell &&
3910 !IsPassiveSpell(m_spellInfo->Id) && !(m_spellInfo->Attributes & SPELL_ATTR_CASTABLE_WHILE_MOUNTED) )
3912 if(m_caster->isInFlight())
3913 return SPELL_FAILED_NOT_FLYING;
3914 else
3915 return SPELL_FAILED_NOT_MOUNTED;
3918 // always (except passive spells) check items (focus object can be required for any type casts)
3919 if(!IsPassiveSpell(m_spellInfo->Id))
3921 SpellCastResult castResult = CheckItems();
3922 if(castResult != SPELL_CAST_OK)
3923 return castResult;
3926 //ImpliciteTargetA-B = 38, If fact there is 0 Spell with ImpliciteTargetB=38
3927 if(m_UniqueTargetInfo.empty()) // skip second CheckCast apply (for delayed spells for example)
3929 for(uint8 j = 0; j < 3; ++j)
3931 if( m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT ||
3932 m_spellInfo->EffectImplicitTargetB[j] == TARGET_SCRIPT && m_spellInfo->EffectImplicitTargetA[j] != TARGET_SELF ||
3933 m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT_COORDINATES ||
3934 m_spellInfo->EffectImplicitTargetB[j] == TARGET_SCRIPT_COORDINATES )
3936 SpellScriptTarget::const_iterator lower = spellmgr.GetBeginSpellScriptTarget(m_spellInfo->Id);
3937 SpellScriptTarget::const_iterator upper = spellmgr.GetEndSpellScriptTarget(m_spellInfo->Id);
3938 if(lower==upper)
3939 sLog.outErrorDb("Spell (ID: %u) has effect EffectImplicitTargetA/EffectImplicitTargetB = TARGET_SCRIPT or TARGET_SCRIPT_COORDINATES, but does not have record in `spell_script_target`",m_spellInfo->Id);
3941 SpellRangeEntry const* srange = sSpellRangeStore.LookupEntry(m_spellInfo->rangeIndex);
3942 float range = GetSpellMaxRange(srange);
3944 Creature* creatureScriptTarget = NULL;
3945 GameObject* goScriptTarget = NULL;
3947 for(SpellScriptTarget::const_iterator i_spellST = lower; i_spellST != upper; ++i_spellST)
3949 switch(i_spellST->second.type)
3951 case SPELL_TARGET_TYPE_GAMEOBJECT:
3953 GameObject* p_GameObject = NULL;
3955 if(i_spellST->second.targetEntry)
3957 CellPair p(MaNGOS::ComputeCellPair(m_caster->GetPositionX(), m_caster->GetPositionY()));
3958 Cell cell(p);
3959 cell.data.Part.reserved = ALL_DISTRICT;
3961 MaNGOS::NearestGameObjectEntryInObjectRangeCheck go_check(*m_caster,i_spellST->second.targetEntry,range);
3962 MaNGOS::GameObjectLastSearcher<MaNGOS::NearestGameObjectEntryInObjectRangeCheck> checker(m_caster, p_GameObject,go_check);
3964 TypeContainerVisitor<MaNGOS::GameObjectLastSearcher<MaNGOS::NearestGameObjectEntryInObjectRangeCheck>, GridTypeMapContainer > object_checker(checker);
3965 CellLock<GridReadGuard> cell_lock(cell, p);
3966 cell_lock->Visit(cell_lock, object_checker, *m_caster->GetMap());
3968 if(p_GameObject)
3970 // remember found target and range, next attempt will find more near target with another entry
3971 creatureScriptTarget = NULL;
3972 goScriptTarget = p_GameObject;
3973 range = go_check.GetLastRange();
3976 else if( focusObject ) // Focus Object
3978 float frange = m_caster->GetDistance(focusObject);
3979 if(range >= frange)
3981 creatureScriptTarget = NULL;
3982 goScriptTarget = focusObject;
3983 range = frange;
3986 break;
3988 case SPELL_TARGET_TYPE_CREATURE:
3989 case SPELL_TARGET_TYPE_DEAD:
3990 default:
3992 Creature *p_Creature = NULL;
3994 CellPair p(MaNGOS::ComputeCellPair(m_caster->GetPositionX(), m_caster->GetPositionY()));
3995 Cell cell(p);
3996 cell.data.Part.reserved = ALL_DISTRICT;
3997 cell.SetNoCreate(); // Really don't know what is that???
3999 MaNGOS::NearestCreatureEntryWithLiveStateInObjectRangeCheck u_check(*m_caster,i_spellST->second.targetEntry,i_spellST->second.type!=SPELL_TARGET_TYPE_DEAD,range);
4000 MaNGOS::CreatureLastSearcher<MaNGOS::NearestCreatureEntryWithLiveStateInObjectRangeCheck> searcher(m_caster, p_Creature, u_check);
4002 TypeContainerVisitor<MaNGOS::CreatureLastSearcher<MaNGOS::NearestCreatureEntryWithLiveStateInObjectRangeCheck>, GridTypeMapContainer > grid_creature_searcher(searcher);
4004 CellLock<GridReadGuard> cell_lock(cell, p);
4005 cell_lock->Visit(cell_lock, grid_creature_searcher, *m_caster->GetMap());
4007 if(p_Creature )
4009 creatureScriptTarget = p_Creature;
4010 goScriptTarget = NULL;
4011 range = u_check.GetLastRange();
4013 break;
4018 if(creatureScriptTarget)
4020 // store coordinates for TARGET_SCRIPT_COORDINATES
4021 if (m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT_COORDINATES ||
4022 m_spellInfo->EffectImplicitTargetB[j] == TARGET_SCRIPT_COORDINATES )
4024 m_targets.setDestination(creatureScriptTarget->GetPositionX(),creatureScriptTarget->GetPositionY(),creatureScriptTarget->GetPositionZ());
4026 if(m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT_COORDINATES && m_spellInfo->EffectImplicitTargetB[j] == 0 && m_spellInfo->Effect[j]!=SPELL_EFFECT_PERSISTENT_AREA_AURA)
4027 AddUnitTarget(creatureScriptTarget, j);
4029 // store explicit target for TARGET_SCRIPT
4030 else
4031 AddUnitTarget(creatureScriptTarget, j);
4033 else if(goScriptTarget)
4035 // store coordinates for TARGET_SCRIPT_COORDINATES
4036 if (m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT_COORDINATES ||
4037 m_spellInfo->EffectImplicitTargetB[j] == TARGET_SCRIPT_COORDINATES )
4039 m_targets.setDestination(goScriptTarget->GetPositionX(),goScriptTarget->GetPositionY(),goScriptTarget->GetPositionZ());
4041 if(m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT_COORDINATES && m_spellInfo->EffectImplicitTargetB[j] == 0 && m_spellInfo->Effect[j]!=SPELL_EFFECT_PERSISTENT_AREA_AURA)
4042 AddGOTarget(goScriptTarget, j);
4044 // store explicit target for TARGET_SCRIPT
4045 else
4046 AddGOTarget(goScriptTarget, j);
4048 //Missing DB Entry or targets for this spellEffect.
4049 else
4051 // not report target not existence for triggered spells
4052 if(m_triggeredByAuraSpell || m_IsTriggeredSpell)
4053 return SPELL_FAILED_DONT_REPORT;
4054 else
4055 return SPELL_FAILED_BAD_TARGETS;
4061 if(!m_IsTriggeredSpell)
4063 SpellCastResult castResult = CheckRange(strict);
4064 if(castResult != SPELL_CAST_OK)
4065 return castResult;
4069 SpellCastResult castResult = CheckPower();
4070 if(castResult != SPELL_CAST_OK)
4071 return castResult;
4074 if(!m_IsTriggeredSpell) // triggered spell not affected by stun/etc
4076 SpellCastResult castResult = CheckCasterAuras();
4077 if(castResult != SPELL_CAST_OK)
4078 return castResult;
4081 for (int i = 0; i < 3; ++i)
4083 // for effects of spells that have only one target
4084 switch(m_spellInfo->Effect[i])
4086 case SPELL_EFFECT_DUMMY:
4088 if(m_spellInfo->SpellIconID == 1648) // Execute
4090 if(!m_targets.getUnitTarget() || m_targets.getUnitTarget()->GetHealth() > m_targets.getUnitTarget()->GetMaxHealth()*0.2)
4091 return SPELL_FAILED_BAD_TARGETS;
4093 else if (m_spellInfo->Id == 51582) // Rocket Boots Engaged
4095 if(m_caster->IsInWater())
4096 return SPELL_FAILED_ONLY_ABOVEWATER;
4098 else if(m_spellInfo->SpellIconID == 156) // Holy Shock
4100 // spell different for friends and enemies
4101 // hart version required facing
4102 if(m_targets.getUnitTarget() && !m_caster->IsFriendlyTo(m_targets.getUnitTarget()) && !m_caster->HasInArc( M_PI, m_targets.getUnitTarget() ))
4103 return SPELL_FAILED_UNIT_NOT_INFRONT;
4105 break;
4107 case SPELL_EFFECT_SCHOOL_DAMAGE:
4109 // Hammer of Wrath
4110 if(m_spellInfo->SpellVisual[0] == 7250)
4112 if (!m_targets.getUnitTarget())
4113 return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
4115 if(m_targets.getUnitTarget()->GetHealth() > m_targets.getUnitTarget()->GetMaxHealth()*0.2)
4116 return SPELL_FAILED_BAD_TARGETS;
4118 break;
4120 case SPELL_EFFECT_TAMECREATURE:
4122 if (m_caster->GetTypeId() != TYPEID_PLAYER)
4123 return SPELL_FAILED_BAD_TARGETS;
4125 if (!m_targets.getUnitTarget() || m_targets.getUnitTarget()->GetTypeId() == TYPEID_PLAYER)
4126 return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
4128 Creature* target = (Creature*)m_targets.getUnitTarget();
4130 if (target->getLevel() > m_caster->getLevel())
4131 return SPELL_FAILED_HIGHLEVEL;
4133 // use SMSG_PET_TAME_FAILURE?
4134 if (!target->GetCreatureInfo()->isTameable (((Player*)m_caster)->CanTameExoticPets()))
4135 return SPELL_FAILED_BAD_TARGETS;
4137 if(m_caster->GetPetGUID())
4138 return SPELL_FAILED_ALREADY_HAVE_SUMMON;
4140 if(m_caster->GetCharmGUID())
4141 return SPELL_FAILED_ALREADY_HAVE_CHARM;
4143 break;
4145 case SPELL_EFFECT_LEARN_SPELL:
4147 if(m_spellInfo->EffectImplicitTargetA[i] != TARGET_PET)
4148 break;
4150 Pet* pet = m_caster->GetPet();
4152 if(!pet)
4153 return SPELL_FAILED_NO_PET;
4155 SpellEntry const *learn_spellproto = sSpellStore.LookupEntry(m_spellInfo->EffectTriggerSpell[i]);
4157 if(!learn_spellproto)
4158 return SPELL_FAILED_NOT_KNOWN;
4160 if(m_spellInfo->spellLevel > pet->getLevel())
4161 return SPELL_FAILED_LOWLEVEL;
4163 break;
4165 case SPELL_EFFECT_LEARN_PET_SPELL:
4167 Pet* pet = m_caster->GetPet();
4169 if(!pet)
4170 return SPELL_FAILED_NO_PET;
4172 SpellEntry const *learn_spellproto = sSpellStore.LookupEntry(m_spellInfo->EffectTriggerSpell[i]);
4174 if(!learn_spellproto)
4175 return SPELL_FAILED_NOT_KNOWN;
4177 if(m_spellInfo->spellLevel > pet->getLevel())
4178 return SPELL_FAILED_LOWLEVEL;
4180 break;
4182 case SPELL_EFFECT_FEED_PET:
4184 if (m_caster->GetTypeId() != TYPEID_PLAYER)
4185 return SPELL_FAILED_BAD_TARGETS;
4187 Item* foodItem = m_targets.getItemTarget();
4188 if(!foodItem)
4189 return SPELL_FAILED_BAD_TARGETS;
4191 Pet* pet = m_caster->GetPet();
4193 if(!pet)
4194 return SPELL_FAILED_NO_PET;
4196 if(!pet->HaveInDiet(foodItem->GetProto()))
4197 return SPELL_FAILED_WRONG_PET_FOOD;
4199 if(!pet->GetCurrentFoodBenefitLevel(foodItem->GetProto()->ItemLevel))
4200 return SPELL_FAILED_FOOD_LOWLEVEL;
4202 if(m_caster->isInCombat() || pet->isInCombat())
4203 return SPELL_FAILED_AFFECTING_COMBAT;
4205 break;
4207 case SPELL_EFFECT_POWER_BURN:
4208 case SPELL_EFFECT_POWER_DRAIN:
4210 // Can be area effect, Check only for players and not check if target - caster (spell can have multiply drain/burn effects)
4211 if(m_caster->GetTypeId() == TYPEID_PLAYER)
4212 if(Unit* target = m_targets.getUnitTarget())
4213 if(target != m_caster && target->getPowerType() != m_spellInfo->EffectMiscValue[i])
4214 return SPELL_FAILED_BAD_TARGETS;
4215 break;
4217 case SPELL_EFFECT_CHARGE:
4219 if (m_caster->hasUnitState(UNIT_STAT_ROOT))
4220 return SPELL_FAILED_ROOTED;
4222 break;
4224 case SPELL_EFFECT_SKINNING:
4226 if (m_caster->GetTypeId() != TYPEID_PLAYER || !m_targets.getUnitTarget() || m_targets.getUnitTarget()->GetTypeId() != TYPEID_UNIT)
4227 return SPELL_FAILED_BAD_TARGETS;
4229 if( !(m_targets.getUnitTarget()->GetUInt32Value(UNIT_FIELD_FLAGS) & UNIT_FLAG_SKINNABLE) )
4230 return SPELL_FAILED_TARGET_UNSKINNABLE;
4232 Creature* creature = (Creature*)m_targets.getUnitTarget();
4233 if ( creature->GetCreatureType() != CREATURE_TYPE_CRITTER && ( !creature->lootForBody || !creature->loot.empty() ) )
4235 return SPELL_FAILED_TARGET_NOT_LOOTED;
4238 uint32 skill = creature->GetCreatureInfo()->GetRequiredLootSkill();
4240 int32 skillValue = ((Player*)m_caster)->GetSkillValue(skill);
4241 int32 TargetLevel = m_targets.getUnitTarget()->getLevel();
4242 int32 ReqValue = (skillValue < 100 ? (TargetLevel-10) * 10 : TargetLevel * 5);
4243 if (ReqValue > skillValue)
4244 return SPELL_FAILED_LOW_CASTLEVEL;
4246 // chance for fail at orange skinning attempt
4247 if( (m_selfContainer && (*m_selfContainer) == this) &&
4248 skillValue < sWorld.GetConfigMaxSkillValue() &&
4249 (ReqValue < 0 ? 0 : ReqValue) > irand(skillValue - 25, skillValue + 37) )
4250 return SPELL_FAILED_TRY_AGAIN;
4252 break;
4254 case SPELL_EFFECT_OPEN_LOCK_ITEM:
4255 case SPELL_EFFECT_OPEN_LOCK:
4257 if( m_spellInfo->EffectImplicitTargetA[i] != TARGET_GAMEOBJECT &&
4258 m_spellInfo->EffectImplicitTargetA[i] != TARGET_GAMEOBJECT_ITEM )
4259 break;
4261 if( m_caster->GetTypeId() != TYPEID_PLAYER // only players can open locks, gather etc.
4262 // we need a go target in case of TARGET_GAMEOBJECT
4263 || m_spellInfo->EffectImplicitTargetA[i] == TARGET_GAMEOBJECT && !m_targets.getGOTarget()
4264 // we need a go target, or an openable item target in case of TARGET_GAMEOBJECT_ITEM
4265 || m_spellInfo->EffectImplicitTargetA[i] == TARGET_GAMEOBJECT_ITEM && !m_targets.getGOTarget() &&
4266 (!m_targets.getItemTarget() || !m_targets.getItemTarget()->GetProto()->LockID || m_targets.getItemTarget()->GetOwner() != m_caster ) )
4267 return SPELL_FAILED_BAD_TARGETS;
4269 // In BattleGround players can use only flags and banners
4270 if( ((Player*)m_caster)->InBattleGround() &&
4271 !((Player*)m_caster)->CanUseBattleGroundObject() )
4272 return SPELL_FAILED_TRY_AGAIN;
4274 // get the lock entry
4275 uint32 lockId = 0;
4276 if (GameObject* go = m_targets.getGOTarget())
4277 lockId = go->GetLockId();
4278 else if(Item* itm = m_targets.getItemTarget())
4279 lockId = itm->GetProto()->LockID;
4281 SkillType skillId = SKILL_NONE;
4282 int32 reqSkillValue = 0;
4283 int32 skillValue = 0;
4285 // check lock compatibility
4286 SpellCastResult res = CanOpenLock(i, lockId, skillId, reqSkillValue, skillValue);
4287 if(res != SPELL_CAST_OK)
4288 return res;
4290 // chance for fail at orange mining/herb/LockPicking gathering attempt
4291 // second check prevent fail at rechecks
4292 if(skillId != SKILL_NONE && (!m_selfContainer || ((*m_selfContainer) != this)))
4294 bool canFailAtMax = skillId != SKILL_HERBALISM && skillId != SKILL_MINING;
4296 // chance for failure in orange gather / lockpick (gathering skill can't fail at maxskill)
4297 if((canFailAtMax || skillValue < sWorld.GetConfigMaxSkillValue()) && reqSkillValue > irand(skillValue - 25, skillValue + 37))
4298 return SPELL_FAILED_TRY_AGAIN;
4300 break;
4302 case SPELL_EFFECT_SUMMON_DEAD_PET:
4304 Creature *pet = m_caster->GetPet();
4305 if(!pet)
4306 return SPELL_FAILED_NO_PET;
4308 if(pet->isAlive())
4309 return SPELL_FAILED_ALREADY_HAVE_SUMMON;
4311 break;
4313 // This is generic summon effect
4314 case SPELL_EFFECT_SUMMON:
4316 switch(m_spellInfo->EffectMiscValueB[i])
4318 case SUMMON_TYPE_POSESSED:
4319 case SUMMON_TYPE_POSESSED2:
4320 case SUMMON_TYPE_DEMON:
4321 case SUMMON_TYPE_SUMMON:
4323 if(m_caster->GetPetGUID())
4324 return SPELL_FAILED_ALREADY_HAVE_SUMMON;
4326 if(m_caster->GetCharmGUID())
4327 return SPELL_FAILED_ALREADY_HAVE_CHARM;
4328 break;
4331 break;
4333 // Not used for summon?
4334 case SPELL_EFFECT_SUMMON_PHANTASM:
4336 if(m_caster->GetPetGUID())
4337 return SPELL_FAILED_ALREADY_HAVE_SUMMON;
4339 if(m_caster->GetCharmGUID())
4340 return SPELL_FAILED_ALREADY_HAVE_CHARM;
4342 break;
4344 case SPELL_EFFECT_SUMMON_PET:
4346 if(m_caster->GetPetGUID()) //let warlock do a replacement summon
4349 Pet* pet = ((Player*)m_caster)->GetPet();
4351 if (m_caster->GetTypeId() == TYPEID_PLAYER && m_caster->getClass() == CLASS_WARLOCK)
4353 if (strict) //starting cast, trigger pet stun (cast by pet so it doesn't attack player)
4354 pet->CastSpell(pet, 32752, true, NULL, NULL, pet->GetGUID());
4356 else
4357 return SPELL_FAILED_ALREADY_HAVE_SUMMON;
4360 if(m_caster->GetCharmGUID())
4361 return SPELL_FAILED_ALREADY_HAVE_CHARM;
4363 break;
4365 case SPELL_EFFECT_SUMMON_PLAYER:
4367 if(m_caster->GetTypeId() != TYPEID_PLAYER)
4368 return SPELL_FAILED_BAD_TARGETS;
4369 if(!((Player*)m_caster)->GetSelection())
4370 return SPELL_FAILED_BAD_TARGETS;
4372 Player* target = objmgr.GetPlayer(((Player*)m_caster)->GetSelection());
4373 if( !target || ((Player*)m_caster) == target || !target->IsInSameRaidWith((Player*)m_caster) )
4374 return SPELL_FAILED_BAD_TARGETS;
4376 // check if our map is dungeon
4377 if( sMapStore.LookupEntry(m_caster->GetMapId())->IsDungeon() )
4379 InstanceTemplate const* instance = ObjectMgr::GetInstanceTemplate(m_caster->GetMapId());
4380 if(!instance)
4381 return SPELL_FAILED_TARGET_NOT_IN_INSTANCE;
4382 if ( instance->levelMin > target->getLevel() )
4383 return SPELL_FAILED_LOWLEVEL;
4384 if ( instance->levelMax && instance->levelMax < target->getLevel() )
4385 return SPELL_FAILED_HIGHLEVEL;
4387 break;
4389 case SPELL_EFFECT_LEAP:
4390 case SPELL_EFFECT_TELEPORT_UNITS_FACE_CASTER:
4392 float dis = GetSpellRadius(sSpellRadiusStore.LookupEntry(m_spellInfo->EffectRadiusIndex[i]));
4393 float fx = m_caster->GetPositionX() + dis * cos(m_caster->GetOrientation());
4394 float fy = m_caster->GetPositionY() + dis * sin(m_caster->GetOrientation());
4395 // teleport a bit above terrain level to avoid falling below it
4396 float fz = MapManager::Instance().GetBaseMap(m_caster->GetMapId())->GetHeight(fx,fy,m_caster->GetPositionZ(),true);
4397 if(fz <= INVALID_HEIGHT) // note: this also will prevent use effect in instances without vmaps height enabled
4398 return SPELL_FAILED_TRY_AGAIN;
4400 float caster_pos_z = m_caster->GetPositionZ();
4401 // Control the caster to not climb or drop when +-fz > 8
4402 if(!(fz <= caster_pos_z + 8 && fz >= caster_pos_z - 8))
4403 return SPELL_FAILED_TRY_AGAIN;
4405 // not allow use this effect at battleground until battleground start
4406 if(m_caster->GetTypeId() == TYPEID_PLAYER)
4407 if(BattleGround const *bg = ((Player*)m_caster)->GetBattleGround())
4408 if(bg->GetStatus() != STATUS_IN_PROGRESS)
4409 return SPELL_FAILED_TRY_AGAIN;
4410 break;
4412 case SPELL_EFFECT_STEAL_BENEFICIAL_BUFF:
4414 if (m_targets.getUnitTarget() == m_caster)
4415 return SPELL_FAILED_BAD_TARGETS;
4416 break;
4418 default:break;
4422 for (int i = 0; i < 3; ++i)
4424 switch(m_spellInfo->EffectApplyAuraName[i])
4426 case SPELL_AURA_DUMMY:
4428 //custom check
4429 switch(m_spellInfo->Id)
4431 case 61336:
4432 if(m_caster->GetTypeId() != TYPEID_PLAYER || !((Player*)m_caster)->IsInFeralForm())
4433 return SPELL_FAILED_ONLY_SHAPESHIFT;
4434 break;
4435 default:
4436 break;
4438 break;
4440 case SPELL_AURA_MOD_POSSESS:
4441 case SPELL_AURA_MOD_CHARM:
4443 if(m_caster->GetPetGUID())
4444 return SPELL_FAILED_ALREADY_HAVE_SUMMON;
4446 if(m_caster->GetCharmGUID())
4447 return SPELL_FAILED_ALREADY_HAVE_CHARM;
4449 if(m_caster->GetCharmerGUID())
4450 return SPELL_FAILED_CHARMED;
4452 if(!m_targets.getUnitTarget())
4453 return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
4455 if(m_targets.getUnitTarget()->GetCharmerGUID())
4456 return SPELL_FAILED_CHARMED;
4458 if(int32(m_targets.getUnitTarget()->getLevel()) > CalculateDamage(i,m_targets.getUnitTarget()))
4459 return SPELL_FAILED_HIGHLEVEL;
4461 break;
4463 case SPELL_AURA_MOUNTED:
4465 if (m_caster->IsInWater())
4466 return SPELL_FAILED_ONLY_ABOVEWATER;
4468 if (m_caster->GetTypeId() == TYPEID_PLAYER && ((Player*)m_caster)->GetTransport())
4469 return SPELL_FAILED_NO_MOUNTS_ALLOWED;
4471 // Ignore map check if spell have AreaId. AreaId already checked and this prevent special mount spells
4472 if (m_caster->GetTypeId() == TYPEID_PLAYER && !sMapStore.LookupEntry(m_caster->GetMapId())->IsMountAllowed() && !m_IsTriggeredSpell && !m_spellInfo->AreaGroupId)
4473 return SPELL_FAILED_NO_MOUNTS_ALLOWED;
4475 ShapeshiftForm form = m_caster->m_form;
4476 if( form == FORM_CAT || form == FORM_TREE || form == FORM_TRAVEL ||
4477 form == FORM_AQUA || form == FORM_BEAR || form == FORM_DIREBEAR ||
4478 form == FORM_CREATUREBEAR || form == FORM_GHOSTWOLF || form == FORM_FLIGHT ||
4479 form == FORM_FLIGHT_EPIC || form == FORM_MOONKIN || form == FORM_METAMORPHOSIS )
4480 return SPELL_FAILED_NOT_SHAPESHIFT;
4482 break;
4484 case SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS:
4486 if(!m_targets.getUnitTarget())
4487 return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
4489 // can be casted at non-friendly unit or own pet/charm
4490 if(m_caster->IsFriendlyTo(m_targets.getUnitTarget()))
4491 return SPELL_FAILED_TARGET_FRIENDLY;
4493 break;
4495 case SPELL_AURA_MOD_INCREASE_FLIGHT_SPEED:
4496 case SPELL_AURA_FLY:
4498 // not allow cast fly spells at old maps by players (all spells is self target)
4499 if(m_caster->GetTypeId() == TYPEID_PLAYER)
4501 if( !((Player*)m_caster)->IsAllowUseFlyMountsHere() )
4502 return SPELL_FAILED_NOT_HERE;
4505 break;
4507 case SPELL_AURA_PERIODIC_MANA_LEECH:
4509 if (!m_targets.getUnitTarget())
4510 return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
4512 if (m_caster->GetTypeId() != TYPEID_PLAYER || m_CastItem)
4513 break;
4515 if(m_targets.getUnitTarget()->getPowerType() != POWER_MANA)
4516 return SPELL_FAILED_BAD_TARGETS;
4518 break;
4520 default:
4521 break;
4525 // all ok
4526 return SPELL_CAST_OK;
4529 SpellCastResult Spell::CheckPetCast(Unit* target)
4531 if(!m_caster->isAlive())
4532 return SPELL_FAILED_CASTER_DEAD;
4534 if(m_caster->IsNonMeleeSpellCasted(false)) //prevent spellcast interruption by another spellcast
4535 return SPELL_FAILED_SPELL_IN_PROGRESS;
4536 if(m_caster->isInCombat() && IsNonCombatSpell(m_spellInfo))
4537 return SPELL_FAILED_AFFECTING_COMBAT;
4539 if(m_caster->GetTypeId()==TYPEID_UNIT && (((Creature*)m_caster)->isPet() || m_caster->isCharmed()))
4541 //dead owner (pets still alive when owners ressed?)
4542 if(m_caster->GetCharmerOrOwner() && !m_caster->GetCharmerOrOwner()->isAlive())
4543 return SPELL_FAILED_CASTER_DEAD;
4545 if(!target && m_targets.getUnitTarget())
4546 target = m_targets.getUnitTarget();
4548 bool need = false;
4549 for(uint32 i = 0; i < 3; ++i)
4551 if(m_spellInfo->EffectImplicitTargetA[i] == TARGET_CHAIN_DAMAGE || m_spellInfo->EffectImplicitTargetA[i] == TARGET_SINGLE_FRIEND || m_spellInfo->EffectImplicitTargetA[i] == TARGET_DUELVSPLAYER || m_spellInfo->EffectImplicitTargetA[i] == TARGET_SINGLE_PARTY || m_spellInfo->EffectImplicitTargetA[i] == TARGET_CURRENT_ENEMY_COORDINATES)
4553 need = true;
4554 if(!target)
4555 return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
4556 break;
4559 if(need)
4560 m_targets.setUnitTarget(target);
4562 Unit* _target = m_targets.getUnitTarget();
4564 if(_target) //for target dead/target not valid
4566 if(!_target->isAlive())
4567 return SPELL_FAILED_BAD_TARGETS;
4569 if(IsPositiveSpell(m_spellInfo->Id))
4571 if(m_caster->IsHostileTo(_target))
4572 return SPELL_FAILED_BAD_TARGETS;
4574 else
4576 bool duelvsplayertar = false;
4577 for(int j = 0; j < 3; ++j)
4579 //TARGET_DUELVSPLAYER is positive AND negative
4580 duelvsplayertar |= (m_spellInfo->EffectImplicitTargetA[j] == TARGET_DUELVSPLAYER);
4582 if(m_caster->IsFriendlyTo(target) && !duelvsplayertar)
4584 return SPELL_FAILED_BAD_TARGETS;
4588 //cooldown
4589 if(((Creature*)m_caster)->HasSpellCooldown(m_spellInfo->Id))
4590 return SPELL_FAILED_NOT_READY;
4593 return CheckCast(true);
4596 SpellCastResult Spell::CheckCasterAuras() const
4598 // Flag drop spells totally immuned to caster auras
4599 // FIXME: find more nice check for all totally immuned spells
4600 // AttributesEx3 & 0x10000000?
4601 if(m_spellInfo->Id == 23336 || m_spellInfo->Id == 23334 || m_spellInfo->Id == 34991)
4602 return SPELL_CAST_OK;
4604 uint8 school_immune = 0;
4605 uint32 mechanic_immune = 0;
4606 uint32 dispel_immune = 0;
4608 // Check if the spell grants school or mechanic immunity.
4609 // We use bitmasks so the loop is done only once and not on every aura check below.
4610 if ( m_spellInfo->AttributesEx & SPELL_ATTR_EX_DISPEL_AURAS_ON_IMMUNITY )
4612 for(int i = 0; i < 3; ++i)
4614 if(m_spellInfo->EffectApplyAuraName[i] == SPELL_AURA_SCHOOL_IMMUNITY)
4615 school_immune |= uint32(m_spellInfo->EffectMiscValue[i]);
4616 else if(m_spellInfo->EffectApplyAuraName[i] == SPELL_AURA_MECHANIC_IMMUNITY)
4617 mechanic_immune |= 1 << uint32(m_spellInfo->EffectMiscValue[i]);
4618 else if(m_spellInfo->EffectApplyAuraName[i] == SPELL_AURA_DISPEL_IMMUNITY)
4619 dispel_immune |= GetDispellMask(DispelType(m_spellInfo->EffectMiscValue[i]));
4621 // immune movement impairment and loss of control
4622 if(m_spellInfo->Id == 42292)
4623 mechanic_immune = IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK;
4626 // Check whether the cast should be prevented by any state you might have.
4627 SpellCastResult prevented_reason = SPELL_CAST_OK;
4628 // Have to check if there is a stun aura. Otherwise will have problems with ghost aura apply while logging out
4629 uint32 unitflag = m_caster->GetUInt32Value(UNIT_FIELD_FLAGS); // Get unit state
4630 if(unitflag & UNIT_FLAG_STUNNED && !(m_spellInfo->AttributesEx5 & SPELL_ATTR_EX5_USABLE_WHILE_STUNNED))
4631 prevented_reason = SPELL_FAILED_STUNNED;
4632 else if(unitflag & UNIT_FLAG_CONFUSED && !(m_spellInfo->AttributesEx5 & SPELL_ATTR_EX5_USABLE_WHILE_CONFUSED))
4633 prevented_reason = SPELL_FAILED_CONFUSED;
4634 else if(unitflag & UNIT_FLAG_FLEEING && !(m_spellInfo->AttributesEx5 & SPELL_ATTR_EX5_USABLE_WHILE_FEARED))
4635 prevented_reason = SPELL_FAILED_FLEEING;
4636 else if(unitflag & UNIT_FLAG_SILENCED && m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE)
4637 prevented_reason = SPELL_FAILED_SILENCED;
4638 else if(unitflag & UNIT_FLAG_PACIFIED && m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY)
4639 prevented_reason = SPELL_FAILED_PACIFIED;
4641 // Attr must make flag drop spell totally immune from all effects
4642 if(prevented_reason != SPELL_CAST_OK)
4644 if(school_immune || mechanic_immune || dispel_immune)
4646 //Checking auras is needed now, because you are prevented by some state but the spell grants immunity.
4647 Unit::AuraMap const& auras = m_caster->GetAuras();
4648 for(Unit::AuraMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
4650 if(itr->second)
4652 if( GetSpellMechanicMask(itr->second->GetSpellProto(), itr->second->GetEffIndex()) & mechanic_immune )
4653 continue;
4654 if( GetSpellSchoolMask(itr->second->GetSpellProto()) & school_immune )
4655 continue;
4656 if( (1<<(itr->second->GetSpellProto()->Dispel)) & dispel_immune)
4657 continue;
4659 // Make a second check for spell failed so the right SPELL_FAILED message is returned.
4660 // That is needed when your casting is prevented by multiple states and you are only immune to some of them.
4661 switch(itr->second->GetModifier()->m_auraname)
4663 case SPELL_AURA_MOD_STUN:
4664 if (!(m_spellInfo->AttributesEx5 & SPELL_ATTR_EX5_USABLE_WHILE_STUNNED))
4665 return SPELL_FAILED_STUNNED;
4666 break;
4667 case SPELL_AURA_MOD_CONFUSE:
4668 if (!(m_spellInfo->AttributesEx5 & SPELL_ATTR_EX5_USABLE_WHILE_CONFUSED))
4669 return SPELL_FAILED_CONFUSED;
4670 break;
4671 case SPELL_AURA_MOD_FEAR:
4672 if (!(m_spellInfo->AttributesEx5 & SPELL_ATTR_EX5_USABLE_WHILE_FEARED))
4673 return SPELL_FAILED_FLEEING;
4674 break;
4675 case SPELL_AURA_MOD_SILENCE:
4676 case SPELL_AURA_MOD_PACIFY:
4677 case SPELL_AURA_MOD_PACIFY_SILENCE:
4678 if( m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY)
4679 return SPELL_FAILED_PACIFIED;
4680 else if ( m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE)
4681 return SPELL_FAILED_SILENCED;
4682 break;
4687 // You are prevented from casting and the spell casted does not grant immunity. Return a failed error.
4688 else
4689 return prevented_reason;
4691 return SPELL_CAST_OK;
4694 bool Spell::CanAutoCast(Unit* target)
4696 uint64 targetguid = target->GetGUID();
4698 for(uint32 j = 0; j < 3; ++j)
4700 if(m_spellInfo->Effect[j] == SPELL_EFFECT_APPLY_AURA)
4702 if( m_spellInfo->StackAmount <= 1)
4704 if( target->HasAura(m_spellInfo->Id, j) )
4705 return false;
4707 else
4709 if( target->GetAuras().count(Unit::spellEffectPair(m_spellInfo->Id, j)) >= m_spellInfo->StackAmount)
4710 return false;
4713 else if ( IsAreaAuraEffect( m_spellInfo->Effect[j] ))
4715 if( target->HasAura(m_spellInfo->Id, j) )
4716 return false;
4720 SpellCastResult result = CheckPetCast(target);
4722 if(result == SPELL_CAST_OK || result == SPELL_FAILED_UNIT_NOT_INFRONT)
4724 FillTargetMap();
4725 //check if among target units, our WANTED target is as well (->only self cast spells return false)
4726 for(std::list<TargetInfo>::const_iterator ihit= m_UniqueTargetInfo.begin();ihit != m_UniqueTargetInfo.end();++ihit)
4727 if( ihit->targetGUID == targetguid )
4728 return true;
4730 return false; //target invalid
4733 SpellCastResult Spell::CheckRange(bool strict)
4735 float range_mod;
4737 // self cast doesn't need range checking -- also for Starshards fix
4738 if (m_spellInfo->rangeIndex == 1)
4739 return SPELL_CAST_OK;
4741 if (strict) //add radius of caster
4742 range_mod = 1.25;
4743 else //add radius of caster and ~5 yds "give"
4744 range_mod = 6.25;
4746 SpellRangeEntry const* srange = sSpellRangeStore.LookupEntry(m_spellInfo->rangeIndex);
4747 Unit *target = m_targets.getUnitTarget();
4748 bool friendly = target ? target->IsFriendlyTo(m_caster) : false;
4749 float max_range = GetSpellMaxRange(srange, friendly) + range_mod;
4750 float min_range = GetSpellMinRange(srange, friendly);
4752 if(Player* modOwner = m_caster->GetSpellModOwner())
4753 modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_RANGE, max_range, this);
4755 if(target && target != m_caster)
4757 // distance from target in checks
4758 float dist = m_caster->GetCombatDistance(target);
4760 if(dist > max_range)
4761 return SPELL_FAILED_OUT_OF_RANGE; //0x5A;
4762 if(dist < min_range)
4763 return SPELL_FAILED_TOO_CLOSE;
4764 if( m_caster->GetTypeId() == TYPEID_PLAYER &&
4765 (m_spellInfo->FacingCasterFlags & SPELL_FACING_FLAG_INFRONT) && !m_caster->HasInArc( M_PI, target ) )
4766 return SPELL_FAILED_UNIT_NOT_INFRONT;
4769 if(m_targets.m_targetMask == TARGET_FLAG_DEST_LOCATION && m_targets.m_destX != 0 && m_targets.m_destY != 0 && m_targets.m_destZ != 0)
4771 if(!m_caster->IsWithinDist3d(m_targets.m_destX, m_targets.m_destY, m_targets.m_destZ, max_range))
4772 return SPELL_FAILED_OUT_OF_RANGE;
4773 if(m_caster->IsWithinDist3d(m_targets.m_destX, m_targets.m_destY, m_targets.m_destZ, min_range))
4774 return SPELL_FAILED_TOO_CLOSE;
4777 return SPELL_CAST_OK;
4780 int32 Spell::CalculatePowerCost()
4782 // item cast not used power
4783 if(m_CastItem)
4784 return 0;
4786 // Spell drain all exist power on cast (Only paladin lay of Hands)
4787 if (m_spellInfo->AttributesEx & SPELL_ATTR_EX_DRAIN_ALL_POWER)
4789 // If power type - health drain all
4790 if (m_spellInfo->powerType == POWER_HEALTH)
4791 return m_caster->GetHealth();
4792 // Else drain all power
4793 if (m_spellInfo->powerType < MAX_POWERS)
4794 return m_caster->GetPower(Powers(m_spellInfo->powerType));
4795 sLog.outError("Spell::CalculateManaCost: Unknown power type '%d' in spell %d", m_spellInfo->powerType, m_spellInfo->Id);
4796 return 0;
4799 // Base powerCost
4800 int32 powerCost = m_spellInfo->manaCost;
4801 // PCT cost from total amount
4802 if (m_spellInfo->ManaCostPercentage)
4804 switch (m_spellInfo->powerType)
4806 // health as power used
4807 case POWER_HEALTH:
4808 powerCost += m_spellInfo->ManaCostPercentage * m_caster->GetCreateHealth() / 100;
4809 break;
4810 case POWER_MANA:
4811 powerCost += m_spellInfo->ManaCostPercentage * m_caster->GetCreateMana() / 100;
4812 break;
4813 case POWER_RAGE:
4814 case POWER_FOCUS:
4815 case POWER_ENERGY:
4816 case POWER_HAPPINESS:
4817 powerCost += m_spellInfo->ManaCostPercentage * m_caster->GetMaxPower(Powers(m_spellInfo->powerType)) / 100;
4818 break;
4819 case POWER_RUNE:
4820 case POWER_RUNIC_POWER:
4821 sLog.outDebug("Spell::CalculateManaCost: Not implemented yet!");
4822 break;
4823 default:
4824 sLog.outError("Spell::CalculateManaCost: Unknown power type '%d' in spell %d", m_spellInfo->powerType, m_spellInfo->Id);
4825 return 0;
4828 SpellSchools school = GetFirstSchoolInMask(m_spellSchoolMask);
4829 // Flat mod from caster auras by spell school
4830 powerCost += m_caster->GetInt32Value(UNIT_FIELD_POWER_COST_MODIFIER + school);
4831 // Shiv - costs 20 + weaponSpeed*10 energy (apply only to non-triggered spell with energy cost)
4832 if ( m_spellInfo->AttributesEx4 & SPELL_ATTR_EX4_SPELL_VS_EXTEND_COST )
4833 powerCost += m_caster->GetAttackTime(OFF_ATTACK)/100;
4834 // Apply cost mod by spell
4835 if(Player* modOwner = m_caster->GetSpellModOwner())
4836 modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_COST, powerCost, this);
4838 if(m_spellInfo->Attributes & SPELL_ATTR_LEVEL_DAMAGE_CALCULATION)
4839 powerCost = int32(powerCost/ (1.117f* m_spellInfo->spellLevel / m_caster->getLevel() -0.1327f));
4841 // PCT mod from user auras by school
4842 powerCost = int32(powerCost * (1.0f+m_caster->GetFloatValue(UNIT_FIELD_POWER_COST_MULTIPLIER+school)));
4843 if (powerCost < 0)
4844 powerCost = 0;
4845 return powerCost;
4848 SpellCastResult Spell::CheckPower()
4850 // item cast not used power
4851 if(m_CastItem)
4852 return SPELL_CAST_OK;
4854 // health as power used - need check health amount
4855 if(m_spellInfo->powerType == POWER_HEALTH)
4857 if(m_caster->GetHealth() <= m_powerCost)
4858 return SPELL_FAILED_CASTER_AURASTATE;
4859 return SPELL_CAST_OK;
4861 // Check valid power type
4862 if( m_spellInfo->powerType >= MAX_POWERS )
4864 sLog.outError("Spell::CheckMana: Unknown power type '%d'", m_spellInfo->powerType);
4865 return SPELL_FAILED_UNKNOWN;
4868 SpellCastResult failReason = CheckRuneCost(m_spellInfo->runeCostID);
4869 if(failReason != SPELL_CAST_OK)
4870 return failReason;
4872 // Check power amount
4873 Powers powerType = Powers(m_spellInfo->powerType);
4874 if(m_caster->GetPower(powerType) < m_powerCost)
4875 return SPELL_FAILED_NO_POWER;
4876 else
4877 return SPELL_CAST_OK;
4880 SpellCastResult Spell::CheckItems()
4882 if (m_caster->GetTypeId() != TYPEID_PLAYER)
4883 return SPELL_CAST_OK;
4885 Player* p_caster = (Player*)m_caster;
4887 // cast item checks
4888 if(m_CastItem)
4890 uint32 itemid = m_CastItem->GetEntry();
4891 if( !p_caster->HasItemCount(itemid, 1) )
4892 return SPELL_FAILED_ITEM_NOT_READY;
4894 ItemPrototype const *proto = m_CastItem->GetProto();
4895 if(!proto)
4896 return SPELL_FAILED_ITEM_NOT_READY;
4898 for (int i = 0; i < 5; ++i)
4899 if (proto->Spells[i].SpellCharges)
4900 if(m_CastItem->GetSpellCharges(i) == 0)
4901 return SPELL_FAILED_NO_CHARGES_REMAIN;
4903 // consumable cast item checks
4904 if (proto->Class == ITEM_CLASS_CONSUMABLE && m_targets.getUnitTarget())
4906 // such items should only fail if there is no suitable effect at all - see Rejuvenation Potions for example
4907 SpellCastResult failReason = SPELL_CAST_OK;
4908 for (int i = 0; i < 3; ++i)
4910 // skip check, pet not required like checks, and for TARGET_PET m_targets.getUnitTarget() is not the real target but the caster
4911 if (m_spellInfo->EffectImplicitTargetA[i] == TARGET_PET)
4912 continue;
4914 if (m_spellInfo->Effect[i] == SPELL_EFFECT_HEAL)
4916 if (m_targets.getUnitTarget()->GetHealth() == m_targets.getUnitTarget()->GetMaxHealth())
4918 failReason = SPELL_FAILED_ALREADY_AT_FULL_HEALTH;
4919 continue;
4921 else
4923 failReason = SPELL_CAST_OK;
4924 break;
4928 // Mana Potion, Rage Potion, Thistle Tea(Rogue), ...
4929 if (m_spellInfo->Effect[i] == SPELL_EFFECT_ENERGIZE)
4931 if(m_spellInfo->EffectMiscValue[i] < 0 || m_spellInfo->EffectMiscValue[i] >= MAX_POWERS)
4933 failReason = SPELL_FAILED_ALREADY_AT_FULL_POWER;
4934 continue;
4937 Powers power = Powers(m_spellInfo->EffectMiscValue[i]);
4938 if (m_targets.getUnitTarget()->GetPower(power) == m_targets.getUnitTarget()->GetMaxPower(power))
4940 failReason = SPELL_FAILED_ALREADY_AT_FULL_POWER;
4941 continue;
4943 else
4945 failReason = SPELL_CAST_OK;
4946 break;
4950 if (failReason != SPELL_CAST_OK)
4951 return failReason;
4955 // check target item
4956 if(m_targets.getItemTargetGUID())
4958 if(m_caster->GetTypeId() != TYPEID_PLAYER)
4959 return SPELL_FAILED_BAD_TARGETS;
4961 if(!m_targets.getItemTarget())
4962 return SPELL_FAILED_ITEM_GONE;
4964 if(!m_targets.getItemTarget()->IsFitToSpellRequirements(m_spellInfo))
4965 return SPELL_FAILED_EQUIPPED_ITEM_CLASS;
4967 // if not item target then required item must be equipped
4968 else
4970 if(m_caster->GetTypeId() == TYPEID_PLAYER && !((Player*)m_caster)->HasItemFitToSpellReqirements(m_spellInfo))
4971 return SPELL_FAILED_EQUIPPED_ITEM_CLASS;
4974 // check spell focus object
4975 if(m_spellInfo->RequiresSpellFocus)
4977 CellPair p(MaNGOS::ComputeCellPair(m_caster->GetPositionX(), m_caster->GetPositionY()));
4978 Cell cell(p);
4979 cell.data.Part.reserved = ALL_DISTRICT;
4981 GameObject* ok = NULL;
4982 MaNGOS::GameObjectFocusCheck go_check(m_caster,m_spellInfo->RequiresSpellFocus);
4983 MaNGOS::GameObjectSearcher<MaNGOS::GameObjectFocusCheck> checker(m_caster, ok, go_check);
4985 TypeContainerVisitor<MaNGOS::GameObjectSearcher<MaNGOS::GameObjectFocusCheck>, GridTypeMapContainer > object_checker(checker);
4986 CellLock<GridReadGuard> cell_lock(cell, p);
4987 cell_lock->Visit(cell_lock, object_checker, *m_caster->GetMap());
4989 if(!ok)
4990 return SPELL_FAILED_REQUIRES_SPELL_FOCUS;
4992 focusObject = ok; // game object found in range
4995 // check reagents (ignore triggered spells with reagents processed by original spell) and special reagent ignore case.
4996 if (!m_IsTriggeredSpell && !p_caster->CanNoReagentCast(m_spellInfo))
4998 for(uint32 i = 0; i < 8; ++i)
5000 if(m_spellInfo->Reagent[i] <= 0)
5001 continue;
5003 uint32 itemid = m_spellInfo->Reagent[i];
5004 uint32 itemcount = m_spellInfo->ReagentCount[i];
5006 // if CastItem is also spell reagent
5007 if( m_CastItem && m_CastItem->GetEntry() == itemid )
5009 ItemPrototype const *proto = m_CastItem->GetProto();
5010 if(!proto)
5011 return SPELL_FAILED_ITEM_NOT_READY;
5012 for(int s = 0; s < MAX_ITEM_PROTO_SPELLS; ++s)
5014 // CastItem will be used up and does not count as reagent
5015 int32 charges = m_CastItem->GetSpellCharges(s);
5016 if (proto->Spells[s].SpellCharges < 0 && abs(charges) < 2)
5018 ++itemcount;
5019 break;
5023 if( !p_caster->HasItemCount(itemid, itemcount) )
5024 return SPELL_FAILED_ITEM_NOT_READY; //0x54
5028 // check totem-item requirements (items presence in inventory)
5029 uint32 totems = 2;
5030 for(int i = 0; i < 2 ; ++i)
5032 if(m_spellInfo->Totem[i] != 0)
5034 if( p_caster->HasItemCount(m_spellInfo->Totem[i], 1) )
5036 totems -= 1;
5037 continue;
5039 }else
5040 totems -= 1;
5042 if(totems != 0)
5043 return SPELL_FAILED_TOTEMS; //0x7C
5045 // Check items for TotemCategory (items presence in inventory)
5046 uint32 TotemCategory = 2;
5047 for(int i= 0; i < 2; ++i)
5049 if(m_spellInfo->TotemCategory[i] != 0)
5051 if( p_caster->HasItemTotemCategory(m_spellInfo->TotemCategory[i]) )
5053 TotemCategory -= 1;
5054 continue;
5057 else
5058 TotemCategory -= 1;
5060 if(TotemCategory != 0)
5061 return SPELL_FAILED_TOTEM_CATEGORY; //0x7B
5063 // special checks for spell effects
5064 for(int i = 0; i < 3; ++i)
5066 switch (m_spellInfo->Effect[i])
5068 case SPELL_EFFECT_CREATE_ITEM:
5070 if (!m_IsTriggeredSpell && m_spellInfo->EffectItemType[i])
5072 ItemPosCountVec dest;
5073 uint8 msg = p_caster->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, m_spellInfo->EffectItemType[i], 1 );
5074 if (msg != EQUIP_ERR_OK )
5076 p_caster->SendEquipError( msg, NULL, NULL );
5077 return SPELL_FAILED_DONT_REPORT;
5080 break;
5082 case SPELL_EFFECT_ENCHANT_ITEM:
5083 case SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC:
5085 Item* targetItem = m_targets.getItemTarget();
5086 if(!targetItem)
5087 return SPELL_FAILED_ITEM_NOT_FOUND;
5089 if( targetItem->GetProto()->ItemLevel < m_spellInfo->baseLevel )
5090 return SPELL_FAILED_LOWLEVEL;
5091 // Not allow enchant in trade slot for some enchant type
5092 if( targetItem->GetOwner() != m_caster )
5094 uint32 enchant_id = m_spellInfo->EffectMiscValue[i];
5095 SpellItemEnchantmentEntry const *pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
5096 if(!pEnchant)
5097 return SPELL_FAILED_ERROR;
5098 if (pEnchant->slot & ENCHANTMENT_CAN_SOULBOUND)
5099 return SPELL_FAILED_NOT_TRADEABLE;
5101 break;
5103 case SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY:
5105 Item *item = m_targets.getItemTarget();
5106 if(!item)
5107 return SPELL_FAILED_ITEM_NOT_FOUND;
5108 // Not allow enchant in trade slot for some enchant type
5109 if( item->GetOwner() != m_caster )
5111 uint32 enchant_id = m_spellInfo->EffectMiscValue[i];
5112 SpellItemEnchantmentEntry const *pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
5113 if(!pEnchant)
5114 return SPELL_FAILED_ERROR;
5115 if (pEnchant->slot & ENCHANTMENT_CAN_SOULBOUND)
5116 return SPELL_FAILED_NOT_TRADEABLE;
5118 break;
5120 case SPELL_EFFECT_ENCHANT_HELD_ITEM:
5121 // check item existence in effect code (not output errors at offhand hold item effect to main hand for example
5122 break;
5123 case SPELL_EFFECT_DISENCHANT:
5125 if(!m_targets.getItemTarget())
5126 return SPELL_FAILED_CANT_BE_DISENCHANTED;
5128 // prevent disenchanting in trade slot
5129 if( m_targets.getItemTarget()->GetOwnerGUID() != m_caster->GetGUID() )
5130 return SPELL_FAILED_CANT_BE_DISENCHANTED;
5132 ItemPrototype const* itemProto = m_targets.getItemTarget()->GetProto();
5133 if(!itemProto)
5134 return SPELL_FAILED_CANT_BE_DISENCHANTED;
5136 uint32 item_quality = itemProto->Quality;
5137 // 2.0.x addon: Check player enchanting level against the item disenchanting requirements
5138 uint32 item_disenchantskilllevel = itemProto->RequiredDisenchantSkill;
5139 if (item_disenchantskilllevel == uint32(-1))
5140 return SPELL_FAILED_CANT_BE_DISENCHANTED;
5141 if (item_disenchantskilllevel > p_caster->GetSkillValue(SKILL_ENCHANTING))
5142 return SPELL_FAILED_LOW_CASTLEVEL;
5143 if(item_quality > 4 || item_quality < 2)
5144 return SPELL_FAILED_CANT_BE_DISENCHANTED;
5145 if(itemProto->Class != ITEM_CLASS_WEAPON && itemProto->Class != ITEM_CLASS_ARMOR)
5146 return SPELL_FAILED_CANT_BE_DISENCHANTED;
5147 if (!itemProto->DisenchantID)
5148 return SPELL_FAILED_CANT_BE_DISENCHANTED;
5149 break;
5151 case SPELL_EFFECT_PROSPECTING:
5153 if(!m_targets.getItemTarget())
5154 return SPELL_FAILED_CANT_BE_PROSPECTED;
5155 //ensure item is a prospectable ore
5156 if(!(m_targets.getItemTarget()->GetProto()->BagFamily & BAG_FAMILY_MASK_MINING_SUPP) || m_targets.getItemTarget()->GetProto()->Class != ITEM_CLASS_TRADE_GOODS)
5157 return SPELL_FAILED_CANT_BE_PROSPECTED;
5158 //prevent prospecting in trade slot
5159 if( m_targets.getItemTarget()->GetOwnerGUID() != m_caster->GetGUID() )
5160 return SPELL_FAILED_CANT_BE_PROSPECTED;
5161 //Check for enough skill in jewelcrafting
5162 uint32 item_prospectingskilllevel = m_targets.getItemTarget()->GetProto()->RequiredSkillRank;
5163 if(item_prospectingskilllevel >p_caster->GetSkillValue(SKILL_JEWELCRAFTING))
5164 return SPELL_FAILED_LOW_CASTLEVEL;
5165 //make sure the player has the required ores in inventory
5166 if(m_targets.getItemTarget()->GetCount() < 5)
5167 return SPELL_FAILED_NEED_MORE_ITEMS;
5169 if(!LootTemplates_Prospecting.HaveLootFor(m_targets.getItemTargetEntry()))
5170 return SPELL_FAILED_CANT_BE_PROSPECTED;
5172 break;
5174 case SPELL_EFFECT_MILLING:
5176 if(!m_targets.getItemTarget())
5177 return SPELL_FAILED_CANT_BE_MILLED;
5178 //ensure item is a millable herb
5179 if(!(m_targets.getItemTarget()->GetProto()->BagFamily & BAG_FAMILY_MASK_HERBS) || m_targets.getItemTarget()->GetProto()->Class != ITEM_CLASS_TRADE_GOODS)
5180 return SPELL_FAILED_CANT_BE_MILLED;
5181 //prevent milling in trade slot
5182 if( m_targets.getItemTarget()->GetOwnerGUID() != m_caster->GetGUID() )
5183 return SPELL_FAILED_CANT_BE_MILLED;
5184 //Check for enough skill in inscription
5185 uint32 item_millingskilllevel = m_targets.getItemTarget()->GetProto()->RequiredSkillRank;
5186 if(item_millingskilllevel >p_caster->GetSkillValue(SKILL_INSCRIPTION))
5187 return SPELL_FAILED_LOW_CASTLEVEL;
5188 //make sure the player has the required herbs in inventory
5189 if(m_targets.getItemTarget()->GetCount() < 5)
5190 return SPELL_FAILED_NEED_MORE_ITEMS;
5192 if(!LootTemplates_Milling.HaveLootFor(m_targets.getItemTargetEntry()))
5193 return SPELL_FAILED_CANT_BE_MILLED;
5195 break;
5197 case SPELL_EFFECT_WEAPON_DAMAGE:
5198 case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
5200 if(m_caster->GetTypeId() != TYPEID_PLAYER) return SPELL_FAILED_TARGET_NOT_PLAYER;
5201 if( m_attackType != RANGED_ATTACK )
5202 break;
5203 Item *pItem = ((Player*)m_caster)->GetWeaponForAttack(m_attackType);
5204 if(!pItem || pItem->IsBroken())
5205 return SPELL_FAILED_EQUIPPED_ITEM;
5207 switch(pItem->GetProto()->SubClass)
5209 case ITEM_SUBCLASS_WEAPON_THROWN:
5211 uint32 ammo = pItem->GetEntry();
5212 if( !((Player*)m_caster)->HasItemCount( ammo, 1 ) )
5213 return SPELL_FAILED_NO_AMMO;
5214 }; break;
5215 case ITEM_SUBCLASS_WEAPON_GUN:
5216 case ITEM_SUBCLASS_WEAPON_BOW:
5217 case ITEM_SUBCLASS_WEAPON_CROSSBOW:
5219 uint32 ammo = ((Player*)m_caster)->GetUInt32Value(PLAYER_AMMO_ID);
5220 if(!ammo)
5222 // Requires No Ammo
5223 if(m_caster->GetDummyAura(46699))
5224 break; // skip other checks
5226 return SPELL_FAILED_NO_AMMO;
5229 ItemPrototype const *ammoProto = objmgr.GetItemPrototype( ammo );
5230 if(!ammoProto)
5231 return SPELL_FAILED_NO_AMMO;
5233 if(ammoProto->Class != ITEM_CLASS_PROJECTILE)
5234 return SPELL_FAILED_NO_AMMO;
5236 // check ammo ws. weapon compatibility
5237 switch(pItem->GetProto()->SubClass)
5239 case ITEM_SUBCLASS_WEAPON_BOW:
5240 case ITEM_SUBCLASS_WEAPON_CROSSBOW:
5241 if(ammoProto->SubClass != ITEM_SUBCLASS_ARROW)
5242 return SPELL_FAILED_NO_AMMO;
5243 break;
5244 case ITEM_SUBCLASS_WEAPON_GUN:
5245 if(ammoProto->SubClass != ITEM_SUBCLASS_BULLET)
5246 return SPELL_FAILED_NO_AMMO;
5247 break;
5248 default:
5249 return SPELL_FAILED_NO_AMMO;
5252 if( !((Player*)m_caster)->HasItemCount( ammo, 1 ) )
5253 return SPELL_FAILED_NO_AMMO;
5254 }; break;
5255 case ITEM_SUBCLASS_WEAPON_WAND:
5256 break;
5257 default:
5258 break;
5260 break;
5262 default:break;
5266 return SPELL_CAST_OK;
5269 void Spell::Delayed()
5271 if(!m_caster || m_caster->GetTypeId() != TYPEID_PLAYER)
5272 return;
5274 if (m_spellState == SPELL_STATE_DELAYED)
5275 return; // spell is active and can't be time-backed
5277 if(isDelayableNoMore()) // Spells may only be delayed twice
5278 return;
5280 // spells not loosing casting time ( slam, dynamites, bombs.. )
5281 if(!(m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_DAMAGE))
5282 return;
5284 //check pushback reduce
5285 int32 delaytime = 500; // spellcasting delay is normally 500ms
5286 int32 delayReduce = 100; // must be initialized to 100 for percent modifiers
5287 ((Player*)m_caster)->ApplySpellMod(m_spellInfo->Id, SPELLMOD_NOT_LOSE_CASTING_TIME, delayReduce, this);
5288 delayReduce += m_caster->GetTotalAuraModifier(SPELL_AURA_REDUCE_PUSHBACK) - 100;
5289 if(delayReduce >= 100)
5290 return;
5292 delaytime = delaytime * (100 - delayReduce) / 100;
5294 if(int32(m_timer) + delaytime > m_casttime)
5296 delaytime = m_casttime - m_timer;
5297 m_timer = m_casttime;
5299 else
5300 m_timer += delaytime;
5302 sLog.outDetail("Spell %u partially interrupted for (%d) ms at damage", m_spellInfo->Id, delaytime);
5304 WorldPacket data(SMSG_SPELL_DELAYED, 8+4);
5305 data.append(m_caster->GetPackGUID());
5306 data << uint32(delaytime);
5308 m_caster->SendMessageToSet(&data, true);
5311 void Spell::DelayedChannel()
5313 if(!m_caster || m_caster->GetTypeId() != TYPEID_PLAYER || getState() != SPELL_STATE_CASTING)
5314 return;
5316 if(isDelayableNoMore()) // Spells may only be delayed twice
5317 return;
5319 //check pushback reduce
5320 int32 delaytime = GetSpellDuration(m_spellInfo) * 25 / 100; // channeling delay is normally 25% of its time per hit
5321 int32 delayReduce = 100; // must be initialized to 100 for percent modifiers
5322 ((Player*)m_caster)->ApplySpellMod(m_spellInfo->Id, SPELLMOD_NOT_LOSE_CASTING_TIME, delayReduce, this);
5323 delayReduce += m_caster->GetTotalAuraModifier(SPELL_AURA_REDUCE_PUSHBACK) - 100;
5324 if(delayReduce >= 100)
5325 return;
5327 delaytime = delaytime * (100 - delayReduce) / 100;
5329 if(int32(m_timer) < delaytime)
5331 delaytime = m_timer;
5332 m_timer = 0;
5334 else
5335 m_timer -= delaytime;
5337 sLog.outDebug("Spell %u partially interrupted for %i ms, new duration: %u ms", m_spellInfo->Id, delaytime, m_timer);
5339 for(std::list<TargetInfo>::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
5341 if ((*ihit).missCondition == SPELL_MISS_NONE)
5343 Unit* unit = m_caster->GetGUID() == ihit->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID);
5344 if (unit)
5346 for (int j = 0; j < 3; ++j)
5347 if( ihit->effectMask & (1 << j) )
5348 unit->DelayAura(m_spellInfo->Id, j, delaytime);
5354 for(int j = 0; j < 3; ++j)
5356 // partially interrupt persistent area auras
5357 DynamicObject* dynObj = m_caster->GetDynObject(m_spellInfo->Id, j);
5358 if(dynObj)
5359 dynObj->Delay(delaytime);
5362 SendChannelUpdate(m_timer);
5365 void Spell::UpdatePointers()
5367 if(m_originalCasterGUID==m_caster->GetGUID())
5368 m_originalCaster = m_caster;
5369 else
5371 m_originalCaster = ObjectAccessor::GetUnit(*m_caster,m_originalCasterGUID);
5372 if(m_originalCaster && !m_originalCaster->IsInWorld()) m_originalCaster = NULL;
5375 m_targets.Update(m_caster);
5378 bool Spell::IsAffectedByAura(Aura *aura)
5380 return spellmgr.IsAffectedByMod(m_spellInfo, aura->getAuraSpellMod());
5383 bool Spell::CheckTargetCreatureType(Unit* target) const
5385 uint32 spellCreatureTargetMask = m_spellInfo->TargetCreatureType;
5387 // Curse of Doom : not find another way to fix spell target check :/
5388 if(m_spellInfo->SpellFamilyName==SPELLFAMILY_WARLOCK && m_spellInfo->SpellFamilyFlags == UI64LIT(0x0200000000))
5390 // not allow cast at player
5391 if(target->GetTypeId()==TYPEID_PLAYER)
5392 return false;
5394 spellCreatureTargetMask = 0x7FF;
5397 // Dismiss Pet and Taming Lesson skipped
5398 if(m_spellInfo->Id == 2641 || m_spellInfo->Id == 23356)
5399 spellCreatureTargetMask = 0;
5401 if (spellCreatureTargetMask)
5403 uint32 TargetCreatureType = target->GetCreatureTypeMask();
5405 return !TargetCreatureType || (spellCreatureTargetMask & TargetCreatureType);
5407 return true;
5410 CurrentSpellTypes Spell::GetCurrentContainer()
5412 if (IsNextMeleeSwingSpell())
5413 return(CURRENT_MELEE_SPELL);
5414 else if (IsAutoRepeat())
5415 return(CURRENT_AUTOREPEAT_SPELL);
5416 else if (IsChanneledSpell(m_spellInfo))
5417 return(CURRENT_CHANNELED_SPELL);
5418 else
5419 return(CURRENT_GENERIC_SPELL);
5422 bool Spell::CheckTarget( Unit* target, uint32 eff )
5424 // Check targets for creature type mask and remove not appropriate (skip explicit self target case, maybe need other explicit targets)
5425 if(m_spellInfo->EffectImplicitTargetA[eff] != TARGET_SELF )
5427 if (!CheckTargetCreatureType(target))
5428 return false;
5431 // Check Aura spell req (need for AoE spells)
5432 if(m_spellInfo->targetAuraSpell && !target->HasAura(m_spellInfo->targetAuraSpell))
5433 return false;
5434 if (m_spellInfo->excludeTargetAuraSpell && target->HasAura(m_spellInfo->excludeTargetAuraSpell))
5435 return false;
5437 // Check targets for not_selectable unit flag and remove
5438 // A player can cast spells on his pet (or other controlled unit) though in any state
5439 if (target != m_caster && target->GetCharmerOrOwnerGUID() != m_caster->GetGUID())
5441 // any unattackable target skipped
5442 if (target->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE))
5443 return false;
5445 // unselectable targets skipped in all cases except TARGET_SCRIPT targeting
5446 // in case TARGET_SCRIPT target selected by server always and can't be cheated
5447 if( target->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE) &&
5448 m_spellInfo->EffectImplicitTargetA[eff] != TARGET_SCRIPT &&
5449 m_spellInfo->EffectImplicitTargetB[eff] != TARGET_SCRIPT )
5450 return false;
5453 //Check player targets and remove if in GM mode or GM invisibility (for not self casting case)
5454 if( target != m_caster && target->GetTypeId() == TYPEID_PLAYER)
5456 if(((Player*)target)->GetVisibility() == VISIBILITY_OFF)
5457 return false;
5459 if(((Player*)target)->isGameMaster() && !IsPositiveSpell(m_spellInfo->Id))
5460 return false;
5463 //Check targets for LOS visibility (except spells without range limitations )
5464 switch(m_spellInfo->Effect[eff])
5466 case SPELL_EFFECT_SUMMON_PLAYER: // from anywhere
5467 break;
5468 case SPELL_EFFECT_DUMMY:
5469 if(m_spellInfo->Id != 20577) // Cannibalize
5470 break;
5471 //fall through
5472 case SPELL_EFFECT_RESURRECT_NEW:
5473 // player far away, maybe his corpse near?
5474 if(target != m_caster && !target->IsWithinLOSInMap(m_caster))
5476 if(!m_targets.getCorpseTargetGUID())
5477 return false;
5479 Corpse *corpse = ObjectAccessor::GetCorpse(*m_caster, m_targets.getCorpseTargetGUID());
5480 if(!corpse)
5481 return false;
5483 if(target->GetGUID() != corpse->GetOwnerGUID())
5484 return false;
5486 if(!corpse->IsWithinLOSInMap(m_caster))
5487 return false;
5490 // all ok by some way or another, skip normal check
5491 break;
5492 default: // normal case
5493 // Get GO cast coordinates if original caster -> GO
5494 WorldObject *caster = NULL;
5495 if (IS_GAMEOBJECT_GUID(m_originalCasterGUID))
5496 caster = m_caster->GetMap()->GetGameObject(m_originalCasterGUID);
5497 if (!caster)
5498 caster = m_caster;
5499 if(target != m_caster && !target->IsWithinLOSInMap(caster))
5500 return false;
5501 break;
5504 return true;
5507 bool Spell::IsNeedSendToClient() const
5509 return m_spellInfo->SpellVisual[0] || m_spellInfo->SpellVisual[1] || IsChanneledSpell(m_spellInfo) ||
5510 m_spellInfo->speed > 0.0f || !m_triggeredByAuraSpell && !m_IsTriggeredSpell;
5513 bool Spell::HaveTargetsForEffect( uint8 effect ) const
5515 for(std::list<TargetInfo>::const_iterator itr = m_UniqueTargetInfo.begin(); itr != m_UniqueTargetInfo.end(); ++itr)
5516 if(itr->effectMask & (1 << effect))
5517 return true;
5519 for(std::list<GOTargetInfo>::const_iterator itr = m_UniqueGOTargetInfo.begin(); itr != m_UniqueGOTargetInfo.end(); ++itr)
5520 if(itr->effectMask & (1 << effect))
5521 return true;
5523 for(std::list<ItemTargetInfo>::const_iterator itr = m_UniqueItemInfo.begin(); itr != m_UniqueItemInfo.end(); ++itr)
5524 if(itr->effectMask & (1 << effect))
5525 return true;
5527 return false;
5530 SpellEvent::SpellEvent(Spell* spell) : BasicEvent()
5532 m_Spell = spell;
5535 SpellEvent::~SpellEvent()
5537 if (m_Spell->getState() != SPELL_STATE_FINISHED)
5538 m_Spell->cancel();
5540 if (m_Spell->IsDeletable())
5542 delete m_Spell;
5544 else
5546 sLog.outError("~SpellEvent: %s %u tried to delete non-deletable spell %u. Was not deleted, causes memory leak.",
5547 (m_Spell->GetCaster()->GetTypeId() == TYPEID_PLAYER ? "Player" : "Creature"), m_Spell->GetCaster()->GetGUIDLow(), m_Spell->m_spellInfo->Id);
5551 bool SpellEvent::Execute(uint64 e_time, uint32 p_time)
5553 // update spell if it is not finished
5554 if (m_Spell->getState() != SPELL_STATE_FINISHED)
5555 m_Spell->update(p_time);
5557 // check spell state to process
5558 switch (m_Spell->getState())
5560 case SPELL_STATE_FINISHED:
5562 // spell was finished, check deletable state
5563 if (m_Spell->IsDeletable())
5565 // check, if we do have unfinished triggered spells
5566 return true; // spell is deletable, finish event
5568 // event will be re-added automatically at the end of routine)
5569 } break;
5571 case SPELL_STATE_CASTING:
5573 // this spell is in channeled state, process it on the next update
5574 // event will be re-added automatically at the end of routine)
5575 } break;
5577 case SPELL_STATE_DELAYED:
5579 // first, check, if we have just started
5580 if (m_Spell->GetDelayStart() != 0)
5582 // no, we aren't, do the typical update
5583 // check, if we have channeled spell on our hands
5584 if (IsChanneledSpell(m_Spell->m_spellInfo))
5586 // evented channeled spell is processed separately, casted once after delay, and not destroyed till finish
5587 // check, if we have casting anything else except this channeled spell and autorepeat
5588 if (m_Spell->GetCaster()->IsNonMeleeSpellCasted(false, true, true))
5590 // another non-melee non-delayed spell is casted now, abort
5591 m_Spell->cancel();
5593 else
5595 // do the action (pass spell to channeling state)
5596 m_Spell->handle_immediate();
5598 // event will be re-added automatically at the end of routine)
5600 else
5602 // run the spell handler and think about what we can do next
5603 uint64 t_offset = e_time - m_Spell->GetDelayStart();
5604 uint64 n_offset = m_Spell->handle_delayed(t_offset);
5605 if (n_offset)
5607 // re-add us to the queue
5608 m_Spell->GetCaster()->m_Events.AddEvent(this, m_Spell->GetDelayStart() + n_offset, false);
5609 return false; // event not complete
5611 // event complete
5612 // finish update event will be re-added automatically at the end of routine)
5615 else
5617 // delaying had just started, record the moment
5618 m_Spell->SetDelayStart(e_time);
5619 // re-plan the event for the delay moment
5620 m_Spell->GetCaster()->m_Events.AddEvent(this, e_time + m_Spell->GetDelayMoment(), false);
5621 return false; // event not complete
5623 } break;
5625 default:
5627 // all other states
5628 // event will be re-added automatically at the end of routine)
5629 } break;
5632 // spell processing not complete, plan event on the next update interval
5633 m_Spell->GetCaster()->m_Events.AddEvent(this, e_time + 1, false);
5634 return false; // event not complete
5637 void SpellEvent::Abort(uint64 /*e_time*/)
5639 // oops, the spell we try to do is aborted
5640 if (m_Spell->getState() != SPELL_STATE_FINISHED)
5641 m_Spell->cancel();
5644 bool SpellEvent::IsDeletable() const
5646 return m_Spell->IsDeletable();
5649 SpellCastResult Spell::CanOpenLock(uint32 effIndex, uint32 lockId, SkillType& skillId, int32& reqSkillValue, int32& skillValue)
5651 if(!lockId) // possible case for GO and maybe for items.
5652 return SPELL_CAST_OK;
5654 // Get LockInfo
5655 LockEntry const *lockInfo = sLockStore.LookupEntry(lockId);
5657 if (!lockInfo)
5658 return SPELL_FAILED_BAD_TARGETS;
5660 bool reqKey = false; // some locks not have reqs
5662 for(int j = 0; j < 8; ++j)
5664 switch(lockInfo->Type[j])
5666 // check key item (many fit cases can be)
5667 case LOCK_KEY_ITEM:
5668 if(lockInfo->Index[j] && m_CastItem && m_CastItem->GetEntry()==lockInfo->Index[j])
5669 return SPELL_CAST_OK;
5670 reqKey = true;
5671 break;
5672 // check key skill (only single first fit case can be)
5673 case LOCK_KEY_SKILL:
5675 reqKey = true;
5677 // wrong locktype, skip
5678 if(uint32(m_spellInfo->EffectMiscValue[effIndex]) != lockInfo->Index[j])
5679 continue;
5681 skillId = SkillByLockType(LockType(lockInfo->Index[j]));
5683 if ( skillId != SKILL_NONE )
5685 // skill bonus provided by casting spell (mostly item spells)
5686 // add the damage modifier from the spell casted (cheat lock / skeleton key etc.) (use m_currentBasePoints, CalculateDamage returns wrong value)
5687 uint32 spellSkillBonus = uint32(m_currentBasePoints[effIndex]+1);
5688 reqSkillValue = lockInfo->Skill[j];
5690 // castitem check: rogue using skeleton keys. the skill values should not be added in this case.
5691 skillValue = m_CastItem || m_caster->GetTypeId()!= TYPEID_PLAYER ?
5692 0 : ((Player*)m_caster)->GetSkillValue(skillId);
5694 skillValue += spellSkillBonus;
5696 if (skillValue < reqSkillValue)
5697 return SPELL_FAILED_LOW_CASTLEVEL;
5700 return SPELL_CAST_OK;
5705 if(reqKey)
5706 return SPELL_FAILED_BAD_TARGETS;
5708 return SPELL_CAST_OK;
5711 void Spell::FillAreaTargets( UnitList& TagUnitMap, float x, float y, float radius, SpellNotifyPushType pushType, SpellTargets spellTargets )
5713 CellPair p(MaNGOS::ComputeCellPair(x, y));
5714 Cell cell(p);
5715 cell.data.Part.reserved = ALL_DISTRICT;
5716 cell.SetNoCreate();
5717 MaNGOS::SpellNotifierCreatureAndPlayer notifier(*this, TagUnitMap, radius, pushType, spellTargets);
5718 TypeContainerVisitor<MaNGOS::SpellNotifierCreatureAndPlayer, WorldTypeMapContainer > world_notifier(notifier);
5719 TypeContainerVisitor<MaNGOS::SpellNotifierCreatureAndPlayer, GridTypeMapContainer > grid_notifier(notifier);
5720 CellLock<GridReadGuard> cell_lock(cell, p);
5721 cell_lock->Visit(cell_lock, world_notifier, *m_caster->GetMap());
5722 cell_lock->Visit(cell_lock, grid_notifier, *m_caster->GetMap());