From c92950b3e1f6366d85d707365a8ad2caddafeecc Mon Sep 17 00:00:00 2001 From: Peter Keresztes Schmidt Date: Sun, 12 Jul 2020 15:36:55 +0200 Subject: Core/DataStores: Update DBC field names to generated ones (#24999) --- src/server/shared/DataStores/DBCEnums.h | 2 +- src/server/shared/DataStores/DBCStructure.h | 2288 ++++++++++++++------------- src/server/shared/DataStores/DBCfmt.h | 14 +- src/server/shared/SharedDefines.h | 2 +- 4 files changed, 1164 insertions(+), 1142 deletions(-) (limited to 'src/server/shared') diff --git a/src/server/shared/DataStores/DBCEnums.h b/src/server/shared/DataStores/DBCEnums.h index 78dc2e842cf..fcd7bb560a5 100644 --- a/src/server/shared/DataStores/DBCEnums.h +++ b/src/server/shared/DataStores/DBCEnums.h @@ -264,7 +264,7 @@ enum AreaFlags AREA_FLAG_UNUSED2 = 0x00020000, // Unused in 3.3.5a AREA_FLAG_CONTESTED_AREA = 0x00040000, // On PvP servers these areas are considered contested, even though the zone it is contained in is a Horde/Alliance territory. AREA_FLAG_UNK4 = 0x00080000, // Valgarde and Acherus: The Ebon Hold - AREA_FLAG_LOWLEVEL = 0x00100000, // used for some starting areas with area_level <= 15 + AREA_FLAG_LOWLEVEL = 0x00100000, // used for some starting areas with ExplorationLevel <= 15 AREA_FLAG_TOWN = 0x00200000, // small towns with Inn AREA_FLAG_REST_ZONE_HORDE = 0x00400000, // Instead of using areatriggers, the zone will act as one for Horde players (Warsong Hold, Acherus: The Ebon Hold, New Agamand Inn, Vengeance Landing Inn, Sunreaver Pavilion, etc) AREA_FLAG_REST_ZONE_ALLIANCE = 0x00800000, // Instead of using areatriggers, the zone will act as one for Alliance players (Valgarde, Acherus: The Ebon Hold, Westguard Inn, Silver Covenant Pavilion, etc) diff --git a/src/server/shared/DataStores/DBCStructure.h b/src/server/shared/DataStores/DBCStructure.h index 5a5039b8312..4cf4be1ecf1 100644 --- a/src/server/shared/DataStores/DBCStructure.h +++ b/src/server/shared/DataStores/DBCStructure.h @@ -25,35 +25,35 @@ #include #include -// Structures using to access raw DBC data and required packing to portability +// Structures used to access raw DBC data require packing for portability #pragma pack(push, 1) struct AchievementEntry { - uint32 ID; - int32 Faction; // -1=all, 0=horde, 1=alliance - int32 MapID; // -1 = none - //uint32 Supercedes; // its Achievement parent (can`t start while parent uncomplete, use its Criteria if don`t have own, use its progress on begin) - char* Title[16]; - //uint32 Title_flags; - //char* Description[16]; - //uint32 Description_flags; - uint32 Category; - uint32 Points; - //uint32 UIOrder; - uint32 Flags; - //uint32 IconID; - //char* Reward[16]; - //uint32 Reward_flags; - uint32 MinimumCriteria; // need this count of completed criterias (own or referenced achievement criterias) - uint32 SharesCriteria; // referenced achievement (counting of all completed criterias) + uint32 ID; // 0 + int32 Faction; // 1 -1=all, 0=horde, 1=alliance + int32 InstanceID; // 2 -1=none + //uint32 Supercedes; // 3 its Achievement parent (can`t start while parent uncomplete, use its Criteria if don`t have own, use its progress on begin) + char* Title[16]; // 4-19 + //uint32 Title_lang_mask; // 20 + //char* Description[16]; // 21-36 + //uint32 Description_lang_mask; // 37 + uint32 Category; // 38 + uint32 Points; // 39 reward points + //uint32 UiOrder; // 40 icon (from SpellIcon.dbc) + uint32 Flags; // 41 + //uint32 IconID; // 42 + //char* Reward[16]; // 43-58 + //uint32 Reward_lang_mask; // 59 + uint32 MinimumCriteria; // 60 - need this count of completed criterias (own or referenced achievement criterias) + uint32 SharesCriteria; // 61 - referenced achievement (counting of all completed criterias) }; struct AchievementCriteriaEntry { - uint32 ID; - uint32 ReferredAchievement; - uint32 Type; + uint32 ID; // 0 + uint32 AchievementID; // 1 + uint32 Type; // 2 union { uint32 ID; @@ -154,52 +154,59 @@ struct AchievementCriteriaEntry // ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE = 109 uint32 LootType; - } Asset; + } Asset; // 3 - uint32 Amount; + uint32 Quantity; // 4 struct { - uint32 Type; - uint32 Asset; - } AdditionalRequirements[MAX_CRITERIA_REQUIREMENTS]; + uint32 Type; + uint32 Asset; + } AdditionalRequirements[MAX_CRITERIA_REQUIREMENTS]; // 5-8 - //char* Description[16]; - //uint32 Description_flags; - uint32 Flags; - uint32 StartEvent; - uint32 StartAsset; - uint32 StartTimer; - //uint32 OrderIndex; + //char* Description[16]; // 9-24 + //uint32 Description_lang_mask; // 25 + uint32 Flags; // 26 + uint32 StartEvent; // 27 AchievementCriteriaTimedTypes + uint32 StartAsset; // 28 Always appears with timed events, used internally to start the achievement, store + uint32 StartTimer; // 29 time limit in seconds + //uint32 UiOrder; // 30 }; 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 - 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 - uint32 LiquidTypeOverride[4]; // 29-32 liquid override by type + uint32 ID; // 0 + uint32 ContinentID; // 1 + uint32 ParentAreaID; // 2 if 0 then it's zone, else it's zone id of this area + uint32 AreaBit; // 3 + uint32 Flags; // 4 + //uint32 SoundProviderPref; // 5 + //uint32 SoundProviderPrefUnderwater; // 6 + //uint32 AmbienceID; // 7 + //uint32 ZoneMusic; // 8 + //uint32 IntroSound; // 9 + int32 ExplorationLevel; // 10 + char* AreaName[16]; // 11-26 + //uint32 AreaName_lang_mask; // 27 + uint32 FactionGroupMask; // 28 + uint32 LiquidTypeID[4]; // 29-32 liquid override by type + //float MinElevation; // 33 + //float AmbientMultiplier; // 34 + //uint32 LightID; // 35 // helpers bool IsSanctuary() const { - if (mapid == 609) + if (ContinentID == 609) return true; - return (flags & AREA_FLAG_SANCTUARY) != 0; + return (Flags & AREA_FLAG_SANCTUARY) != 0; } bool IsFlyable() const { - if (flags & AREA_FLAG_OUTLAND) + if (Flags & AREA_FLAG_OUTLAND) { - if (!(flags & AREA_FLAG_NO_FLY_ZONE)) + if (!(Flags & AREA_FLAG_NO_FLY_ZONE)) return true; } @@ -211,102 +218,100 @@ struct AreaTableEntry struct AreaGroupEntry { - uint32 AreaGroupId; // 0 - uint32 AreaId[MAX_GROUP_AREA_IDS]; // 1-6 - uint32 nextGroup; // 7 index of next group + uint32 ID; // 0 + uint32 AreaID[MAX_GROUP_AREA_IDS]; // 1-6 + uint32 NextAreaID; // 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* name[16]; //18-33 - //uint32 name_flag; //34 - //char* name2[16]; //35-50 - //uint32 name_flag2; //51 - uint32 worldState; //52 - //uint32 val2; //53 + uint32 ID; // 0 + uint32 Importance; // 1 + uint32 Icon[9]; // 2-10 + uint32 FactionID; // 11 + DBCPosition3D Pos; // 12-14 + uint32 ContinentID; // 15 + //uint32 Flags; // 16 + uint32 AreaID; // 17 + //char* Name[16]; // 18-33 + //uint32 Name_lang_mask; // 34 + //char* Description[16]; // 35-50 + //uint32 Description_lang_mask; // 51 + uint32 WorldStateID; // 52 + //uint32 WorldMapLink; // 53 }; struct AreaTriggerEntry { - uint32 id; // 0 m_ID - uint32 mapid; // 1 m_ContinentID - float x; // 2 m_x - float y; // 3 m_y - float z; // 4 m_z - float radius; // 5 m_radius - float box_x; // 6 m_box_length - float box_y; // 7 m_box_width - float box_z; // 8 m_box_heigh - float box_orientation; // 9 m_box_yaw + uint32 ID; // 0 + uint32 ContinentID; // 1 + DBCPosition3D Pos; // 2-4 + float Radius; // 5 + float BoxLength; // 6 + float BoxWidth; // 7 + float BoxHeight; // 8 + float BoxYaw; // 9 }; 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* name[16]; // 4-19 - // 20 string flag, unused + uint32 ID; // 0 + uint32 FactionID; // 1 id of faction.dbc for player factions associated with city + uint32 DepositRate; // 2 1/3 from real + uint32 ConsignmentRate; // 3 + //char* Name[16]; // 4-19 + //uint32 Name_lang_mask; // 20 }; struct BankBagSlotPricesEntry { - uint32 ID; - uint32 price; + uint32 ID; // 0 + uint32 Cost; // 1 }; struct BannedAddOnsEntry { - uint32 Id; - // uint32 NameMD5[4]; - // uint32 VersionMD5[4]; - // uint32 Timestamp; - // uint32 State; + uint32 ID; // 0 + //uint32 NameMD5[4]; // 1-4 + //uint32 VersionMD5[4]; // 5-8 + //uint32 LastModified; // 9 + //uint32 Flags; // 10 }; struct BarberShopStyleEntry { - uint32 Id; // 0 - uint32 type; // 1 value 0 -> hair, value 2 -> facialhair - //char* 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 + uint32 ID; // 0 + uint32 Type; // 1 value 0 -> hair, value 2 -> facialhair + //char* DisplayName[16]; // 2-17 + //uint32 DisplayName_lang_mask; // 18 + //uint32 Description[16]; // 19-34, all empty + //uint32 Description_lang_mask; // 35 + //float CostModifier; // 36 + uint32 Race; // 37 + uint32 Sex; // 38 + uint32 Data; // 39 real ID to hair/facial hair }; struct BattlemasterListEntry { - uint32 id; // 0 - int32 mapid[8]; // 1-8 mapid - uint32 type; // 9 map type (3 - BG, 4 - arena) - //uint32 canJoinAsGroup; // 10 (0 or 1) - char* 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 ID; // 0 + int32 MapID[8]; // 1-8 + uint32 InstanceType; // 9 map type (3 - BG, 4 - arena) + //uint32 GroupsAllowed; // 10 + char* Name[16]; // 11-26 + //uint32 Name_lang_mask; // 27 + uint32 MaxGroupSize; // 28 used for checking if queue as group + uint32 HolidayWorldState; // 29 //uint32 MinLevel; // 30 - //uint32 SomeLevel; // 31, may be max level + //uint32 MaxLevel; // 31 }; struct CharacterFacialHairStylesEntry { - uint32 Race; - uint32 Gender; - uint32 Variation; - // uint32 Geoset[5]; + uint32 RaceID; // 0 + uint32 SexID; // 1 + uint32 VariationID; // 2 + //uint32 Geoset[5]; // 3-7 }; enum CharSectionFlags @@ -326,70 +331,71 @@ enum CharSectionType struct CharSectionsEntry { - //uint32 Id; - uint32 Race; - uint32 Gender; - uint32 GenType; - //char* TexturePath[3]; - uint32 Flags; - uint32 Type; - uint32 Color; + //uint32 ID; // 0 + uint32 RaceID; // 1 + uint32 SexID; // 2 + uint32 BaseSection; // 3 + //char* TextureName[3]; // 4-6 + uint32 Flags; // 7 + uint32 VariationIndex; // 8 + uint32 ColorIndex; // 9 - inline bool HasFlag(CharSectionFlags flag) const { return !!(Flags & flag); } + inline bool HasFlag(CharSectionFlags flag) const { return (Flags & flag) != 0; } }; #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 + //uint32 ID; // 0 + uint8 RaceID; // 1 + uint8 ClassID; // 2 + uint8 SexID; // 3 + //uint8 OutfitID; // 4 + int32 ItemID[MAX_OUTFIT_ITEMS]; // 5-28 + //int32 DisplayItemID[MAX_OUTFIT_ITEMS]; // 29-52 not required at server side + //int32 InventoryType[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* nameMale[16]; // 2-17 - // 18 string flag, unused - char* nameFemale[16]; // 19-34 - // 35 string flag, unused - uint32 bit_index; // 36 used in PLAYER_CHOSEN_TITLE and 1<= 0; + return ReputationIndex >= 0; } }; @@ -678,88 +684,85 @@ struct FactionEntry 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 + uint32 ID; // 0 + uint32 Faction; // 1 + uint32 Flags; // 2 + uint32 FactionGroup; // 3 + uint32 FriendGroup; // 4 + uint32 EnemyGroup; // 5 + uint32 Enemies[MAX_FACTION_RELATIONS]; // 6-9 + uint32 Friend[MAX_FACTION_RELATIONS]; // 10-13 // helpers bool IsFriendlyTo(FactionTemplateEntry const& entry) const { - if (entry.faction) + if (entry.Faction) { for (int i = 0; i < MAX_FACTION_RELATIONS; ++i) - if (enemyFaction[i] == entry.faction) + if (Enemies[i] == entry.Faction) return false; for (int i = 0; i < MAX_FACTION_RELATIONS; ++i) - if (friendFaction[i] == entry.faction) + if (Friend[i] == entry.Faction) return true; } - return (friendlyMask & entry.ourMask) || (ourMask & entry.friendlyMask); + return (FriendGroup & entry.FactionGroup) || (FactionGroup & entry.FriendGroup); } bool IsHostileTo(FactionTemplateEntry const& entry) const { - if (entry.faction) + if (entry.Faction) { for (int i = 0; i < MAX_FACTION_RELATIONS; ++i) - if (enemyFaction[i] == entry.faction) + if (Enemies[i] == entry.Faction) return true; for (int i = 0; i < MAX_FACTION_RELATIONS; ++i) - if (friendFaction[i] == entry.faction) + if (Friend[i] == entry.Faction) return false; } - return (hostileMask & entry.ourMask) != 0; + return (EnemyGroup & entry.FactionGroup) != 0; } - bool IsHostileToPlayers() const { return (hostileMask & FACTION_MASK_PLAYER) !=0; } + bool IsHostileToPlayers() const { return (EnemyGroup & FACTION_MASK_PLAYER) !=0; } bool IsNeutralToAll() const { for (int i = 0; i < MAX_FACTION_RELATIONS; ++i) - if (enemyFaction[i] != 0) + if (Enemies[i] != 0) return false; - return hostileMask == 0 && friendlyMask == 0; + return EnemyGroup == 0 && FriendGroup == 0; } - bool IsContestedGuardFaction() const { return (factionFlags & FACTION_TEMPLATE_FLAG_CONTESTED_GUARD) != 0; } + bool IsContestedGuardFaction() const { return (Flags & FACTION_TEMPLATE_FLAG_CONTESTED_GUARD) != 0; } }; struct GameObjectDisplayInfoEntry { - uint32 Displayid; // 0 m_ID - char* filename; // 1 - //uint32 unk1[10]; //2-11 - float minX; - float minY; - float minZ; - float maxX; - float maxY; - float maxZ; - //uint32 transport; //18 + uint32 ID; // 0 + char* ModelName; // 1 + //uint32 Sound[10]; // 2-11 + DBCPosition3D GeoBoxMin; // 12-14 + DBCPosition3D GeoBoxMax; // 15-17 + //uint32 ObjectEffectPackageID; // 18 }; struct GemPropertiesEntry { - uint32 ID; - uint32 spellitemenchantement; - uint32 color; + uint32 ID; // 0 + uint32 EnchantID; // 1 + //uint32 MaxCountInv; // 2 + //uint32 MaxCountItem; // 3 + uint32 Type; // 4 }; struct GlyphPropertiesEntry { - uint32 Id; - uint32 SpellId; - uint32 TypeFlags; - uint32 Unk1; // GlyphIconId (SpellIcon.dbc) + uint32 ID; // 0 + uint32 SpellID; // 1 + uint32 GlyphSlotFlags; // 2 + uint32 SpellIconID; // 3 }; struct GlyphSlotEntry { - uint32 Id; - uint32 TypeFlags; - uint32 Order; + uint32 ID; // 0 + uint32 Type; // 1 + uint32 Tooltip; // 2 }; // All Gt* DBC store data for 100 levels, some by 100 per class/race @@ -769,79 +772,81 @@ struct GlyphSlotEntry struct GtBarberShopCostBaseEntry { - float cost; + float Data; // 0 }; struct GtCombatRatingsEntry { - float ratio; + float Data; // 0 }; struct GtChanceToMeleeCritBaseEntry { - float base; + float Data; // 0 }; struct GtChanceToMeleeCritEntry { - float ratio; + float Data; // 0 }; struct GtChanceToSpellCritBaseEntry { - float base; + float Data; // 0 }; struct GtNPCManaCostScalerEntry { - float ratio; + float Data; // 0 }; struct GtChanceToSpellCritEntry { - float ratio; + float Data; // 0 }; struct GtOCTClassCombatRatingScalarEntry { - float ratio; + float Data; // 0 }; struct GtOCTRegenHPEntry { - float ratio; + float Data; // 0 }; -//struct GtOCTRegenMPEntry -//{ -// float ratio; -//}; +/* +struct GtOCTRegenMPEntry +{ + float Data; // 0 +}; +*/ struct GtRegenHPPerSptEntry { - float ratio; + float Data; // 0 }; struct GtRegenMPPerSptEntry { - float ratio; + float Data; // 0 }; -/* no used +/* struct HolidayDescriptionsEntry { - uint32 ID; // 0, m_holidayDescriptionID - //char* name[16] // 1-16 m_name_lang - // 17 name flags + uint32 ID; // 0 + char* Description[16]; // 1-16 + uint32 Description_lang_mask; // 17 }; */ -/* no used +/* struct HolidayNamesEntry { - uint32 ID; // 0, m_holidayNameID - //char* name[16] // 1-16 m_name_lang - // 17 name flags + uint32 ID; // 0 + char* Name[16]; // 1-16 + uint32 Name_lang_mask; // 17 }; */ @@ -851,107 +856,112 @@ struct HolidayNamesEntry 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* 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) + uint32 ID; // 0 + uint32 Duration[MAX_HOLIDAY_DURATIONS]; // 1-10 + uint32 Date[MAX_HOLIDAY_DATES]; // 11-36 dates in unix time starting at January, 1, 2000 + uint32 Region; // 37 WoW region + uint32 Looping; // 38 + uint32 CalendarFlags[MAX_HOLIDAY_FLAGS]; // 39-48 + //uint32 HolidayNameID; // 49 HolidayNames.dbc + //uint32 HolidayDescriptionID; // 50 HolidayDescriptions.dbc + char* TextureFilename; // 51 + uint32 Priority; // 52 + int32 CalendarFilterType; // 53 + //uint32 Flags; // 54 0 = Darkmoon Faire, Fishing Contest and Wotlk Launch, rest is 1 }; struct ItemEntry { - uint32 ID; // 0 - uint32 Class; // 1 - uint32 SubClass; // 2 some items have strange subclasses - int32 SoundOverrideSubclass; // 3 - int32 Material; // 4 - uint32 DisplayId; // 5 - uint32 InventoryType; // 6 - uint32 Sheath; // 7 + 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* name[16] // 1-16 m_name_lang - // // 17 name flags + uint32 ID; // 0 + //char* Name[16]; // 1-16 + //uint32 Name_lang_mask; // 17 }; +/* struct ItemDisplayInfoEntry { - uint32 ID; // 0 m_ID - // 1 m_modelName[2] - // 2 m_modelTexture[2] - // 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) -//}; + uint32 ID; // 0 + char* ModelName[2]; // 1-2 + char* ModelTexture[2]; // 3-4 + char* InventoryIcon[2]; // 5-6 + uint32 GeosetGroup[3]; // 7-9 + uint32 Flags; // 10 + uint32 SpellVisualID; // 11 + uint32 GroupSoundIndex; // 12 + uint32 HelmetGeosetVisID[2]; // 13-14 + char* Texture[8]; // 15-22 + int32 ItemVisual; // 23 + uint32 ParticleColorID; // 24 +}; +*/ + +/* +struct ItemCondExtCostsEntry +{ + uint32 ID; // 0 + uint32 CondExtendedCost; // 1 ItemTemplate::CondExtendedCost + uint32 ItemExtendedCostEntry; // 2 ItemTemplate::ExtendedCost + uint32 ArenaSeason; // 3 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}; + uint32 ID; // 0 + uint32 HonorPoints; // 1 required honor points + uint32 ArenaPoints; // 2 required arena points + uint32 ArenaBracket; // 3 arena slot restrictions (min slot value) + uint32 ItemID[MAX_ITEM_EXTENDED_COST_REQUIREMENTS]; // 4-8 required item id + uint32 ItemCount[MAX_ITEM_EXTENDED_COST_REQUIREMENTS]; // 9-13 required count of item + uint32 RequiredArenaRating; // 14 required personal arena rating + //uint32 ItemPurchaseGroup; // 15 }; struct ItemLimitCategoryEntry { - uint32 ID; // 0 Id - //char* 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) + uint32 ID; // 0 + //char* Name[16] // 1-16 + //uint32 Name_lang_mask; // 17 + uint32 Quantity; // 18 max allowed equipped as item or in gem slot + uint32 Flags; // 19 enum ItemLimitCategoryMode }; #define MAX_ITEM_ENCHANTMENT_EFFECTS 3 struct ItemRandomPropertiesEntry { - uint32 ID; // 0 m_ID - //char* internalName // 1 m_Name - uint32 enchant_id[MAX_ITEM_ENCHANTMENT_EFFECTS]; // 2-4 m_Enchantment - // 5-6 unused - char* nameSuffix[16]; // 7-22 m_name_lang - // 23 name flags + uint32 ID; // 0 + //char* InternalName; // 1 + uint32 Enchantment[MAX_ITEM_ENCHANTMENT_EFFECTS]; // 2-4 + //uint32 UnusedEnchantment[2]; // 5-6 + char* Name[16]; // 7-22 + //uint32 Name_lang_mask; // 23 }; struct ItemRandomSuffixEntry { - uint32 ID; // 0 m_ID - char* nameSuffix[16]; // 1-16 m_name_lang - // 17, name flags - // 18 m_internalName - uint32 enchant_id[MAX_ITEM_ENCHANTMENT_EFFECTS]; // 19-21 m_enchantment - //uint32 unk1[2] // 22-23 unknown - uint32 prefix[MAX_ITEM_ENCHANTMENT_EFFECTS]; // 24-26 m_allocationPct - //uint32 unk2[2] // 27-28 unknown + uint32 ID; // 0 + char* Name[16]; // 1-16 + //uint32 Name_lang_mask; // 17 + //char* InternalName; // 18 + uint32 Enchantment[MAX_ITEM_ENCHANTMENT_EFFECTS]; // 19-21 + //uint32 UnusedEnchantment[2] // 22-23 + uint32 AllocationPct[MAX_ITEM_ENCHANTMENT_EFFECTS]; // 24-26 + //uint32 UnusedAllocationPct[2] // 27-28 }; #define MAX_ITEM_SET_ITEMS 10 @@ -959,150 +969,144 @@ struct ItemRandomSuffixEntry struct ItemSetEntry { - //uint32 id // 0 m_ID - char* 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 + //uint32 ID; // 0 + char* Name[16]; // 1-16 + //uint32 Name_lang_mask; // 17 + uint32 ItemID[MAX_ITEM_SET_ITEMS]; // 18-27 + //uint32 UnusedItemID[7]; // 28-34 + uint32 SetSpellID[MAX_ITEM_SET_SPELLS]; // 35-42 + uint32 SetThreshold[MAX_ITEM_SET_SPELLS]; // 43-50 + uint32 RequiredSkill; // 51 + uint32 RequiredSkillRank; // 52 }; struct LFGDungeonEntry { - uint32 ID; // 0 - char* 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* iconname; // 28 - uint32 expansion; // 29 - //uint32 unk4; // 30 - uint32 grouptype; // 31 - //char* desc[16]; // 32-47 Description + uint32 ID; // 0 + char* Name[16]; // 1-16 + //uint32 Name_lang_mask; // 17 + uint32 MinLevel; // 18 + uint32 MaxLevel; // 19 + uint32 TargetLevel; // 20 + uint32 TargetLevelMin; // 21 + uint32 TargetLevelMax; // 22 + int32 MapID; // 23 + uint32 Difficulty; // 24 + uint32 Flags; // 25 + uint32 TypeID; // 26 + //int32 Faction; // 27 + //char* TextureFilename; // 28 + uint32 ExpansionLevel; // 29 + //uint32 OrderIndex; // 30 + uint32 GroupID; // 31 + //char* Description[16]; // 32-47 + //uint32 Description_lang_mask; // 48 + // Helpers - uint32 Entry() const { return ID + (type << 24); } + uint32 Entry() const { return ID + (TypeID << 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; + uint32 ID; // 0 + uint32 ContinentID; // 1 + DBCPosition3D GameCoords; // 2-4 + //float GameFalloffStart; // 5 + //float GameFalloffEnd; // 6 + //uint32 LightParamsID[8]; // 7-14 }; struct LiquidTypeEntry { - uint32 Id; - //char* 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* Texture[6]; - //uint32 Color[2]; - //float Unk1[18]; - //uint32 Unk2[4]; + uint32 ID; // 0 + //char* Name; // 1 + //uint32 Flags; // 2 + uint32 SoundBank; // 3 + //uint32 SoundID; // 4 + uint32 SpellID; // 5 + //float MaxDarkenDepth; // 6 + //float FogDarkenIntensity; // 7 + //float AmbDarkenIntensity; // 8 + //float DirDarkenIntensity; // 9 + //uint32 LightID; // 10 + //float ParticleScale; // 11 + //uint32 ParticleMovement; // 12 + //uint32 ParticleTexSlots; // 13 + //uint32 MaterialID; // 14 + //char* Texture[6]; // 15-20 + //uint32 Color[2]; // 21-22 + //float Unk1[18]; // 23-40 + //uint32 Unk2[4]; // 41-44 }; #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 + uint32 ID; // 0 + uint32 Type[MAX_LOCK_CASE]; // 1-8 + uint32 Index[MAX_LOCK_CASE]; // 9-16 + uint32 Skill[MAX_LOCK_CASE]; // 17-24 + //uint32 Action[MAX_LOCK_CASE]; // 25-32 }; struct MailTemplateEntry { - uint32 ID; // 0 - //char* subject[16]; // 1-16 - // 17 name flags, unused - char* content[16]; // 18-33 + uint32 ID; // 0 + //char* Subject[16]; // 1-16 + //uint32 Subject_lang_mask; // 17 + char* Body[16]; // 18-33 + //uint32 Body_lang_mask; // 34 }; struct MapEntry { - uint32 MapID; // 0 - //char* internalname; // 1 unused - uint32 map_type; // 2 - uint32 Flags; // 3 - // 4 0 or 1 for battlegrounds (not arenas) - char* name[16]; // 5-20 - // 21 name flags, unused - uint32 linked_zone; // 22 common zone for instance and continent map - //char* hordeIntro[16]; // 23-38 text for PvP Zones - // 39 intro text flags - //char* 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 ID; // 0 + //char* Directory; // 1 + uint32 InstanceType; // 2 + uint32 Flags; // 3 + //uint32 MapType; // 4 0 or 1 for battlegrounds (not arenas) + char* MapName[16]; // 5-20 + //uint32 MapName_lang_mask; // 21 + uint32 AreaTableID; // 22 common zone for instance and continent map + //char* MapDescription0[16]; // 23-38 text for PvP Zones (Horde) + //uint32 MapDescription0_lang_mask; // 39 + //char* MapDescription1[16]; // 40-55 text for PvP Zones (Alliance) + //uint32 MapDescription1_lang_mask; // 56 + uint32 LoadingScreenID; // 57 + //float MinimapIconScale; // 58 + int32 CorpseMapID; // 59 MapID of entrance map + DBCPosition2D Corpse; // 60-61 entrance 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 + uint32 ExpansionID; // 63 + uint32 RaidOffset; // 64 + uint32 MaxPlayers; // 65 max players, fallback if not present in MapDifficulty.dbc // Helpers - uint32 Expansion() const { return addon; } + uint32 Expansion() const { return ExpansionID; } - bool IsDungeon() const { return map_type == MAP_INSTANCE || map_type == MAP_RAID; } - bool IsNonRaidDungeon() const { return map_type == MAP_INSTANCE; } - 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 IsWorldMap() const { return map_type == MAP_COMMON; } + bool IsDungeon() const { return InstanceType == MAP_INSTANCE || InstanceType == MAP_RAID; } + bool IsNonRaidDungeon() const { return InstanceType == MAP_INSTANCE; } + bool Instanceable() const { return InstanceType == MAP_INSTANCE || InstanceType == MAP_RAID || InstanceType == MAP_BATTLEGROUND || InstanceType == MAP_ARENA; } + bool IsRaid() const { return InstanceType == MAP_RAID; } + bool IsBattleground() const { return InstanceType == MAP_BATTLEGROUND; } + bool IsBattleArena() const { return InstanceType == MAP_ARENA; } + bool IsBattlegroundOrArena() const { return InstanceType == MAP_BATTLEGROUND || InstanceType == MAP_ARENA; } + bool IsWorldMap() const { return InstanceType == MAP_COMMON; } bool GetEntrancePos(int32 &mapid, float &x, float &y) const { - if (entrance_map < 0) + if (CorpseMapID < 0) return false; - mapid = entrance_map; - x = entrance_x; - y = entrance_y; + mapid = CorpseMapID; + x = Corpse.X; + y = Corpse.Y; return true; } bool IsContinent() const { - return MapID == 0 || MapID == 1 || MapID == 530 || MapID == 571; + return ID == 0 || ID == 1 || ID == 530 || ID == 571; } bool IsDynamicDifficultyMap() const { return (Flags & MAP_FLAG_DYNAMIC_DIFFICULTY) != 0; } @@ -1110,127 +1114,141 @@ struct MapEntry struct MapDifficultyEntry { - //uint32 Id; // 0 - uint32 MapId; // 1 - uint32 Difficulty; // 2 (for arenas: arena slot) - char* areaTriggerText; // 3-18 text showed when transfer to map failed (missing requirements) - //uint32 textFlags; // 19 - uint32 resetTime; // 20 - uint32 maxPlayers; // 21 - //char* difficultyString; // 22 + //uint32 ID; // 0 + uint32 MapID; // 1 + uint32 Difficulty; // 2 (for arenas: arena slot) + char* Message; // 3-18 text showed when transfer to map failed (missing requirements) + //uint32 Message_lang_mask; // 19 + uint32 RaidDuration; // 20 + uint32 MaxPlayers; // 21 + //char* Difficultystring; // 22 }; struct MovieEntry { - uint32 Id; // 0 index - //char* filename; // 1 - //uint32 unk2; // 2 always 100 + uint32 ID; // 0 + //char* Filename; // 1 + //uint32 Volume; // 2 always 100 }; struct NamesProfanityEntry { - //uint32 ID; // 0 - char const* Name; // 1 - int32 Language; // 2 + //uint32 ID; // 0 + char* Name; // 1 + int32 Language; // 2 }; struct NamesReservedEntry { - //uint32 ID; // 0 - char const* Name; // 1 - int32 Language; // 2 + //uint32 ID; // 0 + char* Name; // 1 + int32 Language; // 2 }; #define MAX_OVERRIDE_SPELL 10 struct OverrideSpellDataEntry { - uint32 id; // 0 - uint32 spellId[MAX_OVERRIDE_SPELL]; // 1-10 - //uint32 unk0; // 11 + uint32 ID; // 0 + uint32 Spells[MAX_OVERRIDE_SPELL]; // 1-10 + //uint32 Flags; // 11 }; struct PowerDisplayEntry { - uint32 Id; // 0 - uint32 PowerType; // 1 - //char* Name; // 2 - //uint32 R; // 3 - //uint32 G; // 4 - //uint32 B; // 5 + uint32 ID; // 0 + uint32 ActualType; // 1 + //char* GlobalStringBaseTag; // 2 + //uint8 Red; // 3 + //uint8 Green; // 4 + //uint8 Blue; // 5 }; struct PvPDifficultyEntry { - //uint32 id; // 0 m_ID - uint32 mapId; // 1 - uint32 bracketId; // 2 - uint32 minLevel; // 3 - uint32 maxLevel; // 4 - uint32 difficulty; // 5 + //uint32 ID; // 0 + uint32 MapID; // 1 + uint32 RangeIndex; // 2 + uint32 MinLevel; // 3 + uint32 MaxLevel; // 4 + uint32 Difficulty; // 5 // helpers - BattlegroundBracketId GetBracketId() const { return BattlegroundBracketId(bracketId); } + BattlegroundBracketId GetBracketId() const { return BattlegroundBracketId(RangeIndex); } }; struct QuestSortEntry { - uint32 id; // 0 m_ID - //char* name[16]; // 1-16 m_SortName_lang - // 17 name flags + uint32 ID; // 0 + //char* SortName[16]; // 1-16 + //uint32 SortName_lang; // 17 }; struct QuestXPEntry { - uint32 id; - uint32 Exp[10]; + uint32 ID; // 0 + uint32 Difficulty[10]; // 1-10 }; struct QuestFactionRewEntry { - uint32 id; - int32 QuestRewFactionValue[10]; + uint32 ID; // 0 + int32 Difficulty[10]; // 1 }; -struct RandomPropertiesPointsEntry +struct RandPropPointsEntry { - //uint32 Id; // 0 hidden key - uint32 itemLevel; // 1 - uint32 EpicPropertiesPoints[5]; // 2-6 - uint32 RarePropertiesPoints[5]; // 7-11 - uint32 UncommonPropertiesPoints[5]; // 12-16 + uint32 ID; // 0 item level + uint32 Epic[5]; // 1-5 + uint32 Superior[5]; // 6-10 + uint32 Good[5]; // 11-15 }; struct ScalingStatDistributionEntry { - uint32 Id; // 0 - int32 StatMod[10]; // 1-10 - uint32 Modifier[10]; // 11-20 - uint32 MaxLevel; // 21 + uint32 ID; // 0 + int32 StatID[10]; // 1-10 + uint32 Bonus[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 + uint32 ID; // 0 + uint32 Charlevel; // 1 + uint32 ShoulderBudget; // 2 + uint32 TrinketBudget; // 3 + uint32 WeaponBudget1H; // 4 + uint32 RangedBudget; // 5 + uint32 ClothShoulderArmor; // 6 + uint32 LeatherShoulderArmor; // 7 + uint32 MailShoulderArmor; // 8 + uint32 PlateShoulderArmor; // 9 + uint32 WeaponDPS1H; // 10 + uint32 WeaponDPS2H; // 11 + uint32 SpellcasterDPS1H; // 12 + uint32 SpellcasterDPS2H; // 13 + uint32 RangedDPS; // 14 + uint32 WandDPS; // 15 + uint32 SpellPower; // 16 + uint32 PrimaryBudget; // 17 + uint32 TertiaryBudget; // 18 + uint32 ClothCloakArmor; // 19 + uint32 ClothChestArmor; // 20 + uint32 LeatherChestArmor; // 21 + uint32 MailChestArmor; // 22 + uint32 PlateChestArmor; // 23 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; + if (mask & 0x00000001) return ShoulderBudget; + if (mask & 0x00000002) return TrinketBudget; + if (mask & 0x00000004) return WeaponBudget1H; + if (mask & 0x00000008) return PrimaryBudget; + if (mask & 0x00000010) return RangedBudget; + if (mask & 0x00040000) return TertiaryBudget; } return 0; } @@ -1239,16 +1257,16 @@ struct ScalingStatValuesEntry { if (mask & 0x00F001E0) { - 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 + if (mask & 0x00000020) return ClothShoulderArmor; + if (mask & 0x00000040) return LeatherShoulderArmor; + if (mask & 0x00000080) return MailShoulderArmor; + if (mask & 0x00000100) return PlateShoulderArmor; + + if (mask & 0x00080000) return ClothCloakArmor; + if (mask & 0x00100000) return ClothChestArmor; + if (mask & 0x00200000) return LeatherChestArmor; + if (mask & 0x00400000) return MailChestArmor; + if (mask & 0x00800000) return PlateChestArmor; } return 0; } @@ -1257,19 +1275,19 @@ struct ScalingStatValuesEntry { 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 + if (mask & 0x00000200) return WeaponDPS1H; + if (mask & 0x00000400) return WeaponDPS2H; + if (mask & 0x00000800) return SpellcasterDPS1H; + if (mask & 0x00001000) return SpellcasterDPS2H; + if (mask & 0x00002000) return RangedDPS; + if (mask & 0x00004000) return WandDPS; } return 0; } uint32 getSpellBonus(uint32 mask) const { - if (mask & 0x00008000) return spellPower; + if (mask & 0x00008000) return SpellPower; return 0; } @@ -1280,191 +1298,194 @@ struct ScalingStatValuesEntry } }; -//struct SkillLineCategoryEntry{ -// uint32 id; // 0 m_ID -// char* name[16]; // 1-17 m_name_lang -// // 18 string flag -// uint32 displayOrder; // 19 m_sortIndex -//}; - struct SkillLineEntry { - uint32 id; // 0 m_ID - int32 categoryId; // 1 m_categoryID - //uint32 skillCostID; // 2 m_skillCostsID - char* name[16]; // 3-18 m_displayName_lang - // 19 string flags - //char* description[16]; // 20-35 m_description_lang - // 36 string flags - uint32 spellIcon; // 37 m_spellIconID - //char* alternateVerb[16]; // 38-53 m_alternateVerb_lang - // 54 string flags - uint32 canLink; // 55 m_canLink (prof. with recipes + uint32 ID; // 0 + int32 CategoryID; // 1 + //uint32 SkillCostsID; // 2 + char* DisplayName[16]; // 3-18 + //uint32 DisplayName_lang_mask; // 19 + //char* Description[16]; // 20-35 + //uint32 Description_lang_mask; // 36 + uint32 SpellIconID; // 37 + //char* AlternateVerb[16]; // 38-53 + //uint32 AlternateVerb_lang_mask; // 54 + uint32 CanLink; // 55 }; struct SkillLineAbilityEntry { - uint32 id; // 0 m_ID - uint32 skillId; // 1 m_skillLine - uint32 spellId; // 2 m_spell - uint32 racemask; // 3 m_raceMask - uint32 classmask; // 4 m_classMask - //uint32 racemaskNot; // 5 m_excludeRace - //uint32 classmaskNot; // 6 m_excludeClass - uint32 req_skill_value; // 7 m_minSkillLineRank - uint32 forward_spellid; // 8 m_supercededBySpell - uint32 AutolearnType; // 9 m_acquireMethod - uint32 max_value; // 10 m_trivialSkillLineRankHigh - uint32 min_value; // 11 m_trivialSkillLineRankLow - //uint32 characterPoints[2]; // 12-13 m_characterPoints[2] + 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 SkillLineCategoryEntry +{ + uint32 ID; // 0 + char* Name[16]; // 1-17 + uint32 Name_lang_mask; // 18 + uint32 SortIndex; // 19 +}; +*/ + struct SkillRaceClassInfoEntry { - //uint32 Id; // 0 - uint32 SkillId; // 1 + //uint32 ID; // 0 + uint32 SkillID; // 1 uint32 RaceMask; // 2 uint32 ClassMask; // 3 uint32 Flags; // 4 //uint32 MinLevel; // 5 - uint32 SkillTier; // 6 - //uint32 SkillCostType; // 7 + uint32 SkillTierID; // 6 + //uint32 SkillCostIndex; // 7 }; #define MAX_SKILL_STEP 16 struct SkillTiersEntry { - uint32 Id; // 0 - //uint32 StepCost[MAX_SKILL_STEP]; // 1-16 - uint32 MaxSkill[MAX_SKILL_STEP]; // 17-32 + 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* InternalName; // 2 m_name - //char* FileName[10]; // 3-12 m_File[10] - //uint32 Unk13[10]; // 13-22 m_Freq[10] - //char* Path; // 23 m_DirectoryBase - // 24 m_volumeFloat - // 25 m_flags - // 26 m_minDistance - // 27 m_distanceCutoff - // 28 m_EAXDef - // 29 new in 3.1 + uint32 ID; // 0 + //uint32 SoundType; // 1 + //char* Name; // 2 + //char* File[10]; // 3-12 + //uint32 Freq[10]; // 13-22 + //char* DirectoryBase; // 23 + //float VolumeFloat; // 24 + //uint32 Flags; // 25 + //float MinDistance; // 26 + //float DistanceCutoff; // 27 + //uint32 EAXDef; // 28 + //uint32 SoundEntriesAdvancedID; // 29 }; 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[2]; // 12 m_shapeshiftMask - uint32 StancesNot[2]; // 14 m_shapeshiftExclude - 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 - uint32 Totem[2]; // 50-51 m_totem - int32 Reagent[MAX_SPELL_REAGENTS]; // 52-59 m_reagent - uint32 ReagentCount[MAX_SPELL_REAGENTS]; // 60-67 m_reagentCount - int32 EquippedItemClass; // 68 m_equippedItemClass (value) - int32 EquippedItemSubClassMask; // 69 m_equippedItemSubclass (mask) - int32 EquippedItemInventoryTypeMask; // 70 m_equippedItemInvTypes (mask) - uint32 Effect[MAX_SPELL_EFFECTS]; // 71-73 m_effect - int32 EffectDieSides[MAX_SPELL_EFFECTS]; // 74-76 m_effectDieSides - float EffectRealPointsPerLevel[MAX_SPELL_EFFECTS]; // 77-79 m_effectRealPointsPerLevel - int32 EffectBasePoints[MAX_SPELL_EFFECTS]; // 80-82 m_effectBasePoints (must not be used in spell/auras explicitly, must be used cached Spell::m_currentBasePoints) - uint32 EffectMechanic[MAX_SPELL_EFFECTS]; // 83-85 m_effectMechanic - uint32 EffectImplicitTargetA[MAX_SPELL_EFFECTS]; // 86-88 m_implicitTargetA - uint32 EffectImplicitTargetB[MAX_SPELL_EFFECTS]; // 89-91 m_implicitTargetB - uint32 EffectRadiusIndex[MAX_SPELL_EFFECTS]; // 92-94 m_effectRadiusIndex - spellradius.dbc - uint32 EffectApplyAuraName[MAX_SPELL_EFFECTS]; // 95-97 m_effectAura - uint32 EffectAmplitude[MAX_SPELL_EFFECTS]; // 98-100 m_effectAuraPeriod - float EffectValueMultiplier[MAX_SPELL_EFFECTS]; // 101-103 - uint32 EffectChainTarget[MAX_SPELL_EFFECTS]; // 104-106 m_effectChainTargets - uint32 EffectItemType[MAX_SPELL_EFFECTS]; // 107-109 m_effectItemType - int32 EffectMiscValue[MAX_SPELL_EFFECTS]; // 110-112 m_effectMiscValue - int32 EffectMiscValueB[MAX_SPELL_EFFECTS]; // 113-115 m_effectMiscValueB - uint32 EffectTriggerSpell[MAX_SPELL_EFFECTS]; // 116-118 m_effectTriggerSpell - float EffectPointsPerComboPoint[MAX_SPELL_EFFECTS]; // 119-121 m_effectPointsPerCombo - flag96 EffectSpellClassMask[MAX_SPELL_EFFECTS]; // 122-130 - uint32 SpellVisual[2]; // 131-132 m_spellVisualID - uint32 SpellIconID; // 133 m_spellIconID - uint32 activeIconID; // 134 m_activeIconID - uint32 SpellPriority; // 135 m_spellPriority - char* SpellName[16]; // 136-151 m_name_lang - //uint32 SpellNameFlag; // 152 not used - char* Rank[16]; // 153-168 m_nameSubtext_lang - //uint32 RankFlags; // 169 not used - //char* Description[16]; // 170-185 m_description_lang not used - //uint32 DescriptionFlags; // 186 not used - //char* 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 - float EffectDamageMultiplier[MAX_SPELL_EFFECTS]; // 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 - uint32 TotemCategory[2]; // 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 - float EffectBonusMultiplier[MAX_SPELL_EFFECTS]; // 229-231 3.2.0 - //uint32 spellDescriptionVariableID; // 232 3.2.0 - //uint32 SpellDifficultyId; // 233 3.3.0 + uint32 ID; // 0 + uint32 Category; // 1 + uint32 DispelType; // 2 + uint32 Mechanic; // 3 + uint32 Attributes; // 4 + uint32 AttributesEx; // 5 + uint32 AttributesExB; // 6 + uint32 AttributesExC; // 7 + uint32 AttributesExD; // 8 + uint32 AttributesExE; // 9 + uint32 AttributesExF; // 10 + uint32 AttributesExG; // 11 + uint32 ShapeshiftMask[2]; // 12 + uint32 ShapeshiftExclude[2]; // 14 + uint32 Targets; // 16 + uint32 TargetCreatureType; // 17 + uint32 RequiresSpellFocus; // 18 + uint32 FacingCasterFlags; // 19 + uint32 CasterAuraState; // 20 + uint32 TargetAuraState; // 21 + uint32 ExcludeCasterAuraState; // 22 + uint32 ExcludeTargetAuraState; // 23 + uint32 CasterAuraSpell; // 24 + uint32 TargetAuraSpell; // 25 + uint32 ExcludeCasterAuraSpell; // 26 + uint32 ExcludeTargetAuraSpell; // 27 + uint32 CastingTimeIndex; // 28 + uint32 RecoveryTime; // 29 + uint32 CategoryRecoveryTime; // 30 + uint32 InterruptFlags; // 31 + uint32 AuraInterruptFlags; // 32 + uint32 ChannelInterruptFlags; // 33 + uint32 ProcTypeMask; // 34 + uint32 ProcChance; // 35 + uint32 ProcCharges; // 36 + uint32 MaxLevel; // 37 + uint32 BaseLevel; // 38 + uint32 SpellLevel; // 39 + uint32 DurationIndex; // 40 + uint32 PowerType; // 41 + uint32 ManaCost; // 42 + uint32 ManaCostPerLevel; // 43 + uint32 ManaPerSecond; // 44 + uint32 ManaPerSecondPerLevel; // 45 + uint32 RangeIndex; // 46 + float Speed; // 47 + //uint32 ModalNextSpell; // 48 + uint32 CumulativeAura; // 49 + uint32 Totem[2]; // 50-51 + int32 Reagent[MAX_SPELL_REAGENTS]; // 52-59 + uint32 ReagentCount[MAX_SPELL_REAGENTS]; // 60-67 + int32 EquippedItemClass; // 68 + int32 EquippedItemSubclass; // 69 + int32 EquippedItemInvTypes; // 70 + uint32 Effect[MAX_SPELL_EFFECTS]; // 71-73 + int32 EffectDieSides[MAX_SPELL_EFFECTS]; // 74-76 + float EffectRealPointsPerLevel[MAX_SPELL_EFFECTS]; // 77-79 + int32 EffectBasePoints[MAX_SPELL_EFFECTS]; // 80-82 + uint32 EffectMechanic[MAX_SPELL_EFFECTS]; // 83-85 + uint32 EffectImplicitTargetA[MAX_SPELL_EFFECTS]; // 86-88 + uint32 EffectImplicitTargetB[MAX_SPELL_EFFECTS]; // 89-91 + uint32 EffectRadiusIndex[MAX_SPELL_EFFECTS]; // 92-94 + uint32 EffectAura[MAX_SPELL_EFFECTS]; // 95-97 + uint32 EffectAuraPeriod[MAX_SPELL_EFFECTS]; // 98-100 + float EffectAmplitude[MAX_SPELL_EFFECTS]; // 101-103 + uint32 EffectChainTargets[MAX_SPELL_EFFECTS]; // 104-106 + uint32 EffectItemType[MAX_SPELL_EFFECTS]; // 107-109 + int32 EffectMiscValue[MAX_SPELL_EFFECTS]; // 110-112 + int32 EffectMiscValueB[MAX_SPELL_EFFECTS]; // 113-115 + uint32 EffectTriggerSpell[MAX_SPELL_EFFECTS]; // 116-118 + float EffectPointsPerCombo[MAX_SPELL_EFFECTS]; // 119-121 + flag96 EffectSpellClassMask[MAX_SPELL_EFFECTS]; // 122-130 + uint32 SpellVisualID[2]; // 131-132 + uint32 SpellIconID; // 133 + uint32 ActiveIconID; // 134 + uint32 SpellPriority; // 135 + char* Name[16]; // 136-151 + //uint32 Name_lang_mask; // 152 + char* NameSubtext[16]; // 153-168 + //uint32 NameSubtext_lang_mask; // 169 + //char* Description[16]; // 170-185 + //uint32 Description_lang_mask; // 186 + //char* AuraDescription[16]; // 187-202 + //uint32 AuraDescription_lang_mask; // 203 + uint32 ManaCostPct; // 204 + uint32 StartRecoveryCategory; // 205 + uint32 StartRecoveryTime; // 206 + uint32 MaxTargetLevel; // 207 + uint32 SpellClassSet; // 208 + flag96 SpellClassMask; // 209-211 + uint32 MaxTargets; // 212 + uint32 DefenseType; // 213 + uint32 PreventionType; // 214 + //uint32 StanceBarOrder; // 215 + float EffectChainAmplitude[MAX_SPELL_EFFECTS]; // 216-218 + //uint32 MinFactionID; // 219 + //uint32 MinReputation; // 220 + //uint32 RequiredAuraVision; // 221 + uint32 RequiredTotemCategoryID[2]; // 222-223 + int32 RequiredAreasID; // 224 + uint32 SchoolMask; // 225 + uint32 RuneCostID; // 226 + //uint32 SpellMissileID; // 227 + //uint32 PowerDisplayID; // 228 + float EffectBonusCoefficient[MAX_SPELL_EFFECTS]; // 229-231 + //uint32 DescriptionVariablesID; // 232 + //uint32 Difficulty; // 233 }; typedef std::set PetFamilySpellsSet; @@ -1472,359 +1493,354 @@ typedef std::map PetFamilySpellsStore; struct SpellCastTimesEntry { - uint32 ID; // 0 - int32 CastTime; // 1 - //float CastTimePerLevel; // 2 unsure / per skill? - //int32 MinCastTime; // 3 unsure + uint32 ID; // 0 + int32 Base; // 1 + //int32 PerLevel; // 2 + //int32 Minimum; // 3 }; struct SpellCategoryEntry { - uint32 Id; - uint32 Flags; + uint32 ID; // 0 + uint32 Flags; // 1 }; 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 + uint32 ID; // 0 + int32 DifficultySpellID[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 +struct SpellDurationEntry { - uint32 ID; // 0 - //char* Name[16]; // 1-15 unused - // 16 string flags, unused + uint32 ID; // 0 + int32 Duration; // 1 + int32 DurationPerLevel; // 2 + int32 MaxDuration; // 3 }; -struct SpellRadiusEntry +struct SpellFocusObjectEntry { - uint32 ID; - float RadiusMin; - float RadiusPerLevel; - float RadiusMax; + uint32 ID; // 0 + //char* Name[16]; // 1-15 + //uint32 Name_lang_mask; // 16 }; -struct SpellRangeEntry +struct SpellItemEnchantmentEntry { - uint32 ID; - float minRangeHostile; - float minRangeFriend; - float maxRangeHostile; - float maxRangeFriend; - uint32 type; - //char* Name[16]; // 7-23 unused - // 24 string flags, unused - //char* Name2[16]; // 25-40 unused - // 41 string flags, unused + uint32 ID; // 0 + //uint32 Charges; // 1 + uint32 Effect[MAX_ITEM_ENCHANTMENT_EFFECTS]; // 2-4 + uint32 EffectPointsMin[MAX_ITEM_ENCHANTMENT_EFFECTS]; // 5-7 + //uint32 EffectPointsMax[MAX_ITEM_ENCHANTMENT_EFFECTS] // 8-10 + uint32 EffectArg[MAX_ITEM_ENCHANTMENT_EFFECTS]; // 11-13 + char* Name[16]; // 14-29 + //uint32 Name_lang_mask; // 30 + uint32 ItemVisual; // 31 + uint32 Flags; // 32 + uint32 SrcItemID; // 33 + uint32 ConditionID; // 34 + uint32 RequiredSkillID; // 35 + uint32 RequiredSkillRank; // 36 + uint32 MinLevel; // 37 }; -struct SpellRuneCostEntry +struct SpellItemEnchantmentConditionEntry { - uint32 ID; // 0 - uint32 RuneCost[3]; // 1-3 (0=blood, 1=frost, 2=unholy) - uint32 runePowerGain; // 4 - - bool NoRuneCost() const { return RuneCost[0] == 0 && RuneCost[1] == 0 && RuneCost[2] == 0; } - bool NoRunicPowerGain() const { return runePowerGain == 0; } + uint32 ID; // 0 + uint8 LtOperandType[5]; // 1-5 + //uint32 LtOperand[5]; // 6-10 + uint8 Operator[5]; // 11-15 + uint8 RtOperandType[5]; // 15-20 + uint32 RtOperand[5]; // 21-25 + //uint8 Logic[5]; // 25-30 }; -#define MAX_SHAPESHIFT_SPELLS 8 - -struct SpellShapeshiftEntry +struct SpellRadiusEntry { 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_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 + float Radius; // 1 + float RadiusPerLevel; // 2 + float RadiusMax; // 3 }; -struct SpellDurationEntry +struct SpellRangeEntry { - uint32 ID; - int32 Duration[3]; + 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* DisplayName[16]; // 6-21 + //uint32 DisplayName_lang_mask; // 22 + //char* DisplayNameShort[16]; // 23-38 + //uint32 DisplayNameShort_lang_mask; // 39 }; -struct SpellItemEnchantmentEntry +struct SpellRuneCostEntry { - uint32 ID; // 0 m_ID - //uint32 charges; // 1 m_charges - uint32 type[MAX_ITEM_ENCHANTMENT_EFFECTS]; // 2-4 m_effect[MAX_ITEM_ENCHANTMENT_EFFECTS] - uint32 amount[MAX_ITEM_ENCHANTMENT_EFFECTS]; // 5-7 m_effectPointsMin[MAX_ITEM_ENCHANTMENT_EFFECTS] - //uint32 amount2[MAX_ITEM_ENCHANTMENT_EFFECTS] // 8-10 m_effectPointsMax[MAX_ITEM_ENCHANTMENT_EFFECTS] - uint32 spellid[MAX_ITEM_ENCHANTMENT_EFFECTS]; // 11-13 m_effectArg[MAX_ITEM_ENCHANTMENT_EFFECTS] - char* 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 + uint32 ID; // 0 + uint32 RuneCost[3]; // 1-3 [0] Blood [1] Unholy [2] Frost + uint32 RunicPower; // 4 + + bool NoRuneCost() const { return RuneCost[0] == 0 && RuneCost[1] == 0 && RuneCost[2] == 0; } + bool NoRunicPowerGain() const { return RunicPower == 0; } }; -struct SpellItemEnchantmentConditionEntry +#define MAX_SHAPESHIFT_SPELLS 8 + +struct SpellShapeshiftFormEntry { - 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] + uint32 ID; // 0 + //uint32 BonusActionBar; // 1 + //char* Name[16]; // 2-17 + //uint32 Name_lang_mask; // 18 + uint32 Flags; // 19 + int32 CreatureType; // 20 <= 0 humanoid, other normal creature types + //uint32 AttackIconID; // 21 + uint32 CombatRoundTime; // 22 + uint32 CreatureDisplayID[4]; // 23-26 [0] Alliance [1] Horde [2] Unk [3] Unk + uint32 PresetSpellID[MAX_SHAPESHIFT_SPELLS]; // 27-34 }; 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; + //uint32 ID; // 0 + //uint32 PrecastKit; // 1 + //uint32 CastKit; // 2 + //uint32 ImpactKit; // 3 + //uint32 StateKit; // 4 + //uint32 StateDoneKit; // 5 + //uint32 ChannelKit; // 6 + uint32 HasMissile; // 7 + int32 MissileModel; // 8 + //uint32 MissilePathType; // 9 + //uint32 MissileDestinationAttachment; // 10 + //uint32 MissileSound; // 11 + //uint32 AnimEventSoundID; // 12 + //uint32 Flags; // 13 + //uint32 CasterImpactKit; // 14 + //uint32 TargetImpactKit; // 15 + //int32 MissileAttachment; // 16 + //uint32 MissileFollowGroundHeight; // 17 + //uint32 MissileFollowGroundDropSpeed; // 18 + //uint32 MissileFollowGroundApproach; // 19 + //uint32 MissileFollowGroundFlags; // 20 + //uint32 MissileMotion; // 21 + //uint32 MissileTargetingKit; // 22 + //uint32 InstantAreaKit; // 23 + //uint32 ImpactAreaKit; // 24 + //uint32 PersistentAreaKit; // 25 + //DBCPosition3D MissileCastOffset; // 26-28 + //DBCPosition3D MissileImpactOffset; // 29-31 }; struct StableSlotPricesEntry { - uint32 Slot; - uint32 Price; + uint32 ID; // 0 + uint32 Cost; // 1 }; 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 + uint32 ID; // 0 + uint32 Control; // 1 + uint32 Faction; // 2 + uint32 Title; // 3 + uint32 Slot; // 4 + uint32 Flags; // 5 }; struct TalentEntry { - uint32 TalentID; // 0 - uint32 TalentTab; // 1 index in TalentTab.dbc (TalentTabEntry) - uint32 Row; // 2 - uint32 Col; // 3 - uint32 RankID[MAX_TALENT_RANK]; // 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 needAddInSpellBook; // 19 also need disable higest ranks on reset talent tree - //uint32 unk2; // 20, all 0 - //uint64 allowForPet; // 21 its a 64 bit mask for pet 1<