ElderShell/EverWrath
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
EverWrath/src/server/shared/DataStores/DBCStructure.h
M'Dic ab2c062f03
feat(core\dbc): item.dbc, sItemStore, item_dbc, item enforcement conf, subclass fix (#14675) 
feat (core\log\db): item.dbc and enforcement

dbc enforcement partial pick from tc: 0c44bd33ee

Custom Item for testing by menevia16a (SPP DEV VEIL)

feat (core\log\db): item.dbc and enforcement

Update Item.sql

Update DBCStores.cpp

Update World.cpp

Update ObjectMgr.cpp

further replacement from template to dbc lookup

further logging and implementation

cherry pick tc fd26c3c87c

replace with db lookup

update (sql): Murder all the backticks

line break fixit

fix (item_template): fix incorrect subclass

fix incorrect subclass matching with dbc enforcement

update: log correction for sub class

update log correction for sub class

add subclass to dbc enforcement

add subclass dbc enforcement since it is part of the item.dbc item_dbc

update (log): additional log

Co-authored-by: blub <trinity.michael_vincent@gmx.eu>
Co-authored-by: Shocker <511388+shocker@users.noreply.github.com>
Co-authored-by: Veil <1913466+menevia16a@users.noreply.github.com>
Co-authored-by: Shocker <43253032+shockerqt@users.noreply.github.com>
2023-04-28 01:26:44 +02:00

2246 lines
96 KiB
C++
Raw Blame History

/*
* This file is part of the AzerothCore Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License as published by the
* Free Software Foundation; either version 3 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 Affero 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 ACORE_DBCSTRUCTURE_H
#define ACORE_DBCSTRUCTURE_H
#include "DBCEnums.h"
#include "Define.h"
#include "SharedDefines.h"
#include "Util.h"
#include <array>
#include <map>
#include <set>
#include <unordered_map>
// 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
struct AchievementEntry
{
uint32 ID; // 0
int32 requiredFaction; // 1 -1=all, 0=horde, 1=alliance
int32 mapID; // 2 -1=none
//uint32 parentAchievement; // 3 its Achievement parent (can`t start while parent uncomplete, use its Criteria if don`t have own, use its progress on begin)
std::array<char const*, 16> name; // 4-19
//uint32 name_flags; // 20
//char *description[16]; // 21-36
//uint32 desc_flags; // 37
uint32 categoryId; // 38
uint32 points; // 39 reward points
//uint32 OrderInCategory; // 40
uint32 flags; // 41
//uint32 icon; // 42 icon (from SpellIcon.dbc)
//char *titleReward[16]; // 43-58
//uint32 titleReward_flags; // 59
uint32 count; // 60 - need this count of completed criterias (own or referenced achievement criterias)
uint32 refAchievement; // 61 - referenced achievement (counting of all completed criterias)
};
struct AchievementCategoryEntry
{
int32 ID; // 0
int32 parentCategory; // 1 -1 for main category
//char *name[16]; // 2-17
//uint32 name_flags; // 18
//uint32 sortOrder; // 19
};
struct AchievementCriteriaEntry
{
uint32 ID; // 0
uint32 referredAchievement; // 1
uint32 requiredType; // 2
union
{
// ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE = 0
/// @todo: also used for player deaths..
struct
{
uint32 creatureID; // 3
uint32 creatureCount; // 4
} kill_creature;
// ACHIEVEMENT_CRITERIA_TYPE_WIN_BG = 1
struct
{
uint32 bgMapID; // 3
uint32 winCount; // 4
} win_bg;
// ACHIEVEMENT_CRITERIA_TYPE_REACH_LEVEL = 5
struct
{
uint32 unused; // 3
uint32 level; // 4
} reach_level;
// ACHIEVEMENT_CRITERIA_TYPE_REACH_SKILL_LEVEL = 7
struct
{
uint32 skillID; // 3
uint32 skillLevel; // 4
} reach_skill_level;
// ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_ACHIEVEMENT = 8
struct
{
uint32 linkedAchievement; // 3
} complete_achievement;
// ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST_COUNT = 9
struct
{
uint32 unused; // 3
uint32 totalQuestCount; // 4
} complete_quest_count;
// ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST_DAILY = 10
struct
{
uint32 unused; // 3
uint32 numberOfDays; // 4
} complete_daily_quest_daily;
// ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE = 11
struct
{
uint32 zoneID; // 3
uint32 questCount; // 4
} complete_quests_in_zone;
// ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST = 14
struct
{
uint32 unused; // 3
uint32 questCount; // 4
} complete_daily_quest;
// ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND = 15
struct
{
uint32 mapID; // 3
} complete_battleground;
// ACHIEVEMENT_CRITERIA_TYPE_DEATH_AT_MAP = 16
struct
{
uint32 mapID; // 3
} death_at_map;
// ACHIEVEMENT_CRITERIA_TYPE_DEATH_IN_DUNGEON = 18
struct
{
uint32 manLimit; // 3
} death_in_dungeon;
// ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_RAID = 19
struct
{
uint32 groupSize; // 3 can be 5, 10 or 25
} complete_raid;
// ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE = 20
struct
{
uint32 creatureEntry; // 3
} killed_by_creature;
// ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING = 24
struct
{
uint32 unused; // 3
uint32 fallHeight; // 4
} fall_without_dying;
// ACHIEVEMENT_CRITERIA_TYPE_DEATHS_FROM = 26
struct
{
uint32 type; // 3, see enum EnviromentalDamage
} death_from;
// ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST = 27
struct
{
uint32 questID; // 3
uint32 questCount; // 4
} complete_quest;
// ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET = 28
// ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2 = 69
struct
{
uint32 spellID; // 3
uint32 spellCount; // 4
} be_spell_target;
// ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL = 29
// ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2 = 110
struct
{
uint32 spellID; // 3
uint32 castCount; // 4
} cast_spell;
// ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE
struct
{
uint32 objectiveId; // 3
uint32 completeCount; // 4
} bg_objective;
// ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL_AT_AREA = 31
struct
{
uint32 areaID; // 3 Reference to AreaTable.dbc
uint32 killCount; // 4
} honorable_kill_at_area;
// ACHIEVEMENT_CRITERIA_TYPE_WIN_ARENA = 32
struct
{
uint32 mapID; // 3 Reference to Map.dbc
uint32 count; // 4 Number of times that the arena must be won.
} win_arena;
// ACHIEVEMENT_CRITERIA_TYPE_PLAY_ARENA = 33
struct
{
uint32 mapID; // 3 Reference to Map.dbc
} play_arena;
// ACHIEVEMENT_CRITERIA_TYPE_LEARN_SPELL = 34
struct
{
uint32 spellID; // 3 Reference to Map.dbc
} learn_spell;
// ACHIEVEMENT_CRITERIA_TYPE_OWN_ITEM = 36
struct
{
uint32 itemID; // 3
uint32 itemCount; // 4
} own_item;
// ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA = 37
struct
{
uint32 unused; // 3
uint32 count; // 4
} win_rated_arena;
// ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_TEAM_RATING = 38
struct
{
uint32 teamtype; // 3 {2, 3, 5}
} highest_team_rating;
// ACHIEVEMENT_CRITERIA_TYPE_REACH_TEAM_RATING = 39
struct
{
uint32 teamtype; // 3 {2, 3, 5}
uint32 PersonalRating; // 4
} highest_personal_rating;
// ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LEVEL = 40
struct
{
uint32 skillID; // 3
uint32 skillLevel; // 4 apprentice=1, journeyman=2, expert=3, artisan=4, master=5, grand master=6
} learn_skill_level;
// ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM = 41
struct
{
uint32 itemID; // 3
uint32 itemCount; // 4
} use_item;
// ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM = 42
struct
{
uint32 itemID; // 3
uint32 itemCount; // 4
} loot_item;
// ACHIEVEMENT_CRITERIA_TYPE_EXPLORE_AREA = 43
struct
{
/// @todo: This rank is _NOT_ the index from AreaTable.dbc
uint32 areaReference; // 3
} explore_area;
// ACHIEVEMENT_CRITERIA_TYPE_OWN_RANK = 44
struct
{
/// @todo: This rank is _NOT_ the index from CharTitles.dbc
uint32 rank; // 3
} own_rank;
// ACHIEVEMENT_CRITERIA_TYPE_BUY_BANK_SLOT = 45
struct
{
uint32 unused; // 3
uint32 numberOfSlots; // 4
} buy_bank_slot;
// ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION = 46
struct
{
uint32 factionID; // 3
uint32 reputationAmount; // 4 Total reputation amount, so 42000 = exalted
} gain_reputation;
// ACHIEVEMENT_CRITERIA_TYPE_GAIN_EXALTED_REPUTATION= 47
struct
{
uint32 unused; // 3
uint32 numberOfExaltedFactions; // 4
} gain_exalted_reputation;
// ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP = 48
struct
{
uint32 unused; // 3
uint32 numberOfVisits; // 4
} visit_barber;
// ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM = 49
/// @todo: where is the required itemlevel stored?
struct
{
uint32 itemSlot; // 3
uint32 count; // 4
} equip_epic_item;
// ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT = 50
struct
{
uint32 rollValue; // 3
uint32 count; // 4
} roll_need_on_loot;
// ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT = 51
struct
{
uint32 rollValue; // 3
uint32 count; // 4
} roll_greed_on_loot;
// ACHIEVEMENT_CRITERIA_TYPE_HK_CLASS = 52
struct
{
uint32 classID; // 3
uint32 count; // 4
} hk_class;
// ACHIEVEMENT_CRITERIA_TYPE_HK_RACE = 53
struct
{
uint32 raceID; // 3
uint32 count; // 4
} hk_race;
// ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE = 54
/// @todo: where is the information about the target stored?
struct
{
uint32 emoteID; // 3 enum TextEmotes
uint32 count; // 4 count of emotes, always required special target or requirements
} do_emote;
// ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE = 13
// ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE = 55
struct
{
uint32 unused; // 3
uint32 count; // 4
} healing_done;
// ACHIEVEMENT_CRITERIA_TYPE_GET_KILLING_BLOWS = 56
struct
{
uint32 unused;
uint32 killCount;
} get_killing_blow;
// ACHIEVEMENT_CRITERIA_TYPE_EQUIP_ITEM = 57
struct
{
uint32 itemID; // 3
uint32 count; // 4
} equip_item;
// ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_QUEST_REWARD= 62
struct
{
uint32 unused; // 3
uint32 goldInCopper; // 4
} quest_reward_money;
// ACHIEVEMENT_CRITERIA_TYPE_LOOT_MONEY = 67
struct
{
uint32 unused; // 3
uint32 goldInCopper; // 4
} loot_money;
// ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT = 68
struct
{
uint32 goEntry; // 3
uint32 useCount; // 4
} use_gameobject;
// ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL = 70
/// @todo: are those special criteria stored in the dbc or do we have to add another sql table?
struct
{
uint32 unused; // 3
uint32 killCount; // 4
} special_pvp_kill;
// ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT = 72
struct
{
uint32 goEntry; // 3
uint32 lootCount; // 4
} fish_in_gameobject;
// ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS = 75
struct
{
uint32 skillLine; // 3
uint32 spellCount; // 4
} learn_skillline_spell;
// ACHIEVEMENT_CRITERIA_TYPE_WIN_DUEL = 76
struct
{
uint32 unused; // 3
uint32 duelCount; // 4
} win_duel;
// ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_POWER = 96
struct
{
uint32 powerType; // 3 mana=0, 1=rage, 3=energy, 6=runic power
} highest_power;
// ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_STAT = 97
struct
{
uint32 statType; // 3 4=spirit, 3=int, 2=stamina, 1=agi, 0=strength
} highest_stat;
// ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_SPELLPOWER = 98
struct
{
uint32 spellSchool; // 3
} highest_spellpower;
// ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_RATING = 100
struct
{
uint32 ratingType; // 3
} highest_rating;
// ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE = 109
struct
{
uint32 lootType; // 3 3=fishing, 2=pickpocket, 4=disentchant
uint32 lootTypeCount; // 4
} loot_type;
// ACHIEVEMENT_CRITERIA_TYPE_LEARN_SKILL_LINE = 112
struct
{
uint32 skillLine; // 3
uint32 spellCount; // 4
} learn_skill_line;
// ACHIEVEMENT_CRITERIA_TYPE_EARN_HONORABLE_KILL = 113
struct
{
uint32 unused; // 3
uint32 killCount; // 4
} honorable_kill;
struct
{
uint32 unused;
uint32 dungeonsComplete;
} use_lfg;
struct
{
uint32 field3; // 3 main requirement
uint32 count; // 4 main requirement count
} raw;
};
struct
{
uint32 additionalRequirement_type;
uint32 additionalRequirement_value;
} additionalRequirements[MAX_CRITERIA_REQUIREMENTS];
//char const* name[16]; // 9-24
//uint32 name_flags; // 25
uint32 flags; // 26
uint32 timedType; // 27
uint32 timerStartEvent; // 28 Alway appears with timed events
// for timed spells it is spell id for
// timed kills it is creature id
uint32 timeLimit; // 29 time limit in seconds
//uint32 showOrder; // 30 show order
};
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 const* area_name[16]; // 11-26
// 27, string flags, unused
uint32 team; // 28
uint32 LiquidTypeOverride[4]; // 29-32 liquid override by type
// helpers
[[nodiscard]] bool IsSanctuary() const
{
if (mapid == 609)
return true;
return (flags & AREA_FLAG_SANCTUARY);
}
[[nodiscard]] bool IsFlyable() const
{
return flags & AREA_FLAG_OUTLAND;
}
};
#define MAX_GROUP_AREA_IDS 6
struct AreaGroupEntry
{
uint32 AreaGroupId; // 0
uint32 AreaId[MAX_GROUP_AREA_IDS]; // 1-6
uint32 nextGroup; // 7 index of next group
};
struct AreaPOIEntry
{
uint32 id; //0
uint32 icon[11]; //1-11
float x; //12
float y; //13
float z; //14
uint32 mapId; //15
//uint32 val1; //16
uint32 zoneId; //17
//char const* name[16]; //18-33
//uint32 name_flag; //34
//char const* name2[16]; //35-50
//uint32 name_flag2; //51
uint32 worldState; //52
//uint32 val2; //53
};
struct AuctionHouseEntry
{
uint32 houseId; // 0 index
uint32 faction; // 1 id of faction.dbc for player factions associated with city
uint32 depositPercent; // 2 1/3 from real
uint32 cutPercent; // 3
//char const* name[16]; // 4-19
// 20 string flag, unused
};
struct BankBagSlotPricesEntry
{
uint32 ID;
uint32 price;
};
struct BarberShopStyleEntry
{
uint32 Id; // 0
uint32 type; // 1 value 0 -> hair, value 2 -> facialhair
//char const* name[16]; // 2-17 name of hair style
//uint32 name_flags; // 18
//uint32 unk_name[16]; // 19-34, all empty
//uint32 unk_flags; // 35
//float CostMultiplier; // 36 values 1 and 0.75
uint32 race; // 37 race
uint32 gender; // 38 0 -> male, 1 -> female
uint32 hair_id; // 39 real ID to hair/facial hair
};
struct BattlemasterListEntry
{
uint32 id; // 0
int32 mapid[8]; // 1-8 mapid
uint32 type; // 9 (3 - BG, 4 - arena)
//uint32 canJoinAsGroup; // 10 (0 or 1)
char const* name[16]; // 11-26
//uint32 nameFlags // 27 string flag, unused
uint32 maxGroupSize; // 28 maxGroupSize, used for checking if queue as group
uint32 HolidayWorldStateId; // 29 new 3.1
//uint32 MinLevel; // 30
//uint32 SomeLevel; // 31, may be max level
};
#define MAX_OUTFIT_ITEMS 24
struct CharStartOutfitEntry
{
//uint32 Id; // 0
uint8 Race; // 1
uint8 Class; // 2
uint8 Gender; // 3
//uint8 Unused; // 4
int32 ItemId[MAX_OUTFIT_ITEMS]; // 5-28
//int32 ItemDisplayId[MAX_OUTFIT_ITEMS]; // 29-52 not required at server side
//int32 ItemInventorySlot[MAX_OUTFIT_ITEMS]; // 53-76 not required at server side
};
struct CharTitlesEntry
{
uint32 ID; // 0, title ids, for example in Quest::GetCharTitleId()
//uint32 unk1; // 1 flags?
char const* nameMale[16]; // 2-17
// 18 string flag, unused
char const* nameFemale[16]; // 19-34
// 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 const* pattern[16]; // 3-18
// 19 string flags, unused
//char const* name[16]; // 20-35 unused
// 36 string flag, unused
};
struct ChrClassesEntry
{
uint32 ClassID; // 0
// 1, unused
uint32 powerType; // 2
// 3-4, unused
char const* name[16]; // 5-20 unused
// 21 string flag, unused
//char const* nameFemale[16]; // 21-36 unused, if different from base (male) case
// 37 string flag, unused
//char const* nameNeutralGender[16]; // 38-53 unused, if different from base (male) case
// 54 string flag, unused
// 55, unused
uint32 spellfamily; // 56
// 57, unused
uint32 CinematicSequence; // 58 id from CinematicSequences.dbc
uint32 expansion; // 59 (0 - original race, 1 - tbc addon, ...)
};
enum ChrRacesFlags
{
CHRRACES_FLAGS_NOT_PLAYABLE = 0x01,
CHRRACES_FLAGS_BARE_FEET = 0x02,
CHRRACES_FLAGS_CAN_MOUNT = 0x04
};
struct ChrRacesEntry
{
uint32 RaceID; // 0
uint32 Flags; // 1
uint32 FactionID; // 2 facton template id
// 3 unused
uint32 model_m; // 4
uint32 model_f; // 5
// 6 unused
uint32 TeamID; // 7 (7-Alliance 1-Horde)
// 8-11 unused
uint32 CinematicSequence; // 12 id from CinematicSequences.dbc
//uint32 unk_322; // 13 faction (0 alliance, 1 horde, 2 not available?)
char const* name[16]; // 14-29 used for DBC language detection/selection
// 30 string flags, unused
//char const* nameFemale[16]; // 31-46, if different from base (male) case
// 47 string flags, unused
//char const* nameNeutralGender[16]; // 48-63, if different from base (male) case
// 64 string flags, unused
// 65-67 unused
uint32 expansion; // 68 (0 - original race, 1 - tbc addon, ...)
inline bool HasFlag(ChrRacesFlags flag) const { return (Flags & flag) != 0; }
};
struct CinematicCameraEntry
{
uint32 ID; // 0
char const* Model; // 1 Model filename (translate .mdx to .m2)
uint32 SoundID; // 2 Sound ID (voiceover for cinematic)
DBCPosition3D Origin; // 3-5 Position in map used for basis for M2 co-ordinates
float OriginFacing; // 6 Orientation in map used for basis for M2 co-ordinates
};
struct CinematicSequencesEntry
{
uint32 Id; // 0 index
//uint32 unk1; // 1 always 0
uint32 cinematicCamera; // 2 id in CinematicCamera.dbc
// 3-9 always 0
};
struct CreatureDisplayInfoEntry
{
uint32 Displayid; // 0 m_ID
uint32 ModelId; // 1 m_modelID
// 2 m_soundID
uint32 ExtendedDisplayInfoID; // 3
float scale; // 4 m_creatureModelScale
// 5 m_creatureModelAlpha
// 6-8 m_textureVariation[3]
// 9 m_portraitTextureName
// 10 m_sizeClass
// 11 m_bloodID
// 12 m_NPCSoundID
// 13 m_particleColorID
// 14 m_creatureGeosetData
// 15 m_objectEffectPackageID
};
struct CreatureDisplayInfoExtraEntry
{
//uint32 ID; // 0
uint32 DisplayRaceID; // 1
uint32 DisplaySexID; // 2
//uint32 SkinID; // 3
//uint32 FaceID; // 4
//uint32 HairStyleID; // 5
//uint32 HairColorID; // 6
//uint32 FacialHairID; // 7
//uint32 NPCItemDisplay[11]; // 8-18
//uint32 Flags; // 19
//char const* BakeName; // 20
};
struct CreatureFamilyEntry
{
uint32 ID; // 0 m_ID
float minScale; // 1 m_minScale
uint32 minScaleLevel; // 2 m_minScaleLevel
float maxScale; // 3 m_maxScale
uint32 maxScaleLevel; // 4 m_maxScaleLevel
uint32 skillLine[2]; // 5-6 m_skillLine
uint32 petFoodMask; // 7 m_petFoodMask
int32 petTalentType; // 8 m_petTalentType
// 9 m_categoryEnumID
char const* Name[16]; // 10-25 m_name_lang
// 26 string flags
// 27 m_iconFile
};
enum CreatureModelDataFlags
{
CREATURE_MODEL_DATA_FLAGS_CAN_MOUNT = 0x00000080
};
struct CreatureModelDataEntry
{
uint32 Id;
uint32 Flags;
//char const* ModelPath
//uint32 Unk1;
float Scale; // Used in calculation of unit collision data
//int32 Unk2
//int32 Unk3
//uint32 Unk4
//uint32 Unk5
//float Unk6
//uint32 Unk7
//float Unk8
//uint32 Unk9
//uint32 Unk10
float CollisionWidth;
float CollisionHeight;
float MountHeight; // Used in calculation of unit collision data when mounted
//float Unks[11]
inline bool HasFlag(CreatureModelDataFlags flag) const { return (Flags & flag) != 0; }
};
#define MAX_CREATURE_SPELL_DATA_SLOT 4
struct CreatureSpellDataEntry
{
uint32 ID; // 0 m_ID
uint32 spellId[MAX_CREATURE_SPELL_DATA_SLOT]; // 1-4 m_spells[4]
//uint32 availability[MAX_CREATURE_SPELL_DATA_SLOT]; // 4-7 m_availability[4]
};
struct CreatureTypeEntry
{
uint32 ID; // 0 m_ID
//char const* Name[16]; // 1-16 name
// 17 string flags
//uint32 no_expirience; // 18 no exp? critters, non-combat pets, gas cloud.
};
/* not used
struct CurrencyCategoryEntry
{
uint32 ID; // 0
uint32 Unk1; // 1 0 for known categories and 3 for unknown one (3.0.9)
char const* Name[16]; // 2-17 name
// // 18 string flags
};
*/
struct CurrencyTypesEntry
{
//uint32 ID; // 0 not used
uint32 ItemId; // 1 used as real index
//uint32 Category; // 2 may be category
uint32 BitIndex; // 3 bit index in PLAYER_FIELD_KNOWN_CURRENCIES (1 << (index-1))
};
struct DestructibleModelDataEntry
{
uint32 Id;
//uint32 DamagedUnk1;
//uint32 DamagedUnk2;
uint32 DamagedDisplayId;
//uint32 DamagedUnk3;
//uint32 DestroyedUnk1;
//uint32 DestroyedUnk2;
uint32 DestroyedDisplayId;
//uint32 DestroyedUnk3;
//uint32 RebuildingUnk1;
//uint32 RebuildingUnk2;
uint32 RebuildingDisplayId;
//uint32 RebuildingUnk3;
//uint32 SmokeUnk1;
//uint32 SmokeUnk2;
uint32 SmokeDisplayId;
//uint32 SmokeUnk3;
//uint32 Unk4;
//uint32 Unk5;
};
struct DungeonEncounterEntry
{
uint32 id; // 0 unique id
uint32 mapId; // 1 map id
uint32 difficulty; // 2 instance mode
//uint32 unk0; // 3
uint32 encounterIndex; // 4 encounter index for creating completed mask
char const* encounterName[16]; // 5-20 encounter name
//uint32 nameFlags; // 21
//uint32 unk1; // 22
};
struct DurabilityCostsEntry
{
uint32 Itemlvl; // 0
uint32 multiplier[29]; // 1-29
};
struct DurabilityQualityEntry
{
uint32 Id; // 0
float quality_mod; // 1
};
struct EmotesEntry
{
uint32 Id; // 0
//char const* Name; // 1, internal name
//uint32 AnimationId; // 2, ref to animationData
uint32 Flags; // 3, bitmask, may be unit_flags
uint32 EmoteType; // 4, Can be 0, 1 or 2 (determine how emote are shown)
uint32 UnitStandState; // 5, uncomfirmed, may be enum UnitStandStateType
//uint32 SoundId; // 6, ref to soundEntries
};
struct EmotesTextEntry
{
uint32 Id;
uint32 textid;
};
struct FactionEntry
{
uint32 ID; // 0 m_ID
int32 reputationListID; // 1 m_reputationIndex
uint32 BaseRepRaceMask[4]; // 2-5 m_reputationRaceMask
uint32 BaseRepClassMask[4]; // 6-9 m_reputationClassMask
int32 BaseRepValue[4]; // 10-13 m_reputationBase
uint32 ReputationFlags[4]; // 14-17 m_reputationFlags
uint32 team; // 18 m_parentFactionID
float spilloverRateIn; // 19 Faction gains incoming rep * spilloverRateIn
float spilloverRateOut; // 20 Faction outputs rep * spilloverRateOut as spillover reputation
uint32 spilloverMaxRankIn; // 21 The highest rank the faction will profit from incoming spillover
//uint32 spilloverRank_unk; // 22 It does not seem to be the max standing at which a faction outputs spillover ...so no idea
char const* name[16]; // 23-38 m_name_lang
// 39 string flags
//char const* description[16]; // 40-55 m_description_lang
// 56 string flags
// helpers
[[nodiscard]] bool CanHaveReputation() const
{
return reputationListID >= 0;
}
[[nodiscard]] bool CanBeSetAtWar() const
{
return reputationListID >= 0 && BaseRepRaceMask[0] == 1791;
}
};
#define MAX_FACTION_RELATIONS 4
struct FactionTemplateEntry
{
uint32 ID; // 0 m_ID
uint32 faction; // 1 m_faction
uint32 factionFlags; // 2 m_flags
uint32 ourMask; // 3 m_factionGroup
uint32 friendlyMask; // 4 m_friendGroup
uint32 hostileMask; // 5 m_enemyGroup
uint32 enemyFaction[MAX_FACTION_RELATIONS]; // 6 m_enemies[MAX_FACTION_RELATIONS]
uint32 friendFaction[MAX_FACTION_RELATIONS]; // 10 m_friend[MAX_FACTION_RELATIONS]
//------------------------------------------------------- end structure
// helpers
[[nodiscard]] bool IsFriendlyTo(FactionTemplateEntry const& entry) const
{
// Xinef: Always friendly to self faction
if (faction == entry.faction)
return true;
if (entry.faction)
{
for (unsigned int i : enemyFaction)
if (i == entry.faction)
return false;
for (unsigned int i : friendFaction)
if (i == entry.faction)
return true;
}
return (friendlyMask & entry.ourMask) || (ourMask & entry.friendlyMask);
}
[[nodiscard]] bool IsHostileTo(FactionTemplateEntry const& entry) const
{
if (entry.faction)
{
for (unsigned int i : enemyFaction)
if (i == entry.faction)
return true;
for (unsigned int i : friendFaction)
if (i == entry.faction)
return false;
}
return (hostileMask & entry.ourMask) != 0;
}
[[nodiscard]] bool IsHostileToPlayers() const { return (hostileMask & FACTION_MASK_PLAYER) != 0; }
[[nodiscard]] bool IsNeutralToAll() const
{
for (unsigned int i : enemyFaction)
if (i != 0)
return false;
return hostileMask == 0 && friendlyMask == 0;
}
[[nodiscard]] bool IsContestedGuardFaction() const { return (factionFlags & FACTION_TEMPLATE_FLAG_ATTACK_PVP_ACTIVE_PLAYERS) != 0; }
};
struct GameObjectArtKitEntry
{
uint32 ID; // 0
//char* TextureVariation[3] // 1-3 m_textureVariations[3]
//char* AttachModel[4] // 4-8 m_attachModels[4]
};
struct GameObjectDisplayInfoEntry
{
uint32 Displayid; // 0 m_ID
char const* filename; // 1
//uint32 unk1[10]; //2-11
float minX;
float minY;
float minZ;
float maxX;
float maxY;
float maxZ;
//uint32 transport; //18
};
struct GemPropertiesEntry
{
uint32 ID;
uint32 spellitemenchantement;
uint32 color;
};
struct GlyphPropertiesEntry
{
uint32 Id;
uint32 SpellId;
uint32 TypeFlags;
uint32 Unk1; // GlyphIconId (SpellIcon.dbc)
};
struct GlyphSlotEntry
{
uint32 Id;
uint32 TypeFlags;
uint32 Order;
};
// All Gt* DBC store data for 100 levels, some by 100 per class/race
#define GT_MAX_LEVEL 100
// gtOCTClassCombatRatingScalar.dbc stores data for 32 ratings, look at MAX_COMBAT_RATING for real used amount
#define GT_MAX_RATING 32
struct GtBarberShopCostBaseEntry
{
float cost;
};
struct GtCombatRatingsEntry
{
float ratio;
};
struct GtChanceToMeleeCritBaseEntry
{
float base;
};
struct GtChanceToMeleeCritEntry
{
float ratio;
};
struct GtChanceToSpellCritBaseEntry
{
float base;
};
struct GtNPCManaCostScalerEntry
{
float ratio;
};
struct GtChanceToSpellCritEntry
{
float ratio;
};
struct GtOCTClassCombatRatingScalarEntry
{
float ratio;
};
struct GtOCTRegenHPEntry
{
float ratio;
};
//struct GtOCTRegenMPEntry
//{
// float ratio;
//};
struct GtRegenHPPerSptEntry
{
float ratio;
};
struct GtRegenMPPerSptEntry
{
float ratio;
};
/* no used
struct HolidayDescriptionsEntry
{
uint32 ID; // 0, this is NOT holiday id
//char const* name[16] // 1-16 m_name_lang
// 17 name flags
};
*/
/* no used
struct HolidayNamesEntry
{
uint32 ID; // 0, this is NOT holiday id
//char const* name[16] // 1-16 m_name_lang
// 17 name flags
};
*/
#define MAX_HOLIDAY_DURATIONS 10
#define MAX_HOLIDAY_DATES 26
#define MAX_HOLIDAY_FLAGS 10
struct HolidaysEntry
{
uint32 Id; // 0 m_ID
uint32 Duration[MAX_HOLIDAY_DURATIONS]; // 1-10 m_duration
uint32 Date[MAX_HOLIDAY_DATES]; // 11-36 m_date (dates in unix time starting at January, 1, 2000)
uint32 Region; // 37 m_region (wow region)
uint32 Looping; // 38 m_looping
uint32 CalendarFlags[MAX_HOLIDAY_FLAGS]; // 39-48 m_calendarFlags
//uint32 holidayNameId; // 49 m_holidayNameID (HolidayNames.dbc)
//uint32 holidayDescriptionId; // 50 m_holidayDescriptionID (HolidayDescriptions.dbc)
char const* TextureFilename; // 51 m_textureFilename
uint32 Priority; // 52 m_priority
int32 CalendarFilterType; // 53 m_calendarFilterType (-1 = Fishing Contest, 0 = Unk, 1 = Darkmoon Festival, 2 = Yearly holiday)
//uint32 flags; // 54 m_flags (0 = Darkmoon Faire, Fishing Contest and Wotlk Launch, rest is 1)
};
struct ItemEntry
{
uint32 ID; // 0
uint32 ClassID; // 1
uint32 SubclassID; // 2
int32 SoundOverrideSubclassID; // 3
int32 Material; // 4
uint32 DisplayInfoID; // 5
uint32 InventoryType; // 6
uint32 SheatheType; // 7
};
struct ItemBagFamilyEntry
{
uint32 ID; // 0
//char const* name[16] // 1-16 m_name_lang
// // 17 name flags
};
struct ItemDisplayInfoEntry
{
uint32 ID; // 0 m_ID
// 1 m_modelName[2]
// 2 m_modelTexture[2]
char const* inventoryIcon; // 3 m_inventoryIcon
// 4 m_geosetGroup[3]
// 5 m_flags
// 6 m_spellVisualID
// 7 m_groupSoundIndex
// 8 m_helmetGeosetVis[2]
// 9 m_texture[2]
// 10 m_itemVisual[8]
// 11 m_particleColorID
};
//struct ItemCondExtCostsEntry
//{
// uint32 ID;
// uint32 condExtendedCost; // ItemTemplate::CondExtendedCost
// uint32 itemextendedcostentry; // ItemTemplate::ExtendedCost
// uint32 arenaseason; // arena season number(1-4)
//};
#define MAX_ITEM_EXTENDED_COST_REQUIREMENTS 5
struct ItemExtendedCostEntry
{
uint32 ID; // 0 extended-cost entry id
uint32 reqhonorpoints; // 1 required honor points
uint32 reqarenapoints; // 2 required arena points
uint32 reqarenaslot; // 3 arena slot restrctions (min slot value)
uint32 reqitem[MAX_ITEM_EXTENDED_COST_REQUIREMENTS]; // 4-8 required item id
uint32 reqitemcount[MAX_ITEM_EXTENDED_COST_REQUIREMENTS]; // 9-14 required count of 1st item
uint32 reqpersonalarenarating; // 15 required personal arena rating};
};
struct ItemLimitCategoryEntry
{
uint32 ID; // 0 Id
//char const* name[16] // 1-16 m_name_lang
// 17 name flags
uint32 maxCount; // 18, max allowed equipped as item or in gem slot
uint32 mode; // 19, 0 = have, 1 = equip (enum ItemLimitCategoryMode)
};
#define MAX_ITEM_ENCHANTMENT_EFFECTS 5
struct ItemRandomPropertiesEntry
{
uint32 ID; // 0
//char const* InternalName; // 1
std::array<uint32, MAX_ITEM_ENCHANTMENT_EFFECTS> Enchantment; // 2-4
//std::array<uint32, 2> UnusedEnchantment; // 5-6
std::array<char const*, 16> Name; // 7-22
//uint32 Name_lang_mask; // 23
};
struct ItemRandomSuffixEntry
{
uint32 ID; // 0
std::array<char const*, 16> Name; // 1-16
//uint32 Name_lang_mask; // 17
//char const* InternalName; // 18
std::array<uint32, MAX_ITEM_ENCHANTMENT_EFFECTS> Enchantment; // 19-21
//std::array<uint32, 2> UnusedEnchantment; // 22-23
std::array<uint32, MAX_ITEM_ENCHANTMENT_EFFECTS> AllocationPct; // 24-26
//std::array<uint32, 2> UnusedAllocationPct; // 27-28
};
#define MAX_ITEM_SET_ITEMS 10
#define MAX_ITEM_SET_SPELLS 8
struct ItemSetEntry
{
//uint32 id // 0 m_ID
char const* name[16]; // 1-16 m_name_lang
// 17 string flags, unused
uint32 itemId[MAX_ITEM_SET_ITEMS]; // 18-27 m_itemID
//uint32 unknown[7]; // 28-34 unk, all 0
uint32 spells[MAX_ITEM_SET_SPELLS]; // 35-42 m_setSpellID
uint32 items_to_triggerspell[MAX_ITEM_SET_SPELLS]; // 43-50 m_setThreshold
uint32 required_skill_id; // 51 m_requiredSkill
uint32 required_skill_value; // 52 m_requiredSkillRank
};
struct LFGDungeonEntry
{
uint32 ID; // 0
char const* name[16]; // 1-17 Name lang
uint32 minlevel; // 18
uint32 maxlevel; // 19
uint32 reclevel; // 20
uint32 recminlevel; // 21
uint32 recmaxlevel; // 22
int32 map; // 23
uint32 difficulty; // 24
uint32 flags; // 25
uint32 type; // 26
//uint32 unk; // 27
//char const* iconname; // 28
uint32 expansion; // 29
//uint32 unk4; // 30
uint32 grouptype; // 31
//char const* desc[16]; // 32-47 Description
// Helpers
[[nodiscard]] uint32 Entry() const { return ID + (type << 24); }
};
struct LightEntry
{
uint32 Id;
uint32 MapId;
float X;
float Y;
float Z;
//float FalloffStart;
//float FalloffEnd;
//uint32 SkyAndFog;
//uint32 WaterSettings;
//uint32 SunsetParams;
//uint32 OtherParams;
//uint32 DeathParams;
//uint32 Unknown;
//uint32 Unknown;
//uint32 Unknown;
};
struct LiquidTypeEntry
{
uint32 Id;
//char const* Name;
//uint32 Flags;
uint32 Type;
//uint32 SoundId;
uint32 SpellId;
//float MaxDarkenDepth;
//float FogDarkenIntensity;
//float AmbDarkenIntensity;
//float DirDarkenIntensity;
//uint32 LightID;
//float ParticleScale;
//uint32 ParticleMovement;
//uint32 ParticleTexSlots;
//uint32 LiquidMaterialID;
//char const* Texture[6];
//uint32 Color[2];
//float Unk1[18];
//uint32 Unk2[4];
};
#define MAX_LOCK_CASE 8
struct LockEntry
{
uint32 ID; // 0 m_ID
uint32 Type[MAX_LOCK_CASE]; // 1-8 m_Type
uint32 Index[MAX_LOCK_CASE]; // 9-16 m_Index
uint32 Skill[MAX_LOCK_CASE]; // 17-24 m_Skill
//uint32 Action[MAX_LOCK_CASE]; // 25-32 m_Action
};
struct MailTemplateEntry
{
uint32 ID; // 0
//char const* subject[16]; // 1-16
// 17 name flags, unused
char const* content[16]; // 18-33
};
struct MapEntry
{
uint32 MapID; // 0
//char const* internalname; // 1 unused
uint32 map_type; // 2
uint32 Flags; // 3
// 4 0 or 1 for battlegrounds (not arenas)
char const* name[16]; // 5-20
// 21 name flags, unused
uint32 linked_zone; // 22 common zone for instance and continent map
//char const* hordeIntro[16]; // 23-38 text for PvP Zones
// 39 intro text flags
//char const* allianceIntro[16]; // 40-55 text for PvP Zones
// 56 intro text flags
uint32 multimap_id; // 57
//float BattlefieldMapIconScale; // 58
int32 entrance_map; // 59 map_id of entrance map
float entrance_x; // 60 entrance x coordinate (if exist single entry)
float entrance_y; // 61 entrance y coordinate (if exist single entry)
//uint32 TimeOfDayOverride; // 62 -1, 0 and 720
uint32 addon; // 63 (0-original maps, 1-tbc addon)
uint32 unk_time; // 64 some kind of time?
uint32 maxPlayers; // 65 max players, fallback if not present in MapDifficulty.dbc
// Helpers
[[nodiscard]] uint32 Expansion() const { return addon; }
[[nodiscard]] bool IsDungeon() const { return map_type == MAP_INSTANCE || map_type == MAP_RAID; }
[[nodiscard]] bool IsNonRaidDungeon() const { return map_type == MAP_INSTANCE; }
[[nodiscard]] bool Instanceable() const { return map_type == MAP_INSTANCE || map_type == MAP_RAID || map_type == MAP_BATTLEGROUND || map_type == MAP_ARENA; }
[[nodiscard]] bool IsRaid() const { return map_type == MAP_RAID; }
[[nodiscard]] bool IsBattleground() const { return map_type == MAP_BATTLEGROUND; }
[[nodiscard]] bool IsBattleArena() const { return map_type == MAP_ARENA; }
[[nodiscard]] bool IsBattlegroundOrArena() const { return map_type == MAP_BATTLEGROUND || map_type == MAP_ARENA; }
[[nodiscard]] bool IsWorldMap() const { return map_type == MAP_COMMON; }
bool GetEntrancePos(int32& mapid, float& x, float& y) const
{
if (entrance_map < 0)
return false;
mapid = entrance_map;
x = entrance_x;
y = entrance_y;
return true;
}
[[nodiscard]] bool IsContinent() const
{
return MapID == 0 || MapID == 1 || MapID == 530 || MapID == 571;
}
[[nodiscard]] bool IsDynamicDifficultyMap() const { return Flags & MAP_FLAG_DYNAMIC_DIFFICULTY; }
};
struct MapDifficultyEntry
{
//uint32 Id; // 0
uint32 MapId; // 1
uint32 Difficulty; // 2 (for arenas: arena slot)
char const* areaTriggerText; // 3-18 text showed when transfer to map failed (missing requirements)
//uint32 textFlags; // 19
uint32 resetTime; // 20
uint32 maxPlayers; // 21
//char const* difficultyString; // 22
};
struct MovieEntry
{
uint32 Id; // 0 index
//char const* filename; // 1
//uint32 unk2; // 2 always 100
};
struct NamesReservedEntry
{
//uint32 ID; // 0
char const* Pattern; // 1
//uint32 Language; // 2
};
struct NamesProfanityEntry
{
//uint32 ID; // 0
char const* Pattern; // 1
//uint32 Language; // 2
};
#define MAX_OVERRIDE_SPELL 10
struct OverrideSpellDataEntry
{
uint32 id; // 0
uint32 spellId[MAX_OVERRIDE_SPELL]; // 1-10
//uint32 unk0; // 11
};
struct PowerDisplayEntry
{
uint32 Id; // 0
uint32 PowerType; // 1
//char const* Name; // 2
//uint32 R; // 3
//uint32 G; // 4
//uint32 B; // 5
};
struct PvPDifficultyEntry
{
//uint32 id; // 0 m_ID
uint32 mapId; // 1
uint32 bracketId; // 2
uint32 minLevel; // 3
uint32 maxLevel; // 4
uint32 difficulty; // 5
// helpers
PvPDifficultyEntry(uint32 mapId, uint32 bracketId, uint32 minLevel, uint32 maxLevel, uint32 difficulty) : mapId(mapId), bracketId(bracketId), minLevel(minLevel), maxLevel(maxLevel), difficulty(difficulty) {}
[[nodiscard]] BattlegroundBracketId GetBracketId() const { return BattlegroundBracketId(bracketId); }
};
struct QuestSortEntry
{
uint32 id; // 0 m_ID
//char const* name[16]; // 1-16 m_SortName_lang
// 17 name flags
};
struct QuestXPEntry
{
uint32 id;
uint32 Exp[10];
};
struct QuestFactionRewEntry
{
uint32 id;
int32 QuestRewFactionValue[10];
};
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 ScalingStatDistributionEntry
{
uint32 Id; // 0
int32 StatMod[10]; // 1-10
uint32 Modifier[10]; // 11-20
uint32 MaxLevel; // 21
};
struct ScalingStatValuesEntry
{
uint32 Id; // 0
uint32 Level; // 1
uint32 ssdMultiplier[4]; // 2-5 Multiplier for ScalingStatDistribution
uint32 armorMod[4]; // 6-9 Armor for level
uint32 dpsMod[6]; // 10-15 DPS mod for level
uint32 spellPower; // 16 spell power for level
uint32 ssdMultiplier2; // 17 there's data from 3.1 dbc ssdMultiplier[3]
uint32 ssdMultiplier3; // 18 3.3
uint32 armorMod2[5]; // 19-23 Armor for level
[[nodiscard]] uint32 getssdMultiplier(uint32 mask) const
{
if (mask & 0x4001F)
{
if (mask & 0x00000001) return ssdMultiplier[0]; // Shoulder
if (mask & 0x00000002) return ssdMultiplier[1]; // Trinket
if (mask & 0x00000004) return ssdMultiplier[2]; // Weapon1H
if (mask & 0x00000008) return ssdMultiplier2;
if (mask & 0x00000010) return ssdMultiplier[3]; // Ranged
if (mask & 0x00040000) return ssdMultiplier3;
}
return 0;
}
[[nodiscard]] uint32 getArmorMod(uint32 mask) const
{
if (mask & 0x00F801E0)
{
if (mask & 0x00000020) return armorMod[0]; // Cloth shoulder
if (mask & 0x00000040) return armorMod[1]; // Leather shoulder
if (mask & 0x00000080) return armorMod[2]; // Mail shoulder
if (mask & 0x00000100) return armorMod[3]; // Plate shoulder
if (mask & 0x00080000) return armorMod2[0]; // cloak
if (mask & 0x00100000) return armorMod2[1]; // cloth
if (mask & 0x00200000) return armorMod2[2]; // leather
if (mask & 0x00400000) return armorMod2[3]; // mail
if (mask & 0x00800000) return armorMod2[4]; // plate
}
return 0;
}
[[nodiscard]] uint32 getDPSMod(uint32 mask) const
{
if (mask & 0x7E00)
{
if (mask & 0x00000200) return dpsMod[0]; // Weapon 1h
if (mask & 0x00000400) return dpsMod[1]; // Weapon 2h
if (mask & 0x00000800) return dpsMod[2]; // Caster dps 1h
if (mask & 0x00001000) return dpsMod[3]; // Caster dps 2h
if (mask & 0x00002000) return dpsMod[4]; // Ranged
if (mask & 0x00004000) return dpsMod[5]; // Wand
}
return 0;
}
bool IsTwoHand(uint32 mask) const
{
if (mask & 0x7E00)
{
if (mask & 0x00000400) return true;
if (mask & 0x00001000) return true;
}
return false;
}
[[nodiscard]] uint32 getSpellBonus(uint32 mask) const
{
if (mask & 0x00008000) return spellPower;
return 0;
}
[[nodiscard]] uint32 getFeralBonus(uint32 mask) const // removed in 3.2.x?
{
if (mask & 0x00010000) return 0; // not used?
return 0;
}
};
//struct SkillLineCategoryEntry{
// uint32 id; // 0 m_ID
// char const* name[16]; // 1-17 m_name_lang
// // 18 string flag
// uint32 displayOrder; // 19 m_sortIndex
//};
struct SkillRaceClassInfoEntry
{
//uint32 ID; // 0
uint32 SkillID; // 1
uint32 RaceMask; // 2
uint32 ClassMask; // 3
uint32 Flags; // 4
//uint32 MinLevel; // 5
uint32 SkillTierID; // 6
//uint32 SkillCostIndex; // 7
};
#define MAX_SKILL_STEP 16
struct SkillLineEntry
{
uint32 id; // 0 m_ID
int32 categoryId; // 1 m_categoryID
//uint32 skillCostID; // 2 m_skillCostsID
char const* name[16]; // 3-18 m_displayName_lang
// 19 string flags
//char const* description[16]; // 20-35 m_description_lang
// 36 string flags
uint32 spellIcon; // 37 m_spellIconID
//char const* alternateVerb[16]; // 38-53 m_alternateVerb_lang
// 54 string flags
uint32 canLink; // 55 m_canLink (prof. with recipes
};
struct SkillLineAbilityEntry
{
uint32 ID; // 0
uint32 SkillLine; // 1
uint32 Spell; // 2
uint32 RaceMask; // 3
uint32 ClassMask; // 4
//uint32 ExcludeRace; // 5
//uint32 ExcludeClass; // 6
uint32 MinSkillLineRank; // 7
uint32 SupercededBySpell; // 8
uint32 AcquireMethod; // 9
uint32 TrivialSkillLineRankHigh; // 10
uint32 TrivialSkillLineRankLow; // 11
//uint32 CharacterPoints[2]; // 12-13
};
struct SkillTiersEntry
{
uint32 ID; // 0
//uint32 Cost[MAX_SKILL_STEP]; // 1-16
uint32 Value[MAX_SKILL_STEP]; // 17-32
};
struct SoundEntriesEntry
{
uint32 Id; // 0 m_ID
//uint32 Type; // 1 m_soundType
//char const* InternalName; // 2 m_name
//char const* FileName[10]; // 3-12 m_File[10]
//uint32 Unk13[10]; // 13-22 m_Freq[10]
//char const* Path; // 23 m_DirectoryBase
// 24 m_volumeFloat
// 25 m_flags
// 26 m_minDistance
// 27 m_distanceCutoff
// 28 m_EAXDef
// 29 new in 3.1
};
#define MAX_SPELL_EFFECTS 3
#define MAX_EFFECT_MASK 7
#define MAX_SPELL_REAGENTS 8
struct SpellEntry
{
uint32 Id; // 0 m_ID
uint32 Category; // 1 m_category
uint32 Dispel; // 2 m_dispelType
uint32 Mechanic; // 3 m_mechanic
uint32 Attributes; // 4 m_attributes
uint32 AttributesEx; // 5 m_attributesEx
uint32 AttributesEx2; // 6 m_attributesExB
uint32 AttributesEx3; // 7 m_attributesExC
uint32 AttributesEx4; // 8 m_attributesExD
uint32 AttributesEx5; // 9 m_attributesExE
uint32 AttributesEx6; // 10 m_attributesExF
uint32 AttributesEx7; // 11 m_attributesExG
uint32 Stances; // 12 m_shapeshiftMask
// uint32 unk_320_2; // 13 3.2.0
uint32 StancesNot; // 14 m_shapeshiftExclude
// uint32 unk_320_3; // 15 3.2.0
uint32 Targets; // 16 m_targets
uint32 TargetCreatureType; // 17 m_targetCreatureType
uint32 RequiresSpellFocus; // 18 m_requiresSpellFocus
uint32 FacingCasterFlags; // 19 m_facingCasterFlags
uint32 CasterAuraState; // 20 m_casterAuraState
uint32 TargetAuraState; // 21 m_targetAuraState
uint32 CasterAuraStateNot; // 22 m_excludeCasterAuraState
uint32 TargetAuraStateNot; // 23 m_excludeTargetAuraState
uint32 CasterAuraSpell; // 24 m_casterAuraSpell
uint32 TargetAuraSpell; // 25 m_targetAuraSpell
uint32 ExcludeCasterAuraSpell; // 26 m_excludeCasterAuraSpell
uint32 ExcludeTargetAuraSpell; // 27 m_excludeTargetAuraSpell
uint32 CastingTimeIndex; // 28 m_castingTimeIndex
uint32 RecoveryTime; // 29 m_recoveryTime
uint32 CategoryRecoveryTime; // 30 m_categoryRecoveryTime
uint32 InterruptFlags; // 31 m_interruptFlags
uint32 AuraInterruptFlags; // 32 m_auraInterruptFlags
uint32 ChannelInterruptFlags; // 33 m_channelInterruptFlags
uint32 ProcFlags; // 34 m_procTypeMask
uint32 ProcChance; // 35 m_procChance
uint32 ProcCharges; // 36 m_procCharges
uint32 MaxLevel; // 37 m_maxLevel
uint32 BaseLevel; // 38 m_baseLevel
uint32 SpellLevel; // 39 m_spellLevel
uint32 DurationIndex; // 40 m_durationIndex
uint32 PowerType; // 41 m_powerType
uint32 ManaCost; // 42 m_manaCost
uint32 ManaCostPerlevel; // 43 m_manaCostPerLevel
uint32 ManaPerSecond; // 44 m_manaPerSecond
uint32 ManaPerSecondPerLevel; // 45 m_manaPerSecondPerLeve
uint32 RangeIndex; // 46 m_rangeIndex
float Speed; // 47 m_speed
//uint32 ModalNextSpell; // 48 m_modalNextSpell not used
uint32 StackAmount; // 49 m_cumulativeAura
std::array<uint32, 2> Totem; // 50-51 m_totem
std::array<int32, MAX_SPELL_REAGENTS> Reagent; // 52-59 m_reagent
std::array<uint32, MAX_SPELL_REAGENTS> ReagentCount; // 60-67 m_reagentCount
int32 EquippedItemClass; // 68 m_equippedItemClass (value)
int32 EquippedItemSubClassMask; // 69 m_equippedItemSubclass (mask)
int32 EquippedItemInventoryTypeMask; // 70 m_equippedItemInvTypes (mask)
std::array<uint32, MAX_SPELL_EFFECTS> Effect; // 71-73 m_effect
std::array<int32, MAX_SPELL_EFFECTS> EffectDieSides; // 74-76 m_effectDieSides
std::array<float, MAX_SPELL_EFFECTS> EffectRealPointsPerLevel; // 77-79 m_effectRealPointsPerLevel
std::array<int32, MAX_SPELL_EFFECTS> EffectBasePoints; // 80-82 m_effectBasePoints (must not be used in spell/auras explicitly, must be used cached Spell::m_currentBasePoints)
std::array<uint32, MAX_SPELL_EFFECTS> EffectMechanic; // 83-85 m_effectMechanic
std::array<uint32, MAX_SPELL_EFFECTS> EffectImplicitTargetA; // 86-88 m_implicitTargetA
std::array<uint32, MAX_SPELL_EFFECTS> EffectImplicitTargetB; // 89-91 m_implicitTargetB
std::array<uint32, MAX_SPELL_EFFECTS> EffectRadiusIndex; // 92-94 m_effectRadiusIndex - spellradius.dbc
std::array<uint32, MAX_SPELL_EFFECTS> EffectApplyAuraName; // 95-97 m_effectAura
std::array<uint32, MAX_SPELL_EFFECTS> EffectAmplitude; // 98-100 m_effectAuraPeriod
std::array<float, MAX_SPELL_EFFECTS> EffectValueMultiplier; // 101-103
std::array<uint32, MAX_SPELL_EFFECTS> EffectChainTarget; // 104-106 m_effectChainTargets
std::array<uint32, MAX_SPELL_EFFECTS> EffectItemType; // 107-109 m_effectItemType
std::array<int32, MAX_SPELL_EFFECTS> EffectMiscValue; // 110-112 m_effectMiscValue
std::array<int32, MAX_SPELL_EFFECTS> EffectMiscValueB; // 113-115 m_effectMiscValueB
std::array<uint32, MAX_SPELL_EFFECTS> EffectTriggerSpell; // 116-118 m_effectTriggerSpell
std::array<float, MAX_SPELL_EFFECTS> EffectPointsPerComboPoint; // 119-121 m_effectPointsPerCombo
std::array<flag96, MAX_SPELL_EFFECTS> EffectSpellClassMask; // 122-130
std::array<uint32, 2> SpellVisual; // 131-132 m_spellVisualID
uint32 SpellIconID; // 133 m_spellIconID
uint32 ActiveIconID; // 134 m_activeIconID
uint32 SpellPriority; // 135 not used
std::array<char const*, 16> SpellName; // 136-151 m_name_lang
//uint32 SpellNameFlag; // 152 not used
std::array<char const*, 16> Rank; // 153-168 m_nameSubtext_lang
//uint32 RankFlags; // 169 not used
//char const* Description[16]; // 170-185 m_description_lang not used
//uint32 DescriptionFlags; // 186 not used
//char const* ToolTip[16]; // 187-202 m_auraDescription_lang not used
//uint32 ToolTipFlags; // 203 not used
uint32 ManaCostPercentage; // 204 m_manaCostPct
uint32 StartRecoveryCategory; // 205 m_startRecoveryCategory
uint32 StartRecoveryTime; // 206 m_startRecoveryTime
uint32 MaxTargetLevel; // 207 m_maxTargetLevel
uint32 SpellFamilyName; // 208 m_spellClassSet
flag96 SpellFamilyFlags; // 209-211
uint32 MaxAffectedTargets; // 212 m_maxTargets
uint32 DmgClass; // 213 m_defenseType
uint32 PreventionType; // 214 m_preventionType
//uint32 StanceBarOrder; // 215 m_stanceBarOrder not used
std::array<float, MAX_SPELL_EFFECTS> EffectDamageMultiplier; // 216-218 m_effectChainAmplitude
//uint32 MinFactionId; // 219 m_minFactionID not used
//uint32 MinReputation; // 220 m_minReputation not used
//uint32 RequiredAuraVision; // 221 m_requiredAuraVision not used
std::array<uint32, 2> TotemCategory; // 222-223 m_requiredTotemCategoryID
int32 AreaGroupId; // 224 m_requiredAreaGroupId
uint32 SchoolMask; // 225 m_schoolMask
uint32 RuneCostID; // 226 m_runeCostID
//uint32 SpellMissileID; // 227 m_spellMissileID not used
//uint32 PowerDisplayId; // 228 PowerDisplay.dbc, new in 3.1
std::array<float, MAX_SPELL_EFFECTS> EffectBonusMultiplier; // 229-231 3.2.0
//uint32 SpellDescriptionVariableID; // 232 3.2.0
//uint32 SpellDifficultyId; // 233 3.3.0
};
typedef std::set<std::pair<bool, uint32>> SpellCategorySet;
typedef std::unordered_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 SpellCategoryEntry
{
uint32 Id;
uint32 Flags;
};
struct SpellDifficultyEntry
{
uint32 ID; // 0
int32 SpellID[MAX_DIFFICULTY]; // 1-4 instance modes: 10N, 25N, 10H, 25H or Normal/Heroic if only 1-2 is set, if 3-4 is 0 then Mode-2
};
struct SpellFocusObjectEntry
{
uint32 ID; // 0
//char const* Name[16]; // 1-15 unused
// 16 string flags, unused
};
struct SpellRadiusEntry
{
uint32 ID;
float RadiusMin;
float RadiusPerLevel;
float RadiusMax;
};
struct SpellRangeEntry
{
uint32 ID; // 0
float RangeMin[2]; // 1-2 [0] Hostile [1] Friendly
float RangeMax[2]; // 3-4 [0] Hostile [1] Friendly
uint32 Flags; // 5
// char const* DisplayName[16]; // 6-21
// uint32 DisplayName_lang_mask; // 22
// char const* DisplayNameShort[16]; // 23-38
// uint32 DisplayNameShort_lang_mask; // 39
};
struct SpellRuneCostEntry
{
uint32 ID; // 0
uint32 RuneCost[3]; // 1-3 (0=blood, 1=frost, 2=unholy)
uint32 runePowerGain; // 4
[[nodiscard]] bool NoRuneCost() const { return RuneCost[0] == 0 && RuneCost[1] == 0 && RuneCost[2] == 0; }
[[nodiscard]] bool NoRunicPowerGain() const { return runePowerGain == 0; }
};
#define MAX_SHAPESHIFT_SPELLS 8
struct SpellShapeshiftEntry
{
uint32 ID; // 0
//uint32 buttonPosition; // 1 unused
//char const* 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_A; // 23 alliance modelid
uint32 modelID_H; // 24 horde modelid (only one form)
//uint32 unk3; // 25 unused
//uint32 unk4; // 26 unused
uint32 stanceSpell[MAX_SHAPESHIFT_SPELLS]; // 27 - 34 unused
};
struct SpellDurationEntry
{
uint32 ID;
int32 Duration[3];
};
#define MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS 3
struct SpellItemEnchantmentEntry
{
uint32 ID; // 0 m_ID
uint32 charges; // 1 m_charges
uint32 type[MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS]; // 2-4 m_effect[MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS]
uint32 amount[MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS]; // 5-7 m_effectPointsMin[MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS]
//uint32 amount2[MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS] // 8-10 m_effectPointsMax[MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS]
uint32 spellid[MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS]; // 11-13 m_effectArg[MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS]
char const* description[16]; // 14-29 m_name_lang[16]
//uint32 descriptionFlags; // 30 name flags
uint32 aura_id; // 31 m_itemVisual
uint32 slot; // 32 m_flags
uint32 GemID; // 33 m_src_itemID
uint32 EnchantmentCondition; // 34 m_condition_id
uint32 requiredSkill; // 35 m_requiredSkillID
uint32 requiredSkillValue; // 36 m_requiredSkillRank
uint32 requiredLevel; // 37 m_requiredLevel
};
struct SpellItemEnchantmentConditionEntry
{
uint32 ID; // 0 m_ID
uint8 Color[5]; // 1-5 m_lt_operandType[5]
//uint32 LT_Operand[5]; // 6-10 m_lt_operand[5]
uint8 Comparator[5]; // 11-15 m_operator[5]
uint8 CompareColor[5]; // 15-20 m_rt_operandType[5]
uint32 Value[5]; // 21-25 m_rt_operand[5]
//uint8 Logic[5] // 25-30 m_logic[5]
};
struct SpellVisualEntry
{
//uint32 Id;
//uint32 PrecastKit;
//uint32 CastingKit;
//uint32 ImpactKit;
//uint32 StateKit;
//uint32 StateDoneKit;
//uint32 ChannelKit;
uint32 HasMissile;
int32 MissileModel;
//uint32 MissilePathType;
//uint32 MissileDestinationAttachment;
//uint32 MissileSound;
//uint32 AnimEventSoundID;
//uint32 Flags;
//uint32 CasterImpactKit;
//uint32 TargetImpactKit;
//int32 MissileAttachment;
//uint32 MissileFollowGroundHeight;
//uint32 MissileFollowGroundDropSpeed;
//uint32 MissileFollowGroundApprach;
//uint32 MissileFollowGroundFlags;
//uint32 MissileMotionId;
//uint32 MissileTargetingKit;
//uint32 InstantAreaKit;
//uint32 ImpactAreaKit;
//uint32 PersistentAreaKit;
//DBCPosition3D MissileCastOffset;
//DBCPosition3D MissileImpactOffset;
};
struct StableSlotPricesEntry
{
uint32 Slot;
uint32 Price;
};
struct SummonPropertiesEntry
{
uint32 Id; // 0
uint32 Category; // 1, 0 - can't be controlled?, 1 - something guardian?, 2 - pet?, 3 - something controllable?, 4 - taxi/mount?
uint32 Faction; // 2, 14 rows > 0
uint32 Type; // 3, see enum
uint32 Slot; // 4, 0-6
uint32 Flags; // 5
};
#define MAX_TALENT_RANK 5
#define MAX_PET_TALENT_RANK 3 // use in calculations, expected <= MAX_TALENT_RANK
#define MAX_TALENT_TABS 3
struct TalentEntry
{
uint32 TalentID; // 0
uint32 TalentTab; // 1 index in TalentTab.dbc (TalentTabEntry)
uint32 Row; // 2
uint32 Col; // 3
std::array<uint32, MAX_TALENT_RANK> RankID; // 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-18 not used
uint32 addToSpellBook; // 19 also need disable higest ranks on reset talent tree
//uint32 unk2; // 20, all 0
//uint64 allowForPet; // 21-22 its a 64 bit mask for pet 1<<m_categoryEnumID in CreatureFamily.dbc
};
struct TalentTabEntry
{
uint32 TalentTabID; // 0
//char const* name[16]; // 1-16, unused
//uint32 nameFlags; // 17, unused
//unit32 spellicon; // 18
// 19 not used
uint32 ClassMask; // 20
uint32 petTalentMask; // 21
uint32 tabpage; // 22
//char const* internalname; // 23
};
struct TaxiNodesEntry
{
uint32 ID; // 0 m_ID
uint32 map_id; // 1 m_ContinentID
float x; // 2 m_x
float y; // 3 m_y
float z; // 4 m_z
char const* name[16]; // 5-21 m_Name_lang
// 22 string flags
uint32 MountCreatureID[2]; // 23-24 m_MountCreatureID[2]
};
struct TaxiPathEntry
{
uint32 ID; // 0 m_ID
uint32 from; // 1 m_FromTaxiNode
uint32 to; // 2 m_ToTaxiNode
uint32 price; // 3 m_Cost
};
struct TaxiPathNodeEntry
{
// 0 m_ID
uint32 path; // 1 m_PathID
uint32 index; // 2 m_NodeIndex
uint32 mapid; // 3 m_ContinentID
float x; // 4 m_LocX
float y; // 5 m_LocY
float z; // 6 m_LocZ
uint32 actionFlag; // 7 m_flags
uint32 delay; // 8 m_delay
uint32 arrivalEventID; // 9 m_arrivalEventID
uint32 departureEventID; // 10 m_departureEventID
};
struct TeamContributionPointsEntry
{
//uint32 entry; // 0
float value; // 1 (???)
};
struct TotemCategoryEntry
{
uint32 ID; // 0
//char const* 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 TransportAnimationEntry
{
//uint32 Id;
uint32 TransportEntry;
uint32 TimeSeg;
float X;
float Y;
float Z;
//uint32 MovementId;
};
struct TransportRotationEntry
{
//uint32 Id;
uint32 TransportEntry;
uint32 TimeSeg;
float X;
float Y;
float Z;
float W;
};
#define MAX_VEHICLE_SEATS 8
struct VehicleEntry
{
uint32 m_ID; // 0
uint32 m_flags; // 1
float m_turnSpeed; // 2
float m_pitchSpeed; // 3
float m_pitchMin; // 4
float m_pitchMax; // 5
uint32 m_seatID[MAX_VEHICLE_SEATS]; // 6-13
float m_mouseLookOffsetPitch; // 14
float m_cameraFadeDistScalarMin; // 15
float m_cameraFadeDistScalarMax; // 16
float m_cameraPitchOffset; // 17
//int32 m_powerType[3]; // removed in 3.1
//int32 m_powerToken[3]; // removed in 3.1
float m_facingLimitRight; // 18
float m_facingLimitLeft; // 19
float m_msslTrgtTurnLingering; // 20
float m_msslTrgtPitchLingering; // 21
float m_msslTrgtMouseLingering; // 22
float m_msslTrgtEndOpacity; // 23
float m_msslTrgtArcSpeed; // 24
float m_msslTrgtArcRepeat; // 25
float m_msslTrgtArcWidth; // 26
float m_msslTrgtImpactRadius[2]; // 27-28
char const* m_msslTrgtArcTexture; // 29
char const* m_msslTrgtImpactTexture; // 30
char const* m_msslTrgtImpactModel[2]; // 31-32
float m_cameraYawOffset; // 33
uint32 m_uiLocomotionType; // 34
float m_msslTrgtImpactTexRadius; // 35
uint32 m_uiSeatIndicatorType; // 36
uint32 m_powerDisplayId; // 37, new in 3.1
// 38, new in 3.1
// 39, new in 3.1
};
struct VehicleSeatEntry
{
uint32 m_ID; // 0
uint32 m_flags; // 1
int32 m_attachmentID; // 2
float m_attachmentOffsetX; // 3
float m_attachmentOffsetY; // 4
float m_attachmentOffsetZ; // 5
float m_enterPreDelay; // 6
float m_enterSpeed; // 7
float m_enterGravity; // 8
float m_enterMinDuration; // 9
float m_enterMaxDuration; // 10
float m_enterMinArcHeight; // 11
float m_enterMaxArcHeight; // 12
int32 m_enterAnimStart; // 13
int32 m_enterAnimLoop; // 14
int32 m_rideAnimStart; // 15
int32 m_rideAnimLoop; // 16
int32 m_rideUpperAnimStart; // 17
int32 m_rideUpperAnimLoop; // 18
float m_exitPreDelay; // 19
float m_exitSpeed; // 20
float m_exitGravity; // 21
float m_exitMinDuration; // 22
float m_exitMaxDuration; // 23
float m_exitMinArcHeight; // 24
float m_exitMaxArcHeight; // 25
int32 m_exitAnimStart; // 26
int32 m_exitAnimLoop; // 27
int32 m_exitAnimEnd; // 28
float m_passengerYaw; // 29
float m_passengerPitch; // 30
float m_passengerRoll; // 31
int32 m_passengerAttachmentID; // 32
int32 m_vehicleEnterAnim; // 33
int32 m_vehicleExitAnim; // 34
int32 m_vehicleRideAnimLoop; // 35
int32 m_vehicleEnterAnimBone; // 36
int32 m_vehicleExitAnimBone; // 37
int32 m_vehicleRideAnimLoopBone; // 38
float m_vehicleEnterAnimDelay; // 39
float m_vehicleExitAnimDelay; // 40
uint32 m_vehicleAbilityDisplay; // 41
uint32 m_enterUISoundID; // 42
uint32 m_exitUISoundID; // 43
int32 m_uiSkin; // 44
uint32 m_flagsB; // 45
// 46-57 added in 3.1, floats mostly
[[nodiscard]] bool CanEnterOrExit() const
{
return ((m_flags & VEHICLE_SEAT_FLAG_CAN_ENTER_OR_EXIT) != 0 ||
//If it has anmation for enter/ride, means it can be entered/exited by logic
(m_flags & (VEHICLE_SEAT_FLAG_HAS_LOWER_ANIM_FOR_ENTER | VEHICLE_SEAT_FLAG_HAS_LOWER_ANIM_FOR_RIDE)) != 0);
}
[[nodiscard]] bool CanSwitchFromSeat() const { return m_flags & VEHICLE_SEAT_FLAG_CAN_SWITCH; }
[[nodiscard]] bool IsUsableByOverride() const
{
return (m_flags & (VEHICLE_SEAT_FLAG_UNCONTROLLED | VEHICLE_SEAT_FLAG_UNK18)
|| (m_flagsB & (VEHICLE_SEAT_FLAG_B_USABLE_FORCED | VEHICLE_SEAT_FLAG_B_USABLE_FORCED_2 |
VEHICLE_SEAT_FLAG_B_USABLE_FORCED_3 | VEHICLE_SEAT_FLAG_B_USABLE_FORCED_4)));
}
[[nodiscard]] bool IsEjectable() const { return m_flagsB & VEHICLE_SEAT_FLAG_B_EJECTABLE; }
[[nodiscard]] bool CanControl() const { return (m_flags & VEHICLE_SEAT_FLAG_CAN_CONTROL) != 0; }
};
struct WMOAreaTableEntry
{
uint32 Id; // 0 index
int32 rootId; // 1 used in root WMO
int32 adtId; // 2 used in adt file
int32 groupId; // 3 used in group WMO
//uint32 field4;
//uint32 field5;
//uint32 field6;
//uint32 field7;
//uint32 field8;
uint32 Flags; // 9 used for indoor/outdoor determination
uint32 areaId; // 10 link to AreaTableEntry.ID
//char *Name[16];
//uint32 nameFlags;
};
struct WorldMapAreaEntry
{
//uint32 ID; // 0
uint32 map_id; // 1
uint32 area_id; // 2 index (continent 0 areas ignored)
//char const* 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)
// int32 dungeonMap_id; // 9 pointer to DungeonMap.dbc (owerride x1, x2, y1, y2 coordinates)
// uint32 parentMapID; // 10
};
#define MAX_WORLD_MAP_OVERLAY_AREA_IDX 4
struct WorldMapOverlayEntry
{
uint32 ID; // 0
//uint32 worldMapAreaId; // 1 idx in WorldMapArea.dbc
uint32 areatableID[MAX_WORLD_MAP_OVERLAY_AREA_IDX]; // 2-5
// 6-7 always 0, possible part of areatableID[]
//char const* internal_name // 8
// 9-16 some ints
};
/*
struct WorldStateSounds
{
uint32 ID; // 0 Worldstate
uint32 unk; // 1
uint32 areaTable; // 2
uint32 WMOAreaTable; // 3
uint32 zoneIntroMusicTable; // 4
uint32 zoneIntroMusic; // 5
uint32 zoneMusic; // 6
uint32 soundAmbience; // 7
uint32 soundProviderPreferences; // 8
};
*/
/*
struct WorldStateUI
{
uint32 ID; // 0
uint32 map_id; // 1 Can be -1 to show up everywhere.
uint32 zone; // 2 Can be zero for "everywhere".
uint32 phaseMask; // 3 Phase this WorldState is avaliable in
uint32 icon; // 4 The icon that is used in the interface.
char const* textureFilename; // 5
char const* text; // 6-21 The worldstate text
char const* description; // 22-38 Text shown when hovering mouse on icon
uint32 worldstateID; // 39 This is the actual ID used
uint32 type; // 40 0 = unknown, 1 = unknown, 2 = not shown in ui, 3 = wintergrasp
uint32 unk1; // 41
uint32 unk2; // 43
uint32 unk3; // 44-58
uint32 unk4; // 59-61 Used for some progress bars.
uint32 unk7; // 62 Unused in 3.3.5a
};
*/
// 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 MapDifficulty
{
MapDifficulty() = default;
MapDifficulty(uint32 _resetTime, uint32 _maxPlayers, bool _hasErrorMessage) : resetTime(_resetTime), maxPlayers(_maxPlayers), hasErrorMessage(_hasErrorMessage) {}
uint32 resetTime{0};
uint32 maxPlayers{0};
bool hasErrorMessage{false};
};
struct TalentSpellPos
{
TalentSpellPos() = default;
TalentSpellPos(uint16 _talent_id, uint8 _rank) : talent_id(_talent_id), rank(_rank) {}
uint16 talent_id{0};
uint8 rank{0};
};
typedef std::map<uint32, TalentSpellPos> TalentSpellPosMap;
typedef std::map<uint32, TaxiPathEntry const*> TaxiPathSetForSource;
typedef std::map<uint32, TaxiPathSetForSource> TaxiPathSetBySource;
typedef std::vector<TaxiPathNodeEntry const*> TaxiPathNodeList;
typedef std::vector<TaxiPathNodeList> TaxiPathNodesByPath;
static constexpr size_t TaxiMaskSize = 14;
typedef std::array<uint32, TaxiMaskSize> TaxiMask;
#endif
Reference in a new issue View git blame Copy permalink