; DBC structure - 4.3.4.15595
;
; x - not used/unknown, 4 bytes
; X - not used/unknown, 1 byte
; s - string block index, 4 bytes
; S - string block index, 4 bytes - localized; autofill
; f - float, 4 bytes (rounded to 4 digits after comma)
; u - unsigned int, 4 bytes
; i - signed int, 4 bytes
; b - unsigned char, 1 byte
; d - sorted by this field, not included in array
; n - same, but field included in array
;
; LOC   - used locale strings macro [sxsssxsxsxxxxxxxx]
; X_LOC - unused locale strings macro [xxxxxxxxxxxxxxxxx]

[areatable]
id = n
mapId = i
areaTable = i
areaBit = x
flags = i
soundProviderPref = x
soundProviderPrefWater = x
soundAmbience = i
zoneMusic = i
introSound = x
; nameINT = s
; zoneIntroMusic = i
explorationLevel = x
name = S
factionGroupMask = i
liquidType1 = x
liquidType2 = x
liquidType3 = x
liquidType4 = x
minElevation = x
ambientMultiplier = x
lightId = x
mountFLags = x
uwIntroSound = x
uwZoneMusic = x
uwAmbience = x
worldPvpId = x
pvpCombatWorldStateId = x

[dungeonmap]
id = n
mapId = i
floor = i
minX = f
maxX = f
minY = f
maxY = f
worldMapAreaId = i

[worldmaparea]
id = n
mapId = i
areaId = i
nameINT = s
left = f
right = f
top = f
bottom = f
displayMapId = x
defaultDungeonMapId = i
parentWorldMapId = x
flags = i
levelMin = x
levelMax = x

[worldmapoverlay]
id = n
worldMapAreaId = i
areaTableId = i
areaTableId2 = x
areaTableId3 = x
areaTableId4 = x
textureString = s
w = i
h = i
x = i
y = i
hitRectTop = x
hitRectLeft = x
hitRectBottom = x
hitRectRight = x

; from TrnityCore - Cataclysm Preservation Project
; Achievementfmt = "niixsxiixixxii";
; AnimKitfmt = "nxx";
; AchievementCriteriafmt = "niiiliiiisiiiiiiiiiiiii";
; AreaTableEntryfmt = "niiiiiiiiiisiiiiiffiiiiiii";
; AreaGroupEntryfmt = "niiiiiii";
; AreaPOIEntryfmt = "nxiiiiiiiiixffixixxixx";
; AreaTriggerEntryfmt = "nifffiiifffff";
; ArmorLocationfmt = "nfffff";
; AuctionHouseEntryfmt = "niiix";
; BankBagSlotPricesEntryfmt = "ni";
; BannedAddOnsfmt = "nxxxxxxxxxx";
; BarberShopStyleEntryfmt = "nixxxiii";
; BattlemasterListEntryfmt = "niiiiiiiiixsiiiixxxx";
; CharStartOutfitEntryfmt = "dbbbXiiiiiiiiiiiiiiiiiiiiiiiixxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxii";
; CharSectionsEntryfmt = "diiixxxiii";
; CharTitlesEntryfmt = "nxssix";
; ChatChannelsEntryfmt = "nixsx";
; ChrClassesEntryfmt = "nixsxxxixiiiii";
; ChrRacesEntryfmt = "niixiixixxxxixsxxxxxixxx";
; ChrClassesXPowerTypesfmt = "nii";
; CinematicCameraEntryfmt = "nsiffff";
; CinematicSequencesEntryfmt = "nxiiiiiiii";
; CreatureDisplayInfofmt = "nixifxxxxxxxxxxxx";
; CreatureDisplayInfoExtrafmt = "diixxxxxxxxxxxxxxxxxx";
; CreatureModelDatafmt = "nisxfxxxxxxxxxxffxxxxxxxxxxxxxf";
; CreatureFamilyfmt = "nfifiiiiixsx";
; CreatureSpellDatafmt = "niiiixxxx";
; CreatureTypefmt = "nxx";
; CurrencyTypesfmt = "nixxxxiiiix";
; DestructibleModelDatafmt = "ixxixxxixxxixxxixxxxxxxx";
; DungeonEncounterfmt = "niixisxx";
; DurabilityCostsfmt = "niiiiiiiiiiiiiiiiiiiiiiiiiiiii";
; DurabilityQualityfmt = "nf";
; EmotesEntryfmt = "nxxiiixx";
; EmotesTextEntryfmt = "nxixxxxxxxxxxxxxxxx";
; EmotesTextSoundEntryfmt = "niiii";
; FactionEntryfmt = "niiiiiiiiiiiiiiiiiiffiisxi";
; FactionTemplateEntryfmt = "niiiiiiiiiiiii";
; GameObjectArtKitfmt = "nxxxxxxx";
; GameObjectDisplayInfofmt = "nsxxxxxxxxxxffffffxxx";
; GemPropertiesEntryfmt = "nixxii";
; GlyphPropertiesfmt = "niii";
; GlyphSlotfmt = "nii";
; GtBarberShopCostBasefmt = "xf";
; GtCombatRatingsfmt = "xf";
; GtOCTHpPerStaminafmt = "df";
; GtChanceToMeleeCritBasefmt = "xf";
; GtChanceToMeleeCritfmt = "xf";
; GtChanceToSpellCritBasefmt = "xf";
; GtChanceToSpellCritfmt = "xf";
; GtNPCManaCostScalerfmt = "xf";
; GtOCTClassCombatRatingScalarfmt = "df";
; GtOCTRegenHPfmt = "f";
; GtOCTRegenMPfmt = "f";
; GtRegenMPPerSptfmt = "xf";
; GtSpellScalingfmt = "df";
; GtOCTBaseHPByClassfmt = "df";
; GtOCTBaseMPByClassfmt = "df";
; GuildPerkSpellsfmt = "dii";
; Holidaysfmt = "niiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiixxsiix";
; ImportPriceArmorfmt = "nffff";
; ImportPriceQualityfmt = "nf";
; ImportPriceShieldfmt = "nf";
; ImportPriceWeaponfmt = "nf";
; ItemPriceBasefmt = "diff";
; ItemReforgefmt = "nifif";
; ItemBagFamilyfmt = "nx";
; ItemArmorQualityfmt = "nfffffffi";
; ItemArmorShieldfmt = "nifffffff";
; ItemArmorTotalfmt = "niffff";
; ItemClassfmt = "dixxfx";
; ItemDamagefmt = "nfffffffi";
; ItemDisenchantLootfmt = "niiiiii";
; ItemDisplayTemplateEntryfmt = "nxxxxxxxxxxixxxxxxxxxxx";
; ItemLimitCategoryEntryfmt = "nxii";
; ItemRandomPropertiesfmt = "nxiiiiis";
; ItemRandomSuffixfmt = "nsxiiiiiiiiii";
; ItemSetEntryfmt = "dsiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii";
; LFGDungeonEntryfmt = "nsiiiiiiiiixxixixiiii";
; LFGDungeonsGroupingMapfmt = "niii";
; LightEntryfmt = "nifffxxxxxxxxxx";
; LiquidTypefmt = "nxxixixxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
; LockEntryfmt = "niiiiiiiiiiiiiiiiiiiiiiiixxxxxxxx";
; PhaseEntryfmt = "nsi";
; PhaseGroupfmt = "nii";
; MailTemplateEntryfmt = "nxs";
; MapEntryfmt = "nsiiiisissififfiiiii";
; MapDifficultyEntryfmt = "diisiix";
; MovieEntryfmt = "nxxx";
; NamesProfanityEntryfmt = "dsi";
; NamesReservedEntryfmt = "dsi";
; MountCapabilityfmt = "niiiiiii";
; MountTypefmt = "niiiiiiiiiiiiiiiiiiiiiiii";
; NameGenfmt = "dsii";
; NumTalentsAtLevelfmt = "df";
; OverrideSpellDatafmt = "niiiiiiiiiixx";
; QuestFactionRewardfmt = "niiiiiiiiii";
; QuestPOIBlobfmt = "niii";
; QuestPOIPointfmt = "niii";
; QuestSortEntryfmt = "nx";
; QuestXPfmt = "niiiiiiiiii";
; PlayerConditionfmt = "ns";
; PowerDisplayfmt = "nixxxx";
; PvPDifficultyfmt = "diiiii";
; RandomPropertiesPointsfmt = "niiiiiiiiiiiiiii";
; ResearchBranchEntryfmt = "nsiisi";
; ResearchFieldEntryfmt = "nsi";
; ResearchProjectEntryfmt = "nssiiiisi";
; ResearchSiteEntryfmt = "niiss";
; ScalingStatDistributionfmt = "niiiiiiiiiiiiiiiiiiiiii";
; ScalingStatValuesfmt = "iniiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii";
; SkillLinefmt = "nisxixi";
; SkillLineAbilityfmt = "niiiixxiiiiiii";
; SkillRaceClassInfofmt = "diiiiixix";
; SkillTiersfmt = "nxxxxxxxxxxxxxxxxiiiiiiiiiiiiiiii";
; SoundEntriesfmt = "nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
; SpellCastTimefmt = "nixx";
; SpellCategoriesEntryfmt = "diiiiii";
; SpellCategoryfmt = "niix";
; SpellDifficultyfmt = "niiii";
; SpellDurationfmt = "niii";
; SpellEffectEntryfmt =            "nifiiiffiiiiiifiifiiiiiiiix";
; SpellEntryfmt =            "niiiiiiiiiiiiiiifiiiissxxiixxifiiiiiiixiiiiiiiii";
; SpellFocusObjectfmt = "nx";
; SpellItemEnchantmentfmt = "nxiiiiiixxxiiisiiiiiiix";
; SpellItemEnchantmentConditionfmt = "nbbbXxxxxxxbbbXXbbbxiiixxXXXXXX";
; SpellRadiusfmt = "nfff";
; SpellRangefmt = "nffffixx";
; SpellReagentsEntryfmt = "diiiiiiiiiiiiiiii";
; SpellScalingEntryfmt = "diiiiffffffffffi";
; SpellTotemsEntryfmt = "niiii";
; SpellTargetRestrictionsEntryfmt = "nfiiii";
; SpellPowerEntryfmt = "diiiixxf";
; SpellInterruptsEntryfmt = "diiiii";
; SpellEquippedItemsEntryfmt = "diii";
; SpellAuraOptionsEntryfmt = "niiii";
; SpellAuraRestrictionsEntryfmt = "diiiiiiii";
; SpellCastingRequirementsEntryfmt = "niiiiii";
; SpellClassOptionsEntryfmt = "dxiiiix";
; SpellCooldownsEntryfmt = "diii";
; SpellLevelsEntryfmt = "diii";
; SpellRuneCostfmt = "niiii";
; SpellShapeshiftEntryfmt = "niiiix";
; SpellShapeshiftFormfmt = "nxxiixiiiiiiiiiiiiiix";
; SpellVisualfmt = "dxxxxxxiixxxxxxxxxxxxxxxxxxxxxxxi";
; SpellVisualKitfmt = "niiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii";
; StableSlotPricesfmt = "ni";
; SummonPropertiesfmt = "niiiii";
; TalentEntryfmt = "niiiiiiiiiiiiiixxxx";
; TalentTabEntryfmt = "nxxiiixxxii";
; TalentTreePrimarySpellsfmt = "diix";
; TaxiNodesEntryfmt = "nifffsiiiff";
; TaxiPathEntryfmt = "niii";
; TaxiPathNodeEntryfmt = "diiifffiiii";
; TotemCategoryEntryfmt = "nxii";
; UnitPowerBarfmt = "niiixffxxxxxxxxxxxxxxxxxxxx";
; TransportAnimationfmt = "diifffx";
; TransportRotationfmt = "diiffff";
; VehicleEntryfmt = "niffffiiiiiiiifffffffffffffffssssfifiiii";
; VehicleSeatEntryfmt = "niiffffffffffiiiiiifffffffiiifffiiiiiiiffiiiiiffffffffffffiiiiiiii";
; WMOAreaTableEntryfmt = "niiixxxxxiixxxx";
; WorldSafeLocsEntryfmt = "nifffx";

; struct AchievementEntry
; {
;     uint32 ID;                                              // 0
;     int32  Faction;                                         // 1 -1=all, 0=horde, 1=alliance
;     int32  MapID;                                           // 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;                                            // 4
;     //char* Description;                                    // 5
;     uint32  Category;                                       // 6
;     uint32  Points;                                         // 7 reward points
;     //uint32 Ui_order;                                      // 8
;     uint32  Flags;                                          // 9
;     //uint32 IconID;                                        // 10 icon (from SpellIcon.dbc)
;     //char* Reward;                                         // 11
;     uint32 MinimumCriteria;                                 // 12 - need this count of completed criterias (own or referenced achievement criterias)
;     uint32 SharesCriteria;                                  // 13 - referenced achievement (counting of all completed criterias)
; };

; struct AchievementCategoryEntry
; {
;     uint32  ID;                                             // 0
;     uint32  Parent;                                         // 1 -1 for main category
;     //char* Name;                                           // 2
;     //uint32  Ui_order;                                     // 3
; };

; struct AchievementCriteriaEntry
; {
;     uint32  ID;                                             // 0
;     uint32  AchievementID;                                  // 1
;     uint32  Type;                                           // 2
;     uint64 Quantity;                                        // 4
;     uint32 StartEvent;                                      // 5
;     int32 StartAsset;                                       // 6
;     uint32 FailEvent;                                       // 7
;     int32 FailAsset;                                        // 8
;     char* Description;                                      // 9
;     uint32 Flags;                                           // 10
;     uint32 TimerStartEvent;                                 // 11
;     uint32 TimerAsset;                                      // 12
;     uint32 TimerTime;                                       // 13
;     uint32 OrderIndex;                                      // 14
;     uint32 RequiredWorldStateID;                            // 15
;     int32  RequiredWorldStateValue;                         // 16
;     uint32 AdditionalConditionType[3];                      // 17-19
;     uint32 AdditionalConditionValue[3];                     // 20-22
; };

; struct AnimKitEntry
; {
;     uint32  ID;                                             // 0
;     //uint32  OneShotDuration;                              // 1
;     //uint32  OneShotStopAnimKitID;                         // 2
; };

; struct AreaGroupEntry
; {
;     uint32  ID;                                             // 0
;     uint32  AreaID[6];                                      // 1-6
;     uint32  NextAreaID;                                     // 7 index of next group
; };

; struct AreaPOIEntry
; {
;     uint32 ID;                                              // 0
;     // uint32 Importance                                    // 1
;     uint32 Icon[9];                                         // 2-10
;     // uint32 FactionID                                     // 11
;     DBCPosition2D Pos;                                      // 12 - 13
;     uint32 ContinentID;                                     // 14
;     // uint32 Flags;                                        // 15
;     uint32 AreaID;                                          // 16
;     //char* Name;                                           // 17
;     //char* Description;                                    // 18
;     uint32 WorldStateID;                                    // 19
;     //uint32 WorldMapLink;                                  // 20
;     //uint32 PortLocID;                                     // 21
; };

; struct AreaTriggerEntry
; {
;     uint32          ID;                                     // 0
;     uint32          ContinentID;                            // 1
;     DBCPosition3D   Pos;                                    // 2 - 4
;     uint32          PhaseUseFlags;                          // 5
;     uint32          PhaseID;                                // 6
;     uint32          PhaseGroupID;                           // 7
;     float           Radius;                                 // 8
;     float           Box_length;                             // 9
;     float           Box_width;                              // 10
;     float           Box_height;                             // 11
;     float           Box_yaw;                                // 12
; };

; struct ArmorLocationEntry
; {
;   uint32 ID;                                                // 0
;   float  Value[5];                                          // 1-5 multiplier for armor types (cloth...plate, no armor?)
; };

; struct AuctionHouseEntry
; {
;     uint32  ID;                                             // 0 index
;     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;                                           // 4
; };

; struct BankBagSlotPricesEntry
; {
;     uint32  ID;                                             // 0
;     uint32  Cost;                                           // 1
; };

; struct BannedAddOnsEntry
; {
;     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*   DisplayName;                                  // 2
;     //uint32  Description;                                  // 3
;     //float   Cost_Modifier;                                // 4
;     uint32  Race;                                           // 5
;     uint32  Sex;                                            // 6
;     uint32  Data;                                           // 7
; };

; struct BattlemasterListEntry
; {
;     uint32  ID;                                             // 0
;     int32   MapID[8];                                       // 1-8
;     uint32  InstanceType;                                   // 9 map type (3 - BG, 4 - arena)
;     //uint32 GroupsAllowed;                                 // 10 (0 or 1)
;     char* Name;                                             // 11
;     uint32  MaxGroupSize;                                   // 12 maxGroupSize, used for checking if queue as group
;     uint32  HolidayWorldState;                              // 13 new 3.1
;     uint32  MinLevel;                                       // 14, min level (sync with PvPDifficulty.dbc content)
;     uint32  MaxLevel;                                       // 15, max level (sync with PvPDifficulty.dbc content)
;     //uint32  RatedPlayers;                                 // 16 4.0.1
;     //uint32  MinPlayers;                                   // 17 - 4.0.6.13596
;     //uint32  MaxPlayers;                                   // 18 4.0.1
;     //uint32  Flags;                                        // 19 4.0.3, value 2 for Rated Battlegrounds
; };

; struct CharStartOutfitEntry
; {
;     //uint32  ID;                                           // 0
;     uint8  RaceID;                                          // 1
;     uint8  ClassID;                                         // 2
;     uint8  SexID;                                           // 3
;     //uint8  OutfitID;                                      // 4
;     int32  ItemID[24];                                      // 5-28
;     //int32  DisplayItemID[24];                             // 29-52 not required at server side
;     //int32  InventoryType[24];                             // 53-76 not required at server side
;     uint32  PetDisplayID;                                   // 77 Pet Model ID for starting pet
;     uint32  PetFamilyID;                                    // 78 Pet Family Entry for starting pet
; };

; struct CharSectionsEntry
; {
;     //uint32 ID                                             // 0
;     uint32 RaceID;                                          // 1
;     uint32 SexID;                                           // 2
;     uint32 BaseSection;                                     // 3
;     //char* TextureName[3];                                 // 4 - 7
;     uint32 Flags;                                           // 8
;     uint32 VariationIndex;                                  // 9
;     uint32 ColorIndex;                                      // 10
; };

; struct CharTitlesEntry
; {
;     uint32 ID;                                              // 0 title ids, for example in Quest::GetCharTitleId()
;     //uint32  Condition_ID;                                 // 1
;     char*  Name;                                            // 2
;     char*  Name1;                                           // 3
;     uint32 Mask_ID;                                         // 4 used in PLAYER_CHOSEN_TITLE and 1<<index in PLAYER__FIELD_KNOWN_TITLES
;     //uint32 Flags                                          // 5
; };

; struct ChatChannelsEntry
; {
;     uint32  ID;                                             // 0
;     uint32  Flags;                                          // 1
;     //uint32  FactionGroup                                  // 2
;     char* Name;                                             // 3
;     //char* Shortcut;                                       // 4
; };

; struct ChrClassesEntry
; {
;     uint32  ID;                                             // 0
;     uint32  DisplayPower;                                   // 1
;     //char* PetNameToken                                    // 2
;     char*   Name;                                           // 3
;     //char* Name_female;                                    // 4
;     //char* Name_male;                                      // 5
;     //char* Filename                                        // 6
;     uint32  SpellClassSet;                                  // 7
;     //uint32 Flags;                                         // 8        (0x08 HasRelicSlot)
;     uint32  CinematicSequenceID;                            // 9
;     uint32  Required_expansion;                             // 10
;     uint32  AttackPowerPerStrength;                         // 11
;     uint32  AttackPowerPerAgility;                          // 12
;     uint32  RangedAttackPowerPerAgility;                    // 13
; };

; struct ChrRacesEntry
; {
;     uint32  ID;                                             // 0
;     uint32  Flags;                                          // 1
;     uint32  FactionID;                                      // 2
;     // uint32 ExplorationSoundID                            // 3
;     uint32  MaleDisplayID;                                  // 4
;     uint32  FemaleDisplayID;                                // 5
;     // char* ClientPrefix                                   // 6
;     uint32  BaseLanguage;                                   // 7 (7-Alliance 1-Horde)
;     // uint32 CreatureType                                  // 8
;     // uint32 ResSicknessSpellID                            // 9
;     // uint32 SplashSoundID                                 // 10
;     // char* ClientFileString                               // 11
;     uint32  CinematicSequenceID;                            // 12 id from CinematicSequences.dbc
;     //uint32  Alliance;                                     // 13 (0 alliance, 1 horde, 2 not available?)
;     char* Name;                                             // 14 used for DBC language detection/selection
;     //char* Name_female;                                    // 15
;     //char* Name_male;                                      // 16
;     // uint32 FacialHairCustomization[2]                    // 17-18
;     // uint32 HairCustomization                             // 19
;     uint32  Race_related;                                   // 20
;     //uint32 UnalteredVisualRaceID                          // 21 (23 for worgens)
;     //uint32 UaMaleCreatureSoundDataID                      // 22 4.0.0
;     //uint32 UaFemaleCreatureSoundDataID                    // 23 4.0.0
; };

; struct ChrPowerTypesEntry
; {
;    uint32 ID;                                               // 0
;    uint32 ClassID;                                          // 1
;    uint32 PowerType;                                        // 2
; };

; 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;                                     // 4    Orientation in map used for basis for M2 co-ordinates
; };

; struct CinematicSequencesEntry
; {
;     uint32  ID;                                             // 0 index
;     //uint32 SoundID;                                       // 1 always 0
;     uint32  Camera[8];                                      // 2 id in CinematicCamera.dbc
; };

; struct CreatureDisplayInfoEntry
; {
;     uint32  ID;                                             // 0
;     uint32  ModelID;                                        // 1
;     // uint32 SoundID                                       // 2
;     uint32  ExtendedDisplayInfoID;                          // 3
;     float   CreatureModelScale;                             // 4
;     // uint32 CreatureModelAlpha                            // 5
;     // char* TextureVariation[3]                            // 6-8
;     // char* PortraitTextureName                            // 9
;     // uint32 SizeClass                                     // 10
;     // uint32 BloodID                                       // 11
;     // uint32 NPCSoundID                                    // 12
;     // uint32 ParticleColorID                               // 13
;     // uint32 CreatureGeosetData                            // 14
;     // uint32 ObjectEffectPackageID                         // 15
;     // uint32 AnimReplacementSetID                          // 16
; };

; 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
;     float   MinScale;                                       // 1
;     uint32  MinScaleLevel;                                  // 2
;     float   MaxScale;                                       // 3
;     uint32  MaxScaleLevel;                                  // 4
;     uint32  SkillLine[2];                                   // 5-6
;     uint32  PetFoodMask;                                    // 7
;     int32   PetTalentType;                                  // 8
;     // uint32 CategoryEnumID                                // 9
;     char* Name;                                             // 10
;     // char*  IconFile                                      // 11
; };

; struct CreatureModelDataEntry
; {
;     uint32 ID;                                              // 0
;     uint32 Flags;                                           // 1
;     char* ModelName;                                        // 2
;     // uint32 SizeClass;                                    // 3
;     float ModelScale;                                       // 4 Used in calculation of unit collision data
;     // uint32 BloodID                                       // 5
;     // uint32 FootprintTextureID                            // 6
;     // uint32 FootprintTextureLength                        // 7
;     // uint32 FootprintTextureWidth                         // 8
;     // float FootprintParticleScale                         // 9
;     // uint32 FoleyMaterialID                               // 10
;     // float FootstepShakeSize                              // 11
;     // uint32 DeathThudShakeSize                            // 12
;     // uint32 SoundID                                       // 13
;     // float CollisionWidth;                                // 14
;     float CollisionHeight;                                  // 15
;     float MountHeight;                                      // 16 Used in calculation of unit collision data when mounted
;     // float GeoBoxMin[3]                                   // 17 - 19
;     // float GeoBoxMax[3]                                   // 20 - 22
;     // float WorldEffectScale                               // 23
;     // float AttachedEffectScale                            // 24
;     // float MissileCollisionRadius                         // 25
;     // float MissileCollisionPush                           // 26
;     // float MissileCollisionRaise                          // 27
;     // float OverrideLootEffectScale                        // 28
;     // float OverrideNameScale                              // 29
;     float TamedPetBaseScale;                                // 30
; };

; struct CreatureSpellDataEntry
; {
;     uint32  ID;                                             // 0
;     uint32  Spells[4];                                      // 1-4
;     //uint32  Availability[4];                              // 4-7
; };

; struct CreatureTypeEntry
; {
;     uint32  ID;                                             // 0
;     //char* Name;                                           // 1
;     //uint32  Flags;                                        // 2
; };

; struct CurrencyCategoryEntry
; {
;     uint32  ID;                                             // 0
;     uint32  Flags;                                          // 1
;     char*   Name;                                           // 3
; };

; struct CurrencyTypesEntry
; {
;     uint32 ID;                                              // 0
;     uint32 CategoryID;                                      // 1
;     // char* Name;                                          // 2
;     // char* InventoryIcon1;                                // 3
;     // uint32 InventoryIcon2;                               // 4
;     // uint32 SpellWeight;                                  // 5
;     uint32 SpellCategory;                                   // 6
;     uint32 MaxQty;                                          // 7
;     uint32 MaxEarnablePerWeek;                              // 8
;     uint32 Flags;                                           // 9
;     //uint32 Description;                                   // 10
; };

; struct DestructibleModelDataEntry
; {
;     uint32  ID;                                             // 1
;     uint32  State0WMO;                                      // 2
;     //uint32  State0ImpactEffectDoodadSet;                  // 3
;     //uint32  State0AmbientDoodadSet;                       // 4
;     //uint32  State0NameSet;                                // 5
;     uint32  State1WMO;                                      // 6
;     //uint32  State1DestructionDoodadSet;                   // 7
;     //uint32  State1ImpactEffectDoodadSet;                  // 8
;     //uint32  State1AmbientDoodadSet;                       // 9
;     //uint32  State1NameSet;                                // 10
;     uint32  State2WMO;                                      // 11
;     //uint32  State2DestructionDoodadSet;                   // 12
;     //uint32  State2ImpactEffectDoodadSet;                  // 13
;     //uint32  State2AmbientDoodadSet;                       // 14
;     //uint32  State2NameSet;                                // 15
;     uint32  State3WMO;                                      // 16
;     //uint32  State3InitDoodadSet;                          // 17
;     //uint32  State3AmbientDoodadSet;                       // 18
;     //uint32  State3NameSet;                                // 19
;     //uint32  EjectDirection;                               // 20
;     //uint32  RepairGroundFx;                               // 21
;     //uint32  DoNotHighlight;                               // 22
;     //uint32  HealEffect;                                   // 23
;     //uint32  HealEffectSpeed;                              // 24
; };

; struct DungeonEncounterEntry
; {
;     uint32 ID;                                              // 0
;     uint32 MapID;                                           // 1
;     int32 DifficultyID;                                     // 2
;     // uint32 OrderIndex;                                   // 3
;     uint32 Bit;                                             // 4 used for creating completed masks
;     char* Name;                                             // 5        encounter name
;     //uint32 CreatureDisplayID;                             // 6
;     //uint32 SpellIconID;                                   // 7
; };

; struct DurabilityCostsEntry
; {
;     uint32    ID;                                           // 0
;     uint32    Multiplier[29];                               // 1-29 WeaponSubClassCost<32>[21] + ArmorSubClassCost<32>[8]
; };

; struct DurabilityQualityEntry
; {
;     uint32    ID;                                           // 0
;     float     Data;                                         // 1
; };

; struct EmotesEntry
; {
;     uint32  ID;                                             // 0
;     //char* EmoteSlashCommand;                              // 1, internal name
;     //uint32 AnimID;                                        // 2, ref to animationData
;     uint32  EmoteFlags;                                     // 3, bitmask, may be unit_flags
;     uint32  EmoteSpecProc;                                  // 4, Can be 0, 1 or 2 (determine how emote are shown)
;     uint32  EmoteSpecProcParam;                             // 5, uncomfirmed, may be enum UnitStandStateType
;     //uint32 EventSoundID;                                  // 6, ref to soundEntries
;     //uint32 SpellVisualKitID                               // 7
; };

; struct EmotesTextEntry
; {
;     uint32  ID;                                             // 0
;     // char* Name;                                          // 1
;     uint32  EmoteID;                                        // 2
;     // uint32 EmoteText[16];                                // 3 - 18
; };

; struct EmotesTextSoundEntry
; {
;     uint32 ID;                                              // 0
;     uint32 EmotesTextID;                                    // 1
;     uint32 RaceID;                                          // 2
;     uint32 SexID;                                           // 3 0 male / 1 female
;     uint32 SoundID;                                         // 4
; };

; struct FactionEntry
; {
;     uint32  ID;                                             // 0
;     int32   ReputationIndex;                                // 1
;     uint32  ReputationRaceMask[4];                          // 2 - 5
;     uint32  ReputationClassMask[4];                         // 6 - 9
;     int32   ReputationBase[4];                              // 10 - 13
;     uint32  ReputationFlags[4];                             // 14 - 17
;     uint32  ParentFactionID;                                // 18
;     float   ParentFactionMod[2];                            // 19 - 20 Faction gains incoming rep * spilloverRateIn and  Faction outputs rep * spilloverRateOut as spillover reputation
;     uint32  ParentFactionCap[2];                            // 21 - 22 The highest rank the faction will profit from incoming spillover and It does not seem to be the max standing at which a faction outputs spillover ...so no idea
;     char*   Name;                                           // 23
;     // char* Description;                                   // 24
;     uint32  Expansion;                                      // 25
; };

; struct FactionTemplateEntry
; {
;     uint32      ID;                                         // 0
;     uint32      Faction;                                    // 1
;     uint32      Flags;                                      // 2
;     uint32      FactionGroup;                               // 3
;     uint32      FriendGroup;                                // 4
;     uint32      EnemyGroup;                                 // 5
;     uint32      Enemies[4];                                 // 6
;     uint32      Friend[4];                                  // 10
; };

; struct GameObjectArtKitEntry
; {
;     uint32 ID;                                              // 0
;     //char* TextureVariation[3]                             // 1-3
;     //char* AttachModel[4]                                  // 4-8
; };

; struct GameObjectDisplayInfoEntry
; {
;     uint32  ID;                                             // 0
;     char*   ModelName;                                      // 1
;     // uint32  Sound[10];                                   // 2 - 11
;     DBCPosition3D GeoBoxMin;                                // 12 - 14
;     DBCPosition3D GeoBoxMax;                                // 15 - 17
;     // uint32  ObjectEffectPackageID;                       // 18
;     // float  OverrideLootEffectScale;                      // 19
;     // float  OverrideNameScale;                            // 20
; };

; struct GemPropertiesEntry
; {
;     uint32  ID;                                             // 0
;     uint32  Enchant_ID;                                     // 1
;     // uint32 Maxcount_inv;                                 // 2
;     // uint32  Maxcount_item;                               // 3
;     uint32  Type;                                           // 4
;     uint32  Min_item_level;                                 // 5
; };

; struct GlyphPropertiesEntry
; {
;     uint32  ID;                                             // 0
;     uint32  SpellID;                                        // 1
;     uint32  GlyphSlotFlags;                                 // 2
;     uint32  SpellIconID;                                    // 3 GlyphIconId (SpellIcon.dbc)
; };

; struct GlyphSlotEntry
; {
;     uint32  ID;                                             // 0
;     uint32  Type;                                           // 1
;     uint32  Tooltip;                                        // 2
; };

; // 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
; {
;     //uint32 level;
;     float   cost;
; };

; struct GtCombatRatingsEntry
; {
;     //uint32 level;
;     float    ratio;
; };

; struct GtChanceToMeleeCritBaseEntry
; {
;     //uint32 level;
;     float    base;
; };

; struct GtChanceToMeleeCritEntry
; {
;     //uint32 level;
;     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 gtOCTHpPerStaminaEntry
; {
;     float    ratio;
; };

; struct GtRegenHPPerSptEntry
; {
;     float    ratio;
; };

; struct GtRegenMPPerSptEntry
; {
;     float    ratio;
; };

; struct GtSpellScalingEntry
; {
;     float value;
; };

; struct GtOCTBaseHPByClassEntry
; {
;     float ratio;
; };

; struct GtOCTBaseMPByClassEntry
; {
;     float ratio;
; };

; struct GuildPerkSpellsEntry
; {
;     // uint32 ID;                                           // 0
;     uint32  GuildLevel;                                     // 1
;     uint32  SpellID;                                        // 2
; };

; /* not used
; struct HolidayDescriptionsEntry
; {
;     uint32  ID;                                             // 0
;     //char* Description                                     // 1
; };
*/

; struct HolidayNamesEntry
; {
;     uint32  ID;                                             // 0
;     //char* Name                                            // 1
; };

; struct HolidaysEntry
; {
;     uint32 ID;                                              // 0
;     uint32 Duration[10];                                    // 1-10
;     uint32 Date[26];                                         // 11-36 (dates in unix time starting at January, 1, 2000)
;     uint32 Region;                                          // 37 (wow region)
;     uint32 Looping;                                         // 38
;     uint32 CalendarFlags[10];                               // 39-48
;     //uint32 HolidayNameID;                                 // 49 (HolidayNames.dbc)
;     //uint32 HolidayDescriptionID;                          // 50 (HolidayDescriptions.dbc)
;     char* TextureFilename;                                  // 51
;     uint32 Priority;                                        // 52
;     int32 CalendarFilterType;                               // 53 (-1 = Fishing Contest, 0 = Unk, 1 = Darkmoon Festival, 2 = Yearly holiday)
;     //uint32 Flags;                                         // 54 (0 = Darkmoon Faire, Fishing Contest and Wotlk Launch, rest is 1)
; };

; // ImportPriceArmor.dbc
; struct ImportPriceArmorEntry
; {
;     uint32 ID;                                              // 0        Id/InventoryType
;     float ClothModifier;                                    // 1        Price factor cloth
;     float LeatherModifier;                                  // 2        Price factor leather
;     float ChainModifier;                                    // 3        Price factor mail
;     float PlateModifier;                                    // 4        Price factor plate
; };

; // ImportPriceQuality.dbc
; struct ImportPriceQualityEntry
; {
;     uint32 QualityId;                                       // 1        Quality Id (+1?)
;     float Factor;                                           // 2        Price factor
; };

; // ImportPriceShield.dbc
; struct ImportPriceShieldEntry
; {
;     uint32 ID;                                              // 1
;     float Data;                                             // 2        Price factor
; };

; // ImportPriceWeapon.dbc
; struct ImportPriceWeaponEntry
; {
;     uint32 ID;                                              // 1        Unk id (mainhand - 0, offhand - 1, weapon - 2, 2hweapon - 3, ranged/rangedright/relic - 4)
;     float Data;                                             // 2        Price factor
; };

; // ItemPriceBase.dbc
; struct ItemPriceBaseEntry
; {
;     // uint32 ID;                                           // 0
;     uint32 ItemLevel;                                       // 1        Item level (1 - 1000)
;     float Armor;                                            // 2        Price factor for armor
;     float Weapon;                                           // 3        Price factor for weapons
; };

; struct ItemReforgeEntry
; {
;     uint32 ID;                                              // 0
;     uint32 Source_stat;                                     // 1
;     float Source_multiplier;                                // 2
;     uint32 Target_stat;                                     // 3
;     float Target_multiplier;                                // 4
; };

; // common struct for:
; // ItemDamageAmmo.dbc
; // ItemDamageOneHand.dbc
; // ItemDamageOneHandCaster.dbc
; // ItemDamageRanged.dbc
; // ItemDamageThrown.dbc
; // ItemDamageTwoHand.dbc
; // ItemDamageTwoHandCaster.dbc
; // ItemDamageWand.dbc
; struct ItemDamageEntry
; {
;     uint32    ID;                                           // 0 item level
;     float     Quality[7];                                   // 1-7 multiplier for item quality
;     uint32    ItemLevel;                                    // 8 item level
; };

; struct ItemArmorQualityEntry
; {
;     uint32    ID;                                           // 0
;     float     Qualitymod[7];                                // 1-7 multiplier for item quality
;     uint32    ItemLevel;                                    // 8 item level
; };

; struct ItemArmorShieldEntry
; {
;     uint32    ID;                                           // 0
;     uint32    ItemLevel;                                    // 1 item level
;     float     Quality[7];                                   // 2-8 multiplier for item quality
; };

; struct ItemArmorTotalEntry
; {
;     uint32    ID;                                           // 0
;     uint32    ItemLevel;                                    // 1 item level
;     float     Value[4];                                     // 2-5 multiplier for armor types (cloth...plate)
; };

; // ItemClass.dbc
; struct ItemClassEntry
; {
;     // uint32  ID;                                          // 0
;     uint32  ClassID;                                        // 1 item class id
;     //uint32  SubclassMapID;                                // 2
;     //uint32  Flags;                                        // 3 1 for weapon, 0 for everything else
;     float  PriceModifier;                                   // 4 used to calculate certain prices
;     //char*  ClassName;                                     // 5 class name
; };

; struct ItemBagFamilyEntry
; {
;     uint32  ID;                                             // 0
;     //char* Name;                                           // 1
; };

; struct ItemDisplayInfoEntry
; {
;     uint32  ID;                                             // 0
;     // char* ModelName[2];                                  // 1 - 2
;     // char* ModelTexture[2];                               // 3 - 4
;     // char* InventoryIcon[2];                              // 5 - 6
;     // uint32 GeosetGroup[2];                               // 7 - 8
;     // uint32 Flags;                                        // 9
;     // uint32 SpellVisualID;                                // 10
;     // uint32 GroupSoundIndex;                              // 11
;     // uint32 HelmetGeosetVisID[2];                         // 12 - 13
;     // char* Texture[8]                                     // 14 - 21
;     // uint32 ItemVisual;                                   // 22
;     // uint32 ParticleColorID;                              // 23
; };

; struct ItemDisenchantLootEntry
; {
;     uint32 ID;                                              // 0
;     uint32 Class;                                           // 1
;     int32 Subclass;                                         // 2
;     uint32 Quality;                                         // 3
;     uint32 MinLevel;                                        // 4
;     uint32 MaxLevel;                                        // 5
;     uint32 SkillRequired;                                   // 6
; };

; struct ItemLimitCategoryEntry
; {
;     uint32  ID;                                             // 0
;     //char* Name;                                           // 1
;     uint32  Quantity;                                       // 2 max allowed equipped as item or in gem slot
;     uint32  Flags;                                          // 3 0 = have, 1 = equip (enum ItemLimitCategoryMode)
; };

; struct ItemRandomPropertiesEntry
; {
;     uint32  ID;                                             // 0
;     //char* Name                                            // 1
;     uint32  Enchantment[5];                                 // 2 - 6
;     char*   Name;                                           // 7
; };

; struct ItemRandomSuffixEntry
; {
;     uint32 ID;                                              // 0
;     char*  Name;                                            // 1
;     // char* InternalName                                   // 2
;     uint32  Enchantment[5];                                 // 3 - 7
;     uint32  AllocationPct[5];                               // 8 - 12
; };

; struct ItemSetEntry
; {
;     //uint32  ID                                            // 0
;     char*   Name;                                           // 1
;     uint32  ItemID[17];                                     // 2-18
;     uint32  SetSpellID[8];                                  // 19-26
;     uint32  SetThreshold[8];                                // 27-34
;     uint32  RequiredSkill;                                  // 35
;     uint32  RequiredSkillRank;                              // 36
; };

; struct LFGDungeonEntry
; {
;     uint32  ID;                                             // 0
;     char* Name;                                             // 1
;     uint32  MinLevel;                                       // 2
;     uint32  Maxlevel;                                       // 3
;     uint32  Target_level;                                   // 4
;     uint32  Target_level_min;                               // 5
;     uint32  Target_level_max;                               // 6
;     int32   MapID;                                          // 7
;     uint32  DifficultyID;                                   // 8
;     uint32  Flags;                                          // 9
;     uint32  TypeID;                                         // 10
;     //uint32  Faction;                                      // 11
;     //char*   TextureFilename;                              // 12
;     uint32  ExpansionLevel;                                 // 13
;     //uint32  Order_index;                                  // 14
;     uint32  Group_ID;                                       // 15
;     //char*   Description;                                  // 16 Description
;     uint32  Random_ID;                                      // 17 RandomDungeonID assigned for this dungeon
;     uint32  Count_tank;                                     // 18
;     uint32  Count_healer;                                   // 19
;     uint32  Count_damage;                                   // 20
; };

; struct LFGDungeonsGroupingMapEntry
; {
;     uint32 ID;                                              // 0
;     uint32 LfgDungeonsID;                                   // 1
;     uint32 Random_lfgDungeonsID;                            // 2
;     uint32 Group_ID;                                        // 3
; };

; struct LightEntry
; {
;     uint32  ID;                                             // 0
;     uint32  ContinentID;                                    // 1
;     float   X;                                              // 2
;     float   Y;                                              // 3
;     float   Z;                                              // 4
;     // float FalloffStart;                                  // 5
;     // float FalloffEnd;                                    // 6
;     // uint32 LightParamsID[8];                             // 7 - 14
; };

; struct LiquidTypeEntry
; {
;     uint32 ID;                                              // 1
;     //char*  Name;                                          // 2
;     //uint32 Flags;                                         // 3
;     uint32 SoundBank;                                       // 4
;     //uint32 SoundID;                                       // 5
;     uint32 SpellID;                                         // 6
;     //float MaxDarkenDepth;                                 // 7
;     //float FogDarkenIntensity;                             // 8
;     //float AmbDarkenIntensity;                             // 9
;     //float DirDarkenIntensity;                             // 10
;     //uint32 LightID;                                       // 11
;     //float ParticleScale;                                  // 12
;     //uint32 ParticleMovement;                              // 13
;     //uint32 ParticleTexSlots;                              // 14
;     //uint32 MaterialID;                                    // 15
;     //char* Texture[6];                                     // 16 - 20
;     //uint32 Color[2];                                      // 21 - 22
;     //float Float[18];                                      // 23 - 40
;     //uint32 Int[4];                                        // 41 - 44
; };

; struct LockEntry
; {
;     uint32  ID;                                             // 0
;     uint32  Type[8];                                        // 1-8
;     uint32  Index[8];                                       // 9-16
;     uint32  Skill[8];                                       // 17-24
;     //uint32  Action[8];                                    // 25-32
; };

; struct PhaseEntry
; {
;     uint32  ID;                                             // 0
;     char*   Name;                                           // 1
;     uint32  Flags;                                          // 2
; };

; struct PhaseGroupEntry
; {
;     uint32 ID;                                              // 1
;     uint32 PhaseID;                                         // 2
;     uint32 PhaseGroupID;                                    // 3
; };

; struct MailTemplateEntry
; {
;     uint32  ID;                                             // 0
;     //char*  Subject;                                       // 1
;     char*   Body;                                           // 2
; };

; struct MapEntry
; {
;     uint32 ID;                                              // 0
;     char const* Directory;                                  // 1
;     uint32 MapType;                                         // 2
;     uint32 Flags;                                           // 3
;     uint32 InstanceType;                                    // 4
;     uint32 PVP;                                             // 5  0 or 1 for battlegrounds (not arenas)
;     char const* MapName;                                    // 6
;     uint32 AreaTableID;                                     // 7
;     char const* MapDescription0;                            // 8  Horde
;     char const* MapDescription1;                            // 9  Alliance
;     uint32 LoadingScreenID;                                 // 10  (LoadingScreens.dbc)
;     float MinimapIconScale;                                 // 11
;     int32 CorpseMapID;                                      // 12 map_id of entrance map in ghost mode (continent always and in most cases = normal entrance)
;     DBCPosition2D Corpse;                                   // 13 - 14  entrance coordinates in ghost mode  (in most cases = normal entrance)
;     uint32 TimeOfDayOverride;                               // 15
;     uint32 ExpansionID;                                     // 16
;     uint32 RaidOffset;                                      // 17
;     uint32 MaxPlayers;                                      // 18
;     int32 ParentMapID;                                      // 19
; };

; struct MapDifficultyEntry
; {
;     //uint32  ID;                                           // 0
;     uint32  MapID;                                          // 1
;     uint32  Difficulty;                                     // 2  (for arenas: arena slot)
;     char*   Message;                                        // 3  (text showed when transfer to map failed)
;     uint32  RaidDuration;                                   // 4  in secs, 0 if no fixed reset time
;     uint32  MaxPlayers;                                     // 5  some heroic versions have 0 when expected same amount as in normal version
;     //char*   Difficultystring;                             // 6
; };

; struct MountCapabilityEntry
; {
;     uint32 ID;                                              // 1
;     uint32 Flags;                                           // 2
;     uint32 ReqRidingSkill;                                  // 3
;     uint32 ReqAreaID;                                       // 4
;     uint32 ReqSpellAuraID;                                  // 5
;     uint32 ReqSpellKnownID;                                 // 6
;     uint32 ModSpellAuraID;                                  // 7
;     int32  ReqMapID;                                        // 8
; };

; struct MountTypeEntry
; {
;     uint32 ID;
;     uint32 Capability[24];
; };

; struct MovieEntry
; {
;     uint32  ID;                                             // 0 index
;     //char*   Filename;                                     // 1
;     //uint32  Volume;                                       // 2
;     //uint32  KeyID;                                        // 3
; };

; struct NameGenEntry
; {
;     //uint32  ID;                                           // 1
;     char*   Name;                                           // 2
;     uint32  RaceID;                                         // 3
;     uint32  Sex;                                            // 4
; };

; struct NumTalentsAtLevelEntry
; {
;     //uint32 Level;                                         // 0 index
;     float NumberOfTalents;                                  // 1 talent count
; };

; struct NamesProfanityEntry
; {
;     // uint32    ID;                                        // 0
;     char const* Name;                                       // 1
;     int32       Language;                                   // 2
; };

; struct NamesReservedEntry
; {
;     // uint32    ID;                                        // 0
;     char const* Name;                                       // 1
;     int32       Language;                                   // 2
; };

; struct OverrideSpellDataEntry
; {
;     uint32  ID;                                             // 0
;     uint32  Spells[10];                                     // 1-10
;     // uint32  Flags;                                       // 11
;     // char*   PlayerActionbar;                             // 12
; };

; struct PlayerConditionEntry
; {
;     uint32 ID;                                              // 0
;     char* FailureDescription;                               // 1
; };

; struct PowerDisplayEntry
; {
;     uint32  ID;                                             // 0
;     uint32  ActualType;                                     // 1
;     // char*  GlobalStringBaseTag;                          // 2
;     // uint8 Red;                                           // 3
;     // uint8 Green;                                         // 4
;     // uint8 Blue;                                          // 5
;     // uint8 Padding                                        // 6
; };

; struct PvPDifficultyEntry
; {
;     //uint32  ID;                                           // 0
;     uint32  MapID;                                          // 1
;     uint32  RangeIndex;                                     // 2
;     uint32  MinLevel;                                       // 3
;     uint32  MaxLevel;                                       // 4
;     uint32  Difficulty;                                     // 5
; };

; struct QuestSortEntry
; {
;     uint32  ID;                                             // 0
;     //char*   SortName;                                     // 1
; };

; struct QuestXPEntry
; {
;     uint32  ID;                                             // 0
;     uint32  Difficulty[10];                                 // 1 - 10
; };

; struct QuestFactionRewEntry
; {
;     uint32  ID;                                             // 0
;     int32   Difficulty[10];                                 // 1 - 11
; };

; struct QuestPOIBlobEntry
; {
;     uint32  ID;                                             // 0
;     uint32  NumPoints;                                      // 1
;     uint32  MapID;                                          // 2
;     uint32  WorldMapAreaID;                                 // 3
; };

; struct QuestPOIPointEntry
; {
;     uint32  ID;                                             // 0
;     int32   X;                                              // 1
;     int32   Y;                                              // 2
;     uint32  QuestPOIBlobID;                                 // 3
; };

; 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
; };

; // ResearchBranch.dbc
; struct ResearchBranchEntry
; {
;     uint32  ID;                                             // 0
;     char*   Name;                                           // 1
;     uint32  ResearchFieldID;                                // 2
;     uint32  CurrencyID;                                     // 3
;     char*   Texture;                                        // 4
;     uint32  ItemID;                                         // 5
; };

; // ResearchField.dbc
; struct ResearchFieldEntry
; {
;     uint32 ID;                                              // 0
;     char*  Name;                                            // 1
;     uint32 Slot;                                            // 2
; };

; // ResearchProject.dbc
; struct ResearchProjectEntry
; {
;     uint32  ID;                                             // 0
;     char*   Name;                                           // 1
;     char*   Description;                                    // 2
;     uint32  Rarity;                                         // 3
;     uint32  ResearchBranchID;                               // 4
;     uint32  SpellID;                                        // 5
;     uint32  NumSockets;                                     // 6
;     char*   Texture;                                        // 7
;     uint32  RequiredWeight;                                 // 8
; };

; // ResearchSite.dbc
; struct ResearchSiteEntry
; {
;     uint32  ID;                                             // 1
;     uint32  MapID;                                          // 2
;     uint32  QuestPOIBlobID;                                 // 3
;     char*   Name;                                           // 4
;     char*   AreaPOIIconEnum;                                // 5
; };

; struct ScalingStatDistributionEntry
; {
;     uint32  ID;                                             // 0
;     int32   StatID[10];                                     // 1 - 10
;     uint32  Bonus[10];                                      // 11 - 20
;     uint32  Minlevel;                                       // 21
;     uint32  Maxlevel;                                       // 22
; };

; struct ScalingStatValuesEntry
; {
;     uint32 ID;                                              // 0
;     uint32 Charlevel;                                       // 1
;     uint32 dpsMod[6];                                       // 2 - 7 DPS mod for level
;     uint32 Spellpower;                                      // 8 spell power for level
;     uint32 StatMultiplier[5];                               // 9 - 13 Multiplier for ScalingStatDistribution
;     uint32 Armor[8][4];                                     // 14 - 46 Armor for level
;     uint32 CloakArmor;                                      // 47 armor for cloak
; };

; struct SkillLineCategoryEntry
; {
;     uint32    id;                                           // 0
;     char*     name;                                         // 1
;     uint32    displayOrder;                                 // 2
; };

; struct SkillLineEntry
; {
;     uint32  ID;                                             // 0
;     int32   CategoryID;                                     // 1
;     char*   DisplayName;                                    // 3
;     //char*  Description;                                   // 4
;     uint32  SpellIconID;                                    // 5
;     //char*   AlternateVerb;                                // 6
;     uint32  CanLink;                                        // 7 (prof. with recipe)
; };

; 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 NumSkillUps;                                     // 12
;     uint32 UniqueBit;                                       // 13
; };

; struct SkillRaceClassInfoEntry
; {
;     //uint32 ID;                                            // 0
;     uint32 SkillID;                                         // 1
;     uint32 RaceMask;                                        // 2
;     uint32 ClassMask;                                       // 3
;     uint32 Flags;                                           // 4
;     uint32 Availability;                                    // 5
;     //uint32 MinLevel;                                      // 6
;     uint32 SkillTierID;                                     // 7
;     //uint32 SkillCostIndex;                                // 8
; };

; struct SkillTiersEntry
; {
;     uint32 ID;                                              // 0
;     //uint32 Cost[16];                                      // 1-16
;     uint32 Value[16];                                       // 17-32
; };

; struct SoundEntriesEntry
; {
;     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
;     //float   Volumevariationplus;                          // 30
;     //float   Volumevariationminus;                         // 31
;     //float   Pitchvariationplus;                           // 32
;     //float   Pitchvariationminus;                          // 33
;     //float   PitchAdjust;                                  // 34
; };

; // SpellEffect.dbc
; struct SpellEffectEntry
; {
;     uint32    ID;                                           // 0
;     uint32    Effect;                                       // 1
;     float     EffectAmplitude;                              // 2
;     uint32    EffectAura;                                   // 3
;     uint32    EffectAuraPeriod;                             // 4
;     int32     EffectBasePoints;                             // 5
;     float     EffectBonusCoefficient;                       // 6
;     float     EffectChainAmplitude;                         // 7
;     uint32    EffectChainTargets;                           // 8
;     int32     EffectDieSides;                               // 9
;     uint32    EffectItemType;                               // 10
;     uint32    EffectMechanic;                               // 11
;     int32     EffectMiscValue;                              // 12
;     int32     EffectMiscValueB;                             // 13
;     float     EffectPointsPerResource;                      // 14
;     uint32    EffectRadiusIndex;                            // 15
;     uint32    EffectRadiusMaxIndex;                         // 16
;     float     EffectRealPointsPerLevel;                     // 17
;     flag96    EffectSpellClassMask;                         // 18 - 20
;     uint32    EffectTriggerSpell;                           // 21
;     uint32    EffectImplicitTargetA;                        // 22
;     uint32    EffectImplicitTargetB;                        // 23
;     uint32    SpellID;                                      // 24
;     uint32    EffectIndex;                                  // 25
;     //uint32  EffectAttributes                              // 26
; };

; // SpellAuraOptions.dbc
; struct SpellAuraOptionsEntry
; {
;     uint32    ID;                                           // 0
;     uint32    CumulativeAura;                               // 1
;     uint32    ProcChance;                                   // 2
;     uint32    ProcCharges;                                  // 3
;     uint32    ProcTypeMask;                                 // 4
; };

; // SpellAuraRestrictions.dbc/
; struct SpellAuraRestrictionsEntry
; {
;     //uint32  ID;                                           // 0
;     uint32  CasterAuraState;                                // 1
;     uint32  TargetAuraState;                                // 2
;     uint32  ExcludeCasterAuraState;                         // 3
;     uint32  ExcludeTargetAuraState;                         // 4
;     uint32  CasterAuraSpell;                                // 5
;     uint32  TargetAuraSpell;                                // 6
;     uint32  ExcludeCasterAuraSpell;                         // 7
;     uint32  ExcludeTargetAuraSpell;                         // 8
; };

; // SpellCastingRequirements.dbc
; struct SpellCastingRequirementsEntry
; {
;     uint32  ID;                                             // 0
;     uint32  FacingCasterFlags;                              // 1
;     uint32  MinFactionID;                                   // 2
;     uint32  MinReputation;                                  // 3
;     int32   RequiredAreasID;                                // 4
;     uint32  RequiredAuraVision;                             // 5
;     uint32  RequiresSpellFocus;                             // 6
; };

; // SpellTotems.dbc
; struct SpellTotemsEntry
; {
;     uint32  ID;                                             // 0
;     uint32  RequiredTotemCategoryID[2];                     // 1
;     uint32  Totem[2];                                       // 2
; };

; // Spell.dbc
; struct SpellEntry
; {
;     uint32  ID;                                             // 0
;     uint32  Attributes;                                     // 1
;     uint32  AttributesEx;                                   // 2
;     uint32  AttributesEx2;                                  // 3
;     uint32  AttributesEx3;                                  // 4
;     uint32  AttributesEx4;                                  // 5
;     uint32  AttributesEx5;                                  // 6
;     uint32  AttributesEx6;                                  // 7
;     uint32  AttributesEx7;                                  // 8
;     uint32  AttributesEx8;                                  // 9
;     uint32  AttributesEx9;                                  // 1
;     uint32  AttributesEx10;                                 // 1
;     uint32  CastingTimeIndex;                               // 1
;     uint32  DurationIndex;                                  // 1
;     uint32  PowerType;                                      // 1
;     uint32  RangeIndex;                                     // 1
;     float   Speed;                                          // 1
;     uint32  SpellVisualID[2];                               // 17 - 18
;     uint32  SpellIconID;                                    // 19
;     uint32  ActiveIconID;                                   // 20
;     char*   Name;                                           // 21
;     char*   NameSubtext;                                    // 22
;     //char* Description;                                    // 23
;     //char* AuraDescription;                                // 24
;     uint32  SchoolMask;                                     // 25
;     uint32  RuneCostID;                                     // 26
;     //uint32  SpellMissileID;                               // 27
;     //uint32  DescriptionVariablesID;                       // 28
;     uint32  Difficulty;                                     // 29
;     float   BonusCoefficient;                               // 30
;     uint32  ScalingID;                                      // 31
;     uint32  AuraOptionsID;                                  // 32
;     uint32  AuraRestrictionsID;                             // 33
;     uint32  CastingRequirementsID;                          // 34
;     uint32  CategoriesID;                                   // 35
;     uint32  ClassOptionsID;                                 // 36
;     uint32  CooldownsID;                                    // 37
;     //uint32  unkIndex7;                                    // 38
;     uint32  EquippedItemsID;                                // 39
;     uint32  InterruptsID;                                   // 40
;     uint32  LevelsID;                                       // 41
;     uint32  PowerDisplayID;                                 // 42
;     uint32  ReagentsID;                                     // 43
;     uint32  ShapeshiftID;                                   // 44
;     uint32  TargetRestrictionsID;                           // 45
;     uint32  TotemsID;                                       // 46
;     uint32  RequiredProjectID;                              // 47
; };

; // SpellCategories.dbc
; struct SpellCategoriesEntry
; {
;     //uint32    ID;                                         // 0
;     uint32    Category;                                     // 1
;     uint32    DefenseType;                                  // 2
;     uint32    DispelType;                                   // 3
;     uint32    Mechanic;                                     // 4
;     uint32    PreventionType;                               // 5
;     uint32    StartRecoveryCategory;                        // 6
; };

; struct SpellCastTimesEntry
; {
;     uint32  ID;                                             // 0
;     int32   Base;                                           // 1
;     //int32  PerLevel;                                      // 2
;     //int32  Minimum;                                       // 3
; };

; struct SpellCategoryEntry
; {
;     uint32 ID;                                              // 0
;     uint32 Flags;                                           // 1
;     uint32 UsesPerWeek;                                     // 2
;     // char* Name;                                          // 3
; };

; struct SpellDifficultyEntry
; {
;     uint32     ID;                                          // 0
;     int32      DifficultySpellID[4];                        // 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*   Name;                                         // 1
; };

; struct SpellRadiusEntry
; {
;     uint32  ID;                                             // 0
;     float   RadiusMin;                                      // 1
;     float   RadiusPerLevel;                                 // 2
;     float   RadiusMax;                                      // 3
; };

; struct SpellRangeEntry
; {
;     uint32  ID;                                             // 1
;     float   RangeMin[2];                                    // 2 - 3
;     float   RangeMax[2];                                    // 4 - 5
;     uint32  Flags;                                          // 6
;     //char*   DisplayName;                                  // 7
;     //char*   DisplayNameShort;                             // 8
; };

; // SpellEquippedItems.dbc
; struct SpellEquippedItemsEntry
; {
;     //uint32  ID;                                           // 1
;     int32   EquippedItemClass;                              // 2
;     int32   EquippedItemInvTypes;                           // 3
;     int32   EquippedItemSubclass;                           // 4
; };

; // SpellCooldowns.dbc
; struct SpellCooldownsEntry
; {
;     //uint32  ID;                                           // 0
;     uint32  CategoryRecoveryTime;                           // 1
;     uint32  RecoveryTime;                                   // 2
;     uint32  StartRecoveryTime;                              // 3
; };

; // SpellClassOptions.dbc
; struct SpellClassOptionsEntry
; {
;     //uint32  ID;                                           // 0
;     //uint32  ModalNextSpell;                               // 1
;     flag96  SpellFamilyMask;                                // 2-4
;     uint32  SpellClassSet;                                  // 5
;     //char*   Description;                                  // 6
; };

; // SpellInterrupts.dbc
; struct SpellInterruptsEntry
; {
;     //uint32  ID;                                           // 0
;     uint32  AuraInterruptFlags[2];                          // 1 - 2
;     uint32  ChannelInterruptFlags[2];                       // 3 - 4
;     uint32  InterruptFlags;                                 // 5
; };

; // SpellLevels.dbc
; struct SpellLevelsEntry
; {
;     //uint32  ID;                                           // 0
;     uint32  BaseLevel;                                      // 1
;     uint32  MaxLevel;                                       // 2
;     uint32  SpellLevel;                                     // 3
; };

; // SpellPower.dbc
; struct SpellPowerEntry
; {
;     //uint32  ID;                                           // 0
;     uint32  ManaCost;                                       // 1
;     uint32  ManaCostPerLevel;                               // 2
;     uint32  PowerCostPct;                                   // 3
;     uint32  ManaPerSecond;                                  // 4
;     //uint32  PowerDisplayID;                               // 5
;     //uint32  AltPowerBarID;                                // 6
;     float   PowerCostPct2;                                  // 7
; };

; struct SpellRuneCostEntry
; {
;     uint32  ID;                                             // 0
;     uint32  RuneCost[3];                                    // 1 - 3 (0 = blood, 1 = frost, 2 = unholy)
;     uint32  RunicPower;                                     // 4
; };

; struct SpellShapeshiftFormEntry
; {
;     uint32  ID;                                             // 0
;     //uint32  BonusActionBar;                               // 1 unused
;     //char*   Name;                                         // 2 unused
;     uint32  Flags;                                          // 3
;     int32   CreatureType;                                   // 4 <= 0 humanoid, other normal creature types
;     //uint32  AttackIconID;                                 // 5 unused, related to next field
;     uint32  CombatRoundTime;                                // 6
;     uint32  CreatureDisplayID[4];                           // 7 - 10
;     uint32  PresetSpellID[8];                               // 11 - 18 spells which appear in the bar after shapeshifting
;     uint32  MountTypeID;                                    // 19
;     //uint32  ExitSoundEntriesID;                           // 20
; };

; // SpellShapeshift.dbc
; struct SpellShapeshiftEntry
; {
;     uint32  ID;                                             // 0
;     uint32  ShapeshiftExclude[2];                           // 1
;     uint32  ShapeshiftMask[2];                              // 3
;     // uint32  StanceBarOrder;                              // 5
; };

; // SpellTargetRestrictions.dbc
; struct SpellTargetRestrictionsEntry
; {
;     uint32  ID;                                             // 0
;     float   ConeAngle;                                      // 1
;     uint32  MaxTargets;                                     // 2
;     uint32  MaxTargetLevel;                                 // 3
;     uint32  TargetCreatureType;                             // 4
;     uint32  Targets;                                        // 5
; };

; // SpellReagents.dbc
; struct SpellReagentsEntry
; {
;     //uint32  ID;                                           // 0
;     int32   Reagents[8];                                    // 1 - 8
;     uint32  ReagentCount[8];                                // 9 - 16
; };

; // SpellScaling.dbc
; struct SpellScalingEntry
; {
;     //uint32  ID;                                           // 0        m_ID
;     int32   CastTimeMin;                                    // 1
;     int32   CastTimeMax;                                    // 2
;     int32   CastTimeMaxLevel;                               // 3
;     int32   Class;                                          // 4        (index * 100) + charLevel - 1 => gtSpellScaling.dbc
;     float   Coefficient[3];                                 // 5 - 7
;     float   Variance[3];                                    // 8 - 10
;     float   ComboPointsCoefficient[3];                      // 11 - 13
;     float   NerfFactor;                                     // 14        some coefficient, mostly 1.0f
;     int32   NerfMaxLevel;                                   // 15        some level
; };

; struct SpellDurationEntry
; {
;     uint32  ID;                                             // 0
;     int32   Duration;                                       // 1
;     int32   DurationPerLevel;                               // 2
;     int32   MaxDuration;                                    // 3
; };

; struct SpellItemEnchantmentEntry
; {
;     uint32  ID;                                             // 0
;     //uint32  Charges;                                      // 1
;     uint32  Effect[3];           // 2 - 4
;     uint32  EffectPointsMin[3];  // 5 - 7
;     //uint32  EffectPointsMax[3];// 8 - 10
;     uint32  EffectArg[3];        // 11 - 13
;     char*   Name;                                           // 14
;     uint32  ItemVisual;                                     // 15
;     uint32  Flags;                                          // 16
;     uint32  Src_itemID;                                     // 17
;     uint32  Condition_ID;                                   // 18
;     uint32  RequiredSkillID;                                // 19
;     uint32  RequiredSkillRank;                              // 20
;     uint32  MinLevel;                                       // 21
;     //uint32 ItemLevel;                                     // 22
; };

; struct SpellItemEnchantmentConditionEntry
; {
;     uint32  ID;                                             // 0        m_ID
;     uint8   Color[3];                                       // 1-3      m_lt_operandType[5]
;     //uint8   unk1;                                         // 4
;     //uint32  unk2[6];                                      // 5-10
;     uint8   Comparator[3];                                  // 11-13    m_operator[5]
;     //uint8   unk3[2];                                      // 14-15
;     uint8   CompareColor[3];                                // 16-18    m_rt_operandType[5]
;     //uint32  unk4;                                         // 19
;     uint32  Value[3];                                       // 20-22    m_rt_operand[5]
;     //uint32  unk5[2];                                      // 23-24
;     //uint8   unk6[6];                                      // 25-30
; };

; struct SpellVisualEntry
; {
;     //uint32  ID;
;     //uint32  PrecastKit;
;     //uint32  CastKit;
;     //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 AlternativeVisualID;
; };

; struct SpellVisualKitEntry
; {
;     uint32 ID;
;     uint32 StartAnimID;
;     uint32 AnimID;
;     uint32 AnimKitID;
;     uint32 HeadEffect;
;     uint32 ChestEffect;
;     uint32 BaseEffect;
;     uint32 LeftHandEffect;
;     uint32 RightHandEffect;
;     uint32 BreathEffect;
;     uint32 LeftWeaponEffect;
;     uint32 RightWeaponEffect;
;     uint32 SpecialEffect[3];
;     uint32 WorldEffect;
;     uint32 SoundID;
;     uint32 ShakeID;
;     uint32 CharProc[4];
;     uint32 CharParamZero[4];
;     uint32 CharParamOne[4];
;     uint32 CharParamTwo[4];
;     uint32 CharParamThree[4];
;     uint32 Flags;
; };

; struct SummonPropertiesEntry
; {
;     uint32  ID;                                             // 0
;     uint32  Control;                                        // 1, 0 - can't be controlled?, 1 - something guardian?, 2 - pet?, 3 - something controllable?, 4 - taxi/mount?
;     uint32  Faction;                                        // 2, 14 rows > 0
;     int32   Title;                                          // 3, see enum
;     int32   Slot;                                           // 4, 0-6
;     uint32  Flags;                                          // 5
; };

; struct TalentEntry
; {
;     uint32  ID;                                             // 0
;     uint32  TabID;                                          // 1 index in TalentTab.dbc (TalentTabEntry)
;     uint32  TierID;                                         // 2
;     uint32  ColumnIndex;                                    // 3
;     uint32  SpellRank[MAX_TALENT_RANK];                     // 4-8
;     uint32  PrereqTalent[3];                                // 9 - 11 (Talent.dbc)
;     uint32  PrereqRank[3];                                  // 12 - 14 part of prev field
;     //uint32  Flags;                                        // 15  also need disable higest ranks on reset talent tree
;     //uint32  RequiredSpellID;                              // 16
;     //uint64  CategoryMask[2];                              // 17 - 18 its a 64 bit mask for pet 1 << m_categoryEnumID in CreatureFamily.dbc
; };

; struct TalentTabEntry
; {
;     uint32  ID;                                             // 0
;     //char* Name;                                           // 1
;     //unit32  SpellIconID;                                  // 2
;     uint32  ClassMask;                                      // 3
;     uint32  CategoryEnumID;                                 // 4
;     uint32  OrderIndex;                                     // 5
;     //char* BackgroundFile;                                 // 6
;     //char* Description;                                    // 7
;     //uint32 RoleMask;                                      // 8
;     uint32 MasterySpellID[2];                               // 9 - 10 passive mastery bonus spells
; };

; struct TalentTreePrimarySpellsEntry
; {
;     //uint32  ID;                                            // 0 index
;     uint32  TalentTabID;                                     // 1 entry from TalentTab.dbc
;     uint32  SpellID;                                         // 2 spell id to learn
;     //uint32  Flags;                                         // 3 some kind of flags
; };

; struct TaxiNodesEntry
; {
;     uint32  ID;                                             // 0
;     uint32  ContinentID;                                    // 1
;     DBCPosition3D Pos;                                      // 2 - 4
;     char* Name;                                             // 5
;     uint32  MountCreatureID[2];                             // 6 - 7
;     uint32  Flags;                                          // 8
;     DBCPosition2D MapOffset;                                // 9 - 10
; };

; struct TaxiPathEntry
; {
;     uint32  ID;                                             // 0
;     uint32  FromTaxiNode;                                   // 1
;     uint32  ToTaxiNode;                                     // 2
;     uint32  Cost;                                           // 3
; };

; struct TaxiPathNodeEntry
; {
;     //uint32  ID;                                           // 0
;     uint32    PathID;                                       // 1
;     uint32    NodeIndex;                                    // 2
;     uint32    ContinentID;                                  // 3
;     DBCPosition3D Loc;                                      // 4 - 6
;     uint32    Flags;                                        // 7
;     uint32    Delay;                                        // 8
;     uint32    ArrivalEventID;                               // 9
;     uint32    DepartureEventID;                             // 10
; };

; struct TotemCategoryEntry
; {
;     uint32    ID;                                           // 0
;     //char*   Name;                                         // 1
;     uint32    TotemCategoryType;                            // 2 (one for specialization)
;     uint32    TotemCategoryMask;                            // 3 (compatibility mask for same type: different for totems, compatible from high to low for rods)
; };

; struct UnitPowerBarEntry
; {
;     uint32  ID;                                             // 1
;     uint32  MinPower;                                       // 2
;     uint32  MaxPower;                                       // 3
;     uint32  StartPower;                                     // 4
;     //uint32  CenterPower;                                  // 5
;     float   RegenerationPeace;                              // 6
;     float   RegenerationCombat;                             // 7
;     //uint32  BarType;                                      // 8
;     //uint32  FileDataID[6];                                // 9 - 14
;     //uint32  Color[6];                                     // 15 - 20
;     //uint32  Flags;                                        // 21
;     //char*   Name;                                         // 22
;     //char*   Cost;                                         // 23
;     //char*   OutOfError;                                   // 24
;     //char*   ToolTip;                                      // 25
;     //float   StartInset;                                   // 26
;     //float   EndInset;                                     // 27
; };

; struct TransportAnimationEntry
; {
;     //uint32  ID;                                           // 1
;     uint32  TransportID;                                    // 2
;     uint32  TimeIndex;                                      // 3
;     DBCPosition3D Pos;                                      // 4 - 6
;     //uint32  SequenceID;                                   // 7
; };

; struct TransportRotationEntry
; {
;     //uint32  ID;                                           // 1
;     uint32  GameObjectsID;                                  // 2
;     uint32  TimeIndex;                                      // 3
;     float   X;                                              // 4
;     float   Y;                                              // 5
;     float   Z;                                              // 6
;     float   W;                                              // 7
; };

; struct VehicleEntry
; {
;     uint32  ID;                                             // 0
;     uint32  Flags;                                          // 1
;     float   TurnSpeed;                                      // 2
;     float   PitchSpeed;                                     // 3
;     float   PitchMin;                                       // 4
;     float   PitchMax;                                       // 5
;     uint32  SeatID[8];                                      // 6 - 13
;     float   MouseLookOffsetPitch;                           // 14
;     float   CameraFadeDistScalarMin;                        // 15
;     float   CameraFadeDistScalarMax;                        // 16
;     float   CameraPitchOffset;                              // 17
;     float   FacingLimitRight;                               // 18
;     float   FacingLimitLeft;                                // 19
;     float   MsslTrgtTurnLingering;                          // 20
;     float   MsslTrgtPitchLingering;                         // 21
;     float   MsslTrgtMouseLingering;                         // 22
;     float   MsslTrgtEndOpacity;                             // 23
;     float   MsslTrgtArcSpeed;                               // 24
;     float   MsslTrgtArcRepeat;                              // 25
;     float   MsslTrgtArcWidth;                               // 26
;     float   MsslTrgtImpactRadius[2];                        // 27 - 28
;     char*   MsslTrgtArcTexture;                             // 29
;     char*   MsslTrgtImpactTexture;                          // 30
;     char*   MsslTrgtImpactModel[2];                         // 31 - 32
;     float   CameraYawOffset;                                // 33
;     uint32  UiLocomotionType;                               // 34
;     float   MsslTrgtImpactTexRadius;                        // 35
;     uint32  VehicleUIIndicatorID;                           // 36
;     uint32  PowerDisplayID[3];                              // 37
; };

; struct VehicleSeatEntry
; {
;     uint32  ID;                                             // 0
;     uint32  Flags;                                          // 1
;     int32   AttachmentID;                                   // 2
;     DBCPosition3D AttachmentOffset;                         // 3 - 5
;     float   EnterPreDelay;                                  // 6
;     float   EnterSpeed;                                     // 7
;     float   EnterGravity;                                   // 8
;     float   EnterMinDuration;                               // 9
;     float   EnterMaxDuration;                               // 10
;     float   EnterMinArcHeight;                              // 11
;     float   EnterMaxArcHeight;                              // 12
;     int32   EnterAnimStart;                                 // 13
;     int32   EnterAnimLoop;                                  // 14
;     int32   RideAnimStart;                                  // 15
;     int32   RideAnimLoop;                                   // 16
;     int32   RideUpperAnimStart;                             // 17
;     int32   RideUpperAnimLoop;                              // 18
;     float   ExitPreDelay;                                   // 19
;     float   ExitSpeed;                                      // 20
;     float   ExitGravity;                                    // 21
;     float   ExitMinDuration;                                // 22
;     float   ExitMaxDuration;                                // 23
;     float   ExitMinArcHeight;                               // 24
;     float   ExitMaxArcHeight;                               // 25
;     int32   ExitAnimStart;                                  // 26
;     int32   ExitAnimLoop;                                   // 27
;     int32   ExitAnimEnd;                                    // 28
;     float   PassengerYaw;                                   // 29
;     float   PassengerPitch;                                 // 30
;     float   PassengerRoll;                                  // 31
;     int32   PassengerAttachmentID;                          // 32
;     int32   VehicleEnterAnim;                               // 33
;     int32   VehicleExitAnim;                                // 34
;     int32   VehicleRideAnimLoop;                            // 35
;     int32   VehicleEnterAnimBone;                           // 36
;     int32   VehicleExitAnimBone;                            // 37
;     int32   VehicleRideAnimLoopBone;                        // 38
;     float   VehicleEnterAnimDelay;                          // 39
;     float   VehicleExitAnimDelay;                           // 40
;     uint32  VehicleAbilityDisplay;                          // 41
;     uint32  EnterUISoundID;                                 // 42
;     uint32  ExitUISoundID;                                  // 43
;     int32   UISkin;                                         // 44
;     uint32  FlagsB;                                         // 45
;     float   CameraEnteringDelay;                            // 46
;     float   CameraEnteringDuration;                         // 47
;     float   CameraExitingDelay;                             // 48
;     float   CameraExitingDuration;                          // 49
;     DBCPosition3D CameraOffset;                             // 50 - 52
;     float   CameraPosChaseRate;                             // 53
;     float   CameraFacingChaseRate;                          // 54
;     float   CameraEnteringZoom;                             // 55
;     float   CameraSeatZoomMin;                              // 56
;     float   CameraSeatZoomMax;                              // 57
;     uint32  EnterAnimKitID;                                 // 58
;     uint32  RideAnimKitID;                                  // 59
;     uint32  ExitAnimKitID;                                  // 60
;     uint32  VehicleEnterAnimKitID;                          // 61
;     uint32  VehicleRideAnimKitID;                           // 62
;     uint32  VehicleExitAnimKitID;                           // 63
;     uint32  CameraModeID;                                   // 64
;     uint32  FlagsC;                                         // 65
; };

; struct WMOAreaTableEntry
; {
;     uint32  ID;                                             // 0 index
;     int32   WMOID;                                          // 1 used in root WMO
;     int32   NameSetID;                                      // 2 used in adt file
;     int32   WMOGroupID;                                     // 3 used in group WMO
;     //uint32  SoundProviderPref;                            // 4
;     //uint32  SoundProviderPrefUnderwater;                  // 5
;     //uint32  AmbienceID;                                   // 6
;     //uint32  ZoneMusic;                                    // 7
;     //uint32  IntroSound;                                   // 8
;     uint32  Flags;                                          // 9 used for indoor/outdoor determination
;     uint32  AreaTableID;                                    // 10 link to AreaTableEntry.ID
;     //char*   AreaName;                                     // 11
;     //uint32  UwIntroSound;                                 // 12
;     //uint32  UwZoneMusic;                                  // 13
;     //uint32  UwAmbience;                                   // 14
; };

; struct WorldSafeLocsEntry
; {
;     uint32  ID;                                             // 0
;     uint32  Continent;                                      // 1
;     DBCPosition3D Loc;                                      // 2 - 4
;     //char*   AreaName;                                     // 5
; };

; 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*     textureFilename;                              // 5
;     char*     text;                                         // 6-21     The worldstate text
;     char*     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
; };
