Core: Update to 10.2.7

2 files changed, 444 insertions, 358 deletions

diff --git a/src/server/game/Entities/Object/Updates/UpdateFields.cpp b/src/server/game/Entities/Object/Updates/UpdateFields.cpp
index e05e49e5903..924820bd8ce 100644
--- a/src/server/game/Entities/Object/Updates/UpdateFields.cpp
+++ b/src/server/game/Entities/Object/Updates/UpdateFields.cpp
@@ -989,8 +989,6 @@ void UnitData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisi
     data << int32(ScalingLevelMax);
     data << int32(ScalingLevelDelta);
     data << int32(ScalingFactionGroup);
-    data << int32(ScalingHealthItemLevelCurveID);
-    data << int32(ScalingDamageItemLevelCurveID);
     data << int32(ViewerDependentValue<FactionTemplateTag>::GetValue(this, owner, receiver));
     for (uint32 i = 0; i < 3; ++i)
     {
@@ -1118,6 +1116,8 @@ void UnitData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisi
     data << uint32(ChannelObjects.size());
     data << int32(FlightCapabilityID);
     data << float(GlideEventSpeedDivisor);
+    data << uint32(Field_308);
+    data << uint32(Field_30C);
     data << uint32(SilencedSchoolMask);
     data << uint32(CurrentAreaID);
     data << NameplateAttachToGUID;
@@ -1137,7 +1137,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, 0xFFFFFC01u, 0x007FFFFFu, 0x0003F800u, 0x00000000u });
+    Mask allowedMaskForTarget({ 0xFFFFDFFFu, 0xF0FFBFFFu, 0x000F7FFFu, 0xFFFFFF01u, 0x007FFFFFu, 0x0003F800u, 0x00000000u });
     AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
     WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver);
 }
@@ -1145,16 +1145,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, 0x000003FEu, 0xFF800004u, 0xFFFC07FFu, 0x01FFFFFFu };
+        allowedMaskForTarget |= { 0x00002000u, 0x0F004000u, 0xFFF08000u, 0x000000FEu, 0xFF800004u, 0xFFFC07FFu, 0x01FFFFFFu };
     if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::UnitAll))
         allowedMaskForTarget |= { 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0xFF800004u, 0x000007FFu, 0x00000000u };
     if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Empath))
-        allowedMaskForTarget |= { 0x00000000u, 0x3C000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x000007F8u };
+        allowedMaskForTarget |= { 0x00000000u, 0x0F000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x000007F8u };
 }
 
 void UnitData::FilterDisallowedFieldsMaskForFlag(Mask& changesMask, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
 {
-    Mask allowedMaskForTarget({ 0xFFFFDFFFu, 0xC3FEFFFFu, 0x003DFFFFu, 0xFFFFFC01u, 0x007FFFFFu, 0x0003F800u, 0x00000000u });
+    Mask allowedMaskForTarget({ 0xFFFFDFFFu, 0xF0FFBFFFu, 0x000F7FFFu, 0xFFFFFF01u, 0x007FFFFFu, 0x0003F800u, 0x00000000u });
     AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
     changesMask &= allowedMaskForTarget;
 }
@@ -1380,333 +1380,333 @@ void UnitData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignor
         }
         if (changesMask[41])
         {
-            data << int32(ScalingHealthItemLevelCurveID);
+            data << int32(ViewerDependentValue<FactionTemplateTag>::GetValue(this, owner, receiver));
         }
         if (changesMask[42])
         {
-            data << int32(ScalingDamageItemLevelCurveID);
+            data << uint32(ViewerDependentValue<FlagsTag>::GetValue(this, owner, receiver));
         }
         if (changesMask[43])
         {
-            data << int32(ViewerDependentValue<FactionTemplateTag>::GetValue(this, owner, receiver));
+            data << uint32(Flags2);
         }
         if (changesMask[44])
         {
-            data << uint32(ViewerDependentValue<FlagsTag>::GetValue(this, owner, receiver));
+            data << uint32(ViewerDependentValue<Flags3Tag>::GetValue(this, owner, receiver));
         }
         if (changesMask[45])
         {
-            data << uint32(Flags2);
+            data << uint32(ViewerDependentValue<AuraStateTag>::GetValue(this, owner, receiver));
         }
         if (changesMask[46])
         {
-            data << uint32(ViewerDependentValue<Flags3Tag>::GetValue(this, owner, receiver));
+            data << uint32(RangedAttackRoundBaseTime);
         }
         if (changesMask[47])
         {
-            data << uint32(ViewerDependentValue<AuraStateTag>::GetValue(this, owner, receiver));
+            data << float(BoundingRadius);
         }
         if (changesMask[48])
         {
-            data << uint32(RangedAttackRoundBaseTime);
+            data << float(CombatReach);
         }
         if (changesMask[49])
         {
-            data << float(BoundingRadius);
+            data << float(DisplayScale);
         }
         if (changesMask[50])
         {
-            data << float(CombatReach);
+            data << int32(CreatureFamily);
         }
         if (changesMask[51])
         {
-            data << float(DisplayScale);
+            data << int32(CreatureType);
         }
         if (changesMask[52])
         {
-            data << int32(CreatureFamily);
+            data << int32(NativeDisplayID);
         }
         if (changesMask[53])
         {
-            data << int32(CreatureType);
+            data << float(NativeXDisplayScale);
         }
         if (changesMask[54])
         {
-            data << int32(NativeDisplayID);
+            data << int32(MountDisplayID);
         }
         if (changesMask[55])
         {
-            data << float(NativeXDisplayScale);
+            data << int32(CosmeticMountDisplayID);
         }
         if (changesMask[56])
         {
-            data << int32(MountDisplayID);
+            data << float(MinDamage);
         }
         if (changesMask[57])
         {
-            data << int32(CosmeticMountDisplayID);
+            data << float(MaxDamage);
         }
         if (changesMask[58])
         {
-            data << float(MinDamage);
+            data << float(MinOffHandDamage);
         }
         if (changesMask[59])
         {
-            data << float(MaxDamage);
+            data << float(MaxOffHandDamage);
         }
         if (changesMask[60])
         {
-            data << float(MinOffHandDamage);
+            data << uint8(StandState);
         }
         if (changesMask[61])
         {
-            data << float(MaxOffHandDamage);
+            data << uint8(PetTalentPoints);
         }
         if (changesMask[62])
         {
-            data << uint8(StandState);
+            data << uint8(VisFlags);
         }
         if (changesMask[63])
         {
-            data << uint8(PetTalentPoints);
+            data << uint8(AnimTier);
         }
     }
     if (changesMask[64])
     {
         if (changesMask[65])
         {
-            data << uint8(VisFlags);
+            data << uint32(PetNumber);
         }
         if (changesMask[66])
         {
-            data << uint8(AnimTier);
+            data << uint32(PetNameTimestamp);
         }
         if (changesMask[67])
         {
-            data << uint32(PetNumber);
+            data << uint32(PetExperience);
         }
         if (changesMask[68])
         {
-            data << uint32(PetNameTimestamp);
+            data << uint32(PetNextLevelExperience);
         }
         if (changesMask[69])
         {
-            data << uint32(PetExperience);
+            data << float(ModCastingSpeed);
         }
         if (changesMask[70])
         {
-            data << uint32(PetNextLevelExperience);
+            data << float(ModCastingSpeedNeg);
         }
         if (changesMask[71])
         {
-            data << float(ModCastingSpeed);
+            data << float(ModSpellHaste);
         }
         if (changesMask[72])
         {
-            data << float(ModCastingSpeedNeg);
+            data << float(ModHaste);
         }
         if (changesMask[73])
         {
-            data << float(ModSpellHaste);
+            data << float(ModRangedHaste);
         }
         if (changesMask[74])
         {
-            data << float(ModHaste);
+            data << float(ModHasteRegen);
         }
         if (changesMask[75])
         {
-            data << float(ModRangedHaste);
+            data << float(ModTimeRate);
         }
         if (changesMask[76])
         {
-            data << float(ModHasteRegen);
+            data << int32(CreatedBySpell);
         }
         if (changesMask[77])
         {
-            data << float(ModTimeRate);
+            data << int32(EmoteState);
         }
         if (changesMask[78])
         {
-            data << int32(CreatedBySpell);
+            data << int32(BaseMana);
         }
         if (changesMask[79])
         {
-            data << int32(EmoteState);
+            data << int32(BaseHealth);
         }
         if (changesMask[80])
         {
-            data << int32(BaseMana);
+            data << uint8(SheatheState);
         }
         if (changesMask[81])
         {
-            data << int32(BaseHealth);
+            data << uint8(ViewerDependentValue<PvpFlagsTag>::GetValue(this, owner, receiver));
         }
         if (changesMask[82])
         {
-            data << uint8(SheatheState);
+            data << uint8(PetFlags);
         }
         if (changesMask[83])
         {
-            data << uint8(ViewerDependentValue<PvpFlagsTag>::GetValue(this, owner, receiver));
+            data << uint8(ShapeshiftForm);
         }
         if (changesMask[84])
         {
-            data << uint8(PetFlags);
+            data << int32(AttackPower);
         }
         if (changesMask[85])
         {
-            data << uint8(ShapeshiftForm);
+            data << int32(AttackPowerModPos);
         }
         if (changesMask[86])
         {
-            data << int32(AttackPower);
+            data << int32(AttackPowerModNeg);
         }
         if (changesMask[87])
         {
-            data << int32(AttackPowerModPos);
+            data << float(AttackPowerMultiplier);
         }
         if (changesMask[88])
         {
-            data << int32(AttackPowerModNeg);
+            data << int32(AttackPowerModSupport);
         }
         if (changesMask[89])
         {
-            data << float(AttackPowerMultiplier);
+            data << int32(RangedAttackPower);
         }
         if (changesMask[90])
         {
-            data << int32(AttackPowerModSupport);
+            data << int32(RangedAttackPowerModPos);
         }
         if (changesMask[91])
         {
-            data << int32(RangedAttackPower);
+            data << int32(RangedAttackPowerModNeg);
         }
         if (changesMask[92])
         {
-            data << int32(RangedAttackPowerModPos);
+            data << float(RangedAttackPowerMultiplier);
         }
         if (changesMask[93])
         {
-            data << int32(RangedAttackPowerModNeg);
+            data << int32(RangedAttackPowerModSupport);
         }
         if (changesMask[94])
         {
-            data << float(RangedAttackPowerMultiplier);
+            data << int32(MainHandWeaponAttackPower);
         }
         if (changesMask[95])
         {
-            data << int32(RangedAttackPowerModSupport);
+            data << int32(OffHandWeaponAttackPower);
         }
     }
     if (changesMask[96])
     {
         if (changesMask[97])
         {
-            data << int32(MainHandWeaponAttackPower);
+            data << int32(RangedWeaponAttackPower);
         }
         if (changesMask[98])
         {
-            data << int32(OffHandWeaponAttackPower);
+            data << int32(SetAttackSpeedAura);
         }
         if (changesMask[99])
         {
-            data << int32(RangedWeaponAttackPower);
+            data << float(Lifesteal);
         }
         if (changesMask[100])
         {
-            data << int32(SetAttackSpeedAura);
+            data << float(MinRangedDamage);
         }
         if (changesMask[101])
         {
-            data << float(Lifesteal);
+            data << float(MaxRangedDamage);
         }
         if (changesMask[102])
         {
-            data << float(MinRangedDamage);
+            data << float(ManaCostMultiplier);
         }
         if (changesMask[103])
         {
-            data << float(MaxRangedDamage);
+            data << float(MaxHealthModifier);
         }
         if (changesMask[104])
         {
-            data << float(ManaCostMultiplier);
+            data << float(HoverHeight);
         }
         if (changesMask[105])
         {
-            data << float(MaxHealthModifier);
+            data << int32(MinItemLevelCutoff);
         }
         if (changesMask[106])
         {
-            data << float(HoverHeight);
+            data << int32(MinItemLevel);
         }
         if (changesMask[107])
         {
-            data << int32(MinItemLevelCutoff);
+            data << int32(MaxItemLevel);
         }
         if (changesMask[108])
         {
-            data << int32(MinItemLevel);
+            data << int32(AzeriteItemLevel);
         }
         if (changesMask[109])
         {
-            data << int32(MaxItemLevel);
+            data << int32(WildBattlePetLevel);
         }
         if (changesMask[110])
         {
-            data << int32(AzeriteItemLevel);
+            data << int32(BattlePetCompanionExperience);
         }
         if (changesMask[111])
         {
-            data << int32(WildBattlePetLevel);
+            data << uint32(BattlePetCompanionNameTimestamp);
         }
         if (changesMask[112])
         {
-            data << int32(BattlePetCompanionExperience);
+            data << int32(ViewerDependentValue<InteractSpellIDTag>::GetValue(this, owner, receiver));
         }
         if (changesMask[113])
         {
-            data << uint32(BattlePetCompanionNameTimestamp);
+            data << int32(ScaleDuration);
         }
         if (changesMask[114])
         {
-            data << int32(ViewerDependentValue<InteractSpellIDTag>::GetValue(this, owner, receiver));
+            data << int32(LooksLikeMountID);
         }
         if (changesMask[115])
         {
-            data << int32(ScaleDuration);
+            data << int32(LooksLikeCreatureID);
         }
         if (changesMask[116])
         {
-            data << int32(LooksLikeMountID);
+            data << int32(LookAtControllerID);
         }
         if (changesMask[117])
         {
-            data << int32(LooksLikeCreatureID);
+            data << int32(PerksVendorItemID);
         }
         if (changesMask[118])
         {
-            data << int32(LookAtControllerID);
+            data << int32(TaxiNodesID);
         }
         if (changesMask[119])
         {
-            data << int32(PerksVendorItemID);
+            data << GuildGUID;
         }
         if (changesMask[120])
         {
-            data << int32(TaxiNodesID);
+            data << int32(FlightCapabilityID);
         }
         if (changesMask[121])
         {
-            data << GuildGUID;
+            data << float(GlideEventSpeedDivisor);
         }
         if (changesMask[122])
         {
-            data << int32(FlightCapabilityID);
+            data << uint32(Field_308);
         }
         if (changesMask[123])
         {
-            data << float(GlideEventSpeedDivisor);
+            data << uint32(Field_30C);
         }
         if (changesMask[124])
         {
@@ -1856,8 +1856,6 @@ void UnitData::ClearChangesMask()
     Base::ClearChangesMask(ScalingLevelMax);
     Base::ClearChangesMask(ScalingLevelDelta);
     Base::ClearChangesMask(ScalingFactionGroup);
-    Base::ClearChangesMask(ScalingHealthItemLevelCurveID);
-    Base::ClearChangesMask(ScalingDamageItemLevelCurveID);
     Base::ClearChangesMask(FactionTemplate);
     Base::ClearChangesMask(Flags);
     Base::ClearChangesMask(Flags2);
@@ -1937,6 +1935,8 @@ void UnitData::ClearChangesMask()
     Base::ClearChangesMask(GuildGUID);
     Base::ClearChangesMask(FlightCapabilityID);
     Base::ClearChangesMask(GlideEventSpeedDivisor);
+    Base::ClearChangesMask(Field_308);
+    Base::ClearChangesMask(Field_30C);
     Base::ClearChangesMask(SilencedSchoolMask);
     Base::ClearChangesMask(CurrentAreaID);
     Base::ClearChangesMask(NameplateAttachToGUID);
@@ -2104,6 +2104,45 @@ void ArenaCooldown::ClearChangesMask()
     _changesMask.ResetAll();
 }
 
+void PetCreatureName::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
+{
+    data << uint32(CreatureID);
+    data.WriteBits(Name->size(), 8);
+    data.WriteString(Name);
+    data.FlushBits();
+}
+
+void PetCreatureName::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
+{
+    Mask changesMask = _changesMask;
+    if (ignoreChangesMask)
+        changesMask.SetAll();
+
+    data.WriteBits(changesMask.GetBlock(0), 3);
+
+    data.FlushBits();
+    if (changesMask[0])
+    {
+        if (changesMask[1])
+        {
+            data << uint32(CreatureID);
+        }
+        if (changesMask[2])
+        {
+            data.WriteBits(Name->size(), 8);
+            data.WriteString(Name);
+        }
+    }
+    data.FlushBits();
+}
+
+void PetCreatureName::ClearChangesMask()
+{
+    Base::ClearChangesMask(CreatureID);
+    Base::ClearChangesMask(Name);
+    _changesMask.ResetAll();
+}
+
 void CTROptions::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
 {
     data << int32(ContentTuningConditionMask);
@@ -2285,6 +2324,7 @@ void PlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVi
     data << int32(Field_1AC);
     data << int32(Field_1B0);
     data << int32(CurrentBattlePetSpeciesID);
+    data << uint32(PetNames.size());
     CtrOptions->WriteCreate(data, owner, receiver);
     data << int32(CovenantID);
     data << int32(SoulbindID);
@@ -2333,6 +2373,10 @@ void PlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVi
     {
         data << VisibleEquipableSpells[i];
     }
+    for (uint32 i = 0; i < PetNames.size(); ++i)
+    {
+        PetNames[i].WriteCreate(data, owner, receiver);
+    }
     if (DeclinedNames.has_value())
     {
         DeclinedNames->WriteCreate(data, owner, receiver);
@@ -2342,7 +2386,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({ 0xFFFFFFDDu, 0x0000FFFFu, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0xFFFFFFFFu, 0xFFFFFFFFu });
+    Mask allowedMaskForTarget({ 0xFFFFFFDDu, 0x0001FFFFu, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0xFFFFFFFEu, 0xFFFFFFFFu, 0x00000001u });
     AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
     WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver);
 }
@@ -2350,20 +2394,20 @@ void PlayerData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVi
 void PlayerData::AppendAllowedFieldsMaskForFlag(Mask& allowedMaskForTarget, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
 {
     if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::PartyMember))
-        allowedMaskForTarget |= { 0x00000022u, 0xFFFF0000u, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0x00000000u, 0x00000000u };
+        allowedMaskForTarget |= { 0x00000022u, 0xFFFE0000u, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0x00000001u, 0x00000000u, 0x00000000u };
 }
 
 void PlayerData::FilterDisallowedFieldsMaskForFlag(Mask& changesMask, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
 {
-    Mask allowedMaskForTarget({ 0xFFFFFFDDu, 0x0000FFFFu, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0xFFFFFFFFu, 0xFFFFFFFFu });
+    Mask allowedMaskForTarget({ 0xFFFFFFDDu, 0x0001FFFFu, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0xFFFFFFFEu, 0xFFFFFFFFu, 0x00000001u });
     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), 9);
-    for (uint32 i = 0; i < 9; ++i)
+    data.WriteBits(changesMask.GetBlocksMask(0), 10);
+    for (uint32 i = 0; i < 10; ++i)
         if (changesMask.GetBlock(i))
             data.WriteBits(changesMask.GetBlock(i), 32);
 
@@ -2409,6 +2453,13 @@ void PlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ign
         if (changesMask[7])
         {
             if (!ignoreNestedChangesMask)
+                PetNames.WriteUpdateMask(data);
+            else
+                WriteCompleteDynamicFieldUpdateMask(PetNames.size(), data);
+        }
+        if (changesMask[8])
+        {
+            if (!ignoreNestedChangesMask)
                 VisualItemReplacements.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(VisualItemReplacements.size(), data);
@@ -2460,7 +2511,7 @@ void PlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ign
                 }
             }
         }
-        if (changesMask[7])
+        if (changesMask[8])
         {
             for (uint32 i = 0; i < VisualItemReplacements.size(); ++i)
             {
@@ -2470,156 +2521,166 @@ void PlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ign
                 }
             }
         }
-        if (changesMask[8])
+        if (changesMask[7])
         {
-            data << DuelArbiter;
+            for (uint32 i = 0; i < PetNames.size(); ++i)
+            {
+                if (PetNames.HasChanged(i) || ignoreNestedChangesMask)
+                {
+                    PetNames[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
+                }
+            }
         }
         if (changesMask[9])
         {
-            data << WowAccount;
+            data << DuelArbiter;
         }
         if (changesMask[10])
         {
-            data << BnetAccount;
+            data << WowAccount;
         }
         if (changesMask[11])
         {
-            data << uint64(GuildClubMemberID);
+            data << BnetAccount;
         }
         if (changesMask[12])
         {
-            data << LootTargetGUID;
+            data << uint64(GuildClubMemberID);
         }
         if (changesMask[13])
         {
-            data << uint32(PlayerFlags);
+            data << LootTargetGUID;
         }
         if (changesMask[14])
         {
-            data << uint32(PlayerFlagsEx);
+            data << uint32(PlayerFlags);
         }
         if (changesMask[15])
         {
-            data << uint32(GuildRankID);
+            data << uint32(PlayerFlagsEx);
         }
         if (changesMask[16])
         {
-            data << uint32(GuildDeleteDate);
+            data << uint32(GuildRankID);
         }
         if (changesMask[17])
         {
-            data << int32(GuildLevel);
+            data << uint32(GuildDeleteDate);
         }
         if (changesMask[18])
         {
-            data << uint8(NativeSex);
+            data << int32(GuildLevel);
         }
         if (changesMask[19])
         {
-            data << uint8(Inebriation);
+            data << uint8(NativeSex);
         }
         if (changesMask[20])
         {
-            data << uint8(PvpTitle);
+            data << uint8(Inebriation);
         }
         if (changesMask[21])
         {
-            data << uint8(ArenaFaction);
+            data << uint8(PvpTitle);
         }
         if (changesMask[22])
         {
-            data << uint32(DuelTeam);
+            data << uint8(ArenaFaction);
         }
         if (changesMask[23])
         {
-            data << int32(GuildTimeStamp);
+            data << uint32(DuelTeam);
         }
         if (changesMask[24])
         {
-            data << int32(PlayerTitle);
+            data << int32(GuildTimeStamp);
         }
         if (changesMask[25])
         {
-            data << int32(FakeInebriation);
+            data << int32(PlayerTitle);
         }
         if (changesMask[26])
         {
-            data << uint32(VirtualPlayerRealm);
+            data << int32(FakeInebriation);
         }
         if (changesMask[27])
         {
-            data << uint32(CurrentSpecID);
+            data << uint32(VirtualPlayerRealm);
         }
         if (changesMask[28])
         {
-            data << int32(TaxiMountAnimKitID);
+            data << uint32(CurrentSpecID);
         }
         if (changesMask[29])
         {
-            data << uint8(CurrentBattlePetBreedQuality);
+            data << int32(TaxiMountAnimKitID);
         }
         if (changesMask[30])
         {
-            data << int32(HonorLevel);
+            data << uint8(CurrentBattlePetBreedQuality);
         }
         if (changesMask[31])
         {
-            data << int64(LogoutTime);
+            data << int32(HonorLevel);
         }
     }
     if (changesMask[32])
     {
-        if (changesMask[34])
+        if (changesMask[33])
         {
-            data << int32(Field_1AC);
+            data << int64(LogoutTime);
         }
         if (changesMask[35])
         {
-            data << int32(Field_1B0);
+            data << int32(Field_1AC);
         }
         if (changesMask[36])
         {
-            data << int32(CurrentBattlePetSpeciesID);
+            data << int32(Field_1B0);
         }
         if (changesMask[37])
         {
-            CtrOptions->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
+            data << int32(CurrentBattlePetSpeciesID);
         }
         if (changesMask[38])
         {
-            data << int32(CovenantID);
+            CtrOptions->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
         if (changesMask[39])
         {
+            data << int32(CovenantID);
+        }
+        if (changesMask[40])
+        {
             data << int32(SoulbindID);
         }
-        if (changesMask[41])
+        if (changesMask[42])
         {
             data << SpectateTarget;
         }
-        if (changesMask[42])
+        if (changesMask[43])
         {
             data << int32(Field_200);
         }
-        if (changesMask[44])
+        if (changesMask[45])
         {
             PersonalTabard->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
-        if (changesMask[33])
+        if (changesMask[34])
         {
             data.WriteBits(Name->size(), 6);
         }
         data.WriteBits(DeclinedNames.has_value(), 1);
         data.FlushBits();
-        if (changesMask[40])
+        if (changesMask[41])
         {
             data << DungeonScore;
         }
-        if (changesMask[33])
+        if (changesMask[34])
         {
             data.WriteString(Name);
         }
-        if (changesMask[43])
+        if (changesMask[44])
         {
             if (DeclinedNames.has_value())
             {
@@ -2627,21 +2688,21 @@ void PlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ign
             }
         }
     }
-    if (changesMask[45])
+    if (changesMask[46])
     {
         for (uint32 i = 0; i < 2; ++i)
         {
-            if (changesMask[46 + i])
+            if (changesMask[47 + i])
             {
                 data << uint8(PartyType[i]);
             }
         }
     }
-    if (changesMask[48])
+    if (changesMask[49])
     {
         for (uint32 i = 0; i < 175; ++i)
         {
-            if (changesMask[49 + i])
+            if (changesMask[50 + i])
             {
                 if (noQuestLogChangesMask)
                     QuestLog[i].WriteCreate(data, owner, receiver);
@@ -2650,41 +2711,41 @@ void PlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ign
             }
         }
     }
-    if (changesMask[224])
+    if (changesMask[225])
     {
         for (uint32 i = 0; i < 19; ++i)
         {
-            if (changesMask[225 + i])
+            if (changesMask[226 + i])
             {
                 VisibleItems[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
             }
         }
     }
-    if (changesMask[244])
+    if (changesMask[245])
     {
         for (uint32 i = 0; i < 6; ++i)
         {
-            if (changesMask[245 + i])
+            if (changesMask[246 + i])
             {
                 data << float(AvgItemLevel[i]);
             }
         }
     }
-    if (changesMask[268])
+    if (changesMask[269])
     {
         for (uint32 i = 0; i < 19; ++i)
         {
-            if (changesMask[269 + i])
+            if (changesMask[270 + i])
             {
                 data << uint32(Field_3120[i]);
             }
         }
     }
-    if (changesMask[251])
+    if (changesMask[252])
     {
         for (uint32 i = 0; i < 16; ++i)
         {
-            if (changesMask[252 + i])
+            if (changesMask[253 + i])
             {
                 data << VisibleEquipableSpells[i];
             }
@@ -2702,6 +2763,7 @@ void PlayerData::ClearChangesMask()
     Base::ClearChangesMask(QuestSessionQuestLog);
     Base::ClearChangesMask(ArenaCooldowns);
     Base::ClearChangesMask(VisualItemReplacements);
+    Base::ClearChangesMask(PetNames);
     Base::ClearChangesMask(DuelArbiter);
     Base::ClearChangesMask(WowAccount);
     Base::ClearChangesMask(BnetAccount);
@@ -3154,23 +3216,23 @@ void ResearchHistory::ClearChangesMask()
 
 void MawPower::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
 {
-    data << int32(Field_0);
-    data << int32(Field_4);
-    data << int32(Field_8);
+    data << int32(SpellID);
+    data << int32(MawPowerID);
+    data << int32(Stacks);
 }
 
 void MawPower::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
 {
-    data << int32(Field_0);
-    data << int32(Field_4);
-    data << int32(Field_8);
+    data << int32(SpellID);
+    data << int32(MawPowerID);
+    data << int32(Stacks);
 }
 
 bool MawPower::operator==(MawPower const& right) const
 {
-    return Field_0 == right.Field_0
-        && Field_4 == right.Field_4
-        && Field_8 == right.Field_8;
+    return SpellID == right.SpellID
+        && MawPowerID == right.MawPowerID
+        && Stacks == right.Stacks;
 }
 
 void MultiFloorExplore::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
@@ -4131,7 +4193,7 @@ void ActivePlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> f
     data << float(VersatilityBonus);
     data << float(PvpPowerDamage);
     data << float(PvpPowerHealing);
-    for (uint32 i = 0; i < 8; ++i)
+    for (uint32 i = 0; i < 9; ++i)
     {
         data << uint32(DataFlags[i].size());
         for (uint32 j = 0; j < DataFlags[i].size(); ++j)
@@ -4263,6 +4325,7 @@ void ActivePlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> f
     data << uint32(TaskQuests.size());
     data << uint32(DisabledSpells.size());
     data << int32(UiChromieTimeExpansionID);
+    data << int32(TimerunningSeasonID);
     data << int32(TransportServerTime);
     data << uint32(WeeklyRewardsPeriodSinceOrigin);
     data << int16(DEBUGSoulbindConduitRank);
@@ -4471,7 +4534,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
     }
     if (changesMask[36])
     {
-        for (uint32 i = 0; i < 8; ++i)
+        for (uint32 i = 0; i < 9; ++i)
         {
             if (changesMask[37])
             {
@@ -4484,7 +4547,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
     }
     if (changesMask[36])
     {
-        for (uint32 i = 0; i < 8; ++i)
+        for (uint32 i = 0; i < 9; ++i)
         {
             if (changesMask[37])
             {
@@ -5376,48 +5439,58 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
         }
         if (changesMask[123])
         {
-            data << int32(TransportServerTime);
+            data << int32(TimerunningSeasonID);
         }
         if (changesMask[124])
         {
-            data << uint32(WeeklyRewardsPeriodSinceOrigin);
+            data << int32(TransportServerTime);
         }
         if (changesMask[125])
         {
+            data << uint32(WeeklyRewardsPeriodSinceOrigin);
+        }
+        if (changesMask[126])
+        {
             data << int16(DEBUGSoulbindConduitRank);
         }
-        if (changesMask[127])
+        if (changesMask[128])
         {
             data << uint32(ActiveCombatTraitConfigID);
         }
-        if (changesMask[128])
+        if (changesMask[129])
         {
             data << int32(ItemUpgradeHighOnehandWeaponItemID);
         }
-        if (changesMask[129])
+        if (changesMask[130])
         {
             data << int32(ItemUpgradeHighFingerItemID);
         }
-        if (changesMask[130])
+        if (changesMask[131])
         {
             data << float(ItemUpgradeHighFingerWatermark);
         }
-        if (changesMask[131])
+        if (changesMask[132])
         {
             data << int32(ItemUpgradeHighTrinketItemID);
         }
-        if (changesMask[132])
+        if (changesMask[133])
         {
             data << float(ItemUpgradeHighTrinketWatermark);
         }
-        if (changesMask[133])
+        if (changesMask[134])
         {
             data << uint64(LootHistoryInstanceID);
         }
-        if (changesMask[135])
+    }
+    if (changesMask[136])
+    {
+        if (changesMask[137])
         {
             data << uint8(RequiredMountCapabilityFlags);
         }
+    }
+    if (changesMask[104])
+    {
         data.WriteBits(QuestSession.has_value(), 1);
         data.WriteBits(PetStable.has_value(), 1);
     }
@@ -5443,11 +5516,11 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
         {
             Field_1410->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
-        if (changesMask[126])
+        if (changesMask[127])
         {
             data << DungeonScore;
         }
-        if (changesMask[134])
+        if (changesMask[135])
         {
             if (PetStable.has_value())
             {
@@ -5455,141 +5528,141 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
             }
         }
     }
-    if (changesMask[136])
+    if (changesMask[138])
     {
         for (uint32 i = 0; i < 227; ++i)
         {
-            if (changesMask[137 + i])
+            if (changesMask[139 + i])
             {
                 data << InvSlots[i];
             }
         }
     }
-    if (changesMask[364])
+    if (changesMask[366])
     {
         for (uint32 i = 0; i < 2; ++i)
         {
-            if (changesMask[365 + i])
+            if (changesMask[367 + i])
             {
                 RestInfo[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
             }
         }
     }
-    if (changesMask[367])
+    if (changesMask[369])
     {
         for (uint32 i = 0; i < 7; ++i)
         {
-            if (changesMask[368 + i])
+            if (changesMask[370 + i])
             {
                 data << int32(ModDamageDonePos[i]);
             }
-            if (changesMask[375 + i])
+            if (changesMask[377 + i])
             {
                 data << int32(ModDamageDoneNeg[i]);
             }
-            if (changesMask[382 + i])
+            if (changesMask[384 + i])
             {
                 data << float(ModDamageDonePercent[i]);
             }
-            if (changesMask[389 + i])
+            if (changesMask[391 + i])
             {
                 data << float(ModHealingDonePercent[i]);
             }
         }
     }
-    if (changesMask[396])
+    if (changesMask[398])
     {
         for (uint32 i = 0; i < 3; ++i)
         {
-            if (changesMask[397 + i])
+            if (changesMask[399 + i])
             {
                 data << float(WeaponDmgMultipliers[i]);
             }
-            if (changesMask[400 + i])
+            if (changesMask[402 + i])
             {
                 data << float(WeaponAtkSpeedMultipliers[i]);
             }
         }
     }
-    if (changesMask[403])
+    if (changesMask[405])
     {
         for (uint32 i = 0; i < 12; ++i)
         {
-            if (changesMask[404 + i])
+            if (changesMask[406 + i])
             {
                 data << uint32(BuybackPrice[i]);
             }
-            if (changesMask[416 + i])
+            if (changesMask[418 + i])
             {
                 data << int64(BuybackTimestamp[i]);
             }
         }
     }
-    if (changesMask[428])
+    if (changesMask[430])
     {
         for (uint32 i = 0; i < 32; ++i)
         {
-            if (changesMask[429 + i])
+            if (changesMask[431 + i])
             {
                 data << int32(CombatRatings[i]);
             }
         }
     }
-    if (changesMask[461])
+    if (changesMask[463])
     {
         for (uint32 i = 0; i < 4; ++i)
         {
-            if (changesMask[462 + i])
+            if (changesMask[464 + i])
             {
                 data << uint32(NoReagentCostMask[i]);
             }
         }
     }
-    if (changesMask[466])
+    if (changesMask[468])
     {
         for (uint32 i = 0; i < 2; ++i)
         {
-            if (changesMask[467 + i])
+            if (changesMask[469 + i])
             {
                 data << int32(ProfessionSkillLine[i]);
             }
         }
     }
-    if (changesMask[469])
+    if (changesMask[471])
     {
         for (uint32 i = 0; i < 5; ++i)
         {
-            if (changesMask[470 + i])
+            if (changesMask[472 + i])
             {
                 data << uint32(BagSlotFlags[i]);
             }
         }
     }
-    if (changesMask[475])
+    if (changesMask[477])
     {
         for (uint32 i = 0; i < 7; ++i)
         {
-            if (changesMask[476 + i])
+            if (changesMask[478 + i])
             {
                 data << uint32(BankBagSlotFlags[i]);
             }
         }
     }
-    if (changesMask[483])
+    if (changesMask[485])
     {
         for (uint32 i = 0; i < 950; ++i)
         {
-            if (changesMask[484 + i])
+            if (changesMask[486 + i])
             {
                 data << uint64(QuestCompleted[i]);
             }
         }
     }
-    if (changesMask[1434])
+    if (changesMask[1436])
     {
         for (uint32 i = 0; i < 17; ++i)
         {
-            if (changesMask[1435 + i])
+            if (changesMask[1437 + i])
             {
                 data << float(ItemUpgradeHighWatermark[i]);
             }
@@ -5715,6 +5788,7 @@ void ActivePlayerData::ClearChangesMask()
     Base::ClearChangesMask(Field_1410);
     Base::ClearChangesMask(QuestSession);
     Base::ClearChangesMask(UiChromieTimeExpansionID);
+    Base::ClearChangesMask(TimerunningSeasonID);
     Base::ClearChangesMask(TransportServerTime);
     Base::ClearChangesMask(WeeklyRewardsPeriodSinceOrigin);
     Base::ClearChangesMask(DEBUGSoulbindConduitRank);
diff --git a/src/server/game/Entities/Object/Updates/UpdateFields.h b/src/server/game/Entities/Object/Updates/UpdateFields.h
index 7132f4beaf6..4a09c05dd3b 100644
--- a/src/server/game/Entities/Object/Updates/UpdateFields.h
+++ b/src/server/game/Entities/Object/Updates/UpdateFields.h
@@ -299,93 +299,93 @@ struct UnitData : public IsUpdateFieldStructureTag, public HasChangesMask<217>
     UpdateField<int32, 32, 38> ScalingLevelMax;
     UpdateField<int32, 32, 39> ScalingLevelDelta;
     UpdateField<int32, 32, 40> ScalingFactionGroup;
-    UpdateField<int32, 32, 41> ScalingHealthItemLevelCurveID;
-    UpdateField<int32, 32, 42> ScalingDamageItemLevelCurveID;
-    UpdateField<int32, 32, 43> FactionTemplate;
+    UpdateField<int32, 32, 41> FactionTemplate;
     struct FactionTemplateTag : ViewerDependentValueTag<int32> {};
-    UpdateField<uint32, 32, 44> Flags;
+    UpdateField<uint32, 32, 42> Flags;
     struct FlagsTag : ViewerDependentValueTag<uint32> {};
-    UpdateField<uint32, 32, 45> Flags2;
-    UpdateField<uint32, 32, 46> Flags3;
+    UpdateField<uint32, 32, 43> Flags2;
+    UpdateField<uint32, 32, 44> Flags3;
     struct Flags3Tag : ViewerDependentValueTag<uint32> {};
-    UpdateField<uint32, 32, 47> AuraState;
+    UpdateField<uint32, 32, 45> AuraState;
     struct AuraStateTag : ViewerDependentValueTag<uint32> {};
-    UpdateField<uint32, 32, 48> RangedAttackRoundBaseTime;
-    UpdateField<float, 32, 49> BoundingRadius;
-    UpdateField<float, 32, 50> CombatReach;
-    UpdateField<float, 32, 51> DisplayScale;
-    UpdateField<int32, 32, 52> CreatureFamily;
-    UpdateField<int32, 32, 53> CreatureType;
-    UpdateField<int32, 32, 54> NativeDisplayID;
-    UpdateField<float, 32, 55> NativeXDisplayScale;
-    UpdateField<int32, 32, 56> MountDisplayID;
-    UpdateField<int32, 32, 57> CosmeticMountDisplayID;
-    UpdateField<float, 32, 58> MinDamage;
-    UpdateField<float, 32, 59> MaxDamage;
-    UpdateField<float, 32, 60> MinOffHandDamage;
-    UpdateField<float, 32, 61> MaxOffHandDamage;
-    UpdateField<uint8, 32, 62> StandState;
-    UpdateField<uint8, 32, 63> PetTalentPoints;
-    UpdateField<uint8, 64, 65> VisFlags;
-    UpdateField<uint8, 64, 66> AnimTier;
-    UpdateField<uint32, 64, 67> PetNumber;
-    UpdateField<uint32, 64, 68> PetNameTimestamp;
-    UpdateField<uint32, 64, 69> PetExperience;
-    UpdateField<uint32, 64, 70> PetNextLevelExperience;
-    UpdateField<float, 64, 71> ModCastingSpeed;
-    UpdateField<float, 64, 72> ModCastingSpeedNeg;
-    UpdateField<float, 64, 73> ModSpellHaste;
-    UpdateField<float, 64, 74> ModHaste;
-    UpdateField<float, 64, 75> ModRangedHaste;
-    UpdateField<float, 64, 76> ModHasteRegen;
-    UpdateField<float, 64, 77> ModTimeRate;
-    UpdateField<int32, 64, 78> CreatedBySpell;
-    UpdateField<int32, 64, 79> EmoteState;
-    UpdateField<int32, 64, 80> BaseMana;
-    UpdateField<int32, 64, 81> BaseHealth;
-    UpdateField<uint8, 64, 82> SheatheState;
-    UpdateField<uint8, 64, 83> PvpFlags;
+    UpdateField<uint32, 32, 46> RangedAttackRoundBaseTime;
+    UpdateField<float, 32, 47> BoundingRadius;
+    UpdateField<float, 32, 48> CombatReach;
+    UpdateField<float, 32, 49> DisplayScale;
+    UpdateField<int32, 32, 50> CreatureFamily;
+    UpdateField<int32, 32, 51> CreatureType;
+    UpdateField<int32, 32, 52> NativeDisplayID;
+    UpdateField<float, 32, 53> NativeXDisplayScale;
+    UpdateField<int32, 32, 54> MountDisplayID;
+    UpdateField<int32, 32, 55> CosmeticMountDisplayID;
+    UpdateField<float, 32, 56> MinDamage;
+    UpdateField<float, 32, 57> MaxDamage;
+    UpdateField<float, 32, 58> MinOffHandDamage;
+    UpdateField<float, 32, 59> MaxOffHandDamage;
+    UpdateField<uint8, 32, 60> StandState;
+    UpdateField<uint8, 32, 61> PetTalentPoints;
+    UpdateField<uint8, 32, 62> VisFlags;
+    UpdateField<uint8, 32, 63> AnimTier;
+    UpdateField<uint32, 64, 65> PetNumber;
+    UpdateField<uint32, 64, 66> PetNameTimestamp;
+    UpdateField<uint32, 64, 67> PetExperience;
+    UpdateField<uint32, 64, 68> PetNextLevelExperience;
+    UpdateField<float, 64, 69> ModCastingSpeed;
+    UpdateField<float, 64, 70> ModCastingSpeedNeg;
+    UpdateField<float, 64, 71> ModSpellHaste;
+    UpdateField<float, 64, 72> ModHaste;
+    UpdateField<float, 64, 73> ModRangedHaste;
+    UpdateField<float, 64, 74> ModHasteRegen;
+    UpdateField<float, 64, 75> ModTimeRate;
+    UpdateField<int32, 64, 76> CreatedBySpell;
+    UpdateField<int32, 64, 77> EmoteState;
+    UpdateField<int32, 64, 78> BaseMana;
+    UpdateField<int32, 64, 79> BaseHealth;
+    UpdateField<uint8, 64, 80> SheatheState;
+    UpdateField<uint8, 64, 81> PvpFlags;
     struct PvpFlagsTag : ViewerDependentValueTag<uint8> {};
-    UpdateField<uint8, 64, 84> PetFlags;
-    UpdateField<uint8, 64, 85> ShapeshiftForm;
-    UpdateField<int32, 64, 86> AttackPower;
-    UpdateField<int32, 64, 87> AttackPowerModPos;
-    UpdateField<int32, 64, 88> AttackPowerModNeg;
-    UpdateField<float, 64, 89> AttackPowerMultiplier;
-    UpdateField<int32, 64, 90> AttackPowerModSupport;
-    UpdateField<int32, 64, 91> RangedAttackPower;
-    UpdateField<int32, 64, 92> RangedAttackPowerModPos;
-    UpdateField<int32, 64, 93> RangedAttackPowerModNeg;
-    UpdateField<float, 64, 94> RangedAttackPowerMultiplier;
-    UpdateField<int32, 64, 95> RangedAttackPowerModSupport;
-    UpdateField<int32, 96, 97> MainHandWeaponAttackPower;
-    UpdateField<int32, 96, 98> OffHandWeaponAttackPower;
-    UpdateField<int32, 96, 99> RangedWeaponAttackPower;
-    UpdateField<int32, 96, 100> SetAttackSpeedAura;
-    UpdateField<float, 96, 101> Lifesteal;
-    UpdateField<float, 96, 102> MinRangedDamage;
-    UpdateField<float, 96, 103> MaxRangedDamage;
-    UpdateField<float, 96, 104> ManaCostMultiplier;
-    UpdateField<float, 96, 105> MaxHealthModifier;
-    UpdateField<float, 96, 106> HoverHeight;
-    UpdateField<int32, 96, 107> MinItemLevelCutoff;
-    UpdateField<int32, 96, 108> MinItemLevel;
-    UpdateField<int32, 96, 109> MaxItemLevel;
-    UpdateField<int32, 96, 110> AzeriteItemLevel;
-    UpdateField<int32, 96, 111> WildBattlePetLevel;
-    UpdateField<int32, 96, 112> BattlePetCompanionExperience;
-    UpdateField<uint32, 96, 113> BattlePetCompanionNameTimestamp;
-    UpdateField<int32, 96, 114> InteractSpellID;
+    UpdateField<uint8, 64, 82> PetFlags;
+    UpdateField<uint8, 64, 83> ShapeshiftForm;
+    UpdateField<int32, 64, 84> AttackPower;
+    UpdateField<int32, 64, 85> AttackPowerModPos;
+    UpdateField<int32, 64, 86> AttackPowerModNeg;
+    UpdateField<float, 64, 87> AttackPowerMultiplier;
+    UpdateField<int32, 64, 88> AttackPowerModSupport;
+    UpdateField<int32, 64, 89> RangedAttackPower;
+    UpdateField<int32, 64, 90> RangedAttackPowerModPos;
+    UpdateField<int32, 64, 91> RangedAttackPowerModNeg;
+    UpdateField<float, 64, 92> RangedAttackPowerMultiplier;
+    UpdateField<int32, 64, 93> RangedAttackPowerModSupport;
+    UpdateField<int32, 64, 94> MainHandWeaponAttackPower;
+    UpdateField<int32, 64, 95> OffHandWeaponAttackPower;
+    UpdateField<int32, 96, 97> RangedWeaponAttackPower;
+    UpdateField<int32, 96, 98> SetAttackSpeedAura;
+    UpdateField<float, 96, 99> Lifesteal;
+    UpdateField<float, 96, 100> MinRangedDamage;
+    UpdateField<float, 96, 101> MaxRangedDamage;
+    UpdateField<float, 96, 102> ManaCostMultiplier;
+    UpdateField<float, 96, 103> MaxHealthModifier;
+    UpdateField<float, 96, 104> HoverHeight;
+    UpdateField<int32, 96, 105> MinItemLevelCutoff;
+    UpdateField<int32, 96, 106> MinItemLevel;
+    UpdateField<int32, 96, 107> MaxItemLevel;
+    UpdateField<int32, 96, 108> AzeriteItemLevel;
+    UpdateField<int32, 96, 109> WildBattlePetLevel;
+    UpdateField<int32, 96, 110> BattlePetCompanionExperience;
+    UpdateField<uint32, 96, 111> BattlePetCompanionNameTimestamp;
+    UpdateField<int32, 96, 112> InteractSpellID;
     struct InteractSpellIDTag : ViewerDependentValueTag<int32> {};
-    UpdateField<int32, 96, 115> ScaleDuration;
-    UpdateField<int32, 96, 116> LooksLikeMountID;
-    UpdateField<int32, 96, 117> LooksLikeCreatureID;
-    UpdateField<int32, 96, 118> LookAtControllerID;
-    UpdateField<int32, 96, 119> PerksVendorItemID;
-    UpdateField<int32, 96, 120> TaxiNodesID;
-    UpdateField<ObjectGuid, 96, 121> GuildGUID;
-    UpdateField<int32, 96, 122> FlightCapabilityID;
-    UpdateField<float, 96, 123> GlideEventSpeedDivisor;                         // Movement speed gets divided by this value when evaluating what GlideEvents to use
+    UpdateField<int32, 96, 113> ScaleDuration;
+    UpdateField<int32, 96, 114> LooksLikeMountID;
+    UpdateField<int32, 96, 115> LooksLikeCreatureID;
+    UpdateField<int32, 96, 116> LookAtControllerID;
+    UpdateField<int32, 96, 117> PerksVendorItemID;
+    UpdateField<int32, 96, 118> TaxiNodesID;
+    UpdateField<ObjectGuid, 96, 119> GuildGUID;
+    UpdateField<int32, 96, 120> FlightCapabilityID;
+    UpdateField<float, 96, 121> GlideEventSpeedDivisor;                         // Movement speed gets divided by this value when evaluating what GlideEvents to use
+    UpdateField<uint32, 96, 122> Field_308;
+    UpdateField<uint32, 96, 123> Field_30C;
     UpdateField<uint32, 96, 124> SilencedSchoolMask;
     UpdateField<uint32, 96, 125> CurrentAreaID;
     UpdateField<ObjectGuid, 96, 126> NameplateAttachToGUID;                     // When set, nameplate of this unit will instead appear on that object
@@ -452,6 +452,16 @@ struct ArenaCooldown : public IsUpdateFieldStructureTag, public HasChangesMask<8
     void ClearChangesMask();
 };
 
+struct PetCreatureName : public IsUpdateFieldStructureTag, public HasChangesMask<3>
+{
+    UpdateField<uint32, 0, 1> CreatureID;
+    UpdateField<std::string, 0, 2> Name;
+
+    void WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const;
+    void WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const;
+    void ClearChangesMask();
+};
+
 struct CTROptions : public IsUpdateFieldStructureTag
 {
     int32 ContentTuningConditionMask;
@@ -486,7 +496,7 @@ struct CustomTabardInfo : public IsUpdateFieldStructureTag, public HasChangesMas
     void ClearChangesMask();
 };
 
-struct PlayerData : public IsUpdateFieldStructureTag, public HasChangesMask<288>
+struct PlayerData : public IsUpdateFieldStructureTag, public HasChangesMask<289>
 {
     UpdateField<bool, 0, 1> HasQuestSession;
     UpdateField<bool, 0, 2> HasLevelLink;
@@ -494,49 +504,50 @@ struct PlayerData : public IsUpdateFieldStructureTag, public HasChangesMask<288>
     DynamicUpdateField<UF::ChrCustomizationChoice, 0, 4> QaCustomizations;
     DynamicUpdateField<UF::QuestLog, 0, 5> QuestSessionQuestLog;
     DynamicUpdateField<UF::ArenaCooldown, 0, 6> ArenaCooldowns;
-    DynamicUpdateField<int32, 0, 7> VisualItemReplacements;
-    UpdateField<ObjectGuid, 0, 8> DuelArbiter;
-    UpdateField<ObjectGuid, 0, 9> WowAccount;
-    UpdateField<ObjectGuid, 0, 10> BnetAccount;
-    UpdateField<uint64, 0, 11> GuildClubMemberID;
-    UpdateField<ObjectGuid, 0, 12> LootTargetGUID;
-    UpdateField<uint32, 0, 13> PlayerFlags;
-    UpdateField<uint32, 0, 14> PlayerFlagsEx;
-    UpdateField<uint32, 0, 15> GuildRankID;
-    UpdateField<uint32, 0, 16> GuildDeleteDate;
-    UpdateField<int32, 0, 17> GuildLevel;
-    UpdateField<uint8, 0, 18> NativeSex;
-    UpdateField<uint8, 0, 19> Inebriation;
-    UpdateField<uint8, 0, 20> PvpTitle;
-    UpdateField<uint8, 0, 21> ArenaFaction;
-    UpdateField<uint32, 0, 22> DuelTeam;
-    UpdateField<int32, 0, 23> GuildTimeStamp;
-    UpdateField<int32, 0, 24> PlayerTitle;
-    UpdateField<int32, 0, 25> FakeInebriation;
-    UpdateField<uint32, 0, 26> VirtualPlayerRealm;
-    UpdateField<uint32, 0, 27> CurrentSpecID;
-    UpdateField<int32, 0, 28> TaxiMountAnimKitID;
-    UpdateField<uint8, 0, 29> CurrentBattlePetBreedQuality;
-    UpdateField<int32, 0, 30> HonorLevel;
-    UpdateField<int64, 0, 31> LogoutTime;
-    UpdateField<std::string, 32, 33> Name;
-    UpdateField<int32, 32, 34> Field_1AC;
-    UpdateField<int32, 32, 35> Field_1B0;
-    UpdateField<int32, 32, 36> CurrentBattlePetSpeciesID;
-    UpdateField<UF::CTROptions, 32, 37> CtrOptions;
-    UpdateField<int32, 32, 38> CovenantID;
-    UpdateField<int32, 32, 39> SoulbindID;
-    UpdateField<WorldPackets::MythicPlus::DungeonScoreSummary, 32, 40> DungeonScore;
-    UpdateField<ObjectGuid, 32, 41> SpectateTarget;
-    UpdateField<int32, 32, 42> Field_200;
-    OptionalUpdateField<UF::DeclinedNames, 32, 43> DeclinedNames;
-    UpdateField<UF::CustomTabardInfo, 32, 44> PersonalTabard;
-    UpdateFieldArray<uint8, 2, 45, 46> PartyType;
-    UpdateFieldArray<UF::QuestLog, 175, 48, 49> QuestLog;
-    UpdateFieldArray<UF::VisibleItem, 19, 224, 225> VisibleItems;
-    UpdateFieldArray<float, 6, 244, 245> AvgItemLevel;
-    UpdateFieldArray<WorldPackets::Item::ItemInstance, 16, 251, 252> VisibleEquipableSpells;
-    UpdateFieldArray<uint32, 19, 268, 269> Field_3120;
+    DynamicUpdateField<int32, 0, 8> VisualItemReplacements;
+    DynamicUpdateField<UF::PetCreatureName, 0, 7> PetNames;
+    UpdateField<ObjectGuid, 0, 9> DuelArbiter;
+    UpdateField<ObjectGuid, 0, 10> WowAccount;
+    UpdateField<ObjectGuid, 0, 11> BnetAccount;
+    UpdateField<uint64, 0, 12> GuildClubMemberID;
+    UpdateField<ObjectGuid, 0, 13> LootTargetGUID;
+    UpdateField<uint32, 0, 14> PlayerFlags;
+    UpdateField<uint32, 0, 15> PlayerFlagsEx;
+    UpdateField<uint32, 0, 16> GuildRankID;
+    UpdateField<uint32, 0, 17> GuildDeleteDate;
+    UpdateField<int32, 0, 18> GuildLevel;
+    UpdateField<uint8, 0, 19> NativeSex;
+    UpdateField<uint8, 0, 20> Inebriation;
+    UpdateField<uint8, 0, 21> PvpTitle;
+    UpdateField<uint8, 0, 22> ArenaFaction;
+    UpdateField<uint32, 0, 23> DuelTeam;
+    UpdateField<int32, 0, 24> GuildTimeStamp;
+    UpdateField<int32, 0, 25> PlayerTitle;
+    UpdateField<int32, 0, 26> FakeInebriation;
+    UpdateField<uint32, 0, 27> VirtualPlayerRealm;
+    UpdateField<uint32, 0, 28> CurrentSpecID;
+    UpdateField<int32, 0, 29> TaxiMountAnimKitID;
+    UpdateField<uint8, 0, 30> CurrentBattlePetBreedQuality;
+    UpdateField<int32, 0, 31> HonorLevel;
+    UpdateField<int64, 32, 33> LogoutTime;
+    UpdateField<std::string, 32, 34> Name;
+    UpdateField<int32, 32, 35> Field_1AC;
+    UpdateField<int32, 32, 36> Field_1B0;
+    UpdateField<int32, 32, 37> CurrentBattlePetSpeciesID;
+    UpdateField<UF::CTROptions, 32, 38> CtrOptions;
+    UpdateField<int32, 32, 39> CovenantID;
+    UpdateField<int32, 32, 40> SoulbindID;
+    UpdateField<WorldPackets::MythicPlus::DungeonScoreSummary, 32, 41> DungeonScore;
+    UpdateField<ObjectGuid, 32, 42> SpectateTarget;
+    UpdateField<int32, 32, 43> Field_200;
+    OptionalUpdateField<UF::DeclinedNames, 32, 44> DeclinedNames;
+    UpdateField<UF::CustomTabardInfo, 32, 45> PersonalTabard;
+    UpdateFieldArray<uint8, 2, 46, 47> PartyType;
+    UpdateFieldArray<UF::QuestLog, 175, 49, 50> QuestLog;
+    UpdateFieldArray<UF::VisibleItem, 19, 225, 226> VisibleItems;
+    UpdateFieldArray<float, 6, 245, 246> AvgItemLevel;
+    UpdateFieldArray<WorldPackets::Item::ItemInstance, 16, 252, 253> VisibleEquipableSpells;
+    UpdateFieldArray<uint32, 19, 269, 270> 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;
@@ -657,9 +668,9 @@ struct ResearchHistory : public IsUpdateFieldStructureTag, public HasChangesMask
 
 struct MawPower : public IsUpdateFieldStructureTag
 {
-    int32 Field_0;
-    int32 Field_4;
-    int32 Field_8;
+    int32 SpellID;
+    int32 MawPowerID;
+    int32 Stacks;
 
     void WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const;
     void WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const;
@@ -880,7 +891,7 @@ struct Research : public IsUpdateFieldStructureTag
     bool operator!=(Research const& right) const { return !(*this == right); }
 };
 
-struct ActivePlayerData : public IsUpdateFieldStructureTag, public HasChangesMask<1452>
+struct ActivePlayerData : public IsUpdateFieldStructureTag, public HasChangesMask<1454>
 {
     UpdateField<bool, 0, 1> BackpackAutoSortDisabled;
     UpdateField<bool, 0, 2> BackpackSellJunkDisabled;
@@ -888,7 +899,7 @@ struct ActivePlayerData : public IsUpdateFieldStructureTag, public HasChangesMas
     UpdateField<bool, 0, 4> SortBagsRightToLeft;
     UpdateField<bool, 0, 5> InsertItemsLeftToRight;
     UpdateField<bool, 0, 6> HasPerksProgramPendingReward;
-    UpdateFieldArray<DynamicUpdateFieldBase<uint64>, 8, 36, 37> DataFlags;
+    UpdateFieldArray<DynamicUpdateFieldBase<uint64>, 9, 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;
@@ -997,36 +1008,37 @@ struct ActivePlayerData : public IsUpdateFieldStructureTag, public HasChangesMas
     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;
+    UpdateField<int32, 104, 123> TimerunningSeasonID;
+    UpdateField<int32, 104, 124> TransportServerTime;
+    UpdateField<uint32, 104, 125> WeeklyRewardsPeriodSinceOrigin;               // week count since Cfg_RegionsEntry::ChallengeOrigin
+    UpdateField<int16, 104, 126> DEBUGSoulbindConduitRank;
+    UpdateField<WorldPackets::MythicPlus::DungeonScoreData, 104, 127> DungeonScore;
+    UpdateField<uint32, 104, 128> ActiveCombatTraitConfigID;
+    UpdateField<int32, 104, 129> ItemUpgradeHighOnehandWeaponItemID;
+    UpdateField<int32, 104, 130> ItemUpgradeHighFingerItemID;
+    UpdateField<float, 104, 131> ItemUpgradeHighFingerWatermark;
+    UpdateField<int32, 104, 132> ItemUpgradeHighTrinketItemID;
+    UpdateField<float, 104, 133> ItemUpgradeHighTrinketWatermark;
+    UpdateField<uint64, 104, 134> LootHistoryInstanceID;
+    OptionalUpdateField<UF::StableInfo, 104, 135> PetStable;
+    UpdateField<uint8, 136, 137> RequiredMountCapabilityFlags;
+    UpdateFieldArray<ObjectGuid, 227, 138, 139> InvSlots;
+    UpdateFieldArray<UF::RestInfo, 2, 366, 367> RestInfo;
+    UpdateFieldArray<int32, 7, 369, 370> ModDamageDonePos;
+    UpdateFieldArray<int32, 7, 369, 377> ModDamageDoneNeg;
+    UpdateFieldArray<float, 7, 369, 384> ModDamageDonePercent;
+    UpdateFieldArray<float, 7, 369, 391> ModHealingDonePercent;
+    UpdateFieldArray<float, 3, 398, 399> WeaponDmgMultipliers;
+    UpdateFieldArray<float, 3, 398, 402> WeaponAtkSpeedMultipliers;
+    UpdateFieldArray<uint32, 12, 405, 406> BuybackPrice;
+    UpdateFieldArray<int64, 12, 405, 418> BuybackTimestamp;
+    UpdateFieldArray<int32, 32, 430, 431> CombatRatings;
+    UpdateFieldArray<uint32, 4, 463, 464> NoReagentCostMask;
+    UpdateFieldArray<int32, 2, 468, 469> ProfessionSkillLine;
+    UpdateFieldArray<uint32, 5, 471, 472> BagSlotFlags;
+    UpdateFieldArray<uint32, 7, 477, 478> BankBagSlotFlags;
+    UpdateFieldArray<uint64, 950, 485, 486> QuestCompleted;
+    UpdateFieldArray<float, 17, 1436, 1437> 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;