/* * Copyright (C) 2008-2017 TrinityCore * * 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, see . */ #include "SpellAuraDefines.h" #include "SpellAuras.h" #include "SpellInfo.h" #include "SpellMgr.h" #include "Spell.h" #include "DBCStores.h" #include "ConditionMgr.h" #include "Player.h" #include "Battleground.h" #include "Vehicle.h" #include "Pet.h" uint32 GetTargetFlagMask(SpellTargetObjectTypes objType) { switch (objType) { case TARGET_OBJECT_TYPE_DEST: return TARGET_FLAG_DEST_LOCATION; case TARGET_OBJECT_TYPE_UNIT_AND_DEST: return TARGET_FLAG_DEST_LOCATION | TARGET_FLAG_UNIT; case TARGET_OBJECT_TYPE_CORPSE_ALLY: return TARGET_FLAG_CORPSE_ALLY; case TARGET_OBJECT_TYPE_CORPSE_ENEMY: return TARGET_FLAG_CORPSE_ENEMY; case TARGET_OBJECT_TYPE_CORPSE: return TARGET_FLAG_CORPSE_ALLY | TARGET_FLAG_CORPSE_ENEMY; case TARGET_OBJECT_TYPE_UNIT: return TARGET_FLAG_UNIT; case TARGET_OBJECT_TYPE_GOBJ: return TARGET_FLAG_GAMEOBJECT; case TARGET_OBJECT_TYPE_GOBJ_ITEM: return TARGET_FLAG_GAMEOBJECT_ITEM; case TARGET_OBJECT_TYPE_ITEM: return TARGET_FLAG_ITEM; case TARGET_OBJECT_TYPE_SRC: return TARGET_FLAG_SOURCE_LOCATION; default: return TARGET_FLAG_NONE; } } SpellImplicitTargetInfo::SpellImplicitTargetInfo(uint32 target) { _target = Targets(target); } bool SpellImplicitTargetInfo::IsArea() const { return GetSelectionCategory() == TARGET_SELECT_CATEGORY_AREA || GetSelectionCategory() == TARGET_SELECT_CATEGORY_CONE; } bool SpellImplicitTargetInfo::IsProximityBasedAoe() const { switch (_target) { case TARGET_UNIT_SRC_AREA_ENTRY: case TARGET_UNIT_SRC_AREA_ENEMY: case TARGET_UNIT_CASTER_AREA_PARTY: case TARGET_UNIT_SRC_AREA_ALLY: case TARGET_UNIT_SRC_AREA_PARTY: case TARGET_UNIT_LASTTARGET_AREA_PARTY: case TARGET_GAMEOBJECT_SRC_AREA: case TARGET_UNIT_CASTER_AREA_RAID: case TARGET_CORPSE_SRC_AREA_ENEMY: return true; case TARGET_UNIT_DEST_AREA_ENTRY: case TARGET_UNIT_DEST_AREA_ENEMY: case TARGET_UNIT_DEST_AREA_ALLY: case TARGET_UNIT_DEST_AREA_PARTY: case TARGET_GAMEOBJECT_DEST_AREA: case TARGET_UNIT_TARGET_AREA_RAID_CLASS: return false; default: TC_LOG_WARN("spells", "SpellImplicitTargetInfo::IsProximityBasedAoe called a non-aoe spell"); return false; } } SpellTargetSelectionCategories SpellImplicitTargetInfo::GetSelectionCategory() const { return _data[_target].SelectionCategory; } SpellTargetReferenceTypes SpellImplicitTargetInfo::GetReferenceType() const { return _data[_target].ReferenceType; } SpellTargetObjectTypes SpellImplicitTargetInfo::GetObjectType() const { return _data[_target].ObjectType; } SpellTargetCheckTypes SpellImplicitTargetInfo::GetCheckType() const { return _data[_target].SelectionCheckType; } SpellTargetDirectionTypes SpellImplicitTargetInfo::GetDirectionType() const { return _data[_target].DirectionType; } float SpellImplicitTargetInfo::CalcDirectionAngle() const { switch (GetDirectionType()) { case TARGET_DIR_FRONT: return 0.0f; case TARGET_DIR_BACK: return static_cast(M_PI); case TARGET_DIR_RIGHT: return static_cast(-M_PI/2); case TARGET_DIR_LEFT: return static_cast(M_PI/2); case TARGET_DIR_FRONT_RIGHT: return static_cast(-M_PI/4); case TARGET_DIR_BACK_RIGHT: return static_cast(-3*M_PI/4); case TARGET_DIR_BACK_LEFT: return static_cast(3*M_PI/4); case TARGET_DIR_FRONT_LEFT: return static_cast(M_PI/4); case TARGET_DIR_RANDOM: return float(rand_norm())*static_cast(2*M_PI); default: return 0.0f; } } Targets SpellImplicitTargetInfo::GetTarget() const { return _target; } uint32 SpellImplicitTargetInfo::GetExplicitTargetMask(bool& srcSet, bool& dstSet) const { uint32 targetMask = 0; if (GetTarget() == TARGET_DEST_TRAJ) { if (!srcSet) targetMask = TARGET_FLAG_SOURCE_LOCATION; if (!dstSet) targetMask |= TARGET_FLAG_DEST_LOCATION; } else { switch (GetReferenceType()) { case TARGET_REFERENCE_TYPE_SRC: if (srcSet) break; targetMask = TARGET_FLAG_SOURCE_LOCATION; break; case TARGET_REFERENCE_TYPE_DEST: if (dstSet) break; targetMask = TARGET_FLAG_DEST_LOCATION; break; case TARGET_REFERENCE_TYPE_TARGET: switch (GetObjectType()) { case TARGET_OBJECT_TYPE_GOBJ: targetMask = TARGET_FLAG_GAMEOBJECT; break; case TARGET_OBJECT_TYPE_GOBJ_ITEM: targetMask = TARGET_FLAG_GAMEOBJECT_ITEM; break; case TARGET_OBJECT_TYPE_UNIT_AND_DEST: case TARGET_OBJECT_TYPE_UNIT: case TARGET_OBJECT_TYPE_DEST: switch (GetCheckType()) { case TARGET_CHECK_ENEMY: targetMask = TARGET_FLAG_UNIT_ENEMY; break; case TARGET_CHECK_ALLY: targetMask = TARGET_FLAG_UNIT_ALLY; break; case TARGET_CHECK_PARTY: targetMask = TARGET_FLAG_UNIT_PARTY; break; case TARGET_CHECK_RAID: targetMask = TARGET_FLAG_UNIT_RAID; break; case TARGET_CHECK_PASSENGER: targetMask = TARGET_FLAG_UNIT_PASSENGER; break; case TARGET_CHECK_RAID_CLASS: // nobreak; default: targetMask = TARGET_FLAG_UNIT; break; } break; default: break; } break; default: break; } } switch (GetObjectType()) { case TARGET_OBJECT_TYPE_SRC: srcSet = true; break; case TARGET_OBJECT_TYPE_DEST: case TARGET_OBJECT_TYPE_UNIT_AND_DEST: dstSet = true; break; default: break; } return targetMask; } SpellImplicitTargetInfo::StaticData SpellImplicitTargetInfo::_data[TOTAL_SPELL_TARGETS] = { {TARGET_OBJECT_TYPE_NONE, TARGET_REFERENCE_TYPE_NONE, TARGET_SELECT_CATEGORY_NYI, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 1 TARGET_UNIT_CASTER {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_NEARBY, TARGET_CHECK_ENEMY, TARGET_DIR_NONE}, // 2 TARGET_UNIT_NEARBY_ENEMY {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_NEARBY, TARGET_CHECK_PARTY, TARGET_DIR_NONE}, // 3 TARGET_UNIT_NEARBY_PARTY {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_NEARBY, TARGET_CHECK_ALLY, TARGET_DIR_NONE}, // 4 TARGET_UNIT_NEARBY_ALLY {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 5 TARGET_UNIT_PET {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_ENEMY, TARGET_DIR_NONE}, // 6 TARGET_UNIT_TARGET_ENEMY {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_SRC, TARGET_SELECT_CATEGORY_AREA, TARGET_CHECK_ENTRY, TARGET_DIR_NONE}, // 7 TARGET_UNIT_SRC_AREA_ENTRY {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_AREA, TARGET_CHECK_ENTRY, TARGET_DIR_NONE}, // 8 TARGET_UNIT_DEST_AREA_ENTRY {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 9 TARGET_DEST_HOME {TARGET_OBJECT_TYPE_NONE, TARGET_REFERENCE_TYPE_NONE, TARGET_SELECT_CATEGORY_NYI, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 10 {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_SRC, TARGET_SELECT_CATEGORY_NYI, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 11 TARGET_UNIT_SRC_AREA_UNK_11 {TARGET_OBJECT_TYPE_NONE, TARGET_REFERENCE_TYPE_NONE, TARGET_SELECT_CATEGORY_NYI, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 12 {TARGET_OBJECT_TYPE_NONE, TARGET_REFERENCE_TYPE_NONE, TARGET_SELECT_CATEGORY_NYI, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 13 {TARGET_OBJECT_TYPE_NONE, TARGET_REFERENCE_TYPE_NONE, TARGET_SELECT_CATEGORY_NYI, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 14 {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_SRC, TARGET_SELECT_CATEGORY_AREA, TARGET_CHECK_ENEMY, TARGET_DIR_NONE}, // 15 TARGET_UNIT_SRC_AREA_ENEMY {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_AREA, TARGET_CHECK_ENEMY, TARGET_DIR_NONE}, // 16 TARGET_UNIT_DEST_AREA_ENEMY {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 17 TARGET_DEST_DB {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 18 TARGET_DEST_CASTER {TARGET_OBJECT_TYPE_NONE, TARGET_REFERENCE_TYPE_NONE, TARGET_SELECT_CATEGORY_NYI, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 19 {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_AREA, TARGET_CHECK_PARTY, TARGET_DIR_NONE}, // 20 TARGET_UNIT_CASTER_AREA_PARTY {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_ALLY, TARGET_DIR_NONE}, // 21 TARGET_UNIT_TARGET_ALLY {TARGET_OBJECT_TYPE_SRC, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 22 TARGET_SRC_CASTER {TARGET_OBJECT_TYPE_GOBJ, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 23 TARGET_GAMEOBJECT_TARGET {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_CONE, TARGET_CHECK_ENEMY, TARGET_DIR_FRONT}, // 24 TARGET_UNIT_CONE_ENEMY_24 {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 25 TARGET_UNIT_TARGET_ANY {TARGET_OBJECT_TYPE_GOBJ_ITEM, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 26 TARGET_GAMEOBJECT_ITEM_TARGET {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 27 TARGET_UNIT_MASTER {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_ENEMY, TARGET_DIR_NONE}, // 28 TARGET_DEST_DYNOBJ_ENEMY {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_ALLY, TARGET_DIR_NONE}, // 29 TARGET_DEST_DYNOBJ_ALLY {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_SRC, TARGET_SELECT_CATEGORY_AREA, TARGET_CHECK_ALLY, TARGET_DIR_NONE}, // 30 TARGET_UNIT_SRC_AREA_ALLY {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_AREA, TARGET_CHECK_ALLY, TARGET_DIR_NONE}, // 31 TARGET_UNIT_DEST_AREA_ALLY {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_FRONT_LEFT}, // 32 TARGET_DEST_CASTER_SUMMON {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_SRC, TARGET_SELECT_CATEGORY_AREA, TARGET_CHECK_PARTY, TARGET_DIR_NONE}, // 33 TARGET_UNIT_SRC_AREA_PARTY {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_AREA, TARGET_CHECK_PARTY, TARGET_DIR_NONE}, // 34 TARGET_UNIT_DEST_AREA_PARTY {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_PARTY, TARGET_DIR_NONE}, // 35 TARGET_UNIT_TARGET_PARTY {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_NYI, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 36 TARGET_DEST_CASTER_UNK_36 {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_LAST, TARGET_SELECT_CATEGORY_AREA, TARGET_CHECK_PARTY, TARGET_DIR_NONE}, // 37 TARGET_UNIT_LASTTARGET_AREA_PARTY {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_NEARBY, TARGET_CHECK_ENTRY, TARGET_DIR_NONE}, // 38 TARGET_UNIT_NEARBY_ENTRY {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 39 TARGET_DEST_CASTER_FISHING {TARGET_OBJECT_TYPE_GOBJ, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_NEARBY, TARGET_CHECK_ENTRY, TARGET_DIR_NONE}, // 40 TARGET_GAMEOBJECT_NEARBY_ENTRY {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_FRONT_RIGHT}, // 41 TARGET_DEST_CASTER_FRONT_RIGHT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_BACK_RIGHT}, // 42 TARGET_DEST_CASTER_BACK_RIGHT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_BACK_LEFT}, // 43 TARGET_DEST_CASTER_BACK_LEFT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_FRONT_LEFT}, // 44 TARGET_DEST_CASTER_FRONT_LEFT {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_ALLY, TARGET_DIR_NONE}, // 45 TARGET_UNIT_TARGET_CHAINHEAL_ALLY {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_NEARBY, TARGET_CHECK_ENTRY, TARGET_DIR_NONE}, // 46 TARGET_DEST_NEARBY_ENTRY {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_FRONT}, // 47 TARGET_DEST_CASTER_FRONT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_BACK}, // 48 TARGET_DEST_CASTER_BACK {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_RIGHT}, // 49 TARGET_DEST_CASTER_RIGHT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_LEFT}, // 50 TARGET_DEST_CASTER_LEFT {TARGET_OBJECT_TYPE_GOBJ, TARGET_REFERENCE_TYPE_SRC, TARGET_SELECT_CATEGORY_AREA, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 51 TARGET_GAMEOBJECT_SRC_AREA {TARGET_OBJECT_TYPE_GOBJ, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_AREA, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 52 TARGET_GAMEOBJECT_DEST_AREA {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_ENEMY, TARGET_DIR_NONE}, // 53 TARGET_DEST_TARGET_ENEMY {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_CONE, TARGET_CHECK_ENEMY, TARGET_DIR_FRONT}, // 54 TARGET_UNIT_CONE_ENEMY_54 {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 55 TARGET_DEST_CASTER_FRONT_LEAP {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_AREA, TARGET_CHECK_RAID, TARGET_DIR_NONE}, // 56 TARGET_UNIT_CASTER_AREA_RAID {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_RAID, TARGET_DIR_NONE}, // 57 TARGET_UNIT_TARGET_RAID {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_NEARBY, TARGET_CHECK_RAID, TARGET_DIR_NONE}, // 58 TARGET_UNIT_NEARBY_RAID {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_CONE, TARGET_CHECK_ALLY, TARGET_DIR_FRONT}, // 59 TARGET_UNIT_CONE_ALLY {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_CONE, TARGET_CHECK_ENTRY, TARGET_DIR_FRONT}, // 60 TARGET_UNIT_CONE_ENTRY {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_AREA, TARGET_CHECK_RAID_CLASS, TARGET_DIR_NONE}, // 61 TARGET_UNIT_TARGET_AREA_RAID_CLASS {TARGET_OBJECT_TYPE_NONE, TARGET_REFERENCE_TYPE_NONE, TARGET_SELECT_CATEGORY_NYI, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 62 TARGET_UNK_62 {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 63 TARGET_DEST_TARGET_ANY {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_FRONT}, // 64 TARGET_DEST_TARGET_FRONT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_BACK}, // 65 TARGET_DEST_TARGET_BACK {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_RIGHT}, // 66 TARGET_DEST_TARGET_RIGHT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_LEFT}, // 67 TARGET_DEST_TARGET_LEFT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_FRONT_RIGHT}, // 68 TARGET_DEST_TARGET_FRONT_RIGHT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_BACK_RIGHT}, // 69 TARGET_DEST_TARGET_BACK_RIGHT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_BACK_LEFT}, // 70 TARGET_DEST_TARGET_BACK_LEFT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_FRONT_LEFT}, // 71 TARGET_DEST_TARGET_FRONT_LEFT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_RANDOM}, // 72 TARGET_DEST_CASTER_RANDOM {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_RANDOM}, // 73 TARGET_DEST_CASTER_RADIUS {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_RANDOM}, // 74 TARGET_DEST_TARGET_RANDOM {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_RANDOM}, // 75 TARGET_DEST_TARGET_RADIUS {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_CHANNEL, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 76 TARGET_DEST_CHANNEL_TARGET {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_CHANNEL, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 77 TARGET_UNIT_CHANNEL_TARGET {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_FRONT}, // 78 TARGET_DEST_DEST_FRONT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_BACK}, // 79 TARGET_DEST_DEST_BACK {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_RIGHT}, // 80 TARGET_DEST_DEST_RIGHT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_LEFT}, // 81 TARGET_DEST_DEST_LEFT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_FRONT_RIGHT}, // 82 TARGET_DEST_DEST_FRONT_RIGHT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_BACK_RIGHT}, // 83 TARGET_DEST_DEST_BACK_RIGHT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_BACK_LEFT}, // 84 TARGET_DEST_DEST_BACK_LEFT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_FRONT_LEFT}, // 85 TARGET_DEST_DEST_FRONT_LEFT {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_RANDOM}, // 86 TARGET_DEST_DEST_RANDOM {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 87 TARGET_DEST_DEST {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 88 TARGET_DEST_DYNOBJ_NONE {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_TRAJ, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 89 TARGET_DEST_TRAJ {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 90 TARGET_UNIT_TARGET_MINIPET {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_RANDOM}, // 91 TARGET_DEST_DEST_RADIUS {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 92 TARGET_UNIT_SUMMONER {TARGET_OBJECT_TYPE_CORPSE, TARGET_REFERENCE_TYPE_SRC, TARGET_SELECT_CATEGORY_AREA, TARGET_CHECK_ENEMY, TARGET_DIR_NONE}, // 93 TARGET_CORPSE_SRC_AREA_ENEMY {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 94 TARGET_UNIT_VEHICLE {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_TARGET, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_PASSENGER, TARGET_DIR_NONE}, // 95 TARGET_UNIT_TARGET_PASSENGER {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 96 TARGET_UNIT_PASSENGER_0 {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 97 TARGET_UNIT_PASSENGER_1 {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 98 TARGET_UNIT_PASSENGER_2 {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 99 TARGET_UNIT_PASSENGER_3 {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 100 TARGET_UNIT_PASSENGER_4 {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 101 TARGET_UNIT_PASSENGER_5 {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 102 TARGET_UNIT_PASSENGER_6 {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 103 TARGET_UNIT_PASSENGER_7 {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_CONE, TARGET_CHECK_ENEMY, TARGET_DIR_FRONT}, // 104 TARGET_UNIT_CONE_ENEMY_104 {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_NONE, TARGET_SELECT_CATEGORY_NYI, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 105 TARGET_UNIT_UNK_105 {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_CHANNEL, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 106 TARGET_DEST_CHANNEL_CASTER {TARGET_OBJECT_TYPE_NONE, TARGET_REFERENCE_TYPE_DEST, TARGET_SELECT_CATEGORY_NYI, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 107 TARGET_UNK_DEST_AREA_UNK_107 {TARGET_OBJECT_TYPE_GOBJ, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_CONE, TARGET_CHECK_DEFAULT, TARGET_DIR_FRONT}, // 108 TARGET_GAMEOBJECT_CONE {TARGET_OBJECT_TYPE_NONE, TARGET_REFERENCE_TYPE_NONE, TARGET_SELECT_CATEGORY_NYI, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 109 {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_NONE, TARGET_SELECT_CATEGORY_NYI, TARGET_CHECK_DEFAULT, TARGET_DIR_NONE}, // 110 TARGET_DEST_UNK_110 }; SpellEffectInfo::SpellEffectInfo(SpellEntry const* spellEntry, SpellInfo const* spellInfo, uint8 effIndex) { _spellInfo = spellInfo; _effIndex = effIndex; Effect = spellEntry->Effect[effIndex]; ApplyAuraName = spellEntry->EffectApplyAuraName[effIndex]; Amplitude = spellEntry->EffectAmplitude[effIndex]; DieSides = spellEntry->EffectDieSides[effIndex]; RealPointsPerLevel = spellEntry->EffectRealPointsPerLevel[effIndex]; BasePoints = spellEntry->EffectBasePoints[effIndex]; PointsPerComboPoint = spellEntry->EffectPointsPerComboPoint[effIndex]; ValueMultiplier = spellEntry->EffectValueMultiplier[effIndex]; DamageMultiplier = spellEntry->EffectDamageMultiplier[effIndex]; BonusMultiplier = spellEntry->EffectBonusMultiplier[effIndex]; MiscValue = spellEntry->EffectMiscValue[effIndex]; MiscValueB = spellEntry->EffectMiscValueB[effIndex]; Mechanic = Mechanics(spellEntry->EffectMechanic[effIndex]); TargetA = SpellImplicitTargetInfo(spellEntry->EffectImplicitTargetA[effIndex]); TargetB = SpellImplicitTargetInfo(spellEntry->EffectImplicitTargetB[effIndex]); RadiusEntry = spellEntry->EffectRadiusIndex[effIndex] ? sSpellRadiusStore.LookupEntry(spellEntry->EffectRadiusIndex[effIndex]) : NULL; ChainTarget = spellEntry->EffectChainTarget[effIndex]; ItemType = spellEntry->EffectItemType[effIndex]; TriggerSpell = spellEntry->EffectTriggerSpell[effIndex]; SpellClassMask = spellEntry->EffectSpellClassMask[effIndex]; ImplicitTargetConditions = NULL; } bool SpellEffectInfo::IsEffect() const { return Effect != 0; } bool SpellEffectInfo::IsEffect(SpellEffects effectName) const { return Effect == uint32(effectName); } bool SpellEffectInfo::IsAura() const { return (IsUnitOwnedAuraEffect() || Effect == SPELL_EFFECT_PERSISTENT_AREA_AURA) && ApplyAuraName != 0; } bool SpellEffectInfo::IsAura(AuraType aura) const { return IsAura() && ApplyAuraName == uint32(aura); } bool SpellEffectInfo::IsTargetingArea() const { return TargetA.IsArea() || TargetB.IsArea(); } bool SpellEffectInfo::IsAreaAuraEffect() const { if (Effect == SPELL_EFFECT_APPLY_AREA_AURA_PARTY || Effect == SPELL_EFFECT_APPLY_AREA_AURA_RAID || Effect == SPELL_EFFECT_APPLY_AREA_AURA_FRIEND || Effect == SPELL_EFFECT_APPLY_AREA_AURA_ENEMY || Effect == SPELL_EFFECT_APPLY_AREA_AURA_PET || Effect == SPELL_EFFECT_APPLY_AREA_AURA_OWNER) return true; return false; } bool SpellEffectInfo::IsFarUnitTargetEffect() const { return (Effect == SPELL_EFFECT_SUMMON_PLAYER) || (Effect == SPELL_EFFECT_SUMMON_RAF_FRIEND) || (Effect == SPELL_EFFECT_RESURRECT) || (Effect == SPELL_EFFECT_RESURRECT_NEW); } bool SpellEffectInfo::IsFarDestTargetEffect() const { return Effect == SPELL_EFFECT_TELEPORT_UNITS; } bool SpellEffectInfo::IsUnitOwnedAuraEffect() const { return IsAreaAuraEffect() || Effect == SPELL_EFFECT_APPLY_AURA; } int32 SpellEffectInfo::CalcValue(Unit const* caster, int32 const* bp, Unit const* /*target*/) const { float basePointsPerLevel = RealPointsPerLevel; int32 basePoints = bp ? *bp : BasePoints; int32 randomPoints = int32(DieSides); // base amount modification based on spell lvl vs caster lvl if (caster && basePointsPerLevel != 0.0f) { int32 level = int32(caster->getLevel()); if (level > int32(_spellInfo->MaxLevel) && _spellInfo->MaxLevel > 0) level = int32(_spellInfo->MaxLevel); else if (level < int32(_spellInfo->BaseLevel)) level = int32(_spellInfo->BaseLevel); // if base level is greater than spell level, reduce by base level (eg. pilgrims foods) level -= int32(std::max(_spellInfo->BaseLevel, _spellInfo->SpellLevel)); basePoints += int32(level * basePointsPerLevel); } // roll in a range <1;EffectDieSides> as of patch 3.3.3 switch (randomPoints) { case 0: break; case 1: basePoints += 1; break; // range 1..1 default: // range can have positive (1..rand) and negative (rand..1) values, so order its for irand int32 randvalue = (randomPoints >= 1) ? irand(1, randomPoints) : irand(randomPoints, 1); basePoints += randvalue; break; } float value = float(basePoints); // random damage if (caster) { // bonus amount from combo points if (caster->m_playerMovingMe) if (uint8 comboPoints = caster->m_playerMovingMe->GetComboPoints()) if (float comboDamage = PointsPerComboPoint) value += comboDamage* comboPoints; value = caster->ApplyEffectModifiers(_spellInfo, _effIndex, value); // amount multiplication based on caster's level if (!caster->IsControlledByPlayer() && _spellInfo->SpellLevel && _spellInfo->SpellLevel != caster->getLevel() && !basePointsPerLevel && _spellInfo->HasAttribute(SPELL_ATTR0_LEVEL_DAMAGE_CALCULATION)) { bool canEffectScale = false; switch (Effect) { case SPELL_EFFECT_SCHOOL_DAMAGE: case SPELL_EFFECT_DUMMY: case SPELL_EFFECT_POWER_DRAIN: case SPELL_EFFECT_HEALTH_LEECH: case SPELL_EFFECT_HEAL: case SPELL_EFFECT_WEAPON_DAMAGE: case SPELL_EFFECT_POWER_BURN: case SPELL_EFFECT_SCRIPT_EFFECT: case SPELL_EFFECT_NORMALIZED_WEAPON_DMG: case SPELL_EFFECT_FORCE_CAST_WITH_VALUE: case SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE: case SPELL_EFFECT_TRIGGER_MISSILE_SPELL_WITH_VALUE: canEffectScale = true; break; default: break; } switch (ApplyAuraName) { case SPELL_AURA_PERIODIC_DAMAGE: case SPELL_AURA_DUMMY: case SPELL_AURA_PERIODIC_HEAL: case SPELL_AURA_DAMAGE_SHIELD: case SPELL_AURA_PROC_TRIGGER_DAMAGE: case SPELL_AURA_PERIODIC_LEECH: case SPELL_AURA_PERIODIC_MANA_LEECH: case SPELL_AURA_SCHOOL_ABSORB: case SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE: canEffectScale = true; break; default: break; } if (canEffectScale) { GtNPCManaCostScalerEntry const* spellScaler = sGtNPCManaCostScalerStore.LookupEntry(_spellInfo->SpellLevel - 1); GtNPCManaCostScalerEntry const* casterScaler = sGtNPCManaCostScalerStore.LookupEntry(caster->getLevel() - 1); if (spellScaler && casterScaler) value *= casterScaler->ratio / spellScaler->ratio; } } } return int32(value); } int32 SpellEffectInfo::CalcBaseValue(int32 value) const { if (DieSides == 0) return value; else return value - 1; } float SpellEffectInfo::CalcValueMultiplier(Unit* caster, Spell* spell) const { float multiplier = ValueMultiplier; if (Player* modOwner = (caster ? caster->GetSpellModOwner() : NULL)) modOwner->ApplySpellMod(_spellInfo->Id, multiplier, spell); return multiplier; } float SpellEffectInfo::CalcDamageMultiplier(Unit* caster, Spell* spell) const { float multiplierPercent = DamageMultiplier * 100.0f; if (Player* modOwner = (caster ? caster->GetSpellModOwner() : NULL)) modOwner->ApplySpellMod(_spellInfo->Id, multiplierPercent, spell); return multiplierPercent / 100.0f; } bool SpellEffectInfo::HasRadius() const { return RadiusEntry != NULL; } float SpellEffectInfo::CalcRadius(Unit* caster, Spell* spell) const { if (!HasRadius()) return 0.0f; float radius = RadiusEntry->RadiusMin; if (caster) { radius += RadiusEntry->RadiusPerLevel * caster->getLevel(); radius = std::min(radius, RadiusEntry->RadiusMax); if (Player* modOwner = caster->GetSpellModOwner()) modOwner->ApplySpellMod(_spellInfo->Id, radius, spell); } return radius; } uint32 SpellEffectInfo::GetProvidedTargetMask() const { return GetTargetFlagMask(TargetA.GetObjectType()) | GetTargetFlagMask(TargetB.GetObjectType()); } uint32 SpellEffectInfo::GetMissingTargetMask(bool srcSet /*= false*/, bool dstSet /*= false*/, uint32 mask /*=0*/) const { uint32 effImplicitTargetMask = GetTargetFlagMask(GetUsedTargetObjectType()); uint32 providedTargetMask = GetProvidedTargetMask() | mask; // remove all flags covered by effect target mask if (providedTargetMask & TARGET_FLAG_UNIT_MASK) effImplicitTargetMask &= ~(TARGET_FLAG_UNIT_MASK); if (providedTargetMask & TARGET_FLAG_CORPSE_MASK) effImplicitTargetMask &= ~(TARGET_FLAG_UNIT_MASK | TARGET_FLAG_CORPSE_MASK); if (providedTargetMask & TARGET_FLAG_GAMEOBJECT_ITEM) effImplicitTargetMask &= ~(TARGET_FLAG_GAMEOBJECT_ITEM | TARGET_FLAG_GAMEOBJECT | TARGET_FLAG_ITEM); if (providedTargetMask & TARGET_FLAG_GAMEOBJECT) effImplicitTargetMask &= ~(TARGET_FLAG_GAMEOBJECT | TARGET_FLAG_GAMEOBJECT_ITEM); if (providedTargetMask & TARGET_FLAG_ITEM) effImplicitTargetMask &= ~(TARGET_FLAG_ITEM | TARGET_FLAG_GAMEOBJECT_ITEM); if (dstSet || providedTargetMask & TARGET_FLAG_DEST_LOCATION) effImplicitTargetMask &= ~(TARGET_FLAG_DEST_LOCATION); if (srcSet || providedTargetMask & TARGET_FLAG_SOURCE_LOCATION) effImplicitTargetMask &= ~(TARGET_FLAG_SOURCE_LOCATION); return effImplicitTargetMask; } SpellEffectImplicitTargetTypes SpellEffectInfo::GetImplicitTargetType() const { return _data[Effect].ImplicitTargetType; } SpellTargetObjectTypes SpellEffectInfo::GetUsedTargetObjectType() const { return _data[Effect].UsedTargetObjectType; } SpellEffectInfo::StaticData SpellEffectInfo::_data[TOTAL_SPELL_EFFECTS] = { // implicit target type used target object type {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_NONE}, // 0 {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 1 SPELL_EFFECT_INSTAKILL {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 2 SPELL_EFFECT_SCHOOL_DAMAGE {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_NONE}, // 3 SPELL_EFFECT_DUMMY {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_NONE}, // 4 SPELL_EFFECT_PORTAL_TELEPORT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT_AND_DEST}, // 5 SPELL_EFFECT_TELEPORT_UNITS {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 6 SPELL_EFFECT_APPLY_AURA {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 7 SPELL_EFFECT_ENVIRONMENTAL_DAMAGE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 8 SPELL_EFFECT_POWER_DRAIN {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 9 SPELL_EFFECT_HEALTH_LEECH {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 10 SPELL_EFFECT_HEAL {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 11 SPELL_EFFECT_BIND {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_NONE}, // 12 SPELL_EFFECT_PORTAL {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_NONE}, // 13 SPELL_EFFECT_RITUAL_BASE {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_NONE}, // 14 SPELL_EFFECT_RITUAL_SPECIALIZE {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_NONE}, // 15 SPELL_EFFECT_RITUAL_ACTIVATE_PORTAL {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 16 SPELL_EFFECT_QUEST_COMPLETE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 17 SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_CORPSE_ALLY}, // 18 SPELL_EFFECT_RESURRECT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 19 SPELL_EFFECT_ADD_EXTRA_ATTACKS {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 20 SPELL_EFFECT_DODGE {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 21 SPELL_EFFECT_EVADE {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 22 SPELL_EFFECT_PARRY {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 23 SPELL_EFFECT_BLOCK {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 24 SPELL_EFFECT_CREATE_ITEM {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 25 SPELL_EFFECT_WEAPON {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 26 SPELL_EFFECT_DEFENSE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_DEST}, // 27 SPELL_EFFECT_PERSISTENT_AREA_AURA {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_DEST}, // 28 SPELL_EFFECT_SUMMON {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT_AND_DEST}, // 29 SPELL_EFFECT_LEAP {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 30 SPELL_EFFECT_ENERGIZE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 31 SPELL_EFFECT_WEAPON_PERCENT_DAMAGE {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_NONE}, // 32 SPELL_EFFECT_TRIGGER_MISSILE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_GOBJ_ITEM}, // 33 SPELL_EFFECT_OPEN_LOCK {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 34 SPELL_EFFECT_SUMMON_CHANGE_ITEM {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 35 SPELL_EFFECT_APPLY_AREA_AURA_PARTY {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 36 SPELL_EFFECT_LEARN_SPELL {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 37 SPELL_EFFECT_SPELL_DEFENSE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 38 SPELL_EFFECT_DISPEL {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 39 SPELL_EFFECT_LANGUAGE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 40 SPELL_EFFECT_DUAL_WIELD {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 41 SPELL_EFFECT_JUMP {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_DEST}, // 42 SPELL_EFFECT_JUMP_DEST {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT_AND_DEST}, // 43 SPELL_EFFECT_TELEPORT_UNITS_FACE_CASTER {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 44 SPELL_EFFECT_SKILL_STEP {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 45 SPELL_EFFECT_ADD_HONOR {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 46 SPELL_EFFECT_SPAWN {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 47 SPELL_EFFECT_TRADE_SKILL {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 48 SPELL_EFFECT_STEALTH {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 49 SPELL_EFFECT_DETECT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_DEST}, // 50 SPELL_EFFECT_TRANS_DOOR {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 51 SPELL_EFFECT_FORCE_CRITICAL_HIT {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 52 SPELL_EFFECT_GUARANTEE_HIT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_ITEM}, // 53 SPELL_EFFECT_ENCHANT_ITEM {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_ITEM}, // 54 SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 55 SPELL_EFFECT_TAMECREATURE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_DEST}, // 56 SPELL_EFFECT_SUMMON_PET {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 57 SPELL_EFFECT_LEARN_PET_SPELL {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 58 SPELL_EFFECT_WEAPON_DAMAGE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 59 SPELL_EFFECT_CREATE_RANDOM_ITEM {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 60 SPELL_EFFECT_PROFICIENCY {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_NONE}, // 61 SPELL_EFFECT_SEND_EVENT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 62 SPELL_EFFECT_POWER_BURN {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 63 SPELL_EFFECT_THREAT {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_NONE}, // 64 SPELL_EFFECT_TRIGGER_SPELL {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 65 SPELL_EFFECT_APPLY_AREA_AURA_RAID {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 66 SPELL_EFFECT_CREATE_MANA_GEM {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 67 SPELL_EFFECT_HEAL_MAX_HEALTH {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 68 SPELL_EFFECT_INTERRUPT_CAST {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT_AND_DEST}, // 69 SPELL_EFFECT_DISTRACT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 70 SPELL_EFFECT_PULL {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 71 SPELL_EFFECT_PICKPOCKET {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_DEST}, // 72 SPELL_EFFECT_ADD_FARSIGHT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 73 SPELL_EFFECT_UNTRAIN_TALENTS {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 74 SPELL_EFFECT_APPLY_GLYPH {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 75 SPELL_EFFECT_HEAL_MECHANICAL {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_DEST}, // 76 SPELL_EFFECT_SUMMON_OBJECT_WILD {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_NONE}, // 77 SPELL_EFFECT_SCRIPT_EFFECT {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 78 SPELL_EFFECT_ATTACK {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 79 SPELL_EFFECT_SANCTUARY {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 80 SPELL_EFFECT_ADD_COMBO_POINTS {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_DEST}, // 81 SPELL_EFFECT_CREATE_HOUSE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 82 SPELL_EFFECT_BIND_SIGHT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT_AND_DEST}, // 83 SPELL_EFFECT_DUEL {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 84 SPELL_EFFECT_STUCK {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_NONE}, // 85 SPELL_EFFECT_SUMMON_PLAYER {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_GOBJ}, // 86 SPELL_EFFECT_ACTIVATE_OBJECT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_GOBJ}, // 87 SPELL_EFFECT_GAMEOBJECT_DAMAGE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_GOBJ}, // 88 SPELL_EFFECT_GAMEOBJECT_REPAIR {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_GOBJ}, // 89 SPELL_EFFECT_GAMEOBJECT_SET_DESTRUCTION_STATE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 90 SPELL_EFFECT_KILL_CREDIT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 91 SPELL_EFFECT_THREAT_ALL {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 92 SPELL_EFFECT_ENCHANT_HELD_ITEM {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 93 SPELL_EFFECT_FORCE_DESELECT {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 94 SPELL_EFFECT_SELF_RESURRECT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 95 SPELL_EFFECT_SKINNING {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 96 SPELL_EFFECT_CHARGE {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 97 SPELL_EFFECT_CAST_BUTTON {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 98 SPELL_EFFECT_KNOCK_BACK {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_ITEM}, // 99 SPELL_EFFECT_DISENCHANT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 100 SPELL_EFFECT_INEBRIATE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_ITEM}, // 101 SPELL_EFFECT_FEED_PET {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 102 SPELL_EFFECT_DISMISS_PET {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 103 SPELL_EFFECT_REPUTATION {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_DEST}, // 104 SPELL_EFFECT_SUMMON_OBJECT_SLOT1 {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_DEST}, // 105 SPELL_EFFECT_SUMMON_OBJECT_SLOT2 {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_DEST}, // 106 SPELL_EFFECT_SUMMON_OBJECT_SLOT3 {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_DEST}, // 107 SPELL_EFFECT_SUMMON_OBJECT_SLOT4 {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 108 SPELL_EFFECT_DISPEL_MECHANIC {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_DEST}, // 109 SPELL_EFFECT_SUMMON_DEAD_PET {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 110 SPELL_EFFECT_DESTROY_ALL_TOTEMS {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 111 SPELL_EFFECT_DURABILITY_DAMAGE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 112 SPELL_EFFECT_112 {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_CORPSE_ALLY}, // 113 SPELL_EFFECT_RESURRECT_NEW {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 114 SPELL_EFFECT_ATTACK_ME {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 115 SPELL_EFFECT_DURABILITY_DAMAGE_PCT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_CORPSE_ENEMY}, // 116 SPELL_EFFECT_SKIN_PLAYER_CORPSE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 117 SPELL_EFFECT_SPIRIT_HEAL {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 118 SPELL_EFFECT_SKILL {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 119 SPELL_EFFECT_APPLY_AREA_AURA_PET {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 120 SPELL_EFFECT_TELEPORT_GRAVEYARD {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 121 SPELL_EFFECT_NORMALIZED_WEAPON_DMG {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_NONE}, // 122 SPELL_EFFECT_122 {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 123 SPELL_EFFECT_SEND_TAXI {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 124 SPELL_EFFECT_PULL_TOWARDS {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 125 SPELL_EFFECT_MODIFY_THREAT_PERCENT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 126 SPELL_EFFECT_STEAL_BENEFICIAL_BUFF {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_ITEM}, // 127 SPELL_EFFECT_PROSPECTING {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 128 SPELL_EFFECT_APPLY_AREA_AURA_FRIEND {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 129 SPELL_EFFECT_APPLY_AREA_AURA_ENEMY {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 130 SPELL_EFFECT_REDIRECT_THREAT {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 131 SPELL_EFFECT_PLAY_SOUND {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 132 SPELL_EFFECT_PLAY_MUSIC {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 133 SPELL_EFFECT_UNLEARN_SPECIALIZATION {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 134 SPELL_EFFECT_KILL_CREDIT2 {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_DEST}, // 135 SPELL_EFFECT_CALL_PET {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 136 SPELL_EFFECT_HEAL_PCT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 137 SPELL_EFFECT_ENERGIZE_PCT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 138 SPELL_EFFECT_LEAP_BACK {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 139 SPELL_EFFECT_CLEAR_QUEST {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 140 SPELL_EFFECT_FORCE_CAST {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 141 SPELL_EFFECT_FORCE_CAST_WITH_VALUE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 142 SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 143 SPELL_EFFECT_APPLY_AREA_AURA_OWNER {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT_AND_DEST}, // 144 SPELL_EFFECT_KNOCK_BACK_DEST {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT_AND_DEST}, // 145 SPELL_EFFECT_PULL_TOWARDS_DEST {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 146 SPELL_EFFECT_ACTIVATE_RUNE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 147 SPELL_EFFECT_QUEST_FAIL {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_NONE}, // 148 SPELL_EFFECT_TRIGGER_MISSILE_SPELL_WITH_VALUE {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_DEST}, // 149 SPELL_EFFECT_CHARGE_DEST {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 150 SPELL_EFFECT_QUEST_START {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_NONE}, // 151 SPELL_EFFECT_TRIGGER_SPELL_2 {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_NONE}, // 152 SPELL_EFFECT_SUMMON_RAF_FRIEND {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 153 SPELL_EFFECT_CREATE_TAMED_PET {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 154 SPELL_EFFECT_DISCOVER_TAXI {EFFECT_IMPLICIT_TARGET_NONE, TARGET_OBJECT_TYPE_UNIT}, // 155 SPELL_EFFECT_TITAN_GRIP {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_ITEM}, // 156 SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 157 SPELL_EFFECT_CREATE_ITEM_2 {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_ITEM}, // 158 SPELL_EFFECT_MILLING {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 159 SPELL_EFFECT_ALLOW_RENAME_PET {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 160 SPELL_EFFECT_FORCE_CAST_2 {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 161 SPELL_EFFECT_TALENT_SPEC_COUNT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 162 SPELL_EFFECT_TALENT_SPEC_SELECT {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 163 SPELL_EFFECT_163 {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 164 SPELL_EFFECT_REMOVE_AURA }; SpellInfo::SpellInfo(SpellEntry const* spellEntry) { Id = spellEntry->Id; CategoryEntry = spellEntry->Category ? sSpellCategoryStore.LookupEntry(spellEntry->Category) : NULL; Dispel = spellEntry->Dispel; Mechanic = spellEntry->Mechanic; Attributes = spellEntry->Attributes; AttributesEx = spellEntry->AttributesEx; AttributesEx2 = spellEntry->AttributesEx2; AttributesEx3 = spellEntry->AttributesEx3; AttributesEx4 = spellEntry->AttributesEx4; AttributesEx5 = spellEntry->AttributesEx5; AttributesEx6 = spellEntry->AttributesEx6; AttributesEx7 = spellEntry->AttributesEx7; AttributesCu = 0; Stances = MAKE_PAIR64(spellEntry->Stances[0], spellEntry->Stances[1]); StancesNot = MAKE_PAIR64(spellEntry->StancesNot[0], spellEntry->StancesNot[1]); Targets = spellEntry->Targets; TargetCreatureType = spellEntry->TargetCreatureType; RequiresSpellFocus = spellEntry->RequiresSpellFocus; FacingCasterFlags = spellEntry->FacingCasterFlags; CasterAuraState = spellEntry->CasterAuraState; TargetAuraState = spellEntry->TargetAuraState; CasterAuraStateNot = spellEntry->CasterAuraStateNot; TargetAuraStateNot = spellEntry->TargetAuraStateNot; CasterAuraSpell = spellEntry->casterAuraSpell; TargetAuraSpell = spellEntry->targetAuraSpell; ExcludeCasterAuraSpell = spellEntry->excludeCasterAuraSpell; ExcludeTargetAuraSpell = spellEntry->excludeTargetAuraSpell; CastTimeEntry = spellEntry->CastingTimeIndex ? sSpellCastTimesStore.LookupEntry(spellEntry->CastingTimeIndex) : NULL; RecoveryTime = spellEntry->RecoveryTime; CategoryRecoveryTime = spellEntry->CategoryRecoveryTime; StartRecoveryCategory = spellEntry->StartRecoveryCategory; StartRecoveryTime = spellEntry->StartRecoveryTime; InterruptFlags = spellEntry->InterruptFlags; AuraInterruptFlags = spellEntry->AuraInterruptFlags; ChannelInterruptFlags = spellEntry->ChannelInterruptFlags; ProcFlags = spellEntry->procFlags; ProcChance = spellEntry->procChance; ProcCharges = spellEntry->procCharges; MaxLevel = spellEntry->maxLevel; BaseLevel = spellEntry->baseLevel; SpellLevel = spellEntry->spellLevel; DurationEntry = spellEntry->DurationIndex ? sSpellDurationStore.LookupEntry(spellEntry->DurationIndex) : NULL; PowerType = spellEntry->powerType; ManaCost = spellEntry->manaCost; ManaCostPerlevel = spellEntry->manaCostPerlevel; ManaPerSecond = spellEntry->manaPerSecond; ManaPerSecondPerLevel = spellEntry->manaPerSecondPerLevel; ManaCostPercentage = spellEntry->ManaCostPercentage; RuneCostID = spellEntry->runeCostID; RangeEntry = spellEntry->rangeIndex ? sSpellRangeStore.LookupEntry(spellEntry->rangeIndex) : NULL; Speed = spellEntry->speed; StackAmount = spellEntry->StackAmount; for (uint8 i = 0; i < 2; ++i) Totem[i] = spellEntry->Totem[i]; for (uint8 i = 0; i < MAX_SPELL_REAGENTS; ++i) Reagent[i] = spellEntry->Reagent[i]; for (uint8 i = 0; i < MAX_SPELL_REAGENTS; ++i) ReagentCount[i] = spellEntry->ReagentCount[i]; EquippedItemClass = spellEntry->EquippedItemClass; EquippedItemSubClassMask = spellEntry->EquippedItemSubClassMask; EquippedItemInventoryTypeMask = spellEntry->EquippedItemInventoryTypeMask; for (uint8 i = 0; i < 2; ++i) TotemCategory[i] = spellEntry->TotemCategory[i]; for (uint8 i = 0; i < 2; ++i) SpellVisual[i] = spellEntry->SpellVisual[i]; SpellIconID = spellEntry->SpellIconID; ActiveIconID = spellEntry->activeIconID; for (uint8 i = 0; i < 16; ++i) SpellName[i] = spellEntry->SpellName[i]; for (uint8 i = 0; i < 16; ++i) Rank[i] = spellEntry->Rank[i]; MaxTargetLevel = spellEntry->MaxTargetLevel; MaxAffectedTargets = spellEntry->MaxAffectedTargets; SpellFamilyName = spellEntry->SpellFamilyName; SpellFamilyFlags = spellEntry->SpellFamilyFlags; DmgClass = spellEntry->DmgClass; PreventionType = spellEntry->PreventionType; AreaGroupId = spellEntry->AreaGroupId; SchoolMask = spellEntry->SchoolMask; for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) Effects[i] = SpellEffectInfo(spellEntry, this, i); ChainEntry = NULL; ExplicitTargetMask = 0; _spellSpecific = SPELL_SPECIFIC_NORMAL; _auraState = AURA_STATE_NONE; _allowedMechanicMask = 0; } SpellInfo::~SpellInfo() { _UnloadImplicitTargetConditionLists(); } uint32 SpellInfo::GetCategory() const { return CategoryEntry ? CategoryEntry->Id : 0; } bool SpellInfo::HasEffect(SpellEffects effect) const { for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) if (Effects[i].IsEffect(effect)) return true; return false; } bool SpellInfo::HasAura(AuraType aura) const { for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) if (Effects[i].IsAura(aura)) return true; return false; } bool SpellInfo::HasAreaAuraEffect() const { for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) if (Effects[i].IsAreaAuraEffect()) return true; return false; } bool SpellInfo::HasOnlyDamageEffects() const { for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { if (Effects[i].IsEffect()) { switch (Effects[i].Effect) { case SPELL_EFFECT_WEAPON_DAMAGE: case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL: case SPELL_EFFECT_NORMALIZED_WEAPON_DMG: case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE: case SPELL_EFFECT_SCHOOL_DAMAGE: case SPELL_EFFECT_ENVIRONMENTAL_DAMAGE: case SPELL_EFFECT_HEALTH_LEECH: continue; default: return false; } } } return true; } bool SpellInfo::IsExplicitDiscovery() const { return ((Effects[0].Effect == SPELL_EFFECT_CREATE_RANDOM_ITEM || Effects[0].Effect == SPELL_EFFECT_CREATE_ITEM_2) && Effects[1].Effect == SPELL_EFFECT_SCRIPT_EFFECT) || Id == 64323; } bool SpellInfo::IsLootCrafting() const { return (Effects[0].Effect == SPELL_EFFECT_CREATE_RANDOM_ITEM || // different random cards from Inscription (121==Virtuoso Inking Set category) r without explicit item (Effects[0].Effect == SPELL_EFFECT_CREATE_ITEM_2 && ((TotemCategory[0] != 0 || (Totem[0] != 0 && SpellIconID == 1)) || Effects[0].ItemType == 0))); } bool SpellInfo::IsQuestTame() const { return Effects[0].Effect == SPELL_EFFECT_THREAT && Effects[1].Effect == SPELL_EFFECT_APPLY_AURA && Effects[1].ApplyAuraName == SPELL_AURA_DUMMY; } bool SpellInfo::IsProfessionOrRiding() const { for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { if (Effects[i].Effect == SPELL_EFFECT_SKILL) { uint32 skill = Effects[i].MiscValue; if (IsProfessionOrRidingSkill(skill)) return true; } } return false; } bool SpellInfo::IsProfession() const { for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { if (Effects[i].Effect == SPELL_EFFECT_SKILL) { uint32 skill = Effects[i].MiscValue; if (IsProfessionSkill(skill)) return true; } } return false; } bool SpellInfo::IsPrimaryProfession() const { for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { if (Effects[i].Effect == SPELL_EFFECT_SKILL) { uint32 skill = Effects[i].MiscValue; if (IsPrimaryProfessionSkill(skill)) return true; } } return false; } bool SpellInfo::IsPrimaryProfessionFirstRank() const { return IsPrimaryProfession() && GetRank() == 1; } bool SpellInfo::IsAbilityLearnedWithProfession() const { SkillLineAbilityMapBounds bounds = sSpellMgr->GetSkillLineAbilityMapBounds(Id); for (SkillLineAbilityMap::const_iterator _spell_idx = bounds.first; _spell_idx != bounds.second; ++_spell_idx) { SkillLineAbilityEntry const* pAbility = _spell_idx->second; if (!pAbility || pAbility->AutolearnType != SKILL_LINE_ABILITY_LEARNED_ON_SKILL_VALUE) continue; if (pAbility->req_skill_value > 0) return true; } return false; } bool SpellInfo::IsAbilityOfSkillType(uint32 skillType) const { SkillLineAbilityMapBounds bounds = sSpellMgr->GetSkillLineAbilityMapBounds(Id); for (SkillLineAbilityMap::const_iterator _spell_idx = bounds.first; _spell_idx != bounds.second; ++_spell_idx) if (_spell_idx->second->skillId == uint32(skillType)) return true; return false; } bool SpellInfo::IsAffectingArea() const { for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) if (Effects[i].IsEffect() && (Effects[i].IsTargetingArea() || Effects[i].IsEffect(SPELL_EFFECT_PERSISTENT_AREA_AURA) || Effects[i].IsAreaAuraEffect())) return true; return false; } // checks if spell targets are selected from area, doesn't include spell effects in check (like area wide auras for example) bool SpellInfo::IsTargetingArea() const { for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) if (Effects[i].IsEffect() && Effects[i].IsTargetingArea()) return true; return false; } bool SpellInfo::NeedsExplicitUnitTarget() const { return (GetExplicitTargetMask() & TARGET_FLAG_UNIT_MASK) != 0; } bool SpellInfo::NeedsToBeTriggeredByCaster(SpellInfo const* triggeringSpell) const { if (NeedsExplicitUnitTarget()) return true; /* for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { if (Effects[i].IsEffect()) { if (Effects[i].TargetA.GetSelectionCategory() == TARGET_SELECT_CATEGORY_CHANNEL || Effects[i].TargetB.GetSelectionCategory() == TARGET_SELECT_CATEGORY_CHANNEL) return true; } } */ if (triggeringSpell->IsChanneled()) { uint32 mask = 0; for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { if (Effects[i].TargetA.GetTarget() != TARGET_UNIT_CASTER && Effects[i].TargetA.GetTarget() != TARGET_DEST_CASTER && Effects[i].TargetB.GetTarget() != TARGET_UNIT_CASTER && Effects[i].TargetB.GetTarget() != TARGET_DEST_CASTER) { mask |= Effects[i].GetProvidedTargetMask(); } } if (mask & TARGET_FLAG_UNIT_MASK) return true; } return false; } bool SpellInfo::IsPassive() const { return HasAttribute(SPELL_ATTR0_PASSIVE); } bool SpellInfo::IsAutocastable() const { if (IsPassive()) return false; if (HasAttribute(SPELL_ATTR1_UNAUTOCASTABLE_BY_PET)) return false; return true; } bool SpellInfo::IsStackableWithRanks() const { if (IsPassive()) return false; if (PowerType != POWER_MANA && PowerType != POWER_HEALTH) return false; if (IsProfessionOrRiding()) return false; if (IsAbilityLearnedWithProfession()) return false; // All stance spells. if any better way, change it. for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { switch (SpellFamilyName) { case SPELLFAMILY_PALADIN: // Paladin aura Spell if (Effects[i].Effect == SPELL_EFFECT_APPLY_AREA_AURA_RAID) return false; break; case SPELLFAMILY_DRUID: // Druid form Spell if (Effects[i].Effect == SPELL_EFFECT_APPLY_AURA && Effects[i].ApplyAuraName == SPELL_AURA_MOD_SHAPESHIFT) return false; break; } } return true; } bool SpellInfo::IsPassiveStackableWithRanks() const { return IsPassive() && !HasEffect(SPELL_EFFECT_APPLY_AURA); } bool SpellInfo::IsMultiSlotAura() const { return IsPassive() || Id == 55849 || Id == 40075 || Id == 44413; // Power Spark, Fel Flak Fire, Incanter's Absorption } bool SpellInfo::IsStackableOnOneSlotWithDifferentCasters() const { /// TODO: Re-verify meaning of SPELL_ATTR3_STACK_FOR_DIFF_CASTERS and update conditions here return StackAmount > 1 && !IsChanneled() && !HasAttribute(SPELL_ATTR3_STACK_FOR_DIFF_CASTERS); } bool SpellInfo::IsCooldownStartedOnEvent() const { if (HasAttribute(SPELL_ATTR0_DISABLED_WHILE_ACTIVE)) return true; return CategoryEntry && CategoryEntry->Flags & SPELL_CATEGORY_FLAG_COOLDOWN_STARTS_ON_EVENT; } bool SpellInfo::IsDeathPersistent() const { return HasAttribute(SPELL_ATTR3_DEATH_PERSISTENT); } bool SpellInfo::IsRequiringDeadTarget() const { return HasAttribute(SPELL_ATTR3_ONLY_TARGET_GHOSTS); } bool SpellInfo::IsAllowingDeadTarget() const { return HasAttribute(SPELL_ATTR2_CAN_TARGET_DEAD) || Targets & (TARGET_FLAG_CORPSE_ALLY | TARGET_FLAG_CORPSE_ENEMY | TARGET_FLAG_UNIT_DEAD); } bool SpellInfo::IsGroupBuff() const { for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { switch (Effects[i].TargetA.GetCheckType()) { case TARGET_CHECK_PARTY: case TARGET_CHECK_RAID: case TARGET_CHECK_RAID_CLASS: return true; default: break; } } return false; } bool SpellInfo::CanBeUsedInCombat() const { return !HasAttribute(SPELL_ATTR0_CANT_USED_IN_COMBAT); } bool SpellInfo::IsPositive() const { return !HasAttribute(SPELL_ATTR0_CU_NEGATIVE); } bool SpellInfo::IsPositiveEffect(uint8 effIndex) const { switch (effIndex) { default: case 0: return !HasAttribute(SPELL_ATTR0_CU_NEGATIVE_EFF0); case 1: return !HasAttribute(SPELL_ATTR0_CU_NEGATIVE_EFF1); case 2: return !HasAttribute(SPELL_ATTR0_CU_NEGATIVE_EFF2); } } bool SpellInfo::IsChanneled() const { return HasAttribute(SpellAttr1(SPELL_ATTR1_CHANNELED_1 | SPELL_ATTR1_CHANNELED_2)); } bool SpellInfo::IsMoveAllowedChannel() const { return IsChanneled() && HasAttribute(SPELL_ATTR5_CAN_CHANNEL_WHEN_MOVING); } bool SpellInfo::NeedsComboPoints() const { return HasAttribute(SpellAttr1(SPELL_ATTR1_REQ_COMBO_POINTS1 | SPELL_ATTR1_REQ_COMBO_POINTS2)); } bool SpellInfo::IsNextMeleeSwingSpell() const { return HasAttribute(SpellAttr0(SPELL_ATTR0_ON_NEXT_SWING | SPELL_ATTR0_ON_NEXT_SWING_2)); } bool SpellInfo::IsBreakingStealth() const { return !HasAttribute(SPELL_ATTR1_NOT_BREAK_STEALTH); } bool SpellInfo::IsRangedWeaponSpell() const { return (SpellFamilyName == SPELLFAMILY_HUNTER && !(SpellFamilyFlags[1] & 0x10000000)) // for 53352, cannot find better way || (EquippedItemSubClassMask & ITEM_SUBCLASS_MASK_WEAPON_RANGED) || (Attributes & SPELL_ATTR0_REQ_AMMO); } bool SpellInfo::IsAutoRepeatRangedSpell() const { return HasAttribute(SPELL_ATTR2_AUTOREPEAT_FLAG); } bool SpellInfo::HasInitialAggro() const { return !(HasAttribute(SPELL_ATTR1_NO_THREAT) || HasAttribute(SPELL_ATTR3_NO_INITIAL_AGGRO)); } WeaponAttackType SpellInfo::GetAttackType() const { WeaponAttackType result; switch (DmgClass) { case SPELL_DAMAGE_CLASS_MELEE: if (HasAttribute(SPELL_ATTR3_REQ_OFFHAND)) result = OFF_ATTACK; else result = BASE_ATTACK; break; case SPELL_DAMAGE_CLASS_RANGED: result = IsRangedWeaponSpell() ? RANGED_ATTACK : BASE_ATTACK; break; default: // Wands if (IsAutoRepeatRangedSpell()) result = RANGED_ATTACK; else result = BASE_ATTACK; break; } return result; } bool SpellInfo::IsItemFitToSpellRequirements(Item const* item) const { // item neutral spell if (EquippedItemClass == -1) return true; // item dependent spell if (item && item->IsFitToSpellRequirements(this)) return true; return false; } bool SpellInfo::IsAffected(uint32 familyName, flag96 const& familyFlags) const { if (!familyName) return true; if (familyName != SpellFamilyName) return false; if (familyFlags && !(familyFlags & SpellFamilyFlags)) return false; return true; } bool SpellInfo::IsAffectedBySpellMods() const { return !HasAttribute(SPELL_ATTR3_NO_DONE_BONUS); } bool SpellInfo::IsAffectedBySpellMod(SpellModifier const* mod) const { if (!IsAffectedBySpellMods()) return false; SpellInfo const* affectSpell = sSpellMgr->GetSpellInfo(mod->spellId); if (!affectSpell) return false; return IsAffected(affectSpell->SpellFamilyName, mod->mask); } bool SpellInfo::CanPierceImmuneAura(SpellInfo const* auraSpellInfo) const { // aura can't be pierced if (!auraSpellInfo || auraSpellInfo->HasAttribute(SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY)) return false; // these spells pierce all available spells (Resurrection Sickness for example) if (HasAttribute(SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY)) return true; // these spells (Cyclone for example) can pierce all... if (HasAttribute(SPELL_ATTR1_UNAFFECTED_BY_SCHOOL_IMMUNE) || HasAttribute(SPELL_ATTR2_UNAFFECTED_BY_AURA_SCHOOL_IMMUNE)) { // ...but not these (Divine shield, Ice block, Cyclone and Banish for example) if (!auraSpellInfo || (auraSpellInfo->Mechanic != MECHANIC_IMMUNE_SHIELD && auraSpellInfo->Mechanic != MECHANIC_INVULNERABILITY && (auraSpellInfo->Mechanic != MECHANIC_BANISH || (IsRankOf(auraSpellInfo) && auraSpellInfo->Dispel != DISPEL_NONE)))) // Banish shouldn't be immune to itself, but Cyclone should return true; } // Dispels other auras on immunity, check if this spell makes the unit immune to aura if (HasAttribute(SPELL_ATTR1_DISPEL_AURAS_ON_IMMUNITY) && CanSpellProvideImmunityAgainstAura(auraSpellInfo)) return true; return false; } bool SpellInfo::CanDispelAura(SpellInfo const* auraSpellInfo) const { // These auras (like Divine Shield) can't be dispelled if (auraSpellInfo->HasAttribute(SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY)) return false; // These spells (like Mass Dispel) can dispel all auras if (HasAttribute(SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY)) return true; // These auras (Cyclone for example) are not dispelable if (auraSpellInfo->HasAttribute(SPELL_ATTR1_UNAFFECTED_BY_SCHOOL_IMMUNE) || auraSpellInfo->HasAttribute(SPELL_ATTR2_UNAFFECTED_BY_AURA_SCHOOL_IMMUNE)) return false; return true; } bool SpellInfo::IsSingleTarget() const { // all other single target spells have if it has AttributesEx5 if (HasAttribute(SPELL_ATTR5_SINGLE_TARGET_SPELL)) return true; switch (GetSpellSpecific()) { case SPELL_SPECIFIC_JUDGEMENT: return true; default: break; } return false; } bool SpellInfo::IsAuraExclusiveBySpecificWith(SpellInfo const* spellInfo) const { SpellSpecificType spellSpec1 = GetSpellSpecific(); SpellSpecificType spellSpec2 = spellInfo->GetSpellSpecific(); switch (spellSpec1) { case SPELL_SPECIFIC_TRACKER: case SPELL_SPECIFIC_WARLOCK_ARMOR: case SPELL_SPECIFIC_MAGE_ARMOR: case SPELL_SPECIFIC_ELEMENTAL_SHIELD: case SPELL_SPECIFIC_MAGE_POLYMORPH: case SPELL_SPECIFIC_PRESENCE: case SPELL_SPECIFIC_CHARM: case SPELL_SPECIFIC_SCROLL: case SPELL_SPECIFIC_WARRIOR_ENRAGE: case SPELL_SPECIFIC_MAGE_ARCANE_BRILLANCE: case SPELL_SPECIFIC_PRIEST_DIVINE_SPIRIT: return spellSpec1 == spellSpec2; case SPELL_SPECIFIC_FOOD: return spellSpec2 == SPELL_SPECIFIC_FOOD || spellSpec2 == SPELL_SPECIFIC_FOOD_AND_DRINK; case SPELL_SPECIFIC_DRINK: return spellSpec2 == SPELL_SPECIFIC_DRINK || spellSpec2 == SPELL_SPECIFIC_FOOD_AND_DRINK; case SPELL_SPECIFIC_FOOD_AND_DRINK: return spellSpec2 == SPELL_SPECIFIC_FOOD || spellSpec2 == SPELL_SPECIFIC_DRINK || spellSpec2 == SPELL_SPECIFIC_FOOD_AND_DRINK; default: return false; } } bool SpellInfo::IsAuraExclusiveBySpecificPerCasterWith(SpellInfo const* spellInfo) const { SpellSpecificType spellSpec = GetSpellSpecific(); switch (spellSpec) { case SPELL_SPECIFIC_SEAL: case SPELL_SPECIFIC_HAND: case SPELL_SPECIFIC_AURA: case SPELL_SPECIFIC_STING: case SPELL_SPECIFIC_CURSE: case SPELL_SPECIFIC_ASPECT: case SPELL_SPECIFIC_JUDGEMENT: case SPELL_SPECIFIC_WARLOCK_CORRUPTION: return spellSpec == spellInfo->GetSpellSpecific(); default: return false; } } SpellCastResult SpellInfo::CheckShapeshift(uint32 form) const { // talents that learn spells can have stance requirements that need ignore // (this requirement only for client-side stance show in talent description) if (GetTalentSpellCost(Id) > 0 && (Effects[0].Effect == SPELL_EFFECT_LEARN_SPELL || Effects[1].Effect == SPELL_EFFECT_LEARN_SPELL || Effects[2].Effect == SPELL_EFFECT_LEARN_SPELL)) return SPELL_CAST_OK; uint64 stanceMask = (form ? UI64LIT(1) << (form - 1) : 0); if (stanceMask & StancesNot) // can explicitly not be cast in this stance return SPELL_FAILED_NOT_SHAPESHIFT; if (stanceMask & Stances) // can explicitly be cast in this stance return SPELL_CAST_OK; bool actAsShifted = false; SpellShapeshiftEntry const* shapeInfo = NULL; if (form > 0) { shapeInfo = sSpellShapeshiftStore.LookupEntry(form); if (!shapeInfo) { TC_LOG_ERROR("spells", "GetErrorAtShapeshiftedCast: unknown shapeshift %u", form); return SPELL_CAST_OK; } actAsShifted = !(shapeInfo->flags1 & 1); // shapeshift acts as normal form for spells } if (actAsShifted) { if (HasAttribute(SPELL_ATTR0_NOT_SHAPESHIFT)) // not while shapeshifted return SPELL_FAILED_NOT_SHAPESHIFT; else if (Stances != 0) // needs other shapeshift return SPELL_FAILED_ONLY_SHAPESHIFT; } else { // needs shapeshift if (!HasAttribute(SPELL_ATTR2_NOT_NEED_SHAPESHIFT) && Stances != 0) return SPELL_FAILED_ONLY_SHAPESHIFT; } // Check if stance disables cast of not-stance spells // Example: cannot cast any other spells in zombie or ghoul form /// @todo Find a way to disable use of these spells clientside if (shapeInfo && shapeInfo->flags1 & 0x400) { if (!(stanceMask & Stances)) return SPELL_FAILED_ONLY_SHAPESHIFT; } return SPELL_CAST_OK; } SpellCastResult SpellInfo::CheckLocation(uint32 map_id, uint32 zone_id, uint32 area_id, Player const* player /*= nullptr*/, bool strict /*= true*/) const { // normal case if (AreaGroupId > 0) { bool found = false; AreaGroupEntry const* groupEntry = sAreaGroupStore.LookupEntry(AreaGroupId); while (groupEntry) { for (uint8 i = 0; i < MAX_GROUP_AREA_IDS; ++i) if (groupEntry->AreaId[i] == zone_id || groupEntry->AreaId[i] == area_id) found = true; if (found || !groupEntry->nextGroup) break; // Try search in next group groupEntry = sAreaGroupStore.LookupEntry(groupEntry->nextGroup); } if (!found) return SPELL_FAILED_INCORRECT_AREA; } // continent limitation (virtual continent) if (HasAttribute(SPELL_ATTR4_CAST_ONLY_IN_OUTLAND)) { if (strict) { AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(area_id); if (!areaEntry) areaEntry = sAreaTableStore.LookupEntry(zone_id); if (!areaEntry || !areaEntry->IsFlyable() || !player->CanFlyInZone(map_id, zone_id, this)) return SPELL_FAILED_INCORRECT_AREA; } else { uint32 const v_map = GetVirtualMapForMapAndZone(map_id, zone_id); MapEntry const* mapEntry = sMapStore.LookupEntry(v_map); if (!mapEntry || mapEntry->Expansion() < 1 || !mapEntry->IsContinent()) return SPELL_FAILED_INCORRECT_AREA; } } // raid instance limitation if (HasAttribute(SPELL_ATTR6_NOT_IN_RAID_INSTANCE)) { MapEntry const* mapEntry = sMapStore.LookupEntry(map_id); if (!mapEntry || mapEntry->IsRaid()) return SPELL_FAILED_NOT_IN_RAID_INSTANCE; } // DB base check (if non empty then must fit at least single for allow) SpellAreaMapBounds saBounds = sSpellMgr->GetSpellAreaMapBounds(Id); if (saBounds.first != saBounds.second) { for (SpellAreaMap::const_iterator itr = saBounds.first; itr != saBounds.second; ++itr) { if (itr->second.IsFitToRequirements(player, zone_id, area_id)) return SPELL_CAST_OK; } return SPELL_FAILED_INCORRECT_AREA; } // bg spell checks switch (Id) { case 23333: // Warsong Flag case 23335: // Silverwing Flag return map_id == 489 && player && player->InBattleground() ? SPELL_CAST_OK : SPELL_FAILED_REQUIRES_AREA; case 34976: // Netherstorm Flag return map_id == 566 && player && player->InBattleground() ? SPELL_CAST_OK : SPELL_FAILED_REQUIRES_AREA; case 2584: // Waiting to Resurrect case 22011: // Spirit Heal Channel case 22012: // Spirit Heal case 24171: // Resurrection Impact Visual case 42792: // Recently Dropped Flag case 43681: // Inactive case 44535: // Spirit Heal (mana) { MapEntry const* mapEntry = sMapStore.LookupEntry(map_id); if (!mapEntry) return SPELL_FAILED_INCORRECT_AREA; return zone_id == 4197 || (mapEntry->IsBattleground() && player && player->InBattleground()) ? SPELL_CAST_OK : SPELL_FAILED_REQUIRES_AREA; } case 44521: // Preparation { if (!player) return SPELL_FAILED_REQUIRES_AREA; MapEntry const* mapEntry = sMapStore.LookupEntry(map_id); if (!mapEntry) return SPELL_FAILED_INCORRECT_AREA; if (!mapEntry->IsBattleground()) return SPELL_FAILED_REQUIRES_AREA; Battleground* bg = player->GetBattleground(); return bg && bg->GetStatus() == STATUS_WAIT_JOIN ? SPELL_CAST_OK : SPELL_FAILED_REQUIRES_AREA; } case 32724: // Gold Team (Alliance) case 32725: // Green Team (Alliance) case 35774: // Gold Team (Horde) case 35775: // Green Team (Horde) { MapEntry const* mapEntry = sMapStore.LookupEntry(map_id); if (!mapEntry) return SPELL_FAILED_INCORRECT_AREA; return mapEntry->IsBattleArena() && player && player->InBattleground() ? SPELL_CAST_OK : SPELL_FAILED_REQUIRES_AREA; } case 32727: // Arena Preparation { if (!player) return SPELL_FAILED_REQUIRES_AREA; MapEntry const* mapEntry = sMapStore.LookupEntry(map_id); if (!mapEntry) return SPELL_FAILED_INCORRECT_AREA; if (!mapEntry->IsBattleArena()) return SPELL_FAILED_REQUIRES_AREA; Battleground* bg = player->GetBattleground(); return bg && bg->GetStatus() == STATUS_WAIT_JOIN ? SPELL_CAST_OK : SPELL_FAILED_REQUIRES_AREA; } } return SPELL_CAST_OK; } SpellCastResult SpellInfo::CheckTarget(Unit const* caster, WorldObject const* target, bool implicit) const { if (HasAttribute(SPELL_ATTR1_CANT_TARGET_SELF) && caster == target) return SPELL_FAILED_BAD_TARGETS; // check visibility - ignore stealth for implicit (area) targets if (!HasAttribute(SPELL_ATTR6_CAN_TARGET_INVISIBLE) && !caster->CanSeeOrDetect(target, implicit)) return SPELL_FAILED_BAD_TARGETS; Unit const* unitTarget = target->ToUnit(); // creature/player specific target checks if (unitTarget) { // spells cannot be cast if player is in fake combat also if (HasAttribute(SPELL_ATTR1_CANT_TARGET_IN_COMBAT) && (unitTarget->IsInCombat() || unitTarget->IsPetInCombat())) return SPELL_FAILED_TARGET_AFFECTING_COMBAT; // only spells with SPELL_ATTR3_ONLY_TARGET_GHOSTS can target ghosts if (HasAttribute(SPELL_ATTR3_ONLY_TARGET_GHOSTS) != unitTarget->HasAuraType(SPELL_AURA_GHOST)) { if (HasAttribute(SPELL_ATTR3_ONLY_TARGET_GHOSTS)) return SPELL_FAILED_TARGET_NOT_GHOST; else return SPELL_FAILED_BAD_TARGETS; } if (caster != unitTarget) { if (caster->GetTypeId() == TYPEID_PLAYER) { // Do not allow these spells to target creatures not tapped by us (Banish, Polymorph, many quest spells) if (HasAttribute(SPELL_ATTR2_CANT_TARGET_TAPPED)) if (Creature const* targetCreature = unitTarget->ToCreature()) if (targetCreature->hasLootRecipient() && !targetCreature->isTappedBy(caster->ToPlayer())) return SPELL_FAILED_CANT_CAST_ON_TAPPED; if (HasAttribute(SPELL_ATTR0_CU_PICKPOCKET)) { if (unitTarget->GetTypeId() == TYPEID_PLAYER) return SPELL_FAILED_BAD_TARGETS; else if ((unitTarget->GetCreatureTypeMask() & CREATURE_TYPEMASK_HUMANOID_OR_UNDEAD) == 0) return SPELL_FAILED_TARGET_NO_POCKETS; } // Not allow disarm unarmed player if (Mechanic == MECHANIC_DISARM) { if (unitTarget->GetTypeId() == TYPEID_PLAYER) { Player const* player = unitTarget->ToPlayer(); if (!player->GetWeaponForAttack(BASE_ATTACK) || !player->IsUseEquipedWeapon(true)) return SPELL_FAILED_TARGET_NO_WEAPONS; } else if (!unitTarget->GetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID)) return SPELL_FAILED_TARGET_NO_WEAPONS; } } } } // corpse specific target checks else if (Corpse const* corpseTarget = target->ToCorpse()) { // cannot target bare bones if (corpseTarget->GetType() == CORPSE_BONES) return SPELL_FAILED_BAD_TARGETS; // we have to use owner for some checks (aura preventing resurrection for example) if (Player* owner = ObjectAccessor::FindPlayer(corpseTarget->GetOwnerGUID())) unitTarget = owner; // we're not interested in corpses without owner else return SPELL_FAILED_BAD_TARGETS; } // other types of objects - always valid else return SPELL_CAST_OK; // corpseOwner and unit specific target checks if (HasAttribute(SPELL_ATTR3_ONLY_TARGET_PLAYERS) && unitTarget->GetTypeId() != TYPEID_PLAYER) return SPELL_FAILED_TARGET_NOT_PLAYER; if (!IsAllowingDeadTarget() && !unitTarget->IsAlive()) return SPELL_FAILED_TARGETS_DEAD; // check this flag only for implicit targets (chain and area), allow to explicitly target units for spells like Shield of Righteousness if (implicit && HasAttribute(SPELL_ATTR6_CANT_TARGET_CROWD_CONTROLLED) && !unitTarget->CanFreeMove()) return SPELL_FAILED_BAD_TARGETS; // checked in Unit::IsValidAttack/AssistTarget, shouldn't be checked for ENTRY targets //if (!HasAttribute(SPELL_ATTR6_CAN_TARGET_UNTARGETABLE) && target->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE)) // return SPELL_FAILED_BAD_TARGETS; //if (!HasAttribute(SPELL_ATTR6_CAN_TARGET_POSSESSED_FRIENDS)) if (!CheckTargetCreatureType(unitTarget)) { if (target->GetTypeId() == TYPEID_PLAYER) return SPELL_FAILED_TARGET_IS_PLAYER; else return SPELL_FAILED_BAD_TARGETS; } // check GM mode and GM invisibility - only for player casts (npc casts are controlled by AI) and negative spells if (unitTarget != caster && (caster->IsControlledByPlayer() || !IsPositive()) && unitTarget->GetTypeId() == TYPEID_PLAYER) { if (!unitTarget->ToPlayer()->IsVisible()) return SPELL_FAILED_BM_OR_INVISGOD; if (unitTarget->ToPlayer()->IsGameMaster()) return SPELL_FAILED_BM_OR_INVISGOD; } // not allow casting on flying player if (unitTarget->HasUnitState(UNIT_STATE_IN_FLIGHT) && !HasAttribute(SPELL_ATTR0_CU_ALLOW_INFLIGHT_TARGET)) return SPELL_FAILED_BAD_TARGETS; /* TARGET_UNIT_MASTER gets blocked here for passengers, because the whole idea of this check is to not allow passengers to be implicitly hit by spells, however this target type should be an exception, if this is left it kills spells that award kill credit from vehicle to master (few spells), the use of these 2 covers passenger target check, logically, if vehicle cast this to master it should always hit him, because it would be it's passenger, there's no such case where this gets to fail legitimacy, this problem cannot be solved from within the check in other way since target type cannot be called for the spell currently Spell examples: [ID - 52864 Devour Water, ID - 52862 Devour Wind, ID - 49370 Wyrmrest Defender: Destabilize Azure Dragonshrine Effect] */ if (!caster->IsVehicle() && !(caster->GetCharmerOrOwner() == target)) { if (TargetAuraState && !unitTarget->HasAuraState(AuraStateType(TargetAuraState), this, caster)) return SPELL_FAILED_TARGET_AURASTATE; if (TargetAuraStateNot && unitTarget->HasAuraState(AuraStateType(TargetAuraStateNot), this, caster)) return SPELL_FAILED_TARGET_AURASTATE; } if (TargetAuraSpell && !unitTarget->HasAura(sSpellMgr->GetSpellIdForDifficulty(TargetAuraSpell, caster))) return SPELL_FAILED_TARGET_AURASTATE; if (ExcludeTargetAuraSpell && unitTarget->HasAura(sSpellMgr->GetSpellIdForDifficulty(ExcludeTargetAuraSpell, caster))) return SPELL_FAILED_TARGET_AURASTATE; if (unitTarget->HasAuraType(SPELL_AURA_PREVENT_RESURRECTION)) if (HasEffect(SPELL_EFFECT_SELF_RESURRECT) || HasEffect(SPELL_EFFECT_RESURRECT) || HasEffect(SPELL_EFFECT_RESURRECT_NEW)) return SPELL_FAILED_TARGET_CANNOT_BE_RESURRECTED; return SPELL_CAST_OK; } SpellCastResult SpellInfo::CheckExplicitTarget(Unit const* caster, WorldObject const* target, Item const* itemTarget) const { uint32 neededTargets = GetExplicitTargetMask(); if (!target) { if (neededTargets & (TARGET_FLAG_UNIT_MASK | TARGET_FLAG_GAMEOBJECT_MASK | TARGET_FLAG_CORPSE_MASK)) if (!(neededTargets & TARGET_FLAG_GAMEOBJECT_ITEM) || !itemTarget) return SPELL_FAILED_BAD_TARGETS; return SPELL_CAST_OK; } if (Unit const* unitTarget = target->ToUnit()) { if (neededTargets & (TARGET_FLAG_UNIT_ENEMY | TARGET_FLAG_UNIT_ALLY | TARGET_FLAG_UNIT_RAID | TARGET_FLAG_UNIT_PARTY | TARGET_FLAG_UNIT_MINIPET | TARGET_FLAG_UNIT_PASSENGER)) { if (neededTargets & TARGET_FLAG_UNIT_ENEMY) if (caster->_IsValidAttackTarget(unitTarget, this)) return SPELL_CAST_OK; if (neededTargets & TARGET_FLAG_UNIT_ALLY || (neededTargets & TARGET_FLAG_UNIT_PARTY && caster->IsInPartyWith(unitTarget)) || (neededTargets & TARGET_FLAG_UNIT_RAID && caster->IsInRaidWith(unitTarget))) if (caster->_IsValidAssistTarget(unitTarget, this)) return SPELL_CAST_OK; if (neededTargets & TARGET_FLAG_UNIT_MINIPET) if (unitTarget->GetGUID() == caster->GetCritterGUID()) return SPELL_CAST_OK; if (neededTargets & TARGET_FLAG_UNIT_PASSENGER) if (unitTarget->IsOnVehicle(caster)) return SPELL_CAST_OK; return SPELL_FAILED_BAD_TARGETS; } } return SPELL_CAST_OK; } SpellCastResult SpellInfo::CheckVehicle(Unit const* caster) const { // All creatures should be able to cast as passengers freely, restriction and attribute are only for players if (caster->GetTypeId() != TYPEID_PLAYER) return SPELL_CAST_OK; Vehicle* vehicle = caster->GetVehicle(); if (vehicle) { uint16 checkMask = 0; for (uint8 effIndex = EFFECT_0; effIndex < MAX_SPELL_EFFECTS; ++effIndex) { if (Effects[effIndex].ApplyAuraName == SPELL_AURA_MOD_SHAPESHIFT) { SpellShapeshiftEntry const* shapeShiftEntry = sSpellShapeshiftStore.LookupEntry(Effects[effIndex].MiscValue); if (shapeShiftEntry && (shapeShiftEntry->flags1 & 1) == 0) // unk flag checkMask |= VEHICLE_SEAT_FLAG_UNCONTROLLED; break; } } if (HasAura(SPELL_AURA_MOUNTED)) checkMask |= VEHICLE_SEAT_FLAG_CAN_CAST_MOUNT_SPELL; if (!checkMask) checkMask = VEHICLE_SEAT_FLAG_CAN_ATTACK; VehicleSeatEntry const* vehicleSeat = vehicle->GetSeatForPassenger(caster); if (!HasAttribute(SPELL_ATTR6_CASTABLE_WHILE_ON_VEHICLE) && !HasAttribute(SPELL_ATTR0_CASTABLE_WHILE_MOUNTED) && (vehicleSeat->m_flags & checkMask) != checkMask) return SPELL_FAILED_CANT_DO_THAT_RIGHT_NOW; // Can only summon uncontrolled minions/guardians when on controlled vehicle if (vehicleSeat->m_flags & (VEHICLE_SEAT_FLAG_CAN_CONTROL | VEHICLE_SEAT_FLAG_UNK2)) { for (uint32 i = EFFECT_0; i < MAX_SPELL_EFFECTS; ++i) { if (Effects[i].Effect != SPELL_EFFECT_SUMMON) continue; SummonPropertiesEntry const* props = sSummonPropertiesStore.LookupEntry(Effects[i].MiscValueB); if (props && props->Category != SUMMON_CATEGORY_WILD) return SPELL_FAILED_CANT_DO_THAT_RIGHT_NOW; } } } return SPELL_CAST_OK; } bool SpellInfo::CheckTargetCreatureType(Unit const* target) const { // Curse of Doom & Exorcism: not find another way to fix spell target check :/ if (SpellFamilyName == SPELLFAMILY_WARLOCK && GetCategory() == 1179) { // not allow cast at player if (target->GetTypeId() == TYPEID_PLAYER) return false; else return true; } // if target is magnet (i.e Grounding Totem) the check is skipped if (target->IsMagnet()) return true; uint32 creatureType = target->GetCreatureTypeMask(); return !TargetCreatureType || !creatureType || (creatureType & TargetCreatureType); } SpellSchoolMask SpellInfo::GetSchoolMask() const { return SpellSchoolMask(SchoolMask); } uint32 SpellInfo::GetAllEffectsMechanicMask() const { uint32 mask = 0; if (Mechanic) mask |= 1 << Mechanic; for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) if (Effects[i].IsEffect() && Effects[i].Mechanic) mask |= 1 << Effects[i].Mechanic; return mask; } uint32 SpellInfo::GetEffectMechanicMask(uint8 effIndex) const { uint32 mask = 0; if (Mechanic) mask |= 1 << Mechanic; if (Effects[effIndex].IsEffect() && Effects[effIndex].Mechanic) mask |= 1 << Effects[effIndex].Mechanic; return mask; } uint32 SpellInfo::GetSpellMechanicMaskByEffectMask(uint32 effectMask) const { uint32 mask = 0; if (Mechanic) mask |= 1 << Mechanic; for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) if ((effectMask & (1 << i)) && Effects[i].Mechanic) mask |= 1 << Effects[i].Mechanic; return mask; } Mechanics SpellInfo::GetEffectMechanic(uint8 effIndex) const { if (Effects[effIndex].IsEffect() && Effects[effIndex].Mechanic) return Mechanics(Effects[effIndex].Mechanic); if (Mechanic) return Mechanics(Mechanic); return MECHANIC_NONE; } bool SpellInfo::HasAnyEffectMechanic() const { for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) if (Effects[i].Mechanic) return true; return false; } uint32 SpellInfo::GetDispelMask() const { return GetDispelMask(DispelType(Dispel)); } uint32 SpellInfo::GetDispelMask(DispelType type) { // If dispel all if (type == DISPEL_ALL) return DISPEL_ALL_MASK; else return uint32(1 << type); } uint32 SpellInfo::GetExplicitTargetMask() const { return ExplicitTargetMask; } AuraStateType SpellInfo::GetAuraState() const { return _auraState; } void SpellInfo::_LoadAuraState() { _auraState = [this]() -> AuraStateType { // Seals if (GetSpellSpecific() == SPELL_SPECIFIC_SEAL) return AURA_STATE_JUDGEMENT; // Conflagrate aura state on Immolate and Shadowflame if (SpellFamilyName == SPELLFAMILY_WARLOCK && // Immolate ((SpellFamilyFlags[0] & 4) || // Shadowflame (SpellFamilyFlags[2] & 2))) return AURA_STATE_CONFLAGRATE; // Faerie Fire (druid versions) if (SpellFamilyName == SPELLFAMILY_DRUID && SpellFamilyFlags[0] & 0x400) return AURA_STATE_FAERIE_FIRE; // Sting (hunter's pet ability) if (GetCategory() == 1133) return AURA_STATE_FAERIE_FIRE; // Victorious if (SpellFamilyName == SPELLFAMILY_WARRIOR && SpellFamilyFlags[1] & 0x00040000) return AURA_STATE_WARRIOR_VICTORY_RUSH; // Swiftmend state on Regrowth & Rejuvenation if (SpellFamilyName == SPELLFAMILY_DRUID && SpellFamilyFlags[0] & 0x50) return AURA_STATE_SWIFTMEND; // Deadly poison aura state if (SpellFamilyName == SPELLFAMILY_ROGUE && SpellFamilyFlags[0] & 0x10000) return AURA_STATE_DEADLY_POISON; // Enrage aura state if (Dispel == DISPEL_ENRAGE) return AURA_STATE_ENRAGE; // Bleeding aura state if (GetAllEffectsMechanicMask() & 1 << MECHANIC_BLEED) return AURA_STATE_BLEEDING; if (GetSchoolMask() & SPELL_SCHOOL_MASK_FROST) for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) if (Effects[i].IsAura() && (Effects[i].ApplyAuraName == SPELL_AURA_MOD_STUN || Effects[i].ApplyAuraName == SPELL_AURA_MOD_ROOT)) return AURA_STATE_FROZEN; switch (Id) { case 71465: // Divine Surge case 50241: // Evasive Charges return AURA_STATE_UNKNOWN22; default: break; } return AURA_STATE_NONE; }(); } SpellSpecificType SpellInfo::GetSpellSpecific() const { return _spellSpecific; } void SpellInfo::_LoadSpellSpecific() { _spellSpecific = [this]() -> SpellSpecificType { switch (SpellFamilyName) { case SPELLFAMILY_GENERIC: { // Food / Drinks (mostly) if (AuraInterruptFlags & AURA_INTERRUPT_FLAG_NOT_SEATED) { bool food = false; bool drink = false; for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { if (!Effects[i].IsAura()) continue; switch (Effects[i].ApplyAuraName) { // Food case SPELL_AURA_MOD_REGEN: case SPELL_AURA_OBS_MOD_HEALTH: food = true; break; // Drink case SPELL_AURA_MOD_POWER_REGEN: case SPELL_AURA_OBS_MOD_POWER: drink = true; break; default: break; } } if (food && drink) return SPELL_SPECIFIC_FOOD_AND_DRINK; else if (food) return SPELL_SPECIFIC_FOOD; else if (drink) return SPELL_SPECIFIC_DRINK; } // scrolls effects else { SpellInfo const* firstRankSpellInfo = GetFirstRankSpell(); switch (firstRankSpellInfo->Id) { case 8118: // Strength case 8099: // Stamina case 8112: // Spirit case 8096: // Intellect case 8115: // Agility case 8091: // Armor return SPELL_SPECIFIC_SCROLL; default: break; } switch (Id) { case 12880: // Enrage (Enrage) case 14201: case 14202: case 14203: case 14204: case 57518: // Enrage (Wrecking Crew) case 57519: case 57520: case 57521: case 57522: case 57514: // Enrage (Imp. Defensive Stance) case 57516: return SPELL_SPECIFIC_WARRIOR_ENRAGE; default: break; } } break; } case SPELLFAMILY_MAGE: { // family flags 18(Molten), 25(Frost/Ice), 28(Mage) if (SpellFamilyFlags[0] & 0x12040000) return SPELL_SPECIFIC_MAGE_ARMOR; // Arcane brillance and Arcane intelect (normal check fails because of flags difference) if (SpellFamilyFlags[0] & 0x400) return SPELL_SPECIFIC_MAGE_ARCANE_BRILLANCE; if ((SpellFamilyFlags[0] & 0x1000000) && Effects[0].ApplyAuraName == SPELL_AURA_MOD_CONFUSE) return SPELL_SPECIFIC_MAGE_POLYMORPH; break; } case SPELLFAMILY_WARRIOR: { if (Id == 12292) // Death Wish return SPELL_SPECIFIC_WARRIOR_ENRAGE; break; } case SPELLFAMILY_WARLOCK: { // only warlock curses have this if (Dispel == DISPEL_CURSE) return SPELL_SPECIFIC_CURSE; // Warlock (Demon Armor | Demon Skin | Fel Armor) if (SpellFamilyFlags[1] & 0x20000020 || SpellFamilyFlags[2] & 0x00000010) return SPELL_SPECIFIC_WARLOCK_ARMOR; //seed of corruption and corruption if (SpellFamilyFlags[1] & 0x10 || SpellFamilyFlags[0] & 0x2) return SPELL_SPECIFIC_WARLOCK_CORRUPTION; break; } case SPELLFAMILY_PRIEST: { // Divine Spirit and Prayer of Spirit if (SpellFamilyFlags[0] & 0x20) return SPELL_SPECIFIC_PRIEST_DIVINE_SPIRIT; break; } case SPELLFAMILY_HUNTER: { // only hunter stings have this if (Dispel == DISPEL_POISON) return SPELL_SPECIFIC_STING; // only hunter aspects have this (but not all aspects in hunter family) if (SpellFamilyFlags.HasFlag(0x00380000, 0x00440000, 0x00001010)) return SPELL_SPECIFIC_ASPECT; break; } case SPELLFAMILY_PALADIN: { // Collection of all the seal family flags. No other paladin spell has any of those. if (SpellFamilyFlags[1] & 0x26000C00 || SpellFamilyFlags[0] & 0x0A000000) return SPELL_SPECIFIC_SEAL; if (SpellFamilyFlags[0] & 0x00002190) return SPELL_SPECIFIC_HAND; // Judgement of Wisdom, Judgement of Light, Judgement of Justice if (Id == 20184 || Id == 20185 || Id == 20186) return SPELL_SPECIFIC_JUDGEMENT; // only paladin auras have this (for palaldin class family) if (SpellFamilyFlags[2] & 0x00000020) return SPELL_SPECIFIC_AURA; break; } case SPELLFAMILY_SHAMAN: { // family flags 10 (Lightning), 42 (Earth), 37 (Water), proc shield from T2 8 pieces bonus if (SpellFamilyFlags[1] & 0x420 || SpellFamilyFlags[0] & 0x00000400 || Id == 23552) return SPELL_SPECIFIC_ELEMENTAL_SHIELD; break; } case SPELLFAMILY_DEATHKNIGHT: if (Id == 48266 || Id == 48263 || Id == 48265) return SPELL_SPECIFIC_PRESENCE; break; } for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { if (Effects[i].Effect == SPELL_EFFECT_APPLY_AURA) { switch (Effects[i].ApplyAuraName) { case SPELL_AURA_MOD_CHARM: case SPELL_AURA_MOD_POSSESS_PET: case SPELL_AURA_MOD_POSSESS: case SPELL_AURA_AOE_CHARM: return SPELL_SPECIFIC_CHARM; case SPELL_AURA_TRACK_CREATURES: /// @workaround For non-stacking tracking spells (We need generic solution) if (Id == 30645) // Gas Cloud Tracking return SPELL_SPECIFIC_NORMAL; case SPELL_AURA_TRACK_RESOURCES: case SPELL_AURA_TRACK_STEALTHED: return SPELL_SPECIFIC_TRACKER; } } } return SPELL_SPECIFIC_NORMAL; }(); } void SpellInfo::_LoadSpellDiminishInfo() { auto diminishingGroupCompute = [this](bool triggered) -> DiminishingGroup { if (IsPositive()) return DIMINISHING_NONE; for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { if (Effects[i].ApplyAuraName == SPELL_AURA_MOD_TAUNT) return DIMINISHING_TAUNT; } // Explicit Diminishing Groups switch (SpellFamilyName) { case SPELLFAMILY_GENERIC: { // Pet charge effects (Infernal Awakening, Demon Charge) if (SpellVisual[0] == 2816 && SpellIconID == 15) return DIMINISHING_CONTROLLED_STUN; // Frost Tomb else if (Id == 48400) return DIMINISHING_NONE; // Gnaw else if (Id == 47481) return DIMINISHING_CONTROLLED_STUN; // ToC Icehowl Arctic Breath else if (SpellVisual[0] == 14153) return DIMINISHING_NONE; // Black Plague else if (Id == 64155) return DIMINISHING_NONE; // Screams of the Dead (King Ymiron) else if (Id == 51750) return DIMINISHING_NONE; break; } // Event spells case SPELLFAMILY_UNK1: return DIMINISHING_NONE; case SPELLFAMILY_MAGE: { // Frostbite if (SpellFamilyFlags[1] & 0x80000000) return DIMINISHING_ROOT; // Shattered Barrier else if (SpellVisual[0] == 12297) return DIMINISHING_ROOT; // Deep Freeze else if (SpellIconID == 2939 && SpellVisual[0] == 9963) return DIMINISHING_CONTROLLED_STUN; // Frost Nova / Freeze (Water Elemental) else if (SpellIconID == 193) return DIMINISHING_CONTROLLED_ROOT; // Dragon's Breath else if (SpellFamilyFlags[0] & 0x800000) return DIMINISHING_DRAGONS_BREATH; break; } case SPELLFAMILY_WARRIOR: { // Hamstring - limit duration to 10s in PvP if (SpellFamilyFlags[0] & 0x2) return DIMINISHING_LIMITONLY; // Charge Stun (own diminishing) else if (SpellFamilyFlags[0] & 0x01000000) return DIMINISHING_CHARGE; break; } case SPELLFAMILY_WARLOCK: { // Curses/etc if ((SpellFamilyFlags[0] & 0x80000000) || (SpellFamilyFlags[1] & 0x200)) return DIMINISHING_LIMITONLY; // Seduction else if (SpellFamilyFlags[1] & 0x10000000) return DIMINISHING_FEAR; break; } case SPELLFAMILY_DRUID: { // Pounce if (SpellFamilyFlags[0] & 0x20000) return DIMINISHING_OPENING_STUN; // Cyclone else if (SpellFamilyFlags[1] & 0x20) return DIMINISHING_CYCLONE; // Entangling Roots // Nature's Grasp else if (SpellFamilyFlags[0] & 0x00000200) return DIMINISHING_CONTROLLED_ROOT; // Faerie Fire else if (SpellFamilyFlags[0] & 0x400) return DIMINISHING_LIMITONLY; break; } case SPELLFAMILY_ROGUE: { // Gouge if (SpellFamilyFlags[0] & 0x8) return DIMINISHING_DISORIENT; // Blind else if (SpellFamilyFlags[0] & 0x1000000) return DIMINISHING_FEAR; // Cheap Shot else if (SpellFamilyFlags[0] & 0x400) return DIMINISHING_OPENING_STUN; // Crippling poison - Limit to 10 seconds in PvP (No SpellFamilyFlags) else if (SpellIconID == 163) return DIMINISHING_LIMITONLY; break; } case SPELLFAMILY_HUNTER: { // Hunter's Mark if ((SpellFamilyFlags[0] & 0x400) && SpellIconID == 538) return DIMINISHING_LIMITONLY; // Scatter Shot (own diminishing) else if ((SpellFamilyFlags[0] & 0x40000) && SpellIconID == 132) return DIMINISHING_SCATTER_SHOT; // Entrapment (own diminishing) else if (SpellVisual[0] == 7484 && SpellIconID == 20) return DIMINISHING_ENTRAPMENT; // Wyvern Sting mechanic is MECHANIC_SLEEP but the diminishing is DIMINISHING_DISORIENT else if ((SpellFamilyFlags[1] & 0x1000) && SpellIconID == 1721) return DIMINISHING_DISORIENT; // Freezing Arrow else if (SpellFamilyFlags[0] & 0x8) return DIMINISHING_DISORIENT; break; } case SPELLFAMILY_PALADIN: { // Judgement of Justice - limit duration to 10s in PvP if (SpellFamilyFlags[0] & 0x100000) return DIMINISHING_LIMITONLY; // Turn Evil else if ((SpellFamilyFlags[1] & 0x804000) && SpellIconID == 309) return DIMINISHING_FEAR; break; } case SPELLFAMILY_SHAMAN: { // Storm, Earth and Fire - Earthgrab if (SpellFamilyFlags[2] & 0x4000) return DIMINISHING_NONE; break; } case SPELLFAMILY_DEATHKNIGHT: { // Hungering Cold (no flags) if (SpellIconID == 2797) return DIMINISHING_DISORIENT; // Mark of Blood else if ((SpellFamilyFlags[0] & 0x10000000) && SpellIconID == 2285) return DIMINISHING_LIMITONLY; break; } default: break; } // Lastly - Set diminishing depending on mechanic uint32 mechanic = GetAllEffectsMechanicMask(); if (mechanic & (1 << MECHANIC_CHARM)) return DIMINISHING_MIND_CONTROL; if (mechanic & (1 << MECHANIC_SILENCE)) return DIMINISHING_SILENCE; if (mechanic & (1 << MECHANIC_SLEEP)) return DIMINISHING_SLEEP; if (mechanic & ((1 << MECHANIC_SAPPED) | (1 << MECHANIC_POLYMORPH) | (1 << MECHANIC_SHACKLE))) return DIMINISHING_DISORIENT; // Mechanic Knockout, except Blast Wave if (mechanic & (1 << MECHANIC_KNOCKOUT) && SpellIconID != 292) return DIMINISHING_DISORIENT; if (mechanic & (1 << MECHANIC_DISARM)) return DIMINISHING_DISARM; if (mechanic & (1 << MECHANIC_FEAR)) return DIMINISHING_FEAR; if (mechanic & (1 << MECHANIC_STUN)) return triggered ? DIMINISHING_STUN : DIMINISHING_CONTROLLED_STUN; if (mechanic & (1 << MECHANIC_BANISH)) return DIMINISHING_BANISH; if (mechanic & (1 << MECHANIC_ROOT)) return triggered ? DIMINISHING_ROOT : DIMINISHING_CONTROLLED_ROOT; if (mechanic & (1 << MECHANIC_HORROR)) return DIMINISHING_HORROR; return DIMINISHING_NONE; }; auto diminishingTypeCompute = [](DiminishingGroup group) -> DiminishingReturnsType { switch (group) { case DIMINISHING_TAUNT: case DIMINISHING_CONTROLLED_STUN: case DIMINISHING_STUN: case DIMINISHING_OPENING_STUN: case DIMINISHING_CYCLONE: case DIMINISHING_CHARGE: return DRTYPE_ALL; case DIMINISHING_LIMITONLY: case DIMINISHING_NONE: return DRTYPE_NONE; default: return DRTYPE_PLAYER; } }; auto diminishingMaxLevelCompute = [](DiminishingGroup group) -> DiminishingLevels { switch (group) { case DIMINISHING_TAUNT: return DIMINISHING_LEVEL_TAUNT_IMMUNE; default: return DIMINISHING_LEVEL_IMMUNE; } }; auto diminishingLimitDurationCompute = [this](DiminishingGroup group) -> int32 { auto isGroupDurationLimited = [group]() -> bool { switch (group) { case DIMINISHING_BANISH: case DIMINISHING_CONTROLLED_STUN: case DIMINISHING_CONTROLLED_ROOT: case DIMINISHING_CYCLONE: case DIMINISHING_DISORIENT: case DIMINISHING_ENTRAPMENT: case DIMINISHING_FEAR: case DIMINISHING_HORROR: case DIMINISHING_MIND_CONTROL: case DIMINISHING_OPENING_STUN: case DIMINISHING_ROOT: case DIMINISHING_STUN: case DIMINISHING_SLEEP: case DIMINISHING_LIMITONLY: return true; default: return false; } }; if (!isGroupDurationLimited()) return 0; // Explicit diminishing duration switch (SpellFamilyName) { case SPELLFAMILY_DRUID: { // Faerie Fire - limit to 40 seconds in PvP (3.1) if (SpellFamilyFlags[0] & 0x400) return 40 * IN_MILLISECONDS; break; } case SPELLFAMILY_HUNTER: { // Wyvern Sting if (SpellFamilyFlags[1] & 0x1000) return 6 * IN_MILLISECONDS; // Hunter's Mark if (SpellFamilyFlags[0] & 0x400) return 120 * IN_MILLISECONDS; break; } case SPELLFAMILY_PALADIN: { // Repentance - limit to 6 seconds in PvP if (SpellFamilyFlags[0] & 0x4) return 6 * IN_MILLISECONDS; break; } case SPELLFAMILY_WARLOCK: { // Banish - limit to 6 seconds in PvP if (SpellFamilyFlags[1] & 0x8000000) return 6 * IN_MILLISECONDS; // Curse of Tongues - limit to 12 seconds in PvP else if (SpellFamilyFlags[2] & 0x800) return 12 * IN_MILLISECONDS; // Curse of Elements - limit to 120 seconds in PvP else if (SpellFamilyFlags[1] & 0x200) return 120 * IN_MILLISECONDS; break; } default: break; } return 10 * IN_MILLISECONDS; }; SpellDiminishInfo triggeredInfo, normalInfo; triggeredInfo.DiminishGroup = diminishingGroupCompute(true); triggeredInfo.DiminishReturnType = diminishingTypeCompute(triggeredInfo.DiminishGroup); triggeredInfo.DiminishMaxLevel = diminishingMaxLevelCompute(triggeredInfo.DiminishGroup); triggeredInfo.DiminishDurationLimit = diminishingLimitDurationCompute(triggeredInfo.DiminishGroup); normalInfo.DiminishGroup = diminishingGroupCompute(false); normalInfo.DiminishReturnType = diminishingTypeCompute(normalInfo.DiminishGroup); normalInfo.DiminishMaxLevel = diminishingMaxLevelCompute(normalInfo.DiminishGroup); normalInfo.DiminishDurationLimit = diminishingLimitDurationCompute(normalInfo.DiminishGroup); _diminishInfoTriggered = triggeredInfo; _diminishInfoNonTriggered = normalInfo; } DiminishingGroup SpellInfo::GetDiminishingReturnsGroupForSpell(bool triggered) const { return triggered ? _diminishInfoTriggered.DiminishGroup : _diminishInfoNonTriggered.DiminishGroup; } DiminishingReturnsType SpellInfo::GetDiminishingReturnsGroupType(bool triggered) const { return triggered ? _diminishInfoTriggered.DiminishReturnType : _diminishInfoNonTriggered.DiminishReturnType; } DiminishingLevels SpellInfo::GetDiminishingReturnsMaxLevel(bool triggered) const { return triggered ? _diminishInfoTriggered.DiminishMaxLevel : _diminishInfoNonTriggered.DiminishMaxLevel; } int32 SpellInfo::GetDiminishingReturnsLimitDuration(bool triggered) const { return triggered ? _diminishInfoTriggered.DiminishDurationLimit : _diminishInfoNonTriggered.DiminishDurationLimit; } void SpellInfo::_LoadImmunityInfo() { for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { uint32 schoolImmunityMask = 0; uint32 applyHarmfulAuraImmunityMask = 0; uint32 mechanicImmunityMask = 0; uint32 dispelImmunity = 0; uint32 damageImmunityMask = 0; int32 miscVal = Effects[i].MiscValue; int32 amount = Effects[i].CalcValue(); ImmunityInfo& immuneInfo = _immunityInfo[i]; switch (Effects[i].ApplyAuraName) { case SPELL_AURA_MECHANIC_IMMUNITY_MASK: { switch (miscVal) { case 96: // Free Friend, Uncontrollable Frenzy, Warlord's Presence { mechanicImmunityMask |= IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK; immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DECREASE_SPEED); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_CONFUSE); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_FEAR); break; } case 1615: // Incite Rage, Wolf Spirit, Overload, Lightning Tendrils { switch (Id) { case 43292: // Incite Rage case 49172: // Wolf Spirit mechanicImmunityMask |= IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK; immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DECREASE_SPEED); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_CONFUSE); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_FEAR); // no break intended case 61869: // Overload case 63481: case 61887: // Lightning Tendrils case 63486: mechanicImmunityMask |= (1 << MECHANIC_INTERRUPT) | (1 << MECHANIC_SILENCE); immuneInfo.SpellEffectImmune.insert(SPELL_EFFECT_KNOCK_BACK); immuneInfo.SpellEffectImmune.insert(SPELL_EFFECT_KNOCK_BACK_DEST); break; default: break; } break; } case 679: // Mind Control, Avenging Fury { if (Id == 57742) // Avenging Fury { mechanicImmunityMask |= IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK; immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DECREASE_SPEED); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_CONFUSE); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_FEAR); } break; } case 1557: // Startling Roar, Warlord Roar, Break Bonds, Stormshield { if (Id == 64187) // Stormshield { mechanicImmunityMask |= (1 << MECHANIC_STUN); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN); } else { mechanicImmunityMask |= IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK; immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DECREASE_SPEED); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_CONFUSE); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_FEAR); } break; } case 1614: // Fixate case 1694: // Fixated, Lightning Tendrils { immuneInfo.SpellEffectImmune.insert(SPELL_EFFECT_ATTACK_ME); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_TAUNT); break; } case 1630: // Fervor, Berserk { if (Id == 64112) // Berserk { immuneInfo.SpellEffectImmune.insert(SPELL_EFFECT_ATTACK_ME); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_TAUNT); } else { mechanicImmunityMask |= IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK; immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DECREASE_SPEED); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_CONFUSE); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_FEAR); } break; } case 477: // Bladestorm case 1733: // Bladestorm, Killing Spree { if (!amount) { mechanicImmunityMask |= IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK; immuneInfo.SpellEffectImmune.insert(SPELL_EFFECT_KNOCK_BACK); immuneInfo.SpellEffectImmune.insert(SPELL_EFFECT_KNOCK_BACK_DEST); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DECREASE_SPEED); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_CONFUSE); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_FEAR); } break; } case 878: // Whirlwind, Fog of Corruption, Determination { if (Id == 66092) // Determination { mechanicImmunityMask |= (1 << MECHANIC_SNARE) | (1 << MECHANIC_STUN) | (1 << MECHANIC_DISORIENTED) | (1 << MECHANIC_FREEZE); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN); immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DECREASE_SPEED); } break; } default: break; } if (immuneInfo.AuraTypeImmune.empty()) { if (miscVal & (1 << 10)) immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN); if (miscVal & (1 << 1)) immuneInfo.AuraTypeImmune.insert(SPELL_AURA_TRANSFORM); // These flag can be recognized wrong: if (miscVal & (1 << 6)) immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DECREASE_SPEED); if (miscVal & (1 << 0)) immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT); if (miscVal & (1 << 2)) immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_CONFUSE); if (miscVal & (1 << 9)) immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_FEAR); if (miscVal & (1 << 7)) immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DISARM); } break; } case SPELL_AURA_MECHANIC_IMMUNITY: { switch (Id) { case 34471: // The Beast Within case 19574: // Bestial Wrath case 42292: // PvP trinket case 59752: // Every Man for Himself case 53490: // Bullheaded mechanicImmunityMask |= IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK; break; case 54508: // Demonic Empowerment mechanicImmunityMask |= (1 << MECHANIC_SNARE) | (1 << MECHANIC_ROOT) | (1 << MECHANIC_STUN); break; default: if (miscVal < 1) continue; mechanicImmunityMask |= 1 << miscVal; break; } break; } case SPELL_AURA_EFFECT_IMMUNITY: { immuneInfo.SpellEffectImmune.insert(static_cast(miscVal)); break; } case SPELL_AURA_STATE_IMMUNITY: { immuneInfo.AuraTypeImmune.insert(static_cast(miscVal)); break; } case SPELL_AURA_SCHOOL_IMMUNITY: { schoolImmunityMask |= uint32(miscVal); break; } case SPELL_AURA_MOD_IMMUNE_AURA_APPLY_SCHOOL: { applyHarmfulAuraImmunityMask |= uint32(miscVal); break; } case SPELL_AURA_DAMAGE_IMMUNITY: { damageImmunityMask |= uint32(miscVal); break; } case SPELL_AURA_DISPEL_IMMUNITY: { dispelImmunity = uint32(miscVal); break; } default: break; } immuneInfo.SchoolImmuneMask = schoolImmunityMask; immuneInfo.ApplyHarmfulAuraImmuneMask = applyHarmfulAuraImmunityMask; immuneInfo.MechanicImmuneMask = mechanicImmunityMask; immuneInfo.DispelImmune = dispelImmunity; immuneInfo.DamageSchoolMask = damageImmunityMask; immuneInfo.AuraTypeImmune.shrink_to_fit(); immuneInfo.SpellEffectImmune.shrink_to_fit(); _allowedMechanicMask |= immuneInfo.MechanicImmuneMask; } if (HasAttribute(SPELL_ATTR5_USABLE_WHILE_STUNNED)) { switch (Id) { case 22812: // Barkskin _allowedMechanicMask |= (1 << MECHANIC_STUN) | (1 << MECHANIC_FREEZE) | (1 << MECHANIC_KNOCKOUT) | (1 << MECHANIC_SLEEP); break; case 49039: // Lichborne, don't allow normal stuns break; default: _allowedMechanicMask |= (1 << MECHANIC_STUN); break; } } if (HasAttribute(SPELL_ATTR5_USABLE_WHILE_CONFUSED)) _allowedMechanicMask |= (1 << MECHANIC_DISORIENTED); if (HasAttribute(SPELL_ATTR5_USABLE_WHILE_FEARED)) _allowedMechanicMask |= (1 << MECHANIC_FEAR); } void SpellInfo::ApplyAllSpellImmunitiesTo(Unit* target, uint8 effIndex, bool apply) const { ImmunityInfo const* immuneInfo = _immunityInfo + effIndex; if (uint32 schoolImmunity = immuneInfo->SchoolImmuneMask) { target->ApplySpellImmune(Id, IMMUNITY_SCHOOL, schoolImmunity, apply); if (apply && HasAttribute(SPELL_ATTR1_DISPEL_AURAS_ON_IMMUNITY)) { target->RemoveAppliedAuras([this, schoolImmunity](AuraApplication const* aurApp) -> bool { SpellInfo const* auraSpellInfo = aurApp->GetBase()->GetSpellInfo(); return ((auraSpellInfo->GetSchoolMask() & schoolImmunity) != 0 && // Check for school mask CanDispelAura(auraSpellInfo) && (IsPositive() != aurApp->IsPositive()) && // Check spell vs aura possitivity !auraSpellInfo->IsPassive() && // Don't remove passive auras auraSpellInfo->Id != Id); // Don't remove self }); } } if (uint32 mechanicImmunity = immuneInfo->MechanicImmuneMask) { for (uint32 i = 0; i < MAX_MECHANIC; ++i) if (mechanicImmunity & (1 << i)) target->ApplySpellImmune(Id, IMMUNITY_MECHANIC, i, apply); if (apply && HasAttribute(SPELL_ATTR1_DISPEL_AURAS_ON_IMMUNITY)) { // exception for purely snare mechanic (eg. hands of freedom)! if (mechanicImmunity == (1 << MECHANIC_SNARE)) target->RemoveMovementImpairingAuras(false); else target->RemoveAurasWithMechanic(mechanicImmunity, AURA_REMOVE_BY_DEFAULT, Id); } } if (uint32 dispelImmunity = immuneInfo->DispelImmune) { target->ApplySpellImmune(Id, IMMUNITY_DISPEL, dispelImmunity, apply); if (apply && HasAttribute(SPELL_ATTR1_DISPEL_AURAS_ON_IMMUNITY)) { target->RemoveAppliedAuras([dispelImmunity](AuraApplication const* aurApp) -> bool { SpellInfo const* spellInfo = aurApp->GetBase()->GetSpellInfo(); if (spellInfo->Dispel == dispelImmunity) return true; return false; }); } } if (uint32 damageImmunity = immuneInfo->DamageSchoolMask) target->ApplySpellImmune(Id, IMMUNITY_DAMAGE, damageImmunity, apply); for (AuraType auraType : immuneInfo->AuraTypeImmune) { target->ApplySpellImmune(Id, IMMUNITY_STATE, auraType, apply); if (apply && HasAttribute(SPELL_ATTR1_DISPEL_AURAS_ON_IMMUNITY)) target->RemoveAurasByType(auraType); } for (SpellEffects effectType : immuneInfo->SpellEffectImmune) target->ApplySpellImmune(Id, IMMUNITY_EFFECT, effectType, apply); } bool SpellInfo::CanSpellProvideImmunityAgainstAura(SpellInfo const* auraSpellInfo) const { if (!auraSpellInfo) return false; for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { ImmunityInfo const* immuneInfo = _immunityInfo + i; if (!auraSpellInfo->HasAttribute(SPELL_ATTR1_UNAFFECTED_BY_SCHOOL_IMMUNE) && !auraSpellInfo->HasAttribute(SPELL_ATTR2_UNAFFECTED_BY_AURA_SCHOOL_IMMUNE)) { if (uint32 schoolImmunity = immuneInfo->SchoolImmuneMask) if ((auraSpellInfo->SchoolMask & schoolImmunity) != 0) return true; } if (uint32 mechanicImmunity = immuneInfo->MechanicImmuneMask) if ((mechanicImmunity & (1 << auraSpellInfo->Mechanic)) != 0) return true; if (uint32 dispelImmunity = immuneInfo->DispelImmune) if (auraSpellInfo->Dispel == dispelImmunity) return true; bool immuneToAllEffects = true; for (uint8 effIndex = 0; effIndex < MAX_SPELL_EFFECTS; ++effIndex) { uint32 effectName = auraSpellInfo->Effects[effIndex].Effect; if (!effectName) continue; auto spellImmuneItr = immuneInfo->SpellEffectImmune.find(static_cast(effectName)); if (spellImmuneItr == immuneInfo->SpellEffectImmune.cend()) { immuneToAllEffects = false; break; } if (uint32 mechanic = auraSpellInfo->Effects[effIndex].Mechanic) { if (!(immuneInfo->MechanicImmuneMask & (1 << mechanic))) { immuneToAllEffects = false; break; } } if (!auraSpellInfo->HasAttribute(SPELL_ATTR3_IGNORE_HIT_RESULT)) { if (uint32 auraName = auraSpellInfo->Effects[effIndex].ApplyAuraName) { bool isImmuneToAuraEffectApply = false; auto auraImmuneItr = immuneInfo->AuraTypeImmune.find(static_cast(auraName)); if (auraImmuneItr != immuneInfo->AuraTypeImmune.cend()) isImmuneToAuraEffectApply = true; if (!isImmuneToAuraEffectApply && !auraSpellInfo->IsPositiveEffect(effIndex) && !auraSpellInfo->HasAttribute(SPELL_ATTR2_UNAFFECTED_BY_AURA_SCHOOL_IMMUNE)) { if (uint32 applyHarmfulAuraImmunityMask = immuneInfo->ApplyHarmfulAuraImmuneMask) if ((auraSpellInfo->GetSchoolMask() & applyHarmfulAuraImmunityMask) != 0) isImmuneToAuraEffectApply = true; } if (!isImmuneToAuraEffectApply) { immuneToAllEffects = false; break; } } } } if (immuneToAllEffects) return true; } return false; } // based on client Spell_C::CancelsAuraEffect bool SpellInfo::SpellCancelsAuraEffect(SpellInfo const* auraSpellInfo, uint8 auraEffIndex) const { if (!HasAttribute(SPELL_ATTR1_DISPEL_AURAS_ON_IMMUNITY)) return false; if (auraSpellInfo->HasAttribute(SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY)) return false; for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { if (Effects[i].Effect != SPELL_EFFECT_APPLY_AURA) continue; uint32 const miscValue = static_cast(Effects[i].MiscValue); switch (Effects[i].ApplyAuraName) { case SPELL_AURA_STATE_IMMUNITY: if (miscValue != auraSpellInfo->Effects[auraEffIndex].ApplyAuraName) continue; break; case SPELL_AURA_SCHOOL_IMMUNITY: case SPELL_AURA_MOD_IMMUNE_AURA_APPLY_SCHOOL: if (auraSpellInfo->HasAttribute(SPELL_ATTR2_UNAFFECTED_BY_AURA_SCHOOL_IMMUNE) || !(auraSpellInfo->SchoolMask & miscValue)) continue; break; case SPELL_AURA_DISPEL_IMMUNITY: if (miscValue != auraSpellInfo->Dispel) continue; break; case SPELL_AURA_MECHANIC_IMMUNITY: if (miscValue != auraSpellInfo->Mechanic) { if (miscValue != auraSpellInfo->Effects[auraEffIndex].Mechanic) continue; } break; default: continue; } return true; } return false; } uint32 SpellInfo::GetAllowedMechanicMask() const { return _allowedMechanicMask; } float SpellInfo::GetMinRange(bool positive) const { if (!RangeEntry) return 0.0f; if (positive) return RangeEntry->minRangeFriend; return RangeEntry->minRangeHostile; } float SpellInfo::GetMaxRange(bool positive, Unit* caster, Spell* spell) const { if (!RangeEntry) return 0.0f; float range; if (positive) range = RangeEntry->maxRangeFriend; else range = RangeEntry->maxRangeHostile; if (caster) if (Player* modOwner = caster->GetSpellModOwner()) modOwner->ApplySpellMod(Id, range, spell); return range; } int32 SpellInfo::GetDuration() const { if (!DurationEntry) return 0; return (DurationEntry->Duration[0] == -1) ? -1 : abs(DurationEntry->Duration[0]); } int32 SpellInfo::GetMaxDuration() const { if (!DurationEntry) return 0; return (DurationEntry->Duration[2] == -1) ? -1 : abs(DurationEntry->Duration[2]); } uint32 SpellInfo::CalcCastTime(Spell* spell /*= NULL*/) const { // not all spells have cast time index and this is all is pasiive abilities if (!CastTimeEntry) return 0; int32 castTime = CastTimeEntry->CastTime; if (spell) spell->GetCaster()->ModSpellCastTime(this, castTime, spell); if (HasAttribute(SPELL_ATTR0_REQ_AMMO) && (!IsAutoRepeatRangedSpell())) castTime += 500; return (castTime > 0) ? uint32(castTime) : 0; } uint32 SpellInfo::GetMaxTicks() const { int32 DotDuration = GetDuration(); if (DotDuration == 0) return 1; // 200% limit if (DotDuration > 30000) DotDuration = 30000; for (uint8 x = 0; x < MAX_SPELL_EFFECTS; x++) { if (Effects[x].Effect == SPELL_EFFECT_APPLY_AURA) switch (Effects[x].ApplyAuraName) { case SPELL_AURA_PERIODIC_DAMAGE: case SPELL_AURA_PERIODIC_DAMAGE_PERCENT: case SPELL_AURA_PERIODIC_HEAL: case SPELL_AURA_OBS_MOD_HEALTH: case SPELL_AURA_OBS_MOD_POWER: case SPELL_AURA_48: case SPELL_AURA_POWER_BURN: case SPELL_AURA_PERIODIC_LEECH: case SPELL_AURA_PERIODIC_MANA_LEECH: case SPELL_AURA_PERIODIC_ENERGIZE: case SPELL_AURA_PERIODIC_DUMMY: case SPELL_AURA_PERIODIC_TRIGGER_SPELL: case SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE: case SPELL_AURA_PERIODIC_HEALTH_FUNNEL: if (Effects[x].Amplitude != 0) return DotDuration / Effects[x].Amplitude; break; } } return 6; } uint32 SpellInfo::GetRecoveryTime() const { return RecoveryTime > CategoryRecoveryTime ? RecoveryTime : CategoryRecoveryTime; } int32 SpellInfo::CalcPowerCost(Unit const* caster, SpellSchoolMask schoolMask, Spell* spell) const { // Spell drain all exist power on cast (Only paladin lay of Hands) if (HasAttribute(SPELL_ATTR1_DRAIN_ALL_POWER)) { // If power type - health drain all if (PowerType == POWER_HEALTH) return caster->GetHealth(); // Else drain all power if (PowerType < MAX_POWERS) return caster->GetPower(Powers(PowerType)); TC_LOG_ERROR("spells", "SpellInfo::CalcPowerCost: Unknown power type '%d' in spell %d", PowerType, Id); return 0; } // Base powerCost int32 powerCost = ManaCost; // PCT cost from total amount if (ManaCostPercentage) { switch (PowerType) { // health as power used case POWER_HEALTH: powerCost += int32(CalculatePct(caster->GetCreateHealth(), ManaCostPercentage)); break; case POWER_MANA: powerCost += int32(CalculatePct(caster->GetCreateMana(), ManaCostPercentage)); break; case POWER_RAGE: case POWER_FOCUS: case POWER_ENERGY: case POWER_HAPPINESS: powerCost += int32(CalculatePct(caster->GetMaxPower(Powers(PowerType)), ManaCostPercentage)); break; case POWER_RUNE: case POWER_RUNIC_POWER: TC_LOG_DEBUG("spells", "CalculateManaCost: Not implemented yet!"); break; default: TC_LOG_ERROR("spells", "CalculateManaCost: Unknown power type '%d' in spell %d", PowerType, Id); return 0; } } SpellSchools school = GetFirstSchoolInMask(schoolMask); // Flat mod from caster auras by spell school powerCost += caster->GetInt32Value(UNIT_FIELD_POWER_COST_MODIFIER + school); // Shiv - costs 20 + weaponSpeed*10 energy (apply only to non-triggered spell with energy cost) if (HasAttribute(SPELL_ATTR4_SPELL_VS_EXTEND_COST)) { uint32 speed = 0; if (SpellShapeshiftEntry const* ss = sSpellShapeshiftStore.LookupEntry(caster->GetShapeshiftForm())) speed = ss->attackSpeed; else speed = caster->GetAttackTime(GetAttackType()); powerCost += speed / 100; } // Apply cost mod by spell if (Player* modOwner = caster->GetSpellModOwner()) modOwner->ApplySpellMod(Id, powerCost, spell); if (!caster->IsControlledByPlayer()) { if (HasAttribute(SPELL_ATTR0_LEVEL_DAMAGE_CALCULATION)) { GtNPCManaCostScalerEntry const* spellScaler = sGtNPCManaCostScalerStore.LookupEntry(SpellLevel - 1); GtNPCManaCostScalerEntry const* casterScaler = sGtNPCManaCostScalerStore.LookupEntry(caster->getLevel() - 1); if (spellScaler && casterScaler) powerCost *= casterScaler->ratio / spellScaler->ratio; } } // 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; } bool SpellInfo::IsRanked() const { return ChainEntry != NULL; } uint8 SpellInfo::GetRank() const { if (!ChainEntry) return 1; return ChainEntry->rank; } SpellInfo const* SpellInfo::GetFirstRankSpell() const { if (!ChainEntry) return this; return ChainEntry->first; } SpellInfo const* SpellInfo::GetLastRankSpell() const { if (!ChainEntry) return NULL; return ChainEntry->last; } SpellInfo const* SpellInfo::GetNextRankSpell() const { if (!ChainEntry) return NULL; return ChainEntry->next; } SpellInfo const* SpellInfo::GetPrevRankSpell() const { if (!ChainEntry) return NULL; return ChainEntry->prev; } SpellInfo const* SpellInfo::GetAuraRankForLevel(uint8 level) const { // ignore passive spells if (IsPassive()) return this; // Client ignores spell with these attributes (sub_53D9D0) if (HasAttribute(SPELL_ATTR0_NEGATIVE_1) || HasAttribute(SPELL_ATTR2_UNK3)) return this; bool needRankSelection = false; for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { if (IsPositiveEffect(i) && (Effects[i].Effect == SPELL_EFFECT_APPLY_AURA || Effects[i].Effect == SPELL_EFFECT_APPLY_AREA_AURA_PARTY || Effects[i].Effect == SPELL_EFFECT_APPLY_AREA_AURA_RAID)) { needRankSelection = true; break; } } // not required if (!needRankSelection) return this; for (SpellInfo const* nextSpellInfo = this; nextSpellInfo != NULL; nextSpellInfo = nextSpellInfo->GetPrevRankSpell()) { // if found appropriate level if (uint32(level + 10) >= nextSpellInfo->SpellLevel) return nextSpellInfo; // one rank less then } // not found return NULL; } bool SpellInfo::IsRankOf(SpellInfo const* spellInfo) const { return GetFirstRankSpell() == spellInfo->GetFirstRankSpell(); } bool SpellInfo::IsDifferentRankOf(SpellInfo const* spellInfo) const { if (Id == spellInfo->Id) return false; return IsRankOf(spellInfo); } bool SpellInfo::IsHighRankOf(SpellInfo const* spellInfo) const { if (ChainEntry && spellInfo->ChainEntry) if (ChainEntry->first == spellInfo->ChainEntry->first) if (ChainEntry->rank > spellInfo->ChainEntry->rank) return true; return false; } void SpellInfo::_InitializeExplicitTargetMask() { bool srcSet = false; bool dstSet = false; uint32 targetMask = Targets; // prepare target mask using effect target entries for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { if (!Effects[i].IsEffect()) continue; targetMask |= Effects[i].TargetA.GetExplicitTargetMask(srcSet, dstSet); targetMask |= Effects[i].TargetB.GetExplicitTargetMask(srcSet, dstSet); // add explicit target flags based on spell effects which have EFFECT_IMPLICIT_TARGET_EXPLICIT and no valid target provided if (Effects[i].GetImplicitTargetType() != EFFECT_IMPLICIT_TARGET_EXPLICIT) continue; // extend explicit target mask only if valid targets for effect could not be provided by target types uint32 effectTargetMask = Effects[i].GetMissingTargetMask(srcSet, dstSet, targetMask); // don't add explicit object/dest flags when spell has no max range if (GetMaxRange(true) == 0.0f && GetMaxRange(false) == 0.0f) effectTargetMask &= ~(TARGET_FLAG_UNIT_MASK | TARGET_FLAG_GAMEOBJECT | TARGET_FLAG_CORPSE_MASK | TARGET_FLAG_DEST_LOCATION); targetMask |= effectTargetMask; } ExplicitTargetMask = targetMask; } bool SpellInfo::_IsPositiveEffect(uint8 effIndex, bool deep) const { // not found a single positive spell with this attribute if (HasAttribute(SPELL_ATTR0_NEGATIVE_1)) return false; // these spells must not be downscaled, thus marking them negative (see GetAuraRankForLevel) if (HasAttribute(SPELL_ATTR2_UNK3)) return false; switch (SpellFamilyName) { case SPELLFAMILY_GENERIC: switch (Id) { case 29214: // Wrath of the Plaguebringer case 34700: // Allergic Reaction case 54836: // Wrath of the Plaguebringer case 61987: // Avenging Wrath Marker case 61988: // Divine Shield exclude aura return false; case 30877: // Tag Murloc case 61716: // Rabbit Costume case 61734: // Noblegarden Bunny case 62344: // Fists of Stone case 61819: // Manabonked! (item) case 61834: // Manabonked! (minigob) return true; default: break; } break; case SPELLFAMILY_MAGE: // Amplify Magic, Dampen Magic if (SpellFamilyFlags[0] == 0x00002000) return true; // Impact if (SpellIconID == 45) return true; // Arcane Missiles if (SpellFamilyFlags[0] == 0x00000800) return false; break; case SPELLFAMILY_PRIEST: switch (Id) { case 64844: // Divine Hymn case 64904: // Hymn of Hope case 47585: // Dispersion return true; default: break; } break; case SPELLFAMILY_HUNTER: // Aspect of the Viper if (Id == 34074) return true; break; case SPELLFAMILY_SHAMAN: if (Id == 30708) return false; break; case SPELLFAMILY_ROGUE: switch (Id) { // Envenom must be considered as a positive effect even though it deals damage case 32645: // Envenom (Rank 1) case 32684: // Envenom (Rank 2) case 57992: // Envenom (Rank 3) case 57993: // Envenom (Rank 4) // Slice and Dice. Prevents breaking Stealth case 5171: // Slice and Dice (Rank 1) case 6774: // Slice and Dice (Rank 2) return true; default: break; } break; default: break; } switch (Mechanic) { case MECHANIC_IMMUNE_SHIELD: return true; default: break; } // Special case: effects which determine positivity of whole spell for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { if (Effects[i].IsAura()) { switch (Effects[i].ApplyAuraName) { case SPELL_AURA_MOD_STEALTH: return true; case SPELL_AURA_CHANNEL_DEATH_ITEM: return false; } } } switch (Effects[effIndex].Effect) { case SPELL_EFFECT_DUMMY: // some explicitly required dummy effect sets switch (Id) { case 28441: return false; // AB Effect 000 default: break; } break; // always positive effects (check before target checks that provided non-positive result in some case for positive effects) case SPELL_EFFECT_HEAL: case SPELL_EFFECT_LEARN_SPELL: case SPELL_EFFECT_SKILL_STEP: case SPELL_EFFECT_HEAL_PCT: case SPELL_EFFECT_ENERGIZE_PCT: return true; case SPELL_EFFECT_APPLY_AREA_AURA_ENEMY: return false; // non-positive aura use case SPELL_EFFECT_APPLY_AURA: case SPELL_EFFECT_APPLY_AREA_AURA_FRIEND: { switch (Effects[effIndex].ApplyAuraName) { case SPELL_AURA_MOD_DAMAGE_DONE: // dependent from bas point sign (negative -> negative) case SPELL_AURA_MOD_STAT: case SPELL_AURA_MOD_SKILL: case SPELL_AURA_MOD_DODGE_PERCENT: case SPELL_AURA_MOD_HEALING_PCT: case SPELL_AURA_MOD_HEALING_DONE: case SPELL_AURA_MOD_DAMAGE_PERCENT_DONE: if (Effects[effIndex].CalcValue() < 0) return false; break; case SPELL_AURA_MOD_DAMAGE_TAKEN: // dependent from bas point sign (positive -> negative) if (Effects[effIndex].CalcValue() > 0) return false; break; case SPELL_AURA_MOD_CRIT_PCT: case SPELL_AURA_MOD_SPELL_CRIT_CHANCE: if (Effects[effIndex].CalcValue() > 0) return true; // some expected positive spells have SPELL_ATTR1_NEGATIVE break; case SPELL_AURA_ADD_TARGET_TRIGGER: return true; case SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE: case SPELL_AURA_PERIODIC_TRIGGER_SPELL: if (!deep) { if (SpellInfo const* spellTriggeredProto = sSpellMgr->GetSpellInfo(Effects[effIndex].TriggerSpell)) { // negative targets of main spell return early for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { if (!spellTriggeredProto->Effects[i].Effect) continue; // if non-positive trigger cast targeted to positive target this main cast is non-positive // this will place this spell auras as debuffs if (_IsPositiveTarget(spellTriggeredProto->Effects[i].TargetA.GetTarget(), spellTriggeredProto->Effects[i].TargetB.GetTarget()) && !spellTriggeredProto->_IsPositiveEffect(i, true)) return false; } } } case SPELL_AURA_PROC_TRIGGER_SPELL: // many positive auras have negative triggered spells at damage for example and this not make it negative (it can be canceled for example) break; case SPELL_AURA_MOD_STUN: //have positive and negative spells, we can't sort its correctly at this moment. if (effIndex == 0 && Effects[1].Effect == 0 && Effects[2].Effect == 0) return false; // but all single stun aura spells is negative break; case SPELL_AURA_MOD_PACIFY_SILENCE: if (Id == 24740) // Wisp Costume return true; return false; case SPELL_AURA_MOD_ROOT: case SPELL_AURA_MOD_SILENCE: case SPELL_AURA_GHOST: case SPELL_AURA_PERIODIC_LEECH: case SPELL_AURA_MOD_STALKED: case SPELL_AURA_PERIODIC_DAMAGE_PERCENT: case SPELL_AURA_PREVENT_RESURRECTION: return false; case SPELL_AURA_PERIODIC_DAMAGE: // used in positive spells also. // part of negative spell if cast at self (prevent cancel) if (Effects[effIndex].TargetA.GetTarget() == TARGET_UNIT_CASTER) return false; break; case SPELL_AURA_MOD_DECREASE_SPEED: // used in positive spells also // part of positive spell if cast at self if (Effects[effIndex].TargetA.GetTarget() != TARGET_UNIT_CASTER) return false; // but not this if this first effect (didn't find better check) if (HasAttribute(SPELL_ATTR0_NEGATIVE_1) && effIndex == 0) return false; break; case SPELL_AURA_MECHANIC_IMMUNITY: { // non-positive immunities switch (Effects[effIndex].MiscValue) { case MECHANIC_BANDAGE: case MECHANIC_SHIELD: case MECHANIC_MOUNT: case MECHANIC_INVULNERABILITY: return false; default: break; } break; } case SPELL_AURA_ADD_FLAT_MODIFIER: // mods case SPELL_AURA_ADD_PCT_MODIFIER: { // non-positive mods switch (Effects[effIndex].MiscValue) { case SPELLMOD_COST: // dependent from bas point sign (negative -> positive) if (Effects[effIndex].CalcValue() > 0) { if (!deep) { bool negative = true; for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { if (i != effIndex) if (_IsPositiveEffect(i, true)) { negative = false; break; } } if (negative) return false; } } break; default: break; } break; } default: break; } break; } default: break; } // non-positive targets if (!_IsPositiveTarget(Effects[effIndex].TargetA.GetTarget(), Effects[effIndex].TargetB.GetTarget())) return false; // negative spell if triggered spell is negative if (!deep && !Effects[effIndex].ApplyAuraName && Effects[effIndex].TriggerSpell) { if (SpellInfo const* spellTriggeredProto = sSpellMgr->GetSpellInfo(Effects[effIndex].TriggerSpell)) if (!spellTriggeredProto->_IsPositiveSpell()) return false; } // ok, positive return true; } bool SpellInfo::_IsPositiveSpell() const { // spells with at least one negative effect are considered negative // some self-applied spells have negative effects but in self casting case negative check ignored. for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) if (!_IsPositiveEffect(i, true)) return false; return true; } bool SpellInfo::_IsPositiveTarget(uint32 targetA, uint32 targetB) { // non-positive targets switch (targetA) { case TARGET_UNIT_NEARBY_ENEMY: case TARGET_UNIT_TARGET_ENEMY: case TARGET_UNIT_SRC_AREA_ENEMY: case TARGET_UNIT_DEST_AREA_ENEMY: case TARGET_UNIT_CONE_ENEMY_24: case TARGET_UNIT_CONE_ENEMY_104: case TARGET_DEST_DYNOBJ_ENEMY: case TARGET_DEST_TARGET_ENEMY: return false; default: break; } if (targetB) return _IsPositiveTarget(targetB, 0); return true; } void SpellInfo::_UnloadImplicitTargetConditionLists() { // find the same instances of ConditionList and delete them. for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) { ConditionContainer* cur = Effects[i].ImplicitTargetConditions; if (!cur) continue; for (uint8 j = i; j < MAX_SPELL_EFFECTS; ++j) { if (Effects[j].ImplicitTargetConditions == cur) Effects[j].ImplicitTargetConditions = NULL; } delete cur; } }