| blob | 10d1c5f13a70b2ceed224e60760f54ae952161f1 |
1 /*
2 * Copyright (C) 2005-2010 MaNGOS <http://getmangos.com/>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
48 #define SPELL_CHANNEL_UPDATE_INTERVAL (1 * IN_MILISECONDS)
52 class PrioritizeManaUnitWraper
53 {
56 {
59 }
64 uint32 i_percent;
65 };
67 struct PrioritizeMana
68 {
70 {
72 }
73 };
75 typedef std::priority_queue<PrioritizeManaUnitWraper, std::vector<PrioritizeManaUnitWraper>, PrioritizeMana> PrioritizeManaUnitQueue;
77 class PrioritizeHealthUnitWraper
78 {
81 {
83 }
88 uint32 i_percent;
89 };
91 struct PrioritizeHealth
92 {
94 {
96 }
97 };
99 typedef std::priority_queue<PrioritizeHealthUnitWraper, std::vector<PrioritizeHealthUnitWraper>, PrioritizeHealth> PrioritizeHealthUnitQueue;
102 {
108 && spellproto->Effect[EFFECT_INDEX_1] == SPELL_EFFECT_APPLY_AURA && spellproto->EffectApplyAuraName[EFFECT_INDEX_1] == SPELL_AURA_DUMMY;
109 }
112 {
126 }
129 {
130 }
133 {
143 }
146 {
151 }
154 {
159 }
162 {
165 // m_targetMask |= TARGET_FLAG_OBJECT;
166 }
169 {
177 }
180 {
182 }
185 {
186 m_GOTarget = !m_GOTargetGUID.IsEmpty() ? caster->GetMap()->GetGameObject(m_GOTargetGUID) : NULL;
188 ( m_unitTargetGUID == caster->GetObjectGuid() ? caster : ObjectAccessor::GetUnit(*caster, m_unitTargetGUID) ) :
189 NULL;
193 {
197 {
200 m_itemTarget = pTrader->GetItemByPos(pTrader->GetItemPosByTradeSlot(uint32(m_itemTargetGUID.GetRawValue())));
201 }
204 }
205 }
208 {
212 {
219 }
221 // TARGET_FLAG_UNK2 is used for non-combat pets, maybe other?
228 if(( m_targetMask & ( TARGET_FLAG_ITEM | TARGET_FLAG_TRADE_ITEM )) && caster->GetTypeId() == TYPEID_PLAYER)
235 {
240 }
243 {
248 }
253 // find real units/GOs
255 }
258 {
261 if( m_targetMask & ( TARGET_FLAG_UNIT | TARGET_FLAG_PVP_CORPSE | TARGET_FLAG_OBJECT | TARGET_FLAG_CORPSE | TARGET_FLAG_UNK2 ) )
262 {
264 {
267 else
269 }
271 {
274 else
276 }
279 else
281 }
284 {
287 else
289 }
292 {
295 else
299 }
302 {
305 else
309 }
313 }
315 Spell::Spell( Unit* Caster, SpellEntry const *info, bool triggered, ObjectGuid originalCasterGUID, Spell** triggeringContainer )
316 {
318 ASSERT( info == sSpellStore.LookupEntry( info->Id ) && "`info` must be pointer to sSpellStore element");
331 // Get data for type of attack
334 m_spellSchoolMask = GetSpellSchoolMask(info); // Can be override for some spell (wand shoot for example)
337 {
338 // wand case
339 if((m_caster->getClassMask() & CLASSMASK_WAND_USERS) != 0 && m_caster->GetTypeId() == TYPEID_PLAYER)
340 {
343 }
344 }
345 // Set health leech amount to zero
350 else
364 //m_AreaAura = false;
375 //Auto Shot & Shoot (wand)
385 // determine reflection
388 if(m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MAGIC && !(m_spellInfo->AttributesEx2 & SPELL_ATTR_EX2_CANT_REFLECTED))
389 {
391 {
395 if(!IsPositiveTarget(m_spellInfo->EffectImplicitTargetA[j], m_spellInfo->EffectImplicitTargetB[j]))
397 else
402 else
404 }
405 }
408 }
411 {
412 }
416 {
417 // non-standard target selection
431 TypeContainerVisitor<MaNGOS::WorldObjectSearcher<T>, GridTypeMapContainer > grid_searcher(searcher);
435 {
436 TypeContainerVisitor<MaNGOS::WorldObjectSearcher<T>, WorldTypeMapContainer > world_searcher(searcher);
438 }
441 }
444 {
445 // TODO: ADD the correct target FILLS!!!!!!
448 {
449 // not call for empty effect.
450 // Also some spells use not used effect targets for store targets for dummy effect in triggered spells
454 // targets for TARGET_SCRIPT_COORDINATES (A) and TARGET_SCRIPT
455 // for TARGET_FOCUS_OR_SCRIPTED_GAMEOBJECT (A) all is checked in Spell::CheckCast and in Spell::CheckItem
456 // filled in Spell::CheckCast call
460 (m_spellInfo->EffectImplicitTargetB[i] == TARGET_SCRIPT && m_spellInfo->EffectImplicitTargetA[i] != TARGET_SELF))
463 // TODO: find a way so this is not needed?
464 // for area auras always add caster as target (needed for totems for example)
470 // TargetA/TargetB dependent from each other, we not switch to full support this dependences
471 // but need it support in some know cases
473 {
476 {
483 }
487 {
494 m_targets.setDestination(m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ());
504 }
508 {
528 // need some target for processing
535 }
539 {
541 // Note: this hack with search required until GO casting not implemented
542 // environment damage spells already have around enemies targeting but this not help in case not existed GO casting support
543 // currently each enemy selected explicitly and self cast damage
545 {
548 }
549 else
550 {
553 }
563 }
567 {
571 // need some target for processing
574 case TARGET_AREAEFFECT_INSTANT: // All 17/7 pairs used for dest teleportation, A processed in effect code
581 }
585 {
590 // most A/B target pairs is self->negative and not expect adding caster to target list
594 }
598 {
603 case TARGET_SCRIPT_COORDINATES: // B case filled in CheckCast but we need fill unit list base at A case
610 }
612 }
615 {
618 {
622 {
626 }
627 }
628 }
631 {
633 {
636 }
637 else
639 }
641 for(std::list<Unit*>::const_iterator iunit = tmpUnitMap.begin(); iunit != tmpUnitMap.end(); ++iunit)
643 }
644 }
647 {
648 //==========================================================================================
649 // Now fill data for trigger system, need know:
650 // an spell trigger another or not ( m_canTrigger )
651 // Create base triggers flags for Attacker and Victim ( m_procAttacker and m_procVictim)
652 //==========================================================================================
653 // Fill flag can spell trigger or not
654 // TODO: possible exist spell attribute for this
665 {
667 {
669 // Arcane Missles / Blizzard triggers need do it
672 // Clearcasting trigger need do it
673 else if (m_spellInfo->SpellFamilyFlags & UI64LIT(0x0000000200000000) && m_spellInfo->SpellFamilyFlags2 & 0x8)
675 // Replenish Mana, item spell with triggered cases (Mana Agate, etc mana gems)
680 // For Hellfire Effect / Rain of Fire / Seed of Corruption triggers need do it
685 // For Penance,Mind Sear,Mind Flay heal/damage triggers need do it
686 if (m_spellInfo->SpellFamilyFlags & UI64LIT(0x0001800000800000) || (m_spellInfo->SpellFamilyFlags2 & 0x00000040))
690 // For poisons need do it
695 // Hunter Rapid Killing/Explosive Trap Effect/Immolation Trap Effect/Frost Trap Aura/Snake Trap Effect/Explosive Shot
701 // For Judgements (all) / Holy Shock triggers need do it
707 }
708 }
710 // Get data for type of attack and fill base info for trigger
712 {
718 // Auto attack
720 {
723 }
725 {
728 }
732 {
735 }
737 {
740 }
742 {
745 }
747 }
748 // Hunter traps spells (for Entrapment trigger)
749 // Gives your Immolation Trap, Frost Trap, Explosive Trap, and Snake Trap ....
750 if (m_spellInfo->SpellFamilyName == SPELLFAMILY_HUNTER && (m_spellInfo->SpellFamilyFlags & UI64LIT(0x000020000000001C)))
752 }
755 {
760 }
763 {
767 // Check for effect immune skip if immuned
772 // Lookup target in already in list
773 for(std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
774 {
776 {
780 }
781 }
783 // This is new target calculate data for him
785 // Get spell hit result on target
786 TargetInfo target;
791 // Calculate hit result
794 // Spell have speed - need calculate incoming time
796 {
797 // calculate spell incoming interval
798 float dist = m_caster->GetDistance(pVictim->GetPositionX(), pVictim->GetPositionY(), pVictim->GetPositionZ());
802 // Calculate minimum incoming time
805 }
806 else
809 // If target reflect spell back to caster
811 {
812 // Calculate reflected spell result on caster
815 if (target.reflectResult == SPELL_MISS_REFLECT) // Impossible reflect again, so simply deflect spell
818 // Increase time interval for reflected spells by 1.5
820 }
821 else
824 // Add target to list
826 }
829 {
830 Unit* unit = m_caster->GetGUID() == unitGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, unitGUID);
833 }
836 {
842 // Lookup target in already in list
843 for(std::list<GOTargetInfo>::iterator ihit = m_UniqueGOTargetInfo.begin(); ihit != m_UniqueGOTargetInfo.end(); ++ihit)
844 {
846 {
849 }
850 }
852 // This is new target calculate data for him
854 GOTargetInfo target;
859 // Spell have speed - need calculate incoming time
861 {
862 // calculate spell incoming interval
863 float dist = m_caster->GetDistance(pVictim->GetPositionX(), pVictim->GetPositionY(), pVictim->GetPositionZ());
869 }
870 else
873 // Add target to list
875 }
878 {
882 }
885 {
889 // Lookup target in already in list
890 for(std::list<ItemTargetInfo>::iterator ihit = m_UniqueItemInfo.begin(); ihit != m_UniqueItemInfo.end(); ++ihit)
891 {
893 {
896 }
897 }
899 // This is new target add data
901 ItemTargetInfo target;
905 }
908 {
913 // Get mask of effects for target
916 Unit* unit = m_caster->GetObjectGuid() == target->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, target->targetGUID);
920 // Get original caster (if exist) and calculate damage/healing from him data
922 // FIXME: in case wild GO heal/damage spells will be used target bonuses
926 // Need init unitTarget by default unit (can changed in code on reflect)
927 // Or on missInfo!=SPELL_MISS_NONE unitTarget undefined (but need in trigger subsystem)
930 // Reset damage/healing counter
934 // Fill base trigger info
941 else if (missInfo == SPELL_MISS_REFLECT) // In case spell reflect from target, do all effect on caster (if hit)
942 {
943 if (target->reflectResult == SPELL_MISS_NONE) // If reflected spell hit caster -> do all effect on him
945 }
947 // All calculated do it!
948 // Do healing and triggers
950 {
951 bool crit = real_caster && real_caster->isSpellCrit(unitTarget, m_spellInfo, m_spellSchoolMask);
954 {
957 }
958 else
961 // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge)
963 {
964 caster->ProcDamageAndSpell(unitTarget, real_caster ? procAttacker : PROC_FLAG_NONE, procVictim, procEx, addhealth, m_attackType, m_spellInfo);
965 }
971 }
972 // Do damage and triggers
974 {
975 // Fill base damage struct (unitTarget - is real spell target)
978 // Add bonuses and fill damageInfo struct
983 // Send log damage message to client
989 // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge)
991 caster->ProcDamageAndSpell(unitTarget, real_caster ? procAttacker : PROC_FLAG_NONE, procVictim, procEx, damageInfo.damage, m_attackType, m_spellInfo);
993 // Haunt (NOTE: for avoid use additional field damage stored in dummy value (replace unused 100%)
994 // apply before deal damage because aura can be removed at target kill
1001 }
1002 // Passive spell hits/misses or active spells only misses (only triggers)
1003 else
1004 {
1005 // Fill base damage struct (unitTarget - is real spell target)
1008 // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge)
1010 caster->ProcDamageAndSpell(unit, real_caster ? procAttacker : PROC_FLAG_NONE, procVictim, procEx, 0, m_attackType, m_spellInfo);
1011 }
1013 // Call scripted function for AI if this spell is casted upon a creature
1015 {
1016 // cast at creature (or GO) quest objectives update at successful cast finished (+channel finished)
1017 // ignore pets or autorepeat/melee casts for speed (not exist quest for spells (hm... )
1018 if (real_caster && !((Creature*)unit)->isPet() && !IsAutoRepeat() && !IsNextMeleeSwingSpell() && !IsChannelActive())
1024 }
1026 // Call scripted function for AI if this spell is casted by a creature
1029 }
1032 {
1038 // Recheck immune (only for delayed spells)
1042 {
1046 }
1049 {
1050 ((Player*)unit)->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, m_spellInfo->Id);
1051 ((Player*)unit)->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2, m_spellInfo->Id);
1052 }
1055 ((Player*)realCaster)->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2, m_spellInfo->Id, 0, unit);
1058 {
1059 // Recheck UNIT_FLAG_NON_ATTACKABLE for delayed spells
1063 {
1066 }
1069 {
1070 // for delayed spells ignore not visible explicit target
1073 {
1076 }
1078 // not break stealth by cast targeting
1082 // can cause back attack (if detected), stealth removed at Spell::cast if spell break it
1083 if (!(m_spellInfo->AttributesEx & SPELL_ATTR_EX_NO_INITIAL_AGGRO) && !IsPositiveSpell(m_spellInfo->Id) &&
1085 {
1086 // use speedup check to avoid re-remove after above lines
1090 // caster can be detected but have stealth aura
1105 }
1106 }
1107 else
1108 {
1109 // for delayed spells ignore negative spells (after duel end) for friendly targets
1111 {
1114 }
1116 // assisting case, healing and resurrection
1121 {
1124 }
1125 }
1126 }
1128 // Get Data Needed for Diminishing Returns, some effects may have multiple auras, so this must be done on spell hit, not aura add
1131 // Increase Diminishing on unit, current informations for actually casts will use values above
1132 if ((GetDiminishingReturnsGroupType(m_diminishGroup) == DRTYPE_PLAYER && unit->GetTypeId() == TYPEID_PLAYER) ||
1136 // Apply additional spell effects to target
1140 {
1142 {
1143 HandleEffects(unit, NULL, NULL, SpellEffectIndex(effectNumber), m_damageMultipliers[effectNumber]);
1145 {
1146 // Get multiplier
1148 // Apply multiplier mods
1153 }
1154 }
1155 }
1156 }
1159 {
1176 // cast at creature (or GO) quest objectives update at successful cast finished (+channel finished)
1177 // ignore autorepeat/melee casts for speed (not exist quest for spells (hm... )
1179 {
1182 }
1183 }
1186 {
1194 }
1197 {
1198 // Not need check return true
1204 for(std::list<TargetInfo>::const_iterator ihit= m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
1205 {
1207 {
1208 Unit *unit = m_caster->GetObjectGuid() == ihit->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID);
1210 // either unit is alive and normal spell, or unit dead and deathonly-spell
1212 needAliveTargetMask &= ~ihit->effectMask; // remove from need alive mask effect that have alive target
1213 }
1214 }
1216 // is all effects from m_needAliveTargetMask have alive targets
1218 }
1220 // Helper for Chain Healing
1221 // Spell target first
1222 // Raidmates then descending by injury suffered (MaxHealth - Health)
1223 // Other players/mobs then descending by injury suffered (MaxHealth - Health)
1225 {
1228 // functor for operator ">"
1230 {
1232 }
1234 {
1239 {
1242 else
1244 }
1245 else
1247 }
1248 };
1251 {
1257 {
1259 }
1260 };
1262 // Helper for targets nearest to the spell target
1263 // The spell target is always first unless there is a target at _completely_ the same position (unbelievable case)
1265 {
1268 // functor for operator ">"
1270 {
1272 }
1273 };
1275 void Spell::SetTargetMap(SpellEffectIndex effIndex, uint32 targetMode, UnitList& targetUnitMap)
1276 {
1279 radius = GetSpellRadius(sSpellRadiusStore.LookupEntry(m_spellInfo->EffectRadiusIndex[effIndex]));
1280 else
1286 {
1288 {
1291 }
1292 }
1294 // Get spell max affected targets
1297 // custom target amount cases
1299 {
1301 {
1303 {
1333 }
1335 }
1338 {
1339 // overwrite EffectChainTarget for non single target spell
1346 }
1349 {
1353 }
1356 }
1360 {
1364 }
1367 {
1369 radius *= sqrtf(rand_norm_f()); // Get a random point in circle. Use sqrt(rand) to correct distribution when converting polar to Cartesian coordinates.
1370 // no 'break' expected since we use code in case TARGET_RANDOM_CIRCUMFERENCE_POINT!!!
1372 {
1380 }
1382 {
1383 radius *= sqrtf(rand_norm_f()); // Get a random point in circle. Use sqrt(rand) to correct distribution when converting polar to Cartesian coordinates.
1392 {
1393 // caster included here?
1394 FillAreaTargets(targetUnitMap, dest_x, dest_y, radius, PUSH_DEST_CENTER, SPELL_TARGETS_AOE_DAMAGE);
1395 }
1396 else
1400 }
1412 {
1424 {
1426 MaNGOS::UnitListSearcher<MaNGOS::AnyAoETargetUnitInObjectRangeCheck> searcher(m_caster, tempTargetUnitMap, u_check);
1428 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyAoETargetUnitInObjectRangeCheck>, WorldTypeMapContainer > world_unit_searcher(searcher);
1429 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyAoETargetUnitInObjectRangeCheck>, GridTypeMapContainer > grid_unit_searcher(searcher);
1433 }
1440 //Now to get us a random target that's in the initial range of the spell
1463 {
1468 {
1471 }
1480 }
1482 }
1484 {
1493 {
1495 MaNGOS::UnitListSearcher<MaNGOS::AnyFriendlyUnitInObjectRangeCheck> searcher(m_caster, tempTargetUnitMap, u_check);
1497 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyFriendlyUnitInObjectRangeCheck>, WorldTypeMapContainer > world_unit_searcher(searcher);
1498 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyFriendlyUnitInObjectRangeCheck>, GridTypeMapContainer > grid_unit_searcher(searcher);
1502 }
1509 //Now to get us a random target that's in the initial range of the spell
1532 {
1537 {
1540 }
1547 }
1549 }
1551 {
1556 }
1558 {
1560 {
1562 {
1565 }
1566 }
1567 else
1568 {
1579 else
1580 //FIXME: This very like horrible hack and wrong for most spells
1589 {
1590 MaNGOS::AnyAoEVisibleTargetUnitInObjectRangeCheck u_check(pUnitTarget, originalCaster, max_range);
1591 MaNGOS::UnitListSearcher<MaNGOS::AnyAoEVisibleTargetUnitInObjectRangeCheck> searcher(m_caster, tempTargetUnitMap, u_check);
1592 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyAoEVisibleTargetUnitInObjectRangeCheck>, WorldTypeMapContainer> world_unit_searcher(searcher);
1593 TypeContainerVisitor<MaNGOS::UnitListSearcher<MaNGOS::AnyAoEVisibleTargetUnitInObjectRangeCheck>, GridTypeMapContainer> grid_unit_searcher(searcher);
1597 }
1612 {
1616 {
1619 }
1626 }
1627 }
1629 }
1631 FillAreaTargets(targetUnitMap, m_targets.m_destX, m_targets.m_destY, radius, PUSH_DEST_CENTER, SPELL_TARGETS_AOE_DAMAGE);
1634 {
1636 // Select friendly targets for positive effect
1640 FillAreaTargets(targetUnitMap, m_caster->GetPositionX(), m_caster->GetPositionY(), radius, PUSH_DEST_CENTER, targetB);
1642 // exclude caster
1645 }
1647 {
1648 // targets the ground, not the units in the area
1650 {
1657 FillAreaTargets(targetUnitMap, m_targets.m_destX, m_targets.m_destY, radius, PUSH_DEST_CENTER, SPELL_TARGETS_AOE_DAMAGE);
1659 }
1661 }
1663 {
1665 {
1666 m_targets.setDestination(currentTarget->GetPositionX(), currentTarget->GetPositionY(), currentTarget->GetPositionZ());
1668 }
1670 }
1677 {
1679 FillRaidOrPartyManaPriorityTargets(targetUnitMap, m_caster, m_caster, radius, 10, true, false, true);
1681 FillRaidOrPartyHealthPriorityTargets(targetUnitMap, m_caster, m_caster, radius, 1, true, false, true);
1682 else
1685 }
1693 if( target->GetTypeId() == TYPEID_UNIT && ((Creature*)target)->isPet() && ((Pet*)target)->getPetType() == MINI_PET)
1697 {
1698 // Check original caster is GO - set its coordinates as dst cast
1700 m_targets.setDestination(caster->GetPositionX(), caster->GetPositionY(), caster->GetPositionZ());
1702 }
1704 FillAreaTargets(targetUnitMap, m_targets.m_destX, m_targets.m_destY, radius, PUSH_SELF_CENTER, SPELL_TARGETS_HOSTILE);
1708 {
1710 FillAreaTargets(targetUnitMap, m_targets.m_destX, m_targets.m_destY, radius, PUSH_SELF_CENTER, SPELL_TARGETS_FRIENDLY);
1714 // target amount stored in parent spell dummy effect but hard to access
1715 FillRaidOrPartyHealthPriorityTargets(targetUnitMap, m_caster, m_caster, radius, 3, true, false, false);
1718 // target amount stored in parent spell dummy effect but hard to access
1719 FillRaidOrPartyManaPriorityTargets(targetUnitMap, m_caster, m_caster, radius, 3, true, false, false);
1722 FillAreaTargets(targetUnitMap, m_targets.m_destX, m_targets.m_destY, radius, PUSH_SELF_CENTER, SPELL_TARGETS_FRIENDLY);
1724 }
1727 // Death Pact (in fact selection by player selection)
1729 {
1730 // checked in Spell::CheckCast
1734 }
1735 // Circle of Healing
1736 else if (m_spellInfo->SpellFamilyName == SPELLFAMILY_PRIEST && m_spellInfo->SpellVisual[0] == 8253)
1737 {
1743 // Glyph of Circle of Healing
1747 FillRaidOrPartyHealthPriorityTargets(targetUnitMap, m_caster, target, radius, count, true, false, true);
1748 }
1749 // Wild Growth
1750 else if (m_spellInfo->SpellFamilyName == SPELLFAMILY_DRUID && m_spellInfo->SpellIconID == 2864)
1751 {
1755 uint32 count = CalculateDamage(EFFECT_INDEX_2,m_caster); // stored in dummy effect, affected by mods
1757 FillRaidOrPartyHealthPriorityTargets(targetUnitMap, m_caster, target, radius, count, true, false, true);
1758 }
1759 else
1760 FillAreaTargets(targetUnitMap, m_targets.m_destX, m_targets.m_destY, radius, PUSH_DEST_CENTER, SPELL_TARGETS_FRIENDLY);
1762 // 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..)
1764 {
1766 // Those spells apparently can't be casted on the caster.
1768 {
1769 // Can only be casted on group's members or its pets
1775 {
1777 {
1779 {
1782 }
1784 }
1785 }
1787 {
1788 if( targetOwner == m_caster && target->GetTypeId() == TYPEID_UNIT && ((Creature*)target)->isPet())
1789 {
1792 }
1794 }
1797 {
1798 // Our target can also be a player's pet who's grouped with us or our pet. But can't be controlled player
1800 {
1805 {
1807 }
1808 }
1809 // 1Our target can be a player who is on our group
1810 else if (target->GetTypeId() == TYPEID_PLAYER && pGroup->IsMember(((Player*)target)->GetGUID()))
1811 {
1813 }
1814 }
1815 }
1817 }
1823 {
1825 FillAreaTargets(targetUnitMap, m_caster->GetPositionX(), m_caster->GetPositionY(), radius, inFront ? PUSH_IN_FRONT : PUSH_IN_BACK, SPELL_TARGETS_AOE_DAMAGE);
1827 }
1829 FillAreaTargets(targetUnitMap, m_caster->GetPositionX(), m_caster->GetPositionY(), radius, PUSH_IN_FRONT_90, SPELL_TARGETS_AOE_DAMAGE);
1832 FillAreaTargets(targetUnitMap, m_caster->GetPositionX(), m_caster->GetPositionY(), radius, PUSH_IN_FRONT_15, SPELL_TARGETS_AOE_DAMAGE);
1835 FillAreaTargets(targetUnitMap, m_caster->GetPositionX(), m_caster->GetPositionY(), radius, PUSH_IN_FRONT_30, SPELL_TARGETS_AOE_DAMAGE);
1838 {
1841 {
1843 {
1845 }
1846 else
1847 {
1849 {
1852 }
1853 }
1854 }
1856 }
1868 // targets the ground, not the units in the area
1870 FillAreaTargets(targetUnitMap, m_targets.m_destX, m_targets.m_destY, radius, PUSH_DEST_CENTER, SPELL_TARGETS_AOE_DAMAGE);
1877 {
1879 {
1882 }
1884 }
1886 {
1891 {
1895 }
1897 {
1899 {
1901 {
1903 {
1907 }
1908 }
1909 else
1911 }
1912 }
1917 {
1921 {
1924 // IsHostileTo check duel and controlled by enemy
1926 {
1933 }
1934 }
1935 }
1937 {
1940 }
1942 {
1948 }
1950 }
1952 {
1958 }
1963 {
1970 else
1971 {
1975 UnitList tempTargetUnitMap;
1977 FillAreaTargets(tempTargetUnitMap, m_caster->GetPositionX(), m_caster->GetPositionY(), max_range, PUSH_SELF_CENTER, SPELL_TARGETS_FRIENDLY);
1979 if (m_caster != pUnitTarget && std::find(tempTargetUnitMap.begin(), tempTargetUnitMap.end(), m_caster) == tempTargetUnitMap.end())
1996 {
2001 {
2004 }
2007 {
2010 }
2019 }
2020 }
2022 }
2024 {
2027 {
2029 m_targets.setDestination(currentTarget->GetPositionX(), currentTarget->GetPositionY(), currentTarget->GetPositionZ());
2031 FillAreaTargets(targetUnitMap, currentTarget->GetPositionX(), currentTarget->GetPositionY(), radius, PUSH_TARGET_CENTER, SPELL_TARGETS_AOE_DAMAGE);
2032 }
2034 }
2036 {
2037 Player* targetPlayer = m_targets.getUnitTarget() && m_targets.getUnitTarget()->GetTypeId() == TYPEID_PLAYER
2042 {
2044 {
2047 // IsHostileTo check duel and controlled by enemy
2051 {
2053 }
2054 }
2055 }
2059 }
2061 {
2064 {
2065 // teleport spells are handled in another way
2070 else
2071 sLog.outError( "SPELL: wrong map (%u instead %u) target coordinates for spell ID %u", st->target_mapId, m_caster->GetMapId(), m_spellInfo->Id );
2072 }
2073 else
2076 }
2081 {
2084 // explicit cast data from client or server-side cast
2085 // some spell at client send caster
2094 {
2099 {
2104 }
2107 pTarget->GetClosePoint(_target_x, _target_y, _target_z, pTarget->GetObjectSize(), dist, angle);
2109 {
2112 }
2113 }
2115 }
2117 // if parent spell create dynamic object extract area from it
2118 if(DynamicObject* dynObj = m_caster->GetDynObject(m_triggeredByAuraSpell ? m_triggeredByAuraSpell->Id : m_spellInfo->Id))
2119 m_targets.setDestination(dynObj->GetPositionX(), dynObj->GetPositionY(), dynObj->GetPositionZ());
2126 {
2128 {
2131 {
2136 }
2141 }
2145 }
2154 {
2157 {
2159 float angle = currentTarget != m_caster ? currentTarget->GetAngle(m_caster) : m_caster->GetOrientation();
2162 {
2171 }
2176 }
2178 }
2180 {
2182 {
2191 }
2195 }
2197 {
2198 // add here custom effects that need default target.
2199 // FOR EVERY TARGET TYPE THERE IS A DIFFERENT FILL!!
2201 {
2203 {
2205 {
2207 {
2211 {
2213 {
2223 }
2224 }
2225 else
2226 {
2227 // clear cooldown at fail
2232 }
2234 }
2239 }
2241 }
2258 // Triggered spells have additional spell targets - cast them even if no explicit unit target is given (required for spell 50516 for example)
2264 {
2268 }
2274 {
2277 {
2281 }
2282 }
2311 {
2312 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)
2320 }
2323 // AreaAura
2331 {
2335 }
2340 }
2342 }
2344 //sLog.outError( "SPELL: Unknown implicit target (%u) for spell ID %u", targetMode, m_spellInfo->Id );
2346 }
2349 {
2350 // make sure one unit is always removed per iteration
2352 for (UnitList::iterator itr = targetUnitMap.begin(), next; itr != targetUnitMap.end(); itr = next)
2353 {
2358 {
2361 // break;
2362 }
2363 }
2364 // remove random units from the map
2366 {
2369 {
2373 {
2376 }
2377 }
2378 }
2379 // the player's target will always be added to the map
2382 }
2383 }
2386 {
2399 // create and add update event for this spell
2403 //Prevent casting at cast another spell (ServerSide check)
2405 {
2409 }
2411 // Fill cost data
2416 {
2418 {
2421 }
2425 }
2427 // Prepare data for triggers
2430 // calculate cast time (calculated after first CheckCast check to prevent charge counting for first CheckCast fail)
2433 // set timer base at cast time
2436 // stealth must be removed at cast starting (at show channel bar)
2437 // skip triggered spell (item equip spell casting and other not explicit character casts/item uses)
2439 {
2442 }
2444 // add non-triggered (with cast time and without)
2446 {
2447 // add to cast type slot
2450 // will show cast bar
2452 }
2453 // execute triggered without cast time explicitly in call point
2456 // else triggered with cast time will execute execute at next tick or later
2457 // without adding to cast type slot
2458 // will not show cast bar but will show effects at casting time etc
2459 }
2462 {
2468 {
2471 {
2477 {
2478 for(std::list<TargetInfo>::const_iterator ihit= m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
2479 {
2481 {
2482 Unit* unit = m_caster->GetObjectGuid() == (*ihit).targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID);
2485 }
2486 }
2494 {
2496 }
2501 }
2504 {
2508 {
2510 sLog.outError("Spell %u triggered by aura spell %u too deep in cast chain for cast. Cast not allowed for prevent overflow stack crash.", m_spellInfo->Id, m_triggeredByAuraSpell->Id);
2511 else
2512 sLog.outError("Spell %u too deep in cast chain for cast. Cast not allowed for prevent overflow stack crash.", m_spellInfo->Id);
2518 }
2520 // update pointers base at GUIDs to prevent access to non-existed already object
2523 // cancel at lost main target unit
2524 if(!m_targets.getUnitTarget() && m_targets.getUnitTargetGUID() && m_targets.getUnitTargetGUID() != m_caster->GetGUID())
2525 {
2530 }
2532 if(m_caster->GetTypeId() != TYPEID_PLAYER && m_targets.getUnitTarget() && m_targets.getUnitTarget() != m_caster)
2537 {
2543 }
2545 // triggered cast called from Spell::prepare where it was already checked
2547 {
2550 {
2556 }
2557 }
2559 // different triggred (for caster) and precast (casted before apply effect to target) cases
2561 {
2563 {
2567 // Blood Fury (Racial)
2572 }
2574 {
2575 // Ice Block
2579 }
2581 {
2582 // Power Word: Shield
2586 // Prayer of Mending (jump animation), we need formal caster instead original for correct animation
2591 {
2602 }
2604 }
2606 {
2607 // Faerie Fire (Feral)
2611 }
2613 // Fan of Knives (main hand)
2616 {
2618 }
2621 {
2622 // Hand of Reckoning
2624 {
2627 }
2628 // Divine Shield, Divine Protection or Hand of Protection
2630 {
2633 }
2637 }
2639 {
2640 // Bloodlust
2643 // Heroism
2646 else if (m_spellInfo->Effect[EFFECT_INDEX_0]==SPELL_EFFECT_APPLY_AREA_AURA_RAID && m_spellInfo->SpellFamilyFlags & UI64LIT(0x0000000004000000))
2647 // only for main totem spell cast
2650 }
2653 }
2655 // traded items have trade slot instead of guid in m_itemTargetGUID
2656 // set to real guid to be sent later to the client
2660 {
2662 ((Player*)m_caster)->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM, m_CastItem->GetEntry());
2664 ((Player*)m_caster)->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL, m_spellInfo->Id);
2665 }
2669 if(m_spellState == SPELL_STATE_FINISHED) // stop cast if spell marked as finish somewhere in FillTargetMap
2670 {
2674 }
2676 // CAST SPELL
2680 TakeReagents(); // we must remove reagents before HandleEffects to allow place crafted item in same slot
2683 SendSpellGo(); // we must send smsg_spell_go packet before m_castItem delete in TakeCastItem()...
2685 // Okay, everything is prepared. Now we need to distinguish between immediate and evented delayed spells
2687 {
2689 // Remove used for cast item if need (it can be already NULL after TakeReagents call
2690 // in case delayed spell remove item at cast delay start
2693 // Okay, maps created, now prepare flags
2697 }
2698 else
2699 {
2700 // Immediate spell, no big deal
2702 }
2706 }
2709 {
2710 // start channeling if applicable
2712 {
2715 {
2716 // Apply duration mod
2721 }
2722 }
2724 // process immediate effects (items, ground, etc.) also initialize some variables
2727 for(std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
2730 for(std::list<GOTargetInfo>::iterator ihit = m_UniqueGOTargetInfo.begin(); ihit != m_UniqueGOTargetInfo.end(); ++ihit)
2733 // spell is finished, perform some last features of the spell here
2736 // Remove used for cast item if need (it can be already NULL after TakeReagents call
2741 }
2744 {
2748 {
2751 }
2753 // 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)
2754 for(std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
2755 {
2757 {
2762 }
2763 }
2765 // now recheck gameobject targeting correctness
2766 for(std::list<GOTargetInfo>::iterator ighit = m_UniqueGOTargetInfo.begin(); ighit != m_UniqueGOTargetInfo.end(); ++ighit)
2767 {
2769 {
2774 }
2775 }
2776 // All targets passed - need finish phase
2778 {
2779 // spell is finished, perform some last features of the spell here
2784 // return zero, spell is finished now
2786 }
2787 else
2788 {
2789 // spell is unfinished, return next execution time
2791 }
2792 }
2795 {
2796 // handle some immediate features of the spell here
2801 {
2805 // apply Send Event effect to ground in case empty target lists
2806 if( m_spellInfo->Effect[j] == SPELL_EFFECT_SEND_EVENT && !HaveTargetsForEffect(SpellEffectIndex(j)) )
2807 {
2810 }
2812 // Don't do spell log, if is school damage spell
2821 // initialize multipliers
2823 if( (m_spellInfo->EffectImplicitTargetA[j] == TARGET_CHAIN_DAMAGE || m_spellInfo->EffectImplicitTargetA[j] == TARGET_CHAIN_HEAL) &&
2826 }
2828 // initialize Diminishing Returns Data
2832 // process items
2833 for(std::list<ItemTargetInfo>::iterator ihit = m_UniqueItemInfo.begin(); ihit != m_UniqueItemInfo.end(); ++ihit)
2836 // process ground
2838 {
2839 // persistent area auras target only the ground
2842 }
2843 }
2846 {
2847 // spell log
2850 }
2853 {
2859 // mana/health/etc potions, disabled by client (until combat out as declarate)
2861 {
2862 // need in some way provided data for Spell::finish SendCooldownEvent
2865 }
2867 // (1) have infinity cooldown but set at aura apply, (2) passive cooldown at triggering
2871 _player->AddSpellAndCategoryCooldowns(m_spellInfo, m_CastItem ? m_CastItem->GetEntry() : 0, this);
2872 }
2875 {
2876 // update pointers based at it's GUIDs
2880 {
2883 }
2885 // check if the player caster has moved before the spell finished
2887 (m_castPositionX != m_caster->GetPositionX() || m_castPositionY != m_caster->GetPositionY() || m_castPositionZ != m_caster->GetPositionZ()) &&
2888 (m_spellInfo->Effect[EFFECT_INDEX_0] != SPELL_EFFECT_STUCK || !((Player*)m_caster)->m_movementInfo.HasMovementFlag(MOVEFLAG_FALLINGFAR)))
2889 {
2890 // always cancel for channeled spells
2893 // don't cancel for melee, autorepeat, triggered and instant spells
2894 else if(!IsNextMeleeSwingSpell() && !IsAutoRepeat() && !m_IsTriggeredSpell && (m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_MOVEMENT))
2896 }
2899 {
2901 {
2903 {
2906 else
2908 }
2914 {
2916 {
2918 {
2919 // check if player has jumped before the channeling finished
2923 // check for incapacitating player states
2927 // check if player has turned if flag is set
2928 if( m_spellInfo->ChannelInterruptFlags & CHANNEL_FLAG_TURNING && m_castOrientation != m_caster->GetOrientation() )
2930 }
2932 // check if there are alive targets left
2934 {
2937 }
2941 else
2943 }
2946 {
2949 // channeled spell processed independently for quest targeting
2950 // cast at creature (or GO) quest objectives update at successful cast channel finished
2951 // ignore autorepeat/melee casts for speed (not exist quest for spells (hm... )
2953 {
2955 {
2956 for(std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
2957 {
2962 Unit* unit = m_caster->GetObjectGuid() == target->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, target->targetGUID);
2967 }
2969 for(std::list<GOTargetInfo>::iterator ihit = m_UniqueGOTargetInfo.begin(); ihit != m_UniqueGOTargetInfo.end(); ++ihit)
2970 {
2978 }
2979 }
2980 }
2983 }
2986 {
2988 }
2989 }
2992 {
3001 // other code related only to successfully finished spells
3005 // remove spell mods
3009 // handle SPELL_AURA_ADD_TARGET_TRIGGER auras
3010 Unit::AuraList const& targetTriggers = m_caster->GetAurasByType(SPELL_AURA_ADD_TARGET_TRIGGER);
3012 {
3015 for(std::list<TargetInfo>::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
3016 {
3018 {
3019 // check m_caster->GetGUID() let load auras at login and speedup most often case
3020 Unit *unit = m_caster->GetObjectGuid() == ihit->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID);
3022 {
3025 // Calculate chance at that moment (can be depend for example from combo points)
3026 int32 chance = m_caster->CalculateSpellDamage(auraSpellInfo, auraSpellIdx, (*i)->GetBasePoints(),unit);
3029 }
3030 }
3031 }
3032 }
3034 // Heal caster for all health leech from all targets
3039 {
3043 }
3045 /*if (IsRangedAttackResetSpell())
3046 m_caster->resetAttackTimer(RANGED_ATTACK);*/
3048 // Clear combo at finish state
3050 {
3051 // Not drop combopoints if negative spell and if any miss on enemy exist
3054 {
3055 for(std::list<TargetInfo>::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
3056 {
3058 {
3061 }
3062 }
3063 }
3066 }
3068 // potions disabled by client, send event "not in combat" if need
3072 // call triggered spell only at successful cast (after clear combo points -> for add some if need)
3076 // Stop Attack for some spells
3079 }
3082 {
3089 if(((Player*)m_caster)->GetSession()->PlayerLoading()) // don't send cast results at loading time
3093 }
3095 void Spell::SendCastResult(Player* caster, SpellEntry const* spellInfo, uint8 cast_count, SpellCastResult result)
3096 {
3105 {
3110 // hardcode areas limitation case
3112 {
3127 }
3144 //data << uint32(spellInfo->EquippedItemInventoryTypeMask);
3148 }
3150 }
3153 {
3169 else
3183 {
3189 {
3194 }
3195 }
3201 {
3204 }
3207 }
3210 {
3211 // not send invisible spell casting
3221 if((m_caster->GetTypeId() == TYPEID_PLAYER) && (m_caster->getClass() == CLASS_DEATH_KNIGHT) && m_spellInfo->runeCostID)
3222 {
3226 }
3232 else
3249 {
3251 uint8 v2 = m_caster->getClass() == CLASS_DEATH_KNIGHT ? ((Player*)m_caster)->GetRunesState() : 0;
3255 {
3260 }
3261 }
3264 {
3267 }
3273 {
3276 }
3279 {
3281 }
3284 }
3287 {
3292 {
3295 {
3299 else
3300 {
3303 {
3306 {
3309 }
3310 }
3312 {
3315 }
3316 }
3317 }
3318 }
3319 else
3320 {
3322 {
3324 {
3326 {
3328 {
3330 {
3344 }
3348 }
3349 }
3350 }
3351 }
3352 }
3356 }
3359 {
3360 // This function also fill data for channeled spells:
3361 // m_needAliveTargetMask req for stop channeling if one target die
3364 for(std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
3365 {
3367 {
3368 // possibly SPELL_MISS_IMMUNE2 for this??
3371 }
3374 else
3376 }
3379 for(std::list<TargetInfo>::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
3380 {
3382 {
3385 }
3386 }
3388 for(std::list<GOTargetInfo>::const_iterator ighit = m_UniqueGOTargetInfo.begin(); ighit != m_UniqueGOTargetInfo.end(); ++ighit)
3392 for(std::list<TargetInfo>::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
3393 {
3395 {
3400 }
3401 }
3402 // Reset m_needAliveTargetMask for non channeled spell
3405 }
3408 {
3415 else
3422 {
3427 {
3429 {
3433 else
3442 else
3449 else
3456 else
3464 else
3487 else
3496 else
3503 else
3508 }
3509 }
3510 }
3513 }
3516 {
3530 }
3533 {
3535 {
3545 }
3551 }
3554 {
3557 // select first not resisted target from target list for _0_ effect
3559 {
3560 for(std::list<TargetInfo>::const_iterator itr = m_UniqueTargetInfo.begin(); itr != m_UniqueTargetInfo.end(); ++itr)
3561 {
3562 if( (itr->effectMask & (1 << 0)) && itr->reflectResult == SPELL_MISS_NONE && itr->targetGUID != m_caster->GetObjectGuid())
3563 {
3566 }
3567 }
3568 }
3570 {
3571 for(std::list<GOTargetInfo>::const_iterator itr = m_UniqueGOTargetInfo.begin(); itr != m_UniqueGOTargetInfo.end(); ++itr)
3572 {
3574 {
3577 }
3578 }
3579 }
3593 }
3596 {
3597 // Both players and NPCs can resurrect using spells - have a look at creature 28487 for example
3598 // However, the packet structure differs slightly
3600 const char* sentName = m_caster->GetTypeId() == TYPEID_PLAYER ? "" : m_caster->GetNameForLocaleIdx(target->GetSession()->GetSessionDbLocaleIndex());
3611 }
3614 {
3622 }
3625 {
3629 // not remove cast item at triggered spell (equipping, weapon damage, etc)
3636 {
3637 // This code is to avoid a crash
3638 // I'm not sure, if this is really an error, but I guess every item needs a prototype
3639 sLog.outError("Cast item (%s) has no item prototype", m_CastItem->GetObjectGuid().GetString().c_str());
3641 }
3647 {
3649 {
3650 // item has limited charges
3652 {
3658 // item has charges left
3660 {
3665 }
3667 // all charges used
3669 }
3670 }
3671 }
3674 {
3678 // prevent crash at access to deleted m_targets.getItemTarget
3683 }
3684 }
3687 {
3691 // health as power used
3693 {
3696 }
3699 {
3702 }
3707 {
3710 }
3714 // Set the five second timer
3717 }
3720 {
3740 // at this moment for rune cost exist only no cost mods, and no percent mods
3746 {
3749 // init cost data and apply mods
3755 // scan non-death runes (death rune not used explicitly in rune costs)
3757 {
3762 // already used
3770 }
3772 // collect all not counted rune costs to death runes cost
3777 // scan death runes
3779 {
3781 {
3786 // already used
3797 }
3798 }
3802 }
3805 {
3806 // you can gain some runic power when use runes
3810 }
3813 }
3816 {
3820 if (IgnoreItemRequirements()) // reagents used in triggered spell removed by original spell or don't must be removed.
3828 {
3835 // if CastItem is also spell reagent
3837 {
3840 {
3842 {
3843 // CastItem will be used up and does not count as reagent
3846 {
3849 }
3850 }
3853 }
3854 }
3856 // if getItemTarget is also spell reagent
3861 }
3862 }
3865 {
3877 m_targets.getUnitTarget()->AddThreat(m_caster, float(threat), false, GetSpellSchoolMask(m_spellInfo), m_spellInfo);
3879 DEBUG_LOG("Spell %u, rank %u, added an additional %i threat", spellId, sSpellMgr.GetSpellRank(spellId), threat);
3880 }
3882 void Spell::HandleEffects(Unit *pUnitTarget,Item *pItemTarget,GameObject *pGOTarget,SpellEffectIndex i, float DamageMultiplier)
3883 {
3895 {
3896 //sLog.outDebug( "WORLD: Spell FX %d < TOTAL_SPELL_EFFECTS ", eff);
3898 }
3899 /*
3900 else
3901 {
3902 sLog.outDebug( "WORLD: Spell FX %d > TOTAL_SPELL_EFFECTS ", eff);
3903 if (m_CastItem)
3904 EffectEnchantItemTmp(i);
3905 else
3906 {
3907 sLog.outError("SPELL: unknown effect %u spell id %u",
3908 eff, m_spellInfo->Id);
3909 }
3910 }
3911 */
3912 }
3916 {
3920 {
3921 sLog.outError("Spell::AddTriggeredSpell: unknown spell id %u used as triggred spell for spell %u)", spellId, m_spellInfo->Id);
3923 }
3926 }
3929 {
3933 {
3934 sLog.outError("Spell::AddPrecastSpell: unknown spell id %u used as pre-cast spell for spell %u)", spellId, m_spellInfo->Id);
3936 }
3939 }
3942 {
3943 for(SpellInfoList::const_iterator si = m_TriggerSpells.begin(); si != m_TriggerSpells.end(); ++si)
3944 {
3947 }
3948 }
3951 {
3952 for(SpellInfoList::const_iterator si = m_preCastSpells.begin(); si != m_preCastSpells.end(); ++si)
3954 }
3957 {
3958 // check cooldowns to prevent cheating (ignore passive spells, that client side visual only)
3961 {
3964 else
3966 }
3968 // only allow triggered spells if at an ended battleground
3974 // only check at first call, Stealth auras are already removed at second call
3975 // for now, ignore triggered spells
3977 {
3979 // Ignore form req aura
3982 {
3987 }
3989 {
3990 // Cannot be used in this stance/form
3997 }
3998 }
4000 // caster state requirements
4001 if(m_spellInfo->CasterAuraState && !m_caster->HasAuraState(AuraState(m_spellInfo->CasterAuraState)))
4003 if(m_spellInfo->CasterAuraStateNot && m_caster->HasAuraState(AuraState(m_spellInfo->CasterAuraStateNot)))
4006 // Caster aura req check if need
4010 {
4011 // Special cases of non existing auras handling
4013 {
4014 // Avenging Wrath Marker
4017 }
4020 }
4022 // cancel autorepeat spells if cast start when moving
4023 // (not wand currently autorepeat cast delayed to moving stop anyway in spell update code)
4025 {
4026 // skip stuck spell to allow use it in falling case and apply spell limitations at movement
4027 if( (!((Player*)m_caster)->m_movementInfo.HasMovementFlag(MOVEFLAG_FALLINGFAR) || m_spellInfo->Effect[EFFECT_INDEX_0] != SPELL_EFFECT_STUCK) &&
4030 }
4033 {
4034 // target state requirements (not allowed state), apply to self also
4035 if(m_spellInfo->TargetAuraStateNot && target->HasAuraState(AuraState(m_spellInfo->TargetAuraStateNot)))
4041 // Target aura req check if need
4045 {
4046 // Special cases of non existing auras handling
4048 {
4049 // Avenging Wrath Marker
4053 }
4056 }
4058 bool non_caster_target = target != m_caster && !IsSpellWithCasterSourceTargetsOnly(m_spellInfo);
4061 {
4062 // target state requirements (apply to non-self only), to allow cast affects to self like Dirty Deeds
4063 if(m_spellInfo->TargetAuraState && !target->HasAuraStateForCaster(AuraState(m_spellInfo->TargetAuraState),m_caster->GetGUID()))
4066 // Not allow casting on flying player
4070 if(!m_IsTriggeredSpell && VMAP::VMapFactory::checkSpellForLoS(m_spellInfo->Id) && !m_caster->IsWithinLOSInMap(target))
4073 // auto selection spell rank implemented in WorldSession::HandleCastSpellOpcode
4074 // this case can be triggered if rank not found (too low-level target for first rank)
4076 {
4078 {
4079 // check only spell that apply positive auras
4082 // at not self target
4084 // and target low level
4086 {
4088 }
4089 }
4090 }
4091 }
4093 {
4096 {
4097 // Additional check for some spells
4098 // If 0 spell effect empty - client not send target data (need use selection)
4099 // TODO: check it on next client version
4102 {
4105 else
4107 }
4108 }
4110 // Some special spells with non-caster only mode
4112 // Fire Shield
4117 // Focus Magic (main spell)
4120 }
4122 // check pet presents
4124 {
4126 {
4129 {
4132 else
4134 }
4136 }
4137 }
4139 //check creature type
4140 //ignore self casts (including area casts when caster selected as target)
4142 {
4144 {
4147 else
4149 }
4150 }
4153 {
4154 // simple cases
4161 {
4163 {
4165 {
4168 }
4174 }
4176 {
4178 {
4181 }
4187 }
4188 }
4189 // TODO: this check can be applied and for player to prevent cheating when IsPositiveSpell will return always correct result.
4190 // check target for pet/charmed casts (not self targeted), self targeted cast used for area effects and etc
4191 if (!explicit_target_mode && m_caster->GetTypeId() == TYPEID_UNIT && m_caster->GetCharmerOrOwnerGUID())
4192 {
4193 // check correctness positive/negative cast target (pet cast real check and cheating check)
4195 {
4197 {
4200 }
4204 }
4205 else
4206 {
4208 {
4211 }
4215 }
4216 }
4217 }
4223 //Must be behind the target.
4224 if( m_spellInfo->AttributesEx2 == 0x100000 && (m_spellInfo->AttributesEx & 0x200) == 0x200 && target->HasInArc(M_PI_F, m_caster) )
4225 {
4226 // Exclusion for Pounce: Facing Limitation was removed in 2.0.1, but it still uses the same, old Ex-Flags
4227 // Exclusion for Mutilate:Facing Limitation was removed in 2.0.1 and 3.0.3, but they still use the same, old Ex-Flags
4228 // Exclusion for Throw: Facing limitation was added in 3.2.x, but that shouldn't be
4229 if ((m_spellInfo->SpellFamilyName != SPELLFAMILY_DRUID || (m_spellInfo->SpellFamilyFlags != UI64LIT(0x0000000000020000))) &&
4230 (m_spellInfo->SpellFamilyName != SPELLFAMILY_ROGUE || (m_spellInfo->SpellFamilyFlags != UI64LIT(0x0020000000000000))) &&
4232 {
4235 }
4236 }
4238 //Target must be facing you.
4240 {
4243 }
4245 // check if target is in combat
4246 if (non_caster_target && (m_spellInfo->AttributesEx & SPELL_ATTR_EX_NOT_IN_COMBAT_TARGET) && target->isInCombat())
4248 }
4249 // zone check
4253 SpellCastResult locRes= sSpellMgr.GetSpellAllowedInLocationError(m_spellInfo, m_caster->GetMapId(), zone, area,
4258 // not let players cast spells at mount (and let do it to creatures)
4260 !IsPassiveSpell(m_spellInfo->Id) && !(m_spellInfo->Attributes & SPELL_ATTR_CASTABLE_WHILE_MOUNTED))
4261 {
4264 else
4266 }
4268 // always (except passive spells) check items (focus object can be required for any type casts)
4270 {
4274 }
4276 // Database based targets from spell_target_script
4277 if (m_UniqueTargetInfo.empty()) // skip second CheckCast apply (for delayed spells for example)
4278 {
4280 {
4282 (m_spellInfo->EffectImplicitTargetB[j] == TARGET_SCRIPT && m_spellInfo->EffectImplicitTargetA[j] != TARGET_SELF) ||
4286 {
4291 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);
4299 for(SpellScriptTarget::const_iterator i_spellST = bounds.first; i_spellST != bounds.second; ++i_spellST)
4300 {
4302 {
4304 {
4308 {
4313 MaNGOS::NearestGameObjectEntryInObjectRangeCheck go_check(*m_caster, i_spellST->second.targetEntry, range);
4314 MaNGOS::GameObjectLastSearcher<MaNGOS::NearestGameObjectEntryInObjectRangeCheck> checker(m_caster, p_GameObject, go_check);
4316 TypeContainerVisitor<MaNGOS::GameObjectLastSearcher<MaNGOS::NearestGameObjectEntryInObjectRangeCheck>, GridTypeMapContainer > object_checker(checker);
4320 {
4321 // remember found target and range, next attempt will find more near target with another entry
4325 }
4326 }
4328 {
4331 {
4335 }
4336 }
4338 }
4342 {
4345 // check if explicit target is provided and check it up against database valid target entry/state
4347 {
4348 if (pTarget->GetTypeId() == TYPEID_UNIT && pTarget->GetEntry() == i_spellST->second.targetEntry)
4349 {
4351 {
4354 }
4356 {
4359 }
4360 }
4361 }
4363 // no target provided or it was not valid, so use closest in range
4365 {
4371 MaNGOS::NearestCreatureEntryWithLiveStateInObjectRangeCheck u_check(*m_caster, i_spellST->second.targetEntry, i_spellST->second.type != SPELL_TARGET_TYPE_DEAD, range);
4372 MaNGOS::CreatureLastSearcher<MaNGOS::NearestCreatureEntryWithLiveStateInObjectRangeCheck> searcher(m_caster, p_Creature, u_check);
4374 TypeContainerVisitor<MaNGOS::CreatureLastSearcher<MaNGOS::NearestCreatureEntryWithLiveStateInObjectRangeCheck>, GridTypeMapContainer > grid_creature_searcher(searcher);
4379 }
4382 {
4385 }
4388 }
4389 }
4390 }
4393 {
4394 // store coordinates for TARGET_SCRIPT_COORDINATES
4397 {
4398 m_targets.setDestination(creatureScriptTarget->GetPositionX(),creatureScriptTarget->GetPositionY(),creatureScriptTarget->GetPositionZ());
4400 if (m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT_COORDINATES && m_spellInfo->Effect[j] != SPELL_EFFECT_PERSISTENT_AREA_AURA)
4402 }
4403 // store explicit target for TARGET_SCRIPT
4404 else
4405 {
4409 }
4410 }
4412 {
4413 // store coordinates for TARGET_SCRIPT_COORDINATES
4416 {
4417 m_targets.setDestination(goScriptTarget->GetPositionX(),goScriptTarget->GetPositionY(),goScriptTarget->GetPositionZ());
4419 if (m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT_COORDINATES && m_spellInfo->Effect[j] != SPELL_EFFECT_PERSISTENT_AREA_AURA)
4421 }
4422 // store explicit target for TARGET_FOCUS_OR_SCRIPTED_GAMEOBJECT
4423 else
4424 {
4428 }
4429 }
4430 //Missing DB Entry or targets for this spellEffect.
4431 else
4432 {
4433 /* For TARGET_FOCUS_OR_SCRIPTED_GAMEOBJECT makes DB targets optional not required for now
4434 * TODO: Makes more research for this target type
4435 */
4437 {
4438 // not report target not existence for triggered spells
4441 else
4443 }
4444 }
4445 }
4446 }
4447 }
4450 {
4454 }
4456 {
4460 }
4463 {
4467 }
4470 {
4471 // for effects of spells that have only one target
4473 {
4475 // Death Pact
4477 {
4485 // alive
4488 // undead
4491 // owned
4499 // will set in target selection code
4500 }
4503 {
4505 {
4506 if(!m_targets.getUnitTarget() || m_targets.getUnitTarget()->GetHealth() > m_targets.getUnitTarget()->GetMaxHealth()*0.2)
4508 }
4510 {
4513 }
4515 {
4516 // spell different for friends and enemies
4517 // hart version required facing
4518 if(m_targets.getUnitTarget() && !m_caster->IsFriendlyTo(m_targets.getUnitTarget()) && !m_caster->HasInArc( M_PI_F, m_targets.getUnitTarget() ))
4520 }
4521 // Fire Nova
4523 {
4524 // fire totems slot
4527 }
4529 }
4531 {
4532 // Hammer of Wrath
4534 {
4540 }
4542 }
4544 {
4545 // Spell can be triggered, we need to check original caster prior to caster
4555 {
4558 }
4563 {
4566 }
4569 {
4572 }
4575 {
4578 }
4581 {
4584 }
4587 {
4590 }
4593 }
4595 {
4604 SpellEntry const *learn_spellproto = sSpellStore.LookupEntry(m_spellInfo->EffectTriggerSpell[i]);
4613 }
4615 {
4621 SpellEntry const *learn_spellproto = sSpellStore.LookupEntry(m_spellInfo->EffectTriggerSpell[i]);
4630 }
4632 {
4638 }
4640 {
4663 }
4666 {
4667 // Can be area effect, Check only for players and not check if target - caster (spell can have multiply drain/burn effects)
4673 }
4675 {
4680 }
4682 {
4683 if (m_caster->GetTypeId() != TYPEID_PLAYER || !m_targets.getUnitTarget() || m_targets.getUnitTarget()->GetTypeId() != TYPEID_UNIT)
4690 if ( creature->GetCreatureType() != CREATURE_TYPE_CRITTER && ( !creature->lootForBody || !creature->loot.empty() ) )
4691 {
4693 }
4703 // chance for fail at orange skinning attempt
4710 }
4712 {
4718 // we need a go target in case of TARGET_GAMEOBJECT
4720 // we need a go target, or an openable item target in case of TARGET_GAMEOBJECT_ITEM
4721 || m_spellInfo->EffectImplicitTargetA[i] == TARGET_GAMEOBJECT_ITEM && !m_targets.getGOTarget() &&
4722 (!m_targets.getItemTarget() || !m_targets.getItemTarget()->GetProto()->LockID || m_targets.getItemTarget()->GetOwner() != m_caster ) )
4725 // In BattleGround players can use only flags and banners
4730 // get the lock entry
4733 {
4737 }
4745 // check lock compatibility
4746 SpellCastResult res = CanOpenLock(SpellEffectIndex(i), lockId, skillId, reqSkillValue, skillValue);
4750 // chance for fail at orange mining/herb/LockPicking gathering attempt
4751 // second check prevent fail at rechecks
4753 {
4756 // chance for failure in orange gather / lockpick (gathering skill can't fail at maxskill)
4757 if((canFailAtMax || skillValue < sWorld.GetConfigMaxSkillValue()) && reqSkillValue > irand(skillValue - 25, skillValue + 37))
4759 }
4761 }
4763 {
4772 }
4773 // This is generic summon effect
4775 {
4776 if(SummonPropertiesEntry const *summon_prop = sSummonPropertiesStore.LookupEntry(m_spellInfo->EffectMiscValueB[i]))
4777 {
4779 {
4785 }
4786 }
4789 }
4791 {
4793 {
4798 {
4801 }
4802 else
4804 }
4810 }
4812 {
4822 // check if our map is dungeon
4824 {
4832 }
4834 }
4837 {
4841 // teleport a bit above terrain level to avoid falling below it
4843 if(fz <= INVALID_HEIGHT) // note: this also will prevent use effect in instances without vmaps height enabled
4847 // Control the caster to not climb or drop when +-fz > 8
4851 // not allow use this effect at battleground until battleground start
4857 }
4859 {
4863 }
4865 }
4866 }
4869 {
4871 {
4873 {
4874 //custom check
4876 {
4883 }
4885 }
4887 {
4909 if(int32(m_targets.getUnitTarget()->getLevel()) > CalculateDamage(SpellEffectIndex(i),m_targets.getUnitTarget()))
4913 }
4915 {
4934 if(int32(m_targets.getUnitTarget()->getLevel()) > CalculateDamage(SpellEffectIndex(i),m_targets.getUnitTarget()))
4938 }
4940 {
4958 }
4960 {
4967 // Ignore map check if spell have AreaId. AreaId already checked and this prevent special mount spells
4968 if (m_caster->GetTypeId() == TYPEID_PLAYER && !sMapStore.LookupEntry(m_caster->GetMapId())->IsMountAllowed() && !m_IsTriggeredSpell && !m_spellInfo->AreaGroupId)
4979 }
4981 {
4985 // can be casted at non-friendly unit or own pet/charm
4990 }
4993 {
4994 // not allow cast fly spells if not have req. skills (all spells is self target)
4995 // allow always ghost flight spells
4997 {
5000 }
5002 }
5004 {
5015 }
5018 }
5019 }
5021 // all ok
5023 }
5026 {
5030 if(m_caster->IsNonMeleeSpellCasted(false)) //prevent spellcast interruption by another spellcast
5035 if(m_caster->GetTypeId()==TYPEID_UNIT && (((Creature*)m_caster)->isPet() || m_caster->isCharmed()))
5036 {
5037 //dead owner (pets still alive when owners ressed?)
5046 {
5053 {
5058 }
5059 }
5066 {
5071 {
5074 }
5075 else
5076 {
5079 {
5080 //TARGET_DUELVSPLAYER is positive AND negative
5082 }
5084 {
5086 }
5087 }
5088 }
5089 //cooldown
5092 }
5095 }
5098 {
5099 // Flag drop spells totally immuned to caster auras
5100 // FIXME: find more nice check for all totally immuned spells
5101 // AttributesEx3 & 0x10000000?
5109 // Check if the spell grants school or mechanic immunity.
5110 // We use bitmasks so the loop is done only once and not on every aura check below.
5112 {
5114 {
5123 }
5124 // immune movement impairment and loss of control
5127 }
5129 // Check whether the cast should be prevented by any state you might have.
5131 // Have to check if there is a stun aura. Otherwise will have problems with ghost aura apply while logging out
5133 if (unitflag & UNIT_FLAG_STUNNED && !(m_spellInfo->AttributesEx5 & SPELL_ATTR_EX5_USABLE_WHILE_STUNNED))
5135 else if (unitflag & UNIT_FLAG_CONFUSED && !(m_spellInfo->AttributesEx5 & SPELL_ATTR_EX5_USABLE_WHILE_CONFUSED))
5137 else if (unitflag & UNIT_FLAG_FLEEING && !(m_spellInfo->AttributesEx5 & SPELL_ATTR_EX5_USABLE_WHILE_FEARED))
5139 else if (unitflag & UNIT_FLAG_SILENCED && m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE)
5141 else if (unitflag & UNIT_FLAG_PACIFIED && m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY)
5144 {
5147 {
5149 {
5152 }
5153 }
5154 }
5156 // Attr must make flag drop spell totally immune from all effects
5158 {
5160 {
5161 //Checking auras is needed now, because you are prevented by some state but the spell grants immunity.
5164 {
5166 {
5167 if (GetSpellMechanicMask(itr->second->GetSpellProto(), itr->second->GetEffIndex()) & mechanic_immune)
5174 // Make a second check for spell failed so the right SPELL_FAILED message is returned.
5175 // That is needed when your casting is prevented by multiple states and you are only immune to some of them.
5177 {
5199 }
5200 }
5201 }
5202 }
5203 // You are prevented from casting and the spell casted does not grant immunity. Return a failed error.
5204 else
5206 }
5208 }
5211 {
5215 {
5217 {
5219 {
5222 }
5223 else
5224 {
5228 }
5229 }
5231 {
5234 }
5235 }
5240 {
5242 //check if among target units, our WANTED target is as well (->only self cast spells return false)
5243 for(std::list<TargetInfo>::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
5246 }
5248 }
5251 {
5254 // self cast doesn't need range checking -- also for Starshards fix
5273 {
5274 // distance from target in checks
5282 (m_spellInfo->FacingCasterFlags & SPELL_FACING_FLAG_INFRONT) && !m_caster->HasInArc( M_PI_F, target ) )
5284 }
5286 if(m_targets.m_targetMask == TARGET_FLAG_DEST_LOCATION && m_targets.m_destX != 0 && m_targets.m_destY != 0 && m_targets.m_destZ != 0)
5287 {
5288 if(!m_caster->IsWithinDist3d(m_targets.m_destX, m_targets.m_destY, m_targets.m_destZ, max_range))
5290 if(min_range && m_caster->IsWithinDist3d(m_targets.m_destX, m_targets.m_destY, m_targets.m_destZ, min_range))
5292 }
5295 }
5298 {
5299 // item cast not used power
5303 // Spell drain all exist power on cast (Only paladin lay of Hands)
5305 {
5306 // If power type - health drain all
5309 // Else drain all power
5312 sLog.outError("Spell::CalculateManaCost: Unknown power type '%d' in spell %d", m_spellInfo->powerType, m_spellInfo->Id);
5314 }
5316 // Base powerCost
5318 // PCT cost from total amount
5320 {
5322 {
5323 // health as power used
5334 powerCost += m_spellInfo->ManaCostPercentage * m_caster->GetMaxPower(Powers(m_spellInfo->powerType)) / 100;
5341 sLog.outError("Spell::CalculateManaCost: Unknown power type '%d' in spell %d", m_spellInfo->powerType, m_spellInfo->Id);
5343 }
5344 }
5346 // Flat mod from caster auras by spell school
5348 // Shiv - costs 20 + weaponSpeed*10 energy (apply only to non-triggered spell with energy cost)
5351 // Apply cost mod by spell
5356 powerCost = int32(powerCost/ (1.117f * m_spellInfo->spellLevel / m_caster->getLevel() -0.1327f));
5358 // PCT mod from user auras by school
5359 powerCost = int32(powerCost * (1.0f + m_caster->GetFloatValue(UNIT_FIELD_POWER_COST_MULTIPLIER + school)));
5363 }
5366 {
5367 // item cast not used power
5371 // Do precise power regen on spell cast
5373 {
5378 }
5380 // health as power used - need check health amount
5382 {
5386 }
5387 // Check valid power type
5389 {
5392 }
5394 //check rune cost only if a spell has PowerType == POWER_RUNE
5396 {
5400 }
5402 // Check power amount
5406 else
5408 }
5411 {
5415 /// Check if it's an enchant scroll. These have no required reagents even though their spell does.
5420 }
5423 {
5429 // cast item checks
5431 {
5445 // consumable cast item checks
5447 {
5448 // such items should only fail if there is no suitable effect at all - see Rejuvenation Potions for example
5451 {
5452 // skip check, pet not required like checks, and for TARGET_PET m_targets.getUnitTarget() is not the real target but the caster
5457 {
5459 {
5462 }
5463 else
5464 {
5467 }
5468 }
5470 // Mana Potion, Rage Potion, Thistle Tea(Rogue), ...
5472 {
5474 {
5477 }
5480 if (m_targets.getUnitTarget()->GetPower(power) == m_targets.getUnitTarget()->GetMaxPower(power))
5481 {
5484 }
5485 else
5486 {
5489 }
5490 }
5491 }
5494 }
5495 }
5497 // check target item
5499 {
5508 }
5509 // if not item target then required item must be equipped
5510 else
5511 {
5512 if(m_caster->GetTypeId() == TYPEID_PLAYER && !((Player*)m_caster)->HasItemFitToSpellReqirements(m_spellInfo))
5514 }
5516 // check spell focus object
5518 {
5527 TypeContainerVisitor<MaNGOS::GameObjectSearcher<MaNGOS::GameObjectFocusCheck>, GridTypeMapContainer > object_checker(checker);
5535 }
5537 // check reagents (ignore triggered spells with reagents processed by original spell) and special reagent ignore case.
5539 {
5541 {
5543 {
5550 // if CastItem is also spell reagent
5552 {
5557 {
5558 // CastItem will be used up and does not count as reagent
5560 if (proto->Spells[s].SpellCharges < 0 && !(proto->ExtraFlags & ITEM_EXTRA_NON_CONSUMABLE) && abs(charges) < 2)
5561 {
5564 }
5565 }
5566 }
5570 }
5571 }
5573 // check totem-item requirements (items presence in inventory)
5576 {
5578 {
5580 {
5583 }
5584 }
5585 else
5587 }
5592 // Check items for TotemCategory (items presence in inventory)
5595 {
5597 {
5599 {
5602 }
5603 }
5604 else
5606 }
5610 }
5612 // special checks for spell effects
5614 {
5616 {
5618 {
5620 {
5621 // Conjure Mana Gem (skip same or low level ranks for later recharge)
5623 {
5624 if (ItemPrototype const* itemProto = ObjectMgr::GetItemPrototype(m_spellInfo->EffectItemType[i]))
5625 {
5627 {
5629 {
5633 // will recharge in next effect
5635 }
5636 }
5637 }
5638 }
5640 ItemPosCountVec dest;
5641 uint8 msg = p_caster->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, m_spellInfo->EffectItemType[i], 1 );
5643 {
5646 }
5647 }
5649 }
5651 {
5657 }
5660 {
5667 // Not allow enchant in trade slot for some enchant type
5669 {
5671 SpellItemEnchantmentEntry const *pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
5676 }
5678 }
5680 {
5684 // Not allow enchant in trade slot for some enchant type
5686 {
5688 SpellItemEnchantmentEntry const *pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
5693 }
5695 }
5697 // check item existence in effect code (not output errors at offhand hold item effect to main hand for example
5700 {
5704 // prevent disenchanting in trade slot
5713 // 2.0.x addon: Check player enchanting level against the item disenchanting requirements
5726 }
5728 {
5731 // ensure item is a prospectable ore
5732 if(!(m_targets.getItemTarget()->GetProto()->BagFamily & BAG_FAMILY_MASK_MINING_SUPP) || m_targets.getItemTarget()->GetProto()->Class != ITEM_CLASS_TRADE_GOODS)
5734 // prevent prospecting in trade slot
5737 // Check for enough skill in jewelcrafting
5741 // make sure the player has the required ores in inventory
5749 }
5751 {
5754 // ensure item is a millable herb
5755 if(!(m_targets.getItemTarget()->GetProto()->BagFamily & BAG_FAMILY_MASK_HERBS) || m_targets.getItemTarget()->GetProto()->Class != ITEM_CLASS_TRADE_GOODS)
5757 // prevent milling in trade slot
5760 // Check for enough skill in inscription
5764 // make sure the player has the required herbs in inventory
5772 }
5775 {
5784 {
5786 {
5794 {
5797 {
5798 // Requires No Ammo
5803 }
5812 // check ammo ws. weapon compatibility
5814 {
5826 }
5835 }
5837 }
5839 }
5840 }
5843 }
5846 {
5856 // spells not loosing casting time ( slam, dynamites, bombs.. )
5860 // check pushback reduce
5863 ((Player*)m_caster)->ApplySpellMod(m_spellInfo->Id, SPELLMOD_NOT_LOSE_CASTING_TIME, delayReduce, this);
5871 {
5874 }
5875 else
5878 sLog.outDetail("Spell %u partially interrupted for (%d) ms at damage", m_spellInfo->Id, delaytime);
5885 }
5888 {
5895 // check pushback reduce
5896 int32 delaytime = GetSpellDuration(m_spellInfo) * 25 / 100;// channeling delay is normally 25% of its time per hit
5898 ((Player*)m_caster)->ApplySpellMod(m_spellInfo->Id, SPELLMOD_NOT_LOSE_CASTING_TIME, delayReduce, this);
5906 {
5909 }
5910 else
5913 sLog.outDebug("Spell %u partially interrupted for %i ms, new duration: %u ms", m_spellInfo->Id, delaytime, m_timer);
5915 for(std::list<TargetInfo>::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
5916 {
5918 {
5919 if (Unit* unit = m_caster->GetObjectGuid() == ihit->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID))
5924 }
5925 }
5928 {
5929 // partially interrupt persistent area auras
5932 }
5935 }
5938 {
5942 {
5943 GameObject* go = m_caster->IsInWorld() ? m_caster->GetMap()->GetGameObject(m_originalCasterGUID) : NULL;
5945 }
5946 else
5947 {
5950 }
5951 }
5954 {
5958 }
5961 {
5964 // Curse of Doom & Exorcism: not find another way to fix spell target check :/
5966 {
5967 // not allow cast at player
5972 }
5974 // Dismiss Pet and Taming Lesson skipped
5979 {
5983 }
5985 }
5988 {
5995 else
5997 }
6000 {
6001 // Check targets for creature type mask and remove not appropriate (skip explicit self target case, maybe need other explicit targets)
6003 {
6006 }
6008 // Check Aura spell req (need for AoE spells)
6011 if (m_spellInfo->excludeTargetAuraSpell && target->HasAura(m_spellInfo->excludeTargetAuraSpell))
6014 // Check targets for not_selectable unit flag and remove
6015 // A player can cast spells on his pet (or other controlled unit) though in any state
6017 {
6018 // any unattackable target skipped
6022 // unselectable targets skipped in all cases except TARGET_SCRIPT targeting
6023 // in case TARGET_SCRIPT target selected by server always and can't be cheated
6029 }
6031 // Check player targets and remove if in GM mode or GM invisibility (for not self casting case)
6033 {
6039 }
6041 // Check targets for LOS visibility (except spells without range limitations )
6043 {
6049 // fall through
6051 // player far away, maybe his corpse near?
6053 {
6066 }
6068 // all ok by some way or another, skip normal check
6071 // Get GO cast coordinates if original caster -> GO
6077 }
6080 }
6083 {
6084 return m_spellInfo->SpellVisual[0] || m_spellInfo->SpellVisual[1] || IsChanneledSpell(m_spellInfo) ||
6086 }
6090 {
6092 }
6095 {
6096 for(std::list<TargetInfo>::const_iterator itr = m_UniqueTargetInfo.begin(); itr != m_UniqueTargetInfo.end(); ++itr)
6100 for(std::list<GOTargetInfo>::const_iterator itr = m_UniqueGOTargetInfo.begin(); itr != m_UniqueGOTargetInfo.end(); ++itr)
6104 for(std::list<ItemTargetInfo>::const_iterator itr = m_UniqueItemInfo.begin(); itr != m_UniqueItemInfo.end(); ++itr)
6109 }
6112 {
6114 }
6117 {
6122 {
6124 }
6125 else
6126 {
6127 sLog.outError("~SpellEvent: %s %u tried to delete non-deletable spell %u. Was not deleted, causes memory leak.",
6128 (m_Spell->GetCaster()->GetTypeId() == TYPEID_PLAYER ? "Player" : "Creature"), m_Spell->GetCaster()->GetGUIDLow(), m_Spell->m_spellInfo->Id);
6129 }
6130 }
6133 {
6134 // update spell if it is not finished
6138 // check spell state to process
6140 {
6142 {
6143 // spell was finished, check deletable state
6145 {
6146 // check, if we do have unfinished triggered spells
6148 }
6149 // event will be re-added automatically at the end of routine)
6153 {
6154 // this spell is in channeled state, process it on the next update
6155 // event will be re-added automatically at the end of routine)
6159 {
6160 // first, check, if we have just started
6162 {
6163 // no, we aren't, do the typical update
6164 // check, if we have channeled spell on our hands
6166 {
6167 // evented channeled spell is processed separately, casted once after delay, and not destroyed till finish
6168 // check, if we have casting anything else except this channeled spell and autorepeat
6170 {
6171 // another non-melee non-delayed spell is casted now, abort
6173 }
6174 else
6175 {
6176 // do the action (pass spell to channeling state)
6178 }
6179 // event will be re-added automatically at the end of routine)
6180 }
6181 else
6182 {
6183 // run the spell handler and think about what we can do next
6187 {
6188 // re-add us to the queue
6191 }
6192 // event complete
6193 // finish update event will be re-added automatically at the end of routine)
6194 }
6195 }
6196 else
6197 {
6198 // delaying had just started, record the moment
6200 // re-plan the event for the delay moment
6203 }
6207 {
6208 // all other states
6209 // event will be re-added automatically at the end of routine)
6211 }
6213 // spell processing not complete, plan event on the next update interval
6216 }
6219 {
6220 // oops, the spell we try to do is aborted
6223 }
6226 {
6228 }
6230 SpellCastResult Spell::CanOpenLock(SpellEffectIndex effIndex, uint32 lockId, SkillType& skillId, int32& reqSkillValue, int32& skillValue)
6231 {
6235 // Get LockInfo
6244 {
6246 {
6247 // check key item (many fit cases can be)
6253 // check key skill (only single first fit case can be)
6255 {
6258 // wrong locktype, skip
6265 {
6266 // skill bonus provided by casting spell (mostly item spells)
6267 // add the damage modifier from the spell casted (cheat lock / skeleton key etc.) (use m_currentBasePoints, CalculateDamage returns wrong value)
6271 // castitem check: rogue using skeleton keys. the skill values should not be added in this case.
6279 }
6282 }
6283 }
6284 }
6290 }
6292 void Spell::FillAreaTargets(UnitList &targetUnitMap, float x, float y, float radius, SpellNotifyPushType pushType, SpellTargets spellTargets)
6293 {
6298 MaNGOS::SpellNotifierCreatureAndPlayer notifier(*this, targetUnitMap, radius, pushType, spellTargets);
6299 TypeContainerVisitor<MaNGOS::SpellNotifierCreatureAndPlayer, WorldTypeMapContainer > world_notifier(notifier);
6300 TypeContainerVisitor<MaNGOS::SpellNotifierCreatureAndPlayer, GridTypeMapContainer > grid_notifier(notifier);
6303 }
6305 void Spell::FillRaidOrPartyTargets(UnitList &targetUnitMap, Unit* member, Unit* center, float radius, bool raid, bool withPets, bool withcaster)
6306 {
6311 {
6315 {
6318 // IsHostileTo check duel and controlled by enemy
6321 {
6331 }
6332 }
6333 }
6334 else
6335 {
6346 }
6347 }
6349 void Spell::FillRaidOrPartyManaPriorityTargets(UnitList &targetUnitMap, Unit* member, Unit* center, float radius, uint32 count, bool raid, bool withPets, bool withCaster)
6350 {
6353 PrioritizeManaUnitQueue manaUsers;
6354 for(UnitList::const_iterator itr = targetUnitMap.begin(); itr != targetUnitMap.end() && manaUsers.size() < count; ++itr)
6360 {
6363 }
6364 }
6366 void Spell::FillRaidOrPartyHealthPriorityTargets(UnitList &targetUnitMap, Unit* member, Unit* center, float radius, uint32 count, bool raid, bool withPets, bool withCaster)
6367 {
6370 PrioritizeHealthUnitQueue healthQueue;
6371 for(UnitList::const_iterator itr = targetUnitMap.begin(); itr != targetUnitMap.end() && healthQueue.size() < count; ++itr)
6377 {
6380 }
6381 }
6384 {
6387 else
6389 }