josh/TCPlayerbotCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b1c4118a33f669f8be7131c7d37b34dbe63ff545
TCPlayerbotCore/src/server/game/Spells/SpellInfo.h
T

472 lines
17 KiB
C++
Raw Normal View History

Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
/*
Update headers for 2012. HAPPY NEW YEAR!!!
2012-01-01 00:32:13 +01:00
* Copyright (C) 2008-2012 TrinityCore <http://www.trinitycore.org/>
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
*
* 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 <http://www.gnu.org/licenses/>.
*/
#ifndef _SPELLINFO_H
#define _SPELLINFO_H
#include "SharedDefines.h"
Core: Fix non-PCH build
2011-08-21 17:07:32 +02:00
#include "Util.h"
#include "DBCStructure.h"
Core/Build: Fix non-PCH builds
2011-09-18 16:30:18 +02:00
#include "Object.h"
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
class Unit;
Core: Add missing forward declarations in SpellInfo.h
2011-08-16 20:08:13 +02:00
class Player;
Core/Spells: Fix pick lock - thanks to cyberbrest for pointing the reason of this issue.
2011-09-03 20:16:15 +02:00
class Item;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
class Spell;
class SpellInfo;
struct SpellChainNode;
struct SpellTargetPosition;
struct SpellDurationEntry;
Core: Add missing forward declarations in SpellInfo.h
2011-08-16 20:08:13 +02:00
struct SpellModifier;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
struct SpellRangeEntry;
struct SpellRadiusEntry;
struct SpellEntry;
struct SpellCastTimesEntry;
Core/Db/Conditions:
2012-02-21 20:03:27 +01:00
struct Condition;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
Core/Spells: Add a generic way of selecting spell explicit targets. Make explicit targets independant of calling convention in core - this makes targets sent to client to be much more blizzlike than before (for example CastSpell(Unit*) won't set TARGET_FLAG_UNIT for spells which are not using explicit unit target) for SMSG_SPELL_START packets. Also remove hacks, which became obsolete with this commit.
2011-08-24 08:07:59 +02:00
enum SpellCastTargetFlags
{
TARGET_FLAG_NONE = 0x00000000,
TARGET_FLAG_UNUSED_1 = 0x00000001, // not used
TARGET_FLAG_UNIT = 0x00000002, // pguid
TARGET_FLAG_UNIT_RAID = 0x00000004, // not sent, used to validate target (if raid member)
TARGET_FLAG_UNIT_PARTY = 0x00000008, // not sent, used to validate target (if party member)
TARGET_FLAG_ITEM = 0x00000010, // pguid
TARGET_FLAG_SOURCE_LOCATION = 0x00000020, // pguid, 3 float
TARGET_FLAG_DEST_LOCATION = 0x00000040, // pguid, 3 float
TARGET_FLAG_UNIT_ENEMY = 0x00000080, // not sent, used to validate target (if enemy)
TARGET_FLAG_UNIT_ALLY = 0x00000100, // not sent, used to validate target (if ally)
TARGET_FLAG_CORPSE_ENEMY = 0x00000200, // pguid
TARGET_FLAG_UNIT_DEAD = 0x00000400, // not sent, used to validate target (if dead creature)
TARGET_FLAG_GAMEOBJECT = 0x00000800, // pguid, used with TARGET_GAMEOBJECT_TARGET
TARGET_FLAG_TRADE_ITEM = 0x00001000, // pguid
TARGET_FLAG_STRING = 0x00002000, // string
TARGET_FLAG_GAMEOBJECT_ITEM = 0x00004000, // not sent, used with TARGET_GAMEOBJECT_ITEM_TARGET
TARGET_FLAG_CORPSE_ALLY = 0x00008000, // pguid
TARGET_FLAG_UNIT_MINIPET = 0x00010000, // pguid, used to validate target (if non combat pet)
TARGET_FLAG_GLYPH_SLOT = 0x00020000, // used in glyph spells
TARGET_FLAG_DEST_TARGET = 0x00040000, // sometimes appears with DEST_TARGET spells (may appear or not for a given spell)
TARGET_FLAG_UNUSED20 = 0x00080000, // uint32 counter, loop { vec3 - screen position (?), guid }, not used so far
TARGET_FLAG_UNIT_PASSENGER = 0x00100000, // guessed, used to validate target (if vehicle passenger)
Cosmetic: Multiple cosmetic changes
2011-09-29 12:43:05 +02:00
TARGET_FLAG_UNIT_MASK = TARGET_FLAG_UNIT | TARGET_FLAG_UNIT_RAID | TARGET_FLAG_UNIT_PARTY
Core/Spells: Add a generic way of selecting spell explicit targets. Make explicit targets independant of calling convention in core - this makes targets sent to client to be much more blizzlike than before (for example CastSpell(Unit*) won't set TARGET_FLAG_UNIT for spells which are not using explicit unit target) for SMSG_SPELL_START packets. Also remove hacks, which became obsolete with this commit.
2011-08-24 08:07:59 +02:00
| TARGET_FLAG_UNIT_ENEMY | TARGET_FLAG_UNIT_ALLY | TARGET_FLAG_UNIT_DEAD | TARGET_FLAG_UNIT_MINIPET | TARGET_FLAG_UNIT_PASSENGER,
TARGET_FLAG_GAMEOBJECT_MASK = TARGET_FLAG_GAMEOBJECT | TARGET_FLAG_GAMEOBJECT_ITEM,
TARGET_FLAG_CORPSE_MASK = TARGET_FLAG_CORPSE_ALLY | TARGET_FLAG_CORPSE_ENEMY,
Core: Warning fixes (Also some -pedantic under game folder)
2012-09-10 13:03:38 +02:00
TARGET_FLAG_ITEM_MASK = TARGET_FLAG_TRADE_ITEM | TARGET_FLAG_ITEM | TARGET_FLAG_GAMEOBJECT_ITEM
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
};
Core/Spells: Add new spell implicit target categories data - will be used in future patches.
2011-08-17 11:30:05 +02:00
enum SpellTargetSelectionCategories
{
TARGET_SELECT_CATEGORY_NYI,
TARGET_SELECT_CATEGORY_DEFAULT,
TARGET_SELECT_CATEGORY_CHANNEL,
TARGET_SELECT_CATEGORY_NEARBY,
TARGET_SELECT_CATEGORY_CONE,
Core: Warning fixes (Also some -pedantic under game folder)
2012-09-10 13:03:38 +02:00
TARGET_SELECT_CATEGORY_AREA
Core/Spells: Add new spell implicit target categories data - will be used in future patches.
2011-08-17 11:30:05 +02:00
};
enum SpellTargetReferenceTypes
{
TARGET_REFERENCE_TYPE_NONE,
TARGET_REFERENCE_TYPE_CASTER,
TARGET_REFERENCE_TYPE_TARGET,
TARGET_REFERENCE_TYPE_LAST,
TARGET_REFERENCE_TYPE_SRC,
Core: Warning fixes (Also some -pedantic under game folder)
2012-09-10 13:03:38 +02:00
TARGET_REFERENCE_TYPE_DEST
Core/Spells: Add new spell implicit target categories data - will be used in future patches.
2011-08-17 11:30:05 +02:00
};
enum SpellTargetObjectTypes
{
Core/Spells: Improvements in selecting default targets based on effect type.
2011-09-23 11:58:01 +02:00
TARGET_OBJECT_TYPE_NONE = 0,
Core/Spells: Add new spell implicit target categories data - will be used in future patches.
2011-08-17 11:30:05 +02:00
TARGET_OBJECT_TYPE_SRC,
TARGET_OBJECT_TYPE_DEST,
TARGET_OBJECT_TYPE_UNIT,
Core/Spells: Add required and implicit target object type data for spell effects - will be used in future patches.
2011-08-18 11:50:00 +02:00
TARGET_OBJECT_TYPE_UNIT_AND_DEST,
Core/Spells: Add new spell implicit target categories data - will be used in future patches.
2011-08-17 11:30:05 +02:00
TARGET_OBJECT_TYPE_GOBJ,
TARGET_OBJECT_TYPE_GOBJ_ITEM,
TARGET_OBJECT_TYPE_ITEM,
TARGET_OBJECT_TYPE_CORPSE,
Core/Spells: Improvements in selecting default targets based on effect type.
2011-09-23 11:58:01 +02:00
// only for effect target type
TARGET_OBJECT_TYPE_CORPSE_ENEMY,
Core: Warning fixes (Also some -pedantic under game folder)
2012-09-10 13:03:38 +02:00
TARGET_OBJECT_TYPE_CORPSE_ALLY
Core/Spells: Add new spell implicit target categories data - will be used in future patches.
2011-08-17 11:30:05 +02:00
};
Core/Db/Conditions:
2012-02-21 20:03:27 +01:00
enum SpellTargetCheckTypes
Core/Spells: Add new spell implicit target categories data - will be used in future patches.
2011-08-17 11:30:05 +02:00
{
Core/Db/Conditions:
2012-02-21 20:03:27 +01:00
TARGET_CHECK_DEFAULT,
TARGET_CHECK_ENTRY,
TARGET_CHECK_ENEMY,
TARGET_CHECK_ALLY,
TARGET_CHECK_PARTY,
TARGET_CHECK_RAID,
TARGET_CHECK_RAID_CLASS,
Core: Warning fixes (Also some -pedantic under game folder)
2012-09-10 13:03:38 +02:00
TARGET_CHECK_PASSENGER
Core/Spells: Add new spell implicit target categories data - will be used in future patches.
2011-08-17 11:30:05 +02:00
};
enum SpellTargetDirectionTypes
{
TARGET_DIR_NONE,
TARGET_DIR_FRONT,
TARGET_DIR_BACK,
TARGET_DIR_RIGHT,
TARGET_DIR_LEFT,
TARGET_DIR_FRONT_RIGHT,
TARGET_DIR_BACK_RIGHT,
TARGET_DIR_BACK_LEFT,
TARGET_DIR_FRONT_LEFT,
TARGET_DIR_RANDOM,
Core: Warning fixes (Also some -pedantic under game folder)
2012-09-10 13:03:38 +02:00
TARGET_DIR_ENTRY
Core/Spells: Add new spell implicit target categories data - will be used in future patches.
2011-08-17 11:30:05 +02:00
};
Core/Spells: Improvements in selecting default targets based on effect type.
2011-09-23 11:58:01 +02:00
enum SpellEffectImplicitTargetTypes
{
EFFECT_IMPLICIT_TARGET_NONE = 0,
EFFECT_IMPLICIT_TARGET_EXPLICIT,
Core: Warning fixes (Also some -pedantic under game folder)
2012-09-10 13:03:38 +02:00
EFFECT_IMPLICIT_TARGET_CASTER
Core/Spells: Improvements in selecting default targets based on effect type.
2011-09-23 11:58:01 +02:00
};
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
// Spell clasification
enum SpellSpecificType
{
Cosmetic: Some cosmetic changes here and there
2011-08-15 11:46:48 +02:00
SPELL_SPECIFIC_NORMAL = 0,
SPELL_SPECIFIC_SEAL = 1,
SPELL_SPECIFIC_AURA = 3,
SPELL_SPECIFIC_STING = 4,
SPELL_SPECIFIC_CURSE = 5,
SPELL_SPECIFIC_ASPECT = 6,
SPELL_SPECIFIC_TRACKER = 7,
SPELL_SPECIFIC_WARLOCK_ARMOR = 8,
SPELL_SPECIFIC_MAGE_ARMOR = 9,
SPELL_SPECIFIC_ELEMENTAL_SHIELD = 10,
SPELL_SPECIFIC_MAGE_POLYMORPH = 11,
SPELL_SPECIFIC_JUDGEMENT = 13,
SPELL_SPECIFIC_WARLOCK_CORRUPTION = 17,
SPELL_SPECIFIC_FOOD = 19,
SPELL_SPECIFIC_DRINK = 20,
SPELL_SPECIFIC_FOOD_AND_DRINK = 21,
SPELL_SPECIFIC_PRESENCE = 22,
SPELL_SPECIFIC_CHARM = 23,
SPELL_SPECIFIC_SCROLL = 24,
SPELL_SPECIFIC_MAGE_ARCANE_BRILLANCE = 25,
SPELL_SPECIFIC_WARRIOR_ENRAGE = 26,
SPELL_SPECIFIC_PRIEST_DIVINE_SPIRIT = 27,
Core: Warning fixes (Also some -pedantic under game folder)
2012-09-10 13:03:38 +02:00
SPELL_SPECIFIC_HAND = 28
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
};
enum SpellCustomAttributes
{
Cosmetic: Some cosmetic changes here and there
2011-08-15 11:46:48 +02:00
SPELL_ATTR0_CU_ENCHANT_PROC = 0x00000001,
SPELL_ATTR0_CU_CONE_BACK = 0x00000002,
SPELL_ATTR0_CU_CONE_LINE = 0x00000004,
SPELL_ATTR0_CU_SHARE_DAMAGE = 0x00000008,
[Core/Threat] SpellThreat-Calculation revamped
2011-08-21 12:00:36 +02:00
SPELL_ATTR0_CU_NO_INITIAL_THREAT = 0x00000010,
Cosmetic: Some cosmetic changes here and there
2011-08-15 11:46:48 +02:00
SPELL_ATTR0_CU_NONE2 = 0x00000020, // UNUSED
SPELL_ATTR0_CU_AURA_CC = 0x00000040,
SPELL_ATTR0_CU_DIRECT_DAMAGE = 0x00000100,
SPELL_ATTR0_CU_CHARGE = 0x00000200,
SPELL_ATTR0_CU_PICKPOCKET = 0x00000400,
SPELL_ATTR0_CU_NEGATIVE_EFF0 = 0x00001000,
SPELL_ATTR0_CU_NEGATIVE_EFF1 = 0x00002000,
SPELL_ATTR0_CU_NEGATIVE_EFF2 = 0x00004000,
SPELL_ATTR0_CU_IGNORE_ARMOR = 0x00008000,
SPELL_ATTR0_CU_REQ_TARGET_FACING_CASTER = 0x00010000,
SPELL_ATTR0_CU_REQ_CASTER_BEHIND_TARGET = 0x00020000,
Core: Warning fixes (Also some -pedantic under game folder)
2012-09-10 13:03:38 +02:00
SPELL_ATTR0_CU_NEGATIVE = SPELL_ATTR0_CU_NEGATIVE_EFF0 | SPELL_ATTR0_CU_NEGATIVE_EFF1 | SPELL_ATTR0_CU_NEGATIVE_EFF2
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
};
Core/Spells: Add a generic way of selecting spell explicit targets. Make explicit targets independant of calling convention in core - this makes targets sent to client to be much more blizzlike than before (for example CastSpell(Unit*) won't set TARGET_FLAG_UNIT for spells which are not using explicit unit target) for SMSG_SPELL_START packets. Also remove hacks, which became obsolete with this commit.
2011-08-24 08:07:59 +02:00
uint32 GetTargetFlagMask(SpellTargetObjectTypes objType);
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
class SpellImplicitTargetInfo
{
private:
Targets _target;
public:
SpellImplicitTargetInfo() {}
SpellImplicitTargetInfo(uint32 target);
bool IsArea() const;
Core/Spells: Add new spell implicit target categories data - will be used in future patches.
2011-08-17 11:30:05 +02:00
SpellTargetSelectionCategories GetSelectionCategory() const;
SpellTargetReferenceTypes GetReferenceType() const;
SpellTargetObjectTypes GetObjectType() const;
Core/Db/Conditions:
2012-02-21 20:03:27 +01:00
SpellTargetCheckTypes GetCheckType() const;
Core/Spells: Add new spell implicit target categories data - will be used in future patches.
2011-08-17 11:30:05 +02:00
SpellTargetDirectionTypes GetDirectionType() const;
float CalcDirectionAngle() const;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
Core/Spells: Removed implicit casts from SpellImplicitTargetInfo, fixed copypaste mistakes and one crash
2011-07-27 12:35:59 +02:00
Targets GetTarget() const;
Core/Spells: Add a generic way of selecting spell explicit targets. Make explicit targets independant of calling convention in core - this makes targets sent to client to be much more blizzlike than before (for example CastSpell(Unit*) won't set TARGET_FLAG_UNIT for spells which are not using explicit unit target) for SMSG_SPELL_START packets. Also remove hacks, which became obsolete with this commit.
2011-08-24 08:07:59 +02:00
uint32 GetExplicitTargetMask(bool& srcSet, bool& dstSet) const;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
private:
Core/Spells: Add new spell implicit target categories data - will be used in future patches.
2011-08-17 11:30:05 +02:00
struct StaticData
{
Core/Spells: Add required and implicit target object type data for spell effects - will be used in future patches.
2011-08-18 11:50:00 +02:00
SpellTargetObjectTypes ObjectType; // type of object returned by target type
SpellTargetReferenceTypes ReferenceType; // defines which object is used as a reference when selecting target
Core/Spells: Add new spell implicit target categories data - will be used in future patches.
2011-08-17 11:30:05 +02:00
SpellTargetSelectionCategories SelectionCategory;
Core/Db/Conditions:
2012-02-21 20:03:27 +01:00
SpellTargetCheckTypes SelectionCheckType; // defines selection criteria
Core/Spells: Add required and implicit target object type data for spell effects - will be used in future patches.
2011-08-18 11:50:00 +02:00
SpellTargetDirectionTypes DirectionType; // direction for cone and dest targets
Core/Spells: Add new spell implicit target categories data - will be used in future patches.
2011-08-17 11:30:05 +02:00
};
static StaticData _data[TOTAL_SPELL_TARGETS];
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
};
class SpellEffectInfo
{
SpellInfo const* _spellInfo;
uint8 _effIndex;
public:
uint32 Effect;
uint32 ApplyAuraName;
uint32 Amplitude;
int32 DieSides;
float RealPointsPerLevel;
int32 BasePoints;
float PointsPerComboPoint;
float ValueMultiplier;
float DamageMultiplier;
float BonusMultiplier;
int32 MiscValue;
int32 MiscValueB;
Mechanics Mechanic;
SpellImplicitTargetInfo TargetA;
SpellImplicitTargetInfo TargetB;
SpellRadiusEntry const* RadiusEntry;
uint32 ChainTarget;
uint32 ItemType;
uint32 TriggerSpell;
flag96 SpellClassMask;
Core/Db/Conditions:
2012-02-21 20:03:27 +01:00
std::list<Condition*>* ImplicitTargetConditions;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
SpellEffectInfo() {}
SpellEffectInfo(SpellEntry const* spellEntry, SpellInfo const* spellInfo, uint8 effIndex);
bool IsEffect() const;
bool IsEffect(SpellEffects effectName) const;
bool IsAura() const;
bool IsAura(AuraType aura) const;
Core/Spells:
2012-02-03 22:24:03 +01:00
bool IsTargetingArea() const;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
bool IsAreaAuraEffect() const;
bool IsFarUnitTargetEffect() const;
bool IsFarDestTargetEffect() const;
bool IsUnitOwnedAuraEffect() const;
int32 CalcValue(Unit const* caster = NULL, int32 const* basePoints = NULL, Unit const* target = NULL) const;
int32 CalcBaseValue(int32 value) const;
float CalcValueMultiplier(Unit* caster, Spell* spell = NULL) const;
float CalcDamageMultiplier(Unit* caster, Spell* spell = NULL) const;
bool HasRadius() const;
float CalcRadius(Unit* caster = NULL, Spell* = NULL) const;
Core/Spells: spell effect handling improvements
2011-09-25 13:29:17 +02:00
uint32 GetProvidedTargetMask() const;
Core/Spells: Improvements in selecting default targets based on effect type.
2011-09-23 11:58:01 +02:00
uint32 GetMissingTargetMask(bool srcSet = false, bool destSet = false, uint32 mask = 0) const;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
Core/Spells: Improvements in selecting default targets based on effect type.
2011-09-23 11:58:01 +02:00
SpellEffectImplicitTargetTypes GetImplicitTargetType() const;
SpellTargetObjectTypes GetUsedTargetObjectType() const;
Core/Spells: Add required and implicit target object type data for spell effects - will be used in future patches.
2011-08-18 11:50:00 +02:00
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
private:
Core/Spells: Add required and implicit target object type data for spell effects - will be used in future patches.
2011-08-18 11:50:00 +02:00
struct StaticData
{
Core/Spells: Improvements in selecting default targets based on effect type.
2011-09-23 11:58:01 +02:00
SpellEffectImplicitTargetTypes ImplicitTargetType; // defines what target can be added to effect target list if there's no valid target type provided for effect
SpellTargetObjectTypes UsedTargetObjectType; // defines valid target object type for spell effect
Core/Spells: Add required and implicit target object type data for spell effects - will be used in future patches.
2011-08-18 11:50:00 +02:00
};
static StaticData _data[TOTAL_SPELL_EFFECTS];
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
};
class SpellInfo
{
public:
uint32 Id;
uint32 Category;
uint32 Dispel;
uint32 Mechanic;
uint32 Attributes;
uint32 AttributesEx;
uint32 AttributesEx2;
uint32 AttributesEx3;
uint32 AttributesEx4;
uint32 AttributesEx5;
uint32 AttributesEx6;
uint32 AttributesEx7;
uint32 AttributesCu;
uint32 Stances;
uint32 StancesNot;
uint32 Targets;
uint32 TargetCreatureType;
uint32 RequiresSpellFocus;
uint32 FacingCasterFlags;
uint32 CasterAuraState;
uint32 TargetAuraState;
uint32 CasterAuraStateNot;
uint32 TargetAuraStateNot;
uint32 CasterAuraSpell;
uint32 TargetAuraSpell;
uint32 ExcludeCasterAuraSpell;
uint32 ExcludeTargetAuraSpell;
SpellCastTimesEntry const* CastTimeEntry;
uint32 RecoveryTime;
uint32 CategoryRecoveryTime;
uint32 StartRecoveryCategory;
uint32 StartRecoveryTime;
uint32 InterruptFlags;
uint32 AuraInterruptFlags;
uint32 ChannelInterruptFlags;
uint32 ProcFlags;
uint32 ProcChance;
uint32 ProcCharges;
uint32 MaxLevel;
uint32 BaseLevel;
uint32 SpellLevel;
SpellDurationEntry const* DurationEntry;
uint32 PowerType;
uint32 ManaCost;
uint32 ManaCostPerlevel;
uint32 ManaPerSecond;
uint32 ManaPerSecondPerLevel;
uint32 ManaCostPercentage;
uint32 RuneCostID;
SpellRangeEntry const* RangeEntry;
float Speed;
uint32 StackAmount;
uint32 Totem[2];
int32 Reagent[MAX_SPELL_REAGENTS];
uint32 ReagentCount[MAX_SPELL_REAGENTS];
int32 EquippedItemClass;
int32 EquippedItemSubClassMask;
int32 EquippedItemInventoryTypeMask;
uint32 TotemCategory[2];
uint32 SpellVisual[2];
uint32 SpellIconID;
uint32 ActiveIconID;
char* SpellName[16];
char* Rank[16];
uint32 MaxTargetLevel;
uint32 MaxAffectedTargets;
uint32 SpellFamilyName;
flag96 SpellFamilyFlags;
uint32 DmgClass;
uint32 PreventionType;
int32 AreaGroupId;
uint32 SchoolMask;
SpellEffectInfo Effects[MAX_SPELL_EFFECTS];
Core/Spells: Add a generic way of selecting spell explicit targets. Make explicit targets independant of calling convention in core - this makes targets sent to client to be much more blizzlike than before (for example CastSpell(Unit*) won't set TARGET_FLAG_UNIT for spells which are not using explicit unit target) for SMSG_SPELL_START packets. Also remove hacks, which became obsolete with this commit.
2011-08-24 08:07:59 +02:00
uint32 ExplicitTargetMask;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
SpellChainNode const* ChainEntry;
SpellInfo(SpellEntry const* spellEntry);
Core/Db/Conditions:
2012-02-21 20:03:27 +01:00
~SpellInfo();
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
bool HasEffect(SpellEffects effect) const;
bool HasAura(AuraType aura) const;
bool HasAreaAuraEffect() const;
bool IsExplicitDiscovery() const;
bool IsLootCrafting() const;
bool IsQuestTame() const;
bool IsProfessionOrRiding() const;
bool IsProfession() const;
bool IsPrimaryProfession() const;
bool IsPrimaryProfessionFirstRank() const;
bool IsAbilityLearnedWithProfession() const;
bool IsAbilityOfSkillType(uint32 skillType) const;
Core/Spells:
2012-02-03 22:24:03 +01:00
bool IsAffectingArea() const;
bool IsTargetingArea() const;
Core/Spells: Fix a regression of 7f30ac5a95 - spells with TARGET_SELECT_CATEGORY_CHANNEL target type (like mind sear) should be triggered by triggering spell caster
2011-08-26 12:39:50 +02:00
bool NeedsExplicitUnitTarget() const;
bool NeedsToBeTriggeredByCaster() const;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
bool IsPassive() const;
bool IsAutocastable() const;
bool IsStackableWithRanks() const;
bool IsPassiveStackableWithRanks() const;
bool IsMultiSlotAura() const;
bool IsDeathPersistent() const;
bool IsRequiringDeadTarget() const;
bool IsAllowingDeadTarget() const;
bool CanBeUsedInCombat() const;
bool IsPositive() const;
bool IsPositiveEffect(uint8 effIndex) const;
bool IsChanneled() const;
bool NeedsComboPoints() const;
bool IsBreakingStealth() const;
bool IsRangedWeaponSpell() const;
bool IsAutoRepeatRangedSpell() const;
Core/Spells: Do not apply spellmods to spells with SPELL_ATTR3_NO_DONE_BONUS attribute.
2011-08-23 14:27:35 +02:00
bool IsAffectedBySpellMods() const;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
bool IsAffectedBySpellMod(SpellModifier* mod) const;
bool CanPierceImmuneAura(SpellInfo const* aura) const;
bool CanDispelAura(SpellInfo const* aura) const;
bool IsSingleTarget() const;
bool IsSingleTargetWith(SpellInfo const* spellInfo) const;
bool IsAuraExclusiveBySpecificWith(SpellInfo const* spellInfo) const;
bool IsAuraExclusiveBySpecificPerCasterWith(SpellInfo const* spellInfo) const;
SpellCastResult CheckShapeshift(uint32 form) const;
SpellCastResult CheckLocation(uint32 map_id, uint32 zone_id, uint32 area_id, Player const* player = NULL) const;
Core/Db/Conditions:
2012-02-21 20:03:27 +01:00
SpellCastResult CheckTarget(Unit const* caster, WorldObject const* target, bool implicit = true) const;
Core/Spells: Fix pick lock - thanks to cyberbrest for pointing the reason of this issue.
2011-09-03 20:16:15 +02:00
SpellCastResult CheckExplicitTarget(Unit const* caster, WorldObject const* target, Item const* itemTarget = NULL) const;
Core/Spells: Implement recently discovered target check attributes and move most of target checks to SpellInfo::CheckTarget function.
2011-08-19 14:53:40 +02:00
bool CheckTargetCreatureType(Unit const* target) const;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
SpellSchoolMask GetSchoolMask() const;
uint32 GetAllEffectsMechanicMask() const;
uint32 GetEffectMechanicMask(uint8 effIndex) const;
use effectMask to calculate mechanicMask in ModSpellDuration
2011-10-20 18:28:37 +02:00
uint32 GetSpellMechanicMaskByEffectMask(uint32 effectMask) const;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
Mechanics GetEffectMechanic(uint8 effIndex) const;
Fix immunity system for many spells.
2011-12-14 16:13:10 +01:00
bool HasAnyEffectMechanic() const;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
uint32 GetDispelMask() const;
static uint32 GetDispelMask(DispelType type);
Core/Spells: Add a generic way of selecting spell explicit targets. Make explicit targets independant of calling convention in core - this makes targets sent to client to be much more blizzlike than before (for example CastSpell(Unit*) won't set TARGET_FLAG_UNIT for spells which are not using explicit unit target) for SMSG_SPELL_START packets. Also remove hacks, which became obsolete with this commit.
2011-08-24 08:07:59 +02:00
uint32 GetExplicitTargetMask() const;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
AuraStateType GetAuraState() const;
SpellSpecificType GetSpellSpecific() const;
float GetMinRange(bool positive = false) const;
Core/Db/Conditions:
2012-02-21 20:03:27 +01:00
float GetMaxRange(bool positive = false, Unit* caster = NULL, Spell* spell = NULL) const;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
int32 GetDuration() const;
int32 GetMaxDuration() const;
Core/Spells: Separation caster/target part damage/heal bonus calculations.
2012-04-28 15:10:52 +03:00
uint32 GetMaxTicks() const;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
uint32 CalcCastTime(Unit* caster = NULL, Spell* spell = NULL) const;
uint32 GetRecoveryTime() const;
uint32 CalcPowerCost(Unit const* caster, SpellSchoolMask schoolMask) const;
bool IsRanked() const;
uint8 GetRank() const;
SpellInfo const* GetFirstRankSpell() const;
SpellInfo const* GetLastRankSpell() const;
SpellInfo const* GetNextRankSpell() const;
SpellInfo const* GetPrevRankSpell() const;
SpellInfo const* GetAuraRankForLevel(uint8 level) const;
bool IsRankOf(SpellInfo const* spellInfo) const;
bool IsDifferentRankOf(SpellInfo const* spellInfo) const;
bool IsHighRankOf(SpellInfo const* spellInfo) const;
// loading helpers
Core/Spells: Add a generic way of selecting spell explicit targets. Make explicit targets independant of calling convention in core - this makes targets sent to client to be much more blizzlike than before (for example CastSpell(Unit*) won't set TARGET_FLAG_UNIT for spells which are not using explicit unit target) for SMSG_SPELL_START packets. Also remove hacks, which became obsolete with this commit.
2011-08-24 08:07:59 +02:00
uint32 _GetExplicitTargetMask() const;
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
bool _IsPositiveEffect(uint8 effIndex, bool deep) const;
bool _IsPositiveSpell() const;
static bool _IsPositiveTarget(uint32 targetA, uint32 targetB);
Core/Db/Conditions:
2012-02-21 20:03:27 +01:00
// unloading helpers
void _UnloadImplicitTargetConditionLists();
Core/Spells: Add SpellInfo class to store static data and methods for spells. This class is going to replace SpellEntry use in core. SpellInfo class includes all spell-related functions which resided in SpellMgr, and makes them much easier to access, reuse or add new stuff. Another advantage is that you no longer have to lookup db/dbc data by entry or index, because such data can now be included in the new class. Thanks to that, TC will have no problems on drastic spell dbc format change in 4.x.
2011-07-26 23:00:23 +02:00
};
Cosmetic: Some cosmetic changes here and there
2011-08-15 11:46:48 +02:00
#endif // _SPELLINFO_H
Reference in New Issue Copy Permalink