/** * MaNGOS is a full featured server for World of Warcraft, supporting * the following clients: 1.12.x, 2.4.3, 3.3.5a, 4.3.4a and 5.4.8 * * Copyright (C) 2005-2017 MaNGOS project * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * World of Warcraft, and all World of Warcraft or Warcraft art, images, * and lore are copyrighted by Blizzard Entertainment, Inc. */ #include "Spell.h" #include "Database/DatabaseEnv.h" #include "WorldPacket.h" #include "WorldSession.h" #include "GridNotifiers.h" #include "GridNotifiersImpl.h" #include "Opcodes.h" #include "Log.h" #include "World.h" #include "ObjectMgr.h" #include "SpellMgr.h" #include "Player.h" #include "Pet.h" #include "Unit.h" #include "DynamicObject.h" #include "Group.h" #include "UpdateData.h" #include "ObjectAccessor.h" #include "CellImpl.h" #include "Policies/Singleton.h" #include "SharedDefines.h" #include "LootMgr.h" #include "VMapFactory.h" #include "BattleGround/BattleGround.h" #include "Util.h" #include "Chat.h" #include "SQLStorages.h" #include "DisableMgr.h" #ifdef ENABLE_ELUNA #include "LuaEngine.h" #endif /* ENABLE_ELUNA */ extern pEffect SpellEffects[TOTAL_SPELL_EFFECTS]; bool IsQuestTameSpell(uint32 spellId) { SpellEntry const* spellproto = sSpellStore.LookupEntry(spellId); if (!spellproto) { return false; } return spellproto->Effect[EFFECT_INDEX_0] == SPELL_EFFECT_THREAT && spellproto->Effect[EFFECT_INDEX_1] == SPELL_EFFECT_APPLY_AURA && spellproto->EffectApplyAuraName[EFFECT_INDEX_1] == SPELL_AURA_DUMMY; } SpellCastTargets::SpellCastTargets() { m_unitTarget = NULL; m_itemTarget = NULL; m_GOTarget = NULL; m_itemTargetEntry = 0; m_srcX = m_srcY = m_srcZ = m_destX = m_destY = m_destZ = 0.0f; m_strTarget.clear(); m_targetMask = 0; } SpellCastTargets::~SpellCastTargets() { } void SpellCastTargets::setUnitTarget(Unit* target) { if (!target) { return; } m_destX = target->GetPositionX(); m_destY = target->GetPositionY(); m_destZ = target->GetPositionZ(); m_unitTarget = target; m_unitTargetGUID = target->GetObjectGuid(); m_targetMask |= TARGET_FLAG_UNIT; } void SpellCastTargets::setDestination(float x, float y, float z) { m_destX = x; m_destY = y; m_destZ = z; m_targetMask |= TARGET_FLAG_DEST_LOCATION; } void SpellCastTargets::setSource(float x, float y, float z) { m_srcX = x; m_srcY = y; m_srcZ = z; m_targetMask |= TARGET_FLAG_SOURCE_LOCATION; } void SpellCastTargets::setGOTarget(GameObject* target) { m_GOTarget = target; m_GOTargetGUID = target->GetObjectGuid(); // m_targetMask |= TARGET_FLAG_OBJECT; } void SpellCastTargets::setItemTarget(Item* item) { if (!item) { return; } m_itemTarget = item; m_itemTargetGUID = item->GetObjectGuid(); m_itemTargetEntry = item->GetEntry(); m_targetMask |= TARGET_FLAG_ITEM; } void SpellCastTargets::setTradeItemTarget(Player* caster) { m_itemTargetGUID = ObjectGuid(uint64(TRADE_SLOT_NONTRADED)); m_itemTargetEntry = 0; m_targetMask |= TARGET_FLAG_TRADE_ITEM; Update(caster); } void SpellCastTargets::setCorpseTarget(Corpse* corpse) { m_CorpseTargetGUID = corpse->GetObjectGuid(); } void SpellCastTargets::Update(Unit* caster) { m_GOTarget = m_GOTargetGUID ? caster->GetMap()->GetGameObject(m_GOTargetGUID) : NULL; m_unitTarget = m_unitTargetGUID ? (m_unitTargetGUID == caster->GetObjectGuid() ? caster : ObjectAccessor::GetUnit(*caster, m_unitTargetGUID)) : NULL; m_itemTarget = NULL; if (caster->GetTypeId() == TYPEID_PLAYER) { Player* player = ((Player*)caster); if (m_targetMask & TARGET_FLAG_ITEM) { m_itemTarget = player->GetItemByGuid(m_itemTargetGUID); } else if (m_targetMask & TARGET_FLAG_TRADE_ITEM) { if (TradeData* pTrade = player->GetTradeData()) if (m_itemTargetGUID.GetRawValue() < TRADE_SLOT_COUNT) { m_itemTarget = pTrade->GetTraderData()->GetItem(TradeSlots(m_itemTargetGUID.GetRawValue())); } } if (m_itemTarget) { m_itemTargetEntry = m_itemTarget->GetEntry(); } } } void SpellCastTargets::read(ByteBuffer& data, Unit* caster) { data >> m_targetMask; if (m_targetMask == TARGET_FLAG_SELF) { m_destX = caster->GetPositionX(); m_destY = caster->GetPositionY(); m_destZ = caster->GetPositionZ(); m_unitTarget = caster; m_unitTargetGUID = caster->GetObjectGuid(); return; } // TARGET_FLAG_UNK2 is used for non-combat pets, maybe other? if (m_targetMask & (TARGET_FLAG_UNIT | TARGET_FLAG_UNK2)) { data >> m_unitTargetGUID.ReadAsPacked(); } if (m_targetMask & (TARGET_FLAG_OBJECT | TARGET_FLAG_OBJECT_UNK | TARGET_FLAG_GAMEOBJECT_ITEM)) { data >> m_GOTargetGUID.ReadAsPacked(); } if ((m_targetMask & (TARGET_FLAG_ITEM | TARGET_FLAG_TRADE_ITEM)) && caster->GetTypeId() == TYPEID_PLAYER) { data >> m_itemTargetGUID.ReadAsPacked(); } if (m_targetMask & TARGET_FLAG_SOURCE_LOCATION) { data >> m_srcX >> m_srcY >> m_srcZ; if (!MaNGOS::IsValidMapCoord(m_srcX, m_srcY, m_srcZ)) { throw ByteBufferException(false, data.rpos(), 0, data.size()); } } if (m_targetMask & TARGET_FLAG_DEST_LOCATION) { data >> m_destX >> m_destY >> m_destZ; if (!MaNGOS::IsValidMapCoord(m_destX, m_destY, m_destZ)) { throw ByteBufferException(false, data.rpos(), 0, data.size()); } } if (m_targetMask & TARGET_FLAG_STRING) { data >> m_strTarget; } if (m_targetMask & (TARGET_FLAG_CORPSE | TARGET_FLAG_PVP_CORPSE)) { data >> m_CorpseTargetGUID.ReadAsPacked(); } // find real units/GOs Update(caster); } void SpellCastTargets::write(ByteBuffer& data) const { data << uint16(m_targetMask); if (m_targetMask & (TARGET_FLAG_UNIT | TARGET_FLAG_PVP_CORPSE | TARGET_FLAG_OBJECT | TARGET_FLAG_CORPSE | TARGET_FLAG_UNK2)) { if (m_targetMask & TARGET_FLAG_UNIT) { if (m_unitTarget) { data << m_unitTarget->GetPackGUID(); } else { data << uint8(0); } } else if (m_targetMask & (TARGET_FLAG_OBJECT | TARGET_FLAG_OBJECT_UNK)) { if (m_GOTarget) { data << m_GOTarget->GetPackGUID(); } else { data << uint8(0); } } else if (m_targetMask & (TARGET_FLAG_CORPSE | TARGET_FLAG_PVP_CORPSE)) { data << m_CorpseTargetGUID.WriteAsPacked(); } else { data << uint8(0); } } if (m_targetMask & (TARGET_FLAG_ITEM | TARGET_FLAG_TRADE_ITEM)) { if (m_itemTarget) { data << m_itemTarget->GetPackGUID(); } else { data << uint8(0); } } if (m_targetMask & TARGET_FLAG_SOURCE_LOCATION) { data << m_srcX << m_srcY << m_srcZ; } if (m_targetMask & TARGET_FLAG_DEST_LOCATION) { data << m_destX << m_destY << m_destZ; } if (m_targetMask & TARGET_FLAG_STRING) { data << m_strTarget; } } Spell::Spell(Unit* caster, SpellEntry const* info, bool triggered, ObjectGuid originalCasterGUID, SpellEntry const* triggeredBy) { MANGOS_ASSERT(caster != NULL && info != NULL); MANGOS_ASSERT(info == sSpellStore.LookupEntry(info->Id)); // `info` must be pointer to sSpellStore element m_spellInfo = info; m_triggeredBySpellInfo = triggeredBy; m_caster = caster; m_selfContainer = NULL; m_referencedFromCurrentSpell = false; m_executedCurrently = false; m_delayStart = 0; m_delayAtDamageCount = 0; m_applyMultiplierMask = 0; // Get data for type of attack m_attackType = GetWeaponAttackType(m_spellInfo); m_spellSchoolMask = GetSpellSchoolMask(info); // Can be override for some spell (wand shoot for example) if (m_attackType == RANGED_ATTACK) { // wand case if ((m_caster->getClassMask() & CLASSMASK_WAND_USERS) != 0 && m_caster->GetTypeId() == TYPEID_PLAYER) { if (Item* pItem = ((Player*)m_caster)->GetWeaponForAttack(RANGED_ATTACK)) { m_spellSchoolMask = GetSchoolMask(pItem->GetProto()->Damage[0].DamageType); } } } // Set health leech amount to zero m_healthLeech = 0; m_originalCasterGUID = originalCasterGUID ? originalCasterGUID : m_caster->GetObjectGuid(); UpdateOriginalCasterPointer(); for (int i = 0; i < MAX_EFFECT_INDEX; ++i) { m_currentBasePoints[i] = m_spellInfo->CalculateSimpleValue(SpellEffectIndex(i)); } m_spellState = SPELL_STATE_PREPARING; m_castPositionX = m_castPositionY = m_castPositionZ = 0; m_TriggerSpells.clear(); m_preCastSpells.clear(); m_IsTriggeredSpell = triggered; // m_AreaAura = false; m_CastItem = NULL; unitTarget = NULL; itemTarget = NULL; gameObjTarget = NULL; focusObject = NULL; m_triggeredByAuraSpell = NULL; // Auto Shot & Shoot (wand) m_autoRepeat = IsAutoRepeatRangedSpell(m_spellInfo); m_powerCost = 0; // setup to correct value in Spell::prepare, don't must be used before. m_casttime = 0; // setup to correct value in Spell::prepare, don't must be used before. m_timer = 0; // will set to cast time in prepare m_duration = 0; m_needAliveTargetMask = 0; // determine reflection m_canReflect = false; if (m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MAGIC && !m_spellInfo->HasAttribute(SPELL_ATTR_EX2_CANT_REFLECTED)) { for (int j = 0; j < MAX_EFFECT_INDEX; ++j) { if (m_spellInfo->Effect[j] == 0) { continue; } if (!IsPositiveTarget(m_spellInfo->EffectImplicitTargetA[j], m_spellInfo->EffectImplicitTargetB[j])) { m_canReflect = true; } else { m_canReflect = m_spellInfo->HasAttribute(SPELL_ATTR_EX_NEGATIVE); } if (m_canReflect) { continue; } else { break; } } } CleanupTargetList(); } Spell::~Spell() { } template WorldObject* Spell::FindCorpseUsing() { // non-standard target selection SpellRangeEntry const* srange = sSpellRangeStore.LookupEntry(m_spellInfo->rangeIndex); float max_range = GetSpellMaxRange(srange); WorldObject* result = NULL; T u_check(m_caster, max_range); MaNGOS::WorldObjectSearcher searcher(result, u_check); Cell::VisitGridObjects(m_caster, searcher, max_range); if (!result) { Cell::VisitWorldObjects(m_caster, searcher, max_range); } return result; } void Spell::FillTargetMap() { // TODO: ADD the correct target FILLS!!!!!! UnitList tmpUnitLists[MAX_EFFECT_INDEX]; // Stores the temporary Target Lists for each effect uint8 effToIndex[MAX_EFFECT_INDEX] = {0, 1, 2}; // Helper array, to link to another tmpUnitList, if the targets for both effects match for (int i = 0; i < MAX_EFFECT_INDEX; ++i) { // not call for empty effect. // Also some spells use not used effect targets for store targets for dummy effect in triggered spells if (m_spellInfo->Effect[i] == SPELL_EFFECT_NONE) { continue; } // targets for TARGET_SCRIPT_COORDINATES (A) and TARGET_SCRIPT // for TARGET_FOCUS_OR_SCRIPTED_GAMEOBJECT (A) all is checked in Spell::CheckCast and in Spell::CheckItem // filled in Spell::CheckCast call if (m_spellInfo->EffectImplicitTargetA[i] == TARGET_SCRIPT_COORDINATES || m_spellInfo->EffectImplicitTargetA[i] == TARGET_FOCUS_OR_SCRIPTED_GAMEOBJECT || (m_spellInfo->EffectImplicitTargetA[i] == TARGET_SCRIPT && m_spellInfo->EffectImplicitTargetB[i] != TARGET_SELF) || (m_spellInfo->EffectImplicitTargetB[i] == TARGET_SCRIPT && m_spellInfo->EffectImplicitTargetA[i] != TARGET_SELF)) { continue; } // TODO: find a way so this is not needed? // for area auras always add caster as target (needed for totems for example) if (IsAreaAuraEffect(m_spellInfo->Effect[i])) { AddUnitTarget(m_caster, SpellEffectIndex(i)); } // no double fill for same targets for (int j = 0; j < i; ++j) { // Check if same target, but handle i.e. AreaAuras different if (m_spellInfo->EffectImplicitTargetA[i] == m_spellInfo->EffectImplicitTargetA[j] && m_spellInfo->EffectImplicitTargetB[i] == m_spellInfo->EffectImplicitTargetB[j] && m_spellInfo->Effect[j] != SPELL_EFFECT_NONE && !IsAreaAuraEffect(m_spellInfo->Effect[i]) && !IsAreaAuraEffect(m_spellInfo->Effect[j])) // Add further conditions here if required { effToIndex[i] = j; // effect i has same targeting list as effect j break; } } if (effToIndex[i] == i) // New target combination { // TargetA/TargetB dependent from each other, we not switch to full support this dependences // but need it support in some know cases switch (m_spellInfo->EffectImplicitTargetA[i]) { case TARGET_NONE: switch (m_spellInfo->EffectImplicitTargetB[i]) { case TARGET_NONE: if (m_caster->GetObjectGuid().IsPet()) { SetTargetMap(SpellEffectIndex(i), TARGET_SELF, tmpUnitLists[i /*==effToIndex[i]*/]); } else { SetTargetMap(SpellEffectIndex(i), TARGET_EFFECT_SELECT, tmpUnitLists[i /*==effToIndex[i]*/]); } break; default: SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetB[i], tmpUnitLists[i /*==effToIndex[i]*/]); break; } break; case TARGET_SELF: switch (m_spellInfo->EffectImplicitTargetB[i]) { case TARGET_NONE: // Fill Target based on A only // Arcane Missiles have strange targeting for auras // Gnomish Death Ray triggered 13280 if ((m_spellInfo->SpellFamilyName == SPELLFAMILY_MAGE && m_spellInfo->SpellFamilyFlags & UI64LIT(0x00000800)) || (m_spellInfo->Id == 13280)) { if (m_caster->GetTypeId() == TYPEID_PLAYER) if (Unit* target = ObjectAccessor::Instance().GetUnit(*m_caster, ((Player*)m_caster)->GetSelectionGuid())) if (!m_caster->IsFriendlyTo(target)) { tmpUnitLists[i /*==effToIndex[i]*/].push_back(target); } } else { SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetA[i], tmpUnitLists[i /*==effToIndex[i]*/]); } break; case TARGET_EFFECT_SELECT: case TARGET_SCRIPT: // B-target only used with CheckCast here SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetA[i], tmpUnitLists[i /*==effToIndex[i]*/]); break; case TARGET_AREAEFFECT_INSTANT: // use B case that not dependent from from A in fact if ((m_targets.m_targetMask & TARGET_FLAG_DEST_LOCATION) == 0) { m_targets.setDestination(m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ()); } SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetB[i], tmpUnitLists[i /*==effToIndex[i]*/]); break; default: SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetA[i], tmpUnitLists[i /*==effToIndex[i]*/]); SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetB[i], tmpUnitLists[i /*==effToIndex[i]*/]); break; } break; case TARGET_EFFECT_SELECT: switch (m_spellInfo->EffectImplicitTargetB[i]) { case TARGET_NONE: case TARGET_EFFECT_SELECT: SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetA[i], tmpUnitLists[i /*==effToIndex[i]*/]); break; // dest point setup required case TARGET_AREAEFFECT_INSTANT: case TARGET_AREAEFFECT_CUSTOM: case TARGET_ALL_ENEMY_IN_AREA: case TARGET_ALL_ENEMY_IN_AREA_INSTANT: case TARGET_ALL_ENEMY_IN_AREA_CHANNELED: case TARGET_ALL_FRIENDLY_UNITS_IN_AREA: case TARGET_AREAEFFECT_GO_AROUND_DEST: // triggered spells get dest point from default target set, ignore it if (!(m_targets.m_targetMask & TARGET_FLAG_DEST_LOCATION) || m_IsTriggeredSpell) if (WorldObject* castObject = GetCastingObject()) { m_targets.setDestination(castObject->GetPositionX(), castObject->GetPositionY(), castObject->GetPositionZ()); } SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetB[i], tmpUnitLists[i /*==effToIndex[i]*/]); break; // target pre-selection required case TARGET_INNKEEPER_COORDINATES: case TARGET_TABLE_X_Y_Z_COORDINATES: case TARGET_CASTER_COORDINATES: case TARGET_SCRIPT_COORDINATES: case TARGET_CURRENT_ENEMY_COORDINATES: case TARGET_DUELVSPLAYER_COORDINATES: // need some target for processing SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetA[i], tmpUnitLists[i /*==effToIndex[i]*/]); SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetB[i], tmpUnitLists[i /*==effToIndex[i]*/]); break; default: SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetB[i], tmpUnitLists[i /*==effToIndex[i]*/]); break; } break; case TARGET_CASTER_COORDINATES: switch (m_spellInfo->EffectImplicitTargetB[i]) { case TARGET_ALL_ENEMY_IN_AREA: // Note: this hack with search required until GO casting not implemented // environment damage spells already have around enemies targeting but this not help in case nonexistent GO casting support // currently each enemy selected explicitly and self cast damage if (m_spellInfo->Effect[i] == SPELL_EFFECT_ENVIRONMENTAL_DAMAGE) { if (m_targets.getUnitTarget()) { tmpUnitLists[i /*==effToIndex[i]*/].push_back(m_targets.getUnitTarget()); } } else { SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetA[i], tmpUnitLists[i /*==effToIndex[i]*/]); SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetB[i], tmpUnitLists[i /*==effToIndex[i]*/]); } break; case TARGET_NONE: SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetA[i], tmpUnitLists[i /*==effToIndex[i]*/]); tmpUnitLists[i /*==effToIndex[i]*/].push_back(m_caster); break; default: SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetA[i], tmpUnitLists[i /*==effToIndex[i]*/]); SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetB[i], tmpUnitLists[i /*==effToIndex[i]*/]); break; } break; case TARGET_TABLE_X_Y_Z_COORDINATES: switch (m_spellInfo->EffectImplicitTargetB[i]) { case TARGET_NONE: SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetA[i], tmpUnitLists[i /*==effToIndex[i]*/]); // need some target for processing SetTargetMap(SpellEffectIndex(i), TARGET_EFFECT_SELECT, tmpUnitLists[i /*==effToIndex[i]*/]); break; case TARGET_AREAEFFECT_INSTANT: // All 17/7 pairs used for dest teleportation, A processed in effect code SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetB[i], tmpUnitLists[i /*==effToIndex[i]*/]); break; default: SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetA[i], tmpUnitLists[i /*==effToIndex[i]*/]); SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetB[i], tmpUnitLists[i /*==effToIndex[i]*/]); break; } break; case TARGET_DUELVSPLAYER_COORDINATES: switch (m_spellInfo->EffectImplicitTargetB[i]) { case TARGET_NONE: case TARGET_EFFECT_SELECT: SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetA[i], tmpUnitLists[i /*==effToIndex[i]*/]); if (Unit* currentTarget = m_targets.getUnitTarget()) { tmpUnitLists[i /*==effToIndex[i]*/].push_back(currentTarget); } break; default: SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetA[i], tmpUnitLists[i /*==effToIndex[i]*/]); SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetB[i], tmpUnitLists[i /*==effToIndex[i]*/]); break; } break; case TARGET_SCRIPT: switch (m_spellInfo->EffectImplicitTargetB[i]) { case TARGET_SELF: // Fill target based on B only, A is only used with CheckCast here. SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetB[i], tmpUnitLists[i /*==effToIndex[i]*/]); break; default: break; } break; default: switch (m_spellInfo->EffectImplicitTargetB[i]) { case TARGET_NONE: case TARGET_EFFECT_SELECT: SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetA[i], tmpUnitLists[i /*==effToIndex[i]*/]); break; case TARGET_SCRIPT_COORDINATES: // B case filled in CheckCast but we need fill unit list base at A case SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetA[i], tmpUnitLists[i /*==effToIndex[i]*/]); break; default: SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetA[i], tmpUnitLists[i /*==effToIndex[i]*/]); SetTargetMap(SpellEffectIndex(i), m_spellInfo->EffectImplicitTargetB[i], tmpUnitLists[i /*==effToIndex[i]*/]); break; } break; } } if (m_caster->GetTypeId() == TYPEID_PLAYER) { Player* me = (Player*)m_caster; for (UnitList::const_iterator itr = tmpUnitLists[effToIndex[i]].begin(); itr != tmpUnitLists[effToIndex[i]].end(); ++itr) { Player* targetOwner = (*itr)->GetCharmerOrOwnerPlayerOrPlayerItself(); if (targetOwner && targetOwner != me && targetOwner->IsPvP() && !me->IsInDuelWith(targetOwner)) { me->UpdatePvP(true); me->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT); break; } } } for (UnitList::iterator itr = tmpUnitLists[effToIndex[i]].begin(); itr != tmpUnitLists[effToIndex[i]].end();) { if (!CheckTarget(*itr, SpellEffectIndex(i))) { itr = tmpUnitLists[effToIndex[i]].erase(itr); continue; } else { ++itr; } } for (UnitList::const_iterator iunit = tmpUnitLists[effToIndex[i]].begin(); iunit != tmpUnitLists[effToIndex[i]].end(); ++iunit) { AddUnitTarget((*iunit), SpellEffectIndex(i)); } } } void Spell::prepareDataForTriggerSystem() { //========================================================================================== // Now fill data for trigger system, need know: // an spell trigger another or not ( m_canTrigger ) // Create base triggers flags for Attacker and Victim ( m_procAttacker and m_procVictim) //========================================================================================== // Fill flag can spell trigger or not // TODO: possible exist spell attribute for this m_canTrigger = false; if (m_CastItem) { m_canTrigger = false; } // Do not trigger from item cast spell else if (!m_IsTriggeredSpell) { m_canTrigger = true; } // Normal cast - can trigger else if (!m_triggeredByAuraSpell) { m_canTrigger = true; } // Triggered from SPELL_EFFECT_TRIGGER_SPELL - can trigger if (!m_canTrigger) // Exceptions (some periodic triggers) { switch (m_spellInfo->SpellFamilyName) { case SPELLFAMILY_MAGE: // Arcane Missiles / Blizzard triggers need do it if (m_spellInfo->IsFitToFamilyMask(UI64LIT(0x0000000000200080))) { m_canTrigger = true; } break; case SPELLFAMILY_WARLOCK: // For Hellfire Effect / Rain of Fire / Seed of Corruption triggers need do it if (m_spellInfo->IsFitToFamilyMask(UI64LIT(0x0000800000000060))) { m_canTrigger = true; } break; case SPELLFAMILY_HUNTER: // Hunter Explosive Trap Effect/Immolation Trap Effect/Frost Trap Aura/Snake Trap Effect if (m_spellInfo->IsFitToFamilyMask(UI64LIT(0x0000200000000014))) { m_canTrigger = true; } break; case SPELLFAMILY_PALADIN: // For Holy Shock triggers need do it if (m_spellInfo->IsFitToFamilyMask(UI64LIT(0x0001000000200000))) { m_canTrigger = true; } break; default: break; } } // Get data for type of attack and fill base info for trigger switch (m_spellInfo->DmgClass) { case SPELL_DAMAGE_CLASS_MELEE: m_procAttacker = PROC_FLAG_SUCCESSFUL_MELEE_SPELL_HIT; if (m_attackType == OFF_ATTACK) { m_procAttacker |= PROC_FLAG_SUCCESSFUL_OFFHAND_HIT; } m_procVictim = PROC_FLAG_TAKEN_MELEE_SPELL_HIT; break; case SPELL_DAMAGE_CLASS_RANGED: // Auto attack if (m_spellInfo->HasAttribute(SPELL_ATTR_EX2_AUTOREPEAT_FLAG)) { m_procAttacker = PROC_FLAG_SUCCESSFUL_RANGED_HIT; m_procVictim = PROC_FLAG_TAKEN_RANGED_HIT; } else // Ranged spell attack { m_procAttacker = PROC_FLAG_SUCCESSFUL_RANGED_SPELL_HIT; m_procVictim = PROC_FLAG_TAKEN_RANGED_SPELL_HIT; } break; default: if (IsPositiveSpell(m_spellInfo->Id)) // Check for positive spell { m_procAttacker = PROC_FLAG_SUCCESSFUL_POSITIVE_SPELL; m_procVictim = PROC_FLAG_TAKEN_POSITIVE_SPELL; } else if (m_spellInfo->HasAttribute(SPELL_ATTR_EX2_AUTOREPEAT_FLAG)) // Wands auto attack { m_procAttacker = PROC_FLAG_SUCCESSFUL_RANGED_HIT; m_procVictim = PROC_FLAG_TAKEN_RANGED_HIT; } else // Negative spell { m_procAttacker = PROC_FLAG_SUCCESSFUL_NEGATIVE_SPELL_HIT; m_procVictim = PROC_FLAG_TAKEN_NEGATIVE_SPELL_HIT; } break; } // some negative spells have positive effects to another or same targets // avoid triggering negative hit for only positive targets m_negativeEffectMask = 0x0; for (int i = 0; i < MAX_EFFECT_INDEX; ++i) if (m_spellInfo->Effect[i] != SPELL_EFFECT_NONE && !IsPositiveEffect(m_spellInfo, SpellEffectIndex(i))) { m_negativeEffectMask |= (1 << i); } // Hunter traps spells (for Entrapment trigger) // Gives your Immolation Trap, Frost Trap, Explosive Trap, and Snake Trap .... if (m_spellInfo->SpellFamilyName == SPELLFAMILY_HUNTER && m_spellInfo->SpellFamilyFlags & UI64LIT(0x000020000000001C)) { m_procAttacker |= PROC_FLAG_ON_TRAP_ACTIVATION; } } void Spell::CleanupTargetList() { m_UniqueTargetInfo.clear(); m_UniqueGOTargetInfo.clear(); m_UniqueItemInfo.clear(); m_delayMoment = 0; } void Spell::AddUnitTarget(Unit* pVictim, SpellEffectIndex effIndex) { if (m_spellInfo->Effect[effIndex] == 0) { return; } // Check for effect immune skip if immuned bool immuned = pVictim->IsImmuneToSpellEffect(m_spellInfo, effIndex, pVictim == m_caster); ObjectGuid targetGUID = pVictim->GetObjectGuid(); // Lookup target in already in list for (TargetList::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit) { if (targetGUID == ihit->targetGUID) // Found in list { if (!immuned) { ihit->effectMask |= 1 << effIndex; } // Add only effect mask if not immuned return; } } // This is new target calculate data for him // Get spell hit result on target TargetInfo target; target.targetGUID = targetGUID; // Store target GUID target.effectMask = immuned ? 0 : (1 << effIndex); // Store index of effect if not immuned target.processed = false; // Effects not applied on target // Calculate hit result target.missCondition = m_caster->SpellHitResult(pVictim, m_spellInfo, m_canReflect); // spell fly from visual cast object WorldObject* affectiveObject = GetAffectiveCasterObject(); // Spell have speed (possible inherited from triggering spell) - need calculate incoming time float speed = m_spellInfo->speed == 0.0f && m_triggeredBySpellInfo ? m_triggeredBySpellInfo->speed : m_spellInfo->speed; if (speed > 0.0f && affectiveObject && (pVictim != affectiveObject || (m_targets.m_targetMask & (TARGET_FLAG_SOURCE_LOCATION | TARGET_FLAG_DEST_LOCATION)))) { // calculate spell incoming interval float dist = 0.0f; // distance to impact if (pVictim == affectiveObject) // Calculate dist to destination target also for self-cast spells { if (m_targets.m_targetMask & TARGET_FLAG_DEST_LOCATION) { dist = affectiveObject->GetDistance(m_targets.m_destX, m_targets.m_destY, m_targets.m_destZ); } else // Must have Source Target { dist = affectiveObject->GetDistance(m_targets.m_srcX, m_targets.m_srcY, m_targets.m_srcZ); } } else // normal unit target, take distance { dist = affectiveObject->GetDistance(pVictim->GetPositionX(), pVictim->GetPositionY(), pVictim->GetPositionZ()); } if (dist < 5.0f) { dist = 5.0f; } target.timeDelay = (uint64) floor(dist / speed * 1000.0f); // Calculate minimum incoming time if (m_delayMoment == 0 || m_delayMoment > target.timeDelay) { m_delayMoment = target.timeDelay; } } else { target.timeDelay = UI64LIT(0); } // If target reflect spell back to caster if (target.missCondition == SPELL_MISS_REFLECT) { // Calculate reflected spell result on caster target.reflectResult = m_caster->SpellHitResult(m_caster, m_spellInfo, m_canReflect); if (target.reflectResult == SPELL_MISS_REFLECT) // Impossible reflect again, so simply deflect spell { target.reflectResult = SPELL_MISS_PARRY; } // Increase time interval for reflected spells by 1.5 target.timeDelay += target.timeDelay >> 1; } else { target.reflectResult = SPELL_MISS_NONE; } // Add target to list m_UniqueTargetInfo.push_back(target); } void Spell::AddUnitTarget(ObjectGuid unitGuid, SpellEffectIndex effIndex) { if (Unit* unit = m_caster->GetObjectGuid() == unitGuid ? m_caster : ObjectAccessor::GetUnit(*m_caster, unitGuid)) { AddUnitTarget(unit, effIndex); } } void Spell::AddGOTarget(GameObject* pVictim, SpellEffectIndex effIndex) { if (m_spellInfo->Effect[effIndex] == 0) { return; } ObjectGuid targetGUID = pVictim->GetObjectGuid(); // Lookup target in already in list for (GOTargetList::iterator ihit = m_UniqueGOTargetInfo.begin(); ihit != m_UniqueGOTargetInfo.end(); ++ihit) { if (targetGUID == ihit->targetGUID) // Found in list { ihit->effectMask |= (1 << effIndex); // Add only effect mask return; } } // This is new target calculate data for him GOTargetInfo target; target.targetGUID = targetGUID; target.effectMask = (1 << effIndex); target.processed = false; // Effects not apply on target // spell fly from visual cast object WorldObject* affectiveObject = GetAffectiveCasterObject(); // Spell can have speed - need calculate incoming time float speed = m_spellInfo->speed == 0.0f && m_triggeredBySpellInfo ? m_triggeredBySpellInfo->speed : m_spellInfo->speed; if (speed > 0.0f && affectiveObject && pVictim != affectiveObject) { // calculate spell incoming interval float dist = affectiveObject->GetDistance(pVictim->GetPositionX(), pVictim->GetPositionY(), pVictim->GetPositionZ()); if (dist < 5.0f) { dist = 5.0f; } target.timeDelay = (uint64) floor(dist / speed * 1000.0f); if (m_delayMoment == 0 || m_delayMoment > target.timeDelay) { m_delayMoment = target.timeDelay; } } else { target.timeDelay = UI64LIT(0); } // Add target to list m_UniqueGOTargetInfo.push_back(target); } void Spell::AddGOTarget(ObjectGuid goGuid, SpellEffectIndex effIndex) { if (GameObject* go = m_caster->GetMap()->GetGameObject(goGuid)) { AddGOTarget(go, effIndex); } } void Spell::AddItemTarget(Item* pitem, SpellEffectIndex effIndex) { if (m_spellInfo->Effect[effIndex] == 0) { return; } // Lookup target in already in list for (ItemTargetList::iterator ihit = m_UniqueItemInfo.begin(); ihit != m_UniqueItemInfo.end(); ++ihit) { if (pitem == ihit->item) // Found in list { ihit->effectMask |= (1 << effIndex); // Add only effect mask return; } } // This is new target add data ItemTargetInfo target; target.item = pitem; target.effectMask = (1 << effIndex); m_UniqueItemInfo.push_back(target); } void Spell::DoAllEffectOnTarget(TargetInfo* target) { if (target->processed) // Check target { return; } target->processed = true; // Target checked in apply effects procedure // Get mask of effects for target uint32 mask = target->effectMask; Unit* unit = m_caster->GetObjectGuid() == target->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, target->targetGUID); if (!unit) { return; } // Get original caster (if exist) and calculate damage/healing from him data Unit* real_caster = GetAffectiveCaster(); // FIXME: in case wild GO heal/damage spells will be used target bonuses Unit* caster = real_caster ? real_caster : m_caster; SpellMissInfo missInfo = target->missCondition; // Need init unitTarget by default unit (can changed in code on reflect) // Or on missInfo!=SPELL_MISS_NONE unitTarget undefined (but need in trigger subsystem) unitTarget = unit; // Reset damage/healing counter ResetEffectDamageAndHeal(); // Fill base trigger info uint32 procAttacker = m_procAttacker; uint32 procVictim = m_procVictim; uint32 procEx = PROC_EX_NONE; // drop proc flags in case target not affected negative effects in negative spell // for example caster bonus or animation, // except miss case where will assigned PROC_EX_* flags later if (((procAttacker | procVictim) & NEGATIVE_TRIGGER_MASK) && !(target->effectMask & m_negativeEffectMask) && missInfo == SPELL_MISS_NONE) { procAttacker = PROC_FLAG_NONE; procVictim = PROC_FLAG_NONE; } float speed = m_spellInfo->speed == 0.0f && m_triggeredBySpellInfo ? m_triggeredBySpellInfo->speed : m_spellInfo->speed; if (speed > 0.0f) { // mark effects that were already handled in Spell::HandleDelayedSpellLaunch on spell launch as processed for (int32 i = 0; i < MAX_EFFECT_INDEX; ++i) if (IsEffectHandledOnDelayedSpellLaunch(m_spellInfo, SpellEffectIndex(i))) { mask &= ~(1 << i); } // maybe used in effects that are handled on hit m_damage += target->damage; } if (missInfo == SPELL_MISS_NONE) // In case spell hit target, do all effect on that target { DoSpellHitOnUnit(unit, mask); } else if (missInfo == SPELL_MISS_REFLECT) // In case spell reflect from target, do all effect on caster (if hit) { if (target->reflectResult == SPELL_MISS_NONE) // If reflected spell hit caster -> do all effect on him { DoSpellHitOnUnit(m_caster, mask, true); unitTarget = m_caster; if (m_caster->GetTypeId() == TYPEID_UNIT) m_caster->ToCreature()->LowerPlayerDamageReq(target->damage); } } else // in 1.12.1 we need explicit miss info { if (real_caster) { // Warrior's execute must be returned as 20647 spell result since the client only displays info when receiving this id. // Done here because must be based on MeleeSpellHitResult of spell id's 5308/20658/20660/20661/20662. if(m_spellInfo->SpellFamilyName == SPELLFAMILY_WARRIOR && m_spellInfo->IsFitToFamilyMask(0x0000000020000000)) { real_caster->SendSpellMiss(unit, 20647, missInfo); } else { real_caster->SendSpellMiss(unit, m_spellInfo->Id, missInfo); } } if (missInfo == SPELL_MISS_MISS || missInfo == SPELL_MISS_RESIST) { if (real_caster && real_caster != unit) { // can cause back attack (if detected) if (!m_spellInfo->HasAttribute(SPELL_ATTR_EX3_NO_INITIAL_AGGRO) && !IsPositiveSpell(m_spellInfo->Id) && m_caster->IsVisibleForOrDetect(unit, unit, false)) { if (!unit->IsInCombat() && unit->GetTypeId() != TYPEID_PLAYER && ((Creature*)unit)->AI()) { ((Creature*)unit)->AI()->AttackedBy(real_caster); } unit->AddThreat(real_caster); unit->SetInCombatWith(real_caster); real_caster->SetInCombatWith(unit); } } } } // All calculated do it! // Do healing and triggers if (m_healing) { bool crit = real_caster && real_caster->IsSpellCrit(unitTarget, m_spellInfo, m_spellSchoolMask); uint32 addhealth = m_healing; if (crit) { procEx |= PROC_EX_CRITICAL_HIT; addhealth = caster->SpellCriticalHealingBonus(m_spellInfo, addhealth, NULL); } else { procEx |= PROC_EX_NORMAL_HIT; } // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge) if (m_canTrigger && missInfo != SPELL_MISS_REFLECT) { // Some spell expected send main spell info to triggered system SpellEntry const* spellInfo = m_spellInfo; switch (m_spellInfo->Id) { case 19968: // Holy Light triggered heal case 19993: // Flash of Light triggered heal { // stored in unused spell effect basepoints in main spell code uint32 spellid = m_currentBasePoints[EFFECT_INDEX_1]; spellInfo = sSpellStore.LookupEntry(spellid); } } caster->ProcDamageAndSpell(unitTarget, real_caster ? procAttacker : uint32(PROC_FLAG_NONE), procVictim, procEx, addhealth, m_attackType, spellInfo); } int32 gain = caster->DealHeal(unitTarget, addhealth, m_spellInfo, crit); if (real_caster) { unitTarget->GetHostileRefManager().threatAssist(real_caster, float(gain) * 0.5f * sSpellMgr.GetSpellThreatMultiplier(m_spellInfo), m_spellInfo); } } // Do damage and triggers else if (m_damage) { // Fill base damage struct (unitTarget - is real spell target) SpellNonMeleeDamage damageInfo(caster, unitTarget, m_spellInfo->Id, GetFirstSchoolInMask(m_spellSchoolMask)); if (speed > 0.0f) { damageInfo.damage = m_damage; damageInfo.HitInfo = target->HitInfo; } // Add bonuses and fill damageInfo struct else { caster->CalculateSpellDamage(&damageInfo, m_damage, m_spellInfo, m_attackType); } unitTarget->CalculateAbsorbResistBlock(caster, &damageInfo, m_spellInfo); caster->DealDamageMods(damageInfo.target, damageInfo.damage, &damageInfo.absorb); // Send log damage message to client caster->SendSpellNonMeleeDamageLog(&damageInfo); procEx = createProcExtendMask(&damageInfo, missInfo); procVictim |= PROC_FLAG_TAKEN_ANY_DAMAGE; // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge) if (m_canTrigger && missInfo != SPELL_MISS_REFLECT) { caster->ProcDamageAndSpell(unitTarget, real_caster ? procAttacker : uint32(PROC_FLAG_NONE), procVictim, procEx, damageInfo.damage, m_attackType, m_spellInfo); } // trigger weapon enchants for weapon based spells; exclude spells that stop attack, because may break CC if (m_caster->GetTypeId() == TYPEID_PLAYER && m_spellInfo->EquippedItemClass == ITEM_CLASS_WEAPON && !m_spellInfo->HasAttribute(SPELL_ATTR_STOP_ATTACK_TARGET)) { ((Player*)m_caster)->CastItemCombatSpell(unitTarget, m_attackType); } caster->DealSpellDamage(&damageInfo, true); // Bloodthirst if (m_spellInfo->SpellFamilyName == SPELLFAMILY_WARRIOR && m_spellInfo->SpellFamilyFlags & UI64LIT(0x0000000002000000) && m_spellInfo->SpellIconID == 38) { uint32 BTAura = 0; switch (m_spellInfo->Id) { case 23881: BTAura = 23885; break; case 23892: BTAura = 23886; break; case 23893: BTAura = 23887; break; case 23894: BTAura = 23888; break; default: sLog.outError("Spell::EffectSchoolDMG: Spell %u not handled in BTAura", m_spellInfo->Id); break; } if (BTAura) { m_caster->CastSpell(m_caster, BTAura, true); } } } // Passive spell hits/misses or active spells only misses (only triggers if proc flags set) else if (procAttacker || procVictim) { // Fill base damage struct (unitTarget - is real spell target) SpellNonMeleeDamage damageInfo(caster, unitTarget, m_spellInfo->Id, GetFirstSchoolInMask(m_spellSchoolMask)); procEx = createProcExtendMask(&damageInfo, missInfo); // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge) if (m_canTrigger && missInfo != SPELL_MISS_REFLECT) { caster->ProcDamageAndSpell(unit, real_caster ? procAttacker : uint32(PROC_FLAG_NONE), procVictim, procEx, 0, m_attackType, m_spellInfo); } } // Call scripted function for AI if this spell is casted upon a creature if (unit->GetTypeId() == TYPEID_UNIT) { // cast at creature (or GO) quest objectives update at successful cast finished (+channel finished) // ignore pets or autorepeat/melee casts for speed (not exist quest for spells (hm... ) if (real_caster && !((Creature*)unit)->IsPet() && !IsAutoRepeat() && !IsNextMeleeSwingSpell() && !IsChannelActive()) if (Player* p = real_caster->GetCharmerOrOwnerPlayerOrPlayerItself()) { p->RewardPlayerAndGroupAtCast(unit, m_spellInfo->Id); } if (((Creature*)unit)->AI()) { ((Creature*)unit)->AI()->SpellHit(m_caster, m_spellInfo); } } // Call scripted function for AI if this spell is casted by a creature if (m_caster->GetTypeId() == TYPEID_UNIT && ((Creature*)m_caster)->AI()) { ((Creature*)m_caster)->AI()->SpellHitTarget(unit, m_spellInfo); } if (real_caster && real_caster != m_caster && real_caster->GetTypeId() == TYPEID_UNIT && ((Creature*)real_caster)->AI()) { ((Creature*)real_caster)->AI()->SpellHitTarget(unit, m_spellInfo); } } void Spell::DoSpellHitOnUnit(Unit* unit, uint32 effectMask, bool isReflected) { if (!unit || !effectMask) { return; } Unit* realCaster = GetAffectiveCaster(); // Recheck immune (only for delayed spells) float speed = m_spellInfo->speed == 0.0f && m_triggeredBySpellInfo ? m_triggeredBySpellInfo->speed : m_spellInfo->speed; if (speed && ( unit->IsImmuneToDamage(GetSpellSchoolMask(m_spellInfo)) || unit->IsImmuneToSpell(m_spellInfo, unit == realCaster))) { if (realCaster) { realCaster->SendSpellMiss(unit, m_spellInfo->Id, SPELL_MISS_IMMUNE); } ResetEffectDamageAndHeal(); return; } if (realCaster && realCaster != unit) { // Recheck UNIT_FLAG_NON_ATTACKABLE for delayed spells if (speed > 0.0f && unit->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE) && unit->GetCharmerOrOwnerGuid() != m_caster->GetObjectGuid()) { realCaster->SendSpellMiss(unit, m_spellInfo->Id, SPELL_MISS_EVADE); ResetEffectDamageAndHeal(); return; } if (!realCaster->IsFriendlyTo(unit)) { // for delayed spells ignore not visible explicit target if (speed > 0.0f && unit == m_targets.getUnitTarget() && !unit->IsVisibleForOrDetect(m_caster, m_caster, false)) { realCaster->SendSpellMiss(unit, m_spellInfo->Id, SPELL_MISS_EVADE); ResetEffectDamageAndHeal(); return; } // not break stealth by cast targeting if(!(m_spellInfo->AttributesEx & SPELL_ATTR_EX_NOT_BREAK_STEALTH) && m_spellInfo->Id != 51690 && m_spellInfo->Id != 53055) { unit->RemoveSpellsCausingAura(SPELL_AURA_MOD_STEALTH); } // can cause back attack (if detected), stealth removed at Spell::cast if spell break it if (!m_spellInfo->HasAttribute(SPELL_ATTR_EX3_NO_INITIAL_AGGRO) && !IsPositiveSpell(m_spellInfo->Id) && m_caster->IsVisibleForOrDetect(unit, unit, false)) { // use speedup check to avoid re-remove after above lines if (m_spellInfo->HasAttribute(SPELL_ATTR_EX_NOT_BREAK_STEALTH)) { unit->RemoveSpellsCausingAura(SPELL_AURA_MOD_STEALTH); } // caster can be detected but have stealth aura m_caster->RemoveSpellsCausingAura(SPELL_AURA_MOD_STEALTH); if (!unit->IsStandState() && !unit->hasUnitState(UNIT_STAT_STUNNED)) { unit->SetStandState(UNIT_STAND_STATE_STAND); } switch (m_spellInfo->Id) { // Mind Soothe (all ranks) case 453: case 8192: case 10953: //Soothe animal case 9901: case 8955: case 2908: // Gnomish Mind Control Cap case 13180: break; default: { if (!unit->IsInCombat() && unit->GetTypeId() != TYPEID_PLAYER && ((Creature*)unit)->AI()) { unit->AttackedBy(realCaster); } unit->AddThreat(realCaster); unit->SetInCombatWith(realCaster); realCaster->SetInCombatWith(unit); if (Player* attackedPlayer = unit->GetCharmerOrOwnerPlayerOrPlayerItself()) { realCaster->SetContestedPvP(attackedPlayer); } break; } } } } else { // for delayed spells ignore negative spells (after duel end) for friendly targets if (speed > 0.0f && !IsPositiveSpell(m_spellInfo->Id)) { realCaster->SendSpellMiss(unit, m_spellInfo->Id, SPELL_MISS_EVADE); ResetEffectDamageAndHeal(); return; } // assisting case, healing and resurrection if (unit->hasUnitState(UNIT_STAT_ATTACK_PLAYER)) { realCaster->SetContestedPvP(); } if (unit->IsInCombat() && !m_spellInfo->HasAttribute(SPELL_ATTR_EX3_NO_INITIAL_AGGRO)) { realCaster->SetInCombatState(unit->GetCombatTimer() > 0); unit->GetHostileRefManager().threatAssist(realCaster, 0.0f, m_spellInfo); } } } // Get Data Needed for Diminishing Returns, some effects may have multiple auras, so this must be done on spell hit, not aura add m_diminishGroup = GetDiminishingReturnsGroupForSpell(m_spellInfo, m_triggeredByAuraSpell); m_diminishLevel = unit->GetDiminishing(m_diminishGroup); // Increase Diminishing on unit, current informations for actually casts will use values above if ((GetDiminishingReturnsGroupType(m_diminishGroup) == DRTYPE_PLAYER && unit->GetTypeId() == TYPEID_PLAYER) || GetDiminishingReturnsGroupType(m_diminishGroup) == DRTYPE_ALL) { unit->IncrDiminishing(m_diminishGroup); } // Apply additional spell effects to target CastPreCastSpells(unit); if (IsSpellAppliesAura(m_spellInfo, effectMask)) { m_spellAuraHolder = CreateSpellAuraHolder(m_spellInfo, unit, realCaster, m_CastItem); m_spellAuraHolder->setDiminishGroup(m_diminishGroup); } else { m_spellAuraHolder = NULL; } for (int effectNumber = 0; effectNumber < MAX_EFFECT_INDEX; ++effectNumber) { if (effectMask & (1 << effectNumber)) { HandleEffects(unit, NULL, NULL, SpellEffectIndex(effectNumber), m_damageMultipliers[effectNumber]); if (m_applyMultiplierMask & (1 << effectNumber)) { // Get multiplier float multiplier = m_spellInfo->DmgMultiplier[effectNumber]; // Apply multiplier mods if (realCaster) if (Player* modOwner = realCaster->GetSpellModOwner()) { modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_EFFECT_PAST_FIRST, multiplier, this); } m_damageMultipliers[effectNumber] *= multiplier; } } } // now apply all created auras if (m_spellAuraHolder) { // normally shouldn't happen if (!m_spellAuraHolder->IsEmptyHolder()) { int32 duration = m_spellAuraHolder->GetAuraMaxDuration(); int32 originalDuration = duration; if (duration > 0) { unit->ApplyDiminishingToDuration(m_diminishGroup, duration, m_caster, m_diminishLevel, isReflected); // Fully diminished if (duration == 0) { delete m_spellAuraHolder; return; } } if (duration != originalDuration) { m_spellAuraHolder->SetAuraMaxDuration(duration); m_spellAuraHolder->SetAuraDuration(duration); } unit->AddSpellAuraHolder(m_spellAuraHolder); } else { delete m_spellAuraHolder; } } } void Spell::DoAllEffectOnTarget(GOTargetInfo* target) { if (target->processed) // Check target { return; } target->processed = true; // Target checked in apply effects procedure uint32 effectMask = target->effectMask; if (!effectMask) { return; } GameObject* go = m_caster->GetMap()->GetGameObject(target->targetGUID); if (!go) { return; } for (int effectNumber = 0; effectNumber < MAX_EFFECT_INDEX; ++effectNumber) if (effectMask & (1 << effectNumber)) { HandleEffects(NULL, NULL, go, SpellEffectIndex(effectNumber)); } // cast at creature (or GO) quest objectives update at successful cast finished (+channel finished) // ignore autorepeat/melee casts for speed (not exist quest for spells (hm... ) if (!IsAutoRepeat() && !IsNextMeleeSwingSpell() && !IsChannelActive()) { if (Player* p = m_caster->GetCharmerOrOwnerPlayerOrPlayerItself()) { p->RewardPlayerAndGroupAtCast(go, m_spellInfo->Id); } } } void Spell::DoAllEffectOnTarget(ItemTargetInfo* target) { uint32 effectMask = target->effectMask; if (!target->item || !effectMask) { return; } for (int effectNumber = 0; effectNumber < MAX_EFFECT_INDEX; ++effectNumber) if (effectMask & (1 << effectNumber)) { HandleEffects(NULL, target->item, NULL, SpellEffectIndex(effectNumber)); } } void Spell::HandleDelayedSpellLaunch(TargetInfo* target) { // Get mask of effects for target uint32 mask = target->effectMask; Unit* unit = m_caster->GetObjectGuid() == target->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, target->targetGUID); if (!unit) { return; } // Get original caster (if exist) and calculate damage/healing from him data Unit* real_caster = GetAffectiveCaster(); // FIXME: in case wild GO heal/damage spells will be used target bonuses Unit* caster = real_caster ? real_caster : m_caster; SpellMissInfo missInfo = target->missCondition; // Need init unitTarget by default unit (can changed in code on reflect) // Or on missInfo!=SPELL_MISS_NONE unitTarget undefined (but need in trigger subsystem) unitTarget = unit; // Reset damage/healing counter m_damage = 0; m_healing = 0; // healing maybe not needed at this point // Fill base damage struct (unitTarget - is real spell target) SpellNonMeleeDamage damageInfo(caster, unitTarget, m_spellInfo->Id, GetFirstSchoolInMask(m_spellSchoolMask)); // keep damage amount for reflected spells if (missInfo == SPELL_MISS_NONE || (missInfo == SPELL_MISS_REFLECT && target->reflectResult == SPELL_MISS_NONE)) { for (int32 effectNumber = 0; effectNumber < MAX_EFFECT_INDEX; ++effectNumber) { if (mask & (1 << effectNumber) && IsEffectHandledOnDelayedSpellLaunch(m_spellInfo, SpellEffectIndex(effectNumber))) { HandleEffects(unit, NULL, NULL, SpellEffectIndex(effectNumber), m_damageMultipliers[effectNumber]); if (m_applyMultiplierMask & (1 << effectNumber)) { // Get multiplier float multiplier = m_spellInfo->DmgMultiplier[effectNumber]; // Apply multiplier mods if (real_caster) if (Player* modOwner = real_caster->GetSpellModOwner()) { modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_EFFECT_PAST_FIRST, multiplier, this); } m_damageMultipliers[effectNumber] *= multiplier; } } } if (m_damage > 0) { caster->CalculateSpellDamage(&damageInfo, m_damage, m_spellInfo, m_attackType); } } target->damage = damageInfo.damage; target->HitInfo = damageInfo.HitInfo; } void Spell::InitializeDamageMultipliers() { for (int32 i = 0; i < MAX_EFFECT_INDEX; ++i) { if (m_spellInfo->Effect[i] == 0) { continue; } uint32 EffectChainTarget = m_spellInfo->EffectChainTarget[i]; if (Unit* realCaster = GetAffectiveCaster()) if (Player* modOwner = realCaster->GetSpellModOwner()) { modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_JUMP_TARGETS, EffectChainTarget, this); } m_damageMultipliers[i] = 1.0f; if ((m_spellInfo->EffectImplicitTargetA[i] == TARGET_CHAIN_DAMAGE || m_spellInfo->EffectImplicitTargetA[i] == TARGET_CHAIN_HEAL) && (EffectChainTarget > 1)) { m_applyMultiplierMask |= (1 << i); } } } bool Spell::IsAliveUnitPresentInTargetList() { // Not need check return true if (m_needAliveTargetMask == 0) { return true; } uint8 needAliveTargetMask = m_needAliveTargetMask; for (TargetList::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit) { if (ihit->missCondition == SPELL_MISS_NONE && (needAliveTargetMask & ihit->effectMask)) { Unit* unit = m_caster->GetObjectGuid() == ihit->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID); // either unit is alive and normal spell, or unit dead and deathonly-spell if (unit && (unit->IsAlive() != IsDeathOnlySpell(m_spellInfo))) { needAliveTargetMask &= ~ihit->effectMask; } // remove from need alive mask effect that have alive target } } // is all effects from m_needAliveTargetMask have alive targets return needAliveTargetMask == 0; } // Helper for Chain Healing // Spell target first // Raidmates then descending by injury suffered (MaxHealth - Health) // Other players/mobs then descending by injury suffered (MaxHealth - Health) struct ChainHealingOrder : public std::binary_function { const Unit* MainTarget; ChainHealingOrder(Unit const* Target) : MainTarget(Target) {}; // functor for operator ">" bool operator()(Unit const* _Left, Unit const* _Right) const { return (ChainHealingHash(_Left) < ChainHealingHash(_Right)); } int32 ChainHealingHash(Unit const* Target) const { if (Target == MainTarget) { return 0; } else if (Target->GetTypeId() == TYPEID_PLAYER && MainTarget->GetTypeId() == TYPEID_PLAYER && ((Player const*)Target)->IsInSameRaidWith((Player const*)MainTarget)) { if (Target->GetHealth() == Target->GetMaxHealth()) { return 40000; } else { return 20000 - Target->GetMaxHealth() + Target->GetHealth(); } } else { return 40000 - Target->GetMaxHealth() + Target->GetHealth(); } } }; class ChainHealingFullHealth: std::unary_function { public: const Unit* MainTarget; ChainHealingFullHealth(const Unit* Target) : MainTarget(Target) {}; bool operator()(const Unit* Target) { return (Target != MainTarget && Target->GetHealth() == Target->GetMaxHealth()); } }; // Helper for targets nearest to the spell target // The spell target is always first unless there is a target at _completely_ the same position (unbelievable case) struct TargetDistanceOrderNear : public std::binary_function { const Unit* MainTarget; TargetDistanceOrderNear(const Unit* Target) : MainTarget(Target) {}; // functor for operator ">" bool operator()(const Unit* _Left, const Unit* _Right) const { return MainTarget->GetDistanceOrder(_Left, _Right); } }; void Spell::SetTargetMap(SpellEffectIndex effIndex, uint32 targetMode, UnitList& targetUnitMap) { float radius; uint32 EffectChainTarget = m_spellInfo->EffectChainTarget[effIndex]; uint32 unMaxTargets = m_spellInfo->MaxAffectedTargets; // Get spell max affected targets GetSpellRangeAndRadius(effIndex, radius, EffectChainTarget, unMaxTargets); std::list tempTargetGOList; switch (targetMode) { case TARGET_TOTEM_EARTH: case TARGET_TOTEM_WATER: case TARGET_TOTEM_AIR: case TARGET_TOTEM_FIRE: { float angle = m_caster->GetOrientation(); switch (targetMode) { case TARGET_TOTEM_FIRE: angle += M_PI_F * 0.25f; break; // front - left case TARGET_TOTEM_AIR: angle += M_PI_F * 0.75f; break; // back - left case TARGET_TOTEM_WATER: angle += M_PI_F * 1.25f; break; // back - right case TARGET_TOTEM_EARTH: angle += M_PI_F * 1.75f; break; // front - right } float x, y; float z = m_caster->GetPositionZ(); // Do not search for a free spot. TODO: Should there be searched for a free spot. There was once a discussion that in case this space was impossible (LOS) m_caster's position should be used. // TODO Bring this back to memory and search for it! m_caster->GetNearPoint2D(x, y, radius, angle); m_caster->UpdateAllowedPositionZ(x, y, z); m_targets.setDestination(x, y, z); // Add Summoner targetUnitMap.push_back(m_caster); break; } case TARGET_SELF: targetUnitMap.push_back(m_caster); break; case TARGET_RANDOM_ENEMY_CHAIN_IN_AREA: case TARGET_RANDOM_FRIEND_CHAIN_IN_AREA: case TARGET_RANDOM_UNIT_CHAIN_IN_AREA: { m_targets.m_targetMask = 0; unMaxTargets = EffectChainTarget; float max_range = radius + unMaxTargets * CHAIN_SPELL_JUMP_RADIUS; UnitList tempTargetUnitMap; switch (targetMode) { case TARGET_RANDOM_ENEMY_CHAIN_IN_AREA: { MaNGOS::AnyAoETargetUnitInObjectRangeCheck u_check(m_caster, max_range); MaNGOS::UnitListSearcher searcher(tempTargetUnitMap, u_check); Cell::VisitAllObjects(m_caster, searcher, max_range); break; } case TARGET_RANDOM_FRIEND_CHAIN_IN_AREA: { MaNGOS::AnyFriendlyUnitInObjectRangeCheck u_check(m_caster, max_range); MaNGOS::UnitListSearcher searcher(tempTargetUnitMap, u_check); Cell::VisitAllObjects(m_caster, searcher, max_range); break; } case TARGET_RANDOM_UNIT_CHAIN_IN_AREA: { MaNGOS::AnyUnitInObjectRangeCheck u_check(m_caster, max_range); MaNGOS::UnitListSearcher searcher(tempTargetUnitMap, u_check); Cell::VisitAllObjects(m_caster, searcher, max_range); break; } } if (tempTargetUnitMap.empty()) { break; } tempTargetUnitMap.sort(TargetDistanceOrderNear(m_caster)); // Now to get us a random target that's in the initial range of the spell uint32 t = 0; UnitList::iterator itr = tempTargetUnitMap.begin(); while (itr != tempTargetUnitMap.end() && (*itr)->IsWithinDist(m_caster, radius)) { ++t, ++itr; } if (!t) { break; } itr = tempTargetUnitMap.begin(); std::advance(itr, rand() % t); Unit* pUnitTarget = *itr; targetUnitMap.push_back(pUnitTarget); tempTargetUnitMap.erase(itr); tempTargetUnitMap.sort(TargetDistanceOrderNear(pUnitTarget)); t = unMaxTargets - 1; Unit* prev = pUnitTarget; UnitList::iterator next = tempTargetUnitMap.begin(); while (t && next != tempTargetUnitMap.end()) { if (!prev->IsWithinDist(*next, CHAIN_SPELL_JUMP_RADIUS)) break; if (!DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, m_spellInfo->Id, NULL, SPELL_DISABLE_LOS) && !prev->IsWithinLOSInMap(*next)) { ++next; continue; } prev = *next; targetUnitMap.push_back(prev); tempTargetUnitMap.erase(next); tempTargetUnitMap.sort(TargetDistanceOrderNear(prev)); next = tempTargetUnitMap.begin(); --t; } break; } case TARGET_PET: { Pet* tmpUnit = m_caster->GetPet(); if (!tmpUnit) { break; } targetUnitMap.push_back(tmpUnit); break; } case TARGET_CHAIN_DAMAGE: { if (EffectChainTarget <= 1) { if (Unit* pUnitTarget = m_caster->SelectMagnetTarget(m_targets.getUnitTarget(), this, effIndex)) { m_targets.setUnitTarget(pUnitTarget); targetUnitMap.push_back(pUnitTarget); } } else { Unit* pUnitTarget = m_targets.getUnitTarget(); WorldObject* originalCaster = GetAffectiveCasterObject(); if (!pUnitTarget || !originalCaster) { break; } unMaxTargets = EffectChainTarget; float max_range; if (m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MELEE) { max_range = radius; } else // FIXME: This very like horrible hack and wrong for most spells { max_range = radius + unMaxTargets * CHAIN_SPELL_JUMP_RADIUS; } UnitList tempTargetUnitMap; { MaNGOS::AnyAoEVisibleTargetUnitInObjectRangeCheck u_check(pUnitTarget, originalCaster, max_range); MaNGOS::UnitListSearcher searcher(tempTargetUnitMap, u_check); Cell::VisitAllObjects(m_caster, searcher, max_range); } if (tempTargetUnitMap.empty()) { break; } tempTargetUnitMap.sort(TargetDistanceOrderNear(pUnitTarget)); if (*tempTargetUnitMap.begin() == pUnitTarget) { tempTargetUnitMap.erase(tempTargetUnitMap.begin()); } targetUnitMap.push_back(pUnitTarget); uint32 t = unMaxTargets - 1; Unit* prev = pUnitTarget; UnitList::iterator next = tempTargetUnitMap.begin(); while (t && next != tempTargetUnitMap.end()) { if (!prev->IsWithinDist(*next, CHAIN_SPELL_JUMP_RADIUS)) { break; } if (!DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, m_spellInfo->Id, NULL, SPELL_DISABLE_LOS) && !prev->IsWithinLOSInMap(*next)) { ++next; continue; } prev = *next; targetUnitMap.push_back(prev); tempTargetUnitMap.erase(next); tempTargetUnitMap.sort(TargetDistanceOrderNear(prev)); next = tempTargetUnitMap.begin(); --t; } } break; } case TARGET_ALL_ENEMY_IN_AREA: FillAreaTargets(targetUnitMap, radius, PUSH_DEST_CENTER, SPELL_TARGETS_AOE_DAMAGE); break; case TARGET_AREAEFFECT_INSTANT: { SpellTargets targetB = SPELL_TARGETS_AOE_DAMAGE; switch (m_spellInfo->Effect[effIndex]) { case SPELL_EFFECT_QUEST_COMPLETE: targetB = SPELL_TARGETS_ALL; break; default: // Select friendly targets for positive effect if (IsPositiveEffect(m_spellInfo, effIndex)) targetB = SPELL_TARGETS_FRIENDLY; break; } UnitList tempTargetUnitMap; SQLMultiStorage::SQLMSIteratorBounds bounds = sSpellScriptTargetStorage.getBounds(m_spellInfo->Id); // fill real target list if no spell script target defined FillAreaTargets(bounds.first != bounds.second ? tempTargetUnitMap : targetUnitMap, radius, PUSH_DEST_CENTER, bounds.first != bounds.second ? SPELL_TARGETS_ALL : targetB); if (!tempTargetUnitMap.empty()) { for (UnitList::const_iterator iter = tempTargetUnitMap.begin(); iter != tempTargetUnitMap.end(); ++iter) { if ((*iter)->GetTypeId() != TYPEID_UNIT) { continue; } for (SQLMultiStorage::SQLMultiSIterator i_spellST = bounds.first; i_spellST != bounds.second; ++i_spellST) { if (i_spellST->CanNotHitWithSpellEffect(effIndex)) { continue; } // only creature entries supported for this target type if (i_spellST->type == SPELL_TARGET_TYPE_GAMEOBJECT) { continue; } if ((*iter)->GetEntry() == i_spellST->targetEntry) { if (i_spellST->type == SPELL_TARGET_TYPE_DEAD && ((Creature*)(*iter))->IsCorpse()) { targetUnitMap.push_back((*iter)); } else if (i_spellST->type == SPELL_TARGET_TYPE_CREATURE && (*iter)->IsAlive()) { targetUnitMap.push_back((*iter)); } break; } } } } break; } case TARGET_AREAEFFECT_CUSTOM: { if (m_spellInfo->Effect[effIndex] == SPELL_EFFECT_PERSISTENT_AREA_AURA) { break; } else if (m_spellInfo->Effect[effIndex] == SPELL_EFFECT_SUMMON) { targetUnitMap.push_back(m_caster); break; } UnitList tempTargetUnitMap; SQLMultiStorage::SQLMSIteratorBounds bounds = sSpellScriptTargetStorage.getBounds(m_spellInfo->Id); // fill real target list if no spell script target defined FillAreaTargets(bounds.first != bounds.second ? tempTargetUnitMap : targetUnitMap, radius, PUSH_DEST_CENTER, SPELL_TARGETS_ALL); if (!tempTargetUnitMap.empty()) { for (UnitList::const_iterator iter = tempTargetUnitMap.begin(); iter != tempTargetUnitMap.end(); ++iter) { if ((*iter)->GetTypeId() != TYPEID_UNIT) { continue; } for (SQLMultiStorage::SQLMultiSIterator i_spellST = bounds.first; i_spellST != bounds.second; ++i_spellST) { if (i_spellST->CanNotHitWithSpellEffect(effIndex)) { continue; } // only creature entries supported for this target type if (i_spellST->type == SPELL_TARGET_TYPE_GAMEOBJECT) { continue; } if ((*iter)->GetEntry() == i_spellST->targetEntry) { if (i_spellST->type == SPELL_TARGET_TYPE_DEAD && ((Creature*)(*iter))->IsCorpse()) { targetUnitMap.push_back((*iter)); } else if (i_spellST->type == SPELL_TARGET_TYPE_CREATURE && (*iter)->IsAlive()) { targetUnitMap.push_back((*iter)); } break; } } } } else { // remove not targetable units if spell has no script targets for (UnitList::iterator itr = targetUnitMap.begin(); itr != targetUnitMap.end();) { if (!(*itr)->IsTargetableForAttack(m_spellInfo->HasAttribute(SPELL_ATTR_EX3_CAST_ON_DEAD))) { targetUnitMap.erase(itr++); } else { ++itr; } } } break; } case TARGET_AREAEFFECT_GO_AROUND_SOURCE: case TARGET_AREAEFFECT_GO_AROUND_DEST: { float x, y, z; if (targetMode == TARGET_AREAEFFECT_GO_AROUND_SOURCE) { if (m_targets.m_targetMask & TARGET_FLAG_SOURCE_LOCATION) { m_targets.getSource(x, y, z); } else { m_caster->GetPosition(x, y, z); } } else { m_targets.getDestination(x, y, z); } // It may be possible to fill targets for some spell effects // automatically (SPELL_EFFECT_WMO_REPAIR(88) for example) but // for some/most spells we clearly need/want to limit with spell_target_script // Some spells untested, for affected GO type 33. May need further adjustments for spells related. SQLMultiStorage::SQLMSIteratorBounds bounds = sSpellScriptTargetStorage.getBounds(m_spellInfo->Id); for (SQLMultiStorage::SQLMultiSIterator i_spellST = bounds.first; i_spellST != bounds.second; ++i_spellST) { if (i_spellST->CanNotHitWithSpellEffect(effIndex)) { continue; } if (i_spellST->type == SPELL_TARGET_TYPE_GAMEOBJECT) { // search all GO's with entry, within range of m_destN MaNGOS::GameObjectEntryInPosRangeCheck go_check(*m_caster, i_spellST->targetEntry, x, y, z, radius); MaNGOS::GameObjectListSearcher checker(tempTargetGOList, go_check); Cell::VisitGridObjects(m_caster, checker, radius); } } break; } case TARGET_ALL_ENEMY_IN_AREA_INSTANT: { // targets the ground, not the units in the area switch (m_spellInfo->Effect[effIndex]) { case SPELL_EFFECT_PERSISTENT_AREA_AURA: break; case SPELL_EFFECT_SUMMON: targetUnitMap.push_back(m_caster); break; default: FillAreaTargets(targetUnitMap, radius, PUSH_DEST_CENTER, SPELL_TARGETS_AOE_DAMAGE); break; } break; } case TARGET_DUELVSPLAYER_COORDINATES: { if (Unit* currentTarget = m_targets.getUnitTarget()) { m_targets.setDestination(currentTarget->GetPositionX(), currentTarget->GetPositionY(), currentTarget->GetPositionZ()); } break; } case TARGET_ALL_PARTY_AROUND_CASTER: case TARGET_ALL_PARTY_AROUND_CASTER_2: case TARGET_ALL_PARTY: { FillRaidOrPartyTargets(targetUnitMap, m_caster, radius, false, true, true); break; } case TARGET_ALL_RAID_AROUND_CASTER: { FillRaidOrPartyTargets(targetUnitMap, m_caster, radius, true, true, false); break; } case TARGET_SINGLE_FRIEND: case TARGET_SINGLE_FRIEND_2: if (m_targets.getUnitTarget()) { targetUnitMap.push_back(m_targets.getUnitTarget()); } break; case TARGET_CASTER_COORDINATES: { // Check original caster is GO - set its coordinates as src cast if (WorldObject* caster = GetCastingObject()) { m_targets.setSource(caster->GetPositionX(), caster->GetPositionY(), caster->GetPositionZ()); } break; } case TARGET_ALL_HOSTILE_UNITS_AROUND_CASTER: FillAreaTargets(targetUnitMap, radius, PUSH_SELF_CENTER, SPELL_TARGETS_HOSTILE); break; case TARGET_ALL_FRIENDLY_UNITS_AROUND_CASTER: // selected friendly units (for casting objects) around casting object FillAreaTargets(targetUnitMap, radius, PUSH_SELF_CENTER, SPELL_TARGETS_FRIENDLY, GetCastingObject()); break; case TARGET_ALL_FRIENDLY_UNITS_IN_AREA: FillAreaTargets(targetUnitMap, radius, PUSH_DEST_CENTER, SPELL_TARGETS_FRIENDLY); break; // 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..) case TARGET_SINGLE_PARTY: { Unit* target = m_targets.getUnitTarget(); // Those spells apparently can't be casted on the caster. if (target && target != m_caster) { // Can only be casted on group's members or its pets Group* pGroup = NULL; Unit* owner = m_caster->GetCharmerOrOwner(); Unit* targetOwner = target->GetCharmerOrOwner(); if (owner) { if (owner->GetTypeId() == TYPEID_PLAYER) { if (target == owner) { targetUnitMap.push_back(target); break; } pGroup = ((Player*)owner)->GetGroup(); } } else if (m_caster->GetTypeId() == TYPEID_PLAYER) { if (targetOwner == m_caster && target->GetTypeId() == TYPEID_UNIT && ((Creature*)target)->IsPet()) { targetUnitMap.push_back(target); break; } pGroup = ((Player*)m_caster)->GetGroup(); } if (pGroup) { // Our target can also be a player's pet who's grouped with us or our pet. But can't be controlled player if (targetOwner) { if (targetOwner->GetTypeId() == TYPEID_PLAYER && target->GetTypeId() == TYPEID_UNIT && (((Creature*)target)->IsPet()) && target->GetOwnerGuid() == targetOwner->GetObjectGuid() && pGroup->IsMember(((Player*)targetOwner)->GetObjectGuid())) { targetUnitMap.push_back(target); } } // 1Our target can be a player who is on our group else if (target->GetTypeId() == TYPEID_PLAYER && pGroup->IsMember(((Player*)target)->GetObjectGuid())) { targetUnitMap.push_back(target); } } } break; } case TARGET_GAMEOBJECT: if (m_targets.getGOTarget()) { AddGOTarget(m_targets.getGOTarget(), effIndex); } break; case TARGET_IN_FRONT_OF_CASTER: { SpellNotifyPushType pushType = PUSH_IN_FRONT; switch (m_spellInfo->SpellVisual) // Some spell require a different target fill { case 3879: pushType = PUSH_IN_BACK; break; case 7441: pushType = PUSH_IN_FRONT_15; break; } FillAreaTargets(targetUnitMap, radius, pushType, SPELL_TARGETS_AOE_DAMAGE); break; } case TARGET_LARGE_FRONTAL_CONE: FillAreaTargets(targetUnitMap, radius, PUSH_IN_FRONT_90, SPELL_TARGETS_AOE_DAMAGE); break; case TARGET_NARROW_FRONTAL_CONE: { SpellTargets targetB = SPELL_TARGETS_AOE_DAMAGE; if (m_spellInfo->Effect[effIndex] == SPELL_EFFECT_SCRIPT_EFFECT) targetB = SPELL_TARGETS_ALL; UnitList tempTargetUnitMap; SQLMultiStorage::SQLMSIteratorBounds bounds = sSpellScriptTargetStorage.getBounds(m_spellInfo->Id); // fill real target list if no spell script target defined FillAreaTargets(bounds.first != bounds.second ? tempTargetUnitMap : targetUnitMap, radius, PUSH_IN_FRONT_15, bounds.first != bounds.second ? SPELL_TARGETS_ALL : targetB); if (!tempTargetUnitMap.empty()) { for (UnitList::const_iterator iter = tempTargetUnitMap.begin(); iter != tempTargetUnitMap.end(); ++iter) { if ((*iter)->GetTypeId() != TYPEID_UNIT) continue; for (SQLMultiStorage::SQLMultiSIterator i_spellST = bounds.first; i_spellST != bounds.second; ++i_spellST) { if (i_spellST->CanNotHitWithSpellEffect(effIndex)) continue; // only creature entries supported for this target type if (i_spellST->type == SPELL_TARGET_TYPE_GAMEOBJECT) continue; if ((*iter)->GetEntry() == i_spellST->targetEntry) { if (i_spellST->type == SPELL_TARGET_TYPE_DEAD && ((Creature*)(*iter))->IsCorpse()) { targetUnitMap.push_back((*iter)); } else if (i_spellST->type == SPELL_TARGET_TYPE_CREATURE && (*iter)->IsAlive()) { targetUnitMap.push_back((*iter)); } break; } } } } break; } case TARGET_DUELVSPLAYER: { if (Unit* target = m_targets.getUnitTarget()) { if (m_caster->IsFriendlyTo(target)) { targetUnitMap.push_back(target); } else { if (Unit* pUnitTarget = m_caster->SelectMagnetTarget(target, this, effIndex)) { if (target != pUnitTarget) { m_targets.setUnitTarget(pUnitTarget); } targetUnitMap.push_back(pUnitTarget); } } } break; } case TARGET_GAMEOBJECT_ITEM: if (m_targets.getGOTargetGuid()) { AddGOTarget(m_targets.getGOTarget(), effIndex); } else if (m_targets.getItemTarget()) { AddItemTarget(m_targets.getItemTarget(), effIndex); } break; case TARGET_MASTER: if (Unit* owner = m_caster->GetCharmerOrOwner()) { targetUnitMap.push_back(owner); } break; case TARGET_ALL_ENEMY_IN_AREA_CHANNELED: // targets the ground, not the units in the area if (m_spellInfo->Effect[effIndex] != SPELL_EFFECT_PERSISTENT_AREA_AURA) { FillAreaTargets(targetUnitMap, radius, PUSH_DEST_CENTER, SPELL_TARGETS_AOE_DAMAGE); } break; case TARGET_MINION: if (m_spellInfo->Effect[effIndex] != SPELL_EFFECT_DUEL) { targetUnitMap.push_back(m_caster); } break; case TARGET_AREAEFFECT_PARTY: { Unit* owner = m_caster->GetCharmerOrOwner(); Player* pTarget = NULL; if (owner) { targetUnitMap.push_back(m_caster); if (owner->GetTypeId() == TYPEID_PLAYER) { pTarget = (Player*)owner; } } else if (m_caster->GetTypeId() == TYPEID_PLAYER) { if (Unit* target = m_targets.getUnitTarget()) { if (target->GetTypeId() != TYPEID_PLAYER) { if (((Creature*)target)->IsPet()) { Unit* targetOwner = target->GetOwner(); if (targetOwner->GetTypeId() == TYPEID_PLAYER) { pTarget = (Player*)targetOwner; } } } else { pTarget = (Player*)target; } } } Group* pGroup = pTarget ? pTarget->GetGroup() : NULL; if (pGroup) { uint8 subgroup = pTarget->GetSubGroup(); for (GroupReference* itr = pGroup->GetFirstMember(); itr != NULL; itr = itr->next()) { Player* Target = itr->getSource(); // IsHostileTo check duel and controlled by enemy if (Target && Target->GetSubGroup() == subgroup && !m_caster->IsHostileTo(Target)) { if (pTarget->IsWithinDistInMap(Target, radius)) { targetUnitMap.push_back(Target); } if (Pet* pet = Target->GetPet()) if (pTarget->IsWithinDistInMap(pet, radius)) { targetUnitMap.push_back(pet); } } } } else if (owner) { if (m_caster->IsWithinDistInMap(owner, radius)) { targetUnitMap.push_back(owner); } } else if (pTarget) { targetUnitMap.push_back(pTarget); if (Pet* pet = pTarget->GetPet()) if (m_caster->IsWithinDistInMap(pet, radius)) { targetUnitMap.push_back(pet); } } break; } case TARGET_SCRIPT: { if (m_targets.getUnitTarget()) { targetUnitMap.push_back(m_targets.getUnitTarget()); } if (m_targets.getItemTarget()) { AddItemTarget(m_targets.getItemTarget(), effIndex); } break; } case TARGET_SELF_FISHING: targetUnitMap.push_back(m_caster); break; case TARGET_CHAIN_HEAL: { Unit* pUnitTarget = m_targets.getUnitTarget(); if (!pUnitTarget) { break; } if (EffectChainTarget <= 1) { targetUnitMap.push_back(pUnitTarget); } else { unMaxTargets = EffectChainTarget; float max_range = radius + unMaxTargets * CHAIN_SPELL_JUMP_RADIUS; UnitList tempTargetUnitMap; FillAreaTargets(tempTargetUnitMap, max_range, PUSH_SELF_CENTER, SPELL_TARGETS_FRIENDLY); if (m_caster != pUnitTarget && std::find(tempTargetUnitMap.begin(), tempTargetUnitMap.end(), m_caster) == tempTargetUnitMap.end()) { tempTargetUnitMap.push_front(m_caster); } tempTargetUnitMap.sort(TargetDistanceOrderNear(pUnitTarget)); if (tempTargetUnitMap.empty()) { break; } if (*tempTargetUnitMap.begin() == pUnitTarget) { tempTargetUnitMap.erase(tempTargetUnitMap.begin()); } targetUnitMap.push_back(pUnitTarget); uint32 t = unMaxTargets - 1; Unit* prev = pUnitTarget; UnitList::iterator next = tempTargetUnitMap.begin(); while (t && next != tempTargetUnitMap.end()) { if (!prev->IsWithinDist(*next, CHAIN_SPELL_JUMP_RADIUS)) { break; } if (!DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, m_spellInfo->Id, NULL, SPELL_DISABLE_LOS) && !prev->IsWithinLOSInMap(*next)) { ++next; continue; } if ((*next)->GetHealth() == (*next)->GetMaxHealth()) { next = tempTargetUnitMap.erase(next); continue; } prev = *next; targetUnitMap.push_back(prev); tempTargetUnitMap.erase(next); tempTargetUnitMap.sort(TargetDistanceOrderNear(prev)); next = tempTargetUnitMap.begin(); --t; } } break; } case TARGET_CURRENT_ENEMY_COORDINATES: { Unit* currentTarget = m_targets.getUnitTarget(); if (currentTarget) { targetUnitMap.push_back(currentTarget); m_targets.setDestination(currentTarget->GetPositionX(), currentTarget->GetPositionY(), currentTarget->GetPositionZ()); } break; } case TARGET_AREAEFFECT_PARTY_AND_CLASS: { Player* targetPlayer = m_targets.getUnitTarget() && m_targets.getUnitTarget()->GetTypeId() == TYPEID_PLAYER ? (Player*)m_targets.getUnitTarget() : NULL; Group* pGroup = targetPlayer ? targetPlayer->GetGroup() : NULL; if (pGroup) { for (GroupReference* itr = pGroup->GetFirstMember(); itr != NULL; itr = itr->next()) { Player* Target = itr->getSource(); // IsHostileTo check duel and controlled by enemy if (Target && targetPlayer->IsWithinDistInMap(Target, radius) && targetPlayer->getClass() == Target->getClass() && !m_caster->IsHostileTo(Target)) { targetUnitMap.push_back(Target); } } } else if (m_targets.getUnitTarget()) { targetUnitMap.push_back(m_targets.getUnitTarget()); } break; } case TARGET_TABLE_X_Y_Z_COORDINATES: { if (SpellTargetPosition const* st = sSpellMgr.GetSpellTargetPosition(m_spellInfo->Id)) { m_targets.setDestination(st->target_X, st->target_Y, st->target_Z); // TODO - maybe use an (internal) value for the map for neat far teleport handling // far-teleport spells are handled in SpellEffect, elsewise report an error about an unexpected map (spells are always locally) if (st->target_mapId != m_caster->GetMapId() && m_spellInfo->Effect[effIndex] != SPELL_EFFECT_TELEPORT_UNITS) { sLog.outError("SPELL: wrong map (%u instead %u) target coordinates for spell ID %u", st->target_mapId, m_caster->GetMapId(), m_spellInfo->Id); } } else { sLog.outError("SPELL: unknown target coordinates for spell ID %u", m_spellInfo->Id); } break; } case TARGET_DYNAMIC_OBJECT_FRONT: case TARGET_DYNAMIC_OBJECT_BEHIND: case TARGET_DYNAMIC_OBJECT_LEFT_SIDE: case TARGET_DYNAMIC_OBJECT_RIGHT_SIDE: { if (!(m_targets.m_targetMask & TARGET_FLAG_DEST_LOCATION)) { // General override, we don't want to use max spell range here. // Note: 0.0 radius is also for index 36. It is possible that 36 must be defined as // "at the base of", in difference to 0 which appear to be "directly in front of". // TODO: some summoned will make caster be half inside summoned object. Need to fix // that in the below code (nearpoint vs closepoint, etc). if (m_spellInfo->EffectRadiusIndex[effIndex] == 0) { radius = 0.0f; } float angle = m_caster->GetOrientation(); switch (targetMode) { case TARGET_DYNAMIC_OBJECT_FRONT: break; case TARGET_DYNAMIC_OBJECT_BEHIND: angle += M_PI_F; break; case TARGET_DYNAMIC_OBJECT_LEFT_SIDE: angle += M_PI_F / 2; break; case TARGET_DYNAMIC_OBJECT_RIGHT_SIDE: angle -= M_PI_F / 2; break; } float x, y; m_caster->GetNearPoint2D(x, y, radius + m_caster->GetObjectBoundingRadius(), angle); m_targets.setDestination(x, y, m_caster->GetPositionZ()); } targetUnitMap.push_back(m_caster); break; } case TARGET_EFFECT_SELECT: { // add here custom effects that need default target. // FOR EVERY TARGET TYPE THERE IS A DIFFERENT FILL!! switch (m_spellInfo->Effect[effIndex]) { case SPELL_EFFECT_DUMMY: { switch (m_spellInfo->Id) { case 20577: // Cannibalize { WorldObject* result = FindCorpseUsing (); if (result) { switch (result->GetTypeId()) { case TYPEID_UNIT: case TYPEID_PLAYER: targetUnitMap.push_back((Unit*)result); break; case TYPEID_CORPSE: m_targets.setCorpseTarget((Corpse*)result); if (Player* owner = ObjectAccessor::FindPlayer(((Corpse*)result)->GetOwnerGuid())) { targetUnitMap.push_back(owner); } break; } } else { // clear cooldown at fail if (m_caster->GetTypeId() == TYPEID_PLAYER) { ((Player*)m_caster)->RemoveSpellCooldown(m_spellInfo->Id, true); } SendCastResult(SPELL_FAILED_NO_EDIBLE_CORPSES); finish(false); } break; } default: if (m_targets.getUnitTarget()) { targetUnitMap.push_back(m_targets.getUnitTarget()); } break; } // Add AoE target-mask to self, if no target-dest provided already if ((m_targets.m_targetMask & TARGET_FLAG_DEST_LOCATION) == 0) { m_targets.setDestination(m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ()); } break; } case SPELL_EFFECT_BIND: case SPELL_EFFECT_RESURRECT: case SPELL_EFFECT_PARRY: case SPELL_EFFECT_BLOCK: case SPELL_EFFECT_CREATE_ITEM: case SPELL_EFFECT_WEAPON: case SPELL_EFFECT_TRIGGER_SPELL: case SPELL_EFFECT_TRIGGER_MISSILE: case SPELL_EFFECT_LEARN_SPELL: case SPELL_EFFECT_SKILL_STEP: case SPELL_EFFECT_PROFICIENCY: case SPELL_EFFECT_SUMMON_POSSESSED: case SPELL_EFFECT_SUMMON_OBJECT_WILD: case SPELL_EFFECT_SELF_RESURRECT: case SPELL_EFFECT_REPUTATION: case SPELL_EFFECT_ADD_HONOR: case SPELL_EFFECT_SEND_TAXI: if (m_targets.getUnitTarget()) { targetUnitMap.push_back(m_targets.getUnitTarget()); } // Triggered spells have additional spell targets - cast them even if no explicit unit target is given (required for spell 50516 for example) else if (m_spellInfo->Effect[effIndex] == SPELL_EFFECT_TRIGGER_SPELL) { targetUnitMap.push_back(m_caster); } break; case SPELL_EFFECT_SUMMON_PLAYER: if (m_caster->GetTypeId() == TYPEID_PLAYER && ((Player*)m_caster)->GetSelectionGuid()) if (Player* target = sObjectMgr.GetPlayer(((Player*)m_caster)->GetSelectionGuid())) { targetUnitMap.push_back(target); } break; case SPELL_EFFECT_RESURRECT_NEW: if (m_targets.getUnitTarget()) { targetUnitMap.push_back(m_targets.getUnitTarget()); } if (m_targets.getCorpseTargetGuid()) { if (Corpse* corpse = m_caster->GetMap()->GetCorpse(m_targets.getCorpseTargetGuid())) if (Player* owner = ObjectAccessor::FindPlayer(corpse->GetOwnerGuid())) { targetUnitMap.push_back(owner); } } break; case SPELL_EFFECT_TELEPORT_UNITS: case SPELL_EFFECT_SUMMON: /*[-ZERO] if (m_spellInfo->EffectMiscValueB[effIndex] == SUMMON_TYPE_POSESSED || m_spellInfo->EffectMiscValueB[effIndex] == SUMMON_TYPE_POSESSED2) { if(m_targets.getUnitTarget()) targetUnitMap.push_back(m_targets.getUnitTarget()); } else */ targetUnitMap.push_back(m_caster); break; case SPELL_EFFECT_SUMMON_CHANGE_ITEM: case SPELL_EFFECT_SUMMON_WILD: case SPELL_EFFECT_SUMMON_GUARDIAN: case SPELL_EFFECT_TRANS_DOOR: case SPELL_EFFECT_ADD_FARSIGHT: case SPELL_EFFECT_STUCK: case SPELL_EFFECT_DESTROY_ALL_TOTEMS: case SPELL_EFFECT_SUMMON_DEMON: case SPELL_EFFECT_SKILL: targetUnitMap.push_back(m_caster); break; case SPELL_EFFECT_PERSISTENT_AREA_AURA: if (Unit* currentTarget = m_targets.getUnitTarget()) { m_targets.setDestination(currentTarget->GetPositionX(), currentTarget->GetPositionY(), currentTarget->GetPositionZ()); } break; case SPELL_EFFECT_LEARN_PET_SPELL: if (Pet* pet = m_caster->GetPet()) { targetUnitMap.push_back(pet); } break; case SPELL_EFFECT_ENCHANT_ITEM: case SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY: case SPELL_EFFECT_DISENCHANT: case SPELL_EFFECT_FEED_PET: if (m_targets.getItemTarget()) { AddItemTarget(m_targets.getItemTarget(), effIndex); } break; case SPELL_EFFECT_APPLY_AURA: switch (m_spellInfo->EffectApplyAuraName[effIndex]) { 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) case SPELL_AURA_ADD_PCT_MODIFIER: targetUnitMap.push_back(m_caster); break; default: // apply to target in other case if (m_targets.getUnitTarget()) { targetUnitMap.push_back(m_targets.getUnitTarget()); } break; } break; case SPELL_EFFECT_APPLY_AREA_AURA_PARTY: // AreaAura if ((m_spellInfo->Attributes == (SPELL_ATTR_NOT_SHAPESHIFT | SPELL_ATTR_UNK18 | SPELL_ATTR_CASTABLE_WHILE_MOUNTED | SPELL_ATTR_CASTABLE_WHILE_SITTING)) || (m_spellInfo->Attributes == SPELL_ATTR_NOT_SHAPESHIFT)) { SetTargetMap(effIndex, TARGET_AREAEFFECT_PARTY, targetUnitMap); } break; case SPELL_EFFECT_SKIN_PLAYER_CORPSE: if (m_targets.getUnitTarget()) { targetUnitMap.push_back(m_targets.getUnitTarget()); } else if (m_targets.getCorpseTargetGuid()) { if (Corpse* corpse = m_caster->GetMap()->GetCorpse(m_targets.getCorpseTargetGuid())) if (Player* owner = ObjectAccessor::FindPlayer(corpse->GetOwnerGuid())) { targetUnitMap.push_back(owner); } } break; default: break; } break; } default: // sLog.outError( "SPELL: Unknown implicit target (%u) for spell ID %u", targetMode, m_spellInfo->Id ); break; } if (targetMode != TARGET_SELF && m_spellInfo->HasAttribute(SPELL_ATTR_EX_CANT_TARGET_SELF)) { targetUnitMap.remove(m_caster); } if (unMaxTargets && targetUnitMap.size() > unMaxTargets) { // make sure one unit is always removed per iteration uint32 removed_utarget = 0; for (UnitList::iterator itr = targetUnitMap.begin(), next; itr != targetUnitMap.end(); itr = next) { next = itr; ++next; if (!*itr) { continue; } if ((*itr) == m_targets.getUnitTarget()) { targetUnitMap.erase(itr); removed_utarget = 1; // break; } } // remove random units from the map while (targetUnitMap.size() > unMaxTargets - removed_utarget) { uint32 poz = urand(0, targetUnitMap.size() - 1); for (UnitList::iterator itr = targetUnitMap.begin(); itr != targetUnitMap.end(); ++itr, --poz) { if (!*itr) { continue; } if (!poz) { targetUnitMap.erase(itr); break; } } } // the player's target will always be added to the map if (removed_utarget && m_targets.getUnitTarget()) { targetUnitMap.push_back(m_targets.getUnitTarget()); } } if (!tempTargetGOList.empty()) // GO CASE { if (unMaxTargets && tempTargetGOList.size() > unMaxTargets) { // make sure one go is always removed per iteration uint32 removed_utarget = 0; for (std::list::iterator itr = tempTargetGOList.begin(), next; itr != tempTargetGOList.end(); itr = next) { next = itr; ++next; if (!*itr) { continue; } if ((*itr) == m_targets.getGOTarget()) { tempTargetGOList.erase(itr); removed_utarget = 1; // break; } } // remove random units from the map while (tempTargetGOList.size() > unMaxTargets - removed_utarget) { uint32 poz = urand(0, tempTargetGOList.size() - 1); for (std::list::iterator itr = tempTargetGOList.begin(); itr != tempTargetGOList.end(); ++itr, --poz) { if (!*itr) { continue; } if (!poz) { tempTargetGOList.erase(itr); break; } } } } // Add resulting GOs as GOTargets for (std::list::iterator iter = tempTargetGOList.begin(); iter != tempTargetGOList.end(); ++iter) { AddGOTarget(*iter, effIndex); } } } void Spell::prepare(SpellCastTargets const* targets, Aura* triggeredByAura) { m_targets = *targets; m_spellState = SPELL_STATE_PREPARING; m_castPositionX = m_caster->GetPositionX(); m_castPositionY = m_caster->GetPositionY(); m_castPositionZ = m_caster->GetPositionZ(); m_castOrientation = m_caster->GetOrientation(); if (triggeredByAura) { m_triggeredByAuraSpell = triggeredByAura->GetSpellProto(); } // create and add update event for this spell SpellEvent* Event = new SpellEvent(this); m_caster->m_Events.AddEvent(Event, m_caster->m_Events.CalculateTime(1)); // Prevent casting at cast another spell (ServerSide check) if (!m_IsTriggeredSpell && m_caster->IsNonMeleeSpellCasted(false, true, true)) { SendCastResult(SPELL_FAILED_SPELL_IN_PROGRESS); finish(false); return; } if (DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, m_spellInfo->Id, m_caster)) { SendCastResult(SPELL_FAILED_SPELL_UNAVAILABLE); finish(false); return; } // Fill cost data m_powerCost = CalculatePowerCost(m_spellInfo, m_caster, this, m_CastItem); SpellCastResult result = CheckCast(true); if (result != SPELL_CAST_OK && !IsAutoRepeat()) // always cast autorepeat dummy for triggering { if (triggeredByAura) { SendChannelUpdate(0); triggeredByAura->GetHolder()->SetAuraDuration(0); } SendCastResult(result); finish(false); return; } // Prepare data for triggers prepareDataForTriggerSystem(); // calculate cast time (calculated after first CheckCast check to prevent charge counting for first CheckCast fail) m_casttime = GetSpellCastTime(m_spellInfo, this); m_duration = CalculateSpellDuration(m_spellInfo, m_caster); // set timer base at cast time ReSetTimer(); // stealth must be removed at cast starting (at show channel bar) // skip triggered spell (item equip spell casting and other not explicit character casts/item uses) if (!m_IsTriggeredSpell && isSpellBreakStealth(m_spellInfo)) { // Sap - don't exit Stealth yet to prevent getting in combat and making Sap impossible to cast // Removing Stealth depends on talent later // Pick Pocket - don't exit Stealth at all if (!(m_spellInfo->SpellFamilyName == SPELLFAMILY_ROGUE && (m_spellInfo->SpellFamilyFlags & UI64LIT(0x00000080) || m_spellInfo->SpellFamilyFlags & 2147483648))) m_caster->RemoveSpellsCausingAura(SPELL_AURA_MOD_STEALTH); m_caster->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH); } // add non-triggered (with cast time and without) if (!m_IsTriggeredSpell) { // add to cast type slot m_caster->SetCurrentCastedSpell(this); // will show cast bar SendSpellStart(); TriggerGlobalCooldown(); } else { if (m_timer == 0) cast(true); } } void Spell::cancel() { if (m_spellState == SPELL_STATE_FINISHED) { return; } // channeled spells don't display interrupted message even if they are interrupted, possible other cases with no "Interrupted" message bool sendInterrupt = IsChanneledSpell(m_spellInfo) ? false : true; m_autoRepeat = false; switch (m_spellState) { case SPELL_STATE_PREPARING: CancelGlobalCooldown(); //(no break) case SPELL_STATE_DELAYED: { SendInterrupted(0); if (sendInterrupt) { SendCastResult(SPELL_FAILED_INTERRUPTED); } } break; case SPELL_STATE_CASTING: { for (TargetList::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit) { if (ihit->missCondition == SPELL_MISS_NONE) { Unit* unit = m_caster->GetObjectGuid() == (*ihit).targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID); if (unit && unit->IsAlive()) { unit->RemoveAurasByCasterSpell(m_spellInfo->Id, m_caster->GetObjectGuid()); } } } SendChannelUpdate(0); SendInterrupted(0); if (sendInterrupt) { SendCastResult(SPELL_FAILED_INTERRUPTED); } } break; default: { } break; } finish(false); m_caster->RemoveDynObject(m_spellInfo->Id); m_caster->RemoveGameObject(m_spellInfo->Id, true); } void Spell::cast(bool skipCheck) { SetExecutedCurrently(true); if (!m_caster->CheckAndIncreaseCastCounter()) { if (m_triggeredByAuraSpell) { 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); } else { sLog.outError("Spell %u too deep in cast chain for cast. Cast not allowed for prevent overflow stack crash.", m_spellInfo->Id); } SendCastResult(SPELL_FAILED_ERROR); finish(false); SetExecutedCurrently(false); return; } // update pointers base at GUIDs to prevent access to already nonexistent object UpdatePointers(); // cancel at lost main target unit if (!m_targets.getUnitTarget() && m_targets.getUnitTargetGuid() && m_targets.getUnitTargetGuid() != m_caster->GetObjectGuid()) { cancel(); m_caster->DecreaseCastCounter(); SetExecutedCurrently(false); return; } if (m_caster->GetTypeId() != TYPEID_PLAYER && m_targets.getUnitTarget() && m_targets.getUnitTarget() != m_caster) { m_caster->SetInFront(m_targets.getUnitTarget()); } SpellCastResult castResult = CheckPower(); if (castResult != SPELL_CAST_OK) { SendCastResult(castResult); finish(false); m_caster->DecreaseCastCounter(); SetExecutedCurrently(false); return; } // triggered cast called from Spell::prepare where it was already checked if (!skipCheck) { castResult = CheckCast(false); if (castResult != SPELL_CAST_OK) { SendCastResult(castResult); finish(false); m_caster->DecreaseCastCounter(); SetExecutedCurrently(false); return; } } // different triggered (for caster) and pre-cast (casted before apply effect to each target) cases switch (m_spellInfo->SpellFamilyName) { case SPELLFAMILY_GENERIC: { // Bandages if (m_spellInfo->Mechanic == MECHANIC_BANDAGE) { AddPrecastSpell(11196); } // Recently Bandaged // Divine Shield, Divine Protection (Blessing of Protection in paladin switch case) else if (m_spellInfo->Mechanic == MECHANIC_INVULNERABILITY) { AddPrecastSpell(25771); } // Forbearance break; } case SPELLFAMILY_ROGUE: { // exit stealth on sap when improved sap is not skilled if (m_spellInfo->SpellFamilyFlags & UI64LIT(0x00000080) && m_caster->GetTypeId() == TYPEID_PLAYER && (!m_caster->GetAura(14076, SpellEffectIndex(0)) && !m_caster->GetAura(14094, SpellEffectIndex(0)) && !m_caster->GetAura(14095, SpellEffectIndex(0)))) m_caster->RemoveSpellsCausingAura(SPELL_AURA_MOD_STEALTH); } case SPELLFAMILY_WARRIOR: break; case SPELLFAMILY_PRIEST: { // Power Word: Shield if (m_spellInfo->SpellFamilyName == SPELLFAMILY_PRIEST && m_spellInfo->SpellFamilyFlags & UI64LIT(0x0000000000000001)) { AddPrecastSpell(6788); } // Weakened Soul switch (m_spellInfo->Id) { case 15237: AddTriggeredSpell(23455); break;// Holy Nova, rank 1 case 15430: AddTriggeredSpell(23458); break;// Holy Nova, rank 2 case 15431: AddTriggeredSpell(23459); break;// Holy Nova, rank 3 case 27799: AddTriggeredSpell(27803); break;// Holy Nova, rank 4 case 27800: AddTriggeredSpell(27804); break;// Holy Nova, rank 5 case 27801: AddTriggeredSpell(27805); break;// Holy Nova, rank 6 case 25331: AddTriggeredSpell(25329); break;// Holy Nova, rank 7 default: break; } break; } case SPELLFAMILY_PALADIN: { // Blessing of Protection (Divine Shield, Divine Protection in generic switch case) if (m_spellInfo->Mechanic == MECHANIC_INVULNERABILITY && m_spellInfo->Id != 25771) { AddPrecastSpell(25771); } // Forbearance break; } default: break; } // As of patch 1.10.0, Arcane Power will replace Power Infusion if (m_spellInfo->Id == 12042) { m_targets.getUnitTarget()->RemoveAurasDueToSpell(10060); } // Linked spells (precast chain) SpellLinkedSet linkedSet = sSpellMgr.GetSpellLinked(m_spellInfo->Id, SPELL_LINKED_TYPE_PRECAST); if (linkedSet.size() > 0) { for (SpellLinkedSet::const_iterator itr = linkedSet.begin(); itr != linkedSet.end(); ++itr) { AddPrecastSpell(*itr); } } // Linked spells (triggered chain) linkedSet.clear(); linkedSet = sSpellMgr.GetSpellLinked(m_spellInfo->Id, SPELL_LINKED_TYPE_TRIGGERED); if (linkedSet.size() > 0) { for (SpellLinkedSet::const_iterator itr = linkedSet.begin(); itr != linkedSet.end(); ++itr) { AddTriggeredSpell(*itr); } } // traded items have trade slot instead of guid in m_itemTargetGUID // set to real guid to be sent later to the client m_targets.updateTradeSlotItem(); // Used by Eluna #ifdef ENABLE_ELUNA if (m_caster->GetTypeId() == TYPEID_PLAYER) sEluna->OnSpellCast(m_caster->ToPlayer(), this, skipCheck); #endif /* ENABLE_ELUNA */ FillTargetMap(); if (m_spellState == SPELL_STATE_FINISHED) // stop cast if spell marked as finish somewhere in FillTargetMap { m_caster->DecreaseCastCounter(); SetExecutedCurrently(false); return; } // CAST SPELL SendSpellCooldown(); TakePower(); TakeReagents(); // we must remove reagents before HandleEffects to allow place crafted item in same slot TakeAmmo(); SendCastResult(castResult); SendSpellGo(); // we must send smsg_spell_go packet before m_castItem delete in TakeCastItem()... InitializeDamageMultipliers(); // Okay, everything is prepared. Now we need to distinguish between immediate and evented delayed spells float speed = m_spellInfo->speed == 0.0f && m_triggeredBySpellInfo ? m_triggeredBySpellInfo->speed : m_spellInfo->speed; if (speed > 0.0f) { // Remove used for cast item if need (it can be already NULL after TakeReagents call // in case delayed spell remove item at cast delay start TakeCastItem(); // fill initial spell damage from caster for delayed casted spells for (TargetList::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit) { HandleDelayedSpellLaunch(&(*ihit)); } // Okay, maps created, now prepare flags m_immediateHandled = false; m_spellState = SPELL_STATE_DELAYED; SetDelayStart(0); } else { // Immediate spell, no big deal handle_immediate(); } m_caster->DecreaseCastCounter(); SetExecutedCurrently(false); } void Spell::handle_immediate() { // process immediate effects (items, ground, etc.) also initialize some variables _handle_immediate_phase(); // start channeling if applicable (after _handle_immediate_phase for get persistent effect dynamic object for channel target if (IsChanneledSpell(m_spellInfo) && m_duration) { m_spellState = SPELL_STATE_CASTING; SendChannelStart(m_duration); } for (TargetList::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit) { DoAllEffectOnTarget(&(*ihit)); } for (GOTargetList::iterator ihit = m_UniqueGOTargetInfo.begin(); ihit != m_UniqueGOTargetInfo.end(); ++ihit) { DoAllEffectOnTarget(&(*ihit)); } // spell is finished, perform some last features of the spell here _handle_finish_phase(); // Remove used for cast item if need (it can be already NULL after TakeReagents call TakeCastItem(); if (m_spellState != SPELL_STATE_CASTING) { finish(true); } // successfully finish spell cast (not last in case autorepeat or channel spell) } uint64 Spell::handle_delayed(uint64 t_offset) { uint64 next_time = 0; if (!m_immediateHandled) { _handle_immediate_phase(); m_immediateHandled = true; } // 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) for (TargetList::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit) { if (!ihit->processed) { if (ihit->timeDelay <= t_offset) { DoAllEffectOnTarget(&(*ihit)); } else if (next_time == 0 || ihit->timeDelay < next_time) { next_time = ihit->timeDelay; } } } // now recheck gameobject targeting correctness for (GOTargetList::iterator ighit = m_UniqueGOTargetInfo.begin(); ighit != m_UniqueGOTargetInfo.end(); ++ighit) { if (!ighit->processed) { if (ighit->timeDelay <= t_offset) { DoAllEffectOnTarget(&(*ighit)); } else if (next_time == 0 || ighit->timeDelay < next_time) { next_time = ighit->timeDelay; } } } // All targets passed - need finish phase if (next_time == 0) { // spell is finished, perform some last features of the spell here _handle_finish_phase(); finish(true); // successfully finish spell cast // return zero, spell is finished now return 0; } else { // spell is unfinished, return next execution time return next_time; } } void Spell::_handle_immediate_phase() { // handle some immediate features of the spell here HandleThreatSpells(); m_needSpellLog = IsNeedSendToClient(); for (int j = 0; j < MAX_EFFECT_INDEX; ++j) { if (m_spellInfo->Effect[j] == 0) { continue; } // apply Send Event effect to ground in case empty target lists if (m_spellInfo->Effect[j] == SPELL_EFFECT_SEND_EVENT && !HaveTargetsForEffect(SpellEffectIndex(j))) { HandleEffects(NULL, NULL, NULL, SpellEffectIndex(j)); continue; } // Don't do spell log, if is school damage spell if (m_spellInfo->Effect[j] == SPELL_EFFECT_SCHOOL_DAMAGE || m_spellInfo->Effect[j] == 0) { m_needSpellLog = false; } } // initialize Diminishing Returns Data m_diminishLevel = DIMINISHING_LEVEL_1; m_diminishGroup = DIMINISHING_NONE; // process items for (ItemTargetList::iterator ihit = m_UniqueItemInfo.begin(); ihit != m_UniqueItemInfo.end(); ++ihit) { DoAllEffectOnTarget(&(*ihit)); } // process ground for (int j = 0; j < MAX_EFFECT_INDEX; ++j) { // persistent area auras target only the ground if (m_spellInfo->Effect[j] == SPELL_EFFECT_PERSISTENT_AREA_AURA || //summon a gameobject at the spell's destination xyz (m_spellInfo->Effect[j] == SPELL_EFFECT_TRANS_DOOR && m_spellInfo->EffectImplicitTargetA[j] == TARGET_AREAEFFECT_GO_AROUND_DEST)) { HandleEffects(NULL, NULL, NULL, SpellEffectIndex(j)); } } } void Spell::_handle_finish_phase() { // spell log if (m_needSpellLog) { SendLogExecute(); } if (m_caster->m_extraAttacks && m_spellInfo->HasSpellEffect(SPELL_EFFECT_ADD_EXTRA_ATTACKS)) { switch (m_spellInfo->Id) { // on next swing case 15494: case 18797: case 21919: case 20178: // paladin reckoning proc break; default: if (Unit* victim = m_caster->getVictim()) m_caster->HandleProcExtraAttackFor(victim); else m_caster->m_extraAttacks = 0; // do not allow to accumulate instant extra attacks break; } } } void Spell::SendSpellCooldown() { if (m_caster->GetTypeId() != TYPEID_PLAYER) { return; } Player* _player = (Player*)m_caster; // (1) have infinity cooldown but set at aura apply, (2) passive cooldown at triggering if (m_spellInfo->HasAttribute(SPELL_ATTR_DISABLED_WHILE_ACTIVE) || m_spellInfo->HasAttribute(SPELL_ATTR_PASSIVE)) { return; } _player->AddSpellAndCategoryCooldowns(m_spellInfo, m_CastItem ? m_CastItem->GetEntry() : 0, this); } void Spell::update(uint32 difftime) { // update pointers based at it's GUIDs UpdatePointers(); if (!m_targets.getUnitTargetGuid().IsEmpty() && !m_targets.getUnitTarget()) { cancel(); return; } // check for target going invisiblity/fake death if (Unit* target = m_targets.getUnitTarget()) { if (!target->IsVisibleForOrDetect(m_caster, m_caster, true) || target->HasAuraType(SPELL_AURA_FEIGN_DEATH)) { if (m_caster->GetTargetGuid() == target->GetObjectGuid()) m_caster->SetTargetGuid(ObjectGuid()); cancel(); return; } } if (m_targets.getUnitTarget() && (m_targets.getUnitTarget() != m_caster) && IsSingleTargetSpell(m_spellInfo) && !IsNextMeleeSwingSpell() && !IsAutoRepeat() && !m_IsTriggeredSpell) { if (!m_caster->IsWithinLOSInMap(m_targets.getUnitTarget())) { cancel(); return; } } // check if the player or unit caster has moved before the spell finished (exclude casting on vehicles) if (((m_caster->GetTypeId() == TYPEID_PLAYER || m_caster->GetTypeId() == TYPEID_UNIT) && m_timer != 0) && (m_castPositionX != m_caster->GetPositionX() || m_castPositionY != m_caster->GetPositionY() || m_castPositionZ != m_caster->GetPositionZ()) && (m_spellInfo->Effect[EFFECT_INDEX_0] != SPELL_EFFECT_STUCK || !m_caster->m_movementInfo.HasMovementFlag(MOVEFLAG_FALLINGFAR))) { // always cancel for channeled spells if (m_spellState == SPELL_STATE_CASTING) { cancel(); } // don't cancel for melee, autorepeat, triggered and instant spells else if (!IsNextMeleeSwingSpell() && !IsAutoRepeat() && !m_IsTriggeredSpell && (m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_MOVEMENT)) { cancel(); } } switch (m_spellState) { case SPELL_STATE_PREPARING: { if (m_timer) { if (difftime >= m_timer) { m_timer = 0; } else { m_timer -= difftime; } } if (m_timer == 0 && !IsNextMeleeSwingSpell() && !IsAutoRepeat()) { cast(); } } break; case SPELL_STATE_CASTING: { if (m_timer > 0) { if (m_caster->GetTypeId() == TYPEID_PLAYER || m_caster->GetTypeId() == TYPEID_UNIT) { // check if player has jumped before the channeling finished if (m_caster->m_movementInfo.HasMovementFlag(MOVEFLAG_FALLING)) { cancel(); } // check for incapacitating player states if (m_caster->hasUnitState(UNIT_STAT_CAN_NOT_REACT)) { // certain channel spells are not interrupted if (!m_spellInfo->HasAttribute(SPELL_ATTR_EX_CHANNELED_1) && !m_spellInfo->HasAttribute(SPELL_ATTR_EX3_UNK28)) cancel(); } // check if player has turned if flag is set if (m_spellInfo->ChannelInterruptFlags & CHANNEL_FLAG_TURNING && m_castOrientation != m_caster->GetOrientation()) { cancel(); } } // check if there are alive targets left if (!IsAliveUnitPresentInTargetList()) { SendChannelUpdate(0); finish(); } if (difftime >= m_timer) { m_timer = 0; } else { m_timer -= difftime; } } if (m_timer == 0) { SendChannelUpdate(0); // channeled spell processed independently for quest targeting // cast at creature (or GO) quest objectives update at successful cast channel finished // ignore autorepeat/melee casts for speed (not exist quest for spells (hm... ) if (!IsAutoRepeat() && !IsNextMeleeSwingSpell()) { if (Player* p = m_caster->GetCharmerOrOwnerPlayerOrPlayerItself()) { for (TargetList::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit) { TargetInfo const& target = *ihit; if (!target.targetGUID.IsCreature()) { continue; } Unit* unit = m_caster->GetObjectGuid() == target.targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, target.targetGUID); if (unit == NULL) { continue; } p->RewardPlayerAndGroupAtCast(unit, m_spellInfo->Id); } for (GOTargetList::const_iterator ihit = m_UniqueGOTargetInfo.begin(); ihit != m_UniqueGOTargetInfo.end(); ++ihit) { GOTargetInfo const& target = *ihit; GameObject* go = m_caster->GetMap()->GetGameObject(target.targetGUID); if (!go) { continue; } p->RewardPlayerAndGroupAtCast(go, m_spellInfo->Id); } } } finish(); } } break; default: { } break; } } void Spell::finish(bool ok) { if (!m_caster) { return; } if (m_spellState == SPELL_STATE_FINISHED) { return; } // remove/restore spell mods before m_spellState update if (Player* modOwner = m_caster->GetSpellModOwner()) { if (ok || m_spellState != SPELL_STATE_PREPARING) // fail after start channeling or throw to target not affect spell mods { modOwner->RemoveSpellMods(this); } else { modOwner->ResetSpellModsDueToCanceledSpell(this); } } m_spellState = SPELL_STATE_FINISHED; // other code related only to successfully finished spells if (!ok) { return; } // handle SPELL_AURA_ADD_TARGET_TRIGGER auras Unit::AuraList const& targetTriggers = m_caster->GetAurasByType(SPELL_AURA_ADD_TARGET_TRIGGER); for (Unit::AuraList::const_iterator i = targetTriggers.begin(); i != targetTriggers.end(); ++i) { if (!(*i)->isAffectedOnSpell(m_spellInfo)) { continue; } for (TargetList::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit) { if (ihit->missCondition == SPELL_MISS_NONE) { // check m_caster->GetGUID() let load auras at login and speedup most often case Unit* unit = m_caster->GetObjectGuid() == ihit->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID); if (unit && unit->IsAlive()) { SpellEntry const* auraSpellInfo = (*i)->GetSpellProto(); SpellEffectIndex auraSpellIdx = (*i)->GetEffIndex(); // Calculate chance at that moment (can be depend for example from combo points) int32 auraBasePoints = (*i)->GetBasePoints(); int32 chance = m_caster->CalculateSpellDamage(unit, auraSpellInfo, auraSpellIdx, &auraBasePoints); if (roll_chance_i(chance)) { m_caster->CastSpell(unit, auraSpellInfo->EffectTriggerSpell[auraSpellIdx], true, NULL, (*i)); } } } } } // Heal caster for all health leech from all targets if (m_healthLeech) { m_caster->DealHeal(m_caster, uint32(m_healthLeech), m_spellInfo); } if (IsMeleeAttackResetSpell()) { m_caster->resetAttackTimer(BASE_ATTACK); if (m_caster->haveOffhandWeapon()) { m_caster->resetAttackTimer(OFF_ATTACK); } } /*if (IsRangedAttackResetSpell()) m_caster->resetAttackTimer(RANGED_ATTACK);*/ // Clear combo at finish state if (m_caster->GetTypeId() == TYPEID_PLAYER && NeedsComboPoints(m_spellInfo)) { // Not drop combopoints if negative spell and if any miss on enemy exist bool needDrop = true; if (!IsPositiveSpell(m_spellInfo->Id)) { for (TargetList::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit) { if (ihit->missCondition != SPELL_MISS_NONE && ihit->targetGUID != m_caster->GetObjectGuid()) { needDrop = false; break; } } } if (needDrop) { ((Player*)m_caster)->ClearComboPoints(); } } // call triggered spell only at successful cast (after clear combo points -> for add some if need) if (!m_TriggerSpells.empty()) { CastTriggerSpells(); } // Stop Attack for some spells if (m_spellInfo->HasAttribute(SPELL_ATTR_STOP_ATTACK_TARGET)) { m_caster->AttackStop(); } #ifdef ENABLE_PLAYERBOTS if(!m_caster->GetMapId()) return; #endif } void Spell::SendCastResult(SpellCastResult result) { if (m_caster->GetTypeId() != TYPEID_PLAYER) { if (((Creature*)m_caster)->AI()) ((Creature*)m_caster)->AI()->OnSpellCastChange(m_spellInfo, result); return; } if (((Player*)m_caster)->GetSession()->PlayerLoading()) // don't send cast results at loading time { return; } // Reseting emote state for case not handled by the client. if (result == SPELL_FAILED_CHEST_IN_USE) { SendInterrupted(0); } SendCastResult((Player*)m_caster, m_spellInfo, result); } void Spell::SendCastResult(Player* caster, SpellEntry const* spellInfo, SpellCastResult result) { WorldPacket data(SMSG_CAST_FAILED, (4 + 1 + 1)); data << uint32(spellInfo->Id); if (result != SPELL_CAST_OK) { data << uint8(2); // status = fail data << uint8(!IsPassiveSpell(spellInfo) ? result : SPELL_FAILED_DONT_REPORT); // do not report failed passive spells switch (result) { case SPELL_FAILED_REQUIRES_SPELL_FOCUS: data << uint32(spellInfo->RequiresSpellFocus); break; case SPELL_FAILED_REQUIRES_AREA: /* [-ZERO] // hardcode areas limitation case switch(spellInfo->Id) { default: // default case data << uint32(spellInfo->AreaId); break; } */ break; case SPELL_FAILED_EQUIPPED_ITEM_CLASS: data << uint32(spellInfo->EquippedItemClass); data << uint32(spellInfo->EquippedItemSubClassMask); data << uint32(spellInfo->EquippedItemInventoryTypeMask); break; default: break; } } else { data << uint8(0); } caster->GetSession()->SendPacket(&data); } void Spell::SendSpellStart() { if (!IsNeedSendToClient()) { return; } DEBUG_FILTER_LOG(LOG_FILTER_SPELL_CAST, "Sending SMSG_SPELL_START id=%u", m_spellInfo->Id); uint32 castFlags = CAST_FLAG_UNKNOWN2; if (IsRangedSpell()) { castFlags |= CAST_FLAG_AMMO; } WorldPacket data(SMSG_SPELL_START, (8 + 8 + 4 + 2 + 4)); if (m_CastItem) { data << m_CastItem->GetPackGUID(); } else { data << m_caster->GetPackGUID(); } data << m_caster->GetPackGUID(); data << uint32(m_spellInfo->Id); // spellId data << uint16(castFlags); // cast flags data << uint32(m_timer); // delay? data << m_targets; if (castFlags & CAST_FLAG_AMMO) // projectile info { WriteAmmoToPacket(&data); } m_caster->SendMessageToSet(&data, true); } void Spell::SendSpellGo() { // not send invisible spell casting if (!IsNeedSendToClient()) { return; } DEBUG_FILTER_LOG(LOG_FILTER_SPELL_CAST, "Sending SMSG_SPELL_GO id=%u", m_spellInfo->Id); uint32 castFlags = CAST_FLAG_UNKNOWN9; if (IsRangedSpell()) { castFlags |= CAST_FLAG_AMMO; } // arrows/bullets visual WorldPacket data(SMSG_SPELL_GO, 53); // guess size if (m_CastItem) { data << m_CastItem->GetPackGUID(); } else { data << m_caster->GetPackGUID(); } data << m_caster->GetPackGUID(); data << uint32(m_spellInfo->Id); // spellId data << uint16(castFlags); // cast flags WriteSpellGoTargets(&data); data << m_targets; if (castFlags & CAST_FLAG_AMMO) // projectile info { WriteAmmoToPacket(&data); } m_caster->SendMessageToSet(&data, true); } void Spell::WriteAmmoToPacket(WorldPacket* data) { uint32 ammoInventoryType = 0; uint32 ammoDisplayID = 0; if (m_caster->GetTypeId() == TYPEID_PLAYER) { Item* pItem = ((Player*)m_caster)->GetWeaponForAttack(RANGED_ATTACK); if (pItem) { ammoInventoryType = pItem->GetProto()->InventoryType; if (ammoInventoryType == INVTYPE_THROWN) { ammoDisplayID = pItem->GetProto()->DisplayInfoID; } else { uint32 ammoID = ((Player*)m_caster)->GetUInt32Value(PLAYER_AMMO_ID); if (ammoID) { ItemPrototype const* pProto = ObjectMgr::GetItemPrototype(ammoID); if (pProto) { ammoDisplayID = pProto->DisplayInfoID; ammoInventoryType = pProto->InventoryType; } } } } } else { for (uint8 i = 0; i < MAX_VIRTUAL_ITEM_SLOT; ++i) { // see Creature::SetVirtualItem for structure data if (uint32 item_class = m_caster->GetByteValue(UNIT_VIRTUAL_ITEM_INFO + (i * 2) + 0, VIRTUAL_ITEM_INFO_0_OFFSET_CLASS)) { if (item_class == ITEM_CLASS_WEAPON) { switch (m_caster->GetByteValue(UNIT_VIRTUAL_ITEM_INFO + (i * 2) + 0, VIRTUAL_ITEM_INFO_0_OFFSET_SUBCLASS)) { case ITEM_SUBCLASS_WEAPON_THROWN: ammoDisplayID = m_caster->GetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY + i); ammoInventoryType = m_caster->GetByteValue(UNIT_VIRTUAL_ITEM_INFO + (i * 2) + 0, VIRTUAL_ITEM_INFO_0_OFFSET_INVENTORYTYPE); break; case ITEM_SUBCLASS_WEAPON_BOW: case ITEM_SUBCLASS_WEAPON_CROSSBOW: ammoDisplayID = 5996; // is this need fixing? ammoInventoryType = INVTYPE_AMMO; break; case ITEM_SUBCLASS_WEAPON_GUN: ammoDisplayID = 5998; // is this need fixing? ammoInventoryType = INVTYPE_AMMO; break; } if (ammoDisplayID) { break; } } } } } *data << uint32(ammoDisplayID); *data << uint32(ammoInventoryType); } void Spell::WriteSpellGoTargets(WorldPacket* data) { // This function also fill data for channeled spells: // m_needAliveTargetMask req for stop channeling if one target die // Always hits on GO and expected all targets for Units *data << (uint8)(m_UniqueTargetInfo.size() + m_UniqueGOTargetInfo.size()); for (TargetList::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit) { *data << ihit->targetGUID; // in 1.12.1 expected all targets if (ihit->effectMask == 0) // No effect apply - all immuned add state { // possibly SPELL_MISS_IMMUNE2 for this?? ihit->missCondition = SPELL_MISS_IMMUNE2; } else if (ihit->missCondition == SPELL_MISS_NONE) // Add only hits { m_needAliveTargetMask |= ihit->effectMask; } } for (GOTargetList::const_iterator ighit = m_UniqueGOTargetInfo.begin(); ighit != m_UniqueGOTargetInfo.end(); ++ighit) { *data << ighit->targetGUID; } // Always hits *data << uint8(0); // unknown, not miss // Reset m_needAliveTargetMask for non channeled spell if (!IsChanneledSpell(m_spellInfo)) { m_needAliveTargetMask = 0; } } void Spell::SendLogExecute() { Unit* target = m_targets.getUnitTarget() ? m_targets.getUnitTarget() : m_caster; WorldPacket data(SMSG_SPELLLOGEXECUTE, (8 + 4 + 4 + 4 + 4 + 8)); if (m_caster->GetTypeId() == TYPEID_PLAYER) { data << m_caster->GetPackGUID(); } else { data << target->GetPackGUID(); } data << uint32(m_spellInfo->Id); uint32 count1 = 1; data << uint32(count1); // count1 (effect count?) for (uint32 i = 0; i < count1; ++i) { data << uint32(m_spellInfo->Effect[EFFECT_INDEX_0]);// spell effect uint32 count2 = 1; data << uint32(count2); // count2 (target count?) for (uint32 j = 0; j < count2; ++j) { switch (m_spellInfo->Effect[EFFECT_INDEX_0]) { case SPELL_EFFECT_POWER_DRAIN: if (Unit* unit = m_targets.getUnitTarget()) { data << unit->GetPackGUID(); } else { data << uint8(0); } data << uint32(0); data << uint32(0); data << float(0); break; case SPELL_EFFECT_ADD_EXTRA_ATTACKS: if (Unit* unit = m_targets.getUnitTarget()) { data << unit->GetPackGUID(); } else { data << uint8(0); } data << uint32(0); // count? break; case SPELL_EFFECT_INTERRUPT_CAST: if (Unit* unit = m_targets.getUnitTarget()) { data << unit->GetPackGUID(); } else { data << uint8(0); } data << uint32(0); // spellid break; case SPELL_EFFECT_DURABILITY_DAMAGE: if (Unit* unit = m_targets.getUnitTarget()) { data << unit->GetPackGUID(); } else { data << uint8(0); } data << uint32(0); data << uint32(0); break; case SPELL_EFFECT_OPEN_LOCK: case SPELL_EFFECT_OPEN_LOCK_ITEM: if (Item* item = m_targets.getItemTarget()) { data << item->GetPackGUID(); } else { data << uint8(0); } break; case SPELL_EFFECT_CREATE_ITEM: data << uint32(m_spellInfo->EffectItemType[EFFECT_INDEX_0]); break; case SPELL_EFFECT_SUMMON: case SPELL_EFFECT_SUMMON_WILD: case SPELL_EFFECT_SUMMON_GUARDIAN: case SPELL_EFFECT_TRANS_DOOR: case SPELL_EFFECT_SUMMON_PET: case SPELL_EFFECT_SUMMON_POSSESSED: case SPELL_EFFECT_SUMMON_TOTEM: case SPELL_EFFECT_SUMMON_OBJECT_WILD: case SPELL_EFFECT_CREATE_HOUSE: case SPELL_EFFECT_DUEL: case SPELL_EFFECT_SUMMON_TOTEM_SLOT1: case SPELL_EFFECT_SUMMON_TOTEM_SLOT2: case SPELL_EFFECT_SUMMON_TOTEM_SLOT3: case SPELL_EFFECT_SUMMON_TOTEM_SLOT4: case SPELL_EFFECT_SUMMON_PHANTASM: case SPELL_EFFECT_SUMMON_CRITTER: case SPELL_EFFECT_SUMMON_OBJECT_SLOT1: case SPELL_EFFECT_SUMMON_OBJECT_SLOT2: case SPELL_EFFECT_SUMMON_OBJECT_SLOT3: case SPELL_EFFECT_SUMMON_OBJECT_SLOT4: case SPELL_EFFECT_SUMMON_DEMON: if (Unit* unit = m_targets.getUnitTarget()) { data << unit->GetPackGUID(); } else if (m_targets.getItemTargetGuid()) { data << m_targets.getItemTargetGuid().WriteAsPacked(); } else if (GameObject* go = m_targets.getGOTarget()) { data << go->GetPackGUID(); } else { data << uint8(0); } // guid break; case SPELL_EFFECT_FEED_PET: data << uint32(m_targets.getItemTargetEntry()); break; case SPELL_EFFECT_DISMISS_PET: if (Unit* unit = m_targets.getUnitTarget()) { data << unit->GetPackGUID(); } else { data << uint8(0); } break; default: return; } } } m_caster->SendMessageToSet(&data, true); } void Spell::SendInterrupted(uint8 result) { WorldPacket data(SMSG_SPELL_FAILURE, (8 + 4 + 1)); data << m_caster->GetPackGUID(); data << m_spellInfo->Id; data << result; m_caster->SendMessageToSet(&data, true); data.Initialize(SMSG_SPELL_FAILED_OTHER, (8 + 4)); data << m_caster->GetObjectGuid(); data << m_spellInfo->Id; m_caster->SendMessageToSet(&data, true); } void Spell::SendChannelUpdate(uint32 time) { if (time == 0) { // Reset farsight for some possessing auras of possessed summoned (as they might work with different aura types) if (m_spellInfo->HasAttribute(SPELL_ATTR_EX_FARSIGHT) && m_caster->GetTypeId() == TYPEID_PLAYER && m_caster->GetCharmGuid() && !IsSpellHaveAura(m_spellInfo, SPELL_AURA_MOD_POSSESS) && !IsSpellHaveAura(m_spellInfo, SPELL_AURA_MOD_POSSESS_PET)) { Player* player = (Player*)m_caster; // These Auras are applied to self, so get the possessed first Unit* possessed = player->GetCharm(); player->SetCharm(NULL); if (possessed) { player->SetClientControl(possessed, 0); } player->SetMover(NULL); player->GetCamera().ResetView(); player->RemovePetActionBar(); if (possessed) { possessed->clearUnitState(UNIT_STAT_CONTROLLED); possessed->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED); possessed->SetCharmerGuid(ObjectGuid()); // TODO - Requires more specials for target? // Some possessed might want to despawn? if (possessed->GetUInt32Value(UNIT_CREATED_BY_SPELL) == m_spellInfo->Id && possessed->GetTypeId() == TYPEID_UNIT) { ((Creature*)possessed)->ForcedDespawn(); } } } m_caster->RemoveAurasByCasterSpell(m_spellInfo->Id, m_caster->GetObjectGuid()); ObjectGuid target_guid = m_caster->GetChannelObjectGuid(); if (target_guid != m_caster->GetObjectGuid() && target_guid.IsUnit()) if (Unit* target = ObjectAccessor::GetUnit(*m_caster, target_guid)) { target->RemoveAurasByCasterSpell(m_spellInfo->Id, m_caster->GetObjectGuid()); } // Only finish channeling when latest channeled spell finishes if (m_caster->GetUInt32Value(UNIT_CHANNEL_SPELL) != m_spellInfo->Id) { return; } m_caster->SetChannelObjectGuid(ObjectGuid()); m_caster->SetUInt32Value(UNIT_CHANNEL_SPELL, 0); } if (m_caster->GetTypeId() == TYPEID_PLAYER) { WorldPacket data(MSG_CHANNEL_UPDATE, 4); data << uint32(time); ((Player*)m_caster)->SendDirectMessage(&data); } } void Spell::SendChannelStart(uint32 duration) { WorldObject* target = NULL; // select dynobject created by first effect if any if (m_spellInfo->Effect[EFFECT_INDEX_0] == SPELL_EFFECT_PERSISTENT_AREA_AURA) { target = m_caster->GetDynObject(m_spellInfo->Id, EFFECT_INDEX_0); } // select first not resisted target from target list for _0_ effect else if (!m_UniqueTargetInfo.empty()) { for (TargetList::const_iterator itr = m_UniqueTargetInfo.begin(); itr != m_UniqueTargetInfo.end(); ++itr) { if ((itr->effectMask & (1 << EFFECT_INDEX_0)) && itr->reflectResult == SPELL_MISS_NONE && itr->targetGUID != m_caster->GetObjectGuid()) { target = ObjectAccessor::GetUnit(*m_caster, itr->targetGUID); break; } } } else if (!m_UniqueGOTargetInfo.empty()) { for (GOTargetList::const_iterator itr = m_UniqueGOTargetInfo.begin(); itr != m_UniqueGOTargetInfo.end(); ++itr) { if (itr->effectMask & (1 << EFFECT_INDEX_0)) { target = m_caster->GetMap()->GetGameObject(itr->targetGUID); break; } } } if (m_caster->GetTypeId() == TYPEID_PLAYER) { WorldPacket data(MSG_CHANNEL_START, (4 + 4)); data << uint32(m_spellInfo->Id); data << uint32(duration); ((Player*)m_caster)->SendDirectMessage(&data); } m_timer = duration; if (target) { m_caster->SetChannelObjectGuid(target->GetObjectGuid()); } m_caster->SetUInt32Value(UNIT_CHANNEL_SPELL, m_spellInfo->Id); } void Spell::SendResurrectRequest(Player* target) { // Both players and NPCs can resurrect using spells - have a look at creature 28487 for example // However, the packet structure differs slightly const char* sentName = m_caster->GetTypeId() == TYPEID_PLAYER ? "" : m_caster->GetNameForLocaleIdx(target->GetSession()->GetSessionDbLocaleIndex()); WorldPacket data(SMSG_RESURRECT_REQUEST, (8 + 4 + strlen(sentName) + 1 + 1 + 1)); data << m_caster->GetObjectGuid(); data << uint32(strlen(sentName) + 1); data << sentName; data << uint8(0); data << uint8(m_caster->GetTypeId() == TYPEID_PLAYER ? 0 : 1); target->GetSession()->SendPacket(&data); } void Spell::TakeCastItem() { if (!m_CastItem || m_caster->GetTypeId() != TYPEID_PLAYER) { return; } // not remove cast item at triggered spell (equipping, weapon damage, etc) if (m_IsTriggeredSpell && !(m_targets.m_targetMask & TARGET_FLAG_TRADE_ITEM)) { return; } ItemPrototype const* proto = m_CastItem->GetProto(); if (!proto) { // This code is to avoid a crash // I'm not sure, if this is really an error, but I guess every item needs a prototype sLog.outError("Cast item (%s) has no item prototype", m_CastItem->GetGuidStr().c_str()); return; } bool expendable = false; bool withoutCharges = false; for (int i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i) { if (proto->Spells[i].SpellId) { // item has limited charges if (proto->Spells[i].SpellCharges) { if (proto->Spells[i].SpellCharges < 0 && !(proto->ExtraFlags & ITEM_EXTRA_NON_CONSUMABLE)) { expendable = true; } int32 charges = m_CastItem->GetSpellCharges(i); // item has charges left if (charges) { (charges > 0) ? --charges : ++charges; // abs(charges) less at 1 after use if (proto->Stackable == 1) { m_CastItem->SetSpellCharges(i, charges); } m_CastItem->SetState(ITEM_CHANGED, (Player*)m_caster); } // all charges used withoutCharges = (charges == 0); } } } if (expendable && withoutCharges) { uint32 count = 1; ((Player*)m_caster)->DestroyItemCount(m_CastItem, count, true); // prevent crash at access to deleted m_targets.getItemTarget ClearCastItem(); } } void Spell::TakePower() { if (m_CastItem || m_IsTriggeredSpell) // all triggered spells ignore power req { return; } // health as power used if (m_spellInfo->powerType == POWER_HEALTH) { m_caster->ModifyHealth(-(int32)m_powerCost); return; } // the static data (m_spellInfo) should be checked elsewhere // [+ZERO] actual DBC power values are 0..3 and uint32(-2) Powers powerType = Powers(m_spellInfo->powerType); bool hit = true; for (uint8 j = 0; j < 3; ++j) { // Spell targets a single enemy if (m_spellInfo->EffectImplicitTargetA[j] == TARGET_CHAIN_DAMAGE || m_spellInfo->EffectImplicitTargetA[j] == TARGET_CURRENT_ENEMY_COORDINATES) { if (m_caster->GetTypeId() == TYPEID_PLAYER) { if (powerType == POWER_ENERGY || powerType == POWER_RAGE) for (std::list::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit) { if (ihit->missCondition != SPELL_MISS_NONE) { hit = false; } break; } } } } if (hit || m_spellInfo->AttributesEx & SPELL_ATTR_EX_REQ_TARGET_COMBO_POINTS || m_spellInfo->AttributesEx & SPELL_ATTR_EX_REQ_COMBO_POINTS) m_caster->ModifyPower(powerType, -(int32)m_powerCost); else m_caster->ModifyPower(powerType, -(int32)m_powerCost / 5); // Set the five second timer if (powerType == POWER_MANA && m_powerCost > 0) { m_caster->SetLastManaUse(); } } void Spell::TakeAmmo() { if (m_attackType == RANGED_ATTACK && m_caster->GetTypeId() == TYPEID_PLAYER) { Item* pItem = ((Player*)m_caster)->GetWeaponForAttack(RANGED_ATTACK, true, false); // wands don't have ammo if (!pItem || pItem->GetProto()->SubClass == ITEM_SUBCLASS_WEAPON_WAND) { return; } if (pItem->GetProto()->InventoryType == INVTYPE_THROWN) { if (pItem->GetMaxStackCount() == 1) { // decrease durability for non-stackable throw weapon ((Player*)m_caster)->DurabilityPointLossForEquipSlot(EQUIPMENT_SLOT_RANGED); } else { // decrease items amount for stackable throw weapon uint32 count = 1; ((Player*)m_caster)->DestroyItemCount(pItem, count, true); } } else if (uint32 ammo = ((Player*)m_caster)->GetUInt32Value(PLAYER_AMMO_ID)) { ((Player*)m_caster)->DestroyItemCount(ammo, 1, true); } } } void Spell::TakeReagents() { if (m_caster->GetTypeId() != TYPEID_PLAYER) { return; } if (IgnoreItemRequirements()) // reagents used in triggered spell removed by original spell or don't must be removed. { return; } Player* p_caster = (Player*)m_caster; if (p_caster->CanNoReagentCast(m_spellInfo)) { return; } for (uint32 x = 0; x < MAX_SPELL_REAGENTS; ++x) { if (m_spellInfo->Reagent[x] <= 0) { continue; } uint32 itemid = m_spellInfo->Reagent[x]; uint32 itemcount = m_spellInfo->ReagentCount[x]; // if CastItem is also spell reagent if (m_CastItem) { ItemPrototype const* proto = m_CastItem->GetProto(); if (proto && proto->ItemId == itemid) { for (int s = 0; s < MAX_ITEM_PROTO_SPELLS; ++s) { // CastItem will be used up and does not count as reagent int32 charges = m_CastItem->GetSpellCharges(s); if (proto->Spells[s].SpellCharges < 0 && abs(charges) < 2) { ++itemcount; break; } } m_CastItem = NULL; } } // if getItemTarget is also spell reagent if (m_targets.getItemTargetEntry() == itemid) { m_targets.setItemTarget(NULL); } p_caster->DestroyItemCount(itemid, itemcount, true); } } void Spell::HandleThreatSpells() { if (m_UniqueTargetInfo.empty()) { return; } SpellThreatEntry const* threatEntry = sSpellMgr.GetSpellThreatEntry(m_spellInfo->Id); if (!threatEntry || (!threatEntry->threat && threatEntry->ap_bonus == 0.0f)) { return; } float threat = threatEntry->threat; if (threatEntry->ap_bonus != 0.0f) { threat += threatEntry->ap_bonus * m_caster->GetTotalAttackPowerValue(GetWeaponAttackType(m_spellInfo)); } bool positive = true; uint8 effectMask = 0; for (int i = 0; i < MAX_EFFECT_INDEX; ++i) if (m_spellInfo->Effect[i]) { effectMask |= (1 << i); } if (m_negativeEffectMask & effectMask) { // can only handle spells with clearly defined positive/negative effect, check at spell_threat loading probably not perfect // so abort when only some effects are negative. if ((m_negativeEffectMask & effectMask) != effectMask) { DEBUG_FILTER_LOG(LOG_FILTER_SPELL_CAST, "Spell %u, rank %u, is not clearly positive or negative, ignoring bonus threat", m_spellInfo->Id, sSpellMgr.GetSpellRank(m_spellInfo->Id)); return; } positive = false; } // before 2.0.1 threat from positive effects not dependent from targets amount if (!positive) { threat /= m_UniqueTargetInfo.size(); } for (TargetList::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit) { if (ihit->missCondition != SPELL_MISS_NONE) { continue; } Unit* target = m_caster->GetObjectGuid() == ihit->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID); if (!target) { continue; } // positive spells distribute threat among all units that are in combat with target, like healing if (positive) { target->GetHostileRefManager().threatAssist(m_caster /*real_caster ??*/, threat, m_spellInfo); } // for negative spells threat gets distributed among affected targets else { if (!target->CanHaveThreatList()) { continue; } target->AddThreat(m_caster, threat, false, GetSpellSchoolMask(m_spellInfo), m_spellInfo); } } DEBUG_FILTER_LOG(LOG_FILTER_SPELL_CAST, "Spell %u added an additional %f threat for %s " SIZEFMTD " target(s)", m_spellInfo->Id, threat, positive ? "assisting" : "harming", m_UniqueTargetInfo.size()); } void Spell::HandleEffects(Unit* pUnitTarget, Item* pItemTarget, GameObject* pGOTarget, SpellEffectIndex i, float DamageMultiplier) { unitTarget = pUnitTarget; itemTarget = pItemTarget; gameObjTarget = pGOTarget; uint8 eff = m_spellInfo->Effect[i]; damage = int32(CalculateDamage(i, unitTarget) * DamageMultiplier); DEBUG_FILTER_LOG(LOG_FILTER_SPELL_CAST, "Spell %u Effect%d : %u Targets: %s, %s, %s", m_spellInfo->Id, i, eff, unitTarget ? unitTarget->GetGuidStr().c_str() : "-", itemTarget ? itemTarget->GetGuidStr().c_str() : "-", gameObjTarget ? gameObjTarget->GetGuidStr().c_str() : "-"); if (eff < TOTAL_SPELL_EFFECTS) { (*this.*SpellEffects[eff])(i); } else { sLog.outError("WORLD: Spell FX %d > TOTAL_SPELL_EFFECTS ", eff); } } void Spell::AddTriggeredSpell(uint32 spellId) { SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellId); if (!spellInfo) { sLog.outError("Spell::AddTriggeredSpell: unknown spell id %u used as triggred spell for spell %u)", spellId, m_spellInfo->Id); return; } m_TriggerSpells.push_back(spellInfo); } void Spell::AddPrecastSpell(uint32 spellId) { SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellId); if (!spellInfo) { sLog.outError("Spell::AddPrecastSpell: unknown spell id %u used as pre-cast spell for spell %u)", spellId, m_spellInfo->Id); return; } m_preCastSpells.push_back(spellInfo); } void Spell::CastTriggerSpells() { for (SpellInfoList::const_iterator si = m_TriggerSpells.begin(); si != m_TriggerSpells.end(); ++si) { bool _triggered = true; // ignore triggered status for certain spells switch ((*si)->Id) { case 13181: // Gnomish MC cap case 20578: // Cannibalize healing effect _triggered = false; break; default: break; } Spell* spell = new Spell(m_caster, (*si), _triggered, m_originalCasterGUID); spell->prepare(&m_targets); // use original spell original targets } } void Spell::CastPreCastSpells(Unit* target) { for (SpellInfoList::const_iterator si = m_preCastSpells.begin(); si != m_preCastSpells.end(); ++si) { m_caster->CastSpell(target, (*si), true, m_CastItem); } } Unit* Spell::GetPrefilledUnitTargetOrUnitTarget(SpellEffectIndex effIndex) const { for (TargetList::const_iterator itr = m_UniqueTargetInfo.begin(); itr != m_UniqueTargetInfo.end(); ++itr) if (itr->effectMask & (1 << effIndex)) { return m_caster->GetMap()->GetUnit(itr->targetGUID); } return m_targets.getUnitTarget(); } SpellCastResult Spell::CheckCast(bool strict) { // check cooldowns to prevent cheating (ignore passive spells, that client side visual only) if (m_caster->GetTypeId() == TYPEID_PLAYER && !m_spellInfo->HasAttribute(SPELL_ATTR_PASSIVE) && ((Player*)m_caster)->HasSpellCooldown(m_spellInfo->Id)) { if (m_triggeredByAuraSpell) { return SPELL_FAILED_DONT_REPORT; } else { return SPELL_FAILED_NOT_READY; } } // check global cooldown if (strict && !m_IsTriggeredSpell && HasGlobalCooldown()) { return SPELL_FAILED_NOT_READY; } // only allow triggered spells if at an ended battleground if (!m_IsTriggeredSpell && m_caster->GetTypeId() == TYPEID_PLAYER) if (BattleGround* bg = ((Player*)m_caster)->GetBattleGround()) if (bg->GetStatus() == STATUS_WAIT_LEAVE) { return SPELL_FAILED_DONT_REPORT; } if (!m_IsTriggeredSpell && IsNonCombatSpell(m_spellInfo) && m_caster->IsInCombat()) { return SPELL_FAILED_AFFECTING_COMBAT; } if (m_caster->GetTypeId() == TYPEID_PLAYER && !((Player*)m_caster)->isGameMaster() && sWorld.getConfig(CONFIG_BOOL_VMAP_INDOOR_CHECK) && VMAP::VMapFactory::createOrGetVMapManager()->isLineOfSightCalcEnabled()) { if (m_spellInfo->HasAttribute(SPELL_ATTR_OUTDOORS_ONLY) && !m_caster->GetMap()->GetTerrain()->IsOutdoors(m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ())) { return SPELL_FAILED_ONLY_OUTDOORS; } if (m_spellInfo->HasAttribute(SPELL_ATTR_INDOORS_ONLY) && m_caster->GetMap()->GetTerrain()->IsOutdoors(m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ())) { return SPELL_FAILED_ONLY_INDOORS; } } // only check at first call, Stealth auras are already removed at second call // for now, ignore triggered spells if (strict && !m_IsTriggeredSpell) { // Can not be used in this stance/form SpellCastResult shapeError = GetErrorAtShapeshiftedCast(m_spellInfo, m_caster->GetShapeshiftForm()); if (shapeError != SPELL_CAST_OK) { return shapeError; } if (m_spellInfo->HasAttribute(SPELL_ATTR_ONLY_STEALTHED) && !(m_caster->HasStealthAura())) { return SPELL_FAILED_ONLY_STEALTHED; } } // caster state requirements if (m_spellInfo->CasterAuraState && !m_caster->HasAuraState(AuraState(m_spellInfo->CasterAuraState))) { return SPELL_FAILED_CANT_DO_THAT_YET; } if (m_caster->GetTypeId() == TYPEID_PLAYER) { // cancel autorepeat spells if cast start when moving // (not wand currently autorepeat cast delayed to moving stop anyway in spell update code) if (((Player*)m_caster)->isMoving()) { // skip stuck spell to allow use it in falling case and apply spell limitations at movement if ((!((Player*)m_caster)->m_movementInfo.HasMovementFlag(MOVEFLAG_FALLINGFAR) || m_spellInfo->Effect[EFFECT_INDEX_0] != SPELL_EFFECT_STUCK) && (IsAutoRepeat() || (m_spellInfo->AuraInterruptFlags & AURA_INTERRUPT_FLAG_NOT_SEATED) != 0)) { return SPELL_FAILED_MOVING; } } if (!m_IsTriggeredSpell && NeedsComboPoints(m_spellInfo) && (!m_targets.getUnitTarget() || m_targets.getUnitTarget()->GetObjectGuid() != ((Player*)m_caster)->GetComboTargetGuid())) // warrior not have real combo-points at client side but use this way for mark allow Overpower use { return m_caster->getClass() == CLASS_WARRIOR ? SPELL_FAILED_CANT_DO_THAT_YET : SPELL_FAILED_NO_COMBO_POINTS; } // Loatheb Corrupted Mind spell failed switch(m_spellInfo->SpellFamilyName) { case SPELLFAMILY_DRUID: case SPELLFAMILY_PRIEST: case SPELLFAMILY_SHAMAN: case SPELLFAMILY_PALADIN: { if (m_spellInfo->HasSpellEffect(SPELL_EFFECT_HEAL) || IsSpellHaveAura(m_spellInfo, SPELL_AURA_PERIODIC_HEAL) || m_spellInfo->HasSpellEffect(SPELL_EFFECT_DISPEL)) { Unit::AuraList const& auraClassScripts = m_caster->GetAurasByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS); for (Unit::AuraList::const_iterator itr = auraClassScripts.begin(); itr != auraClassScripts.end();) { if ((*itr)->GetModifier()->m_miscvalue == 4327) { return SPELL_FAILED_FIZZLE; } else ++itr; } } } } } if (Unit* target = m_targets.getUnitTarget()) { //Soothe animal bool foundSootheAnimal = true; //will be set to false in the default case switch (m_spellInfo->Id) { case 9901: case 8955: case 2908: break; default: foundSootheAnimal = false; break; } //Perhaps this should be done for all spells? if (foundSootheAnimal) if (target->getLevel() > m_spellInfo->MaxTargetLevel) { return SPELL_FAILED_HIGHLEVEL; } // Swiftmend if (m_spellInfo->Id == 18562) // future versions have special aura state for this { if (!target->GetAura(SPELL_AURA_PERIODIC_HEAL, SPELLFAMILY_DRUID, UI64LIT(0x50))) { return SPELL_FAILED_TARGET_AURASTATE; } } // Tame Beast trigger if (m_spellInfo->Id == 1515) { SpellCastResult castResult = CanTameUnit(false); if (castResult != SPELL_CAST_OK) { return castResult; } } // give error message when applying lower hot rank to higher hot rank on target if (!m_spellInfo->HasSpellEffect(SPELL_EFFECT_HEAL) && IsSpellHaveAura(m_spellInfo, SPELL_AURA_PERIODIC_HEAL)) { Unit::AuraList const& mPeriodicHeal = target->GetAurasByType(SPELL_AURA_PERIODIC_HEAL); for (Unit::AuraList::const_iterator i = mPeriodicHeal.begin(); i != mPeriodicHeal.end(); ++i) { if ((*i)->GetSpellProto()->SpellFamilyName == m_spellInfo->SpellFamilyName) if (m_spellInfo->IsFitToFamilyMask((*i)->GetSpellProto()->SpellFamilyFlags)) if (CompareAuraRanks(m_spellInfo->Id, (*i)->GetSpellProto()->Id) < 0) { return SPELL_FAILED_MORE_POWERFUL_SPELL_ACTIVE; } } } if (!(m_spellInfo->SpellFamilyName == SPELLFAMILY_WARRIOR && m_spellInfo->SpellFamilyFlags & UI64LIT(0x100000000))) // the Shield Slam does not depend on its dispel effect { // Fill possible dispel list bool isDispell = false; bool isEmpty = true; // As of Patch 1.10.0, dispel effects now check if there is something to dispel first for (int i = 0; i < MAX_EFFECT_INDEX; ++i) { // Dispell Magic switch (m_spellInfo->Effect[i]) { case SPELL_EFFECT_DISPEL: { // It is a dispell spell isDispell = true; // Create dispel mask by dispel type uint32 dispel_type = m_spellInfo->EffectMiscValue[i]; uint32 dispelMask = GetDispellMask(DispelType(dispel_type)); Unit::SpellAuraHolderMap const& auras = target->GetSpellAuraHolderMap(); for (Unit::SpellAuraHolderMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr) { SpellAuraHolder* holder = itr->second; uint32 disp = (1 << holder->GetSpellProto()->Dispel); if (disp & dispelMask) { if (holder->GetSpellProto()->Dispel == DISPEL_MAGIC) { bool positive = true; if (!holder->IsPositive()) { positive = false; } else { positive = (holder->GetSpellProto()->AttributesEx & SPELL_ATTR_EX_NEGATIVE) == 0; } // do not remove positive auras if friendly target // negative auras if non-friendly target if (positive == target->IsFriendlyTo(m_caster)) { continue; } } isEmpty = false; break; } } break; } } } // Ok if exist some buffs for dispel try dispel it if (isDispell && isEmpty) { return SPELL_FAILED_NOTHING_TO_DISPEL; } } if (!m_IsTriggeredSpell && IsDeathOnlySpell(m_spellInfo) && target->IsAlive()) { return SPELL_FAILED_TARGET_NOT_DEAD; } // totem immunity for channeled spells(needs to be before spell cast) // spell attribs for player channeled spells if (m_spellInfo->HasAttribute(SPELL_ATTR_EX_UNK14) && target->GetTypeId() == TYPEID_UNIT && ((Creature*)target)->IsTotem()) { return SPELL_FAILED_IMMUNE; } // Power Infusion: As of patch 1.10, this is no longer usable if the target // has Arcane Power aura from mage. if (m_spellInfo->Id == 10060) // 10060 = Power Infusion { if (target->HasAura(12042)) // 12042 = Arcane Power { return SPELL_FAILED_MORE_POWERFUL_SPELL_ACTIVE; } } bool non_caster_target = target != m_caster && !IsSpellWithCasterSourceTargetsOnly(m_spellInfo); if (non_caster_target) { // Not allow casting on flying player if (target->IsTaxiFlying()) { return SPELL_FAILED_BAD_TARGETS; } if (!m_IsTriggeredSpell && !DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, m_spellInfo->Id, NULL, SPELL_DISABLE_LOS) && VMAP::VMapFactory::checkSpellForLoS(m_spellInfo->Id) && !m_caster->IsWithinLOSInMap(target)) { return SPELL_FAILED_LINE_OF_SIGHT; } // auto selection spell rank implemented in WorldSession::HandleCastSpellOpcode // this case can be triggered if rank not found (too low-level target for first rank) if (m_caster->GetTypeId() == TYPEID_PLAYER && !m_CastItem && !m_IsTriggeredSpell) { // spell expected to be auto-downranking in cast handle, so must be same if (m_spellInfo != sSpellMgr.SelectAuraRankForLevel(m_spellInfo, target->getLevel())) { return SPELL_FAILED_LOWLEVEL; } } if (strict && m_spellInfo->HasAttribute(SPELL_ATTR_EX3_TARGET_ONLY_PLAYER) && target->GetTypeId() != TYPEID_PLAYER && !IsAreaOfEffectSpell(m_spellInfo)) { return SPELL_FAILED_BAD_TARGETS; } } else if (m_caster == target) { if (m_caster->GetTypeId() == TYPEID_PLAYER && m_caster->IsInWorld()) { // Additional check for some spells // If 0 spell effect empty - client not send target data (need use selection) // TODO: check it on next client version if (m_targets.m_targetMask == TARGET_FLAG_SELF && m_spellInfo->EffectImplicitTargetA[EFFECT_INDEX_1] == TARGET_CHAIN_DAMAGE) { target = m_caster->GetMap()->GetUnit(((Player*)m_caster)->GetSelectionGuid()); if (!target) { return SPELL_FAILED_BAD_TARGETS; } // Arcane Missile self cast forbidden if (m_spellInfo->SpellFamilyName == SPELLFAMILY_MAGE && m_spellInfo->SpellFamilyFlags & UI64LIT(0x00000800) && m_caster == target) { return SPELL_FAILED_BAD_TARGETS; } // Gnomish Death Ray self cast forbidden if (m_spellInfo->Id == 13278 && m_caster == target) { return SPELL_FAILED_BAD_TARGETS; } m_targets.setUnitTarget(target); } } // Some special spells with non-caster only mode // Fire Shield if (m_spellInfo->SpellFamilyName == SPELLFAMILY_WARLOCK && m_spellInfo->SpellIconID == 16) { return SPELL_FAILED_BAD_TARGETS; } } // check pet presents for (int j = 0; j < MAX_EFFECT_INDEX; ++j) { if (m_spellInfo->EffectImplicitTargetA[j] == TARGET_PET) { Pet* pet = m_caster->GetPet(); if (!pet) { if (m_triggeredByAuraSpell) // not report pet not existence for triggered spells { return SPELL_FAILED_DONT_REPORT; } else { return SPELL_FAILED_NO_PET; } } else if (!pet->IsAlive()) { return SPELL_FAILED_TARGETS_DEAD; } break; } } // check creature type // ignore self casts (including area casts when caster selected as target) if (non_caster_target) { if (!CheckTargetCreatureType(target)) { if (target->GetTypeId() == TYPEID_PLAYER) { return SPELL_FAILED_TARGET_IS_PLAYER; } else { return SPELL_FAILED_BAD_TARGETS; } } // simple cases bool explicit_target_mode = false; bool target_hostile = false; bool target_hostile_checked = false; bool target_friendly = false; bool target_friendly_checked = false; for (int k = 0; k < MAX_EFFECT_INDEX; ++k) { if (IsExplicitPositiveTarget(m_spellInfo->EffectImplicitTargetA[k])) { if (!target_hostile_checked) { target_hostile_checked = true; target_hostile = m_caster->IsHostileTo(target); } if (target_hostile) { return SPELL_FAILED_BAD_TARGETS; } explicit_target_mode = true; } else if (IsExplicitNegativeTarget(m_spellInfo->EffectImplicitTargetA[k])) { if (!target_friendly_checked) { target_friendly_checked = true; target_friendly = m_caster->IsFriendlyTo(target); } if (target_friendly) { return SPELL_FAILED_BAD_TARGETS; } explicit_target_mode = true; } } // TODO: this check can be applied and for player to prevent cheating when IsPositiveSpell will return always correct result. // check target for pet/charmed casts (not self targeted), self targeted cast used for area effects and etc if (!explicit_target_mode && m_caster->GetTypeId() == TYPEID_UNIT && m_caster->GetCharmerOrOwnerGuid()) { // check correctness positive/negative cast target (pet cast real check and cheating check) if (IsPositiveSpell(m_spellInfo->Id)) { if (!target_hostile_checked) { target_hostile_checked = true; target_hostile = m_caster->IsHostileTo(target); } if (target_hostile) { return SPELL_FAILED_BAD_TARGETS; } } else { if (!target_friendly_checked) { target_friendly_checked = true; target_friendly = m_caster->IsFriendlyTo(target); } if (target_friendly) { return SPELL_FAILED_BAD_TARGETS; } } } } if (IsPositiveSpell(m_spellInfo->Id)) if (target->IsImmuneToSpell(m_spellInfo, target == m_caster)) { return SPELL_FAILED_TARGET_AURASTATE; } // Must be behind the target. if (m_spellInfo->AttributesEx2 == SPELL_ATTR_EX2_UNK20 && m_spellInfo->HasAttribute(SPELL_ATTR_EX_UNK9) && target->HasInArc(M_PI_F, m_caster)) { SendInterrupted(2); return SPELL_FAILED_NOT_BEHIND; } // Target must be facing you. if ((m_spellInfo->Attributes == (SPELL_ATTR_UNK4 | SPELL_ATTR_NOT_SHAPESHIFT | SPELL_ATTR_UNK18 | SPELL_ATTR_STOP_ATTACK_TARGET)) && !target->HasInArc(M_PI_F, m_caster)) { SendInterrupted(2); return SPELL_FAILED_NOT_INFRONT; } // check if target is in combat if (non_caster_target && m_spellInfo->HasAttribute(SPELL_ATTR_EX_NOT_IN_COMBAT_TARGET) && target->IsInCombat()) { return SPELL_FAILED_TARGET_AFFECTING_COMBAT; } // check if target is affected by Spirit of Redemption (Aura: 27827) if (target->HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION)) { return SPELL_FAILED_BAD_TARGETS; } } // zone check uint32 zone, area; m_caster->GetZoneAndAreaId(zone, area); SpellCastResult locRes = sSpellMgr.GetSpellAllowedInLocationError(m_spellInfo, m_caster->GetMapId(), zone, area, m_caster->GetCharmerOrOwnerPlayerOrPlayerItself()); if (locRes != SPELL_CAST_OK) { return locRes; } // not let players cast spells at mount (and let do it to creatures) if (m_caster->IsMounted() && m_caster->GetTypeId() == TYPEID_PLAYER && !m_IsTriggeredSpell && !IsPassiveSpell(m_spellInfo) && !m_spellInfo->HasAttribute(SPELL_ATTR_CASTABLE_WHILE_MOUNTED)) { if (m_caster->IsTaxiFlying()) { return SPELL_FAILED_NOT_ON_TAXI; } else { return SPELL_FAILED_NOT_MOUNTED; } } // always (except passive spells) check items (focus object can be required for any type casts) if (!IsPassiveSpell(m_spellInfo)) { SpellCastResult castResult = CheckItems(); if (castResult != SPELL_CAST_OK) { return castResult; } } // Database based targets from spell_target_script if (m_UniqueTargetInfo.empty()) // skip second CheckCast apply (for delayed spells for example) { for (int j = 0; j < MAX_EFFECT_INDEX; ++j) { if (m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT || m_spellInfo->EffectImplicitTargetB[j] == TARGET_SCRIPT || m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT_COORDINATES || m_spellInfo->EffectImplicitTargetB[j] == TARGET_SCRIPT_COORDINATES || m_spellInfo->EffectImplicitTargetA[j] == TARGET_FOCUS_OR_SCRIPTED_GAMEOBJECT || m_spellInfo->EffectImplicitTargetB[j] == TARGET_FOCUS_OR_SCRIPTED_GAMEOBJECT) { SQLMultiStorage::SQLMSIteratorBounds bounds = sSpellScriptTargetStorage.getBounds(m_spellInfo->Id); if (bounds.first == bounds.second) { if (m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT || m_spellInfo->EffectImplicitTargetB[j] == TARGET_SCRIPT) { sLog.outErrorDb("Spell entry %u, effect %i has EffectImplicitTargetA/EffectImplicitTargetB = TARGET_SCRIPT, but creature are not defined in `spell_script_target`", m_spellInfo->Id, j); } if (m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT_COORDINATES || m_spellInfo->EffectImplicitTargetB[j] == TARGET_SCRIPT_COORDINATES) { sLog.outErrorDb("Spell entry %u, effect %i has EffectImplicitTargetA/EffectImplicitTargetB = TARGET_SCRIPT_COORDINATES, but gameobject or creature are not defined in `spell_script_target`", m_spellInfo->Id, j); } if (m_spellInfo->EffectImplicitTargetA[j] == TARGET_FOCUS_OR_SCRIPTED_GAMEOBJECT || m_spellInfo->EffectImplicitTargetB[j] == TARGET_FOCUS_OR_SCRIPTED_GAMEOBJECT) { sLog.outErrorDb("Spell entry %u, effect %i has EffectImplicitTargetA/EffectImplicitTargetB = TARGET_FOCUS_OR_SCRIPTED_GAMEOBJECT, but gameobject are not defined in `spell_script_target`", m_spellInfo->Id, j); } } SpellRangeEntry const* srange = sSpellRangeStore.LookupEntry(m_spellInfo->rangeIndex); float range = GetSpellMaxRange(srange); // override range with default when it's not provided if (!range) { range = m_caster->GetMap()->IsDungeon() ? DEFAULT_VISIBILITY_INSTANCE : DEFAULT_VISIBILITY_DISTANCE; } Creature* targetExplicit = NULL; // used for cases where a target is provided (by script for example) Creature* creatureScriptTarget = NULL; GameObject* goScriptTarget = NULL; for (SQLMultiStorage::SQLMultiSIterator i_spellST = bounds.first; i_spellST != bounds.second; ++i_spellST) { if (i_spellST->CanNotHitWithSpellEffect(SpellEffectIndex(j))) { continue; } switch (i_spellST->type) { case SPELL_TARGET_TYPE_GAMEOBJECT: { GameObject* p_GameObject = NULL; if (i_spellST->targetEntry) { MaNGOS::NearestGameObjectEntryInObjectRangeCheck go_check(*m_caster, i_spellST->targetEntry, range); MaNGOS::GameObjectLastSearcher checker(p_GameObject, go_check); Cell::VisitGridObjects(m_caster, checker, range); if (p_GameObject) { // remember found target and range, next attempt will find more near target with another entry creatureScriptTarget = NULL; goScriptTarget = p_GameObject; range = go_check.GetLastRange(); } } else if (focusObject) // Focus Object { float frange = m_caster->GetDistance(focusObject); if (range >= frange) { creatureScriptTarget = NULL; goScriptTarget = focusObject; range = frange; } } break; } case SPELL_TARGET_TYPE_CREATURE: case SPELL_TARGET_TYPE_DEAD: default: { Creature* p_Creature = NULL; // check if explicit target is provided and check it up against database valid target entry/state if (Unit* pTarget = m_targets.getUnitTarget()) { if (pTarget->GetTypeId() == TYPEID_UNIT && pTarget->GetEntry() == i_spellST->targetEntry) { if (i_spellST->type == SPELL_TARGET_TYPE_DEAD && ((Creature*)pTarget)->IsCorpse()) { // always use spellMaxRange, in case GetLastRange returned different in a previous pass if (pTarget->IsWithinDistInMap(m_caster, GetSpellMaxRange(srange))) { targetExplicit = (Creature*)pTarget; } } else if (i_spellST->type == SPELL_TARGET_TYPE_CREATURE && pTarget->IsAlive()) { // always use spellMaxRange, in case GetLastRange returned different in a previous pass if (pTarget->IsWithinDistInMap(m_caster, GetSpellMaxRange(srange))) { targetExplicit = (Creature*)pTarget; } } } } // no target provided or it was not valid, so use closest in range if (!targetExplicit) { MaNGOS::NearestCreatureEntryWithLiveStateInObjectRangeCheck u_check(*m_caster, i_spellST->targetEntry, i_spellST->type != SPELL_TARGET_TYPE_DEAD, i_spellST->type == SPELL_TARGET_TYPE_DEAD, range); MaNGOS::CreatureLastSearcher searcher(p_Creature, u_check); // Visit all, need to find also Pet* objects Cell::VisitAllObjects(m_caster, searcher, range); range = u_check.GetLastRange(); } // always prefer provided target if it's valid if (targetExplicit) { creatureScriptTarget = targetExplicit; } else if (p_Creature) { creatureScriptTarget = p_Creature; } if (creatureScriptTarget) { goScriptTarget = NULL; } break; } } } if (creatureScriptTarget) { // store coordinates for TARGET_SCRIPT_COORDINATES if (m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT_COORDINATES || m_spellInfo->EffectImplicitTargetB[j] == TARGET_SCRIPT_COORDINATES) { m_targets.setDestination(creatureScriptTarget->GetPositionX(), creatureScriptTarget->GetPositionY(), creatureScriptTarget->GetPositionZ()); if (m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT_COORDINATES && m_spellInfo->Effect[j] != SPELL_EFFECT_PERSISTENT_AREA_AURA) { AddUnitTarget(creatureScriptTarget, SpellEffectIndex(j)); } } // store explicit target for TARGET_SCRIPT else { if (m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT || m_spellInfo->EffectImplicitTargetB[j] == TARGET_SCRIPT) { AddUnitTarget(creatureScriptTarget, SpellEffectIndex(j)); } } } else if (goScriptTarget) { // store coordinates for TARGET_SCRIPT_COORDINATES if (m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT_COORDINATES || m_spellInfo->EffectImplicitTargetB[j] == TARGET_SCRIPT_COORDINATES) { m_targets.setDestination(goScriptTarget->GetPositionX(), goScriptTarget->GetPositionY(), goScriptTarget->GetPositionZ()); if (m_spellInfo->EffectImplicitTargetA[j] == TARGET_SCRIPT_COORDINATES && m_spellInfo->Effect[j] != SPELL_EFFECT_PERSISTENT_AREA_AURA) { AddGOTarget(goScriptTarget, SpellEffectIndex(j)); } } // store explicit target for TARGET_FOCUS_OR_SCRIPTED_GAMEOBJECT else { if (m_spellInfo->EffectImplicitTargetA[j] == TARGET_FOCUS_OR_SCRIPTED_GAMEOBJECT || m_spellInfo->EffectImplicitTargetB[j] == TARGET_FOCUS_OR_SCRIPTED_GAMEOBJECT) { AddGOTarget(goScriptTarget, SpellEffectIndex(j)); } } } // Missing DB Entry or targets for this spellEffect. else { /* For TARGET_FOCUS_OR_SCRIPTED_GAMEOBJECT makes DB targets optional not required for now * TODO: Makes more research for this target type */ if (m_spellInfo->EffectImplicitTargetA[j] != TARGET_FOCUS_OR_SCRIPTED_GAMEOBJECT) { // not report target not existence for triggered spells if (m_triggeredByAuraSpell || m_IsTriggeredSpell) { return SPELL_FAILED_DONT_REPORT; } else { return SPELL_FAILED_BAD_TARGETS; } } } } } } if (!m_IsTriggeredSpell) { SpellCastResult castResult = CheckRange(strict); if (castResult != SPELL_CAST_OK) { return castResult; } if (Unit* target = m_targets.getUnitTarget()) { if (m_caster->GetTypeId() == TYPEID_PLAYER && (sSpellMgr.GetSpellFacingFlag(m_spellInfo->Id) & SPELL_FACING_FLAG_INFRONT) && !m_caster->HasInArc(M_PI_F, target)) { return SPELL_FAILED_UNIT_NOT_INFRONT; } } } { SpellCastResult castResult = CheckPower(); if (castResult != SPELL_CAST_OK) { return castResult; } } if (!m_IsTriggeredSpell) // triggered spell not affected by stun/etc { SpellCastResult castResult = CheckCasterAuras(); if (castResult != SPELL_CAST_OK) { return castResult; } } for (int i = 0; i < MAX_EFFECT_INDEX; ++i) { // for effects of spells that have only one target switch (m_spellInfo->Effect[i]) { case SPELL_EFFECT_DUMMY: { if (m_spellInfo->SpellIconID == 1648) // Execute { if (!m_targets.getUnitTarget() || m_targets.getUnitTarget()->GetHealth() > m_targets.getUnitTarget()->GetMaxHealth() * 0.2) { return SPELL_FAILED_BAD_TARGETS; } } else if (m_spellInfo->SpellIconID == 156) // Holy Shock { // spell different for friends and enemies // hart version required facing if (m_targets.getUnitTarget() && !m_caster->IsFriendlyTo(m_targets.getUnitTarget()) && !m_caster->HasInArc(M_PI_F, m_targets.getUnitTarget())) { return SPELL_FAILED_UNIT_NOT_INFRONT; } } break; } case SPELL_EFFECT_DISTRACT: // All nearby enemies must not be in combat { if (m_targets.m_targetMask & (TARGET_FLAG_DEST_LOCATION | TARGET_FLAG_SOURCE_LOCATION)) { UnitList targetsCombat; float radius = GetSpellRadius(sSpellRadiusStore.LookupEntry(m_spellInfo->EffectRadiusIndex[i])); FillAreaTargets(targetsCombat, radius, PUSH_DEST_CENTER, SPELL_TARGETS_AOE_DAMAGE); if (targetsCombat.empty()) { break; } for (UnitList::iterator itr = targetsCombat.begin(); itr != targetsCombat.end(); ++itr) if ((*itr)->IsInCombat()) { return SPELL_FAILED_TARGET_IN_COMBAT; } } break; } case SPELL_EFFECT_SCHOOL_DAMAGE: { // Hammer of Wrath if (m_spellInfo->SpellVisual == 7250) { if (!m_targets.getUnitTarget()) { return SPELL_FAILED_BAD_IMPLICIT_TARGETS; } if (m_targets.getUnitTarget()->GetHealth() > m_targets.getUnitTarget()->GetMaxHealth() * 0.2) { return SPELL_FAILED_BAD_TARGETS; } } // Conflagrate else if (m_spellInfo->SpellFamilyName == SPELLFAMILY_WARLOCK && m_spellInfo->SpellFamilyFlags & UI64LIT(0x0000000000000200)) { if (!m_targets.getUnitTarget()) { return SPELL_FAILED_BAD_IMPLICIT_TARGETS; } // for caster applied auras only bool found = false; Unit::AuraList const& mPeriodic = m_targets.getUnitTarget()->GetAurasByType(SPELL_AURA_PERIODIC_DAMAGE); for (Unit::AuraList::const_iterator i = mPeriodic.begin(); i != mPeriodic.end(); ++i) { if ((*i)->GetSpellProto()->SpellFamilyName == SPELLFAMILY_WARLOCK && (*i)->GetCasterGuid() == m_caster->GetObjectGuid() && // Immolate ((*i)->GetSpellProto()->SpellFamilyFlags & UI64LIT(0x0000000000000004))) { found = true; break; } } if (!found) { return SPELL_FAILED_TARGET_AURASTATE; } } break; } case SPELL_EFFECT_TAMECREATURE: { if (m_triggeredBySpellInfo == NULL) { SpellCastResult castResult = CanTameUnit(true); if (castResult != SPELL_CAST_OK) { return castResult; } } break; } case SPELL_EFFECT_LEARN_SPELL: { if (m_spellInfo->EffectImplicitTargetA[i] != TARGET_PET) { break; } Pet* pet = m_caster->GetPet(); if (!pet) { return SPELL_FAILED_NO_PET; } SpellEntry const* learn_spellproto = sSpellStore.LookupEntry(m_spellInfo->EffectTriggerSpell[i]); if (!learn_spellproto) { return SPELL_FAILED_NOT_KNOWN; } if (!pet->CanTakeMoreActiveSpells(learn_spellproto->Id)) { return SPELL_FAILED_TOO_MANY_SKILLS; } if (m_spellInfo->spellLevel > pet->getLevel()) { return SPELL_FAILED_LOWLEVEL; } if (!pet->HasTPForSpell(learn_spellproto->Id)) { return SPELL_FAILED_TRAINING_POINTS; } break; } case SPELL_EFFECT_LEARN_PET_SPELL: { Pet* pet = m_caster->GetPet(); if (!pet) { return SPELL_FAILED_NO_PET; } SpellEntry const* learn_spellproto = sSpellStore.LookupEntry(m_spellInfo->EffectTriggerSpell[i]); if (!learn_spellproto) { return SPELL_FAILED_NOT_KNOWN; } if (!pet->CanTakeMoreActiveSpells(learn_spellproto->Id)) { return SPELL_FAILED_TOO_MANY_SKILLS; } if (m_spellInfo->spellLevel > pet->getLevel()) { return SPELL_FAILED_LOWLEVEL; } if (!pet->HasTPForSpell(learn_spellproto->Id)) { return SPELL_FAILED_TRAINING_POINTS; } break; } case SPELL_EFFECT_FEED_PET: { if (m_caster->GetTypeId() != TYPEID_PLAYER) { return SPELL_FAILED_BAD_TARGETS; } Item* foodItem = m_targets.getItemTarget(); if (!foodItem) { return SPELL_FAILED_BAD_TARGETS; } Pet* pet = m_caster->GetPet(); if (!pet) { return SPELL_FAILED_NO_PET; } if (!pet->HaveInDiet(foodItem->GetProto())) { return SPELL_FAILED_WRONG_PET_FOOD; } if (!pet->GetCurrentFoodBenefitLevel(foodItem->GetProto()->ItemLevel)) { return SPELL_FAILED_FOOD_LOWLEVEL; } if (pet->IsInCombat()) { return SPELL_FAILED_AFFECTING_COMBAT; } break; } case SPELL_EFFECT_POWER_BURN: case SPELL_EFFECT_POWER_DRAIN: { // Can be area effect, Check only for players and not check if target - caster (spell can have multiply drain/burn effects) if (m_caster->GetTypeId() == TYPEID_PLAYER) if (Unit* target = m_targets.getUnitTarget()) if (target != m_caster && int32(target->GetPowerType()) != m_spellInfo->EffectMiscValue[i]) { return SPELL_FAILED_BAD_TARGETS; } break; } case SPELL_EFFECT_CHARGE: { if (m_caster->hasUnitState(UNIT_STAT_ROOT)) { return SPELL_FAILED_ROOTED; } break; } case SPELL_EFFECT_SKINNING: { if (m_caster->GetTypeId() != TYPEID_PLAYER || !m_targets.getUnitTarget() || m_targets.getUnitTarget()->GetTypeId() != TYPEID_UNIT) { return SPELL_FAILED_BAD_TARGETS; } if (!m_targets.getUnitTarget()->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE)) { return SPELL_FAILED_TARGET_UNSKINNABLE; } Creature* creature = (Creature*)m_targets.getUnitTarget(); if (creature->GetCreatureType() != CREATURE_TYPE_CRITTER && (!creature->lootForBody || creature->lootForSkin || !creature->loot.empty())) { return SPELL_FAILED_TARGET_NOT_LOOTED; } uint32 skill = creature->GetCreatureInfo()->GetRequiredLootSkill(); int32 skillValue = ((Player*)m_caster)->GetSkillValue(skill); int32 TargetLevel = m_targets.getUnitTarget()->getLevel(); int32 ReqValue = (skillValue < 100 ? (TargetLevel - 10) * 10 : TargetLevel * 5); if (ReqValue > skillValue) { return SPELL_FAILED_SKILL_NOT_HIGH_ENOUGH; } // chance for fail at orange skinning attempt if ((m_selfContainer && (*m_selfContainer) == this) && skillValue < sWorld.GetConfigMaxSkillValue() && (ReqValue < 0 ? 0 : ReqValue) > irand(skillValue - 25, skillValue + 37)) { return SPELL_FAILED_TRY_AGAIN; } break; } case SPELL_EFFECT_OPEN_LOCK_ITEM: case SPELL_EFFECT_OPEN_LOCK: { if (m_caster->GetTypeId() != TYPEID_PLAYER) // only players can open locks, gather etc. { return SPELL_FAILED_BAD_TARGETS; } // we need a go target in case of TARGET_GAMEOBJECT (for other targets acceptable GO and items) if (m_spellInfo->EffectImplicitTargetA[i] == TARGET_GAMEOBJECT) { if (!m_targets.getGOTarget()) { return SPELL_FAILED_BAD_TARGETS; } } // get the lock entry uint32 lockId = 0; if (GameObject* go = m_targets.getGOTarget()) { // Prevent opening two times a chest in same time. if (go->GetGoType() == GAMEOBJECT_TYPE_CHEST && go->GetGoState() == GO_STATE_ACTIVE) { return SPELL_FAILED_CHEST_IN_USE; } // In BattleGround players can use only flags and banners if (((Player*)m_caster)->InBattleGround() && !((Player*)m_caster)->CanUseBattleGroundObject()) { return SPELL_FAILED_TRY_AGAIN; } lockId = go->GetGOInfo()->GetLockId(); if (!lockId) { return SPELL_FAILED_ALREADY_OPEN; } } else if (Item* item = m_targets.getItemTarget()) { // not own (trade?) if (item->GetOwner() != m_caster) { return SPELL_FAILED_ITEM_GONE; } lockId = item->GetProto()->LockID; // if already unlocked if (!lockId || item->HasFlag(ITEM_FIELD_FLAGS, ITEM_DYNFLAG_UNLOCKED)) { return SPELL_FAILED_ALREADY_OPEN; } } else { return SPELL_FAILED_BAD_TARGETS; } SkillType skillId = SKILL_NONE; int32 reqSkillValue = 0; int32 skillValue = 0; // check lock compatibility SpellCastResult res = CanOpenLock(SpellEffectIndex(i), lockId, skillId, reqSkillValue, skillValue); if (res != SPELL_CAST_OK) { return res; } // chance for fail at orange mining/herb/LockPicking gathering attempt // second check prevent fail at rechecks // Check must be executed at the end of the cast. if (m_executedCurrently && skillId != SKILL_NONE) { bool canFailAtMax = skillId != SKILL_HERBALISM && skillId != SKILL_MINING; // chance for failure in orange gather / lockpick (gathering skill can't fail at maxskill) if ((canFailAtMax || skillValue < sWorld.GetConfigMaxSkillValue()) && reqSkillValue > irand(skillValue - 25, skillValue + 37)) { return SPELL_FAILED_TRY_AGAIN; } } break; } case SPELL_EFFECT_SUMMON_DEAD_PET: { Creature* pet = m_caster->GetPet(); if (pet && pet->IsAlive()) { return SPELL_FAILED_ALREADY_HAVE_SUMMON; } if (!pet) { if (Player* player = m_caster->ToPlayer()) { PetDatabaseStatus status = Pet::GetStatusFromDB(player); if (status == PET_DB_NO_PET) return SPELL_FAILED_NO_PET; else if (status == PET_DB_ALIVE) return SPELL_FAILED_TARGET_NOT_DEAD; } else { return SPELL_FAILED_NO_PET; } } break; } // Don't make this check for SPELL_EFFECT_SUMMON_CRITTER, SPELL_EFFECT_SUMMON_WILD or SPELL_EFFECT_SUMMON_GUARDIAN. // These won't show up in m_caster->GetPetGUID() case SPELL_EFFECT_SUMMON: case SPELL_EFFECT_SUMMON_POSSESSED: case SPELL_EFFECT_SUMMON_PHANTASM: case SPELL_EFFECT_SUMMON_DEMON: { if (m_caster->GetPetGuid()) { return SPELL_FAILED_ALREADY_HAVE_SUMMON; } if (m_caster->GetCharmGuid()) { return SPELL_FAILED_ALREADY_HAVE_CHARM; } break; } case SPELL_EFFECT_SUMMON_PET: { Player* plr = m_caster->ToPlayer(); if (m_caster->GetPetGuid()) // let warlock do a replacement summon { Pet* pet = m_caster->GetPet(); if (plr && m_caster->getClass() != CLASS_WARLOCK) { return SPELL_FAILED_ALREADY_HAVE_SUMMON; } } if (m_caster->GetCharmGuid()) { return SPELL_FAILED_ALREADY_HAVE_CHARM; } if (plr) { PetDatabaseStatus status = Pet::GetStatusFromDB(plr); if (status == PET_DB_DEAD) return SPELL_FAILED_TARGETS_DEAD; else if ((plr->getClass() == CLASS_HUNTER) && (status == PET_DB_NO_PET)) return SPELL_FAILED_NO_PET; } break; } case SPELL_EFFECT_SUMMON_PLAYER: { if (m_caster->GetTypeId() != TYPEID_PLAYER) { return SPELL_FAILED_BAD_TARGETS; } if (!((Player*)m_caster)->GetSelectionGuid()) { return SPELL_FAILED_BAD_TARGETS; } Player* target = sObjectMgr.GetPlayer(((Player*)m_caster)->GetSelectionGuid()); if (!target || ((Player*)m_caster) == target || !target->IsInSameRaidWith((Player*)m_caster)) { return SPELL_FAILED_BAD_TARGETS; } // check if our map is dungeon if (sMapStore.LookupEntry(m_caster->GetMapId())->IsDungeon()) { InstanceTemplate const* instance = ObjectMgr::GetInstanceTemplate(m_caster->GetMapId()); if (!instance) { return SPELL_FAILED_TARGET_NOT_IN_INSTANCE; } if (instance->levelMin > target->getLevel()) { return SPELL_FAILED_LOWLEVEL; } if (instance->levelMax && instance->levelMax < target->getLevel()) { return SPELL_FAILED_HIGHLEVEL; } } break; } case SPELL_EFFECT_LEAP: case SPELL_EFFECT_TELEPORT_UNITS_FACE_CASTER: { if (!m_caster || m_caster->IsTaxiFlying()) return SPELL_FAILED_NOT_ON_TAXI; // Blink has leap first and then removing of auras with root effect // need further research with this if (m_spellInfo->Effect[i] != SPELL_EFFECT_LEAP) { if (m_caster->hasUnitState(UNIT_STAT_ROOT)) return SPELL_FAILED_ROOTED; } if (m_caster->GetTypeId() == TYPEID_PLAYER) { if (((Player*)m_caster)->HasMovementFlag(MOVEFLAG_ONTRANSPORT)) return SPELL_FAILED_NOT_ON_TRANSPORT; // not allow use this effect at battleground until battleground start if (BattleGround const* bg = ((Player*)m_caster)->GetBattleGround()) if (bg->GetStatus() != STATUS_IN_PROGRESS) return SPELL_FAILED_TRY_AGAIN; } break; } default: break; } } for (int i = 0; i < MAX_EFFECT_INDEX; ++i) { // Do not check in case of junk in DBC if (!IsAuraApplyEffect(m_spellInfo, SpellEffectIndex(i))) { continue; } // Possible Unit-target for the spell Unit* expectedTarget = GetPrefilledUnitTargetOrUnitTarget(SpellEffectIndex(i)); switch (m_spellInfo->EffectApplyAuraName[i]) { case SPELL_AURA_MOD_POSSESS: { if (m_caster->GetTypeId() != TYPEID_PLAYER) { return SPELL_FAILED_UNKNOWN; } if (expectedTarget == m_caster) { return SPELL_FAILED_BAD_TARGETS; } if (m_caster->GetPetGuid()) { return SPELL_FAILED_ALREADY_HAVE_SUMMON; } if (m_caster->GetCharmGuid()) { return SPELL_FAILED_ALREADY_HAVE_CHARM; } if (m_caster->GetCharmerGuid()) { return SPELL_FAILED_CHARMED; } if (!expectedTarget) { return SPELL_FAILED_BAD_IMPLICIT_TARGETS; } if (expectedTarget->GetCharmerGuid()) { return SPELL_FAILED_CHARMED; } if (int32(expectedTarget->getLevel()) > CalculateDamage(SpellEffectIndex(i), expectedTarget)) { return SPELL_FAILED_HIGHLEVEL; } break; } case SPELL_AURA_MOD_CHARM: { if (expectedTarget == m_caster) { return SPELL_FAILED_BAD_TARGETS; } if (m_caster->GetPetGuid()) { return SPELL_FAILED_ALREADY_HAVE_SUMMON; } if (m_caster->GetCharmGuid()) { return SPELL_FAILED_ALREADY_HAVE_CHARM; } if (m_caster->GetCharmerGuid()) { return SPELL_FAILED_CHARMED; } if (!expectedTarget) { return SPELL_FAILED_BAD_IMPLICIT_TARGETS; } if (expectedTarget->GetCharmerGuid()) { return SPELL_FAILED_CHARMED; } if (int32(expectedTarget->getLevel()) > CalculateDamage(SpellEffectIndex(i), expectedTarget)) { return SPELL_FAILED_HIGHLEVEL; } break; } case SPELL_AURA_MOD_POSSESS_PET: { if (m_caster->GetTypeId() != TYPEID_PLAYER) { return SPELL_FAILED_UNKNOWN; } if (m_caster->GetCharmGuid()) { return SPELL_FAILED_ALREADY_HAVE_CHARM; } if (m_caster->GetCharmerGuid()) { return SPELL_FAILED_CHARMED; } Pet* pet = m_caster->GetPet(); if (!pet) { return SPELL_FAILED_NO_PET; } if (pet->GetCharmerGuid()) { return SPELL_FAILED_CHARMED; } break; } case SPELL_AURA_MOUNTED: { if (m_caster->IsInWater()) { return SPELL_FAILED_ONLY_ABOVEWATER; } if (m_caster->GetTypeId() == TYPEID_PLAYER && ((Player*)m_caster)->GetTransport()) { return SPELL_FAILED_NO_MOUNTS_ALLOWED; } /// Specific case for Temple of Ahn'Qiraj mounts as they are usable only in AQ40 and are the only mounts allowed here /// TBC and above handle this by using m_spellInfo->AreaId bool isAQ40Mounted = false; switch (m_spellInfo->Id) { case 25863: // spell used by ingame item for Black Qiraji mount (legendary reward) case 26655: // spells also related to Black Qiraji mount but use/trigger unknown case 26656: case 31700: if (m_caster->GetMapId() == 531) isAQ40Mounted = true; break; case 25953: // spells of the 4 regular AQ40 mounts case 26054: case 26055: case 26056: if (m_caster->GetMapId() == 531) { isAQ40Mounted = true; break; } else return SPELL_FAILED_NOT_HERE; default: break; } // Ignore map check if spell have AreaId. AreaId already checked and this prevent special mount spells if (!isAQ40Mounted && m_caster->GetTypeId() == TYPEID_PLAYER && !sMapStore.LookupEntry(m_caster->GetMapId())->IsMountAllowed() && !m_IsTriggeredSpell) //[-ZERO] && !m_spellInfo->AreaId) { return SPELL_FAILED_NO_MOUNTS_ALLOWED; } if (m_caster->GetAreaId() == 35) { return SPELL_FAILED_NO_MOUNTS_ALLOWED; } if (m_caster->IsInDisallowedMountForm()) { return SPELL_FAILED_NOT_SHAPESHIFT; } break; } case SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS: { if (!expectedTarget) { return SPELL_FAILED_BAD_IMPLICIT_TARGETS; } // can be casted at non-friendly unit or own pet/charm if (m_caster->IsFriendlyTo(expectedTarget)) { return SPELL_FAILED_TARGET_FRIENDLY; } break; } case SPELL_AURA_PERIODIC_MANA_LEECH: { if (!expectedTarget) { return SPELL_FAILED_BAD_IMPLICIT_TARGETS; } if (m_caster->GetTypeId() != TYPEID_PLAYER || m_CastItem) { break; } if (expectedTarget->GetPowerType() != POWER_MANA) { return SPELL_FAILED_BAD_TARGETS; } break; } case SPELL_AURA_WATER_WALK: { if (!expectedTarget) return SPELL_FAILED_BAD_IMPLICIT_TARGETS; if (expectedTarget->GetTypeId() == TYPEID_PLAYER) { Player const* player = static_cast(expectedTarget); // Player is not allowed to cast water walk on shapeshifted/mounted player if (player->GetShapeshiftForm() != FORM_NONE || player->IsMounted()) { return SPELL_FAILED_BAD_TARGETS; } } } default: break; } } // check trade slot case (last, for allow catch any another cast problems) if (m_targets.m_targetMask & TARGET_FLAG_TRADE_ITEM) { if (m_caster->GetTypeId() != TYPEID_PLAYER) { return SPELL_FAILED_NOT_TRADING; } Player* pCaster = ((Player*)m_caster); TradeData* my_trade = pCaster->GetTradeData(); if (!my_trade) { return SPELL_FAILED_NOT_TRADING; } TradeSlots slot = TradeSlots(m_targets.getItemTargetGuid().GetRawValue()); if (slot != TRADE_SLOT_NONTRADED) { return SPELL_FAILED_ITEM_NOT_READY; } // if trade not complete then remember it in trade data if (!my_trade->IsInAcceptProcess()) { // Spell will be casted at completing the trade. Silently ignore at this place my_trade->SetSpell(m_spellInfo->Id, m_CastItem); return SPELL_FAILED_DONT_REPORT; } } // all ok return SPELL_CAST_OK; } SpellCastResult Spell::CheckPetCast(Unit* target) { if (!m_caster->IsAlive()) { return SPELL_FAILED_CASTER_DEAD; } if (m_caster->IsNonMeleeSpellCasted(false)) // prevent spellcast interruption by another spellcast { return SPELL_FAILED_SPELL_IN_PROGRESS; } if (m_caster->IsInCombat() && IsNonCombatSpell(m_spellInfo)) { return SPELL_FAILED_AFFECTING_COMBAT; } if (m_caster->GetTypeId() == TYPEID_UNIT && (((Creature*)m_caster)->IsPet() || m_caster->IsCharmed())) { // dead owner (pets still alive when owners ressed?) if (m_caster->GetCharmerOrOwner() && !m_caster->GetCharmerOrOwner()->IsAlive()) { return SPELL_FAILED_CASTER_DEAD; } if (!target && m_targets.getUnitTarget()) { target = m_targets.getUnitTarget(); } bool need = false; for (int i = 0; i < MAX_EFFECT_INDEX; ++i) { if (m_spellInfo->EffectImplicitTargetA[i] == TARGET_CHAIN_DAMAGE || m_spellInfo->EffectImplicitTargetA[i] == TARGET_SINGLE_FRIEND || m_spellInfo->EffectImplicitTargetA[i] == TARGET_SINGLE_FRIEND_2 || m_spellInfo->EffectImplicitTargetA[i] == TARGET_DUELVSPLAYER || m_spellInfo->EffectImplicitTargetA[i] == TARGET_SINGLE_PARTY || m_spellInfo->EffectImplicitTargetA[i] == TARGET_CURRENT_ENEMY_COORDINATES) { need = true; if (!target) { return SPELL_FAILED_BAD_IMPLICIT_TARGETS; } break; } } if (need) { m_targets.setUnitTarget(target); } Unit* _target = m_targets.getUnitTarget(); if (_target) // for target dead/target not valid { if (!_target->IsTargetableForAttack()) { return SPELL_FAILED_BAD_TARGETS; } // guessed error if (IsPositiveSpell(m_spellInfo->Id)) { if (m_caster->IsHostileTo(_target)) { return SPELL_FAILED_BAD_TARGETS; } } else { bool duelvsplayertar = false; for (int j = 0; j < MAX_EFFECT_INDEX; ++j) { // TARGET_DUELVSPLAYER is positive AND negative duelvsplayertar |= (m_spellInfo->EffectImplicitTargetA[j] == TARGET_DUELVSPLAYER); } if (m_caster->IsFriendlyTo(target) && !duelvsplayertar) { return SPELL_FAILED_BAD_TARGETS; } } } // cooldown if (((Creature*)m_caster)->HasSpellCooldown(m_spellInfo->Id)) { return SPELL_FAILED_NOT_READY; } } return CheckCast(true); } SpellCastResult Spell::CheckCasterAuras() const { // Flag drop spells totally immuned to caster auras // FIXME: find more nice check for all totally immuned spells // HasAttribute(SPELL_ATTR_EX3_UNK28) ? if (m_spellInfo->Id == 23336 || // Alliance Flag Drop m_spellInfo->Id == 23334) // Horde Flag Drop { return SPELL_CAST_OK; } uint8 school_immune = 0; uint32 mechanic_immune = 0; uint32 dispel_immune = 0; // Check if the spell grants school or mechanic immunity. // We use bitmasks so the loop is done only once and not on every aura check below. if (m_spellInfo->HasAttribute(SPELL_ATTR_EX_DISPEL_AURAS_ON_IMMUNITY)) { for (int i = 0; i < MAX_EFFECT_INDEX; ++i) { if (m_spellInfo->EffectApplyAuraName[i] == SPELL_AURA_SCHOOL_IMMUNITY) { school_immune |= uint32(m_spellInfo->EffectMiscValue[i]); } else if (m_spellInfo->EffectApplyAuraName[i] == SPELL_AURA_MECHANIC_IMMUNITY) { mechanic_immune |= 1 << uint32(m_spellInfo->EffectMiscValue[i] - 1); } else if (m_spellInfo->EffectApplyAuraName[i] == SPELL_AURA_MECHANIC_IMMUNITY_MASK) { mechanic_immune |= uint32(m_spellInfo->EffectMiscValue[i]); } else if (m_spellInfo->EffectApplyAuraName[i] == SPELL_AURA_DISPEL_IMMUNITY) { dispel_immune |= GetDispellMask(DispelType(m_spellInfo->EffectMiscValue[i])); } } } // Check whether the cast should be prevented by any state you might have. SpellCastResult prevented_reason = SPELL_CAST_OK; // Have to check if there is a stun aura. Otherwise will have problems with ghost aura apply while logging out uint32 unitflag = m_caster->GetUInt32Value(UNIT_FIELD_FLAGS); // Get unit state /*[-ZERO] if (unitflag & UNIT_FLAG_STUNNED && !(m_spellInfo->AttributesEx5 & SPELL_ATTR_EX5_USABLE_WHILE_STUNNED)) prevented_reason = SPELL_FAILED_STUNNED; else if (unitflag & UNIT_FLAG_CONFUSED && !(m_spellInfo->AttributesEx5 & SPELL_ATTR_EX5_USABLE_WHILE_CONFUSED)) prevented_reason = SPELL_FAILED_CONFUSED; else if (unitflag & UNIT_FLAG_FLEEING && !(m_spellInfo->AttributesEx5 & SPELL_ATTR_EX5_USABLE_WHILE_FEARED)) prevented_reason = SPELL_FAILED_FLEEING; else */ if (unitflag & UNIT_FLAG_SILENCED && m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE) { prevented_reason = SPELL_FAILED_SILENCED; } else if (unitflag & UNIT_FLAG_PACIFIED && m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY) { prevented_reason = SPELL_FAILED_PACIFIED; } // Attr must make flag drop spell totally immune from all effects if (prevented_reason != SPELL_CAST_OK) { if (school_immune || mechanic_immune || dispel_immune) { // Checking auras is needed now, because you are prevented by some state but the spell grants immunity. Unit::SpellAuraHolderMap const& auras = m_caster->GetSpellAuraHolderMap(); for (Unit::SpellAuraHolderMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr) { SpellAuraHolder* holder = itr->second; SpellEntry const* pEntry = holder->GetSpellProto(); if ((GetSpellSchoolMask(pEntry) & school_immune) && !pEntry->HasAttribute(SPELL_ATTR_EX_UNAFFECTED_BY_SCHOOL_IMMUNE)) { continue; } if ((1 << (pEntry->Dispel)) & dispel_immune) { continue; } for (int32 i = 0; i < MAX_EFFECT_INDEX; ++i) { Aura* aura = holder->GetAuraByEffectIndex(SpellEffectIndex(i)); if (!aura) { continue; } if (GetSpellMechanicMask(pEntry, 1 << i) & mechanic_immune) { continue; } // Make a second check for spell failed so the right SPELL_FAILED message is returned. // That is needed when your casting is prevented by multiple states and you are only immune to some of them. switch (aura->GetModifier()->m_auraname) { /* Zero case SPELL_AURA_MOD_STUN: if (!(m_spellInfo->AttributesEx5 & SPELL_ATTR_EX5_USABLE_WHILE_STUNNED)) return SPELL_FAILED_STUNNED; break; case SPELL_AURA_MOD_CONFUSE: if (!(m_spellInfo->AttributesEx5 & SPELL_ATTR_EX5_USABLE_WHILE_CONFUSED)) return SPELL_FAILED_CONFUSED; break; case SPELL_AURA_MOD_FEAR: if (!(m_spellInfo->AttributesEx5 & SPELL_ATTR_EX5_USABLE_WHILE_FEARED)) return SPELL_FAILED_FLEEING; break; */ case SPELL_AURA_MOD_SILENCE: case SPELL_AURA_MOD_PACIFY: case SPELL_AURA_MOD_PACIFY_SILENCE: if (m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY) { return SPELL_FAILED_PACIFIED; } else if (m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE) { return SPELL_FAILED_SILENCED; } break; default: break; } } } } // You are prevented from casting and the spell casted does not grant immunity. Return a failed error. else { return prevented_reason; } } return SPELL_CAST_OK; } bool Spell::CanAutoCast(Unit* target) { ObjectGuid targetguid = target->GetObjectGuid(); for (int j = 0; j < MAX_EFFECT_INDEX; ++j) { if (m_spellInfo->Effect[j] == SPELL_EFFECT_APPLY_AURA) { if (m_spellInfo->StackAmount <= 1) { if (target->HasAura(m_spellInfo->Id, SpellEffectIndex(j))) { return false; } } else { if (Aura* aura = target->GetAura(m_spellInfo->Id, SpellEffectIndex(j))) if (aura->GetStackAmount() >= m_spellInfo->StackAmount) { return false; } } } else if (IsAreaAuraEffect(m_spellInfo->Effect[j])) { if (target->HasAura(m_spellInfo->Id, SpellEffectIndex(j))) { return false; } } } SpellCastResult result = CheckPetCast(target); if (result == SPELL_CAST_OK || result == SPELL_FAILED_UNIT_NOT_INFRONT) { FillTargetMap(); // check if among target units, our WANTED target is as well (->only self cast spells return false) for (TargetList::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit) if (ihit->targetGUID == targetguid) { return true; } } return false; // target invalid } SpellCastResult Spell::CheckRange(bool strict) { Unit* target = m_targets.getUnitTarget(); // special range cases switch (m_spellInfo->rangeIndex) { // self cast doesn't need range checking -- also for Starshards fix // spells that can be cast anywhere also need no check case SPELL_RANGE_IDX_SELF_ONLY: case SPELL_RANGE_IDX_ANYWHERE: return SPELL_CAST_OK; // combat range spells are treated differently case SPELL_RANGE_IDX_COMBAT: { if (target) { if (target == m_caster) { return SPELL_CAST_OK; } float range_mod = strict ? 0.0f : 5.0f; float base = ATTACK_DISTANCE; if (Player* modOwner = m_caster->GetSpellModOwner()) { float base = ATTACK_DISTANCE; range_mod += modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_RANGE, base, this); } // with additional 5 dist for non stricted case (some melee spells have delay in apply return m_caster->CanReachWithMeleeAttack(target, range_mod) ? SPELL_CAST_OK : SPELL_FAILED_OUT_OF_RANGE; } break; // let continue in generic way for no target } case SPELL_RANGE_IDX_SHORT: { if ((m_spellInfo->SpellFamilyName == SPELLFAMILY_HUNTER && (m_spellInfo->SpellFamilyFlags & UI64LIT(0x00000080) || m_spellInfo->SpellFamilyFlags & 0x800000))) { Pet* pet = m_caster->GetPet(); if (pet) { float max_range = GetSpellMaxRange(sSpellRangeStore.LookupEntry(SPELL_RANGE_IDX_SHORT)); return m_caster->IsWithinDistInMap(pet, max_range) ? SPELL_CAST_OK : SPELL_FAILED_OUT_OF_RANGE; } } break; } } // add radius of caster and ~5 yds "give" for non stricred (landing) check float range_mod = strict ? 1.25f : 6.25; SpellRangeEntry const* srange = sSpellRangeStore.LookupEntry(m_spellInfo->rangeIndex); float max_range = GetSpellMaxRange(srange) + range_mod; float min_range = GetSpellMinRange(srange); if (Player* modOwner = m_caster->GetSpellModOwner()) { modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_RANGE, max_range, this); } if (target && target != m_caster) { // distance from target in checks float dist = m_caster->GetCombatDistance(target, m_spellInfo->rangeIndex == SPELL_RANGE_IDX_COMBAT); if (dist > max_range) { return SPELL_FAILED_OUT_OF_RANGE; } if (min_range && dist < min_range) { return SPELL_FAILED_TOO_CLOSE; } } // TODO verify that such spells really use bounding radius if (m_targets.m_targetMask == TARGET_FLAG_DEST_LOCATION && m_targets.m_destX != 0 && m_targets.m_destY != 0 && m_targets.m_destZ != 0) { if (!m_caster->IsWithinDist3d(m_targets.m_destX, m_targets.m_destY, m_targets.m_destZ, max_range)) { return SPELL_FAILED_OUT_OF_RANGE; } if (min_range && m_caster->IsWithinDist3d(m_targets.m_destX, m_targets.m_destY, m_targets.m_destZ, min_range)) { return SPELL_FAILED_TOO_CLOSE; } } return SPELL_CAST_OK; } uint32 Spell::CalculatePowerCost(SpellEntry const* spellInfo, Unit* caster, Spell const* spell, Item* castItem) { // item cast not used power if (castItem) { return 0; } // Spell drain all exist power on cast (Only paladin lay of Hands) if (spellInfo->HasAttribute(SPELL_ATTR_EX_DRAIN_ALL_POWER)) { // If power type - health drain all if (spellInfo->powerType == POWER_HEALTH) { return caster->GetHealth(); } // Else drain all power if (spellInfo->powerType < MAX_POWERS) { return caster->GetPower(Powers(spellInfo->powerType)); } sLog.outError("Spell::CalculateManaCost: Unknown power type '%d' in spell %d", spellInfo->powerType, spellInfo->Id); return 0; } // Base powerCost int32 powerCost = spellInfo->manaCost; // PCT cost from total amount if (spellInfo->ManaCostPercentage) { switch (spellInfo->powerType) { // health as power used case POWER_HEALTH: powerCost += spellInfo->ManaCostPercentage * caster->GetCreateHealth() / 100; break; case POWER_MANA: powerCost += spellInfo->ManaCostPercentage * caster->GetCreateMana() / 100; break; case POWER_RAGE: case POWER_FOCUS: case POWER_ENERGY: case POWER_HAPPINESS: powerCost += spellInfo->ManaCostPercentage * caster->GetMaxPower(Powers(spellInfo->powerType)) / 100; break; default: sLog.outError("Spell::CalculateManaCost: Unknown power type '%d' in spell %d", spellInfo->powerType, spellInfo->Id); return 0; } } SpellSchools school = GetFirstSchoolInMask(spell ? spell->m_spellSchoolMask : GetSpellSchoolMask(spellInfo)); // Flat mod from caster auras by spell school powerCost += caster->GetInt32Value(UNIT_FIELD_POWER_COST_MODIFIER + school); // Apply cost mod by spell if (spell) if (Player* modOwner = caster->GetSpellModOwner()) { modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_COST, powerCost, spell); } if (spellInfo->HasAttribute(SPELL_ATTR_LEVEL_DAMAGE_CALCULATION)) { powerCost = int32(powerCost / (1.117f * spellInfo->spellLevel / caster->getLevel() - 0.1327f)); } // PCT mod from user auras by school powerCost = int32(powerCost * (1.0f + caster->GetFloatValue(UNIT_FIELD_POWER_COST_MULTIPLIER + school))); if (powerCost < 0) { powerCost = 0; } return powerCost; } SpellCastResult Spell::CheckPower() { // never check power for triggered spells if (m_IsTriggeredSpell) return SPELL_CAST_OK; // item cast not used power if (m_CastItem) { return SPELL_CAST_OK; } // Questgivers ignore power requirements for scripts, any other creature (except a per) is checked only in combat if (m_caster->GetTypeId() != TYPEID_PLAYER) { // power for pets should be checked if (!m_caster->GetObjectGuid().IsPet() && m_caster->HasFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_QUESTGIVER) != m_caster->IsInCombat()) return SPELL_CAST_OK; } // health as power used - need check health amount if (m_spellInfo->powerType == POWER_HEALTH) { if (m_caster->GetHealth() <= m_powerCost) return SPELL_FAILED_CANT_DO_THAT_YET; } else // any power except health { // Check valid power type: since the static data (m_spellInfo) are checked, the check should be done elsewhere // [+ZERO] actual DBC power values are 0..3 and uint32(-2) // Check power amount Powers powerType = Powers(m_spellInfo->powerType); if (m_caster->GetPower(powerType) < m_powerCost) { return SPELL_FAILED_NO_POWER; } } return SPELL_CAST_OK; } bool Spell::IgnoreItemRequirements() const { if (m_IsTriggeredSpell) { /// Not own traded item (in trader trade slot) req. reagents including triggered spell case if (Item* targetItem = m_targets.getItemTarget()) if (targetItem->GetOwnerGuid() != m_caster->GetObjectGuid()) { return false; } /// Some triggered spells have same reagents that have master spell /// expected in test: master spell have reagents in first slot then triggered don't must use own if (m_triggeredBySpellInfo && !m_triggeredBySpellInfo->Reagent[0]) { return false; } return true; } return false; } SpellCastResult Spell::CheckItems() { if (m_caster->GetTypeId() != TYPEID_PLAYER) { return SPELL_CAST_OK; } Player* p_caster = (Player*)m_caster; // cast item checks if (m_CastItem) { if (m_CastItem->IsInTrade()) { return SPELL_FAILED_ITEM_GONE; } uint32 itemid = m_CastItem->GetEntry(); if (!p_caster->HasItemCount(itemid, 1)) { return SPELL_FAILED_ITEM_NOT_READY; } ItemPrototype const* proto = m_CastItem->GetProto(); if (!proto) { return SPELL_FAILED_ITEM_NOT_READY; } for (int i = 0; i < 5; ++i) if (proto->Spells[i].SpellCharges) if (m_CastItem->GetSpellCharges(i) == 0) { return SPELL_FAILED_NO_CHARGES_REMAIN; } // consumable cast item checks if (proto->Class == ITEM_CLASS_CONSUMABLE && m_targets.getUnitTarget()) { // such items should only fail if there is no suitable effect at all - see Rejuvenation Potions for example SpellCastResult failReason = SPELL_CAST_OK; for (int i = 0; i < MAX_EFFECT_INDEX; ++i) { // skip check, pet not required like checks, and for TARGET_PET m_targets.getUnitTarget() is not the real target but the caster if (m_spellInfo->EffectImplicitTargetA[i] == TARGET_PET) { continue; } if (m_spellInfo->Effect[i] == SPELL_EFFECT_HEAL) { if (m_targets.getUnitTarget()->GetHealth() == m_targets.getUnitTarget()->GetMaxHealth()) { failReason = SPELL_FAILED_ALREADY_AT_FULL_HEALTH; continue; } else { failReason = SPELL_CAST_OK; break; } } // Mana Potion, Rage Potion, Thistle Tea(Rogue), ... if (m_spellInfo->Effect[i] == SPELL_EFFECT_ENERGIZE) { if (m_spellInfo->EffectMiscValue[i] < 0 || m_spellInfo->EffectMiscValue[i] >= MAX_POWERS) { failReason = SPELL_FAILED_ALREADY_AT_FULL_MANA; continue; } Powers power = Powers(m_spellInfo->EffectMiscValue[i]); uint8 targetClass = m_targets.getUnitTarget()->getClass(); /* Mana */ if (power == POWER_MANA) { if (targetClass == CLASS_WARRIOR || targetClass == CLASS_ROGUE) { failReason = SPELL_FAILED_BAD_TARGETS; continue; } } /* Rage */ else if (power == POWER_RAGE) { if (targetClass != CLASS_WARRIOR && targetClass != CLASS_DRUID) { failReason = SPELL_FAILED_BAD_TARGETS; continue; } } /* Energy */ else if (power == POWER_ENERGY) { if (targetClass != CLASS_ROGUE && targetClass != CLASS_DRUID) { failReason = SPELL_FAILED_BAD_TARGETS; continue; } } if (m_targets.getUnitTarget()->GetPower(power) == m_targets.getUnitTarget()->GetMaxPower(power)) { failReason = SPELL_FAILED_ALREADY_AT_FULL_MANA; continue; } else { failReason = SPELL_CAST_OK; break; } } } if (failReason != SPELL_CAST_OK) { return failReason; } } } // check target item (for triggered case not report error) if (m_targets.getItemTargetGuid()) { if (m_caster->GetTypeId() != TYPEID_PLAYER) return m_IsTriggeredSpell && !(m_targets.m_targetMask & TARGET_FLAG_TRADE_ITEM) ? SPELL_FAILED_DONT_REPORT : SPELL_FAILED_BAD_TARGETS; if (!m_targets.getItemTarget()) return m_IsTriggeredSpell && !(m_targets.m_targetMask & TARGET_FLAG_TRADE_ITEM) ? SPELL_FAILED_DONT_REPORT : SPELL_FAILED_ITEM_GONE; if (!m_targets.getItemTarget()->IsFitToSpellRequirements(m_spellInfo)) return m_IsTriggeredSpell && !(m_targets.m_targetMask & TARGET_FLAG_TRADE_ITEM) ? SPELL_FAILED_DONT_REPORT : SPELL_FAILED_EQUIPPED_ITEM_CLASS; } // if not item target then required item must be equipped (for triggered case not report error) else { if (m_caster->GetTypeId() == TYPEID_PLAYER && !((Player*)m_caster)->HasItemFitToSpellReqirements(m_spellInfo)) { return m_IsTriggeredSpell ? SPELL_FAILED_DONT_REPORT : SPELL_FAILED_EQUIPPED_ITEM_CLASS; } } // check spell focus object if (m_spellInfo->RequiresSpellFocus) { GameObject* ok = NULL; MaNGOS::GameObjectFocusCheck go_check(m_caster, m_spellInfo->RequiresSpellFocus); MaNGOS::GameObjectSearcher checker(ok, go_check); Cell::VisitGridObjects(m_caster, checker, m_caster->GetMap()->GetVisibilityDistance()); if (!ok) { return SPELL_FAILED_REQUIRES_SPELL_FOCUS; } focusObject = ok; // game object found in range } // check reagents (ignore triggered spells with reagents processed by original spell) and special reagent ignore case. if (!IgnoreItemRequirements()) { if (!p_caster->CanNoReagentCast(m_spellInfo)) { for (uint32 i = 0; i < MAX_SPELL_REAGENTS; ++i) { if (m_spellInfo->Reagent[i] <= 0) { continue; } uint32 itemid = m_spellInfo->Reagent[i]; uint32 itemcount = m_spellInfo->ReagentCount[i]; // if CastItem is also spell reagent if (m_CastItem && m_CastItem->GetEntry() == itemid) { ItemPrototype const* proto = m_CastItem->GetProto(); if (!proto) { return SPELL_FAILED_ITEM_NOT_READY; } for (int s = 0; s < MAX_ITEM_PROTO_SPELLS; ++s) { // CastItem will be used up and does not count as reagent int32 charges = m_CastItem->GetSpellCharges(s); if (proto->Spells[s].SpellCharges < 0 && !(proto->ExtraFlags & ITEM_EXTRA_NON_CONSUMABLE) && abs(charges) < 2) { ++itemcount; break; } } } if (!p_caster->HasItemCount(itemid, itemcount)) { return SPELL_FAILED_ITEM_NOT_READY; } } } // check totem-item requirements (items presence in inventory) uint32 totems = MAX_SPELL_TOTEMS; for (int i = 0; i < MAX_SPELL_TOTEMS ; ++i) { if (m_spellInfo->Totem[i] != 0) { if (p_caster->HasItemCount(m_spellInfo->Totem[i], 1)) { totems -= 1; continue; } } else { totems -= 1; } } if (totems != 0) { return SPELL_FAILED_ITEM_GONE; } //[-ZERO] not sure of it /*[-ZERO] to rewrite? // Check items for TotemCategory (items presence in inventory) uint32 TotemCategory = MAX_SPELL_TOTEM_CATEGORIES; for(int i= 0; i < MAX_SPELL_TOTEM_CATEGORIES; ++i) { if (m_spellInfo->TotemCategory[i] != 0) { if (p_caster->HasItemTotemCategory(m_spellInfo->TotemCategory[i])) { TotemCategory -= 1; continue; } } else TotemCategory -= 1; } if (TotemCategory != 0) return SPELL_FAILED_TOTEM_CATEGORY; // 0x7B */ } // special checks for spell effects for (int i = 0; i < MAX_EFFECT_INDEX; ++i) { switch (m_spellInfo->Effect[i]) { case SPELL_EFFECT_CREATE_ITEM: { if (!m_IsTriggeredSpell && m_spellInfo->EffectItemType[i]) { ItemPosCountVec dest; InventoryResult msg = p_caster->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, m_spellInfo->EffectItemType[i], 1); if (msg != EQUIP_ERR_OK) { p_caster->SendEquipError(msg, NULL, NULL, m_spellInfo->EffectItemType[i]); return SPELL_FAILED_DONT_REPORT; } } break; } case SPELL_EFFECT_ENCHANT_ITEM: { Item* targetItem = m_targets.getItemTarget(); if (!targetItem) { return SPELL_FAILED_ITEM_GONE; } if (targetItem->GetProto()->ItemLevel < m_spellInfo->baseLevel) { return SPELL_FAILED_LOWLEVEL; } // Not allow enchant in trade slot for some enchant type if (targetItem->GetOwner() != m_caster) { uint32 enchant_id = m_spellInfo->EffectMiscValue[i]; SpellItemEnchantmentEntry const* pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id); if (!pEnchant) { return SPELL_FAILED_ERROR; } if (pEnchant->slot & ENCHANTMENT_CAN_SOULBOUND) { return SPELL_FAILED_NOT_TRADEABLE; } } break; } case SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY: { Item* item = m_targets.getItemTarget(); if (!item) { return SPELL_FAILED_ITEM_GONE; } // Not allow enchant in trade slot for some enchant type if (item->GetOwner() != m_caster) { uint32 enchant_id = m_spellInfo->EffectMiscValue[i]; SpellItemEnchantmentEntry const* pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id); if (!pEnchant) { return SPELL_FAILED_ERROR; } if (pEnchant->slot & ENCHANTMENT_CAN_SOULBOUND) { return SPELL_FAILED_NOT_TRADEABLE; } } break; } case SPELL_EFFECT_ENCHANT_HELD_ITEM: // check item existence in effect code (not output errors at offhand hold item effect to main hand for example break; case SPELL_EFFECT_DISENCHANT: { if (!m_targets.getItemTarget()) { return SPELL_FAILED_CANT_BE_DISENCHANTED; } // prevent disenchanting in trade slot if (m_targets.getItemTarget()->GetOwnerGuid() != m_caster->GetObjectGuid()) { return SPELL_FAILED_CANT_BE_DISENCHANTED; } ItemPrototype const* itemProto = m_targets.getItemTarget()->GetProto(); if (!itemProto) { return SPELL_FAILED_CANT_BE_DISENCHANTED; } // must have disenchant loot (other static req. checked at item prototype loading) if (!itemProto->DisenchantID) { return SPELL_FAILED_CANT_BE_DISENCHANTED; } break; } case SPELL_EFFECT_WEAPON_DAMAGE: case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL: { if (m_caster->GetTypeId() != TYPEID_PLAYER) { return SPELL_FAILED_TARGET_NOT_PLAYER; } if (m_attackType != RANGED_ATTACK) { break; } Item* pItem = ((Player*)m_caster)->GetWeaponForAttack(m_attackType, true, false); if (!pItem) { return SPELL_FAILED_EQUIPPED_ITEM; } switch (pItem->GetProto()->SubClass) { case ITEM_SUBCLASS_WEAPON_THROWN: { uint32 ammo = pItem->GetEntry(); if (!((Player*)m_caster)->HasItemCount(ammo, 1)) { return SPELL_FAILED_NO_AMMO; } }; break; case ITEM_SUBCLASS_WEAPON_GUN: case ITEM_SUBCLASS_WEAPON_BOW: case ITEM_SUBCLASS_WEAPON_CROSSBOW: { uint32 ammo = ((Player*)m_caster)->GetUInt32Value(PLAYER_AMMO_ID); if (!ammo) { // Requires No Ammo if (m_caster->GetDummyAura(46699)) { break; } // skip other checks return SPELL_FAILED_NO_AMMO; } ItemPrototype const* ammoProto = ObjectMgr::GetItemPrototype(ammo); if (!ammoProto) { return SPELL_FAILED_NO_AMMO; } if (ammoProto->Class != ITEM_CLASS_PROJECTILE) { return SPELL_FAILED_NO_AMMO; } // check ammo ws. weapon compatibility switch (pItem->GetProto()->SubClass) { case ITEM_SUBCLASS_WEAPON_BOW: case ITEM_SUBCLASS_WEAPON_CROSSBOW: if (ammoProto->SubClass != ITEM_SUBCLASS_ARROW) { return SPELL_FAILED_NO_AMMO; } break; case ITEM_SUBCLASS_WEAPON_GUN: if (ammoProto->SubClass != ITEM_SUBCLASS_BULLET) { return SPELL_FAILED_NO_AMMO; } break; default: return SPELL_FAILED_NO_AMMO; } if (!((Player*)m_caster)->HasItemCount(ammo, 1)) { return SPELL_FAILED_NO_AMMO; } }; break; case ITEM_SUBCLASS_WEAPON_WAND: break; default: break; } break; } default: break; } } return SPELL_CAST_OK; } void Spell::Delayed() { if (!m_caster || m_caster->GetTypeId() != TYPEID_PLAYER) { return; } if (m_spellState == SPELL_STATE_DELAYED) { return; } // spell is active and can't be time-backed // spells not losing casting time ( slam, dynamites, bombs.. ) if (!(m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_DAMAGE)) { return; } // check resist chance int32 resistChance = 100; // must be initialized to 100 for percent modifiers ((Player*)m_caster)->ApplySpellMod(m_spellInfo->Id, SPELLMOD_NOT_LOSE_CASTING_TIME, resistChance, this); resistChance += m_caster->GetTotalAuraModifier(SPELL_AURA_RESIST_PUSHBACK) - 100; if (roll_chance_i(resistChance)) { return; } int32 delaytime = GetNextDelayAtDamageMsTime(); if (int32(m_timer) + delaytime > m_casttime) { delaytime = m_casttime - m_timer; m_timer = m_casttime; } else { m_timer += delaytime; } DETAIL_FILTER_LOG(LOG_FILTER_SPELL_CAST, "Spell %u partially interrupted for (%d) ms at damage", m_spellInfo->Id, delaytime); WorldPacket data(SMSG_SPELL_DELAYED, 8 + 4); data << ObjectGuid(m_caster->GetObjectGuid()); data << uint32(delaytime); if (m_caster->GetTypeId() == TYPEID_PLAYER) { ((Player*)m_caster)->SendDirectMessage(&data); } } void Spell::DelayedChannel() { if (!m_caster || m_caster->GetTypeId() != TYPEID_PLAYER || getState() != SPELL_STATE_CASTING) { return; } // check resist chance int32 resistChance = 100; // must be initialized to 100 for percent modifiers ((Player*)m_caster)->ApplySpellMod(m_spellInfo->Id, SPELLMOD_NOT_LOSE_CASTING_TIME, resistChance, this); resistChance += m_caster->GetTotalAuraModifier(SPELL_AURA_RESIST_PUSHBACK) - 100; if (roll_chance_i(resistChance)) { return; } int32 delaytime = GetNextDelayAtDamageMsTime(); if (int32(m_timer) < delaytime) { delaytime = m_timer; m_timer = 0; } else { m_timer -= delaytime; } DEBUG_FILTER_LOG(LOG_FILTER_SPELL_CAST, "Spell %u partially interrupted for %i ms, new duration: %u ms", m_spellInfo->Id, delaytime, m_timer); for (TargetList::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit) { if ((*ihit).missCondition == SPELL_MISS_NONE) { if (Unit* unit = m_caster->GetObjectGuid() == ihit->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID)) { unit->DelaySpellAuraHolder(m_spellInfo->Id, delaytime, unit->GetObjectGuid()); } } } for (int j = 0; j < MAX_EFFECT_INDEX; ++j) { // partially interrupt persistent area auras if (DynamicObject* dynObj = m_caster->GetDynObject(m_spellInfo->Id, SpellEffectIndex(j))) { dynObj->Delay(delaytime); } } SendChannelUpdate(m_timer); } void Spell::UpdateOriginalCasterPointer() { if (m_originalCasterGUID == m_caster->GetObjectGuid()) { m_originalCaster = m_caster; } else if (m_originalCasterGUID.IsGameObject()) { GameObject* go = m_caster->IsInWorld() ? m_caster->GetMap()->GetGameObject(m_originalCasterGUID) : NULL; m_originalCaster = go ? go->GetOwner() : NULL; } else { Unit* unit = ObjectAccessor::GetUnit(*m_caster, m_originalCasterGUID); m_originalCaster = unit && unit->IsInWorld() ? unit : NULL; } } void Spell::UpdatePointers() { UpdateOriginalCasterPointer(); m_targets.Update(m_caster); } bool Spell::CheckTargetCreatureType(Unit* target) const { uint32 spellCreatureTargetMask = m_spellInfo->TargetCreatureType; // Curse of Doom : not find another way to fix spell target check :/ if (m_spellInfo->Id == 603) // in 1.12 "Curse of doom" have only 1 rank. { // not allow cast at player if (target->GetTypeId() == TYPEID_PLAYER) { return false; } spellCreatureTargetMask = 0x7FF; } // Dismiss Pet and Taming Lesson skipped if (m_spellInfo->Id == 2641 || m_spellInfo->Id == 23356) { spellCreatureTargetMask = 0; } if (spellCreatureTargetMask) { uint32 TargetCreatureType = target->GetCreatureTypeMask(); return !TargetCreatureType || (spellCreatureTargetMask & TargetCreatureType); } return true; } CurrentSpellTypes Spell::GetCurrentContainer() { if (IsNextMeleeSwingSpell()) { return(CURRENT_MELEE_SPELL); } else if (IsAutoRepeat()) { return(CURRENT_AUTOREPEAT_SPELL); } else if (IsChanneledSpell(m_spellInfo)) { return(CURRENT_CHANNELED_SPELL); } else { return(CURRENT_GENERIC_SPELL); } } bool Spell::CheckTarget(Unit* target, SpellEffectIndex eff) { // Check targets for creature type mask and remove not appropriate (skip explicit self target case, maybe need other explicit targets) if (m_spellInfo->EffectImplicitTargetA[eff] != TARGET_SELF) { if (!CheckTargetCreatureType(target)) { return false; } } // Check targets for not_selectable unit flag and remove // A player can cast spells on his pet (or other controlled unit) though in any state if (target != m_caster && target->GetCharmerOrOwnerGuid() != m_caster->GetObjectGuid()) { // any unattackable target skipped if (target->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE)) { return false; } // unselectable targets skipped in all cases except TARGET_SCRIPT targeting // in case TARGET_SCRIPT target selected by server always and can't be cheated if ((!m_IsTriggeredSpell || target != m_targets.getUnitTarget()) && target->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE) && m_spellInfo->EffectImplicitTargetA[eff] != TARGET_SCRIPT && m_spellInfo->EffectImplicitTargetB[eff] != TARGET_SCRIPT && m_spellInfo->EffectImplicitTargetA[eff] != TARGET_AREAEFFECT_INSTANT && m_spellInfo->EffectImplicitTargetB[eff] != TARGET_AREAEFFECT_INSTANT && m_spellInfo->EffectImplicitTargetA[eff] != TARGET_AREAEFFECT_CUSTOM && m_spellInfo->EffectImplicitTargetB[eff] != TARGET_AREAEFFECT_CUSTOM && m_spellInfo->EffectImplicitTargetA[eff] != TARGET_NARROW_FRONTAL_CONE && m_spellInfo->EffectImplicitTargetB[eff] != TARGET_NARROW_FRONTAL_CONE) { return false; } } // Check player targets and remove if in GM mode or GM invisibility (for not self casting case) if (target != m_caster && target->GetTypeId() == TYPEID_PLAYER) { if (((Player*)target)->GetVisibility() == VISIBILITY_OFF) { return false; } if (((Player*)target)->isGameMaster() && !IsPositiveSpell(m_spellInfo->Id)) { return false; } } // Check targets for LOS visibility (except spells without range limitations ) if (!DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, m_spellInfo->Id, NULL, SPELL_DISABLE_LOS)) { switch (m_spellInfo->Effect[eff]) { case SPELL_EFFECT_SUMMON_PLAYER: // from anywhere break; case SPELL_EFFECT_DUMMY: if (m_spellInfo->Id != 20577) // Cannibalize break; // fall through case SPELL_EFFECT_RESURRECT_NEW: // player far away, maybe his corpse near? if (target != m_caster && !target->IsWithinLOSInMap(m_caster)) { if (!m_targets.getCorpseTargetGuid()) return false; Corpse* corpse = m_caster->GetMap()->GetCorpse(m_targets.getCorpseTargetGuid()); if (!corpse) return false; if (target->GetObjectGuid() != corpse->GetOwnerGuid()) return false; if (!corpse->IsWithinLOSInMap(m_caster)) return false; } // all ok by some way or another, skip normal check break; default: // normal case // Get GO cast coordinates if original caster -> GO if (target != m_caster) if (WorldObject* caster = GetCastingObject()) if (!target->IsWithinLOSInMap(caster)) return false; break; } } if (target->GetTypeId() != TYPEID_PLAYER && m_spellInfo->HasAttribute(SPELL_ATTR_EX3_TARGET_ONLY_PLAYER) && m_spellInfo->EffectImplicitTargetA[eff] != TARGET_SCRIPT && m_spellInfo->EffectImplicitTargetA[eff] != TARGET_SELF) { return false; } return true; } bool Spell::IsNeedSendToClient() const { return m_spellInfo->SpellVisual != 0 || IsChanneledSpell(m_spellInfo) || m_spellInfo->speed > 0.0f || (!m_triggeredByAuraSpell && !m_IsTriggeredSpell); } bool Spell::IsTriggeredSpellWithRedundentCastTime() const { return m_triggeredByAuraSpell || (m_IsTriggeredSpell && (m_spellInfo->manaCost || m_spellInfo->ManaCostPercentage)); } bool Spell::HaveTargetsForEffect(SpellEffectIndex effect) const { for (TargetList::const_iterator itr = m_UniqueTargetInfo.begin(); itr != m_UniqueTargetInfo.end(); ++itr) if (itr->effectMask & (1 << effect)) { return true; } for (GOTargetList::const_iterator itr = m_UniqueGOTargetInfo.begin(); itr != m_UniqueGOTargetInfo.end(); ++itr) if (itr->effectMask & (1 << effect)) { return true; } for (ItemTargetList::const_iterator itr = m_UniqueItemInfo.begin(); itr != m_UniqueItemInfo.end(); ++itr) if (itr->effectMask & (1 << effect)) { return true; } return false; } SpellEvent::SpellEvent(Spell* spell) : BasicEvent() { m_Spell = spell; } SpellEvent::~SpellEvent() { if (m_Spell->getState() != SPELL_STATE_FINISHED) { m_Spell->cancel(); } if (m_Spell->IsDeletable()) { delete m_Spell; } else { sLog.outError("~SpellEvent: %s %u tried to delete non-deletable spell %u. Was not deleted, causes memory leak.", (m_Spell->GetCaster()->GetTypeId() == TYPEID_PLAYER ? "Player" : "Creature"), m_Spell->GetCaster()->GetGUIDLow(), m_Spell->m_spellInfo->Id); } } bool SpellEvent::Execute(uint64 e_time, uint32 p_time) { // update spell if it is not finished if (m_Spell->getState() != SPELL_STATE_FINISHED) { m_Spell->update(p_time); } // check spell state to process switch (m_Spell->getState()) { case SPELL_STATE_FINISHED: { // spell was finished, check deletable state if (m_Spell->IsDeletable()) { // check, if we do have unfinished triggered spells return true; // spell is deletable, finish event } // event will be re-added automatically at the end of routine) } break; case SPELL_STATE_CASTING: { // this spell is in channeled state, process it on the next update // event will be re-added automatically at the end of routine) } break; case SPELL_STATE_DELAYED: { // first, check, if we have just started if (m_Spell->GetDelayStart() != 0) { // no, we aren't, do the typical update // check, if we have channeled spell on our hands if (IsChanneledSpell(m_Spell->m_spellInfo)) { // evented channeled spell is processed separately, casted once after delay, and not destroyed till finish // check, if we have casting anything else except this channeled spell and autorepeat if (m_Spell->GetCaster()->IsNonMeleeSpellCasted(false, true, true)) { // another non-melee non-delayed spell is casted now, abort m_Spell->cancel(); } else { // do the action (pass spell to channeling state) m_Spell->handle_immediate(); } // event will be re-added automatically at the end of routine) } else { // run the spell handler and think about what we can do next uint64 t_offset = e_time - m_Spell->GetDelayStart(); uint64 n_offset = m_Spell->handle_delayed(t_offset); if (n_offset) { // re-add us to the queue m_Spell->GetCaster()->m_Events.AddEvent(this, m_Spell->GetDelayStart() + n_offset, false); return false; // event not complete } // event complete // finish update event will be re-added automatically at the end of routine) } } else { // delaying had just started, record the moment m_Spell->SetDelayStart(e_time); // re-plan the event for the delay moment m_Spell->GetCaster()->m_Events.AddEvent(this, e_time + m_Spell->GetDelayMoment(), false); return false; // event not complete } } break; default: { // all other states // event will be re-added automatically at the end of routine) } break; } // spell processing not complete, plan event on the next update interval m_Spell->GetCaster()->m_Events.AddEvent(this, e_time + 1, false); return false; // event not complete } void SpellEvent::Abort(uint64 /*e_time*/) { // oops, the spell we try to do is aborted if (m_Spell->getState() != SPELL_STATE_FINISHED) { m_Spell->cancel(); } } bool SpellEvent::IsDeletable() const { return m_Spell->IsDeletable(); } SpellCastResult Spell::CanOpenLock(SpellEffectIndex effIndex, uint32 lockId, SkillType& skillId, int32& reqSkillValue, int32& skillValue) { if (!lockId) // possible case for GO and maybe for items. { return SPELL_CAST_OK; } // Get LockInfo LockEntry const* lockInfo = sLockStore.LookupEntry(lockId); if (!lockInfo) { return SPELL_FAILED_BAD_TARGETS; } bool reqKey = false; // some locks not have reqs for (int j = 0; j < 8; ++j) { switch (lockInfo->Type[j]) { // check key item (many fit cases can be) case LOCK_KEY_ITEM: if (lockInfo->Index[j] && m_CastItem && m_CastItem->GetEntry() == lockInfo->Index[j]) { return SPELL_CAST_OK; } reqKey = true; break; // check key skill (only single first fit case can be) case LOCK_KEY_SKILL: { reqKey = true; // wrong locktype, skip if (uint32(m_spellInfo->EffectMiscValue[effIndex]) != lockInfo->Index[j]) { continue; } skillId = SkillByLockType(LockType(lockInfo->Index[j])); if (skillId != SKILL_NONE) { // skill bonus provided by casting spell (mostly item spells) // add the damage modifier from the spell casted (cheat lock / skeleton key etc.) (use m_currentBasePoints, CalculateDamage returns wrong value) uint32 spellSkillBonus = uint32(m_currentBasePoints[effIndex]); reqSkillValue = lockInfo->Skill[j]; // castitem check: rogue using skeleton keys. the skill values should not be added in this case. skillValue = m_CastItem || m_caster->GetTypeId() != TYPEID_PLAYER ? 0 : ((Player*)m_caster)->GetSkillValue(skillId); skillValue += spellSkillBonus; if (skillValue < reqSkillValue) { return SPELL_FAILED_SKILL_NOT_HIGH_ENOUGH; } } return SPELL_CAST_OK; } } } if (reqKey) { return SPELL_FAILED_BAD_TARGETS; } return SPELL_CAST_OK; } /** * Fill target list by units around (x,y) points at radius distance * @param targetUnitMap Reference to target list that filled by function * @param x X coordinates of center point for target search * @param y Y coordinates of center point for target search * @param radius Radius around (x,y) for target search * @param pushType Additional rules for target area selection (in front, angle, etc) * @param spellTargets Additional rules for target selection base at hostile/friendly state to original spell caster * @param originalCaster If provided set alternative original caster, if =NULL then used Spell::GetAffectiveObject() return */ void Spell::FillAreaTargets(UnitList& targetUnitMap, float radius, SpellNotifyPushType pushType, SpellTargets spellTargets, WorldObject* originalCaster /*=NULL*/) { MaNGOS::SpellNotifierCreatureAndPlayer notifier(*this, targetUnitMap, radius, pushType, spellTargets, originalCaster); Cell::VisitAllObjects(notifier.GetCenterX(), notifier.GetCenterY(), m_caster->GetMap(), notifier, radius); } void Spell::FillRaidOrPartyTargets(UnitList& targetUnitMap, Unit* member, float radius, bool raid, bool withPets, bool withcaster) { Player* pMember = member->GetCharmerOrOwnerPlayerOrPlayerItself(); Group* pGroup = pMember ? pMember->GetGroup() : NULL; if (pGroup) { uint8 subgroup = pMember->GetSubGroup(); for (GroupReference* itr = pGroup->GetFirstMember(); itr != NULL; itr = itr->next()) { Player* Target = itr->getSource(); // IsHostileTo check duel and controlled by enemy if (Target && (raid || subgroup == Target->GetSubGroup()) && !m_caster->IsHostileTo(Target)) { if ((Target == m_caster && withcaster) || (Target != m_caster && m_caster->IsWithinDistInMap(Target, radius))) { targetUnitMap.push_back(Target); } if (withPets) if (Pet* pet = Target->GetPet()) if ((pet == m_caster && withcaster) || (pet != m_caster && m_caster->IsWithinDistInMap(pet, radius))) { targetUnitMap.push_back(pet); } } } } else { Unit* ownerOrSelf = pMember ? pMember : member->GetCharmerOrOwnerOrSelf(); if ((ownerOrSelf == m_caster && withcaster) || (ownerOrSelf != m_caster && m_caster->IsWithinDistInMap(ownerOrSelf, radius))) { targetUnitMap.push_back(ownerOrSelf); } if (withPets) if (Pet* pet = ownerOrSelf->GetPet()) if ((pet == m_caster && withcaster) || (pet != m_caster && m_caster->IsWithinDistInMap(pet, radius))) { targetUnitMap.push_back(pet); } } } WorldObject* Spell::GetAffectiveCasterObject() const { if (!m_originalCasterGUID) { return m_caster; } if (m_originalCasterGUID.IsGameObject() && m_caster->IsInWorld()) { return m_caster->GetMap()->GetGameObject(m_originalCasterGUID); } return m_originalCaster; } WorldObject* Spell::GetCastingObject() const { if (m_originalCasterGUID.IsGameObject()) { return m_caster->IsInWorld() ? m_caster->GetMap()->GetGameObject(m_originalCasterGUID) : NULL; } else { return m_caster; } } void Spell::ResetEffectDamageAndHeal() { m_damage = 0; m_healing = 0; } void Spell::ClearCastItem() { if (m_CastItem == m_targets.getItemTarget()) { m_targets.setItemTarget(NULL); } m_CastItem = NULL; } bool Spell::HasGlobalCooldown() { // global cooldown have only player or controlled units if (m_caster->GetCharmInfo()) { return m_caster->GetCharmInfo()->GetGlobalCooldownMgr().HasGlobalCooldown(m_spellInfo); } else if (m_caster->GetTypeId() == TYPEID_PLAYER) { return ((Player*)m_caster)->GetGlobalCooldownMgr().HasGlobalCooldown(m_spellInfo); } else { return false; } } void Spell::TriggerGlobalCooldown() { int32 gcd = m_spellInfo->StartRecoveryTime; if (!gcd) { return; } // global cooldown can't leave range 1..1.5 secs (if it it) // exist some spells (mostly not player directly casted) that have < 1 sec and > 1.5 sec global cooldowns // but its as test show not affected any spell mods. if (gcd >= 1000 && gcd <= 1500) { // apply haste rating gcd = int32(float(gcd) * m_caster->GetFloatValue(UNIT_MOD_CAST_SPEED)); if (gcd < 1000) { gcd = 1000; } else if (gcd > 1500) { gcd = 1500; } } // global cooldown have only player or controlled units if (m_caster->GetCharmInfo()) { m_caster->GetCharmInfo()->GetGlobalCooldownMgr().AddGlobalCooldown(m_spellInfo, gcd); } else if (m_caster->GetTypeId() == TYPEID_PLAYER) { ((Player*)m_caster)->GetGlobalCooldownMgr().AddGlobalCooldown(m_spellInfo, gcd); } } void Spell::CancelGlobalCooldown() { if (!m_spellInfo->StartRecoveryTime) { return; } // cancel global cooldown when interrupting current cast if (m_caster->GetCurrentSpell(CURRENT_GENERIC_SPELL) != this) { return; } // global cooldown have only player or controlled units if (m_caster->GetCharmInfo()) { m_caster->GetCharmInfo()->GetGlobalCooldownMgr().CancelGlobalCooldown(m_spellInfo); } else if (m_caster->GetTypeId() == TYPEID_PLAYER) { ((Player*)m_caster)->GetGlobalCooldownMgr().CancelGlobalCooldown(m_spellInfo); } } void Spell::GetSpellRangeAndRadius(SpellEffectIndex effIndex, float& radius, uint32& EffectChainTarget, uint32& unMaxTargets) const { if (m_spellInfo->EffectRadiusIndex[effIndex]) { radius = GetSpellRadius(sSpellRadiusStore.LookupEntry(m_spellInfo->EffectRadiusIndex[effIndex])); } else { radius = GetSpellMaxRange(sSpellRangeStore.LookupEntry(m_spellInfo->rangeIndex)); } if (Unit* realCaster = GetAffectiveCaster()) { if (Player* modOwner = realCaster->GetSpellModOwner()) { modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_RADIUS, radius, this); modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_JUMP_TARGETS, EffectChainTarget, this); } } // custom target amount cases switch (m_spellInfo->SpellFamilyName) { case SPELLFAMILY_GENERIC: { switch (m_spellInfo->Id) { case 802: // Mutate Bug (AQ40, Emperor Vek'nilash) case 804: // Explode Bug (AQ40, Emperor Vek'lor) case 23138: // Gate of Shazzrah (MC, Shazzrah) case 24781: // Dream Fog (Emerald Dragons) case 28560: // Summon Blizzard (Naxx, Sapphiron) unMaxTargets = 1; break; case 10258: // Awaken Vault Warder (Uldaman) case 28542: // Life Drain (Naxx, Sapphiron) unMaxTargets = 2; break; case 28796: // Poison Bolt Volley (Naxx, Faerlina) unMaxTargets = 10; break; case 25991: // Poison Bolt Volley (AQ40, Pincess Huhuran) unMaxTargets = 15; break; } break; } default: break; } // custom radius cases switch (m_spellInfo->SpellFamilyName) { case SPELLFAMILY_GENERIC: { switch (m_spellInfo->Id) { case 24811: // Draw Spirit (Lethon) { if (effIndex == EFFECT_INDEX_0) // Copy range from EFF_1 to 0 { radius = GetSpellRadius(sSpellRadiusStore.LookupEntry(m_spellInfo->EffectRadiusIndex[EFFECT_INDEX_1])); } break; } case 28241: // Poison (Naxxramas, Grobbulus Cloud) { if (SpellAuraHolder* auraHolder = m_caster->GetSpellAuraHolder(28158)) { radius = 0.5f * (60000 - auraHolder->GetAuraDuration()) * 0.001f; } break; } default: break; } break; } default: break; } } SpellCastResult Spell::CanTameUnit(bool isGM) { // Spell can be triggered, we need to check original caster prior to caster Unit* caster = GetAffectiveCaster(); if (!caster || caster->GetTypeId() != TYPEID_PLAYER || !m_targets.getUnitTarget() || m_targets.getUnitTarget()->GetTypeId() == TYPEID_PLAYER) { return SPELL_FAILED_BAD_TARGETS; } Player* plrCaster = caster->ToPlayer(); if (plrCaster->getClass() != CLASS_HUNTER) { plrCaster->SendPetTameFailure(PETTAME_UNITSCANTTAME); return SPELL_FAILED_DONT_REPORT; } if (isGM && !ChatHandler(plrCaster).FindCommand("npc tame")) { plrCaster->SendPetTameFailure(PETTAME_UNKNOWNERROR); return SPELL_FAILED_DONT_REPORT; } Creature* target = (Creature*)m_targets.getUnitTarget(); if (target->IsPet() || target->IsCharmed()) { plrCaster->SendPetTameFailure(PETTAME_CREATUREALREADYOWNED); return SPELL_FAILED_DONT_REPORT; } if (target->getLevel() > plrCaster->getLevel() && !isGM) { plrCaster->SendPetTameFailure(PETTAME_TOOHIGHLEVEL); return SPELL_FAILED_DONT_REPORT; } if (!target->GetCreatureInfo()->isTameable()) { plrCaster->SendPetTameFailure(PETTAME_NOTTAMEABLE); return SPELL_FAILED_DONT_REPORT; } Pet* pet = plrCaster->GetPet(); if (pet || plrCaster->GetCharmGuid()) { plrCaster->SendPetTameFailure(PETTAME_ANOTHERSUMMONACTIVE); return SPELL_FAILED_DONT_REPORT; } else { PetDatabaseStatus status = Pet::GetStatusFromDB(plrCaster); if (status != PET_DB_NO_PET) { plrCaster->SendPetTameFailure(PETTAME_ANOTHERSUMMONACTIVE); return SPELL_FAILED_DONT_REPORT; } } return SPELL_CAST_OK; }