15 files changed, 1525 insertions, 957 deletions

diff --git a/src/server/game/DataStores/DB2LoadInfo.h b/src/server/game/DataStores/DB2LoadInfo.h
index a6b4c1c0426..bf831521cba 100644
--- a/src/server/game/DataStores/DB2LoadInfo.h
+++ b/src/server/game/DataStores/DB2LoadInfo.h
@@ -30,21 +30,21 @@ struct AchievementLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_STRING, "Title" },
             { false, FT_STRING, "Description" },
+            { false, FT_STRING, "Title" },
             { false, FT_STRING, "Reward" },
-            { true, FT_INT, "Flags" },
+            { false, FT_INT, "ID" },
             { true, FT_SHORT, "InstanceID" },
+            { true, FT_BYTE, "Faction" },
             { true, FT_SHORT, "Supercedes" },
             { true, FT_SHORT, "Category" },
-            { true, FT_SHORT, "UiOrder" },
-            { true, FT_SHORT, "SharesCriteria" },
-            { true, FT_BYTE, "Faction" },
-            { true, FT_BYTE, "Points" },
             { true, FT_BYTE, "MinimumCriteria" },
-            { false, FT_INT, "ID" },
+            { true, FT_BYTE, "Points" },
+            { true, FT_INT, "Flags" },
+            { true, FT_SHORT, "UiOrder" },
             { true, FT_INT, "IconFileID" },
             { false, FT_INT, "CriteriaTree" },
+            { true, FT_SHORT, "SharesCriteria" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AchievementMeta::Instance(), HOTFIX_SEL_ACHIEVEMENT);
         return &loadInfo;
@@ -91,31 +91,31 @@ struct AreaTableLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_STRING_NOT_LOCALIZED, "ZoneName" },
             { false, FT_STRING, "AreaName" },
-            { true, FT_INT, "Flags1" },
-            { true, FT_INT, "Flags2" },
-            { false, FT_FLOAT, "AmbientMultiplier" },
             { false, FT_SHORT, "ContinentID" },
             { false, FT_SHORT, "ParentAreaID" },
             { true, FT_SHORT, "AreaBit" },
+            { false, FT_BYTE, "SoundProviderPref" },
+            { false, FT_BYTE, "SoundProviderPrefUnderwater" },
             { false, FT_SHORT, "AmbienceID" },
+            { false, FT_SHORT, "UwAmbience" },
             { false, FT_SHORT, "ZoneMusic" },
-            { false, FT_SHORT, "IntroSound" },
-            { false, FT_SHORT, "LiquidTypeID1" },
-            { false, FT_SHORT, "LiquidTypeID2" },
-            { false, FT_SHORT, "LiquidTypeID3" },
-            { false, FT_SHORT, "LiquidTypeID4" },
             { false, FT_SHORT, "UwZoneMusic" },
-            { false, FT_SHORT, "UwAmbience" },
-            { true, FT_SHORT, "PvpCombatWorldStateID" },
-            { false, FT_BYTE, "SoundProviderPref" },
-            { false, FT_BYTE, "SoundProviderPrefUnderwater" },
             { true, FT_BYTE, "ExplorationLevel" },
+            { false, FT_SHORT, "IntroSound" },
+            { false, FT_INT, "UwIntroSound" },
             { false, FT_BYTE, "FactionGroupMask" },
+            { false, FT_FLOAT, "AmbientMultiplier" },
             { false, FT_BYTE, "MountFlags" },
+            { true, FT_SHORT, "PvpCombatWorldStateID" },
             { false, FT_BYTE, "WildBattlePetLevelMin" },
             { false, FT_BYTE, "WildBattlePetLevelMax" },
             { false, FT_BYTE, "WindSettingsID" },
-            { false, FT_INT, "UwIntroSound" },
+            { true, FT_INT, "Flags1" },
+            { true, FT_INT, "Flags2" },
+            { false, FT_SHORT, "LiquidTypeID1" },
+            { false, FT_SHORT, "LiquidTypeID2" },
+            { false, FT_SHORT, "LiquidTypeID3" },
+            { false, FT_SHORT, "LiquidTypeID4" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AreaTableMeta::Instance(), HOTFIX_SEL_AREA_TABLE);
         return &loadInfo;
@@ -131,20 +131,20 @@ struct AreaTriggerLoadInfo
             { false, FT_FLOAT, "PosX" },
             { false, FT_FLOAT, "PosY" },
             { false, FT_FLOAT, "PosZ" },
+            { false, FT_INT, "ID" },
+            { true, FT_SHORT, "ContinentID" },
+            { true, FT_BYTE, "PhaseUseFlags" },
+            { true, FT_SHORT, "PhaseID" },
+            { true, FT_SHORT, "PhaseGroupID" },
             { false, FT_FLOAT, "Radius" },
             { false, FT_FLOAT, "BoxLength" },
             { false, FT_FLOAT, "BoxWidth" },
             { false, FT_FLOAT, "BoxHeight" },
             { false, FT_FLOAT, "BoxYaw" },
-            { true, FT_SHORT, "ContinentID" },
-            { true, FT_SHORT, "PhaseID" },
-            { true, FT_SHORT, "PhaseGroupID" },
+            { true, FT_BYTE, "ShapeType" },
             { true, FT_SHORT, "ShapeID" },
             { true, FT_SHORT, "AreaTriggerActionSetID" },
-            { true, FT_BYTE, "PhaseUseFlags" },
-            { true, FT_BYTE, "ShapeType" },
             { true, FT_BYTE, "Flags" },
-            { false, FT_INT, "ID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AreaTriggerMeta::Instance(), HOTFIX_SEL_AREA_TRIGGER);
         return &loadInfo;
@@ -175,15 +175,15 @@ struct ArtifactLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
+            { false, FT_INT, "ID" },
+            { false, FT_SHORT, "UiTextureKitID" },
+            { true, FT_INT, "UiNameColor" },
             { true, FT_INT, "UiBarOverlayColor" },
             { true, FT_INT, "UiBarBackgroundColor" },
-            { true, FT_INT, "UiNameColor" },
-            { false, FT_SHORT, "UiTextureKitID" },
             { false, FT_SHORT, "ChrSpecializationID" },
-            { false, FT_BYTE, "ArtifactCategoryID" },
             { false, FT_BYTE, "Flags" },
+            { false, FT_BYTE, "ArtifactCategoryID" },
             { false, FT_INT, "UiModelSceneID" },
             { false, FT_INT, "SpellVisualKitID" },
         };
@@ -199,20 +199,20 @@ struct ArtifactAppearanceLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_STRING, "Name" },
-            { true, FT_INT, "UiSwatchColor" },
-            { false, FT_FLOAT, "UiModelSaturation" },
-            { false, FT_FLOAT, "UiModelOpacity" },
-            { false, FT_INT, "OverrideShapeshiftDisplayID" },
+            { false, FT_INT, "ID" },
             { false, FT_SHORT, "ArtifactAppearanceSetID" },
-            { false, FT_SHORT, "UiCameraID" },
             { false, FT_BYTE, "DisplayIndex" },
+            { false, FT_INT, "UnlockPlayerConditionID" },
             { false, FT_BYTE, "ItemAppearanceModifierID" },
-            { false, FT_BYTE, "Flags" },
+            { true, FT_INT, "UiSwatchColor" },
+            { false, FT_FLOAT, "UiModelSaturation" },
+            { false, FT_FLOAT, "UiModelOpacity" },
             { false, FT_BYTE, "OverrideShapeshiftFormID" },
-            { false, FT_INT, "ID" },
-            { false, FT_INT, "UnlockPlayerConditionID" },
+            { false, FT_INT, "OverrideShapeshiftDisplayID" },
             { false, FT_INT, "UiItemAppearanceID" },
             { false, FT_INT, "UiAltItemAppearanceID" },
+            { false, FT_BYTE, "Flags" },
+            { false, FT_SHORT, "UiCameraID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactAppearanceMeta::Instance(), HOTFIX_SEL_ARTIFACT_APPEARANCE);
         return &loadInfo;
@@ -227,12 +227,12 @@ struct ArtifactAppearanceSetLoadInfo
         {
             { false, FT_STRING, "Name" },
             { false, FT_STRING, "Description" },
+            { false, FT_INT, "ID" },
+            { false, FT_BYTE, "DisplayIndex" },
             { false, FT_SHORT, "UiCameraID" },
             { false, FT_SHORT, "AltHandUICameraID" },
-            { false, FT_BYTE, "DisplayIndex" },
             { true, FT_BYTE, "ForgeAttachmentOverride" },
             { false, FT_BYTE, "Flags" },
-            { false, FT_INT, "ID" },
             { false, FT_BYTE, "ArtifactID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactAppearanceSetMeta::Instance(), HOTFIX_SEL_ARTIFACT_APPEARANCE_SET);
@@ -261,14 +261,14 @@ struct ArtifactPowerLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_FLOAT, "PosX" },
-            { false, FT_FLOAT, "PosY" },
+            { false, FT_FLOAT, "DisplayPosX" },
+            { false, FT_FLOAT, "DisplayPosY" },
+            { false, FT_INT, "ID" },
             { false, FT_BYTE, "ArtifactID" },
-            { false, FT_BYTE, "Flags" },
             { false, FT_BYTE, "MaxPurchasableRank" },
-            { false, FT_BYTE, "Tier" },
-            { false, FT_INT, "ID" },
             { true, FT_INT, "Label" },
+            { false, FT_BYTE, "Flags" },
+            { false, FT_BYTE, "Tier" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactPowerMeta::Instance(), HOTFIX_SEL_ARTIFACT_POWER);
         return &loadInfo;
@@ -311,10 +311,10 @@ struct ArtifactPowerRankLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "RankIndex" },
             { true, FT_INT, "SpellID" },
-            { false, FT_FLOAT, "AuraPointsOverride" },
             { false, FT_SHORT, "ItemBonusListID" },
-            { false, FT_BYTE, "RankIndex" },
+            { false, FT_FLOAT, "AuraPointsOverride" },
             { false, FT_SHORT, "ArtifactPowerID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactPowerRankMeta::Instance(), HOTFIX_SEL_ARTIFACT_POWER_RANK);
@@ -370,9 +370,9 @@ struct ArtifactUnlockLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_SHORT, "ItemBonusListID" },
-            { false, FT_BYTE, "PowerRank" },
             { false, FT_INT, "PowerID" },
+            { false, FT_BYTE, "PowerRank" },
+            { false, FT_SHORT, "ItemBonusListID" },
             { false, FT_INT, "PlayerConditionID" },
             { false, FT_BYTE, "ArtifactID" },
         };
@@ -436,12 +436,12 @@ struct BarberShopStyleLoadInfo
         {
             { false, FT_STRING, "DisplayName" },
             { false, FT_STRING, "Description" },
-            { false, FT_FLOAT, "CostModifier" },
+            { false, FT_INT, "ID" },
             { false, FT_BYTE, "Type" },
+            { false, FT_FLOAT, "CostModifier" },
             { false, FT_BYTE, "Race" },
             { false, FT_BYTE, "Sex" },
             { false, FT_BYTE, "Data" },
-            { false, FT_INT, "ID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BarberShopStyleMeta::Instance(), HOTFIX_SEL_BARBER_SHOP_STYLE);
         return &loadInfo;
@@ -470,8 +470,8 @@ struct BattlePetBreedStateLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_SHORT, "Value" },
             { false, FT_BYTE, "BattlePetStateID" },
+            { false, FT_SHORT, "Value" },
             { false, FT_BYTE, "BattlePetBreedID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetBreedStateMeta::Instance(), HOTFIX_SEL_BATTLE_PET_BREED_STATE);
@@ -485,15 +485,15 @@ struct BattlePetSpeciesLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_STRING, "SourceText" },
             { false, FT_STRING, "Description" },
+            { false, FT_STRING, "SourceText" },
+            { false, FT_INT, "ID" },
             { true, FT_INT, "CreatureID" },
-            { true, FT_INT, "IconFileDataID" },
             { true, FT_INT, "SummonSpellID" },
-            { false, FT_SHORT, "Flags" },
+            { true, FT_INT, "IconFileDataID" },
             { false, FT_BYTE, "PetTypeEnum" },
+            { false, FT_SHORT, "Flags" },
             { true, FT_BYTE, "SourceTypeEnum" },
-            { false, FT_INT, "ID" },
             { true, FT_INT, "CardUIModelSceneID" },
             { true, FT_INT, "LoadoutUIModelSceneID" },
         };
@@ -509,8 +509,8 @@ struct BattlePetSpeciesStateLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "Value" },
             { false, FT_BYTE, "BattlePetStateID" },
+            { true, FT_INT, "Value" },
             { false, FT_SHORT, "BattlePetSpeciesID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetSpeciesStateMeta::Instance(), HOTFIX_SEL_BATTLE_PET_SPECIES_STATE);
@@ -529,7 +529,18 @@ struct BattlemasterListLoadInfo
             { false, FT_STRING, "GameType" },
             { false, FT_STRING, "ShortDescription" },
             { false, FT_STRING, "LongDescription" },
+            { true, FT_BYTE, "InstanceType" },
+            { true, FT_BYTE, "MinLevel" },
+            { true, FT_BYTE, "MaxLevel" },
+            { true, FT_BYTE, "RatedPlayers" },
+            { true, FT_BYTE, "MinPlayers" },
+            { true, FT_BYTE, "MaxPlayers" },
+            { true, FT_BYTE, "GroupsAllowed" },
+            { true, FT_BYTE, "MaxGroupSize" },
+            { true, FT_SHORT, "HolidayWorldState" },
+            { true, FT_BYTE, "Flags" },
             { true, FT_INT, "IconFileDataID" },
+            { true, FT_SHORT, "RequiredPlayerConditionID" },
             { true, FT_SHORT, "MapID1" },
             { true, FT_SHORT, "MapID2" },
             { true, FT_SHORT, "MapID3" },
@@ -546,17 +557,6 @@ struct BattlemasterListLoadInfo
             { true, FT_SHORT, "MapID14" },
             { true, FT_SHORT, "MapID15" },
             { true, FT_SHORT, "MapID16" },
-            { true, FT_SHORT, "HolidayWorldState" },
-            { true, FT_SHORT, "RequiredPlayerConditionID" },
-            { true, FT_BYTE, "InstanceType" },
-            { true, FT_BYTE, "GroupsAllowed" },
-            { true, FT_BYTE, "MaxGroupSize" },
-            { true, FT_BYTE, "MinLevel" },
-            { true, FT_BYTE, "MaxLevel" },
-            { true, FT_BYTE, "RatedPlayers" },
-            { true, FT_BYTE, "MinPlayers" },
-            { true, FT_BYTE, "MaxPlayers" },
-            { true, FT_BYTE, "Flags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlemasterListMeta::Instance(), HOTFIX_SEL_BATTLEMASTER_LIST);
         return &loadInfo;
@@ -569,21 +569,22 @@ struct BroadcastTextLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_INT, "ID" },
             { false, FT_STRING, "Text" },
             { false, FT_STRING, "Text1" },
+            { false, FT_INT, "ID" },
+            { false, FT_BYTE, "LanguageID" },
+            { true, FT_INT, "ConditionID" },
+            { false, FT_SHORT, "EmotesID" },
+            { false, FT_BYTE, "Flags" },
+            { false, FT_INT, "ChatBubbleDurationMs" },
+            { false, FT_INT, "SoundEntriesID1" },
+            { false, FT_INT, "SoundEntriesID2" },
             { false, FT_SHORT, "EmoteID1" },
             { false, FT_SHORT, "EmoteID2" },
             { false, FT_SHORT, "EmoteID3" },
             { false, FT_SHORT, "EmoteDelay1" },
             { false, FT_SHORT, "EmoteDelay2" },
             { false, FT_SHORT, "EmoteDelay3" },
-            { false, FT_SHORT, "EmotesID" },
-            { false, FT_BYTE, "LanguageID" },
-            { false, FT_BYTE, "Flags" },
-            { true, FT_INT, "ConditionID" },
-            { false, FT_INT, "SoundEntriesID1" },
-            { false, FT_INT, "SoundEntriesID2" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BroadcastTextMeta::Instance(), HOTFIX_SEL_BROADCAST_TEXT);
         return &loadInfo;
@@ -598,10 +599,10 @@ struct CfgRegionsLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING_NOT_LOCALIZED, "Tag" },
-            { false, FT_INT, "Raidorigin" },
-            { false, FT_INT, "ChallengeOrigin" },
             { false, FT_SHORT, "RegionID" },
+            { false, FT_INT, "Raidorigin" },
             { false, FT_BYTE, "RegionGroupMask" },
+            { false, FT_INT, "ChallengeOrigin" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, Cfg_RegionsMeta::Instance(), HOTFIX_SEL_CFG_REGIONS);
         return &loadInfo;
@@ -636,9 +637,9 @@ struct CharBaseSectionLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "LayoutResType" },
             { false, FT_BYTE, "VariationEnum" },
             { false, FT_BYTE, "ResolutionVariationEnum" },
-            { false, FT_BYTE, "LayoutResType" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharBaseSectionMeta::Instance(), HOTFIX_SEL_CHAR_BASE_SECTION);
         return &loadInfo;
@@ -652,15 +653,15 @@ struct CharSectionsLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "MaterialResourcesID1" },
-            { true, FT_INT, "MaterialResourcesID2" },
-            { true, FT_INT, "MaterialResourcesID3" },
-            { true, FT_SHORT, "Flags" },
             { true, FT_BYTE, "RaceID" },
             { true, FT_BYTE, "SexID" },
             { true, FT_BYTE, "BaseSection" },
             { true, FT_BYTE, "VariationIndex" },
             { true, FT_BYTE, "ColorIndex" },
+            { true, FT_SHORT, "Flags" },
+            { true, FT_INT, "MaterialResourcesID1" },
+            { true, FT_INT, "MaterialResourcesID2" },
+            { true, FT_INT, "MaterialResourcesID3" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharSectionsMeta::Instance(), HOTFIX_SEL_CHAR_SECTIONS);
         return &loadInfo;
@@ -674,6 +675,11 @@ struct CharStartOutfitLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "ClassID" },
+            { false, FT_BYTE, "SexID" },
+            { false, FT_BYTE, "OutfitID" },
+            { false, FT_INT, "PetDisplayID" },
+            { false, FT_BYTE, "PetFamilyID" },
             { true, FT_INT, "ItemID1" },
             { true, FT_INT, "ItemID2" },
             { true, FT_INT, "ItemID3" },
@@ -698,11 +704,6 @@ struct CharStartOutfitLoadInfo
             { true, FT_INT, "ItemID22" },
             { true, FT_INT, "ItemID23" },
             { true, FT_INT, "ItemID24" },
-            { false, FT_INT, "PetDisplayID" },
-            { false, FT_BYTE, "ClassID" },
-            { false, FT_BYTE, "SexID" },
-            { false, FT_BYTE, "OutfitID" },
-            { false, FT_BYTE, "PetFamilyID" },
             { false, FT_BYTE, "RaceID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharStartOutfitMeta::Instance(), HOTFIX_SEL_CHAR_START_OUTFIT);
@@ -750,26 +751,26 @@ struct ChrClassesLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_STRING_NOT_LOCALIZED, "PetNameToken" },
             { false, FT_STRING, "Name" },
-            { false, FT_STRING, "NameFemale" },
-            { false, FT_STRING, "NameMale" },
             { false, FT_STRING_NOT_LOCALIZED, "Filename" },
+            { false, FT_STRING, "NameMale" },
+            { false, FT_STRING, "NameFemale" },
+            { false, FT_STRING_NOT_LOCALIZED, "PetNameToken" },
+            { false, FT_INT, "ID" },
             { false, FT_INT, "CreateScreenFileDataID" },
             { false, FT_INT, "SelectScreenFileDataID" },
-            { false, FT_INT, "LowResScreenFileDataID" },
             { false, FT_INT, "IconFileDataID" },
+            { false, FT_INT, "LowResScreenFileDataID" },
             { true, FT_INT, "StartingLevel" },
             { false, FT_SHORT, "Flags" },
             { false, FT_SHORT, "CinematicSequenceID" },
             { false, FT_SHORT, "DefaultSpec" },
+            { false, FT_BYTE, "PrimaryStatPriority" },
             { false, FT_BYTE, "DisplayPower" },
-            { false, FT_BYTE, "SpellClassSet" },
-            { false, FT_BYTE, "AttackPowerPerStrength" },
-            { false, FT_BYTE, "AttackPowerPerAgility" },
             { false, FT_BYTE, "RangedAttackPowerPerAgility" },
-            { false, FT_BYTE, "PrimaryStatPriority" },
-            { false, FT_INT, "ID" },
+            { false, FT_BYTE, "AttackPowerPerAgility" },
+            { false, FT_BYTE, "AttackPowerPerStrength" },
+            { false, FT_BYTE, "SpellClassSet" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrClassesMeta::Instance(), HOTFIX_SEL_CHR_CLASSES);
         return &loadInfo;
@@ -783,7 +784,7 @@ struct ChrClassesXPowerTypesLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_BYTE, "PowerType" },
+            { true, FT_BYTE, "PowerType" },
             { false, FT_BYTE, "ClassID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrClassesXPowerTypesMeta::Instance(), HOTFIX_SEL_CHR_CLASSES_X_POWER_TYPES);
@@ -803,9 +804,12 @@ struct ChrRacesLoadInfo
             { false, FT_STRING, "NameFemale" },
             { false, FT_STRING, "NameLowercase" },
             { false, FT_STRING, "NameFemaleLowercase" },
+            { false, FT_INT, "ID" },
             { true, FT_INT, "Flags" },
             { false, FT_INT, "MaleDisplayId" },
             { false, FT_INT, "FemaleDisplayId" },
+            { false, FT_INT, "HighResMaleDisplayId" },
+            { false, FT_INT, "HighResFemaleDisplayId" },
             { true, FT_INT, "CreateScreenFileDataID" },
             { true, FT_INT, "SelectScreenFileDataID" },
             { false, FT_FLOAT, "MaleCustomizeOffset1" },
@@ -815,34 +819,39 @@ struct ChrRacesLoadInfo
             { false, FT_FLOAT, "FemaleCustomizeOffset2" },
             { false, FT_FLOAT, "FemaleCustomizeOffset3" },
             { true, FT_INT, "LowResScreenFileDataID" },
+            { false, FT_INT, "AlteredFormStartVisualKitID1" },
+            { false, FT_INT, "AlteredFormStartVisualKitID2" },
+            { false, FT_INT, "AlteredFormStartVisualKitID3" },
+            { false, FT_INT, "AlteredFormFinishVisualKitID1" },
+            { false, FT_INT, "AlteredFormFinishVisualKitID2" },
+            { false, FT_INT, "AlteredFormFinishVisualKitID3" },
+            { true, FT_INT, "HeritageArmorAchievementID" },
             { true, FT_INT, "StartingLevel" },
             { true, FT_INT, "UiDisplayOrder" },
+            { true, FT_INT, "FemaleSkeletonFileDataID" },
+            { true, FT_INT, "MaleSkeletonFileDataID" },
+            { true, FT_INT, "HelmVisFallbackRaceID" },
             { true, FT_SHORT, "FactionID" },
+            { true, FT_SHORT, "CinematicSequenceID" },
             { true, FT_SHORT, "ResSicknessSpellID" },
             { true, FT_SHORT, "SplashSoundID" },
-            { true, FT_SHORT, "CinematicSequenceID" },
             { true, FT_BYTE, "BaseLanguage" },
             { true, FT_BYTE, "CreatureType" },
             { true, FT_BYTE, "Alliance" },
             { true, FT_BYTE, "RaceRelated" },
             { true, FT_BYTE, "UnalteredVisualRaceID" },
             { true, FT_BYTE, "CharComponentTextureLayoutID" },
+            { true, FT_BYTE, "CharComponentTexLayoutHiResID" },
             { true, FT_BYTE, "DefaultClassID" },
             { true, FT_BYTE, "NeutralRaceID" },
-            { true, FT_BYTE, "DisplayRaceID" },
-            { true, FT_BYTE, "CharComponentTexLayoutHiResID" },
-            { false, FT_INT, "ID" },
-            { false, FT_INT, "HighResMaleDisplayId" },
-            { false, FT_INT, "HighResFemaleDisplayId" },
-            { true, FT_INT, "HeritageArmorAchievementID" },
-            { true, FT_INT, "MaleSkeletonFileDataID" },
-            { true, FT_INT, "FemaleSkeletonFileDataID" },
-            { false, FT_INT, "AlteredFormStartVisualKitID1" },
-            { false, FT_INT, "AlteredFormStartVisualKitID2" },
-            { false, FT_INT, "AlteredFormStartVisualKitID3" },
-            { false, FT_INT, "AlteredFormFinishVisualKitID1" },
-            { false, FT_INT, "AlteredFormFinishVisualKitID2" },
-            { false, FT_INT, "AlteredFormFinishVisualKitID3" },
+            { true, FT_BYTE, "MaleModelFallbackRaceID" },
+            { true, FT_BYTE, "MaleModelFallbackSex" },
+            { true, FT_BYTE, "FemaleModelFallbackRaceID" },
+            { true, FT_BYTE, "FemaleModelFallbackSex" },
+            { true, FT_BYTE, "MaleTextureFallbackRaceID" },
+            { true, FT_BYTE, "MaleTextureFallbackSex" },
+            { true, FT_BYTE, "FemaleTextureFallbackRaceID" },
+            { true, FT_BYTE, "FemaleTextureFallbackSex" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrRacesMeta::Instance(), HOTFIX_SEL_CHR_RACES);
         return &loadInfo;
@@ -858,17 +867,17 @@ struct ChrSpecializationLoadInfo
             { false, FT_STRING, "Name" },
             { false, FT_STRING, "FemaleName" },
             { false, FT_STRING, "Description" },
-            { true, FT_INT, "MasterySpellID1" },
-            { true, FT_INT, "MasterySpellID2" },
+            { false, FT_INT, "ID" },
             { true, FT_BYTE, "ClassID" },
             { true, FT_BYTE, "OrderIndex" },
             { true, FT_BYTE, "PetTalentType" },
             { true, FT_BYTE, "Role" },
-            { true, FT_BYTE, "PrimaryStatPriority" },
-            { false, FT_INT, "ID" },
-            { true, FT_INT, "SpellIconFileID" },
             { false, FT_INT, "Flags" },
+            { true, FT_INT, "SpellIconFileID" },
+            { true, FT_BYTE, "PrimaryStatPriority" },
             { true, FT_INT, "AnimReplacements" },
+            { true, FT_INT, "MasterySpellID1" },
+            { true, FT_INT, "MasterySpellID2" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrSpecializationMeta::Instance(), HOTFIX_SEL_CHR_SPECIALIZATION);
         return &loadInfo;
@@ -882,10 +891,10 @@ struct CinematicCameraLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "SoundID" },
             { false, FT_FLOAT, "OriginX" },
             { false, FT_FLOAT, "OriginY" },
             { false, FT_FLOAT, "OriginZ" },
+            { false, FT_INT, "SoundID" },
             { false, FT_FLOAT, "OriginFacing" },
             { false, FT_INT, "FileDataID" },
         };
@@ -916,6 +925,24 @@ struct CinematicSequencesLoadInfo
     }
 };
 
+struct ContentTuningLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_INT, "ID" },
+            { true, FT_INT, "MinLevel" },
+            { true, FT_INT, "MaxLevel" },
+            { true, FT_INT, "Flags" },
+            { true, FT_INT, "ExpectedStatModID" },
+            { true, FT_INT, "DifficultyESMID" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ContentTuningMeta::Instance(), HOTFIX_SEL_CONTENT_TUNING);
+        return &loadInfo;
+    }
+};
+
 struct ConversationLineLoadInfo
 {
     static DB2LoadInfo const* Instance()
@@ -944,27 +971,29 @@ struct CreatureDisplayInfoLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_FLOAT, "CreatureModelScale" },
             { false, FT_SHORT, "ModelID" },
-            { false, FT_SHORT, "NPCSoundID" },
+            { false, FT_SHORT, "SoundID" },
             { true, FT_BYTE, "SizeClass" },
-            { false, FT_BYTE, "Flags" },
-            { true, FT_BYTE, "Gender" },
-            { true, FT_INT, "ExtendedDisplayInfoID" },
-            { true, FT_INT, "PortraitTextureFileDataID" },
+            { false, FT_FLOAT, "CreatureModelScale" },
             { false, FT_BYTE, "CreatureModelAlpha" },
-            { false, FT_SHORT, "SoundID" },
-            { false, FT_FLOAT, "PlayerOverrideScale" },
-            { true, FT_INT, "PortraitCreatureDisplayInfoID" },
             { false, FT_BYTE, "BloodID" },
+            { true, FT_INT, "ExtendedDisplayInfoID" },
+            { false, FT_SHORT, "NPCSoundID" },
             { false, FT_SHORT, "ParticleColorID" },
-            { false, FT_INT, "CreatureGeosetData" },
+            { true, FT_INT, "PortraitCreatureDisplayInfoID" },
+            { true, FT_INT, "PortraitTextureFileDataID" },
             { false, FT_SHORT, "ObjectEffectPackageID" },
             { false, FT_SHORT, "AnimReplacementSetID" },
-            { true, FT_BYTE, "UnarmedWeaponType" },
+            { false, FT_BYTE, "Flags" },
             { true, FT_INT, "StateSpellVisualKitID" },
+            { false, FT_FLOAT, "PlayerOverrideScale" },
             { false, FT_FLOAT, "PetInstanceScale" },
+            { true, FT_BYTE, "UnarmedWeaponType" },
             { true, FT_INT, "MountPoofSpellVisualKitID" },
+            { true, FT_INT, "DissolveEffectID" },
+            { true, FT_BYTE, "Gender" },
+            { true, FT_INT, "DissolveOutEffectID" },
+            { true, FT_BYTE, "CreatureModelMinLod" },
             { true, FT_INT, "TextureVariationFileDataID1" },
             { true, FT_INT, "TextureVariationFileDataID2" },
             { true, FT_INT, "TextureVariationFileDataID3" },
@@ -981,8 +1010,6 @@ struct CreatureDisplayInfoExtraLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "BakeMaterialResourcesID" },
-            { true, FT_INT, "HDBakeMaterialResourcesID" },
             { true, FT_BYTE, "DisplayRaceID" },
             { true, FT_BYTE, "DisplaySexID" },
             { true, FT_BYTE, "DisplayClassID" },
@@ -991,10 +1018,12 @@ struct CreatureDisplayInfoExtraLoadInfo
             { true, FT_BYTE, "HairStyleID" },
             { true, FT_BYTE, "HairColorID" },
             { true, FT_BYTE, "FacialHairID" },
+            { true, FT_BYTE, "Flags" },
+            { true, FT_INT, "BakeMaterialResourcesID" },
+            { true, FT_INT, "HDBakeMaterialResourcesID" },
             { false, FT_BYTE, "CustomDisplayOption1" },
             { false, FT_BYTE, "CustomDisplayOption2" },
             { false, FT_BYTE, "CustomDisplayOption3" },
-            { true, FT_BYTE, "Flags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureDisplayInfoExtraMeta::Instance(), HOTFIX_SEL_CREATURE_DISPLAY_INFO_EXTRA);
         return &loadInfo;
@@ -1010,14 +1039,14 @@ struct CreatureFamilyLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
             { false, FT_FLOAT, "MinScale" },
+            { true, FT_BYTE, "MinScaleLevel" },
             { false, FT_FLOAT, "MaxScale" },
+            { true, FT_BYTE, "MaxScaleLevel" },
+            { true, FT_SHORT, "PetFoodMask" },
+            { true, FT_BYTE, "PetTalentType" },
             { true, FT_INT, "IconFileID" },
             { true, FT_SHORT, "SkillLine1" },
             { true, FT_SHORT, "SkillLine2" },
-            { true, FT_SHORT, "PetFoodMask" },
-            { true, FT_BYTE, "MinScaleLevel" },
-            { true, FT_BYTE, "MaxScaleLevel" },
-            { true, FT_BYTE, "PetTalentType" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureFamilyMeta::Instance(), HOTFIX_SEL_CREATURE_FAMILY);
         return &loadInfo;
@@ -1031,39 +1060,39 @@ struct CreatureModelDataLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_FLOAT, "ModelScale" },
-            { false, FT_FLOAT, "FootprintTextureLength" },
-            { false, FT_FLOAT, "FootprintTextureWidth" },
-            { false, FT_FLOAT, "FootprintParticleScale" },
-            { false, FT_FLOAT, "CollisionWidth" },
-            { false, FT_FLOAT, "CollisionHeight" },
-            { false, FT_FLOAT, "MountHeight" },
             { false, FT_FLOAT, "GeoBox1" },
             { false, FT_FLOAT, "GeoBox2" },
             { false, FT_FLOAT, "GeoBox3" },
             { false, FT_FLOAT, "GeoBox4" },
             { false, FT_FLOAT, "GeoBox5" },
             { false, FT_FLOAT, "GeoBox6" },
-            { false, FT_FLOAT, "WorldEffectScale" },
-            { false, FT_FLOAT, "AttachedEffectScale" },
-            { false, FT_FLOAT, "MissileCollisionRadius" },
-            { false, FT_FLOAT, "MissileCollisionPush" },
-            { false, FT_FLOAT, "MissileCollisionRaise" },
-            { false, FT_FLOAT, "OverrideLootEffectScale" },
-            { false, FT_FLOAT, "OverrideNameScale" },
-            { false, FT_FLOAT, "OverrideSelectionRadius" },
-            { false, FT_FLOAT, "TamedPetBaseScale" },
-            { false, FT_FLOAT, "HoverHeight" },
             { false, FT_INT, "Flags" },
             { false, FT_INT, "FileDataID" },
-            { false, FT_INT, "SizeClass" },
             { false, FT_INT, "BloodID" },
             { false, FT_INT, "FootprintTextureID" },
+            { false, FT_FLOAT, "FootprintTextureLength" },
+            { false, FT_FLOAT, "FootprintTextureWidth" },
+            { false, FT_FLOAT, "FootprintParticleScale" },
             { false, FT_INT, "FoleyMaterialID" },
             { false, FT_INT, "FootstepCameraEffectID" },
             { false, FT_INT, "DeathThudCameraEffectID" },
             { false, FT_INT, "SoundID" },
+            { false, FT_INT, "SizeClass" },
+            { false, FT_FLOAT, "CollisionWidth" },
+            { false, FT_FLOAT, "CollisionHeight" },
+            { false, FT_FLOAT, "WorldEffectScale" },
             { false, FT_INT, "CreatureGeosetDataID" },
+            { false, FT_FLOAT, "HoverHeight" },
+            { false, FT_FLOAT, "AttachedEffectScale" },
+            { false, FT_FLOAT, "ModelScale" },
+            { false, FT_FLOAT, "MissileCollisionRadius" },
+            { false, FT_FLOAT, "MissileCollisionPush" },
+            { false, FT_FLOAT, "MissileCollisionRaise" },
+            { false, FT_FLOAT, "MountHeight" },
+            { false, FT_FLOAT, "OverrideLootEffectScale" },
+            { false, FT_FLOAT, "OverrideNameScale" },
+            { false, FT_FLOAT, "OverrideSelectionRadius" },
+            { false, FT_FLOAT, "TamedPetBaseScale" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureModelDataMeta::Instance(), HOTFIX_SEL_CREATURE_MODEL_DATA);
         return &loadInfo;
@@ -1092,16 +1121,16 @@ struct CriteriaLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "Asset" },
-            { true, FT_INT, "StartAsset" },
-            { true, FT_INT, "FailAsset" },
+            { true, FT_SHORT, "Type" },
+            { true, FT_INT, "Asset" },
             { false, FT_INT, "ModifierTreeId" },
-            { false, FT_SHORT, "StartTimer" },
-            { true, FT_SHORT, "EligibilityWorldStateID" },
-            { false, FT_BYTE, "Type" },
             { false, FT_BYTE, "StartEvent" },
+            { true, FT_INT, "StartAsset" },
+            { false, FT_SHORT, "StartTimer" },
             { false, FT_BYTE, "FailEvent" },
+            { true, FT_INT, "FailAsset" },
             { false, FT_BYTE, "Flags" },
+            { true, FT_SHORT, "EligibilityWorldStateID" },
             { true, FT_BYTE, "EligibilityWorldStateValue" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CriteriaMeta::Instance(), HOTFIX_SEL_CRITERIA);
@@ -1117,12 +1146,12 @@ struct CriteriaTreeLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Description" },
-            { true, FT_INT, "Amount" },
-            { true, FT_SHORT, "Flags" },
+            { false, FT_INT, "Parent" },
+            { false, FT_INT, "Amount" },
             { true, FT_BYTE, "Operator" },
             { false, FT_INT, "CriteriaID" },
-            { false, FT_INT, "Parent" },
             { true, FT_INT, "OrderIndex" },
+            { true, FT_SHORT, "Flags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CriteriaTreeMeta::Instance(), HOTFIX_SEL_CRITERIA_TREE);
         return &loadInfo;
@@ -1138,14 +1167,15 @@ struct CurrencyTypesLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
             { false, FT_STRING, "Description" },
-            { false, FT_INT, "MaxQty" },
-            { false, FT_INT, "MaxEarnablePerWeek" },
-            { false, FT_INT, "Flags" },
             { false, FT_BYTE, "CategoryID" },
-            { false, FT_BYTE, "SpellCategory" },
-            { false, FT_BYTE, "Quality" },
             { true, FT_INT, "InventoryIconFileID" },
             { false, FT_INT, "SpellWeight" },
+            { false, FT_BYTE, "SpellCategory" },
+            { false, FT_INT, "MaxQty" },
+            { false, FT_INT, "MaxEarnablePerWeek" },
+            { false, FT_INT, "Flags" },
+            { true, FT_BYTE, "Quality" },
+            { true, FT_INT, "FactionID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CurrencyTypesMeta::Instance(), HOTFIX_SEL_CURRENCY_TYPES);
         return &loadInfo;
@@ -1191,28 +1221,28 @@ struct DestructibleModelDataLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_SHORT, "State0Wmo" },
-            { false, FT_SHORT, "State1Wmo" },
-            { false, FT_SHORT, "State2Wmo" },
-            { false, FT_SHORT, "State3Wmo" },
-            { false, FT_SHORT, "HealEffectSpeed" },
             { true, FT_BYTE, "State0ImpactEffectDoodadSet" },
             { false, FT_BYTE, "State0AmbientDoodadSet" },
-            { true, FT_BYTE, "State0NameSet" },
+            { false, FT_SHORT, "State1Wmo" },
             { true, FT_BYTE, "State1DestructionDoodadSet" },
             { true, FT_BYTE, "State1ImpactEffectDoodadSet" },
             { false, FT_BYTE, "State1AmbientDoodadSet" },
-            { true, FT_BYTE, "State1NameSet" },
+            { false, FT_SHORT, "State2Wmo" },
             { true, FT_BYTE, "State2DestructionDoodadSet" },
             { true, FT_BYTE, "State2ImpactEffectDoodadSet" },
             { false, FT_BYTE, "State2AmbientDoodadSet" },
-            { true, FT_BYTE, "State2NameSet" },
+            { false, FT_SHORT, "State3Wmo" },
             { false, FT_BYTE, "State3InitDoodadSet" },
             { false, FT_BYTE, "State3AmbientDoodadSet" },
-            { true, FT_BYTE, "State3NameSet" },
             { false, FT_BYTE, "EjectDirection" },
             { false, FT_BYTE, "DoNotHighlight" },
+            { false, FT_SHORT, "State0Wmo" },
             { false, FT_BYTE, "HealEffect" },
+            { false, FT_SHORT, "HealEffectSpeed" },
+            { true, FT_BYTE, "State0NameSet" },
+            { true, FT_BYTE, "State1NameSet" },
+            { true, FT_BYTE, "State2NameSet" },
+            { true, FT_BYTE, "State3NameSet" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DestructibleModelDataMeta::Instance(), HOTFIX_SEL_DESTRUCTIBLE_MODEL_DATA);
         return &loadInfo;
@@ -1227,18 +1257,18 @@ struct DifficultyLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
-            { false, FT_SHORT, "GroupSizeHealthCurveID" },
-            { false, FT_SHORT, "GroupSizeDmgCurveID" },
-            { false, FT_SHORT, "GroupSizeSpellPointsCurveID" },
-            { false, FT_BYTE, "FallbackDifficultyID" },
             { false, FT_BYTE, "InstanceType" },
+            { false, FT_BYTE, "OrderIndex" },
+            { true, FT_BYTE, "OldEnumValue" },
+            { false, FT_BYTE, "FallbackDifficultyID" },
             { false, FT_BYTE, "MinPlayers" },
             { false, FT_BYTE, "MaxPlayers" },
-            { true, FT_BYTE, "OldEnumValue" },
             { false, FT_BYTE, "Flags" },
-            { false, FT_BYTE, "ToggleDifficultyID" },
             { false, FT_BYTE, "ItemContext" },
-            { false, FT_BYTE, "OrderIndex" },
+            { false, FT_BYTE, "ToggleDifficultyID" },
+            { false, FT_SHORT, "GroupSizeHealthCurveID" },
+            { false, FT_SHORT, "GroupSizeDmgCurveID" },
+            { false, FT_SHORT, "GroupSizeSpellPointsCurveID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DifficultyMeta::Instance(), HOTFIX_SEL_DIFFICULTY);
         return &loadInfo;
@@ -1252,13 +1282,13 @@ struct DungeonEncounterLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_STRING, "Name" },
-            { true, FT_INT, "CreatureDisplayID" },
+            { false, FT_INT, "ID" },
             { true, FT_SHORT, "MapID" },
             { true, FT_BYTE, "DifficultyID" },
+            { true, FT_INT, "OrderIndex" },
             { true, FT_BYTE, "Bit" },
+            { true, FT_INT, "CreatureDisplayID" },
             { false, FT_BYTE, "Flags" },
-            { false, FT_INT, "ID" },
-            { true, FT_INT, "OrderIndex" },
             { true, FT_INT, "SpellIconFileID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DungeonEncounterMeta::Instance(), HOTFIX_SEL_DUNGEON_ENCOUNTER);
@@ -1331,13 +1361,13 @@ struct EmotesLoadInfo
             { false, FT_INT, "ID" },
             { true, FT_LONG, "RaceMask" },
             { false, FT_STRING_NOT_LOCALIZED, "EmoteSlashCommand" },
+            { true, FT_INT, "AnimID" },
             { false, FT_INT, "EmoteFlags" },
-            { false, FT_INT, "SpellVisualKitID" },
-            { true, FT_SHORT, "AnimID" },
             { false, FT_BYTE, "EmoteSpecProc" },
-            { true, FT_INT, "ClassMask" },
             { false, FT_INT, "EmoteSpecProcParam" },
             { false, FT_INT, "EventSoundID" },
+            { false, FT_INT, "SpellVisualKitID" },
+            { true, FT_INT, "ClassMask" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, EmotesMeta::Instance(), HOTFIX_SEL_EMOTES);
         return &loadInfo;
@@ -1367,8 +1397,8 @@ struct EmotesTextSoundLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_BYTE, "RaceID" },
-            { false, FT_BYTE, "SexID" },
             { false, FT_BYTE, "ClassID" },
+            { false, FT_BYTE, "SexID" },
             { false, FT_INT, "SoundID" },
             { false, FT_SHORT, "EmotesTextID" },
         };
@@ -1377,6 +1407,52 @@ struct EmotesTextSoundLoadInfo
     }
 };
 
+struct ExpectedStatLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_INT, "ID" },
+            { true, FT_INT, "ExpansionID" },
+            { false, FT_FLOAT, "CreatureHealth" },
+            { false, FT_FLOAT, "PlayerHealth" },
+            { false, FT_FLOAT, "CreatureAutoAttackDps" },
+            { false, FT_FLOAT, "CreatureArmor" },
+            { false, FT_FLOAT, "PlayerMana" },
+            { false, FT_FLOAT, "PlayerPrimaryStat" },
+            { false, FT_FLOAT, "PlayerSecondaryStat" },
+            { false, FT_FLOAT, "ArmorConstant" },
+            { false, FT_FLOAT, "CreatureSpellDamage" },
+            { true, FT_INT, "Lvl" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ExpectedStatMeta::Instance(), HOTFIX_SEL_EXPECTED_STAT);
+        return &loadInfo;
+    }
+};
+
+struct ExpectedStatModLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_INT, "ID" },
+            { false, FT_FLOAT, "CreatureHealthMod" },
+            { false, FT_FLOAT, "PlayerHealthMod" },
+            { false, FT_FLOAT, "CreatureAutoAttackDPSMod" },
+            { false, FT_FLOAT, "CreatureArmorMod" },
+            { false, FT_FLOAT, "PlayerManaMod" },
+            { false, FT_FLOAT, "PlayerPrimaryStatMod" },
+            { false, FT_FLOAT, "PlayerSecondaryStatMod" },
+            { false, FT_FLOAT, "ArmorConstantMod" },
+            { false, FT_FLOAT, "CreatureSpellDamageMod" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ExpectedStatModMeta::Instance(), HOTFIX_SEL_EXPECTED_STAT_MOD);
+        return &loadInfo;
+    }
+};
+
 struct FactionLoadInfo
 {
     static DB2LoadInfo const* Instance()
@@ -1390,17 +1466,12 @@ struct FactionLoadInfo
             { false, FT_STRING, "Name" },
             { false, FT_STRING, "Description" },
             { false, FT_INT, "ID" },
-            { true, FT_INT, "ReputationBase1" },
-            { true, FT_INT, "ReputationBase2" },
-            { true, FT_INT, "ReputationBase3" },
-            { true, FT_INT, "ReputationBase4" },
-            { false, FT_FLOAT, "ParentFactionMod1" },
-            { false, FT_FLOAT, "ParentFactionMod2" },
-            { true, FT_INT, "ReputationMax1" },
-            { true, FT_INT, "ReputationMax2" },
-            { true, FT_INT, "ReputationMax3" },
-            { true, FT_INT, "ReputationMax4" },
             { true, FT_SHORT, "ReputationIndex" },
+            { false, FT_SHORT, "ParentFactionID" },
+            { false, FT_BYTE, "Expansion" },
+            { false, FT_BYTE, "FriendshipRepID" },
+            { false, FT_BYTE, "Flags" },
+            { false, FT_SHORT, "ParagonFactionID" },
             { true, FT_SHORT, "ReputationClassMask1" },
             { true, FT_SHORT, "ReputationClassMask2" },
             { true, FT_SHORT, "ReputationClassMask3" },
@@ -1409,13 +1480,18 @@ struct FactionLoadInfo
             { false, FT_SHORT, "ReputationFlags2" },
             { false, FT_SHORT, "ReputationFlags3" },
             { false, FT_SHORT, "ReputationFlags4" },
-            { false, FT_SHORT, "ParentFactionID" },
-            { false, FT_SHORT, "ParagonFactionID" },
+            { true, FT_INT, "ReputationBase1" },
+            { true, FT_INT, "ReputationBase2" },
+            { true, FT_INT, "ReputationBase3" },
+            { true, FT_INT, "ReputationBase4" },
+            { true, FT_INT, "ReputationMax1" },
+            { true, FT_INT, "ReputationMax2" },
+            { true, FT_INT, "ReputationMax3" },
+            { true, FT_INT, "ReputationMax4" },
+            { false, FT_FLOAT, "ParentFactionMod1" },
+            { false, FT_FLOAT, "ParentFactionMod2" },
             { false, FT_BYTE, "ParentFactionCap1" },
             { false, FT_BYTE, "ParentFactionCap2" },
-            { false, FT_BYTE, "Expansion" },
-            { false, FT_BYTE, "Flags" },
-            { false, FT_BYTE, "FriendshipRepID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, FactionMeta::Instance(), HOTFIX_SEL_FACTION);
         return &loadInfo;
@@ -1431,6 +1507,9 @@ struct FactionTemplateLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_SHORT, "Faction" },
             { false, FT_SHORT, "Flags" },
+            { false, FT_BYTE, "FactionGroup" },
+            { false, FT_BYTE, "FriendGroup" },
+            { false, FT_BYTE, "EnemyGroup" },
             { false, FT_SHORT, "Enemies1" },
             { false, FT_SHORT, "Enemies2" },
             { false, FT_SHORT, "Enemies3" },
@@ -1439,9 +1518,6 @@ struct FactionTemplateLoadInfo
             { false, FT_SHORT, "Friend2" },
             { false, FT_SHORT, "Friend3" },
             { false, FT_SHORT, "Friend4" },
-            { false, FT_BYTE, "FactionGroup" },
-            { false, FT_BYTE, "FriendGroup" },
-            { false, FT_BYTE, "EnemyGroup" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, FactionTemplateMeta::Instance(), HOTFIX_SEL_FACTION_TEMPLATE);
         return &loadInfo;
@@ -1455,16 +1531,16 @@ struct GameobjectDisplayInfoLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "FileDataID" },
             { false, FT_FLOAT, "GeoBoxMinX" },
             { false, FT_FLOAT, "GeoBoxMinY" },
             { false, FT_FLOAT, "GeoBoxMinZ" },
             { false, FT_FLOAT, "GeoBoxMaxX" },
             { false, FT_FLOAT, "GeoBoxMaxY" },
             { false, FT_FLOAT, "GeoBoxMaxZ" },
+            { true, FT_INT, "FileDataID" },
+            { true, FT_SHORT, "ObjectEffectPackageID" },
             { false, FT_FLOAT, "OverrideLootEffectScale" },
             { false, FT_FLOAT, "OverrideNameScale" },
-            { true, FT_SHORT, "ObjectEffectPackageID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GameObjectDisplayInfoMeta::Instance(), HOTFIX_SEL_GAMEOBJECT_DISPLAY_INFO);
         return &loadInfo;
@@ -1485,7 +1561,14 @@ struct GameobjectsLoadInfo
             { false, FT_FLOAT, "Rot2" },
             { false, FT_FLOAT, "Rot3" },
             { false, FT_FLOAT, "Rot4" },
+            { false, FT_INT, "ID" },
+            { false, FT_SHORT, "OwnerID" },
+            { false, FT_SHORT, "DisplayID" },
             { false, FT_FLOAT, "Scale" },
+            { false, FT_BYTE, "TypeID" },
+            { false, FT_BYTE, "PhaseUseFlags" },
+            { false, FT_SHORT, "PhaseID" },
+            { false, FT_SHORT, "PhaseGroupID" },
             { true, FT_INT, "PropValue1" },
             { true, FT_INT, "PropValue2" },
             { true, FT_INT, "PropValue3" },
@@ -1494,13 +1577,6 @@ struct GameobjectsLoadInfo
             { true, FT_INT, "PropValue6" },
             { true, FT_INT, "PropValue7" },
             { true, FT_INT, "PropValue8" },
-            { false, FT_SHORT, "OwnerID" },
-            { false, FT_SHORT, "DisplayID" },
-            { false, FT_SHORT, "PhaseID" },
-            { false, FT_SHORT, "PhaseGroupID" },
-            { false, FT_BYTE, "PhaseUseFlags" },
-            { false, FT_BYTE, "TypeID" },
-            { false, FT_INT, "ID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GameObjectsMeta::Instance(), HOTFIX_SEL_GAMEOBJECTS);
         return &loadInfo;
@@ -1515,12 +1591,12 @@ struct GarrAbilityLoadInfo
         {
             { false, FT_STRING, "Name" },
             { false, FT_STRING, "Description" },
-            { true, FT_INT, "IconFileDataID" },
-            { false, FT_SHORT, "Flags" },
-            { false, FT_SHORT, "FactionChangeGarrAbilityID" },
+            { false, FT_INT, "ID" },
             { false, FT_BYTE, "GarrAbilityCategoryID" },
             { false, FT_BYTE, "GarrFollowerTypeID" },
-            { false, FT_INT, "ID" },
+            { true, FT_INT, "IconFileDataID" },
+            { false, FT_SHORT, "FactionChangeGarrAbilityID" },
+            { false, FT_SHORT, "Flags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrAbilityMeta::Instance(), HOTFIX_SEL_GARR_ABILITY);
         return &loadInfo;
@@ -1534,30 +1610,30 @@ struct GarrBuildingLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_STRING, "AllianceName" },
             { false, FT_STRING, "HordeName" },
+            { false, FT_STRING, "AllianceName" },
             { false, FT_STRING, "Description" },
             { false, FT_STRING, "Tooltip" },
+            { false, FT_BYTE, "GarrTypeID" },
+            { false, FT_BYTE, "BuildingType" },
             { true, FT_INT, "HordeGameObjectID" },
             { true, FT_INT, "AllianceGameObjectID" },
-            { true, FT_INT, "IconFileDataID" },
+            { false, FT_BYTE, "GarrSiteID" },
+            { false, FT_BYTE, "UpgradeLevel" },
+            { true, FT_INT, "BuildSeconds" },
             { false, FT_SHORT, "CurrencyTypeID" },
+            { true, FT_INT, "CurrencyQty" },
             { false, FT_SHORT, "HordeUiTextureKitID" },
             { false, FT_SHORT, "AllianceUiTextureKitID" },
+            { true, FT_INT, "IconFileDataID" },
             { false, FT_SHORT, "AllianceSceneScriptPackageID" },
             { false, FT_SHORT, "HordeSceneScriptPackageID" },
+            { true, FT_INT, "MaxAssignments" },
+            { false, FT_BYTE, "ShipmentCapacity" },
             { false, FT_SHORT, "GarrAbilityID" },
             { false, FT_SHORT, "BonusGarrAbilityID" },
             { false, FT_SHORT, "GoldCost" },
-            { false, FT_BYTE, "GarrSiteID" },
-            { false, FT_BYTE, "BuildingType" },
-            { false, FT_BYTE, "UpgradeLevel" },
             { false, FT_BYTE, "Flags" },
-            { false, FT_BYTE, "ShipmentCapacity" },
-            { false, FT_BYTE, "GarrTypeID" },
-            { true, FT_INT, "BuildSeconds" },
-            { true, FT_INT, "CurrencyQty" },
-            { true, FT_INT, "MaxAssignments" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrBuildingMeta::Instance(), HOTFIX_SEL_GARR_BUILDING);
         return &loadInfo;
@@ -1572,10 +1648,10 @@ struct GarrBuildingPlotInstLoadInfo
         {
             { false, FT_FLOAT, "MapOffsetX" },
             { false, FT_FLOAT, "MapOffsetY" },
-            { false, FT_SHORT, "UiTextureAtlasMemberID" },
-            { false, FT_SHORT, "GarrSiteLevelPlotInstID" },
-            { false, FT_BYTE, "GarrBuildingID" },
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "GarrBuildingID" },
+            { false, FT_SHORT, "GarrSiteLevelPlotInstID" },
+            { false, FT_SHORT, "UiTextureAtlasMemberID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrBuildingPlotInstMeta::Instance(), HOTFIX_SEL_GARR_BUILDING_PLOT_INST);
         return &loadInfo;
@@ -1591,11 +1667,11 @@ struct GarrClassSpecLoadInfo
             { false, FT_STRING, "ClassSpec" },
             { false, FT_STRING, "ClassSpecMale" },
             { false, FT_STRING, "ClassSpecFemale" },
+            { false, FT_INT, "ID" },
             { false, FT_SHORT, "UiTextureAtlasMemberID" },
             { false, FT_SHORT, "GarrFollItemSetID" },
             { false, FT_BYTE, "FollowerClassLimit" },
             { false, FT_BYTE, "Flags" },
-            { false, FT_INT, "ID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrClassSpecMeta::Instance(), HOTFIX_SEL_GARR_CLASS_SPEC);
         return &loadInfo;
@@ -1611,35 +1687,35 @@ struct GarrFollowerLoadInfo
             { false, FT_STRING, "HordeSourceText" },
             { false, FT_STRING, "AllianceSourceText" },
             { false, FT_STRING, "TitleName" },
+            { false, FT_INT, "ID" },
+            { false, FT_BYTE, "GarrTypeID" },
+            { false, FT_BYTE, "GarrFollowerTypeID" },
             { true, FT_INT, "HordeCreatureID" },
             { true, FT_INT, "AllianceCreatureID" },
-            { true, FT_INT, "HordeIconFileDataID" },
-            { true, FT_INT, "AllianceIconFileDataID" },
-            { false, FT_INT, "HordeSlottingBroadcastTextID" },
-            { false, FT_INT, "AllySlottingBroadcastTextID" },
-            { false, FT_SHORT, "HordeGarrFollItemSetID" },
-            { false, FT_SHORT, "AllianceGarrFollItemSetID" },
-            { false, FT_SHORT, "ItemLevelWeapon" },
-            { false, FT_SHORT, "ItemLevelArmor" },
-            { false, FT_SHORT, "HordeUITextureKitID" },
-            { false, FT_SHORT, "AllianceUITextureKitID" },
-            { false, FT_BYTE, "GarrFollowerTypeID" },
             { false, FT_BYTE, "HordeGarrFollRaceID" },
             { false, FT_BYTE, "AllianceGarrFollRaceID" },
-            { false, FT_BYTE, "Quality" },
             { false, FT_BYTE, "HordeGarrClassSpecID" },
             { false, FT_BYTE, "AllianceGarrClassSpecID" },
+            { false, FT_BYTE, "Quality" },
             { false, FT_BYTE, "FollowerLevel" },
-            { false, FT_BYTE, "Gender" },
-            { false, FT_BYTE, "Flags" },
+            { false, FT_SHORT, "ItemLevelWeapon" },
+            { false, FT_SHORT, "ItemLevelArmor" },
             { true, FT_BYTE, "HordeSourceTypeEnum" },
             { true, FT_BYTE, "AllianceSourceTypeEnum" },
-            { false, FT_BYTE, "GarrTypeID" },
+            { true, FT_INT, "HordeIconFileDataID" },
+            { true, FT_INT, "AllianceIconFileDataID" },
+            { false, FT_SHORT, "HordeGarrFollItemSetID" },
+            { false, FT_SHORT, "AllianceGarrFollItemSetID" },
+            { false, FT_SHORT, "HordeUITextureKitID" },
+            { false, FT_SHORT, "AllianceUITextureKitID" },
             { false, FT_BYTE, "Vitality" },
-            { false, FT_BYTE, "ChrClassID" },
             { false, FT_BYTE, "HordeFlavorGarrStringID" },
             { false, FT_BYTE, "AllianceFlavorGarrStringID" },
-            { false, FT_INT, "ID" },
+            { false, FT_INT, "HordeSlottingBroadcastTextID" },
+            { false, FT_INT, "AllySlottingBroadcastTextID" },
+            { false, FT_BYTE, "ChrClassID" },
+            { false, FT_BYTE, "Flags" },
+            { false, FT_BYTE, "Gender" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrFollowerMeta::Instance(), HOTFIX_SEL_GARR_FOLLOWER);
         return &loadInfo;
@@ -1653,8 +1729,9 @@ struct GarrFollowerXAbilityLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_SHORT, "GarrAbilityID" },
+            { false, FT_BYTE, "OrderIndex" },
             { false, FT_BYTE, "FactionIndex" },
+            { false, FT_SHORT, "GarrAbilityID" },
             { false, FT_SHORT, "GarrFollowerID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrFollowerXAbilityMeta::Instance(), HOTFIX_SEL_GARR_FOLLOWER_X_ABILITY);
@@ -1669,12 +1746,12 @@ struct GarrPlotLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_STRING, "Name" },
-            { true, FT_INT, "AllianceConstructObjID" },
-            { true, FT_INT, "HordeConstructObjID" },
-            { false, FT_BYTE, "UiCategoryID" },
+            { false, FT_STRING_NOT_LOCALIZED, "Name" },
             { false, FT_BYTE, "PlotType" },
+            { true, FT_INT, "HordeConstructObjID" },
+            { true, FT_INT, "AllianceConstructObjID" },
             { false, FT_BYTE, "Flags" },
+            { false, FT_BYTE, "UiCategoryID" },
             { false, FT_INT, "UpgradeRequirement1" },
             { false, FT_INT, "UpgradeRequirement2" },
         };
@@ -1722,14 +1799,14 @@ struct GarrSiteLevelLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_FLOAT, "TownHallUiPosX" },
             { false, FT_FLOAT, "TownHallUiPosY" },
+            { false, FT_INT, "GarrSiteID" },
+            { false, FT_BYTE, "GarrLevel" },
             { false, FT_SHORT, "MapID" },
-            { false, FT_SHORT, "UiTextureKitID" },
             { false, FT_SHORT, "UpgradeMovieID" },
+            { false, FT_SHORT, "UiTextureKitID" },
+            { false, FT_BYTE, "MaxBuildingLevel" },
             { false, FT_SHORT, "UpgradeCost" },
             { false, FT_SHORT, "UpgradeGoldCost" },
-            { false, FT_BYTE, "GarrLevel" },
-            { false, FT_BYTE, "GarrSiteID" },
-            { false, FT_BYTE, "MaxBuildingLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrSiteLevelMeta::Instance(), HOTFIX_SEL_GARR_SITE_LEVEL);
         return &loadInfo;
@@ -1761,8 +1838,8 @@ struct GemPropertiesLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "Type" },
             { false, FT_SHORT, "EnchantId" },
+            { true, FT_INT, "Type" },
             { false, FT_SHORT, "MinItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GemPropertiesMeta::Instance(), HOTFIX_SEL_GEM_PROPERTIES);
@@ -1825,8 +1902,8 @@ struct GuildColorBackgroundLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_BYTE, "Red" },
-            { false, FT_BYTE, "Green" },
             { false, FT_BYTE, "Blue" },
+            { false, FT_BYTE, "Green" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GuildColorBackgroundMeta::Instance(), HOTFIX_SEL_GUILD_COLOR_BACKGROUND);
         return &loadInfo;
@@ -1841,8 +1918,8 @@ struct GuildColorBorderLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_BYTE, "Red" },
-            { false, FT_BYTE, "Green" },
             { false, FT_BYTE, "Blue" },
+            { false, FT_BYTE, "Green" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GuildColorBorderMeta::Instance(), HOTFIX_SEL_GUILD_COLOR_BORDER);
         return &loadInfo;
@@ -1857,8 +1934,8 @@ struct GuildColorEmblemLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_BYTE, "Red" },
-            { false, FT_BYTE, "Green" },
             { false, FT_BYTE, "Blue" },
+            { false, FT_BYTE, "Green" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GuildColorEmblemMeta::Instance(), HOTFIX_SEL_GUILD_COLOR_EMBLEM);
         return &loadInfo;
@@ -1886,19 +1963,19 @@ struct HeirloomLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_STRING, "SourceText" },
+            { false, FT_INT, "ID" },
             { true, FT_INT, "ItemID" },
-            { true, FT_INT, "LegacyItemID" },
             { true, FT_INT, "LegacyUpgradedItemID" },
             { true, FT_INT, "StaticUpgradedItemID" },
+            { true, FT_BYTE, "SourceTypeEnum" },
+            { false, FT_BYTE, "Flags" },
+            { true, FT_INT, "LegacyItemID" },
             { true, FT_INT, "UpgradeItemID1" },
             { true, FT_INT, "UpgradeItemID2" },
             { true, FT_INT, "UpgradeItemID3" },
             { false, FT_SHORT, "UpgradeItemBonusListID1" },
             { false, FT_SHORT, "UpgradeItemBonusListID2" },
             { false, FT_SHORT, "UpgradeItemBonusListID3" },
-            { false, FT_BYTE, "Flags" },
-            { true, FT_BYTE, "SourceTypeEnum" },
-            { false, FT_INT, "ID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, HeirloomMeta::Instance(), HOTFIX_SEL_HEIRLOOM);
         return &loadInfo;
@@ -1912,6 +1989,23 @@ struct HolidaysLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_SHORT, "Region" },
+            { false, FT_BYTE, "Looping" },
+            { false, FT_INT, "HolidayNameID" },
+            { false, FT_INT, "HolidayDescriptionID" },
+            { false, FT_BYTE, "Priority" },
+            { true, FT_BYTE, "CalendarFilterType" },
+            { false, FT_BYTE, "Flags" },
+            { false, FT_SHORT, "Duration1" },
+            { false, FT_SHORT, "Duration2" },
+            { false, FT_SHORT, "Duration3" },
+            { false, FT_SHORT, "Duration4" },
+            { false, FT_SHORT, "Duration5" },
+            { false, FT_SHORT, "Duration6" },
+            { false, FT_SHORT, "Duration7" },
+            { false, FT_SHORT, "Duration8" },
+            { false, FT_SHORT, "Duration9" },
+            { false, FT_SHORT, "Duration10" },
             { false, FT_INT, "Date1" },
             { false, FT_INT, "Date2" },
             { false, FT_INT, "Date3" },
@@ -1928,18 +2022,6 @@ struct HolidaysLoadInfo
             { false, FT_INT, "Date14" },
             { false, FT_INT, "Date15" },
             { false, FT_INT, "Date16" },
-            { false, FT_SHORT, "Duration1" },
-            { false, FT_SHORT, "Duration2" },
-            { false, FT_SHORT, "Duration3" },
-            { false, FT_SHORT, "Duration4" },
-            { false, FT_SHORT, "Duration5" },
-            { false, FT_SHORT, "Duration6" },
-            { false, FT_SHORT, "Duration7" },
-            { false, FT_SHORT, "Duration8" },
-            { false, FT_SHORT, "Duration9" },
-            { false, FT_SHORT, "Duration10" },
-            { false, FT_SHORT, "Region" },
-            { false, FT_BYTE, "Looping" },
             { false, FT_BYTE, "CalendarFlags1" },
             { false, FT_BYTE, "CalendarFlags2" },
             { false, FT_BYTE, "CalendarFlags3" },
@@ -1950,11 +2032,6 @@ struct HolidaysLoadInfo
             { false, FT_BYTE, "CalendarFlags8" },
             { false, FT_BYTE, "CalendarFlags9" },
             { false, FT_BYTE, "CalendarFlags10" },
-            { false, FT_BYTE, "Priority" },
-            { true, FT_BYTE, "CalendarFilterType" },
-            { false, FT_BYTE, "Flags" },
-            { false, FT_INT, "HolidayNameID" },
-            { false, FT_INT, "HolidayDescriptionID" },
             { true, FT_INT, "TextureFileDataID1" },
             { true, FT_INT, "TextureFileDataID2" },
             { true, FT_INT, "TextureFileDataID3" },
@@ -2030,13 +2107,13 @@ struct ItemLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "IconFileDataID" },
             { false, FT_BYTE, "ClassID" },
             { false, FT_BYTE, "SubclassID" },
-            { true, FT_BYTE, "SoundOverrideSubclassID" },
             { false, FT_BYTE, "Material" },
-            { false, FT_BYTE, "InventoryType" },
+            { true, FT_BYTE, "InventoryType" },
             { false, FT_BYTE, "SheatheType" },
+            { true, FT_BYTE, "SoundOverrideSubclassID" },
+            { true, FT_INT, "IconFileDataID" },
             { false, FT_BYTE, "ItemGroupSoundsID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemMeta::Instance(), HOTFIX_SEL_ITEM);
@@ -2051,10 +2128,10 @@ struct ItemAppearanceLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "DisplayType" },
             { true, FT_INT, "ItemDisplayInfoID" },
             { true, FT_INT, "DefaultIconFileDataID" },
             { true, FT_INT, "UiOrder" },
-            { false, FT_BYTE, "DisplayType" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemAppearanceMeta::Instance(), HOTFIX_SEL_ITEM_APPEARANCE);
         return &loadInfo;
@@ -2075,7 +2152,6 @@ struct ItemArmorQualityLoadInfo
             { false, FT_FLOAT, "Qualitymod5" },
             { false, FT_FLOAT, "Qualitymod6" },
             { false, FT_FLOAT, "Qualitymod7" },
-            { true, FT_SHORT, "ItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemArmorQualityMeta::Instance(), HOTFIX_SEL_ITEM_ARMOR_QUALITY);
         return &loadInfo;
@@ -2110,11 +2186,11 @@ struct ItemArmorTotalLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { true, FT_SHORT, "ItemLevel" },
             { false, FT_FLOAT, "Cloth" },
             { false, FT_FLOAT, "Leather" },
             { false, FT_FLOAT, "Mail" },
             { false, FT_FLOAT, "Plate" },
-            { true, FT_SHORT, "ItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemArmorTotalMeta::Instance(), HOTFIX_SEL_ITEM_ARMOR_TOTAL);
         return &loadInfo;
@@ -2175,10 +2251,10 @@ struct ItemBonusTreeNodeLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "ItemContext" },
             { false, FT_SHORT, "ChildItemBonusTreeID" },
             { false, FT_SHORT, "ChildItemBonusListID" },
             { false, FT_SHORT, "ChildItemLevelSelectorID" },
-            { false, FT_BYTE, "ItemContext" },
             { false, FT_SHORT, "ParentItemBonusTreeID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemBonusTreeNodeMeta::Instance(), HOTFIX_SEL_ITEM_BONUS_TREE_NODE);
@@ -2210,8 +2286,8 @@ struct ItemClassLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "ClassName" },
-            { false, FT_FLOAT, "PriceModifier" },
             { true, FT_BYTE, "ClassID" },
+            { false, FT_FLOAT, "PriceModifier" },
             { false, FT_BYTE, "Flags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemClassMeta::Instance(), HOTFIX_SEL_ITEM_CLASS);
@@ -2240,6 +2316,7 @@ struct ItemDamageAmmoLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_SHORT, "ItemLevel" },
             { false, FT_FLOAT, "Quality1" },
             { false, FT_FLOAT, "Quality2" },
             { false, FT_FLOAT, "Quality3" },
@@ -2247,7 +2324,6 @@ struct ItemDamageAmmoLoadInfo
             { false, FT_FLOAT, "Quality5" },
             { false, FT_FLOAT, "Quality6" },
             { false, FT_FLOAT, "Quality7" },
-            { false, FT_SHORT, "ItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDamageAmmoMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_AMMO);
         return &loadInfo;
@@ -2261,6 +2337,7 @@ struct ItemDamageOneHandLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_SHORT, "ItemLevel" },
             { false, FT_FLOAT, "Quality1" },
             { false, FT_FLOAT, "Quality2" },
             { false, FT_FLOAT, "Quality3" },
@@ -2268,7 +2345,6 @@ struct ItemDamageOneHandLoadInfo
             { false, FT_FLOAT, "Quality5" },
             { false, FT_FLOAT, "Quality6" },
             { false, FT_FLOAT, "Quality7" },
-            { false, FT_SHORT, "ItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDamageOneHandMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_ONE_HAND);
         return &loadInfo;
@@ -2282,6 +2358,7 @@ struct ItemDamageOneHandCasterLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_SHORT, "ItemLevel" },
             { false, FT_FLOAT, "Quality1" },
             { false, FT_FLOAT, "Quality2" },
             { false, FT_FLOAT, "Quality3" },
@@ -2289,7 +2366,6 @@ struct ItemDamageOneHandCasterLoadInfo
             { false, FT_FLOAT, "Quality5" },
             { false, FT_FLOAT, "Quality6" },
             { false, FT_FLOAT, "Quality7" },
-            { false, FT_SHORT, "ItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDamageOneHandCasterMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_ONE_HAND_CASTER);
         return &loadInfo;
@@ -2303,6 +2379,7 @@ struct ItemDamageTwoHandLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_SHORT, "ItemLevel" },
             { false, FT_FLOAT, "Quality1" },
             { false, FT_FLOAT, "Quality2" },
             { false, FT_FLOAT, "Quality3" },
@@ -2310,7 +2387,6 @@ struct ItemDamageTwoHandLoadInfo
             { false, FT_FLOAT, "Quality5" },
             { false, FT_FLOAT, "Quality6" },
             { false, FT_FLOAT, "Quality7" },
-            { false, FT_SHORT, "ItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDamageTwoHandMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_TWO_HAND);
         return &loadInfo;
@@ -2324,6 +2400,7 @@ struct ItemDamageTwoHandCasterLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_SHORT, "ItemLevel" },
             { false, FT_FLOAT, "Quality1" },
             { false, FT_FLOAT, "Quality2" },
             { false, FT_FLOAT, "Quality3" },
@@ -2331,7 +2408,6 @@ struct ItemDamageTwoHandCasterLoadInfo
             { false, FT_FLOAT, "Quality5" },
             { false, FT_FLOAT, "Quality6" },
             { false, FT_FLOAT, "Quality7" },
-            { false, FT_SHORT, "ItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDamageTwoHandCasterMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_TWO_HAND_CASTER);
         return &loadInfo;
@@ -2345,11 +2421,11 @@ struct ItemDisenchantLootLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { true, FT_BYTE, "Subclass" },
+            { false, FT_BYTE, "Quality" },
             { false, FT_SHORT, "MinLevel" },
             { false, FT_SHORT, "MaxLevel" },
             { false, FT_SHORT, "SkillRequired" },
-            { true, FT_BYTE, "Subclass" },
-            { false, FT_BYTE, "Quality" },
             { true, FT_BYTE, "ExpansionID" },
             { false, FT_BYTE, "Class" },
         };
@@ -2365,14 +2441,14 @@ struct ItemEffectLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "SpellID" },
+            { false, FT_BYTE, "LegacySlotIndex" },
+            { true, FT_BYTE, "TriggerType" },
+            { true, FT_SHORT, "Charges" },
             { true, FT_INT, "CoolDownMSec" },
             { true, FT_INT, "CategoryCoolDownMSec" },
-            { true, FT_SHORT, "Charges" },
             { false, FT_SHORT, "SpellCategoryID" },
+            { true, FT_INT, "SpellID" },
             { false, FT_SHORT, "ChrSpecializationID" },
-            { false, FT_BYTE, "LegacySlotIndex" },
-            { true, FT_BYTE, "TriggerType" },
             { true, FT_INT, "ParentItemID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemEffectMeta::Instance(), HOTFIX_SEL_ITEM_EFFECT);
@@ -2387,32 +2463,32 @@ struct ItemExtendedCostLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_SHORT, "RequiredArenaRating" },
+            { true, FT_BYTE, "ArenaBracket" },
+            { false, FT_BYTE, "Flags" },
+            { false, FT_BYTE, "MinFactionID" },
+            { false, FT_BYTE, "MinReputation" },
+            { false, FT_BYTE, "RequiredAchievement" },
             { true, FT_INT, "ItemID1" },
             { true, FT_INT, "ItemID2" },
             { true, FT_INT, "ItemID3" },
             { true, FT_INT, "ItemID4" },
             { true, FT_INT, "ItemID5" },
-            { false, FT_INT, "CurrencyCount1" },
-            { false, FT_INT, "CurrencyCount2" },
-            { false, FT_INT, "CurrencyCount3" },
-            { false, FT_INT, "CurrencyCount4" },
-            { false, FT_INT, "CurrencyCount5" },
             { false, FT_SHORT, "ItemCount1" },
             { false, FT_SHORT, "ItemCount2" },
             { false, FT_SHORT, "ItemCount3" },
             { false, FT_SHORT, "ItemCount4" },
             { false, FT_SHORT, "ItemCount5" },
-            { false, FT_SHORT, "RequiredArenaRating" },
             { false, FT_SHORT, "CurrencyID1" },
             { false, FT_SHORT, "CurrencyID2" },
             { false, FT_SHORT, "CurrencyID3" },
             { false, FT_SHORT, "CurrencyID4" },
             { false, FT_SHORT, "CurrencyID5" },
-            { false, FT_BYTE, "ArenaBracket" },
-            { false, FT_BYTE, "MinFactionID" },
-            { false, FT_BYTE, "MinReputation" },
-            { false, FT_BYTE, "Flags" },
-            { false, FT_BYTE, "RequiredAchievement" },
+            { false, FT_INT, "CurrencyCount1" },
+            { false, FT_INT, "CurrencyCount2" },
+            { false, FT_INT, "CurrencyCount3" },
+            { false, FT_INT, "CurrencyCount4" },
+            { false, FT_INT, "CurrencyCount5" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemExtendedCostMeta::Instance(), HOTFIX_SEL_ITEM_EXTENDED_COST);
         return &loadInfo;
@@ -2503,8 +2579,8 @@ struct ItemModifiedAppearanceLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { true, FT_INT, "ItemID" },
             { false, FT_INT, "ID" },
+            { true, FT_INT, "ItemID" },
             { false, FT_BYTE, "ItemAppearanceModifierID" },
             { false, FT_SHORT, "ItemAppearanceID" },
             { false, FT_BYTE, "OrderIndex" },
@@ -2522,9 +2598,9 @@ struct ItemPriceBaseLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_SHORT, "ItemLevel" },
             { false, FT_FLOAT, "Armor" },
             { false, FT_FLOAT, "Weapon" },
-            { false, FT_SHORT, "ItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemPriceBaseMeta::Instance(), HOTFIX_SEL_ITEM_PRICE_BASE);
         return &loadInfo;
@@ -2583,19 +2659,20 @@ struct ItemSearchNameLoadInfo
             { true, FT_LONG, "AllowableRace" },
             { false, FT_STRING, "Display" },
             { false, FT_INT, "ID" },
-            { true, FT_INT, "Flags1" },
-            { true, FT_INT, "Flags2" },
-            { true, FT_INT, "Flags3" },
-            { false, FT_SHORT, "ItemLevel" },
             { false, FT_BYTE, "OverallQualityID" },
             { false, FT_BYTE, "ExpansionID" },
-            { true, FT_BYTE, "RequiredLevel" },
             { false, FT_SHORT, "MinFactionID" },
             { false, FT_BYTE, "MinReputation" },
             { true, FT_INT, "AllowableClass" },
+            { true, FT_BYTE, "RequiredLevel" },
             { false, FT_SHORT, "RequiredSkill" },
             { false, FT_SHORT, "RequiredSkillRank" },
             { false, FT_INT, "RequiredAbility" },
+            { false, FT_SHORT, "ItemLevel" },
+            { true, FT_INT, "Flags1" },
+            { true, FT_INT, "Flags2" },
+            { true, FT_INT, "Flags3" },
+            { true, FT_INT, "Flags4" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemSearchNameMeta::Instance(), HOTFIX_SEL_ITEM_SEARCH_NAME);
         return &loadInfo;
@@ -2610,6 +2687,9 @@ struct ItemSetLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
+            { false, FT_INT, "SetFlags" },
+            { false, FT_INT, "RequiredSkill" },
+            { false, FT_SHORT, "RequiredSkillRank" },
             { false, FT_INT, "ItemID1" },
             { false, FT_INT, "ItemID2" },
             { false, FT_INT, "ItemID3" },
@@ -2627,9 +2707,6 @@ struct ItemSetLoadInfo
             { false, FT_INT, "ItemID15" },
             { false, FT_INT, "ItemID16" },
             { false, FT_INT, "ItemID17" },
-            { false, FT_SHORT, "RequiredSkillRank" },
-            { false, FT_INT, "RequiredSkill" },
-            { false, FT_INT, "SetFlags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemSetMeta::Instance(), HOTFIX_SEL_ITEM_SET);
         return &loadInfo;
@@ -2643,8 +2720,8 @@ struct ItemSetSpellLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "SpellID" },
             { false, FT_SHORT, "ChrSpecID" },
+            { false, FT_INT, "SpellID" },
             { false, FT_BYTE, "Threshold" },
             { false, FT_SHORT, "ItemSetID" },
         };
@@ -2661,33 +2738,16 @@ struct ItemSparseLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_LONG, "AllowableRace" },
-            { false, FT_STRING, "Display" },
-            { false, FT_STRING, "Display1" },
-            { false, FT_STRING, "Display2" },
-            { false, FT_STRING, "Display3" },
             { false, FT_STRING, "Description" },
-            { true, FT_INT, "Flags1" },
-            { true, FT_INT, "Flags2" },
-            { true, FT_INT, "Flags3" },
-            { true, FT_INT, "Flags4" },
-            { false, FT_FLOAT, "PriceRandomValue" },
-            { false, FT_FLOAT, "PriceVariance" },
-            { false, FT_INT, "VendorStackCount" },
-            { false, FT_INT, "BuyPrice" },
-            { false, FT_INT, "SellPrice" },
-            { false, FT_INT, "RequiredAbility" },
-            { true, FT_INT, "MaxCount" },
-            { true, FT_INT, "Stackable" },
-            { true, FT_INT, "StatPercentEditor1" },
-            { true, FT_INT, "StatPercentEditor2" },
-            { true, FT_INT, "StatPercentEditor3" },
-            { true, FT_INT, "StatPercentEditor4" },
-            { true, FT_INT, "StatPercentEditor5" },
-            { true, FT_INT, "StatPercentEditor6" },
-            { true, FT_INT, "StatPercentEditor7" },
-            { true, FT_INT, "StatPercentEditor8" },
-            { true, FT_INT, "StatPercentEditor9" },
-            { true, FT_INT, "StatPercentEditor10" },
+            { false, FT_STRING, "Display3" },
+            { false, FT_STRING, "Display2" },
+            { false, FT_STRING, "Display1" },
+            { false, FT_STRING, "Display" },
+            { false, FT_FLOAT, "DmgVariance" },
+            { false, FT_INT, "DurationInInventory" },
+            { false, FT_FLOAT, "QualityModifier" },
+            { false, FT_INT, "BagFamily" },
+            { false, FT_FLOAT, "ItemRange" },
             { false, FT_FLOAT, "StatPercentageOfSocket1" },
             { false, FT_FLOAT, "StatPercentageOfSocket2" },
             { false, FT_FLOAT, "StatPercentageOfSocket3" },
@@ -2698,50 +2758,64 @@ struct ItemSparseLoadInfo
             { false, FT_FLOAT, "StatPercentageOfSocket8" },
             { false, FT_FLOAT, "StatPercentageOfSocket9" },
             { false, FT_FLOAT, "StatPercentageOfSocket10" },
-            { false, FT_FLOAT, "ItemRange" },
-            { false, FT_INT, "BagFamily" },
-            { false, FT_FLOAT, "QualityModifier" },
-            { false, FT_INT, "DurationInInventory" },
-            { false, FT_FLOAT, "DmgVariance" },
-            { true, FT_SHORT, "AllowableClass" },
-            { false, FT_SHORT, "ItemLevel" },
-            { false, FT_SHORT, "RequiredSkill" },
-            { false, FT_SHORT, "RequiredSkillRank" },
-            { false, FT_SHORT, "MinFactionID" },
-            { true, FT_SHORT, "ItemStatValue1" },
-            { true, FT_SHORT, "ItemStatValue2" },
-            { true, FT_SHORT, "ItemStatValue3" },
-            { true, FT_SHORT, "ItemStatValue4" },
-            { true, FT_SHORT, "ItemStatValue5" },
-            { true, FT_SHORT, "ItemStatValue6" },
-            { true, FT_SHORT, "ItemStatValue7" },
-            { true, FT_SHORT, "ItemStatValue8" },
-            { true, FT_SHORT, "ItemStatValue9" },
-            { true, FT_SHORT, "ItemStatValue10" },
-            { false, FT_SHORT, "ScalingStatDistributionID" },
-            { false, FT_SHORT, "ItemDelay" },
-            { false, FT_SHORT, "PageID" },
-            { false, FT_SHORT, "StartQuestID" },
-            { false, FT_SHORT, "LockID" },
-            { false, FT_SHORT, "RandomSelect" },
-            { false, FT_SHORT, "ItemRandomSuffixGroupID" },
-            { false, FT_SHORT, "ItemSet" },
-            { false, FT_SHORT, "ZoneBound" },
-            { false, FT_SHORT, "InstanceBound" },
-            { false, FT_SHORT, "TotemCategoryID" },
-            { false, FT_SHORT, "SocketMatchEnchantmentId" },
-            { false, FT_SHORT, "GemProperties" },
-            { false, FT_SHORT, "LimitCategory" },
-            { false, FT_SHORT, "RequiredHoliday" },
-            { false, FT_SHORT, "RequiredTransmogHoliday" },
+            { true, FT_INT, "StatPercentEditor1" },
+            { true, FT_INT, "StatPercentEditor2" },
+            { true, FT_INT, "StatPercentEditor3" },
+            { true, FT_INT, "StatPercentEditor4" },
+            { true, FT_INT, "StatPercentEditor5" },
+            { true, FT_INT, "StatPercentEditor6" },
+            { true, FT_INT, "StatPercentEditor7" },
+            { true, FT_INT, "StatPercentEditor8" },
+            { true, FT_INT, "StatPercentEditor9" },
+            { true, FT_INT, "StatPercentEditor10" },
+            { true, FT_INT, "Stackable" },
+            { true, FT_INT, "MaxCount" },
+            { false, FT_INT, "RequiredAbility" },
+            { false, FT_INT, "SellPrice" },
+            { false, FT_INT, "BuyPrice" },
+            { false, FT_INT, "VendorStackCount" },
+            { false, FT_FLOAT, "PriceVariance" },
+            { false, FT_FLOAT, "PriceRandomValue" },
+            { true, FT_INT, "Flags1" },
+            { true, FT_INT, "Flags2" },
+            { true, FT_INT, "Flags3" },
+            { true, FT_INT, "Flags4" },
+            { true, FT_INT, "FactionRelated" },
             { false, FT_SHORT, "ItemNameDescriptionID" },
-            { false, FT_BYTE, "OverallQualityID" },
-            { false, FT_BYTE, "InventoryType" },
-            { true, FT_BYTE, "RequiredLevel" },
-            { false, FT_BYTE, "RequiredPVPRank" },
-            { false, FT_BYTE, "RequiredPVPMedal" },
-            { false, FT_BYTE, "MinReputation" },
-            { false, FT_BYTE, "ContainerSlots" },
+            { false, FT_SHORT, "RequiredTransmogHoliday" },
+            { false, FT_SHORT, "RequiredHoliday" },
+            { false, FT_SHORT, "LimitCategory" },
+            { false, FT_SHORT, "GemProperties" },
+            { false, FT_SHORT, "SocketMatchEnchantmentId" },
+            { false, FT_SHORT, "TotemCategoryID" },
+            { false, FT_SHORT, "InstanceBound" },
+            { false, FT_SHORT, "ZoneBound" },
+            { false, FT_SHORT, "ItemSet" },
+            { false, FT_SHORT, "ItemRandomSuffixGroupID" },
+            { false, FT_SHORT, "RandomSelect" },
+            { false, FT_SHORT, "LockID" },
+            { false, FT_SHORT, "StartQuestID" },
+            { false, FT_SHORT, "PageID" },
+            { false, FT_SHORT, "ItemDelay" },
+            { false, FT_SHORT, "ScalingStatDistributionID" },
+            { false, FT_SHORT, "MinFactionID" },
+            { false, FT_SHORT, "RequiredSkillRank" },
+            { false, FT_SHORT, "RequiredSkill" },
+            { false, FT_SHORT, "ItemLevel" },
+            { true, FT_SHORT, "AllowableClass" },
+            { false, FT_BYTE, "ExpansionID" },
+            { false, FT_BYTE, "ArtifactID" },
+            { false, FT_BYTE, "SpellWeight" },
+            { false, FT_BYTE, "SpellWeightCategory" },
+            { false, FT_BYTE, "SocketType1" },
+            { false, FT_BYTE, "SocketType2" },
+            { false, FT_BYTE, "SocketType3" },
+            { false, FT_BYTE, "SheatheType" },
+            { false, FT_BYTE, "Material" },
+            { false, FT_BYTE, "PageMaterialID" },
+            { false, FT_BYTE, "LanguageID" },
+            { false, FT_BYTE, "Bonding" },
+            { false, FT_BYTE, "DamageDamageType" },
             { true, FT_BYTE, "StatModifierBonusStat1" },
             { true, FT_BYTE, "StatModifierBonusStat2" },
             { true, FT_BYTE, "StatModifierBonusStat3" },
@@ -2752,19 +2826,13 @@ struct ItemSparseLoadInfo
             { true, FT_BYTE, "StatModifierBonusStat8" },
             { true, FT_BYTE, "StatModifierBonusStat9" },
             { true, FT_BYTE, "StatModifierBonusStat10" },
-            { false, FT_BYTE, "DamageDamageType" },
-            { false, FT_BYTE, "Bonding" },
-            { false, FT_BYTE, "LanguageID" },
-            { false, FT_BYTE, "PageMaterialID" },
-            { false, FT_BYTE, "Material" },
-            { false, FT_BYTE, "SheatheType" },
-            { false, FT_BYTE, "SocketType1" },
-            { false, FT_BYTE, "SocketType2" },
-            { false, FT_BYTE, "SocketType3" },
-            { false, FT_BYTE, "SpellWeightCategory" },
-            { false, FT_BYTE, "SpellWeight" },
-            { false, FT_BYTE, "ArtifactID" },
-            { false, FT_BYTE, "ExpansionID" },
+            { false, FT_BYTE, "ContainerSlots" },
+            { false, FT_BYTE, "MinReputation" },
+            { false, FT_BYTE, "RequiredPVPMedal" },
+            { false, FT_BYTE, "RequiredPVPRank" },
+            { true, FT_BYTE, "RequiredLevel" },
+            { false, FT_BYTE, "InventoryType" },
+            { false, FT_BYTE, "OverallQualityID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemSparseMeta::Instance(), HOTFIX_SEL_ITEM_SPARSE);
         return &loadInfo;
@@ -2778,12 +2846,12 @@ struct ItemSpecLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_SHORT, "SpecializationID" },
             { false, FT_BYTE, "MinLevel" },
             { false, FT_BYTE, "MaxLevel" },
             { false, FT_BYTE, "ItemType" },
             { false, FT_BYTE, "PrimaryStat" },
             { false, FT_BYTE, "SecondaryStat" },
+            { false, FT_SHORT, "SpecializationID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemSpecMeta::Instance(), HOTFIX_SEL_ITEM_SPEC);
         return &loadInfo;
@@ -2812,11 +2880,11 @@ struct ItemUpgradeLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "CurrencyAmount" },
-            { false, FT_SHORT, "PrerequisiteID" },
-            { false, FT_SHORT, "CurrencyType" },
             { false, FT_BYTE, "ItemUpgradePathID" },
             { false, FT_BYTE, "ItemLevelIncrement" },
+            { false, FT_SHORT, "PrerequisiteID" },
+            { false, FT_SHORT, "CurrencyType" },
+            { false, FT_INT, "CurrencyAmount" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemUpgradeMeta::Instance(), HOTFIX_SEL_ITEM_UPGRADE);
         return &loadInfo;
@@ -2892,37 +2960,38 @@ struct LfgDungeonsLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
             { false, FT_STRING, "Description" },
-            { true, FT_INT, "Flags" },
-            { false, FT_FLOAT, "MinGear" },
-            { false, FT_SHORT, "MaxLevel" },
-            { false, FT_SHORT, "TargetLevelMax" },
-            { true, FT_SHORT, "MapID" },
-            { false, FT_SHORT, "RandomID" },
-            { false, FT_SHORT, "ScenarioID" },
-            { false, FT_SHORT, "FinalEncounterID" },
-            { false, FT_SHORT, "BonusReputationAmount" },
-            { false, FT_SHORT, "MentorItemLevel" },
-            { false, FT_SHORT, "RequiredPlayerConditionId" },
             { false, FT_BYTE, "MinLevel" },
-            { false, FT_BYTE, "TargetLevel" },
-            { false, FT_BYTE, "TargetLevelMin" },
-            { false, FT_BYTE, "DifficultyID" },
+            { false, FT_SHORT, "MaxLevel" },
             { false, FT_BYTE, "TypeID" },
+            { false, FT_BYTE, "Subtype" },
             { true, FT_BYTE, "Faction" },
+            { true, FT_INT, "IconTextureFileID" },
+            { true, FT_INT, "RewardsBgTextureFileID" },
+            { true, FT_INT, "PopupBgTextureFileID" },
             { false, FT_BYTE, "ExpansionLevel" },
-            { false, FT_BYTE, "OrderIndex" },
+            { true, FT_SHORT, "MapID" },
+            { false, FT_BYTE, "DifficultyID" },
+            { false, FT_FLOAT, "MinGear" },
             { false, FT_BYTE, "GroupID" },
+            { false, FT_BYTE, "OrderIndex" },
+            { false, FT_INT, "RequiredPlayerConditionId" },
+            { false, FT_BYTE, "TargetLevel" },
+            { false, FT_BYTE, "TargetLevelMin" },
+            { false, FT_SHORT, "TargetLevelMax" },
+            { false, FT_SHORT, "RandomID" },
+            { false, FT_SHORT, "ScenarioID" },
+            { false, FT_SHORT, "FinalEncounterID" },
             { false, FT_BYTE, "CountTank" },
             { false, FT_BYTE, "CountHealer" },
             { false, FT_BYTE, "CountDamage" },
             { false, FT_BYTE, "MinCountTank" },
             { false, FT_BYTE, "MinCountHealer" },
             { false, FT_BYTE, "MinCountDamage" },
-            { false, FT_BYTE, "Subtype" },
+            { false, FT_SHORT, "BonusReputationAmount" },
+            { false, FT_SHORT, "MentorItemLevel" },
             { false, FT_BYTE, "MentorCharLevel" },
-            { true, FT_INT, "IconTextureFileID" },
-            { true, FT_INT, "RewardsBgTextureFileID" },
-            { true, FT_INT, "PopupBgTextureFileID" },
+            { true, FT_INT, "Flags1" },
+            { true, FT_INT, "Flags2" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LFGDungeonsMeta::Instance(), HOTFIX_SEL_LFG_DUNGEONS);
         return &loadInfo;
@@ -2970,12 +3039,26 @@ struct LiquidTypeLoadInfo
             { false, FT_STRING_NOT_LOCALIZED, "Texture4" },
             { false, FT_STRING_NOT_LOCALIZED, "Texture5" },
             { false, FT_STRING_NOT_LOCALIZED, "Texture6" },
+            { false, FT_SHORT, "Flags" },
+            { false, FT_BYTE, "SoundBank" },
+            { false, FT_INT, "SoundID" },
             { false, FT_INT, "SpellID" },
             { false, FT_FLOAT, "MaxDarkenDepth" },
             { false, FT_FLOAT, "FogDarkenIntensity" },
             { false, FT_FLOAT, "AmbDarkenIntensity" },
             { false, FT_FLOAT, "DirDarkenIntensity" },
+            { false, FT_SHORT, "LightID" },
             { false, FT_FLOAT, "ParticleScale" },
+            { false, FT_BYTE, "ParticleMovement" },
+            { false, FT_BYTE, "ParticleTexSlots" },
+            { false, FT_BYTE, "MaterialID" },
+            { true, FT_INT, "MinimapStaticCol" },
+            { false, FT_BYTE, "FrameCountTexture1" },
+            { false, FT_BYTE, "FrameCountTexture2" },
+            { false, FT_BYTE, "FrameCountTexture3" },
+            { false, FT_BYTE, "FrameCountTexture4" },
+            { false, FT_BYTE, "FrameCountTexture5" },
+            { false, FT_BYTE, "FrameCountTexture6" },
             { true, FT_INT, "Color1" },
             { true, FT_INT, "Color2" },
             { false, FT_FLOAT, "Float1" },
@@ -3000,19 +3083,10 @@ struct LiquidTypeLoadInfo
             { false, FT_INT, "Int2" },
             { false, FT_INT, "Int3" },
             { false, FT_INT, "Int4" },
-            { false, FT_SHORT, "Flags" },
-            { false, FT_SHORT, "LightID" },
-            { false, FT_BYTE, "SoundBank" },
-            { false, FT_BYTE, "ParticleMovement" },
-            { false, FT_BYTE, "ParticleTexSlots" },
-            { false, FT_BYTE, "MaterialID" },
-            { false, FT_BYTE, "FrameCountTexture1" },
-            { false, FT_BYTE, "FrameCountTexture2" },
-            { false, FT_BYTE, "FrameCountTexture3" },
-            { false, FT_BYTE, "FrameCountTexture4" },
-            { false, FT_BYTE, "FrameCountTexture5" },
-            { false, FT_BYTE, "FrameCountTexture6" },
-            { false, FT_INT, "SoundID" },
+            { false, FT_FLOAT, "Coefficient1" },
+            { false, FT_FLOAT, "Coefficient2" },
+            { false, FT_FLOAT, "Coefficient3" },
+            { false, FT_FLOAT, "Coefficient4" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LiquidTypeMeta::Instance(), HOTFIX_SEL_LIQUID_TYPE);
         return &loadInfo;
@@ -3091,23 +3165,24 @@ struct MapLoadInfo
             { false, FT_STRING, "MapDescription1" },
             { false, FT_STRING, "PvpShortDescription" },
             { false, FT_STRING, "PvpLongDescription" },
-            { true, FT_INT, "Flags1" },
-            { true, FT_INT, "Flags2" },
-            { false, FT_FLOAT, "MinimapIconScale" },
             { false, FT_FLOAT, "CorpseX" },
             { false, FT_FLOAT, "CorpseY" },
+            { false, FT_BYTE, "MapType" },
+            { true, FT_BYTE, "InstanceType" },
+            { false, FT_BYTE, "ExpansionID" },
             { false, FT_SHORT, "AreaTableID" },
             { true, FT_SHORT, "LoadingScreenID" },
-            { true, FT_SHORT, "CorpseMapID" },
             { true, FT_SHORT, "TimeOfDayOverride" },
             { true, FT_SHORT, "ParentMapID" },
             { true, FT_SHORT, "CosmeticParentMapID" },
-            { true, FT_SHORT, "WindSettingsID" },
-            { false, FT_BYTE, "InstanceType" },
-            { false, FT_BYTE, "MapType" },
-            { false, FT_BYTE, "ExpansionID" },
-            { false, FT_BYTE, "MaxPlayers" },
             { false, FT_BYTE, "TimeOffset" },
+            { false, FT_FLOAT, "MinimapIconScale" },
+            { true, FT_SHORT, "CorpseMapID" },
+            { false, FT_BYTE, "MaxPlayers" },
+            { true, FT_SHORT, "WindSettingsID" },
+            { true, FT_INT, "ZmpFileDataID" },
+            { true, FT_INT, "Flags1" },
+            { true, FT_INT, "Flags2" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MapMeta::Instance(), HOTFIX_SEL_MAP);
         return &loadInfo;
@@ -3122,13 +3197,14 @@ struct MapDifficultyLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Message" },
+            { false, FT_INT, "ItemContextPickerID" },
+            { true, FT_INT, "ContentTuningID" },
             { false, FT_BYTE, "DifficultyID" },
+            { false, FT_BYTE, "LockID" },
             { false, FT_BYTE, "ResetInterval" },
             { false, FT_BYTE, "MaxPlayers" },
-            { false, FT_BYTE, "LockID" },
-            { false, FT_BYTE, "Flags" },
             { false, FT_BYTE, "ItemContext" },
-            { false, FT_INT, "ItemContextPickerID" },
+            { false, FT_BYTE, "Flags" },
             { false, FT_SHORT, "MapID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MapDifficultyMeta::Instance(), HOTFIX_SEL_MAP_DIFFICULTY);
@@ -3143,13 +3219,13 @@ struct ModifierTreeLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "Asset" },
-            { true, FT_INT, "SecondaryAsset" },
             { false, FT_INT, "Parent" },
-            { false, FT_BYTE, "Type" },
-            { true, FT_BYTE, "TertiaryAsset" },
             { true, FT_BYTE, "Operator" },
             { true, FT_BYTE, "Amount" },
+            { false, FT_BYTE, "Type" },
+            { true, FT_INT, "Asset" },
+            { true, FT_INT, "SecondaryAsset" },
+            { true, FT_BYTE, "TertiaryAsset" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ModifierTreeMeta::Instance(), HOTFIX_SEL_MODIFIER_TREE);
         return &loadInfo;
@@ -3163,15 +3239,15 @@ struct MountLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_STRING, "Name" },
-            { false, FT_STRING, "Description" },
             { false, FT_STRING, "SourceText" },
-            { true, FT_INT, "SourceSpellID" },
-            { false, FT_FLOAT, "MountFlyRideHeight" },
+            { false, FT_STRING, "Description" },
+            { false, FT_INT, "ID" },
             { false, FT_SHORT, "MountTypeID" },
             { false, FT_SHORT, "Flags" },
             { true, FT_BYTE, "SourceTypeEnum" },
-            { false, FT_INT, "ID" },
+            { true, FT_INT, "SourceSpellID" },
             { false, FT_INT, "PlayerConditionID" },
+            { false, FT_FLOAT, "MountFlyRideHeight" },
             { true, FT_INT, "UiModelSceneID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MountMeta::Instance(), HOTFIX_SEL_MOUNT);
@@ -3185,14 +3261,14 @@ struct MountCapabilityLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { true, FT_INT, "ReqSpellKnownID" },
-            { true, FT_INT, "ModSpellAuraID" },
+            { false, FT_INT, "ID" },
+            { false, FT_BYTE, "Flags" },
             { false, FT_SHORT, "ReqRidingSkill" },
             { false, FT_SHORT, "ReqAreaID" },
-            { true, FT_SHORT, "ReqMapID" },
-            { false, FT_BYTE, "Flags" },
-            { false, FT_INT, "ID" },
             { false, FT_INT, "ReqSpellAuraID" },
+            { true, FT_INT, "ReqSpellKnownID" },
+            { true, FT_INT, "ModSpellAuraID" },
+            { true, FT_SHORT, "ReqMapID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MountCapabilityMeta::Instance(), HOTFIX_SEL_MOUNT_CAPABILITY);
         return &loadInfo;
@@ -3238,10 +3314,10 @@ struct MovieLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "AudioFileDataID" },
-            { false, FT_INT, "SubtitleFileDataID" },
             { false, FT_BYTE, "Volume" },
             { false, FT_BYTE, "KeyID" },
+            { false, FT_INT, "AudioFileDataID" },
+            { false, FT_INT, "SubtitleFileDataID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MovieMeta::Instance(), HOTFIX_SEL_MOVIE);
         return &loadInfo;
@@ -3371,12 +3447,9 @@ struct PlayerConditionLoadInfo
             { true, FT_LONG, "RaceMask" },
             { false, FT_STRING, "FailureDescription" },
             { false, FT_INT, "ID" },
-            { false, FT_BYTE, "Flags" },
             { false, FT_SHORT, "MinLevel" },
             { false, FT_SHORT, "MaxLevel" },
             { true, FT_INT, "ClassMask" },
-            { true, FT_BYTE, "Gender" },
-            { true, FT_BYTE, "NativeGender" },
             { false, FT_INT, "SkillLogic" },
             { false, FT_BYTE, "LanguageID" },
             { false, FT_BYTE, "MinLanguage" },
@@ -3385,8 +3458,6 @@ struct PlayerConditionLoadInfo
             { false, FT_BYTE, "MaxReputation" },
             { false, FT_INT, "ReputationLogic" },
             { true, FT_BYTE, "CurrentPvpFaction" },
-            { false, FT_BYTE, "MinPVPRank" },
-            { false, FT_BYTE, "MaxPVPRank" },
             { false, FT_BYTE, "PvpMedal" },
             { false, FT_INT, "PrevQuestLogic" },
             { false, FT_INT, "CurrQuestLogic" },
@@ -3400,31 +3471,36 @@ struct PlayerConditionLoadInfo
             { false, FT_BYTE, "PartyStatus" },
             { false, FT_BYTE, "LifetimeMaxPVPRank" },
             { false, FT_INT, "AchievementLogic" },
-            { false, FT_INT, "LfgLogic" },
+            { true, FT_BYTE, "Gender" },
+            { true, FT_BYTE, "NativeGender" },
             { false, FT_INT, "AreaLogic" },
+            { false, FT_INT, "LfgLogic" },
             { false, FT_INT, "CurrencyLogic" },
             { false, FT_SHORT, "QuestKillID" },
             { false, FT_INT, "QuestKillLogic" },
             { true, FT_BYTE, "MinExpansionLevel" },
             { true, FT_BYTE, "MaxExpansionLevel" },
-            { true, FT_BYTE, "MinExpansionTier" },
-            { true, FT_BYTE, "MaxExpansionTier" },
-            { false, FT_BYTE, "MinGuildLevel" },
-            { false, FT_BYTE, "MaxGuildLevel" },
-            { false, FT_BYTE, "PhaseUseFlags" },
-            { false, FT_SHORT, "PhaseID" },
-            { false, FT_INT, "PhaseGroupID" },
             { true, FT_INT, "MinAvgItemLevel" },
             { true, FT_INT, "MaxAvgItemLevel" },
             { false, FT_SHORT, "MinAvgEquippedItemLevel" },
             { false, FT_SHORT, "MaxAvgEquippedItemLevel" },
+            { false, FT_BYTE, "PhaseUseFlags" },
+            { false, FT_SHORT, "PhaseID" },
+            { false, FT_INT, "PhaseGroupID" },
+            { false, FT_BYTE, "Flags" },
             { true, FT_BYTE, "ChrSpecializationIndex" },
             { true, FT_BYTE, "ChrSpecializationRole" },
+            { false, FT_INT, "ModifierTreeID" },
             { true, FT_BYTE, "PowerType" },
             { false, FT_BYTE, "PowerTypeComp" },
             { false, FT_BYTE, "PowerTypeValue" },
-            { false, FT_INT, "ModifierTreeID" },
             { true, FT_INT, "WeaponSubclassMask" },
+            { false, FT_BYTE, "MaxGuildLevel" },
+            { false, FT_BYTE, "MinGuildLevel" },
+            { true, FT_BYTE, "MaxExpansionTier" },
+            { true, FT_BYTE, "MinExpansionTier" },
+            { false, FT_BYTE, "MinPVPRank" },
+            { false, FT_BYTE, "MaxPVPRank" },
             { false, FT_SHORT, "SkillID1" },
             { false, FT_SHORT, "SkillID2" },
             { false, FT_SHORT, "SkillID3" },
@@ -3483,6 +3559,10 @@ struct PlayerConditionLoadInfo
             { false, FT_SHORT, "Achievement2" },
             { false, FT_SHORT, "Achievement3" },
             { false, FT_SHORT, "Achievement4" },
+            { false, FT_SHORT, "AreaID1" },
+            { false, FT_SHORT, "AreaID2" },
+            { false, FT_SHORT, "AreaID3" },
+            { false, FT_SHORT, "AreaID4" },
             { false, FT_BYTE, "LfgStatus1" },
             { false, FT_BYTE, "LfgStatus2" },
             { false, FT_BYTE, "LfgStatus3" },
@@ -3495,10 +3575,6 @@ struct PlayerConditionLoadInfo
             { false, FT_INT, "LfgValue2" },
             { false, FT_INT, "LfgValue3" },
             { false, FT_INT, "LfgValue4" },
-            { false, FT_SHORT, "AreaID1" },
-            { false, FT_SHORT, "AreaID2" },
-            { false, FT_SHORT, "AreaID3" },
-            { false, FT_SHORT, "AreaID4" },
             { false, FT_INT, "CurrencyID1" },
             { false, FT_INT, "CurrencyID2" },
             { false, FT_INT, "CurrencyID3" },
@@ -3548,16 +3624,16 @@ struct PowerTypeLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_STRING_NOT_LOCALIZED, "NameGlobalStringTag" },
             { false, FT_STRING_NOT_LOCALIZED, "CostGlobalStringTag" },
-            { false, FT_FLOAT, "RegenPeace" },
-            { false, FT_FLOAT, "RegenCombat" },
-            { true, FT_SHORT, "MaxBasePower" },
-            { true, FT_SHORT, "RegenInterruptTimeMS" },
-            { true, FT_SHORT, "Flags" },
             { true, FT_BYTE, "PowerTypeEnum" },
             { true, FT_BYTE, "MinPower" },
+            { true, FT_SHORT, "MaxBasePower" },
             { true, FT_BYTE, "CenterPower" },
             { true, FT_BYTE, "DefaultPower" },
             { true, FT_BYTE, "DisplayModifier" },
+            { true, FT_SHORT, "RegenInterruptTimeMS" },
+            { false, FT_FLOAT, "RegenPeace" },
+            { false, FT_FLOAT, "RegenCombat" },
+            { true, FT_SHORT, "Flags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PowerTypeMeta::Instance(), HOTFIX_SEL_POWER_TYPE);
         return &loadInfo;
@@ -3572,9 +3648,10 @@ struct PrestigeLevelInfoLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
+            { true, FT_INT, "PrestigeLevel" },
             { true, FT_INT, "BadgeTextureFileDataID" },
-            { false, FT_BYTE, "PrestigeLevel" },
             { false, FT_BYTE, "Flags" },
+            { true, FT_INT, "AwardedAchievementID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PrestigeLevelInfoMeta::Instance(), HOTFIX_SEL_PRESTIGE_LEVEL_INFO);
         return &loadInfo;
@@ -3613,57 +3690,54 @@ struct PvpItemLoadInfo
     }
 };
 
-struct PvpRewardLoadInfo
+struct PvpTalentLoadInfo
 {
     static DB2LoadInfo const* Instance()
     {
         static DB2FieldMeta const fields[] =
         {
+            { false, FT_STRING, "Description" },
             { false, FT_INT, "ID" },
-            { true, FT_INT, "HonorLevel" },
-            { true, FT_INT, "PrestigeLevel" },
-            { true, FT_INT, "RewardPackID" },
+            { true, FT_INT, "SpecID" },
+            { true, FT_INT, "SpellID" },
+            { true, FT_INT, "OverridesSpellID" },
+            { true, FT_INT, "Flags" },
+            { true, FT_INT, "ActionBarSpellID" },
+            { true, FT_INT, "PvpTalentCategoryID" },
+            { true, FT_INT, "LevelRequired" },
         };
-        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpRewardMeta::Instance(), HOTFIX_SEL_PVP_REWARD);
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpTalentMeta::Instance(), HOTFIX_SEL_PVP_TALENT);
         return &loadInfo;
     }
 };
 
-struct PvpTalentLoadInfo
+struct PvpTalentCategoryLoadInfo
 {
     static DB2LoadInfo const* Instance()
     {
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_STRING, "Description" },
-            { true, FT_INT, "SpellID" },
-            { true, FT_INT, "OverridesSpellID" },
-            { true, FT_INT, "ActionBarSpellID" },
-            { true, FT_INT, "TierID" },
-            { true, FT_INT, "ColumnIndex" },
-            { true, FT_INT, "Flags" },
-            { true, FT_INT, "ClassID" },
-            { true, FT_INT, "SpecID" },
-            { true, FT_INT, "Role" },
+            { false, FT_BYTE, "TalentSlotMask" },
         };
-        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpTalentMeta::Instance(), HOTFIX_SEL_PVP_TALENT);
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpTalentCategoryMeta::Instance(), HOTFIX_SEL_PVP_TALENT_CATEGORY);
         return &loadInfo;
     }
 };
 
-struct PvpTalentUnlockLoadInfo
+struct PvpTalentSlotUnlockLoadInfo
 {
     static DB2LoadInfo const* Instance()
     {
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "TierID" },
-            { true, FT_INT, "ColumnIndex" },
-            { true, FT_INT, "HonorLevel" },
+            { true, FT_BYTE, "Slot" },
+            { true, FT_INT, "LevelRequired" },
+            { true, FT_INT, "DeathKnightLevelRequired" },
+            { true, FT_INT, "DemonHunterLevelRequired" },
         };
-        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpTalentUnlockMeta::Instance(), HOTFIX_SEL_PVP_TALENT_UNLOCK);
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpTalentSlotUnlockMeta::Instance(), HOTFIX_SEL_PVP_TALENT_SLOT_UNLOCK);
         return &loadInfo;
     }
 };
@@ -3721,10 +3795,10 @@ struct QuestPackageItemLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "ItemID" },
             { false, FT_SHORT, "PackageID" },
-            { false, FT_BYTE, "DisplayType" },
+            { true, FT_INT, "ItemID" },
             { false, FT_INT, "ItemQuantity" },
+            { false, FT_BYTE, "DisplayType" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestPackageItemMeta::Instance(), HOTFIX_SEL_QUEST_PACKAGE_ITEM);
         return &loadInfo;
@@ -3790,6 +3864,7 @@ struct RandPropPointsLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { true, FT_INT, "DamageReplaceStat" },
             { false, FT_INT, "Epic1" },
             { false, FT_INT, "Epic2" },
             { false, FT_INT, "Epic3" },
@@ -3818,11 +3893,11 @@ struct RewardPackLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { true, FT_INT, "CharTitleID" },
             { false, FT_INT, "Money" },
-            { false, FT_FLOAT, "ArtifactXPMultiplier" },
             { true, FT_BYTE, "ArtifactXPDifficulty" },
+            { false, FT_FLOAT, "ArtifactXPMultiplier" },
             { false, FT_BYTE, "ArtifactXPCategoryID" },
-            { true, FT_INT, "CharTitleID" },
             { false, FT_INT, "TreasurePickerID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, RewardPackMeta::Instance(), HOTFIX_SEL_REWARD_PACK);
@@ -3877,22 +3952,6 @@ struct RulesetItemUpgradeLoadInfo
     }
 };
 
-struct SandboxScalingLoadInfo
-{
-    static DB2LoadInfo const* Instance()
-    {
-        static DB2FieldMeta const fields[] =
-        {
-            { false, FT_INT, "ID" },
-            { true, FT_INT, "MinLevel" },
-            { true, FT_INT, "MaxLevel" },
-            { true, FT_INT, "Flags" },
-        };
-        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SandboxScalingMeta::Instance(), HOTFIX_SEL_SANDBOX_SCALING);
-        return &loadInfo;
-    }
-};
-
 struct ScalingStatDistributionLoadInfo
 {
     static DB2LoadInfo const* Instance()
@@ -3918,8 +3977,9 @@ struct ScenarioLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
             { false, FT_SHORT, "AreaTableID" },
-            { false, FT_BYTE, "Flags" },
             { false, FT_BYTE, "Type" },
+            { false, FT_BYTE, "Flags" },
+            { false, FT_INT, "UiTextureKitID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ScenarioMeta::Instance(), HOTFIX_SEL_SCENARIO);
         return &loadInfo;
@@ -3936,12 +3996,14 @@ struct ScenarioStepLoadInfo
             { false, FT_STRING, "Description" },
             { false, FT_STRING, "Title" },
             { false, FT_SHORT, "ScenarioID" },
-            { false, FT_SHORT, "Supersedes" },
+            { false, FT_INT, "Criteriatreeid" },
             { false, FT_SHORT, "RewardQuestID" },
+            { true, FT_INT, "RelatedStep" },
+            { false, FT_SHORT, "Supersedes" },
             { false, FT_BYTE, "OrderIndex" },
             { false, FT_BYTE, "Flags" },
-            { false, FT_INT, "Criteriatreeid" },
-            { true, FT_INT, "RelatedStep" },
+            { false, FT_INT, "VisibilityPlayerConditionID" },
+            { false, FT_SHORT, "WidgetSetID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ScenarioStepMeta::Instance(), HOTFIX_SEL_SCENARIO_STEP);
         return &loadInfo;
@@ -4013,15 +4075,19 @@ struct SkillLineLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_INT, "ID" },
             { false, FT_STRING, "DisplayName" },
-            { false, FT_STRING, "Description" },
             { false, FT_STRING, "AlternateVerb" },
-            { false, FT_SHORT, "Flags" },
+            { false, FT_STRING, "Description" },
+            { false, FT_STRING, "HordeDisplayName" },
+            { false, FT_STRING_NOT_LOCALIZED, "OverrideSourceInfoDisplayName" },
+            { false, FT_INT, "ID" },
             { true, FT_BYTE, "CategoryID" },
-            { true, FT_BYTE, "CanLink" },
             { true, FT_INT, "SpellIconFileID" },
+            { true, FT_BYTE, "CanLink" },
             { false, FT_INT, "ParentSkillLineID" },
+            { true, FT_INT, "ParentTierIndex" },
+            { false, FT_SHORT, "Flags" },
+            { true, FT_INT, "SpellBookSpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SkillLineMeta::Instance(), HOTFIX_SEL_SKILL_LINE);
         return &loadInfo;
@@ -4036,18 +4102,19 @@ struct SkillLineAbilityLoadInfo
         {
             { true, FT_LONG, "RaceMask" },
             { false, FT_INT, "ID" },
+            { true, FT_SHORT, "SkillLine" },
             { true, FT_INT, "Spell" },
+            { true, FT_SHORT, "MinSkillLineRank" },
+            { true, FT_INT, "ClassMask" },
             { true, FT_INT, "SupercedesSpell" },
-            { true, FT_SHORT, "SkillLine" },
+            { true, FT_BYTE, "AcquireMethod" },
             { true, FT_SHORT, "TrivialSkillLineRankHigh" },
             { true, FT_SHORT, "TrivialSkillLineRankLow" },
+            { true, FT_BYTE, "Flags" },
+            { true, FT_BYTE, "NumSkillUps" },
             { true, FT_SHORT, "UniqueBit" },
             { true, FT_SHORT, "TradeSkillCategoryID" },
-            { true, FT_BYTE, "NumSkillUps" },
-            { true, FT_INT, "ClassMask" },
-            { true, FT_SHORT, "MinSkillLineRank" },
-            { true, FT_BYTE, "AcquireMethod" },
-            { true, FT_BYTE, "Flags" },
+            { true, FT_SHORT, "SkillupSkillLineID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SkillLineAbilityMeta::Instance(), HOTFIX_SEL_SKILL_LINE_ABILITY);
         return &loadInfo;
@@ -4063,11 +4130,11 @@ struct SkillRaceClassInfoLoadInfo
             { false, FT_INT, "ID" },
             { true, FT_LONG, "RaceMask" },
             { true, FT_SHORT, "SkillID" },
+            { true, FT_INT, "ClassMask" },
             { false, FT_SHORT, "Flags" },
-            { true, FT_SHORT, "SkillTierID" },
             { true, FT_BYTE, "Availability" },
             { true, FT_BYTE, "MinLevel" },
-            { true, FT_INT, "ClassMask" },
+            { true, FT_SHORT, "SkillTierID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SkillRaceClassInfoMeta::Instance(), HOTFIX_SEL_SKILL_RACE_CLASS_INFO);
         return &loadInfo;
@@ -4081,18 +4148,18 @@ struct SoundKitLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "SoundType" },
             { false, FT_FLOAT, "VolumeFloat" },
+            { false, FT_SHORT, "Flags" },
             { false, FT_FLOAT, "MinDistance" },
             { false, FT_FLOAT, "DistanceCutoff" },
-            { false, FT_SHORT, "Flags" },
-            { false, FT_SHORT, "SoundEntriesAdvancedID" },
-            { false, FT_BYTE, "SoundType" },
-            { false, FT_BYTE, "DialogType" },
             { false, FT_BYTE, "EAXDef" },
+            { false, FT_INT, "SoundKitAdvancedID" },
             { false, FT_FLOAT, "VolumeVariationPlus" },
             { false, FT_FLOAT, "VolumeVariationMinus" },
             { false, FT_FLOAT, "PitchVariationPlus" },
             { false, FT_FLOAT, "PitchVariationMinus" },
+            { true, FT_BYTE, "DialogType" },
             { false, FT_FLOAT, "PitchAdjust" },
             { false, FT_SHORT, "BusOverwriteID" },
             { false, FT_BYTE, "MaxInstances" },
@@ -4109,34 +4176,17 @@ struct SpecializationSpellsLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_STRING, "Description" },
+            { false, FT_INT, "ID" },
+            { false, FT_SHORT, "SpecID" },
             { true, FT_INT, "SpellID" },
             { true, FT_INT, "OverridesSpellID" },
-            { false, FT_SHORT, "SpecID" },
             { false, FT_BYTE, "DisplayOrder" },
-            { false, FT_INT, "ID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpecializationSpellsMeta::Instance(), HOTFIX_SEL_SPECIALIZATION_SPELLS);
         return &loadInfo;
     }
 };
 
-struct SpellLoadInfo
-{
-    static DB2LoadInfo const* Instance()
-    {
-        static DB2FieldMeta const fields[] =
-        {
-            { false, FT_INT, "ID" },
-            { false, FT_STRING, "Name" },
-            { false, FT_STRING, "NameSubtext" },
-            { false, FT_STRING, "Description" },
-            { false, FT_STRING, "AuraDescription" },
-        };
-        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellMeta::Instance(), HOTFIX_SEL_SPELL);
-        return &loadInfo;
-    }
-};
-
 struct SpellAuraOptionsLoadInfo
 {
     static DB2LoadInfo const* Instance()
@@ -4144,13 +4194,14 @@ struct SpellAuraOptionsLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "ProcCharges" },
-            { true, FT_INT, "ProcTypeMask" },
-            { true, FT_INT, "ProcCategoryRecovery" },
-            { false, FT_SHORT, "CumulativeAura" },
-            { false, FT_SHORT, "SpellProcsPerMinuteID" },
             { false, FT_BYTE, "DifficultyID" },
+            { false, FT_SHORT, "CumulativeAura" },
+            { true, FT_INT, "ProcCategoryRecovery" },
             { false, FT_BYTE, "ProcChance" },
+            { true, FT_INT, "ProcCharges" },
+            { false, FT_SHORT, "SpellProcsPerMinuteID" },
+            { true, FT_INT, "ProcTypeMask1" },
+            { true, FT_INT, "ProcTypeMask2" },
             { true, FT_INT, "SpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellAuraOptionsMeta::Instance(), HOTFIX_SEL_SPELL_AURA_OPTIONS);
@@ -4165,15 +4216,15 @@ struct SpellAuraRestrictionsLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "CasterAuraSpell" },
-            { true, FT_INT, "TargetAuraSpell" },
-            { true, FT_INT, "ExcludeCasterAuraSpell" },
-            { true, FT_INT, "ExcludeTargetAuraSpell" },
             { false, FT_BYTE, "DifficultyID" },
             { false, FT_BYTE, "CasterAuraState" },
             { false, FT_BYTE, "TargetAuraState" },
             { false, FT_BYTE, "ExcludeCasterAuraState" },
             { false, FT_BYTE, "ExcludeTargetAuraState" },
+            { true, FT_INT, "CasterAuraSpell" },
+            { true, FT_INT, "TargetAuraSpell" },
+            { true, FT_INT, "ExcludeCasterAuraSpell" },
+            { true, FT_INT, "ExcludeTargetAuraSpell" },
             { true, FT_INT, "SpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellAuraRestrictionsMeta::Instance(), HOTFIX_SEL_SPELL_AURA_RESTRICTIONS);
@@ -4189,8 +4240,8 @@ struct SpellCastTimesLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "Base" },
-            { true, FT_INT, "Minimum" },
             { true, FT_SHORT, "PerLevel" },
+            { true, FT_INT, "Minimum" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellCastTimesMeta::Instance(), HOTFIX_SEL_SPELL_CAST_TIMES);
         return &loadInfo;
@@ -4205,12 +4256,12 @@ struct SpellCastingRequirementsLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "SpellID" },
-            { false, FT_SHORT, "MinFactionID" },
-            { false, FT_SHORT, "RequiredAreasID" },
-            { false, FT_SHORT, "RequiresSpellFocus" },
             { false, FT_BYTE, "FacingCasterFlags" },
+            { false, FT_SHORT, "MinFactionID" },
             { true, FT_BYTE, "MinReputation" },
+            { false, FT_SHORT, "RequiredAreasID" },
             { false, FT_BYTE, "RequiredAuraVision" },
+            { false, FT_SHORT, "RequiresSpellFocus" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellCastingRequirementsMeta::Instance(), HOTFIX_SEL_SPELL_CASTING_REQUIREMENTS);
         return &loadInfo;
@@ -4224,14 +4275,14 @@ struct SpellCategoriesLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_SHORT, "Category" },
-            { true, FT_SHORT, "StartRecoveryCategory" },
-            { true, FT_SHORT, "ChargeCategory" },
             { false, FT_BYTE, "DifficultyID" },
+            { true, FT_SHORT, "Category" },
             { true, FT_BYTE, "DefenseType" },
             { true, FT_BYTE, "DispelType" },
             { true, FT_BYTE, "Mechanic" },
             { true, FT_BYTE, "PreventionType" },
+            { true, FT_SHORT, "StartRecoveryCategory" },
+            { true, FT_SHORT, "ChargeCategory" },
             { true, FT_INT, "SpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellCategoriesMeta::Instance(), HOTFIX_SEL_SPELL_CATEGORIES);
@@ -4247,10 +4298,10 @@ struct SpellCategoryLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
-            { true, FT_INT, "ChargeRecoveryTime" },
             { true, FT_BYTE, "Flags" },
             { false, FT_BYTE, "UsesPerWeek" },
             { true, FT_BYTE, "MaxCharges" },
+            { true, FT_INT, "ChargeRecoveryTime" },
             { true, FT_INT, "TypeMask" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellCategoryMeta::Instance(), HOTFIX_SEL_SPELL_CATEGORY);
@@ -4266,12 +4317,12 @@ struct SpellClassOptionsLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "SpellID" },
-            { false, FT_INT, "SpellClassMask1" },
-            { false, FT_INT, "SpellClassMask2" },
-            { false, FT_INT, "SpellClassMask3" },
-            { false, FT_INT, "SpellClassMask4" },
-            { false, FT_BYTE, "SpellClassSet" },
             { false, FT_INT, "ModalNextSpell" },
+            { false, FT_BYTE, "SpellClassSet" },
+            { true, FT_INT, "SpellClassMask1" },
+            { true, FT_INT, "SpellClassMask2" },
+            { true, FT_INT, "SpellClassMask3" },
+            { true, FT_INT, "SpellClassMask4" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellClassOptionsMeta::Instance(), HOTFIX_SEL_SPELL_CLASS_OPTIONS);
         return &loadInfo;
@@ -4285,10 +4336,10 @@ struct SpellCooldownsLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "DifficultyID" },
             { true, FT_INT, "CategoryRecoveryTime" },
             { true, FT_INT, "RecoveryTime" },
             { true, FT_INT, "StartRecoveryTime" },
-            { false, FT_BYTE, "DifficultyID" },
             { true, FT_INT, "SpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellCooldownsMeta::Instance(), HOTFIX_SEL_SPELL_COOLDOWNS);
@@ -4304,8 +4355,8 @@ struct SpellDurationLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "Duration" },
-            { true, FT_INT, "MaxDuration" },
             { false, FT_INT, "DurationPerLevel" },
+            { true, FT_INT, "MaxDuration" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellDurationMeta::Instance(), HOTFIX_SEL_SPELL_DURATION);
         return &loadInfo;
@@ -4319,40 +4370,39 @@ struct SpellEffectLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "Effect" },
-            { true, FT_INT, "EffectBasePoints" },
-            { true, FT_INT, "EffectIndex" },
-            { true, FT_INT, "EffectAura" },
             { true, FT_INT, "DifficultyID" },
+            { true, FT_INT, "EffectIndex" },
+            { false, FT_INT, "Effect" },
             { false, FT_FLOAT, "EffectAmplitude" },
+            { true, FT_INT, "EffectAttributes" },
+            { true, FT_SHORT, "EffectAura" },
             { true, FT_INT, "EffectAuraPeriod" },
             { false, FT_FLOAT, "EffectBonusCoefficient" },
             { false, FT_FLOAT, "EffectChainAmplitude" },
             { true, FT_INT, "EffectChainTargets" },
-            { true, FT_INT, "EffectDieSides" },
             { true, FT_INT, "EffectItemType" },
             { true, FT_INT, "EffectMechanic" },
             { false, FT_FLOAT, "EffectPointsPerResource" },
+            { false, FT_FLOAT, "EffectPosFacing" },
             { false, FT_FLOAT, "EffectRealPointsPerLevel" },
             { true, FT_INT, "EffectTriggerSpell" },
-            { false, FT_FLOAT, "EffectPosFacing" },
-            { true, FT_INT, "EffectAttributes" },
             { false, FT_FLOAT, "BonusCoefficientFromAP" },
             { false, FT_FLOAT, "PvpMultiplier" },
             { false, FT_FLOAT, "Coefficient" },
             { false, FT_FLOAT, "Variance" },
             { false, FT_FLOAT, "ResourceCoefficient" },
             { false, FT_FLOAT, "GroupSizeBasePointsCoefficient" },
-            { false, FT_INT, "EffectSpellClassMask1" },
-            { false, FT_INT, "EffectSpellClassMask2" },
-            { false, FT_INT, "EffectSpellClassMask3" },
-            { false, FT_INT, "EffectSpellClassMask4" },
+            { false, FT_FLOAT, "EffectBasePoints" },
             { true, FT_INT, "EffectMiscValue1" },
             { true, FT_INT, "EffectMiscValue2" },
             { false, FT_INT, "EffectRadiusIndex1" },
             { false, FT_INT, "EffectRadiusIndex2" },
-            { false, FT_INT, "ImplicitTarget1" },
-            { false, FT_INT, "ImplicitTarget2" },
+            { true, FT_INT, "EffectSpellClassMask1" },
+            { true, FT_INT, "EffectSpellClassMask2" },
+            { true, FT_INT, "EffectSpellClassMask3" },
+            { true, FT_INT, "EffectSpellClassMask4" },
+            { true, FT_SHORT, "ImplicitTarget1" },
+            { true, FT_SHORT, "ImplicitTarget2" },
             { true, FT_INT, "SpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellEffectMeta::Instance(), HOTFIX_SEL_SPELL_EFFECT);
@@ -4368,9 +4418,9 @@ struct SpellEquippedItemsLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "SpellID" },
+            { true, FT_BYTE, "EquippedItemClass" },
             { true, FT_INT, "EquippedItemInvTypes" },
             { true, FT_INT, "EquippedItemSubclass" },
-            { true, FT_BYTE, "EquippedItemClass" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellEquippedItemsMeta::Instance(), HOTFIX_SEL_SPELL_EQUIPPED_ITEMS);
         return &loadInfo;
@@ -4419,6 +4469,7 @@ struct SpellItemEnchantmentLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
+            { false, FT_STRING, "HordeName" },
             { false, FT_INT, "EffectArg1" },
             { false, FT_INT, "EffectArg2" },
             { false, FT_INT, "EffectArg3" },
@@ -4427,6 +4478,7 @@ struct SpellItemEnchantmentLoadInfo
             { false, FT_FLOAT, "EffectScalingPoints3" },
             { false, FT_INT, "TransmogCost" },
             { false, FT_INT, "IconFileDataID" },
+            { false, FT_INT, "TransmogPlayerConditionID" },
             { true, FT_SHORT, "EffectPointsMin1" },
             { true, FT_SHORT, "EffectPointsMin2" },
             { true, FT_SHORT, "EffectPointsMin3" },
@@ -4439,12 +4491,11 @@ struct SpellItemEnchantmentLoadInfo
             { false, FT_BYTE, "Effect1" },
             { false, FT_BYTE, "Effect2" },
             { false, FT_BYTE, "Effect3" },
+            { true, FT_BYTE, "ScalingClass" },
+            { true, FT_BYTE, "ScalingClassRestricted" },
             { false, FT_BYTE, "ConditionID" },
             { false, FT_BYTE, "MinLevel" },
             { false, FT_BYTE, "MaxLevel" },
-            { true, FT_BYTE, "ScalingClass" },
-            { true, FT_BYTE, "ScalingClassRestricted" },
-            { false, FT_INT, "TransmogPlayerConditionID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellItemEnchantmentMeta::Instance(), HOTFIX_SEL_SPELL_ITEM_ENCHANTMENT);
         return &loadInfo;
@@ -4458,16 +4509,16 @@ struct SpellItemEnchantmentConditionLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "LtOperand1" },
-            { false, FT_INT, "LtOperand2" },
-            { false, FT_INT, "LtOperand3" },
-            { false, FT_INT, "LtOperand4" },
-            { false, FT_INT, "LtOperand5" },
             { false, FT_BYTE, "LtOperandType1" },
             { false, FT_BYTE, "LtOperandType2" },
             { false, FT_BYTE, "LtOperandType3" },
             { false, FT_BYTE, "LtOperandType4" },
             { false, FT_BYTE, "LtOperandType5" },
+            { false, FT_INT, "LtOperand1" },
+            { false, FT_INT, "LtOperand2" },
+            { false, FT_INT, "LtOperand3" },
+            { false, FT_INT, "LtOperand4" },
+            { false, FT_INT, "LtOperand5" },
             { false, FT_BYTE, "Operator1" },
             { false, FT_BYTE, "Operator2" },
             { false, FT_BYTE, "Operator3" },
@@ -4517,10 +4568,10 @@ struct SpellLevelsLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "DifficultyID" },
             { true, FT_SHORT, "BaseLevel" },
             { true, FT_SHORT, "MaxLevel" },
             { true, FT_SHORT, "SpellLevel" },
-            { false, FT_BYTE, "DifficultyID" },
             { false, FT_BYTE, "MaxPassiveAuraLevel" },
             { true, FT_INT, "SpellID" },
         };
@@ -4536,15 +4587,16 @@ struct SpellMiscLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "DifficultyID" },
             { false, FT_SHORT, "CastingTimeIndex" },
             { false, FT_SHORT, "DurationIndex" },
             { false, FT_SHORT, "RangeIndex" },
             { false, FT_BYTE, "SchoolMask" },
-            { true, FT_INT, "SpellIconFileDataID" },
             { false, FT_FLOAT, "Speed" },
-            { true, FT_INT, "ActiveIconFileDataID" },
             { false, FT_FLOAT, "LaunchDelay" },
-            { false, FT_BYTE, "DifficultyID" },
+            { false, FT_FLOAT, "MinDuration" },
+            { true, FT_INT, "SpellIconFileDataID" },
+            { true, FT_INT, "ActiveIconFileDataID" },
             { true, FT_INT, "Attributes1" },
             { true, FT_INT, "Attributes2" },
             { true, FT_INT, "Attributes3" },
@@ -4566,25 +4618,39 @@ struct SpellMiscLoadInfo
     }
 };
 
+struct SpellNameLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_INT, "ID" },
+            { false, FT_STRING, "Name" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellNameMeta::Instance(), HOTFIX_SEL_SPELL_NAME);
+        return &loadInfo;
+    }
+};
+
 struct SpellPowerLoadInfo
 {
     static DB2LoadInfo const* Instance()
     {
         static DB2FieldMeta const fields[] =
         {
-            { true, FT_INT, "ManaCost" },
-            { false, FT_FLOAT, "PowerCostPct" },
-            { false, FT_FLOAT, "PowerPctPerSecond" },
-            { true, FT_INT, "RequiredAuraSpellID" },
-            { false, FT_FLOAT, "PowerCostMaxPct" },
-            { false, FT_BYTE, "OrderIndex" },
-            { true, FT_BYTE, "PowerType" },
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "OrderIndex" },
+            { true, FT_INT, "ManaCost" },
             { true, FT_INT, "ManaCostPerLevel" },
             { true, FT_INT, "ManaPerSecond" },
-            { false, FT_INT, "OptionalCost" },
             { false, FT_INT, "PowerDisplayID" },
             { true, FT_INT, "AltPowerBarID" },
+            { false, FT_FLOAT, "PowerCostPct" },
+            { false, FT_FLOAT, "PowerCostMaxPct" },
+            { false, FT_FLOAT, "PowerPctPerSecond" },
+            { true, FT_BYTE, "PowerType" },
+            { true, FT_INT, "RequiredAuraSpellID" },
+            { false, FT_INT, "OptionalCost" },
             { true, FT_INT, "SpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellPowerMeta::Instance(), HOTFIX_SEL_SPELL_POWER);
@@ -4598,9 +4664,9 @@ struct SpellPowerDifficultyLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
+            { false, FT_INT, "ID" },
             { false, FT_BYTE, "DifficultyID" },
             { false, FT_BYTE, "OrderIndex" },
-            { false, FT_INT, "ID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellPowerDifficultyMeta::Instance(), HOTFIX_SEL_SPELL_POWER_DIFFICULTY);
         return &loadInfo;
@@ -4629,9 +4695,9 @@ struct SpellProcsPerMinuteModLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_FLOAT, "Coeff" },
-            { true, FT_SHORT, "Param" },
             { false, FT_BYTE, "Type" },
+            { true, FT_SHORT, "Param" },
+            { false, FT_FLOAT, "Coeff" },
             { false, FT_SHORT, "SpellProcsPerMinuteID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellProcsPerMinuteModMeta::Instance(), HOTFIX_SEL_SPELL_PROCS_PER_MINUTE_MOD);
@@ -4665,11 +4731,11 @@ struct SpellRangeLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_STRING, "DisplayName" },
             { false, FT_STRING, "DisplayNameShort" },
+            { false, FT_BYTE, "Flags" },
             { false, FT_FLOAT, "RangeMin1" },
             { false, FT_FLOAT, "RangeMin2" },
             { false, FT_FLOAT, "RangeMax1" },
             { false, FT_FLOAT, "RangeMax2" },
-            { false, FT_BYTE, "Flags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellRangeMeta::Instance(), HOTFIX_SEL_SPELL_RANGE);
         return &loadInfo;
@@ -4714,10 +4780,10 @@ struct SpellScalingLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "SpellID" },
-            { true, FT_SHORT, "ScalesFromItemLevel" },
             { true, FT_INT, "Class" },
             { false, FT_INT, "MinScalingLevel" },
             { false, FT_INT, "MaxScalingLevel" },
+            { true, FT_SHORT, "ScalesFromItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellScalingMeta::Instance(), HOTFIX_SEL_SPELL_SCALING);
         return &loadInfo;
@@ -4732,11 +4798,11 @@ struct SpellShapeshiftLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "SpellID" },
+            { true, FT_BYTE, "StanceBarOrder" },
             { true, FT_INT, "ShapeshiftExclude1" },
             { true, FT_INT, "ShapeshiftExclude2" },
             { true, FT_INT, "ShapeshiftMask1" },
             { true, FT_INT, "ShapeshiftMask2" },
-            { true, FT_BYTE, "StanceBarOrder" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellShapeshiftMeta::Instance(), HOTFIX_SEL_SPELL_SHAPESHIFT);
         return &loadInfo;
@@ -4751,13 +4817,13 @@ struct SpellShapeshiftFormLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
-            { false, FT_FLOAT, "DamageVariance" },
+            { true, FT_BYTE, "CreatureType" },
             { true, FT_INT, "Flags" },
+            { true, FT_INT, "AttackIconFileID" },
+            { true, FT_BYTE, "BonusActionBar" },
             { true, FT_SHORT, "CombatRoundTime" },
+            { false, FT_FLOAT, "DamageVariance" },
             { false, FT_SHORT, "MountTypeID" },
-            { true, FT_BYTE, "CreatureType" },
-            { true, FT_BYTE, "BonusActionBar" },
-            { true, FT_INT, "AttackIconFileID" },
             { false, FT_INT, "CreatureDisplayID1" },
             { false, FT_INT, "CreatureDisplayID2" },
             { false, FT_INT, "CreatureDisplayID3" },
@@ -4783,13 +4849,13 @@ struct SpellTargetRestrictionsLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_FLOAT, "ConeDegrees" },
-            { false, FT_FLOAT, "Width" },
-            { true, FT_INT, "Targets" },
-            { true, FT_SHORT, "TargetCreatureType" },
             { false, FT_BYTE, "DifficultyID" },
+            { false, FT_FLOAT, "ConeDegrees" },
             { false, FT_BYTE, "MaxTargets" },
             { false, FT_INT, "MaxTargetLevel" },
+            { true, FT_SHORT, "TargetCreatureType" },
+            { true, FT_INT, "Targets" },
+            { false, FT_FLOAT, "Width" },
             { true, FT_INT, "SpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellTargetRestrictionsMeta::Instance(), HOTFIX_SEL_SPELL_TARGET_RESTRICTIONS);
@@ -4805,10 +4871,10 @@ struct SpellTotemsLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "SpellID" },
-            { true, FT_INT, "Totem1" },
-            { true, FT_INT, "Totem2" },
             { false, FT_SHORT, "RequiredTotemCategoryID1" },
             { false, FT_SHORT, "RequiredTotemCategoryID2" },
+            { true, FT_INT, "Totem1" },
+            { true, FT_INT, "Totem2" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellTotemsMeta::Instance(), HOTFIX_SEL_SPELL_TOTEMS);
         return &loadInfo;
@@ -4821,18 +4887,18 @@ struct SpellXSpellVisualLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_INT, "SpellVisualID" },
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "DifficultyID" },
+            { false, FT_INT, "SpellVisualID" },
             { false, FT_FLOAT, "Probability" },
-            { false, FT_SHORT, "CasterPlayerConditionID" },
-            { false, FT_SHORT, "CasterUnitConditionID" },
-            { false, FT_SHORT, "ViewerPlayerConditionID" },
-            { false, FT_SHORT, "ViewerUnitConditionID" },
-            { true, FT_INT, "SpellIconFileID" },
-            { true, FT_INT, "ActiveIconFileID" },
             { false, FT_BYTE, "Flags" },
-            { false, FT_BYTE, "DifficultyID" },
             { false, FT_BYTE, "Priority" },
+            { true, FT_INT, "SpellIconFileID" },
+            { true, FT_INT, "ActiveIconFileID" },
+            { false, FT_SHORT, "ViewerUnitConditionID" },
+            { false, FT_INT, "ViewerPlayerConditionID" },
+            { false, FT_SHORT, "CasterUnitConditionID" },
+            { false, FT_INT, "CasterPlayerConditionID" },
             { true, FT_INT, "SpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellXSpellVisualMeta::Instance(), HOTFIX_SEL_SPELL_X_SPELL_VISUAL);
@@ -4847,11 +4913,11 @@ struct SummonPropertiesLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "Flags" },
             { true, FT_INT, "Control" },
             { true, FT_INT, "Faction" },
             { true, FT_INT, "Title" },
             { true, FT_INT, "Slot" },
+            { true, FT_INT, "Flags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SummonPropertiesMeta::Instance(), HOTFIX_SEL_SUMMON_PROPERTIES);
         return &loadInfo;
@@ -4895,15 +4961,15 @@ struct TalentLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Description" },
-            { false, FT_INT, "SpellID" },
-            { false, FT_INT, "OverridesSpellID" },
-            { false, FT_SHORT, "SpecID" },
             { false, FT_BYTE, "TierID" },
-            { false, FT_BYTE, "ColumnIndex" },
             { false, FT_BYTE, "Flags" },
+            { false, FT_BYTE, "ColumnIndex" },
+            { false, FT_BYTE, "ClassID" },
+            { false, FT_SHORT, "SpecID" },
+            { false, FT_INT, "SpellID" },
+            { false, FT_INT, "OverridesSpellID" },
             { false, FT_BYTE, "CategoryMask1" },
             { false, FT_BYTE, "CategoryMask2" },
-            { false, FT_BYTE, "ClassID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TalentMeta::Instance(), HOTFIX_SEL_TALENT);
         return &loadInfo;
@@ -4916,24 +4982,25 @@ struct TaxiNodesLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
             { false, FT_FLOAT, "PosX" },
             { false, FT_FLOAT, "PosY" },
             { false, FT_FLOAT, "PosZ" },
-            { true, FT_INT, "MountCreatureID1" },
-            { true, FT_INT, "MountCreatureID2" },
             { false, FT_FLOAT, "MapOffsetX" },
             { false, FT_FLOAT, "MapOffsetY" },
-            { false, FT_FLOAT, "Facing" },
             { false, FT_FLOAT, "FlightMapOffsetX" },
             { false, FT_FLOAT, "FlightMapOffsetY" },
+            { false, FT_INT, "ID" },
             { false, FT_SHORT, "ContinentID" },
             { false, FT_SHORT, "ConditionID" },
             { false, FT_SHORT, "CharacterBitNumber" },
             { false, FT_BYTE, "Flags" },
             { true, FT_INT, "UiTextureKitID" },
+            { false, FT_FLOAT, "Facing" },
             { false, FT_INT, "SpecialIconConditionID" },
+            { false, FT_INT, "VisibilityConditionID" },
+            { true, FT_INT, "MountCreatureID1" },
+            { true, FT_INT, "MountCreatureID2" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TaxiNodesMeta::Instance(), HOTFIX_SEL_TAXI_NODES);
         return &loadInfo;
@@ -4946,9 +5013,9 @@ struct TaxiPathLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
+            { false, FT_INT, "ID" },
             { false, FT_SHORT, "FromTaxiNode" },
             { false, FT_SHORT, "ToTaxiNode" },
-            { false, FT_INT, "ID" },
             { false, FT_INT, "Cost" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TaxiPathMeta::Instance(), HOTFIX_SEL_TAXI_PATH);
@@ -4965,10 +5032,10 @@ struct TaxiPathNodeLoadInfo
             { false, FT_FLOAT, "LocX" },
             { false, FT_FLOAT, "LocY" },
             { false, FT_FLOAT, "LocZ" },
+            { false, FT_INT, "ID" },
             { false, FT_SHORT, "PathID" },
+            { true, FT_INT, "NodeIndex" },
             { false, FT_SHORT, "ContinentID" },
-            { false, FT_BYTE, "NodeIndex" },
-            { false, FT_INT, "ID" },
             { false, FT_BYTE, "Flags" },
             { false, FT_INT, "Delay" },
             { false, FT_SHORT, "ArrivalEventID" },
@@ -4987,8 +5054,8 @@ struct TotemCategoryLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
-            { true, FT_INT, "TotemCategoryMask" },
             { false, FT_BYTE, "TotemCategoryType" },
+            { true, FT_INT, "TotemCategoryMask" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TotemCategoryMeta::Instance(), HOTFIX_SEL_TOTEM_CATEGORY);
         return &loadInfo;
@@ -5002,10 +5069,10 @@ struct ToyLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_STRING, "SourceText" },
+            { false, FT_INT, "ID" },
             { true, FT_INT, "ItemID" },
             { false, FT_BYTE, "Flags" },
             { true, FT_BYTE, "SourceTypeEnum" },
-            { false, FT_INT, "ID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ToyMeta::Instance(), HOTFIX_SEL_TOY);
         return &loadInfo;
@@ -5033,15 +5100,15 @@ struct TransmogSetLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_STRING, "Name" },
-            { false, FT_SHORT, "ParentTransmogSetID" },
-            { true, FT_SHORT, "UiOrder" },
-            { false, FT_BYTE, "ExpansionID" },
             { false, FT_INT, "ID" },
-            { true, FT_INT, "Flags" },
-            { false, FT_INT, "TrackingQuestID" },
             { true, FT_INT, "ClassMask" },
-            { true, FT_INT, "ItemNameDescriptionID" },
+            { false, FT_INT, "TrackingQuestID" },
+            { true, FT_INT, "Flags" },
             { false, FT_INT, "TransmogSetGroupID" },
+            { true, FT_INT, "ItemNameDescriptionID" },
+            { false, FT_SHORT, "ParentTransmogSetID" },
+            { false, FT_BYTE, "ExpansionID" },
+            { true, FT_SHORT, "UiOrder" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TransmogSetMeta::Instance(), HOTFIX_SEL_TRANSMOG_SET);
         return &loadInfo;
@@ -5085,11 +5152,11 @@ struct TransportAnimationLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "TimeIndex" },
             { false, FT_FLOAT, "PosX" },
             { false, FT_FLOAT, "PosY" },
             { false, FT_FLOAT, "PosZ" },
             { false, FT_BYTE, "SequenceID" },
+            { false, FT_INT, "TimeIndex" },
             { true, FT_INT, "TransportID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TransportAnimationMeta::Instance(), HOTFIX_SEL_TRANSPORT_ANIMATION);
@@ -5104,11 +5171,11 @@ struct TransportRotationLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "TimeIndex" },
             { false, FT_FLOAT, "Rot1" },
             { false, FT_FLOAT, "Rot2" },
             { false, FT_FLOAT, "Rot3" },
             { false, FT_FLOAT, "Rot4" },
+            { false, FT_INT, "TimeIndex" },
             { true, FT_INT, "GameObjectsID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TransportRotationMeta::Instance(), HOTFIX_SEL_TRANSPORT_ROTATION);
@@ -5116,6 +5183,96 @@ struct TransportRotationLoadInfo
     }
 };
 
+struct UiMapLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_STRING, "Name" },
+            { false, FT_INT, "ID" },
+            { true, FT_INT, "ParentUiMapID" },
+            { true, FT_INT, "Flags" },
+            { true, FT_INT, "System" },
+            { true, FT_INT, "Type" },
+            { false, FT_INT, "LevelRangeMin" },
+            { false, FT_INT, "LevelRangeMax" },
+            { true, FT_INT, "BountySetID" },
+            { false, FT_INT, "BountyDisplayLocation" },
+            { true, FT_INT, "VisibilityPlayerConditionID" },
+            { true, FT_BYTE, "HelpTextPosition" },
+            { true, FT_INT, "BkgAtlasID" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiMapMeta::Instance(), HOTFIX_SEL_UI_MAP);
+        return &loadInfo;
+    }
+};
+
+struct UiMapAssignmentLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_FLOAT, "UiMinX" },
+            { false, FT_FLOAT, "UiMinY" },
+            { false, FT_FLOAT, "UiMaxX" },
+            { false, FT_FLOAT, "UiMaxY" },
+            { false, FT_FLOAT, "Region1X" },
+            { false, FT_FLOAT, "Region1Y" },
+            { false, FT_FLOAT, "Region1Z" },
+            { false, FT_FLOAT, "Region2X" },
+            { false, FT_FLOAT, "Region2Y" },
+            { false, FT_FLOAT, "Region2Z" },
+            { false, FT_INT, "ID" },
+            { true, FT_INT, "UiMapID" },
+            { true, FT_INT, "OrderIndex" },
+            { true, FT_INT, "MapID" },
+            { true, FT_INT, "AreaID" },
+            { true, FT_INT, "WmoDoodadPlacementID" },
+            { true, FT_INT, "WmoGroupID" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiMapAssignmentMeta::Instance(), HOTFIX_SEL_UI_MAP_ASSIGNMENT);
+        return &loadInfo;
+    }
+};
+
+struct UiMapLinkLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_FLOAT, "UiMinX" },
+            { false, FT_FLOAT, "UiMinY" },
+            { false, FT_FLOAT, "UiMaxX" },
+            { false, FT_FLOAT, "UiMaxY" },
+            { false, FT_INT, "ID" },
+            { true, FT_INT, "ParentUiMapID" },
+            { true, FT_INT, "OrderIndex" },
+            { true, FT_INT, "ChildUiMapID" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiMapLinkMeta::Instance(), HOTFIX_SEL_UI_MAP_LINK);
+        return &loadInfo;
+    }
+};
+
+struct UiMapXMapArtLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_INT, "ID" },
+            { true, FT_INT, "PhaseID" },
+            { true, FT_INT, "UiMapArtID" },
+            { true, FT_INT, "UiMapID" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiMapXMapArtMeta::Instance(), HOTFIX_SEL_UI_MAP_X_MAP_ART);
+        return &loadInfo;
+    }
+};
+
 struct UnitPowerBarLoadInfo
 {
     static DB2LoadInfo const* Instance()
@@ -5127,8 +5284,16 @@ struct UnitPowerBarLoadInfo
             { false, FT_STRING, "Cost" },
             { false, FT_STRING, "OutOfError" },
             { false, FT_STRING, "ToolTip" },
+            { false, FT_INT, "MinPower" },
+            { false, FT_INT, "MaxPower" },
+            { false, FT_SHORT, "StartPower" },
+            { false, FT_BYTE, "CenterPower" },
             { false, FT_FLOAT, "RegenerationPeace" },
             { false, FT_FLOAT, "RegenerationCombat" },
+            { false, FT_BYTE, "BarType" },
+            { false, FT_SHORT, "Flags" },
+            { false, FT_FLOAT, "StartInset" },
+            { false, FT_FLOAT, "EndInset" },
             { true, FT_INT, "FileDataID1" },
             { true, FT_INT, "FileDataID2" },
             { true, FT_INT, "FileDataID3" },
@@ -5141,14 +5306,6 @@ struct UnitPowerBarLoadInfo
             { true, FT_INT, "Color4" },
             { true, FT_INT, "Color5" },
             { true, FT_INT, "Color6" },
-            { false, FT_FLOAT, "StartInset" },
-            { false, FT_FLOAT, "EndInset" },
-            { false, FT_SHORT, "StartPower" },
-            { false, FT_SHORT, "Flags" },
-            { false, FT_BYTE, "CenterPower" },
-            { false, FT_BYTE, "BarType" },
-            { false, FT_INT, "MinPower" },
-            { false, FT_INT, "MaxPower" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UnitPowerBarMeta::Instance(), HOTFIX_SEL_UNIT_POWER_BAR);
         return &loadInfo;
@@ -5163,6 +5320,7 @@ struct VehicleLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "Flags" },
+            { false, FT_BYTE, "FlagsB" },
             { false, FT_FLOAT, "TurnSpeed" },
             { false, FT_FLOAT, "PitchSpeed" },
             { false, FT_FLOAT, "PitchMin" },
@@ -5174,6 +5332,9 @@ struct VehicleLoadInfo
             { false, FT_FLOAT, "FacingLimitRight" },
             { false, FT_FLOAT, "FacingLimitLeft" },
             { false, FT_FLOAT, "CameraYawOffset" },
+            { false, FT_BYTE, "UiLocomotionType" },
+            { false, FT_SHORT, "VehicleUIIndicatorID" },
+            { true, FT_INT, "MissileTargetingID" },
             { false, FT_SHORT, "SeatID1" },
             { false, FT_SHORT, "SeatID2" },
             { false, FT_SHORT, "SeatID3" },
@@ -5182,13 +5343,9 @@ struct VehicleLoadInfo
             { false, FT_SHORT, "SeatID6" },
             { false, FT_SHORT, "SeatID7" },
             { false, FT_SHORT, "SeatID8" },
-            { false, FT_SHORT, "VehicleUIIndicatorID" },
             { false, FT_SHORT, "PowerDisplayID1" },
             { false, FT_SHORT, "PowerDisplayID2" },
             { false, FT_SHORT, "PowerDisplayID3" },
-            { false, FT_BYTE, "FlagsB" },
-            { false, FT_BYTE, "UiLocomotionType" },
-            { true, FT_INT, "MissileTargetingID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, VehicleMeta::Instance(), HOTFIX_SEL_VEHICLE);
         return &loadInfo;
@@ -5202,12 +5359,16 @@ struct VehicleSeatLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "Flags" },
-            { true, FT_INT, "FlagsB" },
-            { true, FT_INT, "FlagsC" },
             { false, FT_FLOAT, "AttachmentOffsetX" },
             { false, FT_FLOAT, "AttachmentOffsetY" },
             { false, FT_FLOAT, "AttachmentOffsetZ" },
+            { false, FT_FLOAT, "CameraOffsetX" },
+            { false, FT_FLOAT, "CameraOffsetY" },
+            { false, FT_FLOAT, "CameraOffsetZ" },
+            { true, FT_INT, "Flags" },
+            { true, FT_INT, "FlagsB" },
+            { true, FT_INT, "FlagsC" },
+            { true, FT_BYTE, "AttachmentID" },
             { false, FT_FLOAT, "EnterPreDelay" },
             { false, FT_FLOAT, "EnterSpeed" },
             { false, FT_FLOAT, "EnterGravity" },
@@ -5215,6 +5376,12 @@ struct VehicleSeatLoadInfo
             { false, FT_FLOAT, "EnterMaxDuration" },
             { false, FT_FLOAT, "EnterMinArcHeight" },
             { false, FT_FLOAT, "EnterMaxArcHeight" },
+            { true, FT_INT, "EnterAnimStart" },
+            { true, FT_INT, "EnterAnimLoop" },
+            { true, FT_INT, "RideAnimStart" },
+            { true, FT_INT, "RideAnimLoop" },
+            { true, FT_INT, "RideUpperAnimStart" },
+            { true, FT_INT, "RideUpperAnimLoop" },
             { false, FT_FLOAT, "ExitPreDelay" },
             { false, FT_FLOAT, "ExitSpeed" },
             { false, FT_FLOAT, "ExitGravity" },
@@ -5222,36 +5389,34 @@ struct VehicleSeatLoadInfo
             { false, FT_FLOAT, "ExitMaxDuration" },
             { false, FT_FLOAT, "ExitMinArcHeight" },
             { false, FT_FLOAT, "ExitMaxArcHeight" },
+            { true, FT_INT, "ExitAnimStart" },
+            { true, FT_INT, "ExitAnimLoop" },
+            { true, FT_INT, "ExitAnimEnd" },
+            { true, FT_SHORT, "VehicleEnterAnim" },
+            { true, FT_BYTE, "VehicleEnterAnimBone" },
+            { true, FT_SHORT, "VehicleExitAnim" },
+            { true, FT_BYTE, "VehicleExitAnimBone" },
+            { true, FT_SHORT, "VehicleRideAnimLoop" },
+            { true, FT_BYTE, "VehicleRideAnimLoopBone" },
+            { true, FT_BYTE, "PassengerAttachmentID" },
             { false, FT_FLOAT, "PassengerYaw" },
             { false, FT_FLOAT, "PassengerPitch" },
             { false, FT_FLOAT, "PassengerRoll" },
             { false, FT_FLOAT, "VehicleEnterAnimDelay" },
             { false, FT_FLOAT, "VehicleExitAnimDelay" },
+            { true, FT_BYTE, "VehicleAbilityDisplay" },
+            { false, FT_INT, "EnterUISoundID" },
+            { false, FT_INT, "ExitUISoundID" },
+            { true, FT_INT, "UiSkinFileDataID" },
             { false, FT_FLOAT, "CameraEnteringDelay" },
             { false, FT_FLOAT, "CameraEnteringDuration" },
             { false, FT_FLOAT, "CameraExitingDelay" },
             { false, FT_FLOAT, "CameraExitingDuration" },
-            { false, FT_FLOAT, "CameraOffsetX" },
-            { false, FT_FLOAT, "CameraOffsetY" },
-            { false, FT_FLOAT, "CameraOffsetZ" },
             { false, FT_FLOAT, "CameraPosChaseRate" },
             { false, FT_FLOAT, "CameraFacingChaseRate" },
             { false, FT_FLOAT, "CameraEnteringZoom" },
             { false, FT_FLOAT, "CameraSeatZoomMin" },
             { false, FT_FLOAT, "CameraSeatZoomMax" },
-            { true, FT_INT, "UiSkinFileDataID" },
-            { true, FT_SHORT, "EnterAnimStart" },
-            { true, FT_SHORT, "EnterAnimLoop" },
-            { true, FT_SHORT, "RideAnimStart" },
-            { true, FT_SHORT, "RideAnimLoop" },
-            { true, FT_SHORT, "RideUpperAnimStart" },
-            { true, FT_SHORT, "RideUpperAnimLoop" },
-            { true, FT_SHORT, "ExitAnimStart" },
-            { true, FT_SHORT, "ExitAnimLoop" },
-            { true, FT_SHORT, "ExitAnimEnd" },
-            { true, FT_SHORT, "VehicleEnterAnim" },
-            { true, FT_SHORT, "VehicleExitAnim" },
-            { true, FT_SHORT, "VehicleRideAnimLoop" },
             { true, FT_SHORT, "EnterAnimKitID" },
             { true, FT_SHORT, "RideAnimKitID" },
             { true, FT_SHORT, "ExitAnimKitID" },
@@ -5259,14 +5424,6 @@ struct VehicleSeatLoadInfo
             { true, FT_SHORT, "VehicleRideAnimKitID" },
             { true, FT_SHORT, "VehicleExitAnimKitID" },
             { true, FT_SHORT, "CameraModeID" },
-            { true, FT_BYTE, "AttachmentID" },
-            { true, FT_BYTE, "PassengerAttachmentID" },
-            { true, FT_BYTE, "VehicleEnterAnimBone" },
-            { true, FT_BYTE, "VehicleExitAnimBone" },
-            { true, FT_BYTE, "VehicleRideAnimLoopBone" },
-            { true, FT_BYTE, "VehicleAbilityDisplay" },
-            { false, FT_INT, "EnterUISoundID" },
-            { false, FT_INT, "ExitUISoundID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, VehicleSeatMeta::Instance(), HOTFIX_SEL_VEHICLE_SEAT);
         return &loadInfo;
@@ -5280,20 +5437,20 @@ struct WmoAreaTableLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_STRING, "AreaName" },
+            { false, FT_INT, "ID" },
+            { false, FT_SHORT, "WmoID" },
+            { false, FT_BYTE, "NameSetID" },
             { true, FT_INT, "WmoGroupID" },
+            { false, FT_BYTE, "SoundProviderPref" },
+            { false, FT_BYTE, "SoundProviderPrefUnderwater" },
             { false, FT_SHORT, "AmbienceID" },
+            { false, FT_SHORT, "UwAmbience" },
             { false, FT_SHORT, "ZoneMusic" },
+            { false, FT_INT, "UwZoneMusic" },
             { false, FT_SHORT, "IntroSound" },
-            { false, FT_SHORT, "AreaTableID" },
             { false, FT_SHORT, "UwIntroSound" },
-            { false, FT_SHORT, "UwAmbience" },
-            { false, FT_BYTE, "NameSetID" },
-            { false, FT_BYTE, "SoundProviderPref" },
-            { false, FT_BYTE, "SoundProviderPrefUnderwater" },
+            { false, FT_SHORT, "AreaTableID" },
             { false, FT_BYTE, "Flags" },
-            { false, FT_INT, "ID" },
-            { false, FT_INT, "UwZoneMusic" },
-            { false, FT_SHORT, "WmoID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WMOAreaTableMeta::Instance(), HOTFIX_SEL_WMO_AREA_TABLE);
         return &loadInfo;
@@ -5307,63 +5464,33 @@ struct WorldEffectLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "TargetAsset" },
-            { false, FT_SHORT, "CombatConditionID" },
-            { false, FT_BYTE, "TargetType" },
-            { false, FT_BYTE, "WhenToDisplay" },
             { false, FT_INT, "QuestFeedbackEffectID" },
+            { false, FT_BYTE, "WhenToDisplay" },
+            { false, FT_BYTE, "TargetType" },
+            { true, FT_INT, "TargetAsset" },
             { false, FT_INT, "PlayerConditionID" },
+            { false, FT_SHORT, "CombatConditionID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldEffectMeta::Instance(), HOTFIX_SEL_WORLD_EFFECT);
         return &loadInfo;
     }
 };
 
-struct WorldMapAreaLoadInfo
-{
-    static DB2LoadInfo const* Instance()
-    {
-        static DB2FieldMeta const fields[] =
-        {
-            { false, FT_STRING_NOT_LOCALIZED, "AreaName" },
-            { false, FT_FLOAT, "LocLeft" },
-            { false, FT_FLOAT, "LocRight" },
-            { false, FT_FLOAT, "LocTop" },
-            { false, FT_FLOAT, "LocBottom" },
-            { false, FT_INT, "Flags" },
-            { true, FT_SHORT, "MapID" },
-            { false, FT_SHORT, "AreaID" },
-            { true, FT_SHORT, "DisplayMapID" },
-            { false, FT_SHORT, "DefaultDungeonFloor" },
-            { false, FT_SHORT, "ParentWorldMapID" },
-            { false, FT_BYTE, "LevelRangeMin" },
-            { false, FT_BYTE, "LevelRangeMax" },
-            { false, FT_BYTE, "BountySetID" },
-            { false, FT_BYTE, "BountyDisplayLocation" },
-            { false, FT_INT, "ID" },
-            { false, FT_INT, "VisibilityPlayerConditionID" },
-        };
-        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldMapAreaMeta::Instance(), HOTFIX_SEL_WORLD_MAP_AREA);
-        return &loadInfo;
-    }
-};
-
 struct WorldMapOverlayLoadInfo
 {
     static DB2LoadInfo const* Instance()
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_STRING_NOT_LOCALIZED, "TextureName" },
             { false, FT_INT, "ID" },
+            { false, FT_INT, "UiMapArtID" },
             { false, FT_SHORT, "TextureWidth" },
             { false, FT_SHORT, "TextureHeight" },
-            { false, FT_INT, "MapAreaID" },
             { true, FT_INT, "OffsetX" },
             { true, FT_INT, "OffsetY" },
             { true, FT_INT, "HitRectTop" },
-            { true, FT_INT, "HitRectLeft" },
             { true, FT_INT, "HitRectBottom" },
+            { true, FT_INT, "HitRectLeft" },
             { true, FT_INT, "HitRectRight" },
             { false, FT_INT, "PlayerConditionID" },
             { false, FT_INT, "Flags" },
@@ -5377,35 +5504,6 @@ struct WorldMapOverlayLoadInfo
     }
 };
 
-struct WorldMapTransformsLoadInfo
-{
-    static DB2LoadInfo const* Instance()
-    {
-        static DB2FieldMeta const fields[] =
-        {
-            { false, FT_INT, "ID" },
-            { false, FT_FLOAT, "RegionMinX" },
-            { false, FT_FLOAT, "RegionMinY" },
-            { false, FT_FLOAT, "RegionMinZ" },
-            { false, FT_FLOAT, "RegionMaxX" },
-            { false, FT_FLOAT, "RegionMaxY" },
-            { false, FT_FLOAT, "RegionMaxZ" },
-            { false, FT_FLOAT, "RegionOffsetX" },
-            { false, FT_FLOAT, "RegionOffsetY" },
-            { false, FT_FLOAT, "RegionScale" },
-            { false, FT_SHORT, "MapID" },
-            { false, FT_SHORT, "AreaID" },
-            { false, FT_SHORT, "NewMapID" },
-            { false, FT_SHORT, "NewDungeonMapID" },
-            { false, FT_SHORT, "NewAreaID" },
-            { false, FT_BYTE, "Flags" },
-            { true, FT_INT, "Priority" },
-        };
-        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldMapTransformsMeta::Instance(), HOTFIX_SEL_WORLD_MAP_TRANSFORMS);
-        return &loadInfo;
-    }
-};
-
 struct WorldSafeLocsLoadInfo
 {
     static DB2LoadInfo const* Instance()
@@ -5417,8 +5515,8 @@ struct WorldSafeLocsLoadInfo
             { false, FT_FLOAT, "LocX" },
             { false, FT_FLOAT, "LocY" },
             { false, FT_FLOAT, "LocZ" },
-            { false, FT_FLOAT, "Facing" },
             { false, FT_SHORT, "MapID" },
+            { false, FT_FLOAT, "Facing" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldSafeLocsMeta::Instance(), HOTFIX_SEL_WORLD_SAFE_LOCS);
         return &loadInfo;
diff --git a/src/server/game/DataStores/DB2Stores.cpp b/src/server/game/DataStores/DB2Stores.cpp
index b233f53324b..52ae4deaa2f 100644
--- a/src/server/game/DataStores/DB2Stores.cpp
+++ b/src/server/game/DataStores/DB2Stores.cpp
@@ -263,14 +263,16 @@ DB2Storage<TransmogSetGroupEntry>               sTransmogSetGroupStore("Transmog
 DB2Storage<TransmogSetItemEntry>                sTransmogSetItemStore("TransmogSetItem.db2", TransmogSetItemLoadInfo::Instance());
 DB2Storage<TransportAnimationEntry>             sTransportAnimationStore("TransportAnimation.db2", TransportAnimationLoadInfo::Instance());
 DB2Storage<TransportRotationEntry>              sTransportRotationStore("TransportRotation.db2", TransportRotationLoadInfo::Instance());
+DB2Storage<UiMapEntry>                          sUiMapStore("UiMap.db2", UiMapLoadInfo::Instance());
+DB2Storage<UiMapAssignmentEntry>                sUiMapAssignmentStore("UiMapAssignment.db2", UiMapAssignmentLoadInfo::Instance());
+DB2Storage<UiMapLinkEntry>                      sUiMapLinkStore("UiMapLink.db2", UiMapLinkLoadInfo::Instance());
+DB2Storage<UiMapXMapArtEntry>                   sUiMapXMapArtStore("UiMapXMapArt.db2", UiMapXMapArtLoadInfo::Instance());
 DB2Storage<UnitPowerBarEntry>                   sUnitPowerBarStore("UnitPowerBar.db2", UnitPowerBarLoadInfo::Instance());
 DB2Storage<VehicleEntry>                        sVehicleStore("Vehicle.db2", VehicleLoadInfo::Instance());
 DB2Storage<VehicleSeatEntry>                    sVehicleSeatStore("VehicleSeat.db2", VehicleSeatLoadInfo::Instance());
 DB2Storage<WMOAreaTableEntry>                   sWMOAreaTableStore("WMOAreaTable.db2", WmoAreaTableLoadInfo::Instance());
 DB2Storage<WorldEffectEntry>                    sWorldEffectStore("WorldEffect.db2", WorldEffectLoadInfo::Instance());
-DB2Storage<WorldMapAreaEntry>                   sWorldMapAreaStore("WorldMapArea.db2", WorldMapAreaLoadInfo::Instance());
 DB2Storage<WorldMapOverlayEntry>                sWorldMapOverlayStore("WorldMapOverlay.db2", WorldMapOverlayLoadInfo::Instance());
-DB2Storage<WorldMapTransformsEntry>             sWorldMapTransformsStore("WorldMapTransforms.db2", WorldMapTransformsLoadInfo::Instance());
 DB2Storage<WorldSafeLocsEntry>                  sWorldSafeLocsStore("WorldSafeLocs.db2", WorldSafeLocsLoadInfo::Instance());
 
 TaxiMask                                        sTaxiNodesMask;
@@ -331,10 +333,17 @@ typedef std::vector<TalentEntry const*> TalentsByPosition[MAX_CLASSES][MAX_TALEN
 typedef std::unordered_set<uint32> ToyItemIdsContainer;
 typedef std::tuple<uint16, uint8, int32> WMOAreaTableKey;
 typedef std::map<WMOAreaTableKey, WMOAreaTableEntry const*> WMOAreaTableLookupContainer;
-typedef std::unordered_map<uint32, WorldMapAreaEntry const*> WorldMapAreaByAreaIDContainer;
 
 namespace
 {
+    struct UiMapBounds
+    {
+        // these coords are mixed when calculated and used... its a mess
+        float Bounds[4];
+        bool IsUiAssignment;
+        bool IsUiLink;
+    };
+
     StorageMap _stores;
     std::map<uint64, int32> _hotfixData;
 
@@ -391,8 +400,13 @@ namespace
     ToyItemIdsContainer _toys;
     std::unordered_map<uint32, std::vector<TransmogSetEntry const*>> _transmogSetsByItemModifiedAppearance;
     std::unordered_map<uint32, std::vector<TransmogSetItemEntry const*>> _transmogSetItemsByTransmogSet;
+    std::unordered_map<int32, UiMapBounds> _uiMapBounds;
+    std::unordered_multimap<int32, UiMapAssignmentEntry const*> _uiMapAssignmentByMap[MAX_UI_MAP_SYSTEM];
+    std::unordered_multimap<int32, UiMapAssignmentEntry const*> _uiMapAssignmentByArea[MAX_UI_MAP_SYSTEM];
+    std::unordered_multimap<int32, UiMapAssignmentEntry const*> _uiMapAssignmentByWmoDoodadPlacement[MAX_UI_MAP_SYSTEM];
+    std::unordered_multimap<int32, UiMapAssignmentEntry const*> _uiMapAssignmentByWmoGroup[MAX_UI_MAP_SYSTEM];
+    std::unordered_set<int32> _uiMapPhases;
     WMOAreaTableLookupContainer _wmoAreaTableLookup;
-    WorldMapAreaByAreaIDContainer _worldMapAreaByAreaID;
 }
 
 template<class T, template<class> class DB2>
@@ -421,7 +435,7 @@ inline void LoadDB2(uint32& availableDb2Locales, std::vector<std::string>& errli
 
     if (storage->Load(db2Path + localeNames[defaultLocale] + '/', defaultLocale))
     {
-        storage->LoadFromDB();
+       storage->LoadFromDB();
         // LoadFromDB() always loads strings into enUS locale, other locales are expected to have data in corresponding _locale tables
         // so we need to make additional call to load that data in case said locale is set as default by worldserver.conf (and we do not want to load all this data from .db2 file again)
         if (defaultLocale != LOCALE_enUS)
@@ -629,7 +643,6 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
     LOAD_DB2(sPrestigeLevelInfoStore);
     LOAD_DB2(sPVPDifficultyStore);
     LOAD_DB2(sPVPItemStore);
-    //LOAD_DB2(sPvpRewardStore);
     LOAD_DB2(sPvpTalentStore);
     LOAD_DB2(sPvpTalentCategoryStore);
     LOAD_DB2(sPvpTalentSlotUnlockStore);
@@ -702,14 +715,16 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
     LOAD_DB2(sTransmogSetItemStore);
     LOAD_DB2(sTransportAnimationStore);
     LOAD_DB2(sTransportRotationStore);
+    LOAD_DB2(sUiMapStore);
+    LOAD_DB2(sUiMapAssignmentStore);
+    LOAD_DB2(sUiMapLinkStore);
+    LOAD_DB2(sUiMapXMapArtStore);
     LOAD_DB2(sUnitPowerBarStore);
     LOAD_DB2(sVehicleStore);
     LOAD_DB2(sVehicleSeatStore);
     LOAD_DB2(sWMOAreaTableStore);
     LOAD_DB2(sWorldEffectStore);
-    LOAD_DB2(sWorldMapAreaStore);
     LOAD_DB2(sWorldMapOverlayStore);
-    LOAD_DB2(sWorldMapTransformsStore);
     LOAD_DB2(sWorldSafeLocsStore);
 
 #undef LOAD_DB2
@@ -1067,6 +1082,118 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
     for (TaxiPathNodeEntry const* entry : sTaxiPathNodeStore)
         sTaxiPathNodesByPath[entry->PathID][entry->NodeIndex] = entry;
 
+    for (ToyEntry const* toy : sToyStore)
+        _toys.insert(toy->ItemID);
+
+    for (TransmogSetItemEntry const* transmogSetItem : sTransmogSetItemStore)
+    {
+        TransmogSetEntry const* set = sTransmogSetStore.LookupEntry(transmogSetItem->TransmogSetID);
+        if (!set)
+            continue;
+
+        _transmogSetsByItemModifiedAppearance[transmogSetItem->ItemModifiedAppearanceID].push_back(set);
+        _transmogSetItemsByTransmogSet[transmogSetItem->TransmogSetID].push_back(transmogSetItem);
+    }
+
+    std::unordered_multimap<int32, UiMapAssignmentEntry const*> uiMapAssignmentByUiMap;
+    for (UiMapAssignmentEntry const* uiMapAssignment : sUiMapAssignmentStore)
+    {
+        uiMapAssignmentByUiMap.emplace(uiMapAssignment->UiMapID, uiMapAssignment);
+        if (UiMapEntry const* uiMap = sUiMapStore.LookupEntry(uiMapAssignment->UiMapID))
+        {
+            ASSERT(uiMap->System < MAX_UI_MAP_SYSTEM, "MAX_TALENT_TIERS must be at least %u", uiMap->System + 1);
+            if (uiMapAssignment->MapID >= 0)
+                _uiMapAssignmentByMap[uiMap->System].emplace(uiMapAssignment->MapID, uiMapAssignment);
+            if (uiMapAssignment->AreaID)
+                _uiMapAssignmentByArea[uiMap->System].emplace(uiMapAssignment->AreaID, uiMapAssignment);
+            if (uiMapAssignment->WmoDoodadPlacementID)
+                _uiMapAssignmentByWmoDoodadPlacement[uiMap->System].emplace(uiMapAssignment->WmoDoodadPlacementID, uiMapAssignment);
+            if (uiMapAssignment->WmoGroupID)
+                _uiMapAssignmentByWmoGroup[uiMap->System].emplace(uiMapAssignment->WmoGroupID, uiMapAssignment);
+        }
+    }
+
+    std::unordered_map<std::pair<int32, uint32>, UiMapLinkEntry const*> uiMapLinks;
+    for (UiMapLinkEntry const* uiMapLink : sUiMapLinkStore)
+        uiMapLinks[std::make_pair(uiMapLink->ParentUiMapID, uint32(uiMapLink->ChildUiMapID))] = uiMapLink;
+
+    for (UiMapEntry const* uiMap : sUiMapStore)
+    {
+        UiMapBounds& bounds = _uiMapBounds[uiMap->ID];
+        memset(&bounds, 0, sizeof(bounds));
+        if (UiMapEntry const* parentUiMap = sUiMapStore.LookupEntry(uiMap->ParentUiMapID))
+        {
+            if (parentUiMap->Flags & 0x80)
+                continue;
+
+            UiMapAssignmentEntry const* uiMapAssignment = nullptr;
+            UiMapAssignmentEntry const* parentUiMapAssignment = nullptr;
+            for (auto uiMapAssignmentForMap : Trinity::Containers::MapEqualRange(uiMapAssignmentByUiMap, uiMap->ID))
+            {
+                if (uiMapAssignmentForMap.second->MapID >= 0 &&
+                    uiMapAssignmentForMap.second->Region[1].X - uiMapAssignmentForMap.second->Region[0].X > 0 &&
+                    uiMapAssignmentForMap.second->Region[1].Y - uiMapAssignmentForMap.second->Region[0].Y > 0)
+                {
+                    uiMapAssignment = uiMapAssignmentForMap.second;
+                    break;
+                }
+            }
+
+            if (!uiMapAssignment)
+                continue;
+
+            for (auto uiMapAssignmentForMap : Trinity::Containers::MapEqualRange(uiMapAssignmentByUiMap, uiMap->ParentUiMapID))
+            {
+                if (uiMapAssignmentForMap.second->MapID == uiMapAssignment->MapID &&
+                    uiMapAssignmentForMap.second->Region[1].X - uiMapAssignmentForMap.second->Region[0].X > 0 &&
+                    uiMapAssignmentForMap.second->Region[1].Y - uiMapAssignmentForMap.second->Region[0].Y > 0)
+                {
+                    parentUiMapAssignment = uiMapAssignmentForMap.second;
+                    break;
+                }
+            }
+
+            if (!parentUiMapAssignment)
+                continue;
+
+            float parentXsize = parentUiMapAssignment->Region[1].X - parentUiMapAssignment->Region[0].X;
+            float parentYsize = parentUiMapAssignment->Region[1].Y - parentUiMapAssignment->Region[0].Y;
+            float bound0scale = (uiMapAssignment->Region[1].X - parentUiMapAssignment->Region[0].X) / parentXsize;
+            float bound0 = ((1.0f - bound0scale) * parentUiMapAssignment->UiMax.Y) + (bound0scale * parentUiMapAssignment->UiMin.Y);
+            float bound2scale = (uiMapAssignment->Region[0].X - parentUiMapAssignment->Region[0].X) / parentXsize;
+            float bound2 = ((1.0f - bound2scale) * parentUiMapAssignment->UiMax.Y) + (bound2scale * parentUiMapAssignment->UiMin.Y);
+            float bound1scale = (uiMapAssignment->Region[1].Y - parentUiMapAssignment->Region[0].Y) / parentYsize;
+            float bound1 = ((1.0f - bound1scale) * parentUiMapAssignment->UiMax.X) + (bound1scale * parentUiMapAssignment->UiMin.X);
+            float bound3scale = (uiMapAssignment->Region[0].Y - parentUiMapAssignment->Region[0].Y) / parentYsize;
+            float bound3 = ((1.0f - bound3scale) * parentUiMapAssignment->UiMax.X) + (bound3scale * parentUiMapAssignment->UiMin.X);
+            if ((bound3 - bound1) > 0.0f || (bound2 - bound0) > 0.0f)
+            {
+                bounds.Bounds[0] = bound0;
+                bounds.Bounds[1] = bound1;
+                bounds.Bounds[2] = bound2;
+                bounds.Bounds[3] = bound3;
+                bounds.IsUiAssignment = true;
+            }
+        }
+
+        if (UiMapLinkEntry const* uiMapLink = Trinity::Containers::MapGetValuePtr(uiMapLinks, std::make_pair(uiMap->ParentUiMapID, uiMap->ID)))
+        {
+            bounds.IsUiAssignment = false;
+            bounds.IsUiLink = true;
+            bounds.Bounds[0] = uiMapLink->UiMin.Y;
+            bounds.Bounds[1] = uiMapLink->UiMin.X;
+            bounds.Bounds[2] = uiMapLink->UiMax.Y;
+            bounds.Bounds[3] = uiMapLink->UiMax.X;
+        }
+    }
+
+    for (UiMapXMapArtEntry const* uiMapArt : sUiMapXMapArtStore)
+        if (uiMapArt->PhaseID)
+            _uiMapPhases.insert(uiMapArt->PhaseID);
+
+    for (WMOAreaTableEntry const* entry : sWMOAreaTableStore)
+        _wmoAreaTableLookup[WMOAreaTableKey(entry->WmoID, entry->NameSetID, entry->WmoGroupID)] = entry;
+
     // Initialize global taxinodes mask
     // include existed nodes that have at least single not spell base (scripted) path
     {
@@ -1096,32 +1223,20 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
             if (node->Flags & TAXI_NODE_FLAG_ALLIANCE)
                 sAllianceTaxiNodesMask[field] |= submask;
 
-            uint32 nodeMap;
-            DeterminaAlternateMapPosition(node->ContinentID, node->Pos.X, node->Pos.Y, node->Pos.Z, &nodeMap);
-            if (nodeMap < 2)
-                sOldContinentsNodesMask[field] |= submask;
-        }
-    }
+            int32 uiMapId = -1;
+            if (!GetUiMapPosition(node->Pos.X, node->Pos.Y, node->Pos.Z, node->ContinentID, 0, 0, 0, UI_MAP_SYSTEM_ADVENTURE, false, &uiMapId))
+                GetUiMapPosition(node->Pos.X, node->Pos.Y, node->Pos.Z, node->ContinentID, 0, 0, 0, UI_MAP_SYSTEM_TAXI, false, &uiMapId);
 
-    for (ToyEntry const* toy : sToyStore)
-        _toys.insert(toy->ItemID);
-
-    for (TransmogSetItemEntry const* transmogSetItem : sTransmogSetItemStore)
-    {
-        TransmogSetEntry const* set = sTransmogSetStore.LookupEntry(transmogSetItem->TransmogSetID);
-        if (!set)
-            continue;
+            if (uiMapId != -1)
+            {
+                TC_LOG_INFO(LOGGER_ROOT, "%s %d %f %f %f %d", node->Name->Str[0], node->ConditionID, node->Pos.X, node->Pos.Y, node->Pos.Z, uiMapId);
+            }
 
-        _transmogSetsByItemModifiedAppearance[transmogSetItem->ItemModifiedAppearanceID].push_back(set);
-        _transmogSetItemsByTransmogSet[transmogSetItem->TransmogSetID].push_back(transmogSetItem);
+            if (uiMapId == 985 || uiMapId == 986)
+                sOldContinentsNodesMask[field] |= submask;
+        }
     }
 
-    for (WMOAreaTableEntry const* entry : sWMOAreaTableStore)
-        _wmoAreaTableLookup[WMOAreaTableKey(entry->WmoID, entry->NameSetID, entry->WmoGroupID)] = entry;
-
-    for (WorldMapAreaEntry const* worldMapArea : sWorldMapAreaStore)
-        _worldMapAreaByAreaID[worldMapArea->AreaID] = worldMapArea;
-
     // error checks
     if (bad_db2_files.size() == _stores.size())
     {
@@ -2253,99 +2368,355 @@ std::vector<TransmogSetItemEntry const*> const* DB2Manager::GetTransmogSetItems(
     return Trinity::Containers::MapGetValuePtr(_transmogSetItemsByTransmogSet, transmogSetId);
 }
 
-WMOAreaTableEntry const* DB2Manager::GetWMOAreaTable(int32 rootId, int32 adtId, int32 groupId) const
+struct UiMapAssignmentStatus
 {
-    auto i = _wmoAreaTableLookup.find(WMOAreaTableKey(int16(rootId), int8(adtId), groupId));
-    if (i != _wmoAreaTableLookup.end())
-        return i->second;
+    UiMapAssignmentEntry const* UiMapAssignment = nullptr;
+    // distances if inside
+    struct
+    {
+        float DistanceToRegionCenterSquared = std::numeric_limits<float>::max();
+        float DistanceToRegionBottom = std::numeric_limits<float>::max();
+    } Inside;
 
-    return nullptr;
-}
+    // distances if outside
+    struct
+    {
+        float DistanceToRegionEdgeSquared = std::numeric_limits<float>::max();
+        float DistanceToRegionTop = std::numeric_limits<float>::max();
+        float DistanceToRegionBottom = std::numeric_limits<float>::max();
+    } Outside;
 
-uint32 DB2Manager::GetVirtualMapForMapAndZone(uint32 mapId, uint32 zoneId) const
+    int8 MapPriority = 3;
+    int8 AreaPriority = -1;
+    int8 WmoPriority = 3;
+
+    bool IsInside() const
+    {
+        return Outside.DistanceToRegionEdgeSquared < std::numeric_limits<float>::epsilon() &&
+            std::abs(Outside.DistanceToRegionTop) < std::numeric_limits<float>::epsilon() &&
+            std::abs(Outside.DistanceToRegionBottom) < std::numeric_limits<float>::epsilon();
+    }
+};
+
+static bool operator<(UiMapAssignmentStatus const& left, UiMapAssignmentStatus const& right)
 {
-    if (mapId != 530 && mapId != 571 && mapId != 732)   // speed for most cases
-        return mapId;
+    bool leftInside = left.IsInside();
+    bool rightInside = right.IsInside();
+    if (leftInside != rightInside)
+        return leftInside;
+
+    if (left.UiMapAssignment && right.UiMapAssignment &&
+        left.UiMapAssignment->UiMapID == right.UiMapAssignment->UiMapID &&
+        left.UiMapAssignment->OrderIndex != right.UiMapAssignment->OrderIndex)
+        return left.UiMapAssignment->OrderIndex < right.UiMapAssignment->OrderIndex;
+
+    if (left.WmoPriority != right.WmoPriority)
+        return left.WmoPriority < right.WmoPriority;
+
+    if (left.AreaPriority != right.AreaPriority)
+        return left.AreaPriority < right.AreaPriority;
+
+    if (left.MapPriority != right.MapPriority)
+        return left.MapPriority < right.MapPriority;
+
+    if (leftInside)
+    {
+        if (left.Inside.DistanceToRegionBottom != right.Inside.DistanceToRegionBottom)
+            return left.Inside.DistanceToRegionBottom < right.Inside.DistanceToRegionBottom;
+
+        float leftUiSizeX = left.UiMapAssignment ? (left.UiMapAssignment->UiMax.X - left.UiMapAssignment->UiMin.X) : 0.0f;
+        float rightUiSizeX = right.UiMapAssignment ? (right.UiMapAssignment->UiMax.X - right.UiMapAssignment->UiMin.X) : 0.0f;
+
+        if (leftUiSizeX > std::numeric_limits<float>::epsilon() && rightUiSizeX > std::numeric_limits<float>::epsilon())
+        {
+            float leftScale = (left.UiMapAssignment->Region[1].X - left.UiMapAssignment->Region[0].X) / leftUiSizeX;
+            float rightScale = (right.UiMapAssignment->Region[1].X - right.UiMapAssignment->Region[0].X) / rightUiSizeX;
+            if (leftScale != rightScale)
+                return leftScale < rightScale;
+        }
 
-    auto itr = _worldMapAreaByAreaID.find(zoneId);
-    if (itr != _worldMapAreaByAreaID.end())
-        return itr->second->DisplayMapID >= 0 ? itr->second->DisplayMapID : itr->second->MapID;
+        if (left.Inside.DistanceToRegionCenterSquared != right.Inside.DistanceToRegionCenterSquared)
+            return left.Inside.DistanceToRegionCenterSquared < right.Inside.DistanceToRegionCenterSquared;
+    }
+    else
+    {
+        if (left.Outside.DistanceToRegionTop != right.Outside.DistanceToRegionTop)
+            return left.Outside.DistanceToRegionTop < right.Outside.DistanceToRegionTop;
+
+        if (left.Outside.DistanceToRegionBottom != right.Outside.DistanceToRegionBottom)
+            return left.Outside.DistanceToRegionBottom < right.Outside.DistanceToRegionBottom;
 
-    return mapId;
+        if (left.Outside.DistanceToRegionEdgeSquared != right.Outside.DistanceToRegionEdgeSquared)
+            return left.Outside.DistanceToRegionEdgeSquared < right.Outside.DistanceToRegionEdgeSquared;
+    }
+
+    return true;
 }
 
-void DB2Manager::Zone2MapCoordinates(uint32 areaId, float& x, float& y) const
+static bool CheckUiMapAssignmentStatus(float x, float y, float z, int32 mapId, int32 areaId, int32 wmoDoodadPlacementId, int32 wmoGroupId,
+    UiMapAssignmentEntry const* uiMapAssignment, UiMapAssignmentStatus* status)
 {
-    auto itr = _worldMapAreaByAreaID.find(areaId);
-    if (itr == _worldMapAreaByAreaID.end())
-        return;
+    status->UiMapAssignment = uiMapAssignment;
+    // x,y not in region
+    if (x < uiMapAssignment->Region[0].X || x > uiMapAssignment->Region[1].X || y < uiMapAssignment->Region[0].Y || y > uiMapAssignment->Region[1].Y)
+    {
+        float xDiff, yDiff;
+        if (x >= uiMapAssignment->Region[0].X)
+        {
+            xDiff = 0.0f;
+            if (x > uiMapAssignment->Region[1].X)
+                xDiff = x - uiMapAssignment->Region[0].X;
+        }
+        else
+            xDiff = uiMapAssignment->Region[0].X - x;
+
+        if (y >= uiMapAssignment->Region[0].Y)
+        {
+            yDiff = 0.0f;
+            if (y > uiMapAssignment->Region[1].Y)
+                yDiff = y - uiMapAssignment->Region[0].Y;
+        }
+        else
+            yDiff = uiMapAssignment->Region[0].Y - y;
+
+        status->Outside.DistanceToRegionEdgeSquared = xDiff * xDiff + yDiff * yDiff;
+    }
+    else
+    {
+        status->Inside.DistanceToRegionCenterSquared =
+            (x - (uiMapAssignment->Region[0].X + uiMapAssignment->Region[1].X) * 0.5f) * (x - (uiMapAssignment->Region[0].X + uiMapAssignment->Region[1].X) * 0.5f)
+            + (y - (uiMapAssignment->Region[0].Y + uiMapAssignment->Region[1].Y) * 0.5f) * (y - (uiMapAssignment->Region[0].Y + uiMapAssignment->Region[1].Y) * 0.5f);
+        status->Outside.DistanceToRegionEdgeSquared = 0.0f;
+    }
 
-    std::swap(x, y);                                         // at client map coords swapped
-    x = x*((itr->second->LocBottom - itr->second->LocTop) / 100) + itr->second->LocTop;
-    y = y*((itr->second->LocRight - itr->second->LocLeft) / 100) + itr->second->LocLeft;        // client y coord from top to down
+    // z not in region
+    if (z < uiMapAssignment->Region[0].Z || z > uiMapAssignment->Region[1].Z)
+    {
+        if (z < uiMapAssignment->Region[1].Z)
+        {
+            if (z < uiMapAssignment->Region[0].Z)
+                status->Outside.DistanceToRegionBottom = std::min(uiMapAssignment->Region[0].Z - z, 10000.0f);
+        }
+        else
+            status->Outside.DistanceToRegionTop = std::min(z - uiMapAssignment->Region[1].Z, 10000.0f);
+    }
+    else
+    {
+        status->Outside.DistanceToRegionTop = 0.0f;
+        status->Outside.DistanceToRegionBottom = 0.0f;
+        status->Inside.DistanceToRegionBottom = std::min(uiMapAssignment->Region[0].Z - z, 10000.0f);
+    }
+
+    if (areaId && uiMapAssignment->AreaID)
+    {
+        int8 areaPriority = 0;
+        if (areaId)
+        {
+            while (areaId != uiMapAssignment->AreaID)
+            {
+                if (AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(areaId))
+                {
+                    areaId = areaEntry->ParentAreaID;
+                    ++areaPriority;
+                }
+                else
+                    return false;
+            }
+        }
+        else
+            return false;
+
+        status->AreaPriority = areaPriority;
+    }
+
+    if (mapId >= 0 && uiMapAssignment->MapID >= 0)
+    {
+        if (mapId != uiMapAssignment->MapID)
+        {
+            if (MapEntry const* mapEntry = sMapStore.LookupEntry(mapId))
+            {
+                if (mapEntry->ParentMapID == uiMapAssignment->MapID)
+                    status->MapPriority = 1;
+                else if (mapEntry->CosmeticParentMapID == uiMapAssignment->MapID)
+                    status->MapPriority = 2;
+                else
+                    return false;
+            }
+            else
+                return false;
+        }
+        else
+            status->MapPriority = 0;
+    }
+
+    if (wmoGroupId || wmoDoodadPlacementId)
+    {
+        if (uiMapAssignment->WmoGroupID || uiMapAssignment->WmoDoodadPlacementID)
+        {
+            bool hasDoodadPlacement = false;
+            if (wmoDoodadPlacementId && uiMapAssignment->WmoDoodadPlacementID)
+            {
+                if (wmoDoodadPlacementId != uiMapAssignment->WmoDoodadPlacementID)
+                    return false;
+
+                hasDoodadPlacement = true;
+            }
+
+            if (wmoGroupId && uiMapAssignment->WmoGroupID)
+            {
+                if (wmoGroupId != uiMapAssignment->WmoGroupID)
+                    return false;
+
+                if (hasDoodadPlacement)
+                    status->WmoPriority = 0;
+                else
+                    status->WmoPriority = 2;
+            }
+            else if (hasDoodadPlacement)
+                status->WmoPriority = 1;
+        }
+    }
+
+    return true;
 }
 
-void DB2Manager::Map2ZoneCoordinates(uint32 areaId, float& x, float& y) const
+static UiMapAssignmentEntry const* FindNearestMapAssignment(float x, float y, float z, int32 mapId, int32 areaId, int32 wmoDoodadPlacementId, int32 wmoGroupId, UiMapSystem system)
 {
-    auto itr = _worldMapAreaByAreaID.find(areaId);
-    if (itr == _worldMapAreaByAreaID.end())
-        return;
+    UiMapAssignmentStatus nearestMapAssignment;
+    auto iterateUiMapAssignments = [&](std::unordered_multimap<int32, UiMapAssignmentEntry const*> const& assignments, int32 id)
+    {
+        for (auto assignment : Trinity::Containers::MapEqualRange(assignments, id))
+        {
+            UiMapAssignmentStatus status;
+            if (CheckUiMapAssignmentStatus(x, y, z, mapId, areaId, wmoDoodadPlacementId, wmoGroupId, assignment.second, &status))
+                if (status < nearestMapAssignment)
+                    nearestMapAssignment = status;
+        }
+    };
 
-    x = (x - itr->second->LocTop) / ((itr->second->LocBottom - itr->second->LocTop) / 100);
-    y = (y - itr->second->LocLeft) / ((itr->second->LocRight - itr->second->LocLeft) / 100);    // client y coord from top to down
-    std::swap(x, y);                                         // client have map coords swapped
+    iterateUiMapAssignments(_uiMapAssignmentByWmoGroup[system], wmoGroupId);
+    iterateUiMapAssignments(_uiMapAssignmentByWmoDoodadPlacement[system], wmoDoodadPlacementId);
+
+    AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(areaId);
+    while (areaEntry)
+    {
+        iterateUiMapAssignments(_uiMapAssignmentByArea[system], areaEntry->ID);
+        areaEntry = sAreaTableStore.LookupEntry(areaEntry->ParentAreaID);
+    }
+
+    if (MapEntry const* mapEntry = sMapStore.LookupEntry(mapId))
+    {
+        iterateUiMapAssignments(_uiMapAssignmentByMap[system], mapEntry->ID);
+        if (mapEntry->ParentMapID >= 0)
+            iterateUiMapAssignments(_uiMapAssignmentByMap[system], mapEntry->ParentMapID);
+        if (mapEntry->CosmeticParentMapID >= 0)
+            iterateUiMapAssignments(_uiMapAssignmentByMap[system], mapEntry->CosmeticParentMapID);
+    }
+
+    return nearestMapAssignment.UiMapAssignment;
 }
 
-void DB2Manager::DeterminaAlternateMapPosition(uint32 mapId, float x, float y, float z, uint32* newMapId /*= nullptr*/, DBCPosition2D* newPos /*= nullptr*/)
+static DBCPosition2D CalculateGlobalUiMapPosition(int32 uiMapID, DBCPosition2D uiPosition)
 {
-    ASSERT(newMapId || newPos);
-    WorldMapTransformsEntry const* transformation = nullptr;
-    for (WorldMapTransformsEntry const* transform : sWorldMapTransformsStore)
+    UiMapEntry const* uiMap = sUiMapStore.LookupEntry(uiMapID);
+    while (uiMap)
     {
-        if (transform->MapID != mapId)
-            continue;
-        if (transform->AreaID)
-            continue;
-        if (transform->Flags & WORLD_MAP_TRANSFORMS_FLAG_DUNGEON)
-            continue;
-        if (transform->RegionMin.X > x || transform->RegionMax.X < x)
-            continue;
-        if (transform->RegionMin.Y > y || transform->RegionMax.Y < y)
-            continue;
-        if (transform->RegionMin.Z > z || transform->RegionMax.Z < z)
-            continue;
+        if (uiMap->Type <= UI_MAP_TYPE_CONTINENT)
+            break;
 
-        if (!transformation || transformation->Priority < transform->Priority)
-            transformation = transform;
+        UiMapBounds const* bounds = Trinity::Containers::MapGetValuePtr(_uiMapBounds, uiMap->ID);
+        if (!bounds || !bounds->IsUiAssignment)
+            break;
+
+        uiPosition.X = ((1.0 - uiPosition.X) * bounds->Bounds[1]) + (bounds->Bounds[3] * uiPosition.X);
+        uiPosition.Y = ((1.0 - uiPosition.Y) * bounds->Bounds[0]) + (bounds->Bounds[2] * uiPosition.Y);
+
+        uiMap = sUiMapStore.LookupEntry(uiMap->ParentUiMapID);
     }
 
-    if (!transformation)
-    {
-        if (newMapId)
-            *newMapId = mapId;
+    return uiPosition;
+}
 
-        if (newPos)
-        {
-            newPos->X = x;
-            newPos->Y = y;
-        }
-        return;
+bool DB2Manager::GetUiMapPosition(float x, float y, float z, int32 mapId, int32 areaId, int32 wmoDoodadPlacementId, int32 wmoGroupId, UiMapSystem system, bool local,
+    int32* uiMapId /*= nullptr*/, DBCPosition2D* newPos /*= nullptr*/)
+{
+    if (uiMapId)
+        *uiMapId = -1;
+
+    if (newPos)
+    {
+        newPos->X = 0.0f;
+        newPos->Y = 0.0f;
     }
 
-    if (newMapId)
-        *newMapId = transformation->NewMapID;
+    UiMapAssignmentEntry const* uiMapAssignment = FindNearestMapAssignment(x, y, z, mapId, areaId, wmoDoodadPlacementId, wmoGroupId, system);
+    if (!uiMapAssignment)
+        return false;
+
+    if (uiMapId)
+        *uiMapId = uiMapAssignment->UiMapID;
+
+    DBCPosition2D relativePosition{ 0.5f, 0.5f };
+    DBCPosition2D regionSize{ uiMapAssignment->Region[1].X - uiMapAssignment->Region[0].X, uiMapAssignment->Region[1].Y - uiMapAssignment->Region[0].Y };
+    if (regionSize.X > 0.0f)
+        relativePosition.X = (x - uiMapAssignment->Region[0].X) / regionSize.X;
+    if (regionSize.Y > 0.0f)
+        relativePosition.Y = (y - uiMapAssignment->Region[0].Y) / regionSize.Y;
+
+    DBCPosition2D uiPosition
+    {
+        // x any y are swapped
+        ((1.0f - (1.0f - relativePosition.Y)) * uiMapAssignment->UiMin.X) + ((1.0f - relativePosition.Y) * uiMapAssignment->UiMax.X),
+        ((1.0f - (1.0f - relativePosition.X)) * uiMapAssignment->UiMin.Y) + ((1.0f - relativePosition.X) * uiMapAssignment->UiMax.Y)
+    };
+
+    if (!local)
+        uiPosition = CalculateGlobalUiMapPosition(uiMapAssignment->UiMapID, uiPosition);
 
-    if (!newPos)
+    if (newPos)
+        *newPos = uiPosition;
+
+    return true;
+}
+
+void DB2Manager::Zone2MapCoordinates(uint32 areaId, float& x, float& y) const
+{
+    AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(areaId);
+    if (!areaEntry)
         return;
 
-    if (std::abs(transformation->RegionScale - 1.0f) > 0.001f)
+    int32 uiMapId = -1;
+    for (auto assignment : Trinity::Containers::MapEqualRange(_uiMapAssignmentByArea[UI_MAP_SYSTEM_WORLD], areaId))
     {
-        x = (x - transformation->RegionMin.X) * transformation->RegionScale + transformation->RegionMin.X;
-        y = (y - transformation->RegionMin.Y) * transformation->RegionScale + transformation->RegionMin.Y;
+        if (assignment.second->MapID >= 0 && assignment.second->MapID != areaEntry->ContinentID)
+            continue;
+
+        float tmpY = 1.0 - ((y - assignment.second->UiMin.Y) / (assignment.second->UiMax.Y - assignment.second->UiMin.Y));
+        float tmpX = 1.0 - ((x - assignment.second->UiMin.X) / (assignment.second->UiMax.X - assignment.second->UiMin.X));
+        y = ((1.0 - tmpY) * assignment.second->Region[0].X) + (tmpY * assignment.second->Region[1].X);
+        x = ((1.0 - tmpX) * assignment.second->Region[0].Y) + (tmpX * assignment.second->Region[1].Y);
+        break;
     }
+}
 
-    newPos->X = x + transformation->RegionOffset.X;
-    newPos->Y = y + transformation->RegionOffset.Y;
+void DB2Manager::Map2ZoneCoordinates(uint32 areaId, float& x, float& y) const
+{
+    DBCPosition2D zoneCoords;
+    if (!GetUiMapPosition(x, y, 0.0f, -1, areaId, 0, 0, UI_MAP_SYSTEM_WORLD, true, nullptr, &zoneCoords))
+        return;
+
+    x = zoneCoords.Y * 100.0f;
+    y = zoneCoords.X * 100.0f;
+}
+
+bool DB2Manager::IsUiMapPhase(uint32 phaseId) const
+{
+    return _uiMapPhases.find(phaseId) != _uiMapPhases.end();
+}
+
+WMOAreaTableEntry const* DB2Manager::GetWMOAreaTable(int32 rootId, int32 adtId, int32 groupId) const
+{
+    return Trinity::Containers::MapGetValuePtr(_wmoAreaTableLookup, WMOAreaTableKey(int16(rootId), int8(adtId), groupId));
 }
 
 bool ChrClassesXPowerTypesEntryComparator::Compare(ChrClassesXPowerTypesEntry const* left, ChrClassesXPowerTypesEntry const* right)
diff --git a/src/server/game/DataStores/DB2Stores.h b/src/server/game/DataStores/DB2Stores.h
index 2517433b58b..46a0dee2095 100644
--- a/src/server/game/DataStores/DB2Stores.h
+++ b/src/server/game/DataStores/DB2Stores.h
@@ -209,7 +209,6 @@ TC_GAME_API extern DB2Storage<UnitPowerBarEntry>                    sUnitPowerBa
 TC_GAME_API extern DB2Storage<VehicleEntry>                         sVehicleStore;
 TC_GAME_API extern DB2Storage<VehicleSeatEntry>                     sVehicleSeatStore;
 TC_GAME_API extern DB2Storage<WorldEffectEntry>                     sWorldEffectStore;
-TC_GAME_API extern DB2Storage<WorldMapAreaEntry>                    sWorldMapAreaStore;
 TC_GAME_API extern DB2Storage<WorldMapOverlayEntry>                 sWorldMapOverlayStore;
 TC_GAME_API extern DB2Storage<WorldSafeLocsEntry>                   sWorldSafeLocsStore;
 
@@ -331,11 +330,12 @@ public:
     bool IsToyItem(uint32 toy) const;
     std::vector<TransmogSetEntry const*> const* GetTransmogSetsForItemModifiedAppearance(uint32 itemModifiedAppearanceId) const;
     std::vector<TransmogSetItemEntry const*> const* GetTransmogSetItems(uint32 transmogSetId) const;
-    WMOAreaTableEntry const* GetWMOAreaTable(int32 rootId, int32 adtId, int32 groupId) const;
-    uint32 GetVirtualMapForMapAndZone(uint32 mapId, uint32 zoneId) const;
+    static bool GetUiMapPosition(float x, float y, float z, int32 mapId, int32 areaId, int32 wmoDoodadPlacementId, int32 wmoGroupId, UiMapSystem system, bool local,
+        int32* uiMapId = nullptr, DBCPosition2D* newPos = nullptr);
     void Zone2MapCoordinates(uint32 areaId, float& x, float& y) const;
     void Map2ZoneCoordinates(uint32 areaId, float& x, float& y) const;
-    static void DeterminaAlternateMapPosition(uint32 mapId, float x, float y, float z, uint32* newMapId = nullptr, DBCPosition2D* newPos = nullptr);
+    bool IsUiMapPhase(uint32 phaseId) const;
+    WMOAreaTableEntry const* GetWMOAreaTable(int32 rootId, int32 adtId, int32 groupId) const;
 
 private:
     friend class DB2HotfixGeneratorBase;
diff --git a/src/server/game/DataStores/DB2Structure.h b/src/server/game/DataStores/DB2Structure.h
index 7fca60b7fbc..f6e1c93f563 100644
--- a/src/server/game/DataStores/DB2Structure.h
+++ b/src/server/game/DataStores/DB2Structure.h
@@ -2992,6 +2992,55 @@ struct TransportRotationEntry
     int32 GameObjectsID;
 };
 
+struct UiMapEntry
+{
+    LocalizedString* Name;
+    uint32 ID;
+    int32 ParentUiMapID;
+    int32 Flags;
+    int32 System;
+    int32 Type;
+    uint32 LevelRangeMin;
+    uint32 LevelRangeMax;
+    int32 BountySetID;
+    uint32 BountyDisplayLocation;
+    int32 VisibilityPlayerConditionID;
+    int8 HelpTextPosition;
+    int32 BkgAtlasID;
+};
+
+struct UiMapAssignmentEntry
+{
+    DBCPosition2D UiMin;
+    DBCPosition2D UiMax;
+    DBCPosition3D Region[2];
+    uint32 ID;
+    int32 UiMapID;
+    int32 OrderIndex;
+    int32 MapID;
+    int32 AreaID;
+    int32 WmoDoodadPlacementID;
+    int32 WmoGroupID;
+};
+
+struct UiMapLinkEntry
+{
+    DBCPosition2D UiMin;
+    DBCPosition2D UiMax;
+    uint32 ID;
+    int32 ParentUiMapID;
+    int32 OrderIndex;
+    int32 ChildUiMapID;
+};
+
+struct UiMapXMapArtEntry
+{
+    uint32 ID;
+    int32 PhaseID;
+    int32 UiMapArtID;
+    int32 UiMapID;
+};
+
 struct UnitPowerBarEntry
 {
     uint32 ID;
diff --git a/src/server/game/DataStores/DBCEnums.h b/src/server/game/DataStores/DBCEnums.h
index dfcdc2756af..1eba72590f7 100644
--- a/src/server/game/DataStores/DBCEnums.h
+++ b/src/server/game/DataStores/DBCEnums.h
@@ -58,7 +58,7 @@ enum LevelLimit
 enum BattlegroundBracketId                                  // bracketId for level ranges
 {
     BG_BRACKET_ID_FIRST          = 0,
-    BG_BRACKET_ID_LAST           = 11,
+    BG_BRACKET_ID_LAST           = 12,
 
     // must be max value in PvPDificulty slot + 1
     MAX_BATTLEGROUND_BRACKETS
@@ -166,7 +166,7 @@ enum ArtifactPowerFlag : uint8
 
 #define MAX_ARTIFACT_TIER 1
 
-#define BATTLE_PET_SPECIES_MAX_ID 2164
+#define BATTLE_PET_SPECIES_MAX_ID 2480
 
 enum ChrSpecializationFlag
 {
@@ -608,6 +608,11 @@ enum Difficulty : uint8
     DIFFICULTY_WORLD_PVP_SCENARIO_2 = 32,
     DIFFICULTY_TIMEWALKING_RAID     = 33,
     DIFFICULTY_PVP                  = 34,
+    DIFFICULTY_NORMAL_ISLAND        = 38,
+    DIFFICULTY_HEROIC_ISLAND        = 39,
+    DIFFICULTY_MYTHIC_ISLAND        = 40,
+    DIFFICULTY_PVP_ISLAND           = 45,
+    DIFFICULTY_NORMAL_WARFRONT      = 147,
 
     MAX_DIFFICULTY
 };
@@ -993,7 +998,7 @@ enum SpellShapeshiftFormFlags
     SHAPESHIFT_FORM_PREVENT_EMOTE_SOUNDS        = 0x1000
 };
 
-#define TaxiMaskSize 258
+#define TaxiMaskSize 286
 typedef std::array<uint8, TaxiMaskSize> TaxiMask;
 
 enum TotemCategoryType
@@ -1080,6 +1085,25 @@ enum TaxiPathNodeFlags
     TAXI_PATH_NODE_FLAG_STOP        = 0x2
 };
 
+enum UiMapSystem : int8
+{
+    UI_MAP_SYSTEM_WORLD     = 0,
+    UI_MAP_SYSTEM_TAXI      = 1,
+    UI_MAP_SYSTEM_ADVENTURE = 2,
+    MAX_UI_MAP_SYSTEM       = 3
+};
+
+enum UiMapType : int8
+{
+    UI_MAP_TYPE_COSMIC      = 0,
+    UI_MAP_TYPE_WORLD       = 1,
+    UI_MAP_TYPE_CONTINENT   = 2,
+    UI_MAP_TYPE_ZONE        = 3,
+    UI_MAP_TYPE_DUNGEON     = 4,
+    UI_MAP_TYPE_MICRO       = 5,
+    UI_MAP_TYPE_ORPHAN      = 6,
+};
+
 enum VehicleSeatFlags
 {
     VEHICLE_SEAT_FLAG_HAS_LOWER_ANIM_FOR_ENTER                         = 0x00000001,
diff --git a/src/server/game/DataStores/GameTables.cpp b/src/server/game/DataStores/GameTables.cpp
index 0dd01aa3930..d6142ccf065 100644
--- a/src/server/game/DataStores/GameTables.cpp
+++ b/src/server/game/DataStores/GameTables.cpp
@@ -127,6 +127,7 @@ void LoadGameTables(std::string const& dataPath)
     LOAD_GT(sNpcDamageByClassGameTable[4], "NpcDamageByClassExp4.txt");
     LOAD_GT(sNpcDamageByClassGameTable[5], "NpcDamageByClassExp5.txt");
     LOAD_GT(sNpcDamageByClassGameTable[6], "NpcDamageByClassExp6.txt");
+    LOAD_GT(sNpcDamageByClassGameTable[7], "NpcDamageByClassExp7.txt");
     LOAD_GT(sNpcManaCostScalerGameTable, "NPCManaCostScaler.txt");
     LOAD_GT(sNpcTotalHpGameTable[0], "NpcTotalHp.txt");
     LOAD_GT(sNpcTotalHpGameTable[1], "NpcTotalHpExp1.txt");
@@ -135,6 +136,7 @@ void LoadGameTables(std::string const& dataPath)
     LOAD_GT(sNpcTotalHpGameTable[4], "NpcTotalHpExp4.txt");
     LOAD_GT(sNpcTotalHpGameTable[5], "NpcTotalHpExp5.txt");
     LOAD_GT(sNpcTotalHpGameTable[6], "NpcTotalHpExp6.txt");
+    LOAD_GT(sNpcTotalHpGameTable[7], "NpcTotalHpExp7.txt");
     LOAD_GT(sSpellScalingGameTable, "SpellScaling.txt");
     LOAD_GT(sXpGameTable, "xp.txt");
 
diff --git a/src/server/game/Entities/Taxi/TaxiPathGraph.cpp b/src/server/game/Entities/Taxi/TaxiPathGraph.cpp
index 3ec90f577a7..b60c1780fd3 100644
--- a/src/server/game/Entities/Taxi/TaxiPathGraph.cpp
+++ b/src/server/game/Entities/Taxi/TaxiPathGraph.cpp
@@ -76,6 +76,12 @@ std::size_t TaxiPathGraph::GetVertexCount()
     return std::max(boost::num_vertices(m_graph), m_vertices.size());
 }
 
+void GetTaxiMapPosition(DBCPosition3D const& position, int32 mapId, DBCPosition2D* uiMapPosition, int32* uiMapId)
+{
+    if (!DB2Manager::GetUiMapPosition(position.X, position.Y, position.Z, mapId, 0, 0, 0, UI_MAP_SYSTEM_ADVENTURE, false, uiMapId, uiMapPosition))
+        DB2Manager::GetUiMapPosition(position.X, position.Y, position.Z, mapId, 0, 0, 0, UI_MAP_SYSTEM_TAXI, false, uiMapId, uiMapPosition);
+}
+
 void TaxiPathGraph::AddVerticeAndEdgeFromNodeInfo(TaxiNodesEntry const* from, TaxiNodesEntry const* to, uint32 pathId, std::vector<std::pair<edge, EdgeCost>>& edges)
 {
     if (from != to)
@@ -104,22 +110,21 @@ void TaxiPathGraph::AddVerticeAndEdgeFromNodeInfo(TaxiNodesEntry const* from, Ta
             if (nodes[i - 1]->Flags & TAXI_PATH_NODE_FLAG_TELEPORT)
                 continue;
 
-            uint32 map1, map2;
+            int32 uiMap1, uiMap2;
             DBCPosition2D pos1, pos2;
 
-            DB2Manager::DeterminaAlternateMapPosition(nodes[i - 1]->ContinentID, nodes[i - 1]->Loc.X, nodes[i - 1]->Loc.Y, nodes[i - 1]->Loc.Z, &map1, &pos1);
-            DB2Manager::DeterminaAlternateMapPosition(nodes[i]->ContinentID, nodes[i]->Loc.X, nodes[i]->Loc.Y, nodes[i]->Loc.Z, &map2, &pos2);
+            GetTaxiMapPosition(nodes[i - 1]->Loc, nodes[i - 1]->ContinentID, &pos1, &uiMap1);
+            GetTaxiMapPosition(nodes[i]->Loc, nodes[i]->ContinentID, &pos2, &uiMap2);
 
-            if (map1 != map2)
+            if (uiMap1 != uiMap2)
                 continue;
 
             totalDist += std::sqrt(
                 std::pow(pos2.X - pos1.X, 2) +
-                std::pow(pos2.Y - pos1.Y, 2) +
-                std::pow(nodes[i]->Loc.Z - nodes[i - 1]->Loc.Z, 2));
+                std::pow(pos2.Y - pos1.Y, 2));
         }
 
-        uint32 dist = uint32(totalDist);
+        uint32 dist = uint32(totalDist * 32767.0f);
         if (dist > 0xFFFF)
             dist = 0xFFFF;
 
diff --git a/src/server/game/Globals/ObjectMgr.cpp b/src/server/game/Globals/ObjectMgr.cpp
index 746782fa1ec..53dbcb38f33 100644
--- a/src/server/game/Globals/ObjectMgr.cpp
+++ b/src/server/game/Globals/ObjectMgr.cpp
@@ -9581,7 +9581,7 @@ void ObjectMgr::LoadTerrainWorldMaps()
     uint32 oldMSTime = getMSTime();
 
     //                                               0               1
-    QueryResult result = WorldDatabase.Query("SELECT TerrainSwapMap, WorldMapArea FROM `terrain_worldmap`");
+    QueryResult result = WorldDatabase.Query("SELECT TerrainSwapMap, UiMapPhaseId FROM `terrain_worldmap`");
 
     if (!result)
     {
@@ -9595,7 +9595,7 @@ void ObjectMgr::LoadTerrainWorldMaps()
         Field* fields = result->Fetch();
 
         uint32 mapId = fields[0].GetUInt32();
-        uint32 worldMapArea = fields[1].GetUInt32();
+        uint32 uiMapPhaseId = fields[1].GetUInt32();
 
         if (!sMapStore.LookupEntry(mapId))
         {
@@ -9603,15 +9603,15 @@ void ObjectMgr::LoadTerrainWorldMaps()
             continue;
         }
 
-        if (!sWorldMapAreaStore.LookupEntry(worldMapArea))
+        if (!sDB2Manager.IsUiMapPhase(uiMapPhaseId))
         {
-            TC_LOG_ERROR("sql.sql", "WorldMapArea %u defined in `terrain_worldmap` does not exist, skipped.", worldMapArea);
+            TC_LOG_ERROR("sql.sql", "Phase %u defined in `terrain_worldmap` is not a valid terrain swap phase, skipped.", uiMapPhaseId);
             continue;
         }
 
         TerrainSwapInfo* terrainSwapInfo = &_terrainSwapInfoById[mapId];
         terrainSwapInfo->Id = mapId;
-        terrainSwapInfo->UiWorldMapAreaIDSwaps.push_back(worldMapArea);
+        terrainSwapInfo->UiMapPhaseIDs.push_back(uiMapPhaseId);
 
         ++count;
     } while (result->NextRow());
@@ -9758,11 +9758,6 @@ TerrainSwapInfo const* ObjectMgr::GetTerrainSwapInfo(uint32 terrainSwapId) const
     return Trinity::Containers::MapGetValuePtr(_terrainSwapInfoById, terrainSwapId);
 }
 
-std::vector<TerrainSwapInfo*> const* ObjectMgr::GetTerrainSwapsForMap(uint32 mapId) const
-{
-    return Trinity::Containers::MapGetValuePtr(_terrainSwapInfoByMap, mapId);
-}
-
 GameObjectTemplate const* ObjectMgr::GetGameObjectTemplate(uint32 entry) const
 {
     GameObjectTemplateContainer::const_iterator itr = _gameObjectTemplateStore.find(entry);
diff --git a/src/server/game/Globals/ObjectMgr.h b/src/server/game/Globals/ObjectMgr.h
index d8a667210c1..51cbe07bcee 100644
--- a/src/server/game/Globals/ObjectMgr.h
+++ b/src/server/game/Globals/ObjectMgr.h
@@ -885,7 +885,7 @@ typedef std::unordered_map<uint64, DungeonEncounterList> DungeonEncounterContain
 struct TerrainSwapInfo
 {
     uint32 Id;
-    std::vector<uint32> UiWorldMapAreaIDSwaps;
+    std::vector<uint32> UiMapPhaseIDs;
 };
 
 struct PhaseInfoStruct
@@ -1666,7 +1666,7 @@ class TC_GAME_API ObjectMgr
         PhaseInfoStruct const* GetPhaseInfo(uint32 phaseId) const;
         std::vector<PhaseAreaInfo> const* GetPhasesForArea(uint32 areaId) const;
         TerrainSwapInfo const* GetTerrainSwapInfo(uint32 terrainSwapId) const;
-        std::vector<TerrainSwapInfo*> const* GetTerrainSwapsForMap(uint32 mapId) const;
+        std::unordered_map<uint32, std::vector<TerrainSwapInfo*>> const& GetTerrainSwaps() const { return _terrainSwapInfoByMap; }
 
     private:
         std::unordered_map<uint32, PhaseInfoStruct> _phaseInfoById;
diff --git a/src/server/game/Phasing/PhaseShift.cpp b/src/server/game/Phasing/PhaseShift.cpp
index b2885ae15bb..b7df2e5cd13 100644
--- a/src/server/game/Phasing/PhaseShift.cpp
+++ b/src/server/game/Phasing/PhaseShift.cpp
@@ -60,23 +60,23 @@ PhaseShift::EraseResult<PhaseShift::VisibleMapIdContainer> PhaseShift::RemoveVis
     return { VisibleMapIds.end(), false };
 }
 
-bool PhaseShift::AddUiWorldMapAreaIdSwap(uint32 uiWorldMapAreaId, int32 references /*= 1*/)
+bool PhaseShift::AddUiMapPhaseId(uint32 uiMapPhaseId, int32 references /*= 1*/)
 {
-    auto insertResult = UiWorldMapAreaIdSwaps.emplace(uiWorldMapAreaId, UiWorldMapAreaIdSwapRef{ 0 });
+    auto insertResult = UiMapPhaseIds.emplace(uiMapPhaseId, UiMapPhaseIdRef{ 0 });
     insertResult.first->second.References += references;
     return insertResult.second;
 }
 
-PhaseShift::EraseResult<PhaseShift::UiWorldMapAreaIdSwapContainer> PhaseShift::RemoveUiWorldMapAreaIdSwap(uint32 uiWorldMapAreaId)
+PhaseShift::EraseResult<PhaseShift::UiMapPhaseIdContainer> PhaseShift::RemoveUiMapPhaseId(uint32 uiMapPhaseId)
 {
-    auto itr = UiWorldMapAreaIdSwaps.find(uiWorldMapAreaId);
-    if (itr != UiWorldMapAreaIdSwaps.end())
+    auto itr = UiMapPhaseIds.find(uiMapPhaseId);
+    if (itr != UiMapPhaseIds.end())
     {
         if (!--itr->second.References)
-            return { UiWorldMapAreaIdSwaps.erase(itr), true };
+            return { UiMapPhaseIds.erase(itr), true };
         return { itr, false };
     }
-    return { UiWorldMapAreaIdSwaps.end(), false };
+    return { UiMapPhaseIds.end(), false };
 }
 
 void PhaseShift::Clear()
@@ -84,7 +84,7 @@ void PhaseShift::Clear()
     ClearPhases();
     PersonalGuid.Clear();
     VisibleMapIds.clear();
-    UiWorldMapAreaIdSwaps.clear();
+    UiMapPhaseIds.clear();
 }
 
 void PhaseShift::ClearPhases()
diff --git a/src/server/game/Phasing/PhaseShift.h b/src/server/game/Phasing/PhaseShift.h
index f1929168613..c15bf4100a2 100644
--- a/src/server/game/Phasing/PhaseShift.h
+++ b/src/server/game/Phasing/PhaseShift.h
@@ -68,7 +68,7 @@ public:
         int32 References = 0;
         TerrainSwapInfo const* VisibleMapInfo = nullptr;
     };
-    struct UiWorldMapAreaIdSwapRef
+    struct UiMapPhaseIdRef
     {
         int32 References = 0;
     };
@@ -80,7 +80,7 @@ public:
     };
     typedef boost::container::flat_set<PhaseRef> PhaseContainer;
     typedef std::map<uint32, VisibleMapIdRef> VisibleMapIdContainer;
-    typedef std::map<uint32, UiWorldMapAreaIdSwapRef> UiWorldMapAreaIdSwapContainer;
+    typedef std::map<uint32, UiMapPhaseIdRef> UiMapPhaseIdContainer;
 
     PhaseShift() : Flags(PhaseShiftFlags::Unphased), NonCosmeticReferences(0), CosmeticReferences(0), DefaultReferences(0), IsDbPhaseShift(false) { }
 
@@ -94,10 +94,10 @@ public:
     bool HasVisibleMapId(uint32 visibleMapId) const { return VisibleMapIds.find(visibleMapId) != VisibleMapIds.end(); }
     VisibleMapIdContainer const& GetVisibleMapIds() const { return VisibleMapIds; }
 
-    bool AddUiWorldMapAreaIdSwap(uint32 uiWorldMapAreaId, int32 references = 1);
-    EraseResult<UiWorldMapAreaIdSwapContainer> RemoveUiWorldMapAreaIdSwap(uint32 uiWorldMapAreaId);
-    bool HasUiWorldMapAreaIdSwap(uint32 uiWorldMapAreaId) const { return UiWorldMapAreaIdSwaps.find(uiWorldMapAreaId) != UiWorldMapAreaIdSwaps.end(); }
-    UiWorldMapAreaIdSwapContainer const& GetUiWorldMapAreaIdSwaps() const { return UiWorldMapAreaIdSwaps; }
+    bool AddUiMapPhaseId(uint32 uiMapPhaseId, int32 references = 1);
+    EraseResult<UiMapPhaseIdContainer> RemoveUiMapPhaseId(uint32 uiMapPhaseId);
+    bool HasUiMapPhaseId(uint32 uiMapPhaseId) const { return UiMapPhaseIds.find(uiMapPhaseId) != UiMapPhaseIds.end(); }
+    UiMapPhaseIdContainer const& GetUiWorldMapAreaIdSwaps() const { return UiMapPhaseIds; }
 
     void Clear();
     void ClearPhases();
@@ -111,7 +111,7 @@ protected:
     ObjectGuid PersonalGuid;
     PhaseContainer Phases;
     VisibleMapIdContainer VisibleMapIds;
-    UiWorldMapAreaIdSwapContainer UiWorldMapAreaIdSwaps;
+    UiMapPhaseIdContainer UiMapPhaseIds;
 
     void ModifyPhasesReferences(PhaseContainer::iterator itr, int32 references);
     void UpdateUnphasedFlag();
diff --git a/src/server/game/Phasing/PhasingHandler.cpp b/src/server/game/Phasing/PhasingHandler.cpp
index e60c87b4816..1cce3361654 100644
--- a/src/server/game/Phasing/PhasingHandler.cpp
+++ b/src/server/game/Phasing/PhasingHandler.cpp
@@ -146,8 +146,8 @@ void PhasingHandler::AddVisibleMapId(WorldObject* object, uint32 visibleMapId)
     TerrainSwapInfo const* terrainSwapInfo = sObjectMgr->GetTerrainSwapInfo(visibleMapId);
     bool changed = object->GetPhaseShift().AddVisibleMapId(visibleMapId, terrainSwapInfo);
 
-    for (uint32 uiWorldMapAreaIDSwap : terrainSwapInfo->UiWorldMapAreaIDSwaps)
-        changed = object->GetPhaseShift().AddUiWorldMapAreaIdSwap(uiWorldMapAreaIDSwap) || changed;
+    for (uint32 uiMapPhaseId : terrainSwapInfo->UiMapPhaseIDs)
+        changed = object->GetPhaseShift().AddUiMapPhaseId(uiMapPhaseId) || changed;
 
     if (Unit* unit = object->ToUnit())
     {
@@ -165,8 +165,8 @@ void PhasingHandler::RemoveVisibleMapId(WorldObject* object, uint32 visibleMapId
     TerrainSwapInfo const* terrainSwapInfo = sObjectMgr->GetTerrainSwapInfo(visibleMapId);
     bool changed = object->GetPhaseShift().RemoveVisibleMapId(visibleMapId).Erased;
 
-    for (uint32 uiWorldMapAreaIDSwap : terrainSwapInfo->UiWorldMapAreaIDSwaps)
-        changed = object->GetPhaseShift().RemoveUiWorldMapAreaIdSwap(uiWorldMapAreaIDSwap).Erased || changed;
+    for (uint32 uiWorldMapAreaIDSwap : terrainSwapInfo->UiMapPhaseIDs)
+        changed = object->GetPhaseShift().RemoveUiMapPhaseId(uiWorldMapAreaIDSwap).Erased || changed;
 
     if (Unit* unit = object->ToUnit())
     {
@@ -198,18 +198,21 @@ void PhasingHandler::OnMapChange(WorldObject* object)
     ConditionSourceInfo srcInfo = ConditionSourceInfo(object);
 
     object->GetPhaseShift().VisibleMapIds.clear();
-    object->GetPhaseShift().UiWorldMapAreaIdSwaps.clear();
+    object->GetPhaseShift().UiMapPhaseIds.clear();
     object->GetSuppressedPhaseShift().VisibleMapIds.clear();
 
-    if (std::vector<TerrainSwapInfo*> const* visibleMapIds = sObjectMgr->GetTerrainSwapsForMap(object->GetMapId()))
+    for (auto visibleMapPair : sObjectMgr->GetTerrainSwaps())
     {
-        for (TerrainSwapInfo const* visibleMapInfo : *visibleMapIds)
+        for (TerrainSwapInfo const* visibleMapInfo : visibleMapPair.second)
         {
             if (sConditionMgr->IsObjectMeetingNotGroupedConditions(CONDITION_SOURCE_TYPE_TERRAIN_SWAP, visibleMapInfo->Id, srcInfo))
             {
-                phaseShift.AddVisibleMapId(visibleMapInfo->Id, visibleMapInfo);
-                for (uint32 uiWorldMapAreaIdSwap : visibleMapInfo->UiWorldMapAreaIDSwaps)
-                    phaseShift.AddUiWorldMapAreaIdSwap(uiWorldMapAreaIdSwap);
+                if (visibleMapPair.first == object->GetMapId())
+                    phaseShift.AddVisibleMapId(visibleMapInfo->Id, visibleMapInfo);
+
+                // ui map is visible on all maps
+                for (uint32 uiMapPhaseId : visibleMapInfo->UiMapPhaseIDs)
+                    phaseShift.AddUiMapPhaseId(uiMapPhaseId);
             }
             else
                 suppressedPhaseShift.AddVisibleMapId(visibleMapInfo->Id, visibleMapInfo);
@@ -317,8 +320,8 @@ void PhasingHandler::OnConditionChange(WorldObject* object)
         if (!sConditionMgr->IsObjectMeetingNotGroupedConditions(CONDITION_SOURCE_TYPE_TERRAIN_SWAP, itr->first, srcInfo))
         {
             newSuppressions.AddVisibleMapId(itr->first, itr->second.VisibleMapInfo, itr->second.References);
-            for (uint32 uiWorldMapAreaIdSwap : itr->second.VisibleMapInfo->UiWorldMapAreaIDSwaps)
-                changed = phaseShift.RemoveUiWorldMapAreaIdSwap(uiWorldMapAreaIdSwap).Erased || changed;
+            for (uint32 uiMapPhaseId : itr->second.VisibleMapInfo->UiMapPhaseIDs)
+                changed = phaseShift.RemoveUiMapPhaseId(uiMapPhaseId).Erased || changed;
 
             itr = phaseShift.VisibleMapIds.erase(itr);
         }
@@ -331,8 +334,8 @@ void PhasingHandler::OnConditionChange(WorldObject* object)
         if (sConditionMgr->IsObjectMeetingNotGroupedConditions(CONDITION_SOURCE_TYPE_TERRAIN_SWAP, itr->first, srcInfo))
         {
             changed = phaseShift.AddVisibleMapId(itr->first, itr->second.VisibleMapInfo, itr->second.References) || changed;
-            for (uint32 uiWorldMapAreaIdSwap : itr->second.VisibleMapInfo->UiWorldMapAreaIDSwaps)
-                changed = phaseShift.AddUiWorldMapAreaIdSwap(uiWorldMapAreaIdSwap) || changed;
+            for (uint32 uiMapPhaseId : itr->second.VisibleMapInfo->UiMapPhaseIDs)
+                changed = phaseShift.AddUiMapPhaseId(uiMapPhaseId) || changed;
 
             itr = suppressedPhaseShift.VisibleMapIds.erase(itr);
         }
@@ -403,9 +406,9 @@ void PhasingHandler::SendToPlayer(Player const* player, PhaseShift const& phaseS
     phaseShiftChange.VisibleMapIDs.reserve(phaseShift.VisibleMapIds.size());
     std::transform(phaseShift.VisibleMapIds.begin(), phaseShift.VisibleMapIds.end(), std::back_inserter(phaseShiftChange.VisibleMapIDs),
         [](PhaseShift::VisibleMapIdContainer::value_type const& visibleMapId) { return visibleMapId.first; });
-    phaseShiftChange.UiWorldMapAreaIDSwaps.reserve(phaseShift.UiWorldMapAreaIdSwaps.size());
-    std::transform(phaseShift.UiWorldMapAreaIdSwaps.begin(), phaseShift.UiWorldMapAreaIdSwaps.end(), std::back_inserter(phaseShiftChange.UiWorldMapAreaIDSwaps),
-        [](PhaseShift::UiWorldMapAreaIdSwapContainer::value_type const& uiWorldMapAreaIdSwap) { return uiWorldMapAreaIdSwap.first; });
+    phaseShiftChange.UiMapPhaseIDs.reserve(phaseShift.UiMapPhaseIds.size());
+    std::transform(phaseShift.UiMapPhaseIds.begin(), phaseShift.UiMapPhaseIds.end(), std::back_inserter(phaseShiftChange.UiMapPhaseIDs),
+        [](PhaseShift::UiMapPhaseIdContainer::value_type const& uiWorldMapAreaIdSwap) { return uiWorldMapAreaIdSwap.first; });
 
     player->SendDirectMessage(phaseShiftChange.Write());
 }
@@ -545,10 +548,10 @@ void PhasingHandler::PrintToChat(ChatHandler* chat, PhaseShift const& phaseShift
         chat->PSendSysMessage(LANG_PHASESHIFT_VISIBLE_MAP_IDS, visibleMapIds.str().c_str());
     }
 
-    if (!phaseShift.UiWorldMapAreaIdSwaps.empty())
+    if (!phaseShift.UiMapPhaseIds.empty())
     {
         std::ostringstream uiWorldMapAreaIdSwaps;
-        for (PhaseShift::UiWorldMapAreaIdSwapContainer::value_type const& uiWorldMapAreaIdSwap : phaseShift.UiWorldMapAreaIdSwaps)
+        for (PhaseShift::UiMapPhaseIdContainer::value_type const& uiWorldMapAreaIdSwap : phaseShift.UiMapPhaseIds)
             uiWorldMapAreaIdSwaps << uiWorldMapAreaIdSwap.first << ',' << ' ';
 
         chat->PSendSysMessage(LANG_PHASESHIFT_UI_WORLD_MAP_AREA_SWAPS, uiWorldMapAreaIdSwaps.str().c_str());
diff --git a/src/server/game/Server/Packets/MiscPackets.cpp b/src/server/game/Server/Packets/MiscPackets.cpp
index a03f1ff35fc..4399b0d3924 100644
--- a/src/server/game/Server/Packets/MiscPackets.cpp
+++ b/src/server/game/Server/Packets/MiscPackets.cpp
@@ -404,11 +404,11 @@ WorldPacket const* WorldPackets::Misc::PhaseShiftChange::Write()
 
     _worldPacket << uint32(PreloadMapIDs.size() * 2);           // size in bytes
     for (uint16 preloadMapId : PreloadMapIDs)
-        _worldPacket << uint16(preloadMapId);                            // Inactive terrain swap map id
+        _worldPacket << uint16(preloadMapId);                   // Inactive terrain swap map id
 
-    _worldPacket << uint32(UiWorldMapAreaIDSwaps.size() * 2);   // size in bytes
-    for (uint16 uiWorldMapAreaIDSwap : UiWorldMapAreaIDSwaps)
-        _worldPacket << uint16(uiWorldMapAreaIDSwap);          // UI map id, WorldMapArea.db2, controls map display
+    _worldPacket << uint32(UiMapPhaseIDs.size() * 2);           // size in bytes
+    for (uint16 uiMapPhaseId : UiMapPhaseIDs)
+        _worldPacket << uint16(uiMapPhaseId);                   // phase id, controls only map display (visible on all maps)
 
     return &_worldPacket;
 }
diff --git a/src/server/game/Server/Packets/MiscPackets.h b/src/server/game/Server/Packets/MiscPackets.h
index 26affbaf934..d6ab86d5e2f 100644
--- a/src/server/game/Server/Packets/MiscPackets.h
+++ b/src/server/game/Server/Packets/MiscPackets.h
@@ -551,7 +551,7 @@ namespace WorldPackets
             ObjectGuid Client;
             PhaseShiftData Phaseshift;
             std::vector<uint16> PreloadMapIDs;
-            std::vector<uint16> UiWorldMapAreaIDSwaps;
+            std::vector<uint16> UiMapPhaseIDs;
             std::vector<uint16> VisibleMapIDs;
         };
 
diff --git a/src/server/game/Spells/SpellInfo.cpp b/src/server/game/Spells/SpellInfo.cpp
index 4a8695a60f5..1c935e62bd5 100644
--- a/src/server/game/Spells/SpellInfo.cpp
+++ b/src/server/game/Spells/SpellInfo.cpp
@@ -1879,10 +1879,31 @@ SpellCastResult SpellInfo::CheckLocation(uint32 map_id, uint32 zone_id, uint32 a
     // continent limitation (virtual continent)
     if (HasAttribute(SPELL_ATTR4_CAST_ONLY_IN_OUTLAND))
     {
-        uint32 v_map = sDB2Manager.GetVirtualMapForMapAndZone(map_id, zone_id);
-        MapEntry const* mapEntry = sMapStore.LookupEntry(v_map);
-        if (!mapEntry || mapEntry->ExpansionID < 1 || !mapEntry->IsContinent())
+        uint32 mountFlags = 0;
+        if (player && player->HasAuraType(SPELL_AURA_MOUNT_RESTRICTIONS))
+        {
+            for (AuraEffect const* auraEffect : player->GetAuraEffectsByType(SPELL_AURA_MOUNT_RESTRICTIONS))
+                mountFlags |= auraEffect->GetMiscValue();
+        }
+        else if (AreaTableEntry const* areaTable = sAreaTableStore.LookupEntry(area_id))
+            mountFlags = areaTable->MountFlags;
+
+        if (!(mountFlags & AREA_MOUNT_FLAG_FLYING_ALLOWED))
             return SPELL_FAILED_INCORRECT_AREA;
+
+        if (player)
+        {
+            uint32 mapToCheck = map_id;
+            if (MapEntry const* mapEntry = sMapStore.LookupEntry(map_id))
+                mapToCheck = mapEntry->CosmeticParentMapID;
+
+            if ((mapToCheck == 1116 || mapToCheck == 1464) && !player->HasSpell(191645)) // Draenor Pathfinder
+                return SPELL_FAILED_INCORRECT_AREA;
+            else if (mapToCheck == 1220 && !player->HasSpell(233368)) // Broken Isles Pathfinder
+                return SPELL_FAILED_INCORRECT_AREA;
+            else if ((mapToCheck == 1642 || mapToCheck == 1643) && !player->HasSpell(278833)) // Battle for Azeroth Pathfinder
+                return SPELL_FAILED_INCORRECT_AREA;
+        }
     }
 
     // raid instance limitation