Core: Updated to 10.2.5

6 files changed, 377 insertions, 310 deletions

diff --git a/src/server/game/Entities/Creature/Creature.cpp b/src/server/game/Entities/Creature/Creature.cpp
index 6905966e567..a8077ffae0b 100644
--- a/src/server/game/Entities/Creature/Creature.cpp
+++ b/src/server/game/Entities/Creature/Creature.cpp
@@ -222,7 +222,10 @@ WorldPacket CreatureTemplate::BuildQueryData(LocaleConstant loc, Difficulty diff
     stats.CursorName = IconName;
 
     if (std::vector<uint32> const* items = sObjectMgr->GetCreatureQuestItemList(Entry, difficulty))
-        stats.QuestItems.insert(stats.QuestItems.begin(), items->begin(), items->end());
+        stats.QuestItems.assign(items->begin(), items->end());
+
+    if (std::vector<int32> const* currencies = sObjectMgr->GetCreatureQuestCurrencyList(Entry))
+        stats.QuestCurrencies.assign(currencies->begin(), currencies->end());
 
     if (loc != LOCALE_enUS)
         if (CreatureLocale const* creatureLocale = sObjectMgr->GetCreatureLocale(Entry))
diff --git a/src/server/game/Entities/Object/Updates/UpdateField.h b/src/server/game/Entities/Object/Updates/UpdateField.h
index 74b0176851c..fdad7e0d18e 100644
--- a/src/server/game/Entities/Object/Updates/UpdateField.h
+++ b/src/server/game/Entities/Object/Updates/UpdateField.h
@@ -214,11 +214,11 @@ namespace UF
             _updateMask[block] |= UpdateMaskHelpers::GetBlockFlag(index);
         }
 
-        void MarkNewValue(T&, std::false_type)
+        static void MarkNewValue(T&, std::false_type)
         {
         }
 
-        void MarkNewValue(T& value, std::true_type)
+        static void MarkNewValue(T& value, std::true_type)
         {
             value._changesMask.SetAll();
         }
@@ -278,7 +278,11 @@ namespace UF
             ModifyValue(UpdateFieldArray<V, Size, Bit, FirstElementBit>(T::* field), uint32 index)
         {
             _value._changesMask.Set(Bit);
-            _value._changesMask.Set(FirstElementBit + index);
+            if constexpr (!std::is_base_of_v<IsUpdateFieldHolderTag, V>)
+                _value._changesMask.Set(FirstElementBit + index);
+            else
+                _value._changesMask.Set(FirstElementBit);
+
             return { (_value.*field)._values[index] };
         }
 
@@ -536,7 +540,10 @@ namespace UF
             static_assert(std::is_base_of_v<Base, Derived>, "Given field argument must belong to the same structure as this HasChangesMask");
 
             _changesMask.Set(Bit);
-            _changesMask.Set(FirstElementBit + index);
+            if constexpr (!std::is_base_of_v<IsUpdateFieldHolderTag, T>)
+                _changesMask.Set(FirstElementBit + index);
+            else
+                _changesMask.Set(FirstElementBit);
         }
 
         template<typename Derived, typename T, int32 BlockBit, uint32 Bit>
@@ -574,7 +581,10 @@ namespace UF
         {
             static_assert(std::is_base_of_v<Base, Derived>, "Given field argument must belong to the same structure as this HasChangesMask");
 
-            _changesMask.Reset(FirstElementBit + index);
+            if constexpr (!std::is_base_of_v<IsUpdateFieldHolderTag, T>)
+                _changesMask.Reset(FirstElementBit + index);
+            else
+                _changesMask.Reset(FirstElementBit);
         }
 
         template<typename Derived, typename T, int32 BlockBit, uint32 Bit>
@@ -596,64 +606,64 @@ namespace UF
 
     protected:
         template<typename T, int32 BlockBit, uint32 Bit>
-        void ClearChangesMask(UpdateField<T, BlockBit, Bit>& field)
+        static void ClearChangesMask(UpdateField<T, BlockBit, Bit>& field)
         {
             ClearChangesMask(field, std::is_base_of<HasChangesMaskTag, T>{});
         }
 
         template<typename T, int32 BlockBit, uint32 Bit>
-        void ClearChangesMask(UpdateField<T, BlockBit, Bit>&, std::false_type) { }
+        static void ClearChangesMask(UpdateField<T, BlockBit, Bit>&, std::false_type) { }
 
         template<typename T, int32 BlockBit, uint32 Bit>
-        void ClearChangesMask(UpdateField<T, BlockBit, Bit>& field, std::true_type)
+        static void ClearChangesMask(UpdateField<T, BlockBit, Bit>& field, std::true_type)
         {
             field._value.ClearChangesMask();
         }
 
         template<typename T, std::size_t Size, uint32 Bit, uint32 FirstElementBit>
-        void ClearChangesMask(UpdateFieldArray<T, Size, Bit, FirstElementBit>& field)
+        static void ClearChangesMask(UpdateFieldArray<T, Size, Bit, FirstElementBit>& field)
         {
-            ClearChangesMask(field, std::is_base_of<HasChangesMaskTag, T>{});
+            ClearChangesMask(field, std::disjunction<std::is_base_of<HasChangesMaskTag, T>, std::is_base_of<IsUpdateFieldHolderTag, T>>{});
         }
 
         template<typename T, std::size_t Size, uint32 Bit, uint32 FirstElementBit>
-        void ClearChangesMask(UpdateFieldArray<T, Size, Bit, FirstElementBit>&, std::false_type) { }
+        static void ClearChangesMask(UpdateFieldArray<T, Size, Bit, FirstElementBit>&, std::false_type) { }
 
         template<typename T, std::size_t Size, uint32 Bit, uint32 FirstElementBit>
-        void ClearChangesMask(UpdateFieldArray<T, Size, Bit, FirstElementBit>& field, std::true_type)
+        static void ClearChangesMask(UpdateFieldArray<T, Size, Bit, FirstElementBit>& field, std::true_type)
         {
             for (uint32 i = 0; i < Size; ++i)
                 field._values[i].ClearChangesMask();
         }
 
         template<typename T, int32 BlockBit, uint32 Bit>
-        void ClearChangesMask(DynamicUpdateField<T, BlockBit, Bit>& field)
+        static void ClearChangesMask(DynamicUpdateField<T, BlockBit, Bit>& field)
         {
             ClearChangesMask(field, std::is_base_of<HasChangesMaskTag, T>{});
             field.ClearChangesMask();
         }
 
         template<typename T, int32 BlockBit, uint32 Bit>
-        void ClearChangesMask(DynamicUpdateField<T, BlockBit, Bit>&, std::false_type) { }
+        static void ClearChangesMask(DynamicUpdateField<T, BlockBit, Bit>&, std::false_type) { }
 
         template<typename T, int32 BlockBit, uint32 Bit>
-        void ClearChangesMask(DynamicUpdateField<T, BlockBit, Bit>& field, std::true_type)
+        static void ClearChangesMask(DynamicUpdateField<T, BlockBit, Bit>& field, std::true_type)
         {
             for (uint32 i = 0; i < field._values.size(); ++i)
                 field._values[i].ClearChangesMask();
         }
 
         template<typename T, int32 BlockBit, uint32 Bit>
-        void ClearChangesMask(OptionalUpdateField<T, BlockBit, Bit>& field)
+        static void ClearChangesMask(OptionalUpdateField<T, BlockBit, Bit>& field)
         {
             ClearChangesMask(field, std::is_base_of<HasChangesMaskTag, T>{});
         }
 
         template<typename T, int32 BlockBit, uint32 Bit>
-        void ClearChangesMask(OptionalUpdateField<T, BlockBit, Bit>&, std::false_type) { }
+        static void ClearChangesMask(OptionalUpdateField<T, BlockBit, Bit>&, std::false_type) { }
 
         template<typename T, int32 BlockBit, uint32 Bit>
-        void ClearChangesMask(OptionalUpdateField<T, BlockBit, Bit>& field, std::true_type)
+        static void ClearChangesMask(OptionalUpdateField<T, BlockBit, Bit>& field, std::true_type)
         {
             if (field.has_value())
                 field._value->ClearChangesMask();
diff --git a/src/server/game/Entities/Object/Updates/UpdateFields.cpp b/src/server/game/Entities/Object/Updates/UpdateFields.cpp
index 2a4402603e9..6f02ac0e838 100644
--- a/src/server/game/Entities/Object/Updates/UpdateFields.cpp
+++ b/src/server/game/Entities/Object/Updates/UpdateFields.cpp
@@ -4104,9 +4104,13 @@ void ActivePlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> f
     data << float(VersatilityBonus);
     data << float(PvpPowerDamage);
     data << float(PvpPowerHealing);
-    for (uint32 i = 0; i < 240; ++i)
+    for (uint32 i = 0; i < 8; ++i)
     {
-        data << uint64(ExploredZones[i]);
+        data << uint32(DataFlags[i].size());
+        for (uint32 j = 0; j < DataFlags[i].size(); ++j)
+        {
+            data << uint64(DataFlags[i][j]);
+        }
     }
     for (uint32 i = 0; i < 2; ++i)
     {
@@ -4185,7 +4189,7 @@ void ActivePlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> f
     {
         data << uint32(BankBagSlotFlags[i]);
     }
-    for (uint32 i = 0; i < 875; ++i)
+    for (uint32 i = 0; i < 950; ++i)
     {
         data << uint64(QuestCompleted[i]);
     }
@@ -4399,8 +4403,8 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
 {
     for (uint32 i = 0; i < 1; ++i)
         data << uint32(changesMask.GetBlocksMask(i));
-    data.WriteBits(changesMask.GetBlocksMask(1), 19);
-    for (uint32 i = 0; i < 51; ++i)
+    data.WriteBits(changesMask.GetBlocksMask(1), 14);
+    for (uint32 i = 0; i < 46; ++i)
         if (changesMask.GetBlock(i))
             data.WriteBits(changesMask.GetBlock(i), 32);
 
@@ -4437,6 +4441,38 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
             else
                 WriteCompleteDynamicFieldUpdateMask(KnownTitles.size(), data);
         }
+    }
+    if (changesMask[36])
+    {
+        for (uint32 i = 0; i < 8; ++i)
+        {
+            if (changesMask[37])
+            {
+                if (!ignoreNestedChangesMask)
+                    DataFlags[i].WriteUpdateMask(data);
+                else
+                    WriteCompleteDynamicFieldUpdateMask(DataFlags[i].size(), data);
+            }
+        }
+    }
+    if (changesMask[36])
+    {
+        for (uint32 i = 0; i < 8; ++i)
+        {
+            if (changesMask[37])
+            {
+                for (uint32 j = 0; j < DataFlags[i].size(); ++j)
+                {
+                    if (DataFlags[i].HasChanged(j) || ignoreNestedChangesMask)
+                    {
+                        data << uint64(DataFlags[i][j]);
+                    }
+                }
+            }
+        }
+    }
+    if (changesMask[0])
+    {
         if (changesMask[8])
         {
             if (!ignoreNestedChangesMask)
@@ -4445,11 +4481,11 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 WriteCompleteDynamicFieldUpdateMask(PvpInfo.size(), data);
         }
     }
-    if (changesMask[36])
+    if (changesMask[38])
     {
         for (uint32 i = 0; i < 1; ++i)
         {
-            if (changesMask[37 + i])
+            if (changesMask[39])
             {
                 if (!ignoreNestedChangesMask)
                     ResearchSites[i].WriteUpdateMask(data);
@@ -4458,11 +4494,11 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
             }
         }
     }
-    if (changesMask[38])
+    if (changesMask[40])
     {
         for (uint32 i = 0; i < 1; ++i)
         {
-            if (changesMask[39 + i])
+            if (changesMask[41])
             {
                 if (!ignoreNestedChangesMask)
                     ResearchSiteProgress[i].WriteUpdateMask(data);
@@ -4471,11 +4507,11 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
             }
         }
     }
-    if (changesMask[40])
+    if (changesMask[42])
     {
         for (uint32 i = 0; i < 1; ++i)
         {
-            if (changesMask[41 + i])
+            if (changesMask[43])
             {
                 if (!ignoreNestedChangesMask)
                     Research[i].WriteUpdateMask(data);
@@ -4484,11 +4520,11 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
             }
         }
     }
-    if (changesMask[36])
+    if (changesMask[38])
     {
         for (uint32 i = 0; i < 1; ++i)
         {
-            if (changesMask[37 + i])
+            if (changesMask[39])
             {
                 for (uint32 j = 0; j < ResearchSites[i].size(); ++j)
                 {
@@ -4500,11 +4536,11 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
             }
         }
     }
-    if (changesMask[38])
+    if (changesMask[40])
     {
         for (uint32 i = 0; i < 1; ++i)
         {
-            if (changesMask[39 + i])
+            if (changesMask[41])
             {
                 for (uint32 j = 0; j < ResearchSiteProgress[i].size(); ++j)
                 {
@@ -4516,11 +4552,11 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
             }
         }
     }
-    if (changesMask[40])
+    if (changesMask[42])
     {
         for (uint32 i = 0; i < 1; ++i)
         {
-            if (changesMask[41 + i])
+            if (changesMask[43])
             {
                 for (uint32 j = 0; j < Research[i].size(); ++j)
                 {
@@ -5013,345 +5049,345 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
     }
     if (changesMask[32])
     {
-        if (changesMask[42])
+        if (changesMask[44])
         {
             data << FarsightObject;
         }
-        if (changesMask[43])
+        if (changesMask[45])
         {
             data << SummonedBattlePetGUID;
         }
-        if (changesMask[44])
+        if (changesMask[46])
         {
             data << uint64(Coinage);
         }
-        if (changesMask[45])
+        if (changesMask[47])
         {
             data << int32(XP);
         }
-        if (changesMask[46])
+        if (changesMask[48])
         {
             data << int32(NextLevelXP);
         }
-        if (changesMask[47])
+        if (changesMask[49])
         {
             data << int32(TrialXP);
         }
-        if (changesMask[48])
+        if (changesMask[50])
         {
             Skill->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
-        if (changesMask[49])
+        if (changesMask[51])
         {
             data << int32(CharacterPoints);
         }
-        if (changesMask[50])
+        if (changesMask[52])
         {
             data << int32(MaxTalentTiers);
         }
-        if (changesMask[51])
+        if (changesMask[53])
         {
             data << uint32(TrackCreatureMask);
         }
-        if (changesMask[52])
+        if (changesMask[54])
         {
             data << float(MainhandExpertise);
         }
-        if (changesMask[53])
+        if (changesMask[55])
         {
             data << float(OffhandExpertise);
         }
-        if (changesMask[54])
+        if (changesMask[56])
         {
             data << float(RangedExpertise);
         }
-        if (changesMask[55])
+        if (changesMask[57])
         {
             data << float(CombatRatingExpertise);
         }
-        if (changesMask[56])
+        if (changesMask[58])
         {
             data << float(BlockPercentage);
         }
-        if (changesMask[57])
+        if (changesMask[59])
         {
             data << float(DodgePercentage);
         }
-        if (changesMask[58])
+        if (changesMask[60])
         {
             data << float(DodgePercentageFromAttribute);
         }
-        if (changesMask[59])
+        if (changesMask[61])
         {
             data << float(ParryPercentage);
         }
-        if (changesMask[60])
+        if (changesMask[62])
         {
             data << float(ParryPercentageFromAttribute);
         }
-        if (changesMask[61])
+        if (changesMask[63])
         {
             data << float(CritPercentage);
         }
-        if (changesMask[62])
+        if (changesMask[64])
         {
             data << float(RangedCritPercentage);
         }
-        if (changesMask[63])
+        if (changesMask[65])
         {
             data << float(OffhandCritPercentage);
         }
-        if (changesMask[64])
+        if (changesMask[66])
         {
             data << float(SpellCritPercentage);
         }
-        if (changesMask[65])
+        if (changesMask[67])
         {
             data << int32(ShieldBlock);
         }
-        if (changesMask[66])
+        if (changesMask[68])
         {
             data << float(ShieldBlockCritPercentage);
         }
-        if (changesMask[67])
+        if (changesMask[69])
         {
             data << float(Mastery);
         }
-        if (changesMask[68])
+        if (changesMask[70])
         {
             data << float(Speed);
         }
-        if (changesMask[69])
+        if (changesMask[71])
         {
             data << float(Avoidance);
         }
     }
-    if (changesMask[70])
+    if (changesMask[72])
     {
-        if (changesMask[71])
+        if (changesMask[73])
         {
             data << float(Sturdiness);
         }
-        if (changesMask[72])
+        if (changesMask[74])
         {
             data << int32(Versatility);
         }
-        if (changesMask[73])
+        if (changesMask[75])
         {
             data << float(VersatilityBonus);
         }
-        if (changesMask[74])
+        if (changesMask[76])
         {
             data << float(PvpPowerDamage);
         }
-        if (changesMask[75])
+        if (changesMask[77])
         {
             data << float(PvpPowerHealing);
         }
-        if (changesMask[76])
+        if (changesMask[78])
         {
             data << int32(ModHealingDonePos);
         }
-        if (changesMask[77])
+        if (changesMask[79])
         {
             data << float(ModHealingPercent);
         }
-        if (changesMask[78])
+        if (changesMask[80])
         {
             data << float(ModPeriodicHealingDonePercent);
         }
-        if (changesMask[79])
+        if (changesMask[81])
         {
             data << float(ModSpellPowerPercent);
         }
-        if (changesMask[80])
+        if (changesMask[82])
         {
             data << float(ModResiliencePercent);
         }
-        if (changesMask[81])
+        if (changesMask[83])
         {
             data << float(OverrideSpellPowerByAPPercent);
         }
-        if (changesMask[82])
+        if (changesMask[84])
         {
             data << float(OverrideAPBySpellPowerPercent);
         }
-        if (changesMask[83])
+        if (changesMask[85])
         {
             data << int32(ModTargetResistance);
         }
-        if (changesMask[84])
+        if (changesMask[86])
         {
             data << int32(ModTargetPhysicalResistance);
         }
-        if (changesMask[85])
+        if (changesMask[87])
         {
             data << uint32(LocalFlags);
         }
-        if (changesMask[86])
+        if (changesMask[88])
         {
             data << uint8(GrantableLevels);
         }
-        if (changesMask[87])
+        if (changesMask[89])
         {
             data << uint8(MultiActionBars);
         }
-        if (changesMask[88])
+        if (changesMask[90])
         {
             data << uint8(LifetimeMaxRank);
         }
-        if (changesMask[89])
+        if (changesMask[91])
         {
             data << uint8(NumRespecs);
         }
-        if (changesMask[90])
+        if (changesMask[92])
         {
             data << uint32(PvpMedals);
         }
-        if (changesMask[91])
+        if (changesMask[93])
         {
             data << uint16(TodayHonorableKills);
         }
-        if (changesMask[92])
+        if (changesMask[94])
         {
             data << uint16(YesterdayHonorableKills);
         }
-        if (changesMask[93])
+        if (changesMask[95])
         {
             data << uint32(LifetimeHonorableKills);
         }
-        if (changesMask[94])
+        if (changesMask[96])
         {
             data << int32(WatchedFactionIndex);
         }
-        if (changesMask[95])
+        if (changesMask[97])
         {
             data << int32(MaxLevel);
         }
-        if (changesMask[96])
+        if (changesMask[98])
         {
             data << int32(ScalingPlayerLevelDelta);
         }
-        if (changesMask[97])
+        if (changesMask[99])
         {
             data << int32(MaxCreatureScalingLevel);
         }
-        if (changesMask[98])
+        if (changesMask[100])
         {
             data << int32(PetSpellPower);
         }
-        if (changesMask[99])
+        if (changesMask[101])
         {
             data << float(UiHitModifier);
         }
-        if (changesMask[100])
+        if (changesMask[102])
         {
             data << float(UiSpellHitModifier);
         }
-        if (changesMask[101])
+        if (changesMask[103])
         {
             data << int32(HomeRealmTimeOffset);
         }
     }
-    if (changesMask[102])
+    if (changesMask[104])
     {
-        if (changesMask[103])
+        if (changesMask[105])
         {
             data << float(ModPetHaste);
         }
-        if (changesMask[104])
+        if (changesMask[106])
         {
             data << int8(JailersTowerLevelMax);
         }
-        if (changesMask[105])
+        if (changesMask[107])
         {
             data << int8(JailersTowerLevel);
         }
-        if (changesMask[106])
+        if (changesMask[108])
         {
             data << uint8(LocalRegenFlags);
         }
-        if (changesMask[107])
+        if (changesMask[109])
         {
             data << uint8(AuraVision);
         }
-        if (changesMask[108])
+        if (changesMask[110])
         {
             data << uint8(NumBackpackSlots);
         }
-        if (changesMask[109])
+        if (changesMask[111])
         {
             data << int32(OverrideSpellsID);
         }
-        if (changesMask[110])
+        if (changesMask[112])
         {
             data << uint16(LootSpecID);
         }
-        if (changesMask[111])
+        if (changesMask[113])
         {
             data << uint32(OverrideZonePVPType);
         }
-        if (changesMask[112])
+        if (changesMask[114])
         {
             data << int32(Honor);
         }
-        if (changesMask[113])
+        if (changesMask[115])
         {
             data << int32(HonorNextLevel);
         }
-        if (changesMask[114])
+        if (changesMask[116])
         {
             data << int32(PerksProgramCurrency);
         }
-        if (changesMask[115])
+        if (changesMask[117])
         {
             data << uint8(NumBankSlots);
         }
-        if (changesMask[120])
+        if (changesMask[122])
         {
             data << int32(UiChromieTimeExpansionID);
         }
-        if (changesMask[121])
+        if (changesMask[123])
         {
             data << int32(TransportServerTime);
         }
-        if (changesMask[122])
+        if (changesMask[124])
         {
             data << uint32(WeeklyRewardsPeriodSinceOrigin);
         }
-        if (changesMask[123])
+        if (changesMask[125])
         {
             data << int16(DEBUGSoulbindConduitRank);
         }
-        if (changesMask[125])
+        if (changesMask[127])
         {
             data << uint32(ActiveCombatTraitConfigID);
         }
-        if (changesMask[126])
+        if (changesMask[128])
         {
             data << int32(ItemUpgradeHighOnehandWeaponItemID);
         }
-        if (changesMask[127])
+        if (changesMask[129])
         {
             data << int32(ItemUpgradeHighFingerItemID);
         }
-        if (changesMask[128])
+        if (changesMask[130])
         {
             data << float(ItemUpgradeHighFingerWatermark);
         }
-        if (changesMask[129])
+        if (changesMask[131])
         {
             data << int32(ItemUpgradeHighTrinketItemID);
         }
-        if (changesMask[130])
+        if (changesMask[132])
         {
             data << float(ItemUpgradeHighTrinketWatermark);
         }
-        if (changesMask[131])
+        if (changesMask[133])
         {
             data << uint64(LootHistoryInstanceID);
         }
-        if (changesMask[133])
+        if (changesMask[135])
         {
             data << uint8(RequiredMountCapabilityFlags);
         }
@@ -5359,32 +5395,32 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
         data.WriteBits(PetStable.has_value(), 1);
     }
     data.FlushBits();
-    if (changesMask[102])
+    if (changesMask[104])
     {
-        if (changesMask[116])
+        if (changesMask[118])
         {
             ResearchHistory->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
-        if (changesMask[118])
+        if (changesMask[120])
         {
             if (QuestSession.has_value())
             {
                 QuestSession->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
             }
         }
-        if (changesMask[117])
+        if (changesMask[119])
         {
             data << FrozenPerksVendorItem;
         }
-        if (changesMask[119])
+        if (changesMask[121])
         {
             Field_1410->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
-        if (changesMask[124])
+        if (changesMask[126])
         {
             data << DungeonScore;
         }
-        if (changesMask[132])
+        if (changesMask[134])
         {
             if (PetStable.has_value())
             {
@@ -5392,151 +5428,141 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
             }
         }
     }
-    if (changesMask[134])
+    if (changesMask[136])
     {
         for (uint32 i = 0; i < 227; ++i)
         {
-            if (changesMask[135 + i])
+            if (changesMask[137 + i])
             {
                 data << InvSlots[i];
             }
         }
     }
-    if (changesMask[362])
-    {
-        for (uint32 i = 0; i < 240; ++i)
-        {
-            if (changesMask[363 + i])
-            {
-                data << uint64(ExploredZones[i]);
-            }
-        }
-    }
-    if (changesMask[603])
+    if (changesMask[364])
     {
         for (uint32 i = 0; i < 2; ++i)
         {
-            if (changesMask[604 + i])
+            if (changesMask[365 + i])
             {
                 RestInfo[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
             }
         }
     }
-    if (changesMask[606])
+    if (changesMask[367])
     {
         for (uint32 i = 0; i < 7; ++i)
         {
-            if (changesMask[607 + i])
+            if (changesMask[368 + i])
             {
                 data << int32(ModDamageDonePos[i]);
             }
-            if (changesMask[614 + i])
+            if (changesMask[375 + i])
             {
                 data << int32(ModDamageDoneNeg[i]);
             }
-            if (changesMask[621 + i])
+            if (changesMask[382 + i])
             {
                 data << float(ModDamageDonePercent[i]);
             }
-            if (changesMask[628 + i])
+            if (changesMask[389 + i])
             {
                 data << float(ModHealingDonePercent[i]);
             }
         }
     }
-    if (changesMask[635])
+    if (changesMask[396])
     {
         for (uint32 i = 0; i < 3; ++i)
         {
-            if (changesMask[636 + i])
+            if (changesMask[397 + i])
             {
                 data << float(WeaponDmgMultipliers[i]);
             }
-            if (changesMask[639 + i])
+            if (changesMask[400 + i])
             {
                 data << float(WeaponAtkSpeedMultipliers[i]);
             }
         }
     }
-    if (changesMask[642])
+    if (changesMask[403])
     {
         for (uint32 i = 0; i < 12; ++i)
         {
-            if (changesMask[643 + i])
+            if (changesMask[404 + i])
             {
                 data << uint32(BuybackPrice[i]);
             }
-            if (changesMask[655 + i])
+            if (changesMask[416 + i])
             {
                 data << int64(BuybackTimestamp[i]);
             }
         }
     }
-    if (changesMask[667])
+    if (changesMask[428])
     {
         for (uint32 i = 0; i < 32; ++i)
         {
-            if (changesMask[668 + i])
+            if (changesMask[429 + i])
             {
                 data << int32(CombatRatings[i]);
             }
         }
     }
-    if (changesMask[700])
+    if (changesMask[461])
     {
         for (uint32 i = 0; i < 4; ++i)
         {
-            if (changesMask[701 + i])
+            if (changesMask[462 + i])
             {
                 data << uint32(NoReagentCostMask[i]);
             }
         }
     }
-    if (changesMask[705])
+    if (changesMask[466])
     {
         for (uint32 i = 0; i < 2; ++i)
         {
-            if (changesMask[706 + i])
+            if (changesMask[467 + i])
             {
                 data << int32(ProfessionSkillLine[i]);
             }
         }
     }
-    if (changesMask[708])
+    if (changesMask[469])
     {
         for (uint32 i = 0; i < 5; ++i)
         {
-            if (changesMask[709 + i])
+            if (changesMask[470 + i])
             {
                 data << uint32(BagSlotFlags[i]);
             }
         }
     }
-    if (changesMask[714])
+    if (changesMask[475])
     {
         for (uint32 i = 0; i < 7; ++i)
         {
-            if (changesMask[715 + i])
+            if (changesMask[476 + i])
             {
                 data << uint32(BankBagSlotFlags[i]);
             }
         }
     }
-    if (changesMask[722])
+    if (changesMask[483])
     {
-        for (uint32 i = 0; i < 875; ++i)
+        for (uint32 i = 0; i < 950; ++i)
         {
-            if (changesMask[723 + i])
+            if (changesMask[484 + i])
             {
                 data << uint64(QuestCompleted[i]);
             }
         }
     }
-    if (changesMask[1598])
+    if (changesMask[1434])
     {
         for (uint32 i = 0; i < 17; ++i)
         {
-            if (changesMask[1599 + i])
+            if (changesMask[1435 + i])
             {
                 data << float(ItemUpgradeHighWatermark[i]);
             }
@@ -5553,6 +5579,7 @@ void ActivePlayerData::ClearChangesMask()
     Base::ClearChangesMask(SortBagsRightToLeft);
     Base::ClearChangesMask(InsertItemsLeftToRight);
     Base::ClearChangesMask(HasPerksProgramPendingReward);
+    Base::ClearChangesMask(DataFlags);
     Base::ClearChangesMask(ResearchSites);
     Base::ClearChangesMask(ResearchSiteProgress);
     Base::ClearChangesMask(Research);
@@ -5675,7 +5702,6 @@ void ActivePlayerData::ClearChangesMask()
     Base::ClearChangesMask(PetStable);
     Base::ClearChangesMask(RequiredMountCapabilityFlags);
     Base::ClearChangesMask(InvSlots);
-    Base::ClearChangesMask(ExploredZones);
     Base::ClearChangesMask(RestInfo);
     Base::ClearChangesMask(ModDamageDonePos);
     Base::ClearChangesMask(ModDamageDoneNeg);
diff --git a/src/server/game/Entities/Object/Updates/UpdateFields.h b/src/server/game/Entities/Object/Updates/UpdateFields.h
index 96eb02620b3..d3458ea8e67 100644
--- a/src/server/game/Entities/Object/Updates/UpdateFields.h
+++ b/src/server/game/Entities/Object/Updates/UpdateFields.h
@@ -798,10 +798,10 @@ struct CraftingOrder : public IsUpdateFieldStructureTag, public HasChangesMask<4
     void ClearChangesMask();
 };
 
-struct PersonalCraftingOrderCount : public IsUpdateFieldStructureTag, public HasChangesMask<3>
+struct PersonalCraftingOrderCount : public IsUpdateFieldStructureTag, public HasChangesMask<2>
 {
-    UpdateField<int32, 0, 1> ProfessionID;
-    UpdateField<uint32, 0, 2> Count;
+    UpdateField<int32, -1, 0> ProfessionID;
+    UpdateField<uint32, -1, 1> Count;
 
     void WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const;
     void WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const;
@@ -876,7 +876,7 @@ struct Research : public IsUpdateFieldStructureTag
     bool operator!=(Research const& right) const { return !(*this == right); }
 };
 
-struct ActivePlayerData : public IsUpdateFieldStructureTag, public HasChangesMask<1616>
+struct ActivePlayerData : public IsUpdateFieldStructureTag, public HasChangesMask<1452>
 {
     UpdateField<bool, 0, 1> BackpackAutoSortDisabled;
     UpdateField<bool, 0, 2> BackpackSellJunkDisabled;
@@ -884,9 +884,10 @@ struct ActivePlayerData : public IsUpdateFieldStructureTag, public HasChangesMas
     UpdateField<bool, 0, 4> SortBagsRightToLeft;
     UpdateField<bool, 0, 5> InsertItemsLeftToRight;
     UpdateField<bool, 0, 6> HasPerksProgramPendingReward;
-    UpdateFieldArray<DynamicUpdateFieldBase<uint16>, 1, 36, 37> ResearchSites;
-    UpdateFieldArray<DynamicUpdateFieldBase<uint32>, 1, 38, 39> ResearchSiteProgress;
-    UpdateFieldArray<DynamicUpdateFieldBase<UF::Research>, 1, 40, 41> Research;
+    UpdateFieldArray<DynamicUpdateFieldBase<uint64>, 8, 36, 37> DataFlags;
+    UpdateFieldArray<DynamicUpdateFieldBase<uint16>, 1, 38, 39> ResearchSites;
+    UpdateFieldArray<DynamicUpdateFieldBase<uint32>, 1, 40, 41> ResearchSiteProgress;
+    UpdateFieldArray<DynamicUpdateFieldBase<UF::Research>, 1, 42, 43> Research;
     DynamicUpdateField<uint64, 0, 7> KnownTitles;
     DynamicUpdateField<int32, 0, 9> DailyQuestsCompleted;
     DynamicUpdateField<int32, 0, 10> AvailableQuestLineXQuestIDs;
@@ -915,114 +916,113 @@ struct ActivePlayerData : public IsUpdateFieldStructureTag, public HasChangesMas
     DynamicUpdateField<UF::CharacterRestriction, 0, 20> CharacterRestrictions;
     DynamicUpdateField<UF::TraitConfig, 0, 29> TraitConfigs;
     DynamicUpdateField<UF::CraftingOrder, 0, 30> CraftingOrders;
-    UpdateField<ObjectGuid, 32, 42> FarsightObject;
-    UpdateField<ObjectGuid, 32, 43> SummonedBattlePetGUID;
-    UpdateField<uint64, 32, 44> Coinage;
-    UpdateField<int32, 32, 45> XP;
-    UpdateField<int32, 32, 46> NextLevelXP;
-    UpdateField<int32, 32, 47> TrialXP;
-    UpdateField<UF::SkillInfo, 32, 48> Skill;
-    UpdateField<int32, 32, 49> CharacterPoints;
-    UpdateField<int32, 32, 50> MaxTalentTiers;
-    UpdateField<uint32, 32, 51> TrackCreatureMask;
-    UpdateField<float, 32, 52> MainhandExpertise;
-    UpdateField<float, 32, 53> OffhandExpertise;
-    UpdateField<float, 32, 54> RangedExpertise;
-    UpdateField<float, 32, 55> CombatRatingExpertise;
-    UpdateField<float, 32, 56> BlockPercentage;
-    UpdateField<float, 32, 57> DodgePercentage;
-    UpdateField<float, 32, 58> DodgePercentageFromAttribute;
-    UpdateField<float, 32, 59> ParryPercentage;
-    UpdateField<float, 32, 60> ParryPercentageFromAttribute;
-    UpdateField<float, 32, 61> CritPercentage;
-    UpdateField<float, 32, 62> RangedCritPercentage;
-    UpdateField<float, 32, 63> OffhandCritPercentage;
-    UpdateField<float, 32, 64> SpellCritPercentage;
-    UpdateField<int32, 32, 65> ShieldBlock;
-    UpdateField<float, 32, 66> ShieldBlockCritPercentage;
-    UpdateField<float, 32, 67> Mastery;
-    UpdateField<float, 32, 68> Speed;
-    UpdateField<float, 32, 69> Avoidance;
-    UpdateField<float, 70, 71> Sturdiness;
-    UpdateField<int32, 70, 72> Versatility;
-    UpdateField<float, 70, 73> VersatilityBonus;
-    UpdateField<float, 70, 74> PvpPowerDamage;
-    UpdateField<float, 70, 75> PvpPowerHealing;
-    UpdateField<int32, 70, 76> ModHealingDonePos;
-    UpdateField<float, 70, 77> ModHealingPercent;
-    UpdateField<float, 70, 78> ModPeriodicHealingDonePercent;
-    UpdateField<float, 70, 79> ModSpellPowerPercent;
-    UpdateField<float, 70, 80> ModResiliencePercent;
-    UpdateField<float, 70, 81> OverrideSpellPowerByAPPercent;
-    UpdateField<float, 70, 82> OverrideAPBySpellPowerPercent;
-    UpdateField<int32, 70, 83> ModTargetResistance;
-    UpdateField<int32, 70, 84> ModTargetPhysicalResistance;
-    UpdateField<uint32, 70, 85> LocalFlags;
-    UpdateField<uint8, 70, 86> GrantableLevels;
-    UpdateField<uint8, 70, 87> MultiActionBars;
-    UpdateField<uint8, 70, 88> LifetimeMaxRank;
-    UpdateField<uint8, 70, 89> NumRespecs;
-    UpdateField<uint32, 70, 90> PvpMedals;
-    UpdateField<uint16, 70, 91> TodayHonorableKills;
-    UpdateField<uint16, 70, 92> YesterdayHonorableKills;
-    UpdateField<uint32, 70, 93> LifetimeHonorableKills;
-    UpdateField<int32, 70, 94> WatchedFactionIndex;
-    UpdateField<int32, 70, 95> MaxLevel;
-    UpdateField<int32, 70, 96> ScalingPlayerLevelDelta;
-    UpdateField<int32, 70, 97> MaxCreatureScalingLevel;
-    UpdateField<int32, 70, 98> PetSpellPower;
-    UpdateField<float, 70, 99> UiHitModifier;
-    UpdateField<float, 70, 100> UiSpellHitModifier;
-    UpdateField<int32, 70, 101> HomeRealmTimeOffset;
-    UpdateField<float, 102, 103> ModPetHaste;
-    UpdateField<int8, 102, 104> JailersTowerLevelMax;
-    UpdateField<int8, 102, 105> JailersTowerLevel;
-    UpdateField<uint8, 102, 106> LocalRegenFlags;
-    UpdateField<uint8, 102, 107> AuraVision;
-    UpdateField<uint8, 102, 108> NumBackpackSlots;
-    UpdateField<int32, 102, 109> OverrideSpellsID;
-    UpdateField<uint16, 102, 110> LootSpecID;
-    UpdateField<uint32, 102, 111> OverrideZonePVPType;
-    UpdateField<int32, 102, 112> Honor;
-    UpdateField<int32, 102, 113> HonorNextLevel;
-    UpdateField<int32, 102, 114> PerksProgramCurrency;
-    UpdateField<uint8, 102, 115> NumBankSlots;
-    UpdateField<UF::ResearchHistory, 102, 116> ResearchHistory;
-    UpdateField<WorldPackets::PerksProgram::PerksVendorItem, 102, 117> FrozenPerksVendorItem;
-    UpdateField<UF::ActivePlayerUnk901, 102, 119> Field_1410;
-    OptionalUpdateField<UF::QuestSession, 102, 118> QuestSession;
-    UpdateField<int32, 102, 120> UiChromieTimeExpansionID;
-    UpdateField<int32, 102, 121> TransportServerTime;
-    UpdateField<uint32, 102, 122> WeeklyRewardsPeriodSinceOrigin;               // week count since Cfg_RegionsEntry::ChallengeOrigin
-    UpdateField<int16, 102, 123> DEBUGSoulbindConduitRank;
-    UpdateField<WorldPackets::MythicPlus::DungeonScoreData, 102, 124> DungeonScore;
-    UpdateField<uint32, 102, 125> ActiveCombatTraitConfigID;
-    UpdateField<int32, 102, 126> ItemUpgradeHighOnehandWeaponItemID;
-    UpdateField<int32, 102, 127> ItemUpgradeHighFingerItemID;
-    UpdateField<float, 102, 128> ItemUpgradeHighFingerWatermark;
-    UpdateField<int32, 102, 129> ItemUpgradeHighTrinketItemID;
-    UpdateField<float, 102, 130> ItemUpgradeHighTrinketWatermark;
-    UpdateField<uint64, 102, 131> LootHistoryInstanceID;
-    OptionalUpdateField<UF::StableInfo, 102, 132> PetStable;
-    UpdateField<uint8, 102, 133> RequiredMountCapabilityFlags;
-    UpdateFieldArray<ObjectGuid, 227, 134, 135> InvSlots;
-    UpdateFieldArray<uint64, 240, 362, 363> ExploredZones;
-    UpdateFieldArray<UF::RestInfo, 2, 603, 604> RestInfo;
-    UpdateFieldArray<int32, 7, 606, 607> ModDamageDonePos;
-    UpdateFieldArray<int32, 7, 606, 614> ModDamageDoneNeg;
-    UpdateFieldArray<float, 7, 606, 621> ModDamageDonePercent;
-    UpdateFieldArray<float, 7, 606, 628> ModHealingDonePercent;
-    UpdateFieldArray<float, 3, 635, 636> WeaponDmgMultipliers;
-    UpdateFieldArray<float, 3, 635, 639> WeaponAtkSpeedMultipliers;
-    UpdateFieldArray<uint32, 12, 642, 643> BuybackPrice;
-    UpdateFieldArray<int64, 12, 642, 655> BuybackTimestamp;
-    UpdateFieldArray<int32, 32, 667, 668> CombatRatings;
-    UpdateFieldArray<uint32, 4, 700, 701> NoReagentCostMask;
-    UpdateFieldArray<int32, 2, 705, 706> ProfessionSkillLine;
-    UpdateFieldArray<uint32, 5, 708, 709> BagSlotFlags;
-    UpdateFieldArray<uint32, 7, 714, 715> BankBagSlotFlags;
-    UpdateFieldArray<uint64, 875, 722, 723> QuestCompleted;
-    UpdateFieldArray<float, 17, 1598, 1599> ItemUpgradeHighWatermark;
+    UpdateField<ObjectGuid, 32, 44> FarsightObject;
+    UpdateField<ObjectGuid, 32, 45> SummonedBattlePetGUID;
+    UpdateField<uint64, 32, 46> Coinage;
+    UpdateField<int32, 32, 47> XP;
+    UpdateField<int32, 32, 48> NextLevelXP;
+    UpdateField<int32, 32, 49> TrialXP;
+    UpdateField<UF::SkillInfo, 32, 50> Skill;
+    UpdateField<int32, 32, 51> CharacterPoints;
+    UpdateField<int32, 32, 52> MaxTalentTiers;
+    UpdateField<uint32, 32, 53> TrackCreatureMask;
+    UpdateField<float, 32, 54> MainhandExpertise;
+    UpdateField<float, 32, 55> OffhandExpertise;
+    UpdateField<float, 32, 56> RangedExpertise;
+    UpdateField<float, 32, 57> CombatRatingExpertise;
+    UpdateField<float, 32, 58> BlockPercentage;
+    UpdateField<float, 32, 59> DodgePercentage;
+    UpdateField<float, 32, 60> DodgePercentageFromAttribute;
+    UpdateField<float, 32, 61> ParryPercentage;
+    UpdateField<float, 32, 62> ParryPercentageFromAttribute;
+    UpdateField<float, 32, 63> CritPercentage;
+    UpdateField<float, 32, 64> RangedCritPercentage;
+    UpdateField<float, 32, 65> OffhandCritPercentage;
+    UpdateField<float, 32, 66> SpellCritPercentage;
+    UpdateField<int32, 32, 67> ShieldBlock;
+    UpdateField<float, 32, 68> ShieldBlockCritPercentage;
+    UpdateField<float, 32, 69> Mastery;
+    UpdateField<float, 32, 70> Speed;
+    UpdateField<float, 32, 71> Avoidance;
+    UpdateField<float, 72, 73> Sturdiness;
+    UpdateField<int32, 72, 74> Versatility;
+    UpdateField<float, 72, 75> VersatilityBonus;
+    UpdateField<float, 72, 76> PvpPowerDamage;
+    UpdateField<float, 72, 77> PvpPowerHealing;
+    UpdateField<int32, 72, 78> ModHealingDonePos;
+    UpdateField<float, 72, 79> ModHealingPercent;
+    UpdateField<float, 72, 80> ModPeriodicHealingDonePercent;
+    UpdateField<float, 72, 81> ModSpellPowerPercent;
+    UpdateField<float, 72, 82> ModResiliencePercent;
+    UpdateField<float, 72, 83> OverrideSpellPowerByAPPercent;
+    UpdateField<float, 72, 84> OverrideAPBySpellPowerPercent;
+    UpdateField<int32, 72, 85> ModTargetResistance;
+    UpdateField<int32, 72, 86> ModTargetPhysicalResistance;
+    UpdateField<uint32, 72, 87> LocalFlags;
+    UpdateField<uint8, 72, 88> GrantableLevels;
+    UpdateField<uint8, 72, 89> MultiActionBars;
+    UpdateField<uint8, 72, 90> LifetimeMaxRank;
+    UpdateField<uint8, 72, 91> NumRespecs;
+    UpdateField<uint32, 72, 92> PvpMedals;
+    UpdateField<uint16, 72, 93> TodayHonorableKills;
+    UpdateField<uint16, 72, 94> YesterdayHonorableKills;
+    UpdateField<uint32, 72, 95> LifetimeHonorableKills;
+    UpdateField<int32, 72, 96> WatchedFactionIndex;
+    UpdateField<int32, 72, 97> MaxLevel;
+    UpdateField<int32, 72, 98> ScalingPlayerLevelDelta;
+    UpdateField<int32, 72, 99> MaxCreatureScalingLevel;
+    UpdateField<int32, 72, 100> PetSpellPower;
+    UpdateField<float, 72, 101> UiHitModifier;
+    UpdateField<float, 72, 102> UiSpellHitModifier;
+    UpdateField<int32, 72, 103> HomeRealmTimeOffset;
+    UpdateField<float, 104, 105> ModPetHaste;
+    UpdateField<int8, 104, 106> JailersTowerLevelMax;
+    UpdateField<int8, 104, 107> JailersTowerLevel;
+    UpdateField<uint8, 104, 108> LocalRegenFlags;
+    UpdateField<uint8, 104, 109> AuraVision;
+    UpdateField<uint8, 104, 110> NumBackpackSlots;
+    UpdateField<int32, 104, 111> OverrideSpellsID;
+    UpdateField<uint16, 104, 112> LootSpecID;
+    UpdateField<uint32, 104, 113> OverrideZonePVPType;
+    UpdateField<int32, 104, 114> Honor;
+    UpdateField<int32, 104, 115> HonorNextLevel;
+    UpdateField<int32, 104, 116> PerksProgramCurrency;
+    UpdateField<uint8, 104, 117> NumBankSlots;
+    UpdateField<UF::ResearchHistory, 104, 118> ResearchHistory;
+    UpdateField<WorldPackets::PerksProgram::PerksVendorItem, 104, 119> FrozenPerksVendorItem;
+    UpdateField<UF::ActivePlayerUnk901, 104, 121> Field_1410;
+    OptionalUpdateField<UF::QuestSession, 104, 120> QuestSession;
+    UpdateField<int32, 104, 122> UiChromieTimeExpansionID;
+    UpdateField<int32, 104, 123> TransportServerTime;
+    UpdateField<uint32, 104, 124> WeeklyRewardsPeriodSinceOrigin;               // week count since Cfg_RegionsEntry::ChallengeOrigin
+    UpdateField<int16, 104, 125> DEBUGSoulbindConduitRank;
+    UpdateField<WorldPackets::MythicPlus::DungeonScoreData, 104, 126> DungeonScore;
+    UpdateField<uint32, 104, 127> ActiveCombatTraitConfigID;
+    UpdateField<int32, 104, 128> ItemUpgradeHighOnehandWeaponItemID;
+    UpdateField<int32, 104, 129> ItemUpgradeHighFingerItemID;
+    UpdateField<float, 104, 130> ItemUpgradeHighFingerWatermark;
+    UpdateField<int32, 104, 131> ItemUpgradeHighTrinketItemID;
+    UpdateField<float, 104, 132> ItemUpgradeHighTrinketWatermark;
+    UpdateField<uint64, 104, 133> LootHistoryInstanceID;
+    OptionalUpdateField<UF::StableInfo, 104, 134> PetStable;
+    UpdateField<uint8, 104, 135> RequiredMountCapabilityFlags;
+    UpdateFieldArray<ObjectGuid, 227, 136, 137> InvSlots;
+    UpdateFieldArray<UF::RestInfo, 2, 364, 365> RestInfo;
+    UpdateFieldArray<int32, 7, 367, 368> ModDamageDonePos;
+    UpdateFieldArray<int32, 7, 367, 375> ModDamageDoneNeg;
+    UpdateFieldArray<float, 7, 367, 382> ModDamageDonePercent;
+    UpdateFieldArray<float, 7, 367, 389> ModHealingDonePercent;
+    UpdateFieldArray<float, 3, 396, 397> WeaponDmgMultipliers;
+    UpdateFieldArray<float, 3, 396, 400> WeaponAtkSpeedMultipliers;
+    UpdateFieldArray<uint32, 12, 403, 404> BuybackPrice;
+    UpdateFieldArray<int64, 12, 403, 416> BuybackTimestamp;
+    UpdateFieldArray<int32, 32, 428, 429> CombatRatings;
+    UpdateFieldArray<uint32, 4, 461, 462> NoReagentCostMask;
+    UpdateFieldArray<int32, 2, 466, 467> ProfessionSkillLine;
+    UpdateFieldArray<uint32, 5, 469, 470> BagSlotFlags;
+    UpdateFieldArray<uint32, 7, 475, 476> BankBagSlotFlags;
+    UpdateFieldArray<uint64, 950, 483, 484> QuestCompleted;
+    UpdateFieldArray<float, 17, 1434, 1435> ItemUpgradeHighWatermark;
 
     void WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Player const* owner, Player const* receiver) const;
     void WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Player const* owner, Player const* receiver) const;
diff --git a/src/server/game/Entities/Player/Player.cpp b/src/server/game/Entities/Player/Player.cpp
index 360e1c52cef..7edd50481b8 100644
--- a/src/server/game/Entities/Player/Player.cpp
+++ b/src/server/game/Entities/Player/Player.cpp
@@ -6360,20 +6360,12 @@ void Player::CheckAreaExploreAndOutdoor()
     }
 
     uint32 offset = areaEntry->AreaBit / PLAYER_EXPLORED_ZONES_BITS;
-
-    if (offset >= PLAYER_EXPLORED_ZONES_SIZE)
-    {
-        TC_LOG_ERROR("entities.player", "Player::CheckAreaExploreAndOutdoor: Wrong area flag {} in map data for (X: {} Y: {}) point to field PLAYER_EXPLORED_ZONES_1 + {} ( {} must be < {} ).",
-            areaId, GetPositionX(), GetPositionY(), offset, offset, PLAYER_EXPLORED_ZONES_SIZE);
-        return;
-    }
-
     uint64 val = UI64LIT(1) << (areaEntry->AreaBit % PLAYER_EXPLORED_ZONES_BITS);
-    uint64 currFields = m_activePlayerData->ExploredZones[offset];
 
-    if (!(currFields & val))
+    if (offset >= m_activePlayerData->DataFlags[PLAYER_DATA_FLAG_EXPLORED_ZONES_INDEX].size()
+        || !(m_activePlayerData->DataFlags[PLAYER_DATA_FLAG_EXPLORED_ZONES_INDEX][offset] & val))
     {
-        SetUpdateFieldFlagValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ExploredZones, offset), val);
+        AddExploredZones(offset, val);
 
         UpdateCriteria(CriteriaType::RevealWorldMapOverlay, GetAreaId());
 
@@ -6419,6 +6411,39 @@ void Player::CheckAreaExploreAndOutdoor()
     }
 }
 
+void Player::AddExploredZones(uint32 pos, uint64 mask)
+{
+    SetUpdateFieldFlagValue(m_values
+        .ModifyValue(&Player::m_activePlayerData)
+        .ModifyValue(&UF::ActivePlayerData::DataFlags, PLAYER_DATA_FLAG_EXPLORED_ZONES_INDEX)
+        .ModifyValue(pos), mask);
+}
+
+void Player::RemoveExploredZones(uint32 pos, uint64 mask)
+{
+    RemoveUpdateFieldFlagValue(m_values
+        .ModifyValue(&Player::m_activePlayerData)
+        .ModifyValue(&UF::ActivePlayerData::DataFlags, PLAYER_DATA_FLAG_EXPLORED_ZONES_INDEX)
+        .ModifyValue(pos), mask);
+}
+
+bool Player::HasExploredZone(uint32 areaId) const
+{
+    AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaId);
+    if (!area)
+        return false;
+
+    if (area->AreaBit < 0)
+        return false;
+
+    size_t playerIndexOffset = size_t(area->AreaBit) / PLAYER_EXPLORED_ZONES_BITS;
+    if (playerIndexOffset >= m_activePlayerData->DataFlags[PLAYER_DATA_FLAG_EXPLORED_ZONES_INDEX].size())
+        return false;
+
+    uint64 mask = uint64(1) << (area->AreaBit % PLAYER_EXPLORED_ZONES_BITS);
+    return (m_activePlayerData->DataFlags[PLAYER_DATA_FLAG_EXPLORED_ZONES_INDEX][playerIndexOffset] & mask) != 0;
+}
+
 Team Player::TeamForRace(uint8 race)
 {
     if (ChrRacesEntry const* rEntry = sChrRacesStore.LookupEntry(race))
@@ -17785,9 +17810,8 @@ bool Player::LoadFromDB(ObjectGuid guid, CharacterDatabaseQueryHolder const& hol
     SetXP(fields.xp);
 
     std::vector<std::string_view> exploredZones = Trinity::Tokenize(fields.exploredZones, ' ', false);
-    for (std::size_t i = 0; i < exploredZones.size() && i / 2 < PLAYER_EXPLORED_ZONES_SIZE; ++i)
-        SetUpdateFieldFlagValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ExploredZones, i / 2),
-            Trinity::StringTo<uint64>(exploredZones[i]).value_or(UI64LIT(0)) << (32 * (i % 2)));
+    for (std::size_t i = 0; i < exploredZones.size(); ++i)
+        AddExploredZones(i / 2, Trinity::StringTo<uint64>(exploredZones[i]).value_or(UI64LIT(0)) << (32 * (i % 2)));
 
     std::vector<std::string_view> knownTitles = Trinity::Tokenize(fields.knownTitles, ' ', false);
     for (std::size_t i = 0; i < knownTitles.size(); ++i)
@@ -20037,10 +20061,10 @@ void Player::SaveToDB(LoginDatabaseTransaction loginTransaction, CharacterDataba
         stmt->setUInt32(index++, GetLootSpecId());
 
         ss.str("");
-        for (uint32 i = 0; i < PLAYER_EXPLORED_ZONES_SIZE; ++i)
+        for (size_t i = 0; i < m_activePlayerData->DataFlags[PLAYER_DATA_FLAG_EXPLORED_ZONES_INDEX].size(); ++i)
         {
-            ss << uint32(m_activePlayerData->ExploredZones[i] & 0xFFFFFFFF) << ' ';
-            ss << uint32((m_activePlayerData->ExploredZones[i] >> 32) & 0xFFFFFFFF) << ' ';
+            ss << uint32(m_activePlayerData->DataFlags[PLAYER_DATA_FLAG_EXPLORED_ZONES_INDEX][i] & 0xFFFFFFFF) << ' ';
+            ss << uint32((m_activePlayerData->DataFlags[PLAYER_DATA_FLAG_EXPLORED_ZONES_INDEX][i] >> 32) & 0xFFFFFFFF) << ' ';
         }
         stmt->setString(index++, ss.str());
 
@@ -20174,10 +20198,10 @@ void Player::SaveToDB(LoginDatabaseTransaction loginTransaction, CharacterDataba
         stmt->setUInt32(index++, GetLootSpecId());
 
         ss.str("");
-        for (uint32 i = 0; i < PLAYER_EXPLORED_ZONES_SIZE; ++i)
+        for (size_t i = 0; i < m_activePlayerData->DataFlags[PLAYER_DATA_FLAG_EXPLORED_ZONES_INDEX].size(); ++i)
         {
-            ss << uint32(m_activePlayerData->ExploredZones[i] & 0xFFFFFFFF) << ' ';
-            ss << uint32((m_activePlayerData->ExploredZones[i] >> 32) & 0xFFFFFFFF) << ' ';
+            ss << uint32(m_activePlayerData->DataFlags[PLAYER_DATA_FLAG_EXPLORED_ZONES_INDEX][i] & 0xFFFFFFFF) << ' ';
+            ss << uint32((m_activePlayerData->DataFlags[PLAYER_DATA_FLAG_EXPLORED_ZONES_INDEX][i] >> 32) & 0xFFFFFFFF) << ' ';
         }
         stmt->setString(index++, ss.str());
 
diff --git a/src/server/game/Entities/Player/Player.h b/src/server/game/Entities/Player/Player.h
index 0dda39ea498..10f309f56ca 100644
--- a/src/server/game/Entities/Player/Player.h
+++ b/src/server/game/Entities/Player/Player.h
@@ -143,10 +143,13 @@ enum PlayerSkillsConstants
     PLAYER_MAX_SKILLS   = UF::size<decltype(UF::SkillInfo::SkillLineID)>()
 };
 
-enum PlayerExplorationConstants
+enum PlayerDataFlagConstants
 {
-    PLAYER_EXPLORED_ZONES_SIZE  = UF::size<decltype(UF::ActivePlayerData::ExploredZones)>(),
-    PLAYER_EXPLORED_ZONES_BITS  = UF::size_of_value_type<decltype(UF::ActivePlayerData::ExploredZones)>() * 8
+    PLAYER_EXPLORED_ZONES_BITS  = UF::size_of_value_type<decltype(UF::ActivePlayerData::DataFlags)::value_type>() * 8,
+
+    PLAYER_DATA_FLAG_EXPLORED_ZONES_INDEX   = 1,
+    PLAYER_DATA_FLAG_CHARACTER_INDEX        = 2,
+    PLAYER_DATA_FLAG_ACCOUNT_INDEX          = 3,
 };
 
 enum SpellModType : uint8
@@ -2223,8 +2226,9 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
         void ProcessDelayedOperations();
 
         void CheckAreaExploreAndOutdoor(void);
-        void AddExploredZones(uint32 pos, uint64 mask) { SetUpdateFieldFlagValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ExploredZones, pos), mask); }
-        void RemoveExploredZones(uint32 pos, uint64 mask) { RemoveUpdateFieldFlagValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ExploredZones, pos), mask); }
+        void AddExploredZones(uint32 pos, uint64 mask);
+        void RemoveExploredZones(uint32 pos, uint64 mask);
+        bool HasExploredZone(uint32 areaId) const;
 
         static Team TeamForRace(uint8 race);
         static TeamId TeamIdForRace(uint8 race);