2008-10-11 14:16:25 -05:00
/*
* Copyright (C) 2005-2008 MaNGOS <http://www.mangosproject.org/>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef DBCSTRUCTURE_H
#define DBCSTRUCTURE_H
#include "Platform/Define.h"
#include <map>
#include <set>
#include <vector>
// Structures using to access raw DBC data and required packing to portability
// GCC have alternative #pragma pack(N) syntax and old gcc version not support pack(push,N), also any gcc version not support it at some platform
#if defined( __GNUC__ )
#pragma pack(1)
#else
#pragma pack(push,1)
#endif
enum AreaTeams
{
AREATEAM_NONE = 0 ,
AREATEAM_ALLY = 2 ,
AREATEAM_HORDE = 4
};
enum AreaFlags
{
AREA_FLAG_SNOW = 0x00000001 , // snow (only Dun Morogh, Naxxramas, Razorfen Downs and Winterspring)
AREA_FLAG_UNK1 = 0x00000002 , // unknown, (only Naxxramas and Razorfen Downs)
AREA_FLAG_UNK2 = 0x00000004 , // Only used on development map
AREA_FLAG_SLAVE_CAPITAL = 0x00000008 , // slave capital city flag?
AREA_FLAG_UNK3 = 0x00000010 , // unknown
AREA_FLAG_SLAVE_CAPITAL2 = 0x00000020 , // slave capital city flag?
AREA_FLAG_UNK4 = 0x00000040 , // many zones have this flag
AREA_FLAG_ARENA = 0x00000080 , // arena, both instanced and world arenas
AREA_FLAG_CAPITAL = 0x00000100 , // main capital city flag
AREA_FLAG_CITY = 0x00000200 , // only for one zone named "City" (where it located?)
AREA_FLAG_OUTLAND = 0x00000400 , // outland zones? (only Eye of the Storm not have this flag, but have 0x00004000 flag)
AREA_FLAG_SANCTUARY = 0x00000800 , // sanctuary area (PvP disabled)
AREA_FLAG_NEED_FLY = 0x00001000 , // only Netherwing Ledge, Socrethar's Seat, Tempest Keep, The Arcatraz, The Botanica, The Mechanar, Sorrow Wing Point, Dragonspine Ridge, Netherwing Mines, Dragonmaw Base Camp, Dragonmaw Skyway
AREA_FLAG_UNUSED1 = 0x00002000 , // not used now (no area/zones with this flag set in 2.4.2)
AREA_FLAG_OUTLAND2 = 0x00004000 , // outland zones? (only Circle of Blood Arena not have this flag, but have 0x00000400 flag)
AREA_FLAG_PVP = 0x00008000 , // pvp objective area? (Death's Door also has this flag although it's no pvp object area)
AREA_FLAG_ARENA_INSTANCE = 0x00010000 , // used by instanced arenas only
AREA_FLAG_UNUSED2 = 0x00020000 , // not used now (no area/zones with this flag set in 2.4.2)
AREA_FLAG_UNK5 = 0x00040000 , // just used for Amani Pass, Hatchet Hills
AREA_FLAG_LOWLEVEL = 0x00100000 // used for some starting areas with area_level <=15
};
enum FactionTemplateFlags
{
FACTION_TEMPLATE_FLAG_CONTESTED_GUARD = 0x00001000 , // faction will attack players that were involved in PvP combats
};
struct AreaTableEntry
{
uint32 ID ; // 0
uint32 mapid ; // 1
uint32 zone ; // 2 if 0 then it's zone, else it's zone id of this area
uint32 exploreFlag ; // 3, main index
uint32 flags ; // 4, unknown value but 312 for all cities
// 5-9 unused
int32 area_level ; // 10
char * area_name [ 16 ]; // 11-26
// 27, string flags, unused
uint32 team ; // 28
};
struct AreaTriggerEntry
{
uint32 id ; // 0
uint32 mapid ; // 1
float x ; // 2
float y ; // 3
float z ; // 4
float radius ; // 5
float box_x ; // 6 extent x edge
float box_y ; // 7 extent y edge
float box_z ; // 8 extent z edge
float box_orientation ; // 9 extent rotation by about z axis
};
struct BankBagSlotPricesEntry
{
uint32 ID ;
uint32 price ;
};
struct BattlemasterListEntry
{
uint32 id ; // 0
uint32 mapid [ 3 ]; // 1-3 mapid
// 4-8 unused
uint32 type ; // 9 (3 - BG, 4 - arena)
uint32 minlvl ; // 10
uint32 maxlvl ; // 11
uint32 maxplayersperteam ; // 12
// 13-14 unused
char * name [ 16 ]; // 15-30
// 31 string flag, unused
// 32 unused
};
struct CharTitlesEntry
{
uint32 ID ; // 0, title ids, for example in Quest::GetCharTitleId()
//uint32 unk1; // 1 flags?
//char* name[16]; // 2-17, unused
// 18 string flag, unused
//char* name2[16]; // 19-34, unused
// 35 string flag, unused
uint32 bit_index ; // 36 used in PLAYER_CHOSEN_TITLE and 1<<index in PLAYER__FIELD_KNOWN_TITLES
};
struct ChatChannelsEntry
{
uint32 ChannelID ; // 0
uint32 flags ; // 1
char * pattern [ 16 ]; // 3-18
// 19 string flags, unused
//char* name[16]; // 20-35 unused
// 36 string flag, unused
};
struct ChrClassesEntry
{
uint32 ClassID ; // 0
// 1-2, unused
uint32 powerType ; // 3
// 4, unused
//char* name[16]; // 5-20 unused
2008-10-12 14:03:38 -05:00
char * name [ 16 ]; // 5-20 unused
2008-10-11 14:16:25 -05:00
// 21 string flag, unused
//char* string1[16]; // 21-36 unused
// 37 string flag, unused
//char* string2[16]; // 38-53 unused
// 54 string flag, unused
// 55, unused
uint32 spellfamily ; // 56
// 57, unused
};
struct ChrRacesEntry
{
uint32 RaceID ; // 0
// 1 unused
uint32 FactionID ; // 2 facton template id
// 3 unused
uint32 model_m ; // 4
uint32 model_f ; // 5
// 6-7 unused
uint32 TeamID ; // 8 (7-Alliance 1-Horde)
// 9-12 unused
uint32 startmovie ; // 13 id from CinematicCamera.dbc
char * name [ 16 ]; // 14-29 used for DBC language detection/selection
// 30 string flags, unused
//char* string1[16]; // 31-46 used for DBC language detection/selection
// 47 string flags, unused
//char* string2[16]; // 48-63 used for DBC language detection/selection
// 64 string flags, unused
// 65-67 unused
//uint32 addon // 68 (0 - original race, 1 - tbc addon, ...) unused
};
struct CreatureDisplayInfoEntry
{
uint32 Displayid ; // 0
// 1-3,unused
float scale ; // 4
// 5-13,unused
};
struct CreatureFamilyEntry
{
uint32 ID ; // 0
float minScale ; // 1
uint32 minScaleLevel ; // 2 0/1
float maxScale ; // 3
uint32 maxScaleLevel ; // 4 0/60
uint32 skillLine ; // 5
uint32 skillLine2 ; // 6
uint32 petFoodMask ; // 7
char * Name [ 16 ]; // 8-23
// 24 string flags, unused
// 25 icon, unused
};
struct CreatureSpellDataEntry
{
uint32 ID ; // 0
//uint32 spellId[4]; // 1-4 hunter pet learned spell (for later use)
};
struct DurabilityCostsEntry
{
uint32 Itemlvl ; // 0
uint32 multiplier [ 29 ]; // 1-29
};
struct DurabilityQualityEntry
{
uint32 Id ; // 0
float quality_mod ; // 1
};
struct EmotesTextEntry
{
uint32 Id ;
uint32 textid ;
};
struct FactionEntry
{
uint32 ID ; // 0
int32 reputationListID ; // 1
uint32 BaseRepRaceMask [ 4 ]; // 2-5 Base reputation race masks (see enum Races)
uint32 BaseRepClassMask [ 4 ]; // 6-9 Base reputation class masks (see enum Classes)
int32 BaseRepValue [ 4 ]; // 10-13 Base reputation values
uint32 ReputationFlags [ 4 ]; // 14-17 Default flags to apply
uint32 team ; // 18 enum Team
char * name [ 16 ]; // 19-34
// 35 string flags, unused
//char* description[16]; // 36-51 unused
// 52 string flags, unused
};
enum FactionMasks
{
FACTION_MASK_PLAYER = 1 , // any player
FACTION_MASK_ALLIANCE = 2 , // player or creature from alliance team
FACTION_MASK_HORDE = 4 , // player or creature from horde team
FACTION_MASK_MONSTER = 8 // aggressive creature from monster team
// if none flags set then non-aggressive creature
};
struct FactionTemplateEntry
{
uint32 ID ; // 0
uint32 faction ; // 1
uint32 factionFlags ; // 2 specific flags for that faction
uint32 ourMask ; // 3 if mask set (see FactionMasks) then faction included in masked team
uint32 friendlyMask ; // 4 if mask set (see FactionMasks) then faction friendly to masked team
uint32 hostileMask ; // 5 if mask set (see FactionMasks) then faction hostile to masked team
uint32 enemyFaction1 ; // 6
uint32 enemyFaction2 ; // 7
uint32 enemyFaction3 ; // 8
uint32 enemyFaction4 ; // 9
uint32 friendFaction1 ; // 10
uint32 friendFaction2 ; // 11
uint32 friendFaction3 ; // 12
uint32 friendFaction4 ; // 13
//------------------------------------------------------- end structure
// helpers
bool IsFriendlyTo ( FactionTemplateEntry const & entry ) const
{
if ( enemyFaction1 == entry . faction || enemyFaction2 == entry . faction || enemyFaction3 == entry . faction || enemyFaction4 == entry . faction )
return false ;
if ( friendFaction1 == entry . faction || friendFaction2 == entry . faction || friendFaction3 == entry . faction || friendFaction4 == entry . faction )
return true ;
return ( friendlyMask & entry . ourMask ) || ( ourMask & entry . friendlyMask );
}
bool IsHostileTo ( FactionTemplateEntry const & entry ) const
{
if ( enemyFaction1 == entry . faction || enemyFaction2 == entry . faction || enemyFaction3 == entry . faction || enemyFaction4 == entry . faction )
return true ;
if ( friendFaction1 == entry . faction || friendFaction2 == entry . faction || friendFaction3 == entry . faction || friendFaction4 == entry . faction )
return false ;
return ( hostileMask & entry . ourMask ) != 0 ;
}
bool IsHostileToPlayers () const { return ( hostileMask & FACTION_MASK_PLAYER ) != 0 ; }
bool IsNeutralToAll () const { return hostileMask == 0 && friendlyMask == 0 && enemyFaction1 == 0 && enemyFaction2 == 0 && enemyFaction3 == 0 && enemyFaction4 == 0 ; }
bool IsContestedGuardFaction () const { return ( factionFlags & FACTION_TEMPLATE_FLAG_CONTESTED_GUARD ) != 0 ; }
};
struct GemPropertiesEntry
{
uint32 ID ;
uint32 spellitemenchantement ;
uint32 color ;
};
#define GT_MAX_LEVEL 100
struct GtCombatRatingsEntry
{
float ratio ;
};
struct GtChanceToMeleeCritBaseEntry
{
float base ;
};
struct GtChanceToMeleeCritEntry
{
float ratio ;
};
struct GtChanceToSpellCritBaseEntry
{
float base ;
};
struct GtChanceToSpellCritEntry
{
float ratio ;
};
struct GtOCTRegenHPEntry
{
float ratio ;
};
//struct GtOCTRegenMPEntry
//{
// float ratio;
//};
struct GtRegenHPPerSptEntry
{
float ratio ;
};
struct GtRegenMPPerSptEntry
{
float ratio ;
};
struct ItemEntry
{
uint32 ID ;
uint32 DisplayId ;
uint32 InventoryType ;
uint32 Sheath ;
};
struct ItemDisplayInfoEntry
{
uint32 ID ;
uint32 randomPropertyChance ;
};
//struct ItemCondExtCostsEntry
//{
// uint32 ID;
// uint32 condExtendedCost; // ItemPrototype::CondExtendedCost
// uint32 itemextendedcostentry; // ItemPrototype::ExtendedCost
// uint32 arenaseason; // arena season number(1-4)
//};
struct ItemExtendedCostEntry
{
uint32 ID ; // 0 extended-cost entry id
uint32 reqhonorpoints ; // 1 required honor points
uint32 reqarenapoints ; // 2 required arena points
uint32 reqitem [ 5 ]; // 3-7 required item id
uint32 reqitemcount [ 5 ]; // 8-12 required count of 1st item
uint32 reqpersonalarenarating ; // 13 required personal arena rating
};
struct ItemRandomPropertiesEntry
{
uint32 ID ; // 0
//char* internalName // 1 unused
uint32 enchant_id [ 3 ]; // 2-4
// 5-6 unused, 0 only values, reserved for additional enchantments?
//char* nameSuffix[16] // 7-22, unused
// 23 nameSufix flags, unused
};
struct ItemRandomSuffixEntry
{
uint32 ID ; // 0
//char* name[16] // 1-16 unused
// 17, name flags, unused
// 18 unused
uint32 enchant_id [ 3 ]; // 19-21
uint32 prefix [ 3 ]; // 22-24
};
struct ItemSetEntry
{
//uint32 id // 0 item set ID
char * name [ 16 ]; // 1-16
// 17 string flags, unused
// 18-28 items from set, but not have all items listed, use ItemPrototype::ItemSet instead
// 29-34 unused
uint32 spells [ 8 ]; // 35-42
uint32 items_to_triggerspell [ 8 ]; // 43-50
uint32 required_skill_id ; // 51
uint32 required_skill_value ; // 52
};
struct LockEntry
{
uint32 ID ; // 0
uint32 keytype [ 5 ]; // 1-5
// 6-8, not used
uint32 key [ 5 ]; // 9-13
// 14-16, not used
uint32 requiredminingskill ; // 17
uint32 requiredlockskill ; // 18
// 19-32, not used
};
struct MailTemplateEntry
{
uint32 ID ; // 0
//char* subject[16]; // 1-16
// 17 name flags, unused
//char* content[16]; // 18-33
};
enum MapTypes
{
MAP_COMMON = 0 ,
MAP_INSTANCE = 1 ,
MAP_RAID = 2 ,
MAP_BATTLEGROUND = 3 ,
MAP_ARENA = 4
};
struct MapEntry
{
uint32 MapID ; // 0
//char* internalname; // 1 unused
uint32 map_type ; // 2
// 3 unused
char * name [ 16 ]; // 4-19
// 20 name flags, unused
// 21-23 unused (something PvPZone related - levels?)
// 24-26
uint32 linked_zone ; // 27 common zone for instance and continent map
//char* hordeIntro // 28-43 text for PvP Zones
// 44 intro text flags
//char* allianceIntro // 45-60 text for PvP Zones
// 46 intro text flags
// 47-61 not used
uint32 multimap_id ; // 62
// 63-65 not used
//chat* unknownText1 // 66-81 unknown empty text fields, possible normal Intro text.
// 82 text flags
//chat* heroicIntroText // 83-98 heroic mode requirement text
// 99 text flags
//chat* unknownText2 // 100-115 unknown empty text fields
// 116 text flags
int32 parent_map ; // 117 map_id of parent map
//float start_x // 118 enter x coordinate (if exist single entry)
//float start_y // 119 enter y coordinate (if exist single entry)
uint32 resetTimeRaid ; // 120
uint32 resetTimeHeroic ; // 121
// 122-123
uint32 addon ; // 124 (0-original maps,1-tbc addon)
// Helpers
bool IsExpansionMap () const { return addon != 0 ; }
bool IsDungeon () const { return map_type == MAP_INSTANCE || map_type == MAP_RAID ; }
bool Instanceable () const { return map_type == MAP_INSTANCE || map_type == MAP_RAID || map_type == MAP_BATTLEGROUND || map_type == MAP_ARENA ; }
bool IsRaid () const { return map_type == MAP_RAID ; }
bool IsBattleGround () const { return map_type == MAP_BATTLEGROUND ; }
bool IsBattleArena () const { return map_type == MAP_ARENA ; }
bool IsBattleGroundOrArena () const { return map_type == MAP_BATTLEGROUND || map_type == MAP_ARENA ; }
bool SupportsHeroicMode () const { return resetTimeHeroic && ! resetTimeRaid ; }
bool HasResetTime () const { return resetTimeHeroic || resetTimeRaid ; }
bool IsMountAllowed () const
{
return ! IsDungeon () ||
MapID == 568 || MapID == 309 || MapID == 209 || MapID == 534 ||
MapID == 560 || MapID == 509 || MapID == 269 ;
}
};
struct QuestSortEntry
{
uint32 id ; // 0, sort id
//char* name[16]; // 1-16, unused
// 17 name flags, unused
};
struct RandomPropertiesPointsEntry
{
//uint32 Id; // 0 hidden key
uint32 itemLevel ; // 1
uint32 EpicPropertiesPoints [ 5 ]; // 2-6
uint32 RarePropertiesPoints [ 5 ]; // 7-11
uint32 UncommonPropertiesPoints [ 5 ]; // 12-16
};
//struct SkillLineCategoryEntry{
// uint32 id; // 0 hidden key
// char* name[16]; // 1 - 17 Category name
// // 18 string flag
// uint32 displayOrder; // Display order in character tab
//};
//struct SkillRaceClassInfoEntry{
// uint32 id; // 0
// uint32 skillId; // 1 present some refrences to unknown skill
// uint32 raceMask; // 2
// uint32 classMask; // 3
// uint32 flags; // 4 mask for some thing
// uint32 reqLevel; // 5
// uint32 skillTierId; // 6
// uint32 skillCostID; // 7
//};
//struct SkillTiersEntry{
// uint32 id; // 0
// uint32 skillValue[16]; // 1-17 unknown possibly add value on learn?
// uint32 maxSkillValue[16]; // Max value for rank
//};
struct SkillLineEntry
{
uint32 id ; // 0
uint32 categoryId ; // 1 (index from SkillLineCategory.dbc)
//uint32 skillCostID; // 2 not used
char * name [ 16 ]; // 3-18
// 19 string flags, not used
//char* description[16]; // 20-35, not used
// 36 string flags, not used
uint32 spellIcon ; // 37
};
enum AbilytyLearnType
{
ABILITY_LEARNED_ON_GET_PROFESSION_SKILL = 1 ,
ABILITY_LEARNED_ON_GET_RACE_OR_CLASS_SKILL = 2
};
struct SkillLineAbilityEntry
{
uint32 id ; // 0, INDEX
uint32 skillId ; // 1
uint32 spellId ; // 2
uint32 racemask ; // 3
uint32 classmask ; // 4
//uint32 racemaskNot; // 5 always 0 in 2.4.2
//uint32 classmaskNot; // 6 always 0 in 2.4.2
uint32 req_skill_value ; // 7 for trade skill.not for training.
uint32 forward_spellid ; // 8
uint32 learnOnGetSkill ; // 9 can be 1 or 2 for spells learned on get skill
uint32 max_value ; // 10
uint32 min_value ; // 11
// 12-13, unknown, always 0
uint32 reqtrainpoints ; // 14
};
struct SoundEntriesEntry
{
uint32 Id ; // 0, sound id
//uint32 Type; // 1, sound type (10 generally for creature, etc)
//char* InternalName; // 2, internal name, for use in lookup command for example
//char* FileName[10]; // 3-12, file names
//uint32 Unk13[10]; // 13-22, linked with file names?
//char* Path; // 23
// 24-28, unknown
};
struct SpellEntry
{
uint32 Id ; // 0 normally counted from 0 field (but some tools start counting from 1, check this before tool use for data view!)
uint32 Category ; // 1
//uint32 castUI // 2 not used
uint32 Dispel ; // 3
uint32 Mechanic ; // 4
uint32 Attributes ; // 5
uint32 AttributesEx ; // 6
uint32 AttributesEx2 ; // 7
uint32 AttributesEx3 ; // 8
uint32 AttributesEx4 ; // 9
uint32 AttributesEx5 ; // 10
//uint32 AttributesEx6; // 11 not used
uint32 Stances ; // 12
uint32 StancesNot ; // 13
uint32 Targets ; // 14
uint32 TargetCreatureType ; // 15
uint32 RequiresSpellFocus ; // 16
uint32 FacingCasterFlags ; // 17
uint32 CasterAuraState ; // 18
uint32 TargetAuraState ; // 19
uint32 CasterAuraStateNot ; // 20
uint32 TargetAuraStateNot ; // 21
uint32 CastingTimeIndex ; // 22
uint32 RecoveryTime ; // 23
uint32 CategoryRecoveryTime ; // 24
uint32 InterruptFlags ; // 25
uint32 AuraInterruptFlags ; // 26
uint32 ChannelInterruptFlags ; // 27
uint32 procFlags ; // 28
uint32 procChance ; // 29
uint32 procCharges ; // 30
uint32 maxLevel ; // 31
uint32 baseLevel ; // 32
uint32 spellLevel ; // 33
uint32 DurationIndex ; // 34
uint32 powerType ; // 35
uint32 manaCost ; // 36
uint32 manaCostPerlevel ; // 37
uint32 manaPerSecond ; // 38
uint32 manaPerSecondPerLevel ; // 39
uint32 rangeIndex ; // 40
float speed ; // 41
//uint32 modalNextSpell; // 42
uint32 StackAmount ; // 43
uint32 Totem [ 2 ]; // 44-45
int32 Reagent [ 8 ]; // 46-53
uint32 ReagentCount [ 8 ]; // 54-61
int32 EquippedItemClass ; // 62 (value)
int32 EquippedItemSubClassMask ; // 63 (mask)
int32 EquippedItemInventoryTypeMask ; // 64 (mask)
uint32 Effect [ 3 ]; // 65-67
int32 EffectDieSides [ 3 ]; // 68-70
uint32 EffectBaseDice [ 3 ]; // 71-73
float EffectDicePerLevel [ 3 ]; // 74-76
float EffectRealPointsPerLevel [ 3 ]; // 77-79
int32 EffectBasePoints [ 3 ]; // 80-82 (don't must be used in spell/auras explicitly, must be used cached Spell::m_currentBasePoints)
uint32 EffectMechanic [ 3 ]; // 83-85
uint32 EffectImplicitTargetA [ 3 ]; // 86-88
uint32 EffectImplicitTargetB [ 3 ]; // 89-91
uint32 EffectRadiusIndex [ 3 ]; // 92-94 - spellradius.dbc
uint32 EffectApplyAuraName [ 3 ]; // 95-97
uint32 EffectAmplitude [ 3 ]; // 98-100
float EffectMultipleValue [ 3 ]; // 101-103
uint32 EffectChainTarget [ 3 ]; // 104-106
uint32 EffectItemType [ 3 ]; // 107-109
int32 EffectMiscValue [ 3 ]; // 110-112
int32 EffectMiscValueB [ 3 ]; // 113-115
uint32 EffectTriggerSpell [ 3 ]; // 116-118
float EffectPointsPerComboPoint [ 3 ]; // 119-121
uint32 SpellVisual ; // 122
// 123 not used
uint32 SpellIconID ; // 124
uint32 activeIconID ; // 125
//uint32 spellPriority; // 126
char * SpellName [ 16 ]; // 127-142
//uint32 SpellNameFlag; // 143
char * Rank [ 16 ]; // 144-159
//uint32 RankFlags; // 160
//char* Description[16]; // 161-176 not used
//uint32 DescriptionFlags; // 177 not used
//char* ToolTip[16]; // 178-193 not used
//uint32 ToolTipFlags; // 194 not used
uint32 ManaCostPercentage ; // 195
uint32 StartRecoveryCategory ; // 196
uint32 StartRecoveryTime ; // 197
uint32 MaxTargetLevel ; // 198
uint32 SpellFamilyName ; // 199
uint64 SpellFamilyFlags ; // 200+201
uint32 MaxAffectedTargets ; // 202
uint32 DmgClass ; // 203 defenseType
uint32 PreventionType ; // 204
//uint32 StanceBarOrder; // 205 not used
float DmgMultiplier [ 3 ]; // 206-208
//uint32 MinFactionId; // 209 not used, and 0 in 2.4.2
//uint32 MinReputation; // 210 not used, and 0 in 2.4.2
//uint32 RequiredAuraVision; // 211 not used
uint32 TotemCategory [ 2 ]; // 212-213
uint32 AreaId ; // 214
uint32 SchoolMask ; // 215 school mask
private :
// prevent creating custom entries (copy data from original in fact)
SpellEntry ( SpellEntry const & ); // DON'T must have implementation
};
typedef std :: set < uint32 > SpellCategorySet ;
typedef std :: map < uint32 , SpellCategorySet > SpellCategoryStore ;
typedef std :: set < uint32 > PetFamilySpellsSet ;
typedef std :: map < uint32 , PetFamilySpellsSet > PetFamilySpellsStore ;
struct SpellCastTimesEntry
{
uint32 ID ; // 0
int32 CastTime ; // 1
//float CastTimePerLevel; // 2 unsure / per skill?
//int32 MinCastTime; // 3 unsure
};
struct SpellFocusObjectEntry
{
uint32 ID ; // 0
//char* Name[16]; // 1-15 unused
// 16 string flags, unused
};
// stored in SQL table
struct SpellThreatEntry
{
uint32 spellId ;
int32 threat ;
};
struct SpellRadiusEntry
{
uint32 ID ;
float Radius ;
float Radius2 ;
};
struct SpellRangeEntry
{
uint32 ID ;
float minRange ;
float maxRange ;
};
struct SpellShapeshiftEntry
{
uint32 ID ; // 0
//uint32 buttonPosition; // 1 unused
//char* Name[16]; // 2-17 unused
//uint32 NameFlags; // 18 unused
uint32 flags1 ; // 19
int32 creatureType ; // 20 <=0 humanoid, other normal creature types
//uint32 unk1; // 21 unused
uint32 attackSpeed ; // 22
//uint32 modelID; // 23 unused, alliance modelid (where horde case?)
//uint32 unk2; // 24 unused
//uint32 unk3; // 25 unused
//uint32 unk4; // 26 unused
//uint32 unk5; // 27 unused
//uint32 unk6; // 28 unused
//uint32 unk7; // 29 unused
//uint32 unk8; // 30 unused
//uint32 unk9; // 31 unused
//uint32 unk10; // 32 unused
//uint32 unk11; // 33 unused
//uint32 unk12; // 34 unused
};
struct SpellDurationEntry
{
uint32 ID ;
int32 Duration [ 3 ];
};
enum ItemEnchantmentType
{
ITEM_ENCHANTMENT_TYPE_NONE = 0 ,
ITEM_ENCHANTMENT_TYPE_COMBAT_SPELL = 1 ,
ITEM_ENCHANTMENT_TYPE_DAMAGE = 2 ,
ITEM_ENCHANTMENT_TYPE_EQUIP_SPELL = 3 ,
ITEM_ENCHANTMENT_TYPE_RESISTANCE = 4 ,
ITEM_ENCHANTMENT_TYPE_STAT = 5 ,
ITEM_ENCHANTMENT_TYPE_TOTEM = 6
};
struct SpellItemEnchantmentEntry
{
uint32 ID ; // 0
uint32 type [ 3 ]; // 1-3
uint32 amount [ 3 ]; // 4-6
//uint32 amount2[3] // 7-9 always same as similar `amount` value
uint32 spellid [ 3 ]; // 10-12
char * description [ 16 ]; // 13-29
// 30 description flags
uint32 aura_id ; // 31
uint32 slot ; // 32
uint32 GemID ; // 33
uint32 EnchantmentCondition ; // 34
};
struct SpellItemEnchantmentConditionEntry
{
uint32 ID ;
uint8 Color [ 5 ];
uint8 Comparator [ 5 ];
uint8 CompareColor [ 5 ];
uint32 Value [ 5 ];
};
struct StableSlotPricesEntry
{
uint32 Slot ;
uint32 Price ;
};
struct TalentEntry
{
uint32 TalentID ; // 0
uint32 TalentTab ; // 1 index in TalentTab.dbc (TalentTabEntry)
uint32 Row ; // 2
uint32 Col ; // 3
uint32 RankID [ 5 ]; // 4-8
// 9-12 not used, always 0, maybe not used high ranks
uint32 DependsOn ; // 13 index in Talent.dbc (TalentEntry)
// 14-15 not used
uint32 DependsOnRank ; // 16
// 17-19 not used
uint32 DependsOnSpell ; // 20 req.spell
};
struct TalentTabEntry
{
uint32 TalentTabID ; // 0
//char* name[16]; // 1-16, unused
//uint32 nameFlags; // 17, unused
//unit32 spellicon; // 18
// 19 not used
uint32 ClassMask ; // 20
uint32 tabpage ; // 21
//char* internalname; // 22
};
struct TaxiPathEntry
{
uint32 ID ;
uint32 from ;
uint32 to ;
uint32 price ;
};
struct TaxiNodesEntry
{
uint32 ID ; // 0
uint32 map_id ; // 1
float x ; // 2
float y ; // 3
float z ; // 4
//char* name[16]; // 5-21
// 22 string flags, unused
uint32 horde_mount_type ; // 23
uint32 alliance_mount_type ; // 24
};
enum TotemCategoryType
{
TOTEM_CATEGORY_TYPE_KNIFE = 1 ,
TOTEM_CATEGORY_TYPE_TOTEM = 2 ,
TOTEM_CATEGORY_TYPE_ROD = 3 ,
TOTEM_CATEGORY_TYPE_PICK = 21 ,
TOTEM_CATEGORY_TYPE_STONE = 22 ,
TOTEM_CATEGORY_TYPE_HAMMER = 23 ,
TOTEM_CATEGORY_TYPE_SPANNER = 24
};
struct TotemCategoryEntry
{
uint32 ID ; // 0
//char* name[16]; // 1-16
// 17 string flags, unused
uint32 categoryType ; // 18 (one for specialization)
uint32 categoryMask ; // 19 (compatibility mask for same type: different for totems, compatible from high to low for rods)
};
struct WorldMapAreaEntry
{
//uint32 ID; // 0
uint32 map_id ; // 1
uint32 area_id ; // 2 index (continent 0 areas ignored)
//char* internal_name // 3
float y1 ; // 4
float y2 ; // 5
float x1 ; // 6
float x2 ; // 7
int32 virtual_map_id ; // 8 -1 (map_id have correct map) other: virtual map where zone show (map_id - where zone in fact internally)
};
struct WorldSafeLocsEntry
{
uint32 ID ; // 0
uint32 map_id ; // 1
float x ; // 2
float y ; // 3
float z ; // 4
//char* name[16] // 5-20 name, unused
// 21 name flags, unused
};
// GCC have alternative #pragma pack() syntax and old gcc version not support pack(pop), also any gcc version not support it at some platform
#if defined( __GNUC__ )
#pragma pack()
#else
#pragma pack(pop)
#endif
// Structures not used for casting to loaded DBC data and not required then packing
struct TalentSpellPos
{
TalentSpellPos () : talent_id ( 0 ), rank ( 0 ) {}
TalentSpellPos ( uint16 _talent_id , uint8 _rank ) : talent_id ( _talent_id ), rank ( _rank ) {}
uint16 talent_id ;
uint8 rank ;
};
typedef std :: map < uint32 , TalentSpellPos > TalentSpellPosMap ;
struct TaxiPathBySourceAndDestination
{
TaxiPathBySourceAndDestination () : ID ( 0 ), price ( 0 ) {}
TaxiPathBySourceAndDestination ( uint32 _id , uint32 _price ) : ID ( _id ), price ( _price ) {}
uint32 ID ;
uint32 price ;
};
typedef std :: map < uint32 , TaxiPathBySourceAndDestination > TaxiPathSetForSource ;
typedef std :: map < uint32 , TaxiPathSetForSource > TaxiPathSetBySource ;
struct TaxiPathNode
{
TaxiPathNode () : mapid ( 0 ), x ( 0 ), y ( 0 ), z ( 0 ), actionFlag ( 0 ), delay ( 0 ) {}
TaxiPathNode ( uint32 _mapid , float _x , float _y , float _z , uint32 _actionFlag , uint32 _delay ) : mapid ( _mapid ), x ( _x ), y ( _y ), z ( _z ), actionFlag ( _actionFlag ), delay ( _delay ) {}
uint32 mapid ;
float x ;
float y ;
float z ;
uint32 actionFlag ;
uint32 delay ;
};
typedef std :: vector < TaxiPathNode > TaxiPathNodeList ;
typedef std :: vector < TaxiPathNodeList > TaxiPathNodesByPath ;
#define TaxiMaskSize 16
typedef uint32 TaxiMask [ TaxiMaskSize ];
#endif
