Core: Update to 10.1

5 files changed, 535 insertions, 331 deletions

diff --git a/src/server/game/Entities/Object/MovementInfo.h b/src/server/game/Entities/Object/MovementInfo.h
index 9e8c3909b36..768785fdfb9 100644
--- a/src/server/game/Entities/Object/MovementInfo.h
+++ b/src/server/game/Entities/Object/MovementInfo.h
@@ -95,6 +95,8 @@ struct MovementInfo
 
     Optional<AdvFlying> advFlying;
 
+    Optional<ObjectGuid> standingOnGameObjectGUID;
+
     MovementInfo() :
         flags(0), flags2(0), flags3(0), time(0), pitch(0.0f), stepUpStartElevation(0.0f)
     {
diff --git a/src/server/game/Entities/Object/Object.cpp b/src/server/game/Entities/Object/Object.cpp
index a710e31bf71..a911aaec5ab 100644
--- a/src/server/game/Entities/Object/Object.cpp
+++ b/src/server/game/Entities/Object/Object.cpp
@@ -279,6 +279,7 @@ void Object::BuildMovementUpdate(ByteBuffer* data, CreateObjectBits flags, Playe
         bool HasSpline = unit->IsSplineEnabled();
         bool HasInertia = unit->m_movementInfo.inertia.has_value();
         bool HasAdvFlying = unit->m_movementInfo.advFlying.has_value();
+        bool HasStandingOnGameObjectGUID = unit->m_movementInfo.standingOnGameObjectGUID.has_value();
 
         *data << GetGUID();                                             // MoverGUID
 
@@ -301,6 +302,7 @@ void Object::BuildMovementUpdate(ByteBuffer* data, CreateObjectBits flags, Playe
         //for (std::size_t i = 0; i < RemoveForcesIDs.size(); ++i)
         //    *data << ObjectGuid(RemoveForcesIDs);
 
+        data->WriteBit(HasStandingOnGameObjectGUID);                    // HasStandingOnGameObjectGUID
         data->WriteBit(!unit->m_movementInfo.transport.guid.IsEmpty()); // HasTransport
         data->WriteBit(HasFall);                                        // HasFall
         data->WriteBit(HasSpline);                                      // HasSpline - marks that the unit uses spline movement
@@ -312,6 +314,9 @@ void Object::BuildMovementUpdate(ByteBuffer* data, CreateObjectBits flags, Playe
         if (!unit->m_movementInfo.transport.guid.IsEmpty())
             *data << unit->m_movementInfo.transport;
 
+        if (HasStandingOnGameObjectGUID)
+            *data << *unit->m_movementInfo.standingOnGameObjectGUID;
+
         if (HasInertia)
         {
             *data << unit->m_movementInfo.inertia->id;
@@ -842,6 +847,22 @@ void MovementInfo::OutDebug()
 
     if (flags & MOVEMENTFLAG_SPLINE_ELEVATION)
         TC_LOG_DEBUG("misc", "stepUpStartElevation: {}", stepUpStartElevation);
+
+    if (inertia)
+    {
+        TC_LOG_DEBUG("misc", "inertia->id: {}", inertia->id);
+        TC_LOG_DEBUG("misc", "inertia->force: {}", inertia->force.ToString());
+        TC_LOG_DEBUG("misc", "inertia->lifetime: {}", inertia->lifetime);
+    }
+
+    if (advFlying)
+    {
+        TC_LOG_DEBUG("misc", "advFlying->forwardVelocity: {}", advFlying->forwardVelocity);
+        TC_LOG_DEBUG("misc", "advFlying->upVelocity: {}", advFlying->upVelocity);
+    }
+
+    if (standingOnGameObjectGUID)
+        TC_LOG_DEBUG("misc", "standingOnGameObjectGUID: {}", standingOnGameObjectGUID->ToString());
 }
 
 WorldObject::WorldObject(bool isWorldObject) : Object(), WorldLocation(), LastUsedScriptID(0),
diff --git a/src/server/game/Entities/Object/ObjectDefines.h b/src/server/game/Entities/Object/ObjectDefines.h
index 964743fbc0e..86b2c3be09b 100644
--- a/src/server/game/Entities/Object/ObjectDefines.h
+++ b/src/server/game/Entities/Object/ObjectDefines.h
@@ -58,7 +58,7 @@ enum class VisibilityDistanceType : uint8
     Max
 };
 
-enum TempSummonType
+enum TempSummonType : uint8
 {
     TEMPSUMMON_TIMED_OR_DEAD_DESPAWN       = 1,             // despawns after a specified time OR when the creature disappears
     TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN     = 2,             // despawns after a specified time OR when the creature dies
diff --git a/src/server/game/Entities/Object/Updates/UpdateFields.cpp b/src/server/game/Entities/Object/Updates/UpdateFields.cpp
index 8d125ed74db..ebb9c34207e 100644
--- a/src/server/game/Entities/Object/Updates/UpdateFields.cpp
+++ b/src/server/game/Entities/Object/Updates/UpdateFields.cpp
@@ -968,14 +968,14 @@ void UnitData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisi
     data << uint8(DisplayPower);
     data << uint32(OverrideDisplayPowerID);
     data << int64(Health);
-    for (uint32 i = 0; i < 7; ++i)
+    for (uint32 i = 0; i < 10; ++i)
     {
         data << int32(Power[i]);
         data << int32(MaxPower[i]);
     }
     if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner | UpdateFieldFlag::UnitAll))
     {
-        for (uint32 i = 0; i < 7; ++i)
+        for (uint32 i = 0; i < 10; ++i)
         {
             data << float(PowerRegenFlatModifier[i]);
             data << float(PowerRegenInterruptedFlatModifier[i]);
@@ -1132,7 +1132,7 @@ void UnitData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisi
 
 void UnitData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Unit const* owner, Player const* receiver) const
 {
-    Mask allowedMaskForTarget({ 0xFFFFDFFFu, 0xC3FEFFFFu, 0x003DFFFFu, 0xFFFFFF01u, 0xF8001FFFu, 0x00000003u, 0x00000000u });
+    Mask allowedMaskForTarget({ 0xFFFFDFFFu, 0xC3FEFFFFu, 0x003DFFFFu, 0xFFFFFF01u, 0x0007FFFFu, 0x00003F80u, 0x00000000u });
     AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
     WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver);
 }
@@ -1140,16 +1140,16 @@ void UnitData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisi
 void UnitData::AppendAllowedFieldsMaskForFlag(Mask& allowedMaskForTarget, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
 {
     if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
-        allowedMaskForTarget |= { 0x00002000u, 0x3C010000u, 0xFFC20000u, 0x400000FEu, 0x07FFE000u, 0xFFFFFFFCu, 0x0000001Fu };
+        allowedMaskForTarget |= { 0x00002000u, 0x3C010000u, 0xFFC20000u, 0x400000FEu, 0xFFF80000u, 0xFFFFC07Fu, 0x0001FFFFu };
     if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::UnitAll))
-        allowedMaskForTarget |= { 0x00000000u, 0x00000000u, 0x00000000u, 0x40000000u, 0x07FFE000u, 0x00000000u, 0x00000000u };
+        allowedMaskForTarget |= { 0x00000000u, 0x00000000u, 0x00000000u, 0x40000000u, 0xFFF80000u, 0x0000007Fu, 0x00000000u };
     if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Empath))
-        allowedMaskForTarget |= { 0x00000000u, 0x3C000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x007F8000u, 0x00000000u };
+        allowedMaskForTarget |= { 0x00000000u, 0x3C000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0xF8000000u, 0x00000007u };
 }
 
 void UnitData::FilterDisallowedFieldsMaskForFlag(Mask& changesMask, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
 {
-    Mask allowedMaskForTarget({ 0xFFFFDFFFu, 0xC3FEFFFFu, 0x003DFFFFu, 0xFFFFFF01u, 0xF8001FFFu, 0x00000003u, 0x00000000u });
+    Mask allowedMaskForTarget({ 0xFFFFDFFFu, 0xC3FEFFFFu, 0x003DFFFFu, 0xFFFFFF01u, 0x0007FFFFu, 0x00003F80u, 0x00000000u });
     AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
     changesMask &= allowedMaskForTarget;
 }
@@ -1712,77 +1712,77 @@ void UnitData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignor
     }
     if (changesMask[126])
     {
-        for (uint32 i = 0; i < 7; ++i)
+        for (uint32 i = 0; i < 10; ++i)
         {
             if (changesMask[127 + i])
             {
                 data << int32(Power[i]);
             }
-            if (changesMask[134 + i])
+            if (changesMask[137 + i])
             {
                 data << int32(MaxPower[i]);
             }
-            if (changesMask[141 + i])
+            if (changesMask[147 + i])
             {
                 data << float(PowerRegenFlatModifier[i]);
             }
-            if (changesMask[148 + i])
+            if (changesMask[157 + i])
             {
                 data << float(PowerRegenInterruptedFlatModifier[i]);
             }
         }
     }
-    if (changesMask[155])
+    if (changesMask[167])
     {
         for (uint32 i = 0; i < 3; ++i)
         {
-            if (changesMask[156 + i])
+            if (changesMask[168 + i])
             {
                 VirtualItems[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
             }
         }
     }
-    if (changesMask[159])
+    if (changesMask[171])
     {
         for (uint32 i = 0; i < 2; ++i)
         {
-            if (changesMask[160 + i])
+            if (changesMask[172 + i])
             {
                 data << uint32(AttackRoundBaseTime[i]);
             }
         }
     }
-    if (changesMask[162])
+    if (changesMask[174])
     {
         for (uint32 i = 0; i < 4; ++i)
         {
-            if (changesMask[163 + i])
+            if (changesMask[175 + i])
             {
                 data << int32(Stats[i]);
             }
-            if (changesMask[167 + i])
+            if (changesMask[179 + i])
             {
                 data << int32(StatPosBuff[i]);
             }
-            if (changesMask[171 + i])
+            if (changesMask[183 + i])
             {
                 data << int32(StatNegBuff[i]);
             }
         }
     }
-    if (changesMask[175])
+    if (changesMask[187])
     {
         for (uint32 i = 0; i < 7; ++i)
         {
-            if (changesMask[176 + i])
+            if (changesMask[188 + i])
             {
                 data << int32(Resistances[i]);
             }
-            if (changesMask[183 + i])
+            if (changesMask[195 + i])
             {
                 data << int32(BonusResistanceMods[i]);
             }
-            if (changesMask[190 + i])
+            if (changesMask[202 + i])
             {
                 data << int32(ManaCostModifier[i]);
             }
@@ -2146,10 +2146,15 @@ void PlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVi
     data << uint32(ArenaCooldowns.size());
     data << int32(Field_B0);
     data << int32(Field_B4);
+    data << int32(CurrentBattlePetSpeciesID);
     CtrOptions->WriteCreate(data, owner, receiver);
     data << int32(CovenantID);
     data << int32(SoulbindID);
     data << uint32(VisualItemReplacements.size());
+    for (uint32 i = 0; i < 19; ++i)
+    {
+        data << uint32(Field_3120[i]);
+    }
     for (uint32 i = 0; i < Customizations.size(); ++i)
     {
         Customizations[i].WriteCreate(data, owner, receiver);
@@ -2180,7 +2185,7 @@ void PlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVi
 
 void PlayerData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Player const* owner, Player const* receiver) const
 {
-    Mask allowedMaskForTarget({ 0xFFFFFFEDu, 0x0000001Fu, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0xFFE00000u, 0x0000FFFFu });
+    Mask allowedMaskForTarget({ 0xFFFFFFEDu, 0x0000003Fu, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0xFFC00000u, 0xFFFFFFFFu, 0x0000001Fu });
     AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
     WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver);
 }
@@ -2188,20 +2193,20 @@ void PlayerData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVi
 void PlayerData::AppendAllowedFieldsMaskForFlag(Mask& allowedMaskForTarget, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
 {
     if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::PartyMember))
-        allowedMaskForTarget |= { 0x00000012u, 0xFFFFFFE0u, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0x001FFFFFu, 0x00000000u };
+        allowedMaskForTarget |= { 0x00000012u, 0xFFFFFFC0u, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0x003FFFFFu, 0x00000000u, 0x00000000u };
 }
 
 void PlayerData::FilterDisallowedFieldsMaskForFlag(Mask& changesMask, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
 {
-    Mask allowedMaskForTarget({ 0xFFFFFFEDu, 0x0000001Fu, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0xFFE00000u, 0x0000FFFFu });
+    Mask allowedMaskForTarget({ 0xFFFFFFEDu, 0x0000003Fu, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0xFFC00000u, 0xFFFFFFFFu, 0x0000001Fu });
     AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
     changesMask &= allowedMaskForTarget;
 }
 
 void PlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignoreNestedChangesMask, Player const* owner, Player const* receiver) const
 {
-    data.WriteBits(changesMask.GetBlocksMask(0), 8);
-    for (uint32 i = 0; i < 8; ++i)
+    data.WriteBits(changesMask.GetBlocksMask(0), 9);
+    for (uint32 i = 0; i < 9; ++i)
         if (changesMask.GetBlock(i))
             data.WriteBits(changesMask.GetBlock(i), 32);
 
@@ -2396,26 +2401,30 @@ void PlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ign
     {
         if (changesMask[33])
         {
-            CtrOptions->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
+            data << int32(CurrentBattlePetSpeciesID);
         }
         if (changesMask[34])
         {
-            data << int32(CovenantID);
+            CtrOptions->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
         if (changesMask[35])
         {
-            data << int32(SoulbindID);
+            data << int32(CovenantID);
         }
         if (changesMask[36])
         {
+            data << int32(SoulbindID);
+        }
+        if (changesMask[37])
+        {
             data << DungeonScore;
         }
     }
-    if (changesMask[37])
+    if (changesMask[38])
     {
         for (uint32 i = 0; i < 175; ++i)
         {
-            if (changesMask[38 + i])
+            if (changesMask[39 + i])
             {
                 if (noQuestLogChangesMask)
                     QuestLog[i].WriteCreate(data, owner, receiver);
@@ -2424,26 +2433,36 @@ void PlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ign
             }
         }
     }
-    if (changesMask[213])
+    if (changesMask[214])
     {
         for (uint32 i = 0; i < 19; ++i)
         {
-            if (changesMask[214 + i])
+            if (changesMask[215 + i])
             {
                 VisibleItems[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
             }
         }
     }
-    if (changesMask[233])
+    if (changesMask[234])
     {
         for (uint32 i = 0; i < 6; ++i)
         {
-            if (changesMask[234 + i])
+            if (changesMask[235 + i])
             {
                 data << float(AvgItemLevel[i]);
             }
         }
     }
+    if (changesMask[241])
+    {
+        for (uint32 i = 0; i < 19; ++i)
+        {
+            if (changesMask[242 + i])
+            {
+                data << uint32(Field_3120[i]);
+            }
+        }
+    }
     data.FlushBits();
 }
 
@@ -2480,6 +2499,7 @@ void PlayerData::ClearChangesMask()
     Base::ClearChangesMask(LogoutTime);
     Base::ClearChangesMask(Field_B0);
     Base::ClearChangesMask(Field_B4);
+    Base::ClearChangesMask(CurrentBattlePetSpeciesID);
     Base::ClearChangesMask(CtrOptions);
     Base::ClearChangesMask(CovenantID);
     Base::ClearChangesMask(SoulbindID);
@@ -2487,6 +2507,7 @@ void PlayerData::ClearChangesMask()
     Base::ClearChangesMask(QuestLog);
     Base::ClearChangesMask(VisibleItems);
     Base::ClearChangesMask(AvgItemLevel);
+    Base::ClearChangesMask(Field_3120);
     _changesMask.ResetAll();
 }
 
@@ -3523,9 +3544,45 @@ bool PersonalCraftingOrderCount::operator==(PersonalCraftingOrderCount const& ri
         && Count == right.Count;
 }
 
+void CategoryCooldownMod::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
+{
+    data << int32(SpellCategoryID);
+    data << int32(ModCooldown);
+}
+
+void CategoryCooldownMod::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
+{
+    data << int32(SpellCategoryID);
+    data << int32(ModCooldown);
+}
+
+bool CategoryCooldownMod::operator==(CategoryCooldownMod const& right) const
+{
+    return SpellCategoryID == right.SpellCategoryID
+        && ModCooldown == right.ModCooldown;
+}
+
+void WeeklySpellUse::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
+{
+    data << int32(SpellCategoryID);
+    data << uint8(Uses);
+}
+
+void WeeklySpellUse::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
+{
+    data << int32(SpellCategoryID);
+    data << uint8(Uses);
+}
+
+bool WeeklySpellUse::operator==(WeeklySpellUse const& right) const
+{
+    return SpellCategoryID == right.SpellCategoryID
+        && Uses == right.Uses;
+}
+
 void ActivePlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Player const* owner, Player const* receiver) const
 {
-    for (uint32 i = 0; i < 218; ++i)
+    for (uint32 i = 0; i < 227; ++i)
     {
         data << InvSlots[i];
     }
@@ -3691,6 +3748,13 @@ void ActivePlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> f
     data << uint32(ActiveCombatTraitConfigID);
     data << uint32(CraftingOrders.size());
     data << uint32(PersonalCraftingOrderCounts.size());
+    data << uint32(CategoryCooldownMods.size());
+    data << uint32(WeeklySpellUses.size());
+    for (uint32 i = 0; i < 17; ++i)
+    {
+        data << float(ItemUpgradeHighWatermark[i]);
+    }
+    data << uint64(LootHistoryInstanceID);
     for (uint32 i = 0; i < KnownTitles.size(); ++i)
     {
         data << uint64(KnownTitles[i]);
@@ -3779,6 +3843,14 @@ void ActivePlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> f
     {
         PersonalCraftingOrderCounts[i].WriteCreate(data, owner, receiver);
     }
+    for (uint32 i = 0; i < CategoryCooldownMods.size(); ++i)
+    {
+        CategoryCooldownMods[i].WriteCreate(data, owner, receiver);
+    }
+    for (uint32 i = 0; i < WeeklySpellUses.size(); ++i)
+    {
+        WeeklySpellUses[i].WriteCreate(data, owner, receiver);
+    }
     data.FlushBits();
     data.WriteBit(BackpackAutoSortDisabled);
     data.WriteBit(BankAutoSortDisabled);
@@ -3821,8 +3893,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), 18);
-    for (uint32 i = 0; i < 50; ++i)
+    data.WriteBits(changesMask.GetBlocksMask(1), 19);
+    for (uint32 i = 0; i < 51; ++i)
         if (changesMask.GetBlock(i))
             data.WriteBits(changesMask.GetBlock(i), 32);
 
@@ -3975,11 +4047,11 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 WriteCompleteDynamicFieldUpdateMask(SpellFlatModByLabel.size(), data);
         }
     }
-    if (changesMask[32])
+    if (changesMask[35])
     {
         for (uint32 i = 0; i < 1; ++i)
         {
-            if (changesMask[33 + i])
+            if (changesMask[36 + i])
             {
                 if (!ignoreNestedChangesMask)
                     Research[i].WriteUpdateMask(data);
@@ -4055,6 +4127,23 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 WriteCompleteDynamicFieldUpdateMask(PersonalCraftingOrderCounts.size(), data);
         }
     }
+    if (changesMask[32])
+    {
+        if (changesMask[33])
+        {
+            if (!ignoreNestedChangesMask)
+                CategoryCooldownMods.WriteUpdateMask(data);
+            else
+                WriteCompleteDynamicFieldUpdateMask(CategoryCooldownMods.size(), data);
+        }
+        if (changesMask[34])
+        {
+            if (!ignoreNestedChangesMask)
+                WeeklySpellUses.WriteUpdateMask(data);
+            else
+                WriteCompleteDynamicFieldUpdateMask(WeeklySpellUses.size(), data);
+        }
+    }
     data.FlushBits();
     if (changesMask[0])
     {
@@ -4278,6 +4367,32 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
+    }
+    if (changesMask[32])
+    {
+        if (changesMask[33])
+        {
+            for (uint32 i = 0; i < CategoryCooldownMods.size(); ++i)
+            {
+                if (CategoryCooldownMods.HasChanged(i) || ignoreNestedChangesMask)
+                {
+                    CategoryCooldownMods[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
+                }
+            }
+        }
+        if (changesMask[34])
+        {
+            for (uint32 i = 0; i < WeeklySpellUses.size(); ++i)
+            {
+                if (WeeklySpellUses.HasChanged(i) || ignoreNestedChangesMask)
+                {
+                    WeeklySpellUses[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
+                }
+            }
+        }
+    }
+    if (changesMask[0])
+    {
         if (changesMask[7])
         {
             for (uint32 i = 0; i < PvpInfo.size(); ++i)
@@ -4319,494 +4434,508 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
             }
         }
     }
-    if (changesMask[34])
+    if (changesMask[32])
     {
-        if (changesMask[35])
-        {
-            data << FarsightObject;
-        }
-        if (changesMask[36])
-        {
-            data << SummonedBattlePetGUID;
-        }
         if (changesMask[37])
         {
-            data << uint64(Coinage);
+            data << FarsightObject;
         }
         if (changesMask[38])
         {
-            data << int32(XP);
+            data << SummonedBattlePetGUID;
         }
         if (changesMask[39])
         {
-            data << int32(NextLevelXP);
+            data << uint64(Coinage);
         }
         if (changesMask[40])
         {
-            data << int32(TrialXP);
+            data << int32(XP);
         }
         if (changesMask[41])
         {
-            Skill->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
+            data << int32(NextLevelXP);
         }
         if (changesMask[42])
         {
-            data << int32(CharacterPoints);
+            data << int32(TrialXP);
         }
         if (changesMask[43])
         {
-            data << int32(MaxTalentTiers);
+            Skill->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
         if (changesMask[44])
         {
-            data << uint32(TrackCreatureMask);
+            data << int32(CharacterPoints);
         }
         if (changesMask[45])
         {
-            data << float(MainhandExpertise);
+            data << int32(MaxTalentTiers);
         }
         if (changesMask[46])
         {
-            data << float(OffhandExpertise);
+            data << uint32(TrackCreatureMask);
         }
         if (changesMask[47])
         {
-            data << float(RangedExpertise);
+            data << float(MainhandExpertise);
         }
         if (changesMask[48])
         {
-            data << float(CombatRatingExpertise);
+            data << float(OffhandExpertise);
         }
         if (changesMask[49])
         {
-            data << float(BlockPercentage);
+            data << float(RangedExpertise);
         }
         if (changesMask[50])
         {
-            data << float(DodgePercentage);
+            data << float(CombatRatingExpertise);
         }
         if (changesMask[51])
         {
-            data << float(DodgePercentageFromAttribute);
+            data << float(BlockPercentage);
         }
         if (changesMask[52])
         {
-            data << float(ParryPercentage);
+            data << float(DodgePercentage);
         }
         if (changesMask[53])
         {
-            data << float(ParryPercentageFromAttribute);
+            data << float(DodgePercentageFromAttribute);
         }
         if (changesMask[54])
         {
-            data << float(CritPercentage);
+            data << float(ParryPercentage);
         }
         if (changesMask[55])
         {
-            data << float(RangedCritPercentage);
+            data << float(ParryPercentageFromAttribute);
         }
         if (changesMask[56])
         {
-            data << float(OffhandCritPercentage);
+            data << float(CritPercentage);
         }
         if (changesMask[57])
         {
-            data << float(SpellCritPercentage);
+            data << float(RangedCritPercentage);
         }
         if (changesMask[58])
         {
-            data << int32(ShieldBlock);
+            data << float(OffhandCritPercentage);
         }
         if (changesMask[59])
         {
-            data << float(ShieldBlockCritPercentage);
+            data << float(SpellCritPercentage);
         }
         if (changesMask[60])
         {
-            data << float(Mastery);
+            data << int32(ShieldBlock);
         }
         if (changesMask[61])
         {
-            data << float(Speed);
+            data << float(ShieldBlockCritPercentage);
         }
         if (changesMask[62])
         {
-            data << float(Avoidance);
+            data << float(Mastery);
         }
         if (changesMask[63])
         {
-            data << float(Sturdiness);
+            data << float(Speed);
         }
         if (changesMask[64])
         {
-            data << int32(Versatility);
+            data << float(Avoidance);
         }
         if (changesMask[65])
         {
-            data << float(VersatilityBonus);
+            data << float(Sturdiness);
         }
     }
     if (changesMask[66])
     {
         if (changesMask[67])
         {
-            data << float(PvpPowerDamage);
+            data << int32(Versatility);
         }
         if (changesMask[68])
         {
-            data << float(PvpPowerHealing);
+            data << float(VersatilityBonus);
         }
         if (changesMask[69])
         {
-            data << int32(ModHealingDonePos);
+            data << float(PvpPowerDamage);
         }
         if (changesMask[70])
         {
-            data << float(ModHealingPercent);
+            data << float(PvpPowerHealing);
         }
         if (changesMask[71])
         {
-            data << float(ModPeriodicHealingDonePercent);
+            data << int32(ModHealingDonePos);
         }
         if (changesMask[72])
         {
-            data << float(ModSpellPowerPercent);
+            data << float(ModHealingPercent);
         }
         if (changesMask[73])
         {
-            data << float(ModResiliencePercent);
+            data << float(ModPeriodicHealingDonePercent);
         }
         if (changesMask[74])
         {
-            data << float(OverrideSpellPowerByAPPercent);
+            data << float(ModSpellPowerPercent);
         }
         if (changesMask[75])
         {
-            data << float(OverrideAPBySpellPowerPercent);
+            data << float(ModResiliencePercent);
         }
         if (changesMask[76])
         {
-            data << int32(ModTargetResistance);
+            data << float(OverrideSpellPowerByAPPercent);
         }
         if (changesMask[77])
         {
-            data << int32(ModTargetPhysicalResistance);
+            data << float(OverrideAPBySpellPowerPercent);
         }
         if (changesMask[78])
         {
-            data << uint32(LocalFlags);
+            data << int32(ModTargetResistance);
         }
         if (changesMask[79])
         {
-            data << uint8(GrantableLevels);
+            data << int32(ModTargetPhysicalResistance);
         }
         if (changesMask[80])
         {
-            data << uint8(MultiActionBars);
+            data << uint32(LocalFlags);
         }
         if (changesMask[81])
         {
-            data << uint8(LifetimeMaxRank);
+            data << uint8(GrantableLevels);
         }
         if (changesMask[82])
         {
-            data << uint8(NumRespecs);
+            data << uint8(MultiActionBars);
         }
         if (changesMask[83])
         {
-            data << uint32(PvpMedals);
+            data << uint8(LifetimeMaxRank);
         }
         if (changesMask[84])
         {
-            data << uint16(TodayHonorableKills);
+            data << uint8(NumRespecs);
         }
         if (changesMask[85])
         {
-            data << uint16(YesterdayHonorableKills);
+            data << uint32(PvpMedals);
         }
         if (changesMask[86])
         {
-            data << uint32(LifetimeHonorableKills);
+            data << uint16(TodayHonorableKills);
         }
         if (changesMask[87])
         {
-            data << int32(WatchedFactionIndex);
+            data << uint16(YesterdayHonorableKills);
         }
         if (changesMask[88])
         {
-            data << int32(MaxLevel);
+            data << uint32(LifetimeHonorableKills);
         }
         if (changesMask[89])
         {
-            data << int32(ScalingPlayerLevelDelta);
+            data << int32(WatchedFactionIndex);
         }
         if (changesMask[90])
         {
-            data << int32(MaxCreatureScalingLevel);
+            data << int32(MaxLevel);
         }
         if (changesMask[91])
         {
-            data << int32(PetSpellPower);
+            data << int32(ScalingPlayerLevelDelta);
         }
         if (changesMask[92])
         {
-            data << float(UiHitModifier);
+            data << int32(MaxCreatureScalingLevel);
         }
         if (changesMask[93])
         {
-            data << float(UiSpellHitModifier);
+            data << int32(PetSpellPower);
         }
         if (changesMask[94])
         {
-            data << int32(HomeRealmTimeOffset);
+            data << float(UiHitModifier);
         }
         if (changesMask[95])
         {
-            data << float(ModPetHaste);
+            data << float(UiSpellHitModifier);
         }
         if (changesMask[96])
         {
-            data << int8(JailersTowerLevelMax);
+            data << int32(HomeRealmTimeOffset);
         }
         if (changesMask[97])
         {
-            data << int8(JailersTowerLevel);
+            data << float(ModPetHaste);
         }
     }
     if (changesMask[98])
     {
         if (changesMask[99])
         {
-            data << uint8(LocalRegenFlags);
+            data << int8(JailersTowerLevelMax);
         }
         if (changesMask[100])
         {
-            data << uint8(AuraVision);
+            data << int8(JailersTowerLevel);
         }
         if (changesMask[101])
         {
-            data << uint8(NumBackpackSlots);
+            data << uint8(LocalRegenFlags);
         }
         if (changesMask[102])
         {
-            data << int32(OverrideSpellsID);
+            data << uint8(AuraVision);
         }
         if (changesMask[103])
         {
-            data << uint16(LootSpecID);
+            data << uint8(NumBackpackSlots);
         }
         if (changesMask[104])
         {
-            data << uint32(OverrideZonePVPType);
+            data << int32(OverrideSpellsID);
         }
         if (changesMask[105])
         {
-            data << BnetAccount;
+            data << uint16(LootSpecID);
         }
         if (changesMask[106])
         {
-            data << uint64(GuildClubMemberID);
+            data << uint32(OverrideZonePVPType);
         }
         if (changesMask[107])
         {
-            data << int32(Honor);
+            data << BnetAccount;
         }
         if (changesMask[108])
         {
-            data << int32(HonorNextLevel);
+            data << uint64(GuildClubMemberID);
         }
         if (changesMask[109])
         {
-            data << int32(PerksProgramCurrency);
+            data << int32(Honor);
         }
         if (changesMask[110])
         {
+            data << int32(HonorNextLevel);
+        }
+        if (changesMask[111])
+        {
+            data << int32(PerksProgramCurrency);
+        }
+        if (changesMask[112])
+        {
             data << uint8(NumBankSlots);
         }
-        if (changesMask[114])
+        if (changesMask[116])
         {
             data << int32(UiChromieTimeExpansionID);
         }
-        if (changesMask[115])
+        if (changesMask[117])
         {
             data << int32(TransportServerTime);
         }
-        if (changesMask[116])
+        if (changesMask[118])
         {
             data << uint32(WeeklyRewardsPeriodSinceOrigin);
         }
-        if (changesMask[117])
+        if (changesMask[119])
         {
             data << int16(DEBUGSoulbindConduitRank);
         }
-        if (changesMask[119])
+        if (changesMask[121])
         {
             data << uint32(ActiveCombatTraitConfigID);
         }
+        if (changesMask[122])
+        {
+            data << uint64(LootHistoryInstanceID);
+        }
     }
     if (changesMask[98])
     {
         data.WriteBits(QuestSession.has_value(), 1);
-        if (changesMask[111])
+        if (changesMask[113])
         {
             data << FrozenPerksVendorItem;
         }
-        if (changesMask[112])
+        if (changesMask[114])
         {
             if (QuestSession.has_value())
             {
                 QuestSession->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
             }
         }
-        if (changesMask[113])
+        if (changesMask[115])
         {
             Field_1410->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
-        if (changesMask[118])
+        if (changesMask[120])
         {
             data << DungeonScore;
         }
     }
-    if (changesMask[120])
+    if (changesMask[123])
     {
-        for (uint32 i = 0; i < 218; ++i)
+        for (uint32 i = 0; i < 227; ++i)
         {
-            if (changesMask[121 + i])
+            if (changesMask[124 + i])
             {
                 data << InvSlots[i];
             }
         }
     }
-    if (changesMask[339])
+    if (changesMask[351])
     {
         for (uint32 i = 0; i < 240; ++i)
         {
-            if (changesMask[340 + i])
+            if (changesMask[352 + i])
             {
                 data << uint64(ExploredZones[i]);
             }
         }
     }
-    if (changesMask[580])
+    if (changesMask[592])
     {
         for (uint32 i = 0; i < 2; ++i)
         {
-            if (changesMask[581 + i])
+            if (changesMask[593 + i])
             {
                 RestInfo[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
             }
         }
     }
-    if (changesMask[583])
+    if (changesMask[595])
     {
         for (uint32 i = 0; i < 7; ++i)
         {
-            if (changesMask[584 + i])
+            if (changesMask[596 + i])
             {
                 data << int32(ModDamageDonePos[i]);
             }
-            if (changesMask[591 + i])
+            if (changesMask[603 + i])
             {
                 data << int32(ModDamageDoneNeg[i]);
             }
-            if (changesMask[598 + i])
+            if (changesMask[610 + i])
             {
                 data << float(ModDamageDonePercent[i]);
             }
-            if (changesMask[605 + i])
+            if (changesMask[617 + i])
             {
                 data << float(ModHealingDonePercent[i]);
             }
         }
     }
-    if (changesMask[612])
+    if (changesMask[624])
     {
         for (uint32 i = 0; i < 3; ++i)
         {
-            if (changesMask[613 + i])
+            if (changesMask[625 + i])
             {
                 data << float(WeaponDmgMultipliers[i]);
             }
-            if (changesMask[616 + i])
+            if (changesMask[628 + i])
             {
                 data << float(WeaponAtkSpeedMultipliers[i]);
             }
         }
     }
-    if (changesMask[619])
+    if (changesMask[631])
     {
         for (uint32 i = 0; i < 12; ++i)
         {
-            if (changesMask[620 + i])
+            if (changesMask[632 + i])
             {
                 data << uint32(BuybackPrice[i]);
             }
-            if (changesMask[632 + i])
+            if (changesMask[644 + i])
             {
                 data << int64(BuybackTimestamp[i]);
             }
         }
     }
-    if (changesMask[644])
+    if (changesMask[656])
     {
         for (uint32 i = 0; i < 32; ++i)
         {
-            if (changesMask[645 + i])
+            if (changesMask[657 + i])
             {
                 data << int32(CombatRatings[i]);
             }
         }
     }
-    if (changesMask[677])
+    if (changesMask[689])
     {
         for (uint32 i = 0; i < 4; ++i)
         {
-            if (changesMask[678 + i])
+            if (changesMask[690 + i])
             {
                 data << uint32(NoReagentCostMask[i]);
             }
         }
     }
-    if (changesMask[682])
+    if (changesMask[694])
     {
         for (uint32 i = 0; i < 2; ++i)
         {
-            if (changesMask[683 + i])
+            if (changesMask[695 + i])
             {
                 data << int32(ProfessionSkillLine[i]);
             }
         }
     }
-    if (changesMask[685])
+    if (changesMask[697])
     {
         for (uint32 i = 0; i < 5; ++i)
         {
-            if (changesMask[686 + i])
+            if (changesMask[698 + i])
             {
                 data << uint32(BagSlotFlags[i]);
             }
         }
     }
-    if (changesMask[691])
+    if (changesMask[703])
     {
         for (uint32 i = 0; i < 7; ++i)
         {
-            if (changesMask[692 + i])
+            if (changesMask[704 + i])
             {
                 data << uint32(BankBagSlotFlags[i]);
             }
         }
     }
-    if (changesMask[699])
+    if (changesMask[711])
     {
         for (uint32 i = 0; i < 875; ++i)
         {
-            if (changesMask[700 + i])
+            if (changesMask[712 + i])
             {
                 data << uint64(QuestCompleted[i]);
             }
         }
     }
+    if (changesMask[1587])
+    {
+        for (uint32 i = 0; i < 17; ++i)
+        {
+            if (changesMask[1588 + i])
+            {
+                data << float(ItemUpgradeHighWatermark[i]);
+            }
+        }
+    }
     data.FlushBits();
 }
 
@@ -4840,6 +4969,8 @@ void ActivePlayerData::ClearChangesMask()
     Base::ClearChangesMask(ReplayedQuests);
     Base::ClearChangesMask(DisabledSpells);
     Base::ClearChangesMask(PersonalCraftingOrderCounts);
+    Base::ClearChangesMask(CategoryCooldownMods);
+    Base::ClearChangesMask(WeeklySpellUses);
     Base::ClearChangesMask(PvpInfo);
     Base::ClearChangesMask(CharacterRestrictions);
     Base::ClearChangesMask(TraitConfigs);
@@ -4927,6 +5058,7 @@ void ActivePlayerData::ClearChangesMask()
     Base::ClearChangesMask(DEBUGSoulbindConduitRank);
     Base::ClearChangesMask(DungeonScore);
     Base::ClearChangesMask(ActiveCombatTraitConfigID);
+    Base::ClearChangesMask(LootHistoryInstanceID);
     Base::ClearChangesMask(InvSlots);
     Base::ClearChangesMask(ExploredZones);
     Base::ClearChangesMask(RestInfo);
@@ -4944,6 +5076,7 @@ void ActivePlayerData::ClearChangesMask()
     Base::ClearChangesMask(BagSlotFlags);
     Base::ClearChangesMask(BankBagSlotFlags);
     Base::ClearChangesMask(QuestCompleted);
+    Base::ClearChangesMask(ItemUpgradeHighWatermark);
     _changesMask.ResetAll();
 }
 
@@ -5497,10 +5630,14 @@ void AreaTriggerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fi
     data << Field_88;
     data << Field_F8;
     ExtraScaleCurve->WriteCreate(data, owner, receiver);
+    data.WriteBit(Field_260);
+    data.WriteBit(Field_261);
     Field_C38->WriteCreate(data, owner, receiver);
     Field_C54->WriteCreate(data, owner, receiver);
     Field_C70->WriteCreate(data, owner, receiver);
     VisualAnim->WriteCreate(data, owner, receiver);
+    data.FlushBits();
+    data.FlushBits();
 }
 
 void AreaTriggerData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, AreaTrigger const* owner, Player const* receiver) const
@@ -5510,104 +5647,118 @@ void AreaTriggerData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fi
 
 void AreaTriggerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignoreNestedChangesMask, AreaTrigger const* owner, Player const* receiver) const
 {
-    data.WriteBits(changesMask.GetBlock(0), 23);
+    data.WriteBits(changesMask.GetBlock(0), 25);
 
-    data.FlushBits();
     if (changesMask[0])
     {
         if (changesMask[1])
         {
+            data.WriteBit(Field_260);
+        }
+        if (changesMask[2])
+        {
+            data.WriteBit(Field_261);
+        }
+    }
+    data.FlushBits();
+    if (changesMask[0])
+    {
+        if (changesMask[3])
+        {
             OverrideScaleCurve->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
-        if (changesMask[6])
+        if (changesMask[8])
         {
             data << Caster;
         }
-        if (changesMask[7])
+        if (changesMask[9])
         {
             data << uint32(Duration);
         }
-        if (changesMask[8])
+        if (changesMask[10])
         {
             data << uint32(TimeToTarget);
         }
-        if (changesMask[9])
+        if (changesMask[11])
         {
             data << uint32(TimeToTargetScale);
         }
-        if (changesMask[10])
+        if (changesMask[12])
         {
             data << uint32(TimeToTargetExtraScale);
         }
-        if (changesMask[11])
+        if (changesMask[13])
         {
             data << uint32(Field_B0);
         }
-        if (changesMask[12])
+        if (changesMask[14])
         {
             data << int32(SpellID);
         }
-        if (changesMask[13])
+        if (changesMask[15])
         {
             data << int32(SpellForVisuals);
         }
-        if (changesMask[14])
+        if (changesMask[16])
         {
             SpellVisual->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
-        if (changesMask[15])
+        if (changesMask[17])
         {
             data << float(BoundsRadius2D);
         }
-        if (changesMask[16])
+        if (changesMask[18])
         {
             data << uint32(DecalPropertiesID);
         }
-        if (changesMask[17])
+        if (changesMask[19])
         {
             data << CreatingEffectGUID;
         }
-        if (changesMask[18])
+        if (changesMask[20])
         {
             data << uint32(Field_80);
         }
-        if (changesMask[19])
+        if (changesMask[21])
         {
             data << uint32(Field_84);
         }
-        if (changesMask[20])
+        if (changesMask[22])
         {
             data << Field_88;
         }
-        if (changesMask[21])
+        if (changesMask[23])
         {
             data << Field_F8;
         }
-        if (changesMask[2])
+        if (changesMask[4])
         {
             ExtraScaleCurve->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
-        if (changesMask[3])
+        if (changesMask[5])
         {
             Field_C38->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
-        if (changesMask[4])
+        if (changesMask[6])
         {
             Field_C54->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
-        if (changesMask[5])
+        if (changesMask[7])
         {
             Field_C70->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
-        if (changesMask[22])
+        if (changesMask[24])
         {
             VisualAnim->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
     }
+    data.FlushBits();
 }
 
 void AreaTriggerData::ClearChangesMask()
 {
+    Base::ClearChangesMask(Field_260);
+    Base::ClearChangesMask(Field_261);
     Base::ClearChangesMask(OverrideScaleCurve);
     Base::ClearChangesMask(ExtraScaleCurve);
     Base::ClearChangesMask(Field_C38);
diff --git a/src/server/game/Entities/Object/Updates/UpdateFields.h b/src/server/game/Entities/Object/Updates/UpdateFields.h
index ee689dd4fa4..9af78fef00f 100644
--- a/src/server/game/Entities/Object/Updates/UpdateFields.h
+++ b/src/server/game/Entities/Object/Updates/UpdateFields.h
@@ -256,7 +256,7 @@ struct PassiveSpellHistory : public IsUpdateFieldStructureTag
     bool operator!=(PassiveSpellHistory const& right) const { return !(*this == right); }
 };
 
-struct UnitData : public IsUpdateFieldStructureTag, public HasChangesMask<197>
+struct UnitData : public IsUpdateFieldStructureTag, public HasChangesMask<209>
 {
     UpdateField<std::vector<uint32>, 0, 1> StateWorldEffectIDs;
     DynamicUpdateField<UF::PassiveSpellHistory, 0, 2> PassiveSpells;
@@ -385,18 +385,18 @@ struct UnitData : public IsUpdateFieldStructureTag, public HasChangesMask<197>
     UpdateField<ObjectGuid, 96, 122> NameplateAttachToGUID;                     // When set, nameplate of this unit will instead appear on that object
     UpdateFieldArray<uint32, 2, 123, 124> NpcFlags;
     struct NpcFlagsTag : ViewerDependentValueTag<uint32> {};
-    UpdateFieldArray<int32, 7, 126, 127> Power;
-    UpdateFieldArray<int32, 7, 126, 134> MaxPower;
-    UpdateFieldArray<float, 7, 126, 141> PowerRegenFlatModifier;
-    UpdateFieldArray<float, 7, 126, 148> PowerRegenInterruptedFlatModifier;
-    UpdateFieldArray<UF::VisibleItem, 3, 155, 156> VirtualItems;
-    UpdateFieldArray<uint32, 2, 159, 160> AttackRoundBaseTime;
-    UpdateFieldArray<int32, 4, 162, 163> Stats;
-    UpdateFieldArray<int32, 4, 162, 167> StatPosBuff;
-    UpdateFieldArray<int32, 4, 162, 171> StatNegBuff;
-    UpdateFieldArray<int32, 7, 175, 176> Resistances;
-    UpdateFieldArray<int32, 7, 175, 183> BonusResistanceMods;
-    UpdateFieldArray<int32, 7, 175, 190> ManaCostModifier;
+    UpdateFieldArray<int32, 10, 126, 127> Power;
+    UpdateFieldArray<int32, 10, 126, 137> MaxPower;
+    UpdateFieldArray<float, 10, 126, 147> PowerRegenFlatModifier;
+    UpdateFieldArray<float, 10, 126, 157> PowerRegenInterruptedFlatModifier;
+    UpdateFieldArray<UF::VisibleItem, 3, 167, 168> VirtualItems;
+    UpdateFieldArray<uint32, 2, 171, 172> AttackRoundBaseTime;
+    UpdateFieldArray<int32, 4, 174, 175> Stats;
+    UpdateFieldArray<int32, 4, 174, 179> StatPosBuff;
+    UpdateFieldArray<int32, 4, 174, 183> StatNegBuff;
+    UpdateFieldArray<int32, 7, 187, 188> Resistances;
+    UpdateFieldArray<int32, 7, 187, 195> BonusResistanceMods;
+    UpdateFieldArray<int32, 7, 187, 202> ManaCostModifier;
 
     void WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Unit const* owner, Player const* receiver) const;
     void WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Unit const* owner, Player const* receiver) const;
@@ -458,7 +458,7 @@ struct CTROptions : public IsUpdateFieldStructureTag
     bool operator!=(CTROptions const& right) const { return !(*this == right); }
 };
 
-struct PlayerData : public IsUpdateFieldStructureTag, public HasChangesMask<240>
+struct PlayerData : public IsUpdateFieldStructureTag, public HasChangesMask<261>
 {
     UpdateField<bool, 0, 1> HasQuestSession;
     UpdateField<bool, 0, 2> HasLevelLink;
@@ -491,13 +491,15 @@ struct PlayerData : public IsUpdateFieldStructureTag, public HasChangesMask<240>
     UpdateField<int64, 0, 29> LogoutTime;
     UpdateField<int32, 0, 30> Field_B0;
     UpdateField<int32, 0, 31> Field_B4;
-    UpdateField<UF::CTROptions, 32, 33> CtrOptions;
-    UpdateField<int32, 32, 34> CovenantID;
-    UpdateField<int32, 32, 35> SoulbindID;
-    UpdateField<WorldPackets::MythicPlus::DungeonScoreSummary, 32, 36> DungeonScore;
-    UpdateFieldArray<UF::QuestLog, 175, 37, 38> QuestLog;
-    UpdateFieldArray<UF::VisibleItem, 19, 213, 214> VisibleItems;
-    UpdateFieldArray<float, 6, 233, 234> AvgItemLevel;
+    UpdateField<int32, 32, 33> CurrentBattlePetSpeciesID;
+    UpdateField<UF::CTROptions, 32, 34> CtrOptions;
+    UpdateField<int32, 32, 35> CovenantID;
+    UpdateField<int32, 32, 36> SoulbindID;
+    UpdateField<WorldPackets::MythicPlus::DungeonScoreSummary, 32, 37> DungeonScore;
+    UpdateFieldArray<UF::QuestLog, 175, 38, 39> QuestLog;
+    UpdateFieldArray<UF::VisibleItem, 19, 214, 215> VisibleItems;
+    UpdateFieldArray<float, 6, 234, 235> AvgItemLevel;
+    UpdateFieldArray<uint32, 19, 241, 242> Field_3120;
 
     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;
@@ -764,14 +766,36 @@ struct PersonalCraftingOrderCount : public IsUpdateFieldStructureTag
     bool operator!=(PersonalCraftingOrderCount const& right) const { return !(*this == right); }
 };
 
-struct ActivePlayerData : public IsUpdateFieldStructureTag, public HasChangesMask<1575>
+struct CategoryCooldownMod : public IsUpdateFieldStructureTag
+{
+    int32 SpellCategoryID;
+    int32 ModCooldown;
+
+    void WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const;
+    void WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const;
+    bool operator==(CategoryCooldownMod const& right) const;
+    bool operator!=(CategoryCooldownMod const& right) const { return !(*this == right); }
+};
+
+struct WeeklySpellUse : public IsUpdateFieldStructureTag
+{
+    int32 SpellCategoryID;
+    uint8 Uses;
+
+    void WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const;
+    void WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const;
+    bool operator==(WeeklySpellUse const& right) const;
+    bool operator!=(WeeklySpellUse const& right) const { return !(*this == right); }
+};
+
+struct ActivePlayerData : public IsUpdateFieldStructureTag, public HasChangesMask<1605>
 {
     UpdateField<bool, 0, 1> BackpackAutoSortDisabled;
     UpdateField<bool, 0, 2> BankAutoSortDisabled;
     UpdateField<bool, 0, 3> SortBagsRightToLeft;
     UpdateField<bool, 0, 4> InsertItemsLeftToRight;
     UpdateField<bool, 0, 5> HasPerksProgramPendingReward;
-    UpdateFieldArray<DynamicUpdateFieldBase<UF::Research>, 1, 32, 33> Research;
+    UpdateFieldArray<DynamicUpdateFieldBase<UF::Research>, 1, 35, 36> Research;
     DynamicUpdateField<uint64, 0, 6> KnownTitles;
     DynamicUpdateField<uint16, 0, 8> ResearchSites;
     DynamicUpdateField<uint32, 0, 9> ResearchSiteProgress;
@@ -794,110 +818,114 @@ struct ActivePlayerData : public IsUpdateFieldStructureTag, public HasChangesMas
     DynamicUpdateField<UF::ReplayedQuest, 0, 27> ReplayedQuests;
     DynamicUpdateField<int32, 0, 28> DisabledSpells;
     DynamicUpdateField<UF::PersonalCraftingOrderCount, 0, 31> PersonalCraftingOrderCounts;
+    DynamicUpdateField<UF::CategoryCooldownMod, 32, 33> CategoryCooldownMods;
+    DynamicUpdateField<UF::WeeklySpellUse, 32, 34> WeeklySpellUses;
     DynamicUpdateField<UF::PVPInfo, 0, 7> PvpInfo;
     DynamicUpdateField<UF::CharacterRestriction, 0, 21> CharacterRestrictions;
     DynamicUpdateField<UF::TraitConfig, 0, 29> TraitConfigs;
     DynamicUpdateField<UF::CraftingOrder, 0, 30> CraftingOrders;
-    UpdateField<ObjectGuid, 34, 35> FarsightObject;
-    UpdateField<ObjectGuid, 34, 36> SummonedBattlePetGUID;
-    UpdateField<uint64, 34, 37> Coinage;
-    UpdateField<int32, 34, 38> XP;
-    UpdateField<int32, 34, 39> NextLevelXP;
-    UpdateField<int32, 34, 40> TrialXP;
-    UpdateField<UF::SkillInfo, 34, 41> Skill;
-    UpdateField<int32, 34, 42> CharacterPoints;
-    UpdateField<int32, 34, 43> MaxTalentTiers;
-    UpdateField<uint32, 34, 44> TrackCreatureMask;
-    UpdateField<float, 34, 45> MainhandExpertise;
-    UpdateField<float, 34, 46> OffhandExpertise;
-    UpdateField<float, 34, 47> RangedExpertise;
-    UpdateField<float, 34, 48> CombatRatingExpertise;
-    UpdateField<float, 34, 49> BlockPercentage;
-    UpdateField<float, 34, 50> DodgePercentage;
-    UpdateField<float, 34, 51> DodgePercentageFromAttribute;
-    UpdateField<float, 34, 52> ParryPercentage;
-    UpdateField<float, 34, 53> ParryPercentageFromAttribute;
-    UpdateField<float, 34, 54> CritPercentage;
-    UpdateField<float, 34, 55> RangedCritPercentage;
-    UpdateField<float, 34, 56> OffhandCritPercentage;
-    UpdateField<float, 34, 57> SpellCritPercentage;
-    UpdateField<int32, 34, 58> ShieldBlock;
-    UpdateField<float, 34, 59> ShieldBlockCritPercentage;
-    UpdateField<float, 34, 60> Mastery;
-    UpdateField<float, 34, 61> Speed;
-    UpdateField<float, 34, 62> Avoidance;
-    UpdateField<float, 34, 63> Sturdiness;
-    UpdateField<int32, 34, 64> Versatility;
-    UpdateField<float, 34, 65> VersatilityBonus;
-    UpdateField<float, 66, 67> PvpPowerDamage;
-    UpdateField<float, 66, 68> PvpPowerHealing;
-    UpdateField<int32, 66, 69> ModHealingDonePos;
-    UpdateField<float, 66, 70> ModHealingPercent;
-    UpdateField<float, 66, 71> ModPeriodicHealingDonePercent;
-    UpdateField<float, 66, 72> ModSpellPowerPercent;
-    UpdateField<float, 66, 73> ModResiliencePercent;
-    UpdateField<float, 66, 74> OverrideSpellPowerByAPPercent;
-    UpdateField<float, 66, 75> OverrideAPBySpellPowerPercent;
-    UpdateField<int32, 66, 76> ModTargetResistance;
-    UpdateField<int32, 66, 77> ModTargetPhysicalResistance;
-    UpdateField<uint32, 66, 78> LocalFlags;
-    UpdateField<uint8, 66, 79> GrantableLevels;
-    UpdateField<uint8, 66, 80> MultiActionBars;
-    UpdateField<uint8, 66, 81> LifetimeMaxRank;
-    UpdateField<uint8, 66, 82> NumRespecs;
-    UpdateField<uint32, 66, 83> PvpMedals;
-    UpdateField<uint16, 66, 84> TodayHonorableKills;
-    UpdateField<uint16, 66, 85> YesterdayHonorableKills;
-    UpdateField<uint32, 66, 86> LifetimeHonorableKills;
-    UpdateField<int32, 66, 87> WatchedFactionIndex;
-    UpdateField<int32, 66, 88> MaxLevel;
-    UpdateField<int32, 66, 89> ScalingPlayerLevelDelta;
-    UpdateField<int32, 66, 90> MaxCreatureScalingLevel;
-    UpdateField<int32, 66, 91> PetSpellPower;
-    UpdateField<float, 66, 92> UiHitModifier;
-    UpdateField<float, 66, 93> UiSpellHitModifier;
-    UpdateField<int32, 66, 94> HomeRealmTimeOffset;
-    UpdateField<float, 66, 95> ModPetHaste;
-    UpdateField<int8, 66, 96> JailersTowerLevelMax;
-    UpdateField<int8, 66, 97> JailersTowerLevel;
-    UpdateField<uint8, 98, 99> LocalRegenFlags;
-    UpdateField<uint8, 98, 100> AuraVision;
-    UpdateField<uint8, 98, 101> NumBackpackSlots;
-    UpdateField<int32, 98, 102> OverrideSpellsID;
-    UpdateField<uint16, 98, 103> LootSpecID;
-    UpdateField<uint32, 98, 104> OverrideZonePVPType;
-    UpdateField<ObjectGuid, 98, 105> BnetAccount;
-    UpdateField<uint64, 98, 106> GuildClubMemberID;
-    UpdateField<int32, 98, 107> Honor;
-    UpdateField<int32, 98, 108> HonorNextLevel;
-    UpdateField<int32, 98, 109> PerksProgramCurrency;
-    UpdateField<uint8, 98, 110> NumBankSlots;
-    UpdateField<WorldPackets::PerksProgram::PerksVendorItem, 98, 111> FrozenPerksVendorItem;
-    UpdateField<UF::ActivePlayerUnk901, 98, 113> Field_1410;
-    OptionalUpdateField<UF::QuestSession, 98, 112> QuestSession;
-    UpdateField<int32, 98, 114> UiChromieTimeExpansionID;
-    UpdateField<int32, 98, 115> TransportServerTime;
-    UpdateField<uint32, 98, 116> WeeklyRewardsPeriodSinceOrigin;                // week count since Cfg_RegionsEntry::ChallengeOrigin
-    UpdateField<int16, 98, 117> DEBUGSoulbindConduitRank;
-    UpdateField<WorldPackets::MythicPlus::DungeonScoreData, 98, 118> DungeonScore;
-    UpdateField<uint32, 98, 119> ActiveCombatTraitConfigID;
-    UpdateFieldArray<ObjectGuid, 218, 120, 121> InvSlots;
-    UpdateFieldArray<uint64, 240, 339, 340> ExploredZones;
-    UpdateFieldArray<UF::RestInfo, 2, 580, 581> RestInfo;
-    UpdateFieldArray<int32, 7, 583, 584> ModDamageDonePos;
-    UpdateFieldArray<int32, 7, 583, 591> ModDamageDoneNeg;
-    UpdateFieldArray<float, 7, 583, 598> ModDamageDonePercent;
-    UpdateFieldArray<float, 7, 583, 605> ModHealingDonePercent;
-    UpdateFieldArray<float, 3, 612, 613> WeaponDmgMultipliers;
-    UpdateFieldArray<float, 3, 612, 616> WeaponAtkSpeedMultipliers;
-    UpdateFieldArray<uint32, 12, 619, 620> BuybackPrice;
-    UpdateFieldArray<int64, 12, 619, 632> BuybackTimestamp;
-    UpdateFieldArray<int32, 32, 644, 645> CombatRatings;
-    UpdateFieldArray<uint32, 4, 677, 678> NoReagentCostMask;
-    UpdateFieldArray<int32, 2, 682, 683> ProfessionSkillLine;
-    UpdateFieldArray<uint32, 5, 685, 686> BagSlotFlags;
-    UpdateFieldArray<uint32, 7, 691, 692> BankBagSlotFlags;
-    UpdateFieldArray<uint64, 875, 699, 700> QuestCompleted;
+    UpdateField<ObjectGuid, 32, 37> FarsightObject;
+    UpdateField<ObjectGuid, 32, 38> SummonedBattlePetGUID;
+    UpdateField<uint64, 32, 39> Coinage;
+    UpdateField<int32, 32, 40> XP;
+    UpdateField<int32, 32, 41> NextLevelXP;
+    UpdateField<int32, 32, 42> TrialXP;
+    UpdateField<UF::SkillInfo, 32, 43> Skill;
+    UpdateField<int32, 32, 44> CharacterPoints;
+    UpdateField<int32, 32, 45> MaxTalentTiers;
+    UpdateField<uint32, 32, 46> TrackCreatureMask;
+    UpdateField<float, 32, 47> MainhandExpertise;
+    UpdateField<float, 32, 48> OffhandExpertise;
+    UpdateField<float, 32, 49> RangedExpertise;
+    UpdateField<float, 32, 50> CombatRatingExpertise;
+    UpdateField<float, 32, 51> BlockPercentage;
+    UpdateField<float, 32, 52> DodgePercentage;
+    UpdateField<float, 32, 53> DodgePercentageFromAttribute;
+    UpdateField<float, 32, 54> ParryPercentage;
+    UpdateField<float, 32, 55> ParryPercentageFromAttribute;
+    UpdateField<float, 32, 56> CritPercentage;
+    UpdateField<float, 32, 57> RangedCritPercentage;
+    UpdateField<float, 32, 58> OffhandCritPercentage;
+    UpdateField<float, 32, 59> SpellCritPercentage;
+    UpdateField<int32, 32, 60> ShieldBlock;
+    UpdateField<float, 32, 61> ShieldBlockCritPercentage;
+    UpdateField<float, 32, 62> Mastery;
+    UpdateField<float, 32, 63> Speed;
+    UpdateField<float, 32, 64> Avoidance;
+    UpdateField<float, 32, 65> Sturdiness;
+    UpdateField<int32, 66, 67> Versatility;
+    UpdateField<float, 66, 68> VersatilityBonus;
+    UpdateField<float, 66, 69> PvpPowerDamage;
+    UpdateField<float, 66, 70> PvpPowerHealing;
+    UpdateField<int32, 66, 71> ModHealingDonePos;
+    UpdateField<float, 66, 72> ModHealingPercent;
+    UpdateField<float, 66, 73> ModPeriodicHealingDonePercent;
+    UpdateField<float, 66, 74> ModSpellPowerPercent;
+    UpdateField<float, 66, 75> ModResiliencePercent;
+    UpdateField<float, 66, 76> OverrideSpellPowerByAPPercent;
+    UpdateField<float, 66, 77> OverrideAPBySpellPowerPercent;
+    UpdateField<int32, 66, 78> ModTargetResistance;
+    UpdateField<int32, 66, 79> ModTargetPhysicalResistance;
+    UpdateField<uint32, 66, 80> LocalFlags;
+    UpdateField<uint8, 66, 81> GrantableLevels;
+    UpdateField<uint8, 66, 82> MultiActionBars;
+    UpdateField<uint8, 66, 83> LifetimeMaxRank;
+    UpdateField<uint8, 66, 84> NumRespecs;
+    UpdateField<uint32, 66, 85> PvpMedals;
+    UpdateField<uint16, 66, 86> TodayHonorableKills;
+    UpdateField<uint16, 66, 87> YesterdayHonorableKills;
+    UpdateField<uint32, 66, 88> LifetimeHonorableKills;
+    UpdateField<int32, 66, 89> WatchedFactionIndex;
+    UpdateField<int32, 66, 90> MaxLevel;
+    UpdateField<int32, 66, 91> ScalingPlayerLevelDelta;
+    UpdateField<int32, 66, 92> MaxCreatureScalingLevel;
+    UpdateField<int32, 66, 93> PetSpellPower;
+    UpdateField<float, 66, 94> UiHitModifier;
+    UpdateField<float, 66, 95> UiSpellHitModifier;
+    UpdateField<int32, 66, 96> HomeRealmTimeOffset;
+    UpdateField<float, 66, 97> ModPetHaste;
+    UpdateField<int8, 98, 99> JailersTowerLevelMax;
+    UpdateField<int8, 98, 100> JailersTowerLevel;
+    UpdateField<uint8, 98, 101> LocalRegenFlags;
+    UpdateField<uint8, 98, 102> AuraVision;
+    UpdateField<uint8, 98, 103> NumBackpackSlots;
+    UpdateField<int32, 98, 104> OverrideSpellsID;
+    UpdateField<uint16, 98, 105> LootSpecID;
+    UpdateField<uint32, 98, 106> OverrideZonePVPType;
+    UpdateField<ObjectGuid, 98, 107> BnetAccount;
+    UpdateField<uint64, 98, 108> GuildClubMemberID;
+    UpdateField<int32, 98, 109> Honor;
+    UpdateField<int32, 98, 110> HonorNextLevel;
+    UpdateField<int32, 98, 111> PerksProgramCurrency;
+    UpdateField<uint8, 98, 112> NumBankSlots;
+    UpdateField<WorldPackets::PerksProgram::PerksVendorItem, 98, 113> FrozenPerksVendorItem;
+    UpdateField<UF::ActivePlayerUnk901, 98, 115> Field_1410;
+    OptionalUpdateField<UF::QuestSession, 98, 114> QuestSession;
+    UpdateField<int32, 98, 116> UiChromieTimeExpansionID;
+    UpdateField<int32, 98, 117> TransportServerTime;
+    UpdateField<uint32, 98, 118> WeeklyRewardsPeriodSinceOrigin;                // week count since Cfg_RegionsEntry::ChallengeOrigin
+    UpdateField<int16, 98, 119> DEBUGSoulbindConduitRank;
+    UpdateField<WorldPackets::MythicPlus::DungeonScoreData, 98, 120> DungeonScore;
+    UpdateField<uint32, 98, 121> ActiveCombatTraitConfigID;
+    UpdateField<uint64, 98, 122> LootHistoryInstanceID;
+    UpdateFieldArray<ObjectGuid, 227, 123, 124> InvSlots;
+    UpdateFieldArray<uint64, 240, 351, 352> ExploredZones;
+    UpdateFieldArray<UF::RestInfo, 2, 592, 593> RestInfo;
+    UpdateFieldArray<int32, 7, 595, 596> ModDamageDonePos;
+    UpdateFieldArray<int32, 7, 595, 603> ModDamageDoneNeg;
+    UpdateFieldArray<float, 7, 595, 610> ModDamageDonePercent;
+    UpdateFieldArray<float, 7, 595, 617> ModHealingDonePercent;
+    UpdateFieldArray<float, 3, 624, 625> WeaponDmgMultipliers;
+    UpdateFieldArray<float, 3, 624, 628> WeaponAtkSpeedMultipliers;
+    UpdateFieldArray<uint32, 12, 631, 632> BuybackPrice;
+    UpdateFieldArray<int64, 12, 631, 644> BuybackTimestamp;
+    UpdateFieldArray<int32, 32, 656, 657> CombatRatings;
+    UpdateFieldArray<uint32, 4, 689, 690> NoReagentCostMask;
+    UpdateFieldArray<int32, 2, 694, 695> ProfessionSkillLine;
+    UpdateFieldArray<uint32, 5, 697, 698> BagSlotFlags;
+    UpdateFieldArray<uint32, 7, 703, 704> BankBagSlotFlags;
+    UpdateFieldArray<uint64, 875, 711, 712> QuestCompleted;
+    UpdateFieldArray<float, 17, 1587, 1588> 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;
@@ -1001,30 +1029,32 @@ struct VisualAnim : public IsUpdateFieldStructureTag, public HasChangesMask<5>
     void ClearChangesMask();
 };
 
-struct AreaTriggerData : public IsUpdateFieldStructureTag, public HasChangesMask<23>
+struct AreaTriggerData : public IsUpdateFieldStructureTag, public HasChangesMask<25>
 {
-    UpdateField<UF::ScaleCurve, 0, 1> OverrideScaleCurve;
-    UpdateField<UF::ScaleCurve, 0, 2> ExtraScaleCurve;
-    UpdateField<UF::ScaleCurve, 0, 3> Field_C38;
-    UpdateField<UF::ScaleCurve, 0, 4> Field_C54;
-    UpdateField<UF::ScaleCurve, 0, 5> Field_C70;
-    UpdateField<ObjectGuid, 0, 6> Caster;
-    UpdateField<uint32, 0, 7> Duration;
-    UpdateField<uint32, 0, 8> TimeToTarget;
-    UpdateField<uint32, 0, 9> TimeToTargetScale;
-    UpdateField<uint32, 0, 10> TimeToTargetExtraScale;
-    UpdateField<uint32, 0, 11> Field_B0;
-    UpdateField<int32, 0, 12> SpellID;
-    UpdateField<int32, 0, 13> SpellForVisuals;
-    UpdateField<UF::SpellCastVisual, 0, 14> SpellVisual;
-    UpdateField<float, 0, 15> BoundsRadius2D;
-    UpdateField<uint32, 0, 16> DecalPropertiesID;
-    UpdateField<ObjectGuid, 0, 17> CreatingEffectGUID;
-    UpdateField<uint32, 0, 18> Field_80;
-    UpdateField<uint32, 0, 19> Field_84;
-    UpdateField<ObjectGuid, 0, 20> Field_88;
-    UpdateField<TaggedPosition<Position::XYZ>, 0, 21> Field_F8;
-    UpdateField<UF::VisualAnim, 0, 22> VisualAnim;
+    UpdateField<bool, 0, 1> Field_260;
+    UpdateField<bool, 0, 2> Field_261;
+    UpdateField<UF::ScaleCurve, 0, 3> OverrideScaleCurve;
+    UpdateField<UF::ScaleCurve, 0, 4> ExtraScaleCurve;
+    UpdateField<UF::ScaleCurve, 0, 5> Field_C38;
+    UpdateField<UF::ScaleCurve, 0, 6> Field_C54;
+    UpdateField<UF::ScaleCurve, 0, 7> Field_C70;
+    UpdateField<ObjectGuid, 0, 8> Caster;
+    UpdateField<uint32, 0, 9> Duration;
+    UpdateField<uint32, 0, 10> TimeToTarget;
+    UpdateField<uint32, 0, 11> TimeToTargetScale;
+    UpdateField<uint32, 0, 12> TimeToTargetExtraScale;
+    UpdateField<uint32, 0, 13> Field_B0;
+    UpdateField<int32, 0, 14> SpellID;
+    UpdateField<int32, 0, 15> SpellForVisuals;
+    UpdateField<UF::SpellCastVisual, 0, 16> SpellVisual;
+    UpdateField<float, 0, 17> BoundsRadius2D;
+    UpdateField<uint32, 0, 18> DecalPropertiesID;
+    UpdateField<ObjectGuid, 0, 19> CreatingEffectGUID;
+    UpdateField<uint32, 0, 20> Field_80;
+    UpdateField<uint32, 0, 21> Field_84;
+    UpdateField<ObjectGuid, 0, 22> Field_88;
+    UpdateField<TaggedPosition<Position::XYZ>, 0, 23> Field_F8;
+    UpdateField<UF::VisualAnim, 0, 24> VisualAnim;
 
     void WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, AreaTrigger const* owner, Player const* receiver) const;
     void WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, AreaTrigger const* owner, Player const* receiver) const;