Core: Updated to 10.0.2

4 files changed, 1605 insertions, 747 deletions

diff --git a/src/server/game/Entities/Object/MovementInfo.h b/src/server/game/Entities/Object/MovementInfo.h
index 15b4af8ebfa..9e8c3909b36 100644
--- a/src/server/game/Entities/Object/MovementInfo.h
+++ b/src/server/game/Entities/Object/MovementInfo.h
@@ -60,9 +60,9 @@ struct MovementInfo
 
     struct Inertia
     {
-        Inertia() : lifetime(0) { }
+        Inertia() : id(0), lifetime(0) { }
 
-        ObjectGuid guid;
+        int32 id;
         Position force;
         uint32 lifetime;
     };
@@ -86,6 +86,15 @@ struct MovementInfo
 
     float stepUpStartElevation;
 
+    // advflying
+    struct AdvFlying
+    {
+        float forwardVelocity;
+        float upVelocity;
+    };
+
+    Optional<AdvFlying> advFlying;
+
     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 1059e2d7686..cca7c5fe890 100644
--- a/src/server/game/Entities/Object/Object.cpp
+++ b/src/server/game/Entities/Object/Object.cpp
@@ -293,6 +293,7 @@ void Object::BuildMovementUpdate(ByteBuffer* data, CreateObjectBits flags, Playe
         bool HasFall = HasFallDirection || unit->m_movementInfo.jump.fallTime != 0;
         bool HasSpline = unit->IsSplineEnabled();
         bool HasInertia = unit->m_movementInfo.inertia.has_value();
+        bool HasAdvFlying = unit->m_movementInfo.advFlying.has_value();
 
         *data << GetGUID();                                             // MoverGUID
 
@@ -321,17 +322,24 @@ void Object::BuildMovementUpdate(ByteBuffer* data, CreateObjectBits flags, Playe
         data->WriteBit(false);                                          // HeightChangeFailed
         data->WriteBit(false);                                          // RemoteTimeValid
         data->WriteBit(HasInertia);                                     // HasInertia
+        data->WriteBit(HasAdvFlying);                                   // HasAdvFlying
 
         if (!unit->m_movementInfo.transport.guid.IsEmpty())
             *data << unit->m_movementInfo.transport;
 
         if (HasInertia)
         {
-            *data << unit->m_movementInfo.inertia->guid;
+            *data << unit->m_movementInfo.inertia->id;
             *data << unit->m_movementInfo.inertia->force.PositionXYZStream();
             *data << uint32(unit->m_movementInfo.inertia->lifetime);
         }
 
+        if (HasAdvFlying)
+        {
+            *data << float(unit->m_movementInfo.advFlying->forwardVelocity);
+            *data << float(unit->m_movementInfo.advFlying->upVelocity);
+        }
+
         if (HasFall)
         {
             *data << uint32(unit->m_movementInfo.jump.fallTime);        // Time
@@ -366,6 +374,24 @@ void Object::BuildMovementUpdate(ByteBuffer* data, CreateObjectBits flags, Playe
             *data << float(1.0f);                                       // MovementForcesModMagnitude
         }
 
+        *data << float(2.0f);                                           // advFlyingAirFriction
+        *data << float(65.0f);                                          // advFlyingMaxVel
+        *data << float(1.0f);                                           // advFlyingLiftCoefficient
+        *data << float(3.0f);                                           // advFlyingDoubleJumpVelMod
+        *data << float(10.0f);                                          // advFlyingGlideStartMinHeight
+        *data << float(100.0f);                                         // advFlyingAddImpulseMaxSpeed
+        *data << float(90.0f);                                          // advFlyingMinBankingRate
+        *data << float(140.0f);                                         // advFlyingMaxBankingRate
+        *data << float(180.0f);                                         // advFlyingMinPitchingRateDown
+        *data << float(360.0f);                                         // advFlyingMaxPitchingRateDown
+        *data << float(90.0f);                                          // advFlyingMinPitchingRateUp
+        *data << float(270.0f);                                         // advFlyingMaxPitchingRateUp
+        *data << float(30.0f);                                          // advFlyingMinTurnVelocityThreshold
+        *data << float(80.0f);                                          // advFlyingMaxTurnVelocityThreshold
+        *data << float(2.75f);                                          // advFlyingSurfaceFriction
+        *data << float(7.0f);                                           // advFlyingOverMaxDeceleration
+        *data << float(0.4f);                                           // advFlyingLaunchSpeedCoefficient
+
         data->WriteBit(HasSpline);
         data->FlushBits();
 
@@ -438,6 +464,7 @@ void Object::BuildMovementUpdate(ByteBuffer* data, CreateObjectBits flags, Playe
         bool hasFaceMovementDir     = areaTriggerTemplate && areaTrigger->GetTemplate()->HasFlag(AREATRIGGER_FLAG_HAS_FACE_MOVEMENT_DIR);
         bool hasFollowsTerrain      = areaTriggerTemplate && areaTrigger->GetTemplate()->HasFlag(AREATRIGGER_FLAG_HAS_FOLLOWS_TERRAIN);
         bool hasUnk1                = areaTriggerTemplate && areaTrigger->GetTemplate()->HasFlag(AREATRIGGER_FLAG_UNK1);
+        bool hasUnk2                = false;
         bool hasTargetRollPitchYaw  = areaTriggerTemplate && areaTrigger->GetTemplate()->HasFlag(AREATRIGGER_FLAG_HAS_TARGET_ROLL_PITCH_YAW);
         bool hasScaleCurveID        = createProperties && createProperties->ScaleCurveId != 0;
         bool hasMorphCurveID        = createProperties && createProperties->MorphCurveId != 0;
@@ -448,6 +475,7 @@ void Object::BuildMovementUpdate(ByteBuffer* data, CreateObjectBits flags, Playe
         bool hasAreaTriggerPolygon  = createProperties && shape.IsPolygon();
         bool hasAreaTriggerCylinder = shape.IsCylinder();
         bool hasDisk                = shape.IsDisk();
+        bool hasBoundedPlane        = shape.IsBoudedPlane();
         bool hasAreaTriggerSpline   = areaTrigger->HasSplines();
         bool hasOrbit               = areaTrigger->HasOrbit();
         bool hasMovementScript      = false;
@@ -458,6 +486,7 @@ void Object::BuildMovementUpdate(ByteBuffer* data, CreateObjectBits flags, Playe
         data->WriteBit(hasFaceMovementDir);
         data->WriteBit(hasFollowsTerrain);
         data->WriteBit(hasUnk1);
+        data->WriteBit(hasUnk2);
         data->WriteBit(hasTargetRollPitchYaw);
         data->WriteBit(hasScaleCurveID);
         data->WriteBit(hasMorphCurveID);
@@ -468,6 +497,7 @@ void Object::BuildMovementUpdate(ByteBuffer* data, CreateObjectBits flags, Playe
         data->WriteBit(hasAreaTriggerPolygon);
         data->WriteBit(hasAreaTriggerCylinder);
         data->WriteBit(hasDisk);
+        data->WriteBit(hasBoundedPlane);
         data->WriteBit(hasAreaTriggerSpline);
         data->WriteBit(hasOrbit);
         data->WriteBit(hasMovementScript);
@@ -549,6 +579,14 @@ void Object::BuildMovementUpdate(ByteBuffer* data, CreateObjectBits flags, Playe
             *data << float(shape.DiskDatas.LocationZOffsetTarget);
         }
 
+        if (hasBoundedPlane)
+        {
+            *data << float(shape.BoundedPlaneDatas.Extents[0]);
+            *data << float(shape.BoundedPlaneDatas.Extents[1]);
+            *data << float(shape.BoundedPlaneDatas.ExtentsTarget[0]);
+            *data << float(shape.BoundedPlaneDatas.ExtentsTarget[1]);
+        }
+
         //if (hasMovementScript)
         //    *data << *areaTrigger->GetMovementScript(); // AreaTriggerMovementScriptInfo
 
@@ -2300,10 +2338,10 @@ int32 WorldObject::ModSpellDuration(SpellInfo const* spellInfo, WorldObject cons
 
     if (!positive)
     {
-        int32 mechanicMask = spellInfo->GetSpellMechanicMaskByEffectMask(effectMask);
+        uint64 mechanicMask = spellInfo->GetSpellMechanicMaskByEffectMask(effectMask);
         auto mechanicCheck = [mechanicMask](AuraEffect const* aurEff) -> bool
         {
-            if (mechanicMask & (1 << aurEff->GetMiscValue()))
+            if (mechanicMask & (UI64LIT(1) << aurEff->GetMiscValue()))
                 return true;
             return false;
         };
diff --git a/src/server/game/Entities/Object/Updates/UpdateFields.cpp b/src/server/game/Entities/Object/Updates/UpdateFields.cpp
index c38670e91ff..1b7632da868 100644
--- a/src/server/game/Entities/Object/Updates/UpdateFields.cpp
+++ b/src/server/game/Entities/Object/Updates/UpdateFields.cpp
@@ -268,11 +268,6 @@ void SocketedGem::ClearChangesMask()
 
 void ItemData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Item const* owner, Player const* receiver) const
 {
-    data << uint32(BonusListIDs->size());
-    for (uint32 i = 0; i < BonusListIDs->size(); ++i)
-    {
-        data << int32((*BonusListIDs)[i]);
-    }
     data << Owner;
     data << ContainedIn;
     data << Creator;
@@ -309,6 +304,10 @@ void ItemData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisi
     if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
     {
         data << uint32(DynamicFlags2);
+    }
+    data << ItemBonusKey;
+    if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
+    {
         data << uint16(DEBUGItemLevel);
     }
     for (uint32 i = 0; i < ArtifactPowers.size(); ++i)
@@ -324,7 +323,7 @@ void ItemData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisi
 
 void ItemData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Item const* owner, Player const* receiver) const
 {
-    Mask allowedMaskForTarget({ 0xF804E4FFu, 0x000001FFu });
+    Mask allowedMaskForTarget({ 0xF80A727Fu, 0x000001FFu });
     AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
     WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver);
 }
@@ -332,12 +331,12 @@ void ItemData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisi
 void ItemData::AppendAllowedFieldsMaskForFlag(Mask& allowedMaskForTarget, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
 {
     if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
-        allowedMaskForTarget |= { 0x07FB1B00u, 0x00000000u };
+        allowedMaskForTarget |= { 0x07F58D80u, 0x00000000u };
 }
 
 void ItemData::FilterDisallowedFieldsMaskForFlag(Mask& changesMask, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
 {
-    Mask allowedMaskForTarget({ 0xF804E4FFu, 0x000001FFu });
+    Mask allowedMaskForTarget({ 0xF80A727Fu, 0x000001FFu });
     AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
     changesMask &= allowedMaskForTarget;
 }
@@ -353,24 +352,12 @@ void ItemData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignor
     {
         if (changesMask[1])
         {
-            data.WriteBits(BonusListIDs->size(), 32);
-            for (uint32 i = 0; i < BonusListIDs->size(); ++i)
-            {
-                data << int32((*BonusListIDs)[i]);
-            }
-        }
-    }
-    data.FlushBits();
-    if (changesMask[0])
-    {
-        if (changesMask[2])
-        {
             if (!ignoreNestedChangesMask)
                 ArtifactPowers.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(ArtifactPowers.size(), data);
         }
-        if (changesMask[3])
+        if (changesMask[2])
         {
             if (!ignoreNestedChangesMask)
                 Gems.WriteUpdateMask(data);
@@ -381,7 +368,7 @@ void ItemData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignor
     data.FlushBits();
     if (changesMask[0])
     {
-        if (changesMask[2])
+        if (changesMask[1])
         {
             for (uint32 i = 0; i < ArtifactPowers.size(); ++i)
             {
@@ -391,7 +378,7 @@ void ItemData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignor
                 }
             }
         }
-        if (changesMask[3])
+        if (changesMask[2])
         {
             for (uint32 i = 0; i < Gems.size(); ++i)
             {
@@ -401,71 +388,75 @@ void ItemData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignor
                 }
             }
         }
-        if (changesMask[4])
+        if (changesMask[3])
         {
             data << Owner;
         }
-        if (changesMask[5])
+        if (changesMask[4])
         {
             data << ContainedIn;
         }
-        if (changesMask[6])
+        if (changesMask[5])
         {
             data << Creator;
         }
-        if (changesMask[7])
+        if (changesMask[6])
         {
             data << GiftCreator;
         }
-        if (changesMask[8])
+        if (changesMask[7])
         {
             data << uint32(StackCount);
         }
-        if (changesMask[9])
+        if (changesMask[8])
         {
             data << uint32(Expiration);
         }
-        if (changesMask[10])
+        if (changesMask[9])
         {
             data << uint32(DynamicFlags);
         }
-        if (changesMask[11])
+        if (changesMask[10])
         {
             data << uint32(Durability);
         }
-        if (changesMask[12])
+        if (changesMask[11])
         {
             data << uint32(MaxDurability);
         }
-        if (changesMask[13])
+        if (changesMask[12])
         {
             data << uint32(CreatePlayedTime);
         }
-        if (changesMask[14])
+        if (changesMask[13])
         {
             data << int32(Context);
         }
-        if (changesMask[15])
+        if (changesMask[14])
         {
             data << int64(CreateTime);
         }
-        if (changesMask[16])
+        if (changesMask[15])
         {
             data << uint64(ArtifactXP);
         }
-        if (changesMask[17])
+        if (changesMask[16])
         {
             data << uint8(ItemAppearanceModID);
         }
-        if (changesMask[19])
+        if (changesMask[18])
         {
             data << uint32(DynamicFlags2);
         }
+        if (changesMask[19])
+        {
+            data << ItemBonusKey;
+        }
         if (changesMask[20])
         {
             data << uint16(DEBUGItemLevel);
         }
-        if (changesMask[18])
+        if (changesMask[17])
         {
             Modifiers->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
@@ -494,7 +485,6 @@ void ItemData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignor
 
 void ItemData::ClearChangesMask()
 {
-    Base::ClearChangesMask(BonusListIDs);
     Base::ClearChangesMask(ArtifactPowers);
     Base::ClearChangesMask(Gems);
     Base::ClearChangesMask(Owner);
@@ -513,6 +503,7 @@ void ItemData::ClearChangesMask()
     Base::ClearChangesMask(ItemAppearanceModID);
     Base::ClearChangesMask(Modifiers);
     Base::ClearChangesMask(DynamicFlags2);
+    Base::ClearChangesMask(ItemBonusKey);
     Base::ClearChangesMask(DEBUGItemLevel);
     Base::ClearChangesMask(SpellCharges);
     Base::ClearChangesMask(Enchantment);
@@ -968,6 +959,7 @@ void UnitData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisi
     data << BattlePetCompanionGUID;
     data << uint64(BattlePetDBID);
     ChannelData->WriteCreate(data, owner, receiver);
+    data << int8(SpellEmpowerStage);
     data << uint32(SummonedByHomeRealm);
     data << uint8(Race);
     data << uint8(ClassId);
@@ -1120,6 +1112,7 @@ void UnitData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisi
     data << uint32(PassiveSpells.size());
     data << uint32(WorldEffects.size());
     data << uint32(ChannelObjects.size());
+    data << int32(FlightCapabilityID);
     data << uint32(SilencedSchoolMask);
     data << NameplateAttachToGUID;
     for (uint32 i = 0; i < PassiveSpells.size(); ++i)
@@ -1138,7 +1131,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, 0xE1FF7FFFu, 0x001EFFFFu, 0xFFFFFF81u, 0x7F0003FFu, 0x00000000u, 0x00000000u });
+    Mask allowedMaskForTarget({ 0xFFFFDFFFu, 0xC3FEFFFFu, 0x003DFFFFu, 0xFFFFFF01u, 0xFC000FFFu, 0x00000001u, 0x00000000u });
     AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
     WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver);
 }
@@ -1146,16 +1139,16 @@ void UnitData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisi
 void UnitData::AppendAllowedFieldsMaskForFlag(Mask& allowedMaskForTarget, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
 {
     if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Owner))
-        allowedMaskForTarget |= { 0x00002000u, 0x1E008000u, 0xFFE10000u, 0x0800007Eu, 0x80FFFC00u, 0xFFFFFFFFu, 0x00000003u };
+        allowedMaskForTarget |= { 0x00002000u, 0x3C010000u, 0xFFC20000u, 0x200000FEu, 0x03FFF000u, 0xFFFFFFFEu, 0x0000000Fu };
     if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::UnitAll))
-        allowedMaskForTarget |= { 0x00000000u, 0x00000000u, 0x00000000u, 0x08000000u, 0x00FFFC00u, 0x00000000u, 0x00000000u };
+        allowedMaskForTarget |= { 0x00000000u, 0x00000000u, 0x00000000u, 0x20000000u, 0x03FFF000u, 0x00000000u, 0x00000000u };
     if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::Empath))
-        allowedMaskForTarget |= { 0x00000000u, 0x1E000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x000FF000u, 0x00000000u };
+        allowedMaskForTarget |= { 0x00000000u, 0x3C000000u, 0x00000000u, 0x00000000u, 0x00000000u, 0x003FC000u, 0x00000000u };
 }
 
 void UnitData::FilterDisallowedFieldsMaskForFlag(Mask& changesMask, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
 {
-    Mask allowedMaskForTarget({ 0xFFFFDFFFu, 0xE1FF7FFFu, 0x001EFFFFu, 0xFFFFFF81u, 0x7F0003FFu, 0x00000000u, 0x00000000u });
+    Mask allowedMaskForTarget({ 0xFFFFDFFFu, 0xC3FEFFFFu, 0x003DFFFFu, 0xFFFFFF01u, 0xFC000FFFu, 0x00000001u, 0x00000000u });
     AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
     changesMask &= allowedMaskForTarget;
 }
@@ -1310,473 +1303,481 @@ void UnitData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignor
         }
         if (changesMask[23])
         {
-            data << uint32(SummonedByHomeRealm);
+            data << int8(SpellEmpowerStage);
         }
         if (changesMask[24])
         {
-            data << uint8(Race);
+            data << uint32(SummonedByHomeRealm);
         }
         if (changesMask[25])
         {
-            data << uint8(ClassId);
+            data << uint8(Race);
         }
         if (changesMask[26])
         {
-            data << uint8(PlayerClassId);
+            data << uint8(ClassId);
         }
         if (changesMask[27])
         {
-            data << uint8(Sex);
+            data << uint8(PlayerClassId);
         }
         if (changesMask[28])
         {
-            data << uint8(DisplayPower);
+            data << uint8(Sex);
         }
         if (changesMask[29])
         {
-            data << uint32(OverrideDisplayPowerID);
+            data << uint8(DisplayPower);
         }
         if (changesMask[30])
         {
-            data << int64(Health);
+            data << uint32(OverrideDisplayPowerID);
         }
         if (changesMask[31])
         {
-            data << int64(MaxHealth);
+            data << int64(Health);
         }
     }
     if (changesMask[32])
     {
         if (changesMask[33])
         {
-            data << int32(Level);
+            data << int64(MaxHealth);
         }
         if (changesMask[34])
         {
-            data << int32(EffectiveLevel);
+            data << int32(Level);
         }
         if (changesMask[35])
         {
-            data << int32(ContentTuningID);
+            data << int32(EffectiveLevel);
         }
         if (changesMask[36])
         {
-            data << int32(ScalingLevelMin);
+            data << int32(ContentTuningID);
         }
         if (changesMask[37])
         {
-            data << int32(ScalingLevelMax);
+            data << int32(ScalingLevelMin);
         }
         if (changesMask[38])
         {
-            data << int32(ScalingLevelDelta);
+            data << int32(ScalingLevelMax);
         }
         if (changesMask[39])
         {
-            data << int32(ScalingFactionGroup);
+            data << int32(ScalingLevelDelta);
         }
         if (changesMask[40])
         {
-            data << int32(ScalingHealthItemLevelCurveID);
+            data << int32(ScalingFactionGroup);
         }
         if (changesMask[41])
         {
-            data << int32(ScalingDamageItemLevelCurveID);
+            data << int32(ScalingHealthItemLevelCurveID);
         }
         if (changesMask[42])
         {
-            data << int32(ViewerDependentValue<FactionTemplateTag>::GetValue(this, owner, receiver));
+            data << int32(ScalingDamageItemLevelCurveID);
         }
         if (changesMask[43])
         {
-            data << uint32(ViewerDependentValue<FlagsTag>::GetValue(this, owner, receiver));
+            data << int32(ViewerDependentValue<FactionTemplateTag>::GetValue(this, owner, receiver));
         }
         if (changesMask[44])
         {
-            data << uint32(Flags2);
+            data << uint32(ViewerDependentValue<FlagsTag>::GetValue(this, owner, receiver));
         }
         if (changesMask[45])
         {
-            data << uint32(ViewerDependentValue<Flags3Tag>::GetValue(this, owner, receiver));
+            data << uint32(Flags2);
         }
         if (changesMask[46])
         {
-            data << uint32(ViewerDependentValue<AuraStateTag>::GetValue(this, owner, receiver));
+            data << uint32(ViewerDependentValue<Flags3Tag>::GetValue(this, owner, receiver));
         }
         if (changesMask[47])
         {
-            data << uint32(RangedAttackRoundBaseTime);
+            data << uint32(ViewerDependentValue<AuraStateTag>::GetValue(this, owner, receiver));
         }
         if (changesMask[48])
         {
-            data << float(BoundingRadius);
+            data << uint32(RangedAttackRoundBaseTime);
         }
         if (changesMask[49])
         {
-            data << float(CombatReach);
+            data << float(BoundingRadius);
         }
         if (changesMask[50])
         {
-            data << float(DisplayScale);
+            data << float(CombatReach);
         }
         if (changesMask[51])
         {
-            data << int32(CreatureFamily);
+            data << float(DisplayScale);
         }
         if (changesMask[52])
         {
-            data << int32(CreatureType);
+            data << int32(CreatureFamily);
         }
         if (changesMask[53])
         {
-            data << int32(NativeDisplayID);
+            data << int32(CreatureType);
         }
         if (changesMask[54])
         {
-            data << float(NativeXDisplayScale);
+            data << int32(NativeDisplayID);
         }
         if (changesMask[55])
         {
-            data << int32(MountDisplayID);
+            data << float(NativeXDisplayScale);
         }
         if (changesMask[56])
         {
-            data << int32(CosmeticMountDisplayID);
+            data << int32(MountDisplayID);
         }
         if (changesMask[57])
         {
-            data << float(MinDamage);
+            data << int32(CosmeticMountDisplayID);
         }
         if (changesMask[58])
         {
-            data << float(MaxDamage);
+            data << float(MinDamage);
         }
         if (changesMask[59])
         {
-            data << float(MinOffHandDamage);
+            data << float(MaxDamage);
         }
         if (changesMask[60])
         {
-            data << float(MaxOffHandDamage);
+            data << float(MinOffHandDamage);
         }
         if (changesMask[61])
         {
-            data << uint8(StandState);
+            data << float(MaxOffHandDamage);
         }
         if (changesMask[62])
         {
-            data << uint8(PetTalentPoints);
+            data << uint8(StandState);
         }
         if (changesMask[63])
         {
-            data << uint8(VisFlags);
+            data << uint8(PetTalentPoints);
         }
     }
     if (changesMask[64])
     {
         if (changesMask[65])
         {
-            data << uint8(AnimTier);
+            data << uint8(VisFlags);
         }
         if (changesMask[66])
         {
-            data << uint32(PetNumber);
+            data << uint8(AnimTier);
         }
         if (changesMask[67])
         {
-            data << uint32(PetNameTimestamp);
+            data << uint32(PetNumber);
         }
         if (changesMask[68])
         {
-            data << uint32(PetExperience);
+            data << uint32(PetNameTimestamp);
         }
         if (changesMask[69])
         {
-            data << uint32(PetNextLevelExperience);
+            data << uint32(PetExperience);
         }
         if (changesMask[70])
         {
-            data << float(ModCastingSpeed);
+            data << uint32(PetNextLevelExperience);
         }
         if (changesMask[71])
         {
-            data << float(ModCastingSpeedNeg);
+            data << float(ModCastingSpeed);
         }
         if (changesMask[72])
         {
-            data << float(ModSpellHaste);
+            data << float(ModCastingSpeedNeg);
         }
         if (changesMask[73])
         {
-            data << float(ModHaste);
+            data << float(ModSpellHaste);
         }
         if (changesMask[74])
         {
-            data << float(ModRangedHaste);
+            data << float(ModHaste);
         }
         if (changesMask[75])
         {
-            data << float(ModHasteRegen);
+            data << float(ModRangedHaste);
         }
         if (changesMask[76])
         {
-            data << float(ModTimeRate);
+            data << float(ModHasteRegen);
         }
         if (changesMask[77])
         {
-            data << int32(CreatedBySpell);
+            data << float(ModTimeRate);
         }
         if (changesMask[78])
         {
-            data << int32(EmoteState);
+            data << int32(CreatedBySpell);
         }
         if (changesMask[79])
         {
-            data << int32(BaseMana);
+            data << int32(EmoteState);
         }
         if (changesMask[80])
         {
-            data << int32(BaseHealth);
+            data << int32(BaseMana);
         }
         if (changesMask[81])
         {
-            data << uint8(SheatheState);
+            data << int32(BaseHealth);
         }
         if (changesMask[82])
         {
-            data << uint8(ViewerDependentValue<PvpFlagsTag>::GetValue(this, owner, receiver));
+            data << uint8(SheatheState);
         }
         if (changesMask[83])
         {
-            data << uint8(PetFlags);
+            data << uint8(ViewerDependentValue<PvpFlagsTag>::GetValue(this, owner, receiver));
         }
         if (changesMask[84])
         {
-            data << uint8(ShapeshiftForm);
+            data << uint8(PetFlags);
         }
         if (changesMask[85])
         {
-            data << int32(AttackPower);
+            data << uint8(ShapeshiftForm);
         }
         if (changesMask[86])
         {
-            data << int32(AttackPowerModPos);
+            data << int32(AttackPower);
         }
         if (changesMask[87])
         {
-            data << int32(AttackPowerModNeg);
+            data << int32(AttackPowerModPos);
         }
         if (changesMask[88])
         {
-            data << float(AttackPowerMultiplier);
+            data << int32(AttackPowerModNeg);
         }
         if (changesMask[89])
         {
-            data << int32(RangedAttackPower);
+            data << float(AttackPowerMultiplier);
         }
         if (changesMask[90])
         {
-            data << int32(RangedAttackPowerModPos);
+            data << int32(RangedAttackPower);
         }
         if (changesMask[91])
         {
-            data << int32(RangedAttackPowerModNeg);
+            data << int32(RangedAttackPowerModPos);
         }
         if (changesMask[92])
         {
-            data << float(RangedAttackPowerMultiplier);
+            data << int32(RangedAttackPowerModNeg);
         }
         if (changesMask[93])
         {
-            data << int32(MainHandWeaponAttackPower);
+            data << float(RangedAttackPowerMultiplier);
         }
         if (changesMask[94])
         {
-            data << int32(OffHandWeaponAttackPower);
+            data << int32(MainHandWeaponAttackPower);
         }
         if (changesMask[95])
         {
-            data << int32(RangedWeaponAttackPower);
+            data << int32(OffHandWeaponAttackPower);
         }
     }
     if (changesMask[96])
     {
         if (changesMask[97])
         {
-            data << int32(SetAttackSpeedAura);
+            data << int32(RangedWeaponAttackPower);
         }
         if (changesMask[98])
         {
-            data << float(Lifesteal);
+            data << int32(SetAttackSpeedAura);
         }
         if (changesMask[99])
         {
-            data << float(MinRangedDamage);
+            data << float(Lifesteal);
         }
         if (changesMask[100])
         {
-            data << float(MaxRangedDamage);
+            data << float(MinRangedDamage);
         }
         if (changesMask[101])
         {
-            data << float(ManaCostMultiplier);
+            data << float(MaxRangedDamage);
         }
         if (changesMask[102])
         {
-            data << float(MaxHealthModifier);
+            data << float(ManaCostMultiplier);
         }
         if (changesMask[103])
         {
-            data << float(HoverHeight);
+            data << float(MaxHealthModifier);
         }
         if (changesMask[104])
         {
-            data << int32(MinItemLevelCutoff);
+            data << float(HoverHeight);
         }
         if (changesMask[105])
         {
-            data << int32(MinItemLevel);
+            data << int32(MinItemLevelCutoff);
         }
         if (changesMask[106])
         {
-            data << int32(MaxItemLevel);
+            data << int32(MinItemLevel);
         }
         if (changesMask[107])
         {
-            data << int32(AzeriteItemLevel);
+            data << int32(MaxItemLevel);
         }
         if (changesMask[108])
         {
-            data << int32(WildBattlePetLevel);
+            data << int32(AzeriteItemLevel);
         }
         if (changesMask[109])
         {
-            data << int32(BattlePetCompanionExperience);
+            data << int32(WildBattlePetLevel);
         }
         if (changesMask[110])
         {
-            data << uint32(BattlePetCompanionNameTimestamp);
+            data << int32(BattlePetCompanionExperience);
         }
         if (changesMask[111])
         {
-            data << int32(InteractSpellID);
+            data << uint32(BattlePetCompanionNameTimestamp);
         }
         if (changesMask[112])
         {
-            data << int32(ScaleDuration);
+            data << int32(InteractSpellID);
         }
         if (changesMask[113])
         {
-            data << int32(LooksLikeMountID);
+            data << int32(ScaleDuration);
         }
         if (changesMask[114])
         {
-            data << int32(LooksLikeCreatureID);
+            data << int32(LooksLikeMountID);
         }
         if (changesMask[115])
         {
-            data << int32(LookAtControllerID);
+            data << int32(LooksLikeCreatureID);
         }
         if (changesMask[116])
         {
-            data << int32(TaxiNodesID);
+            data << int32(LookAtControllerID);
         }
         if (changesMask[117])
         {
-            data << GuildGUID;
+            data << int32(TaxiNodesID);
         }
         if (changesMask[118])
         {
-            data << uint32(SilencedSchoolMask);
+            data << GuildGUID;
         }
         if (changesMask[119])
         {
+            data << int32(FlightCapabilityID);
+        }
+        if (changesMask[120])
+        {
+            data << uint32(SilencedSchoolMask);
+        }
+        if (changesMask[121])
+        {
             data << NameplateAttachToGUID;
         }
     }
-    if (changesMask[120])
+    if (changesMask[122])
     {
         for (uint32 i = 0; i < 2; ++i)
         {
-            if (changesMask[121 + i])
+            if (changesMask[123 + i])
             {
                 data << uint32(ViewerDependentValue<NpcFlagsTag>::GetValue(this, i, owner, receiver));
             }
         }
     }
-    if (changesMask[123])
+    if (changesMask[125])
     {
         for (uint32 i = 0; i < 7; ++i)
         {
-            if (changesMask[124 + i])
+            if (changesMask[126 + i])
             {
                 data << int32(Power[i]);
             }
-            if (changesMask[131 + i])
+            if (changesMask[133 + i])
             {
                 data << int32(MaxPower[i]);
             }
-            if (changesMask[138 + i])
+            if (changesMask[140 + i])
             {
                 data << float(PowerRegenFlatModifier[i]);
             }
-            if (changesMask[145 + i])
+            if (changesMask[147 + i])
             {
                 data << float(PowerRegenInterruptedFlatModifier[i]);
             }
         }
     }
-    if (changesMask[152])
+    if (changesMask[154])
     {
         for (uint32 i = 0; i < 3; ++i)
         {
-            if (changesMask[153 + i])
+            if (changesMask[155 + i])
             {
                 VirtualItems[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
             }
         }
     }
-    if (changesMask[156])
+    if (changesMask[158])
     {
         for (uint32 i = 0; i < 2; ++i)
         {
-            if (changesMask[157 + i])
+            if (changesMask[159 + i])
             {
                 data << uint32(AttackRoundBaseTime[i]);
             }
         }
     }
-    if (changesMask[159])
+    if (changesMask[161])
     {
         for (uint32 i = 0; i < 4; ++i)
         {
-            if (changesMask[160 + i])
+            if (changesMask[162 + i])
             {
                 data << int32(Stats[i]);
             }
-            if (changesMask[164 + i])
+            if (changesMask[166 + i])
             {
                 data << int32(StatPosBuff[i]);
             }
-            if (changesMask[168 + i])
+            if (changesMask[170 + i])
             {
                 data << int32(StatNegBuff[i]);
             }
         }
     }
-    if (changesMask[172])
+    if (changesMask[174])
     {
         for (uint32 i = 0; i < 7; ++i)
         {
-            if (changesMask[173 + i])
+            if (changesMask[175 + i])
             {
                 data << int32(Resistances[i]);
             }
-            if (changesMask[180 + i])
+            if (changesMask[182 + i])
             {
                 data << int32(BonusResistanceMods[i]);
             }
-            if (changesMask[187 + i])
+            if (changesMask[189 + i])
             {
                 data << int32(ManaCostModifier[i]);
             }
@@ -1808,6 +1809,7 @@ void UnitData::ClearChangesMask()
     Base::ClearChangesMask(BattlePetCompanionGUID);
     Base::ClearChangesMask(BattlePetDBID);
     Base::ClearChangesMask(ChannelData);
+    Base::ClearChangesMask(SpellEmpowerStage);
     Base::ClearChangesMask(SummonedByHomeRealm);
     Base::ClearChangesMask(Race);
     Base::ClearChangesMask(ClassId);
@@ -1900,6 +1902,7 @@ void UnitData::ClearChangesMask()
     Base::ClearChangesMask(LookAtControllerID);
     Base::ClearChangesMask(TaxiNodesID);
     Base::ClearChangesMask(GuildGUID);
+    Base::ClearChangesMask(FlightCapabilityID);
     Base::ClearChangesMask(SilencedSchoolMask);
     Base::ClearChangesMask(NameplateAttachToGUID);
     Base::ClearChangesMask(NpcFlags);
@@ -2133,12 +2136,14 @@ void PlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVi
     }
     data << uint8(CurrentBattlePetBreedQuality);
     data << int32(HonorLevel);
+    data << int64(LogoutTime);
     data << uint32(ArenaCooldowns.size());
     data << int32(Field_B0);
     data << int32(Field_B4);
     CtrOptions->WriteCreate(data, owner, receiver);
     data << int32(CovenantID);
     data << int32(SoulbindID);
+    data << uint32(VisualItemReplacements.size());
     for (uint32 i = 0; i < Customizations.size(); ++i)
     {
         Customizations[i].WriteCreate(data, owner, receiver);
@@ -2154,6 +2159,10 @@ void PlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVi
     {
         ArenaCooldowns[i].WriteCreate(data, owner, receiver);
     }
+    for (uint32 i = 0; i < VisualItemReplacements.size(); ++i)
+    {
+        data << int32(VisualItemReplacements[i]);
+    }
     if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::PartyMember))
     {
         data.WriteBit(HasQuestSession);
@@ -2165,7 +2174,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, 0x00000007u, 0x00000000u, 0x00000000u, 0x00000000u, 0x0FFFFFFEu });
+    Mask allowedMaskForTarget({ 0xFFFFFFEDu, 0x0000001Fu, 0x00000000u, 0x00000000u, 0x00000000u, 0x3FFFFFF8u });
     AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
     WriteUpdate(data, _changesMask & allowedMaskForTarget, false, owner, receiver);
 }
@@ -2173,12 +2182,12 @@ void PlayerData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVi
 void PlayerData::AppendAllowedFieldsMaskForFlag(Mask& allowedMaskForTarget, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
 {
     if (fieldVisibilityFlags.HasFlag(UpdateFieldFlag::PartyMember))
-        allowedMaskForTarget |= { 0x00000012u, 0xFFFFFFF8u, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0x00000001u };
+        allowedMaskForTarget |= { 0x00000012u, 0xFFFFFFE0u, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0x00000007u };
 }
 
 void PlayerData::FilterDisallowedFieldsMaskForFlag(Mask& changesMask, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags)
 {
-    Mask allowedMaskForTarget({ 0xFFFFFFEDu, 0x00000007u, 0x00000000u, 0x00000000u, 0x00000000u, 0x0FFFFFFEu });
+    Mask allowedMaskForTarget({ 0xFFFFFFEDu, 0x0000001Fu, 0x00000000u, 0x00000000u, 0x00000000u, 0x3FFFFFF8u });
     AppendAllowedFieldsMaskForFlag(allowedMaskForTarget, fieldVisibilityFlags);
     changesMask &= allowedMaskForTarget;
 }
@@ -2222,6 +2231,13 @@ void PlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ign
             else
                 WriteCompleteDynamicFieldUpdateMask(ArenaCooldowns.size(), data);
         }
+        if (changesMask[6])
+        {
+            if (!ignoreNestedChangesMask)
+                VisualItemReplacements.WriteUpdateMask(data);
+            else
+                WriteCompleteDynamicFieldUpdateMask(VisualItemReplacements.size(), data);
+        }
     }
     data.FlushBits();
     if (changesMask[0])
@@ -2261,125 +2277,139 @@ void PlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ign
         }
         if (changesMask[6])
         {
-            data << DuelArbiter;
+            for (uint32 i = 0; i < VisualItemReplacements.size(); ++i)
+            {
+                if (VisualItemReplacements.HasChanged(i) || ignoreNestedChangesMask)
+                {
+                    data << int32(VisualItemReplacements[i]);
+                }
+            }
         }
         if (changesMask[7])
         {
-            data << WowAccount;
+            data << DuelArbiter;
         }
         if (changesMask[8])
         {
-            data << LootTargetGUID;
+            data << WowAccount;
         }
         if (changesMask[9])
         {
-            data << uint32(PlayerFlags);
+            data << LootTargetGUID;
         }
         if (changesMask[10])
         {
-            data << uint32(PlayerFlagsEx);
+            data << uint32(PlayerFlags);
         }
         if (changesMask[11])
         {
-            data << uint32(GuildRankID);
+            data << uint32(PlayerFlagsEx);
         }
         if (changesMask[12])
         {
-            data << uint32(GuildDeleteDate);
+            data << uint32(GuildRankID);
         }
         if (changesMask[13])
         {
-            data << int32(GuildLevel);
+            data << uint32(GuildDeleteDate);
         }
         if (changesMask[14])
         {
-            data << uint8(PartyType);
+            data << int32(GuildLevel);
         }
         if (changesMask[15])
         {
-            data << uint8(NativeSex);
+            data << uint8(PartyType);
         }
         if (changesMask[16])
         {
-            data << uint8(Inebriation);
+            data << uint8(NativeSex);
         }
         if (changesMask[17])
         {
-            data << uint8(PvpTitle);
+            data << uint8(Inebriation);
         }
         if (changesMask[18])
         {
-            data << uint8(ArenaFaction);
+            data << uint8(PvpTitle);
         }
         if (changesMask[19])
         {
-            data << uint32(DuelTeam);
+            data << uint8(ArenaFaction);
         }
         if (changesMask[20])
         {
-            data << int32(GuildTimeStamp);
+            data << uint32(DuelTeam);
         }
         if (changesMask[21])
         {
-            data << int32(PlayerTitle);
+            data << int32(GuildTimeStamp);
         }
         if (changesMask[22])
         {
-            data << int32(FakeInebriation);
+            data << int32(PlayerTitle);
         }
         if (changesMask[23])
         {
-            data << uint32(VirtualPlayerRealm);
+            data << int32(FakeInebriation);
         }
         if (changesMask[24])
         {
-            data << uint32(CurrentSpecID);
+            data << uint32(VirtualPlayerRealm);
         }
         if (changesMask[25])
         {
-            data << int32(TaxiMountAnimKitID);
+            data << uint32(CurrentSpecID);
         }
         if (changesMask[26])
         {
-            data << uint8(CurrentBattlePetBreedQuality);
+            data << int32(TaxiMountAnimKitID);
         }
         if (changesMask[27])
         {
-            data << int32(HonorLevel);
+            data << uint8(CurrentBattlePetBreedQuality);
         }
         if (changesMask[28])
         {
-            data << int32(Field_B0);
+            data << int32(HonorLevel);
         }
         if (changesMask[29])
         {
-            data << int32(Field_B4);
+            data << int64(LogoutTime);
         }
         if (changesMask[30])
         {
-            CtrOptions->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
+            data << int32(Field_B0);
         }
         if (changesMask[31])
         {
-            data << int32(CovenantID);
+            data << int32(Field_B4);
         }
     }
     if (changesMask[32])
     {
         if (changesMask[33])
         {
-            data << int32(SoulbindID);
+            CtrOptions->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
         if (changesMask[34])
         {
+            data << int32(CovenantID);
+        }
+        if (changesMask[35])
+        {
+            data << int32(SoulbindID);
+        }
+        if (changesMask[36])
+        {
             data << DungeonScore;
         }
     }
-    if (changesMask[35])
+    if (changesMask[37])
     {
         for (uint32 i = 0; i < 125; ++i)
         {
-            if (changesMask[36 + i])
+            if (changesMask[38 + i])
             {
                 if (noQuestLogChangesMask)
                     QuestLog[i].WriteCreate(data, owner, receiver);
@@ -2388,21 +2418,21 @@ void PlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ign
             }
         }
     }
-    if (changesMask[161])
+    if (changesMask[163])
     {
         for (uint32 i = 0; i < 19; ++i)
         {
-            if (changesMask[162 + i])
+            if (changesMask[164 + i])
             {
                 VisibleItems[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
             }
         }
     }
-    if (changesMask[181])
+    if (changesMask[183])
     {
         for (uint32 i = 0; i < 6; ++i)
         {
-            if (changesMask[182 + i])
+            if (changesMask[184 + i])
             {
                 data << float(AvgItemLevel[i]);
             }
@@ -2418,6 +2448,7 @@ void PlayerData::ClearChangesMask()
     Base::ClearChangesMask(Customizations);
     Base::ClearChangesMask(QuestSessionQuestLog);
     Base::ClearChangesMask(ArenaCooldowns);
+    Base::ClearChangesMask(VisualItemReplacements);
     Base::ClearChangesMask(DuelArbiter);
     Base::ClearChangesMask(WowAccount);
     Base::ClearChangesMask(LootTargetGUID);
@@ -2440,6 +2471,7 @@ void PlayerData::ClearChangesMask()
     Base::ClearChangesMask(TaxiMountAnimKitID);
     Base::ClearChangesMask(CurrentBattlePetBreedQuality);
     Base::ClearChangesMask(HonorLevel);
+    Base::ClearChangesMask(LogoutTime);
     Base::ClearChangesMask(Field_B0);
     Base::ClearChangesMask(Field_B4);
     Base::ClearChangesMask(CtrOptions);
@@ -2565,6 +2597,8 @@ void RestInfo::ClearChangesMask()
 
 void PVPInfo::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
 {
+    data << int8(Bracket);
+    data << int32(PvpRatingID);
     data << uint32(WeeklyPlayed);
     data << uint32(WeeklyWon);
     data << uint32(SeasonPlayed);
@@ -2576,6 +2610,10 @@ void PVPInfo::WriteCreate(ByteBuffer& data, Player const* owner, Player const* r
     data << uint32(WeeklyBestWinPvpTierID);
     data << uint32(Field_28);
     data << uint32(Field_2C);
+    data << uint32(WeeklyRoundsPlayed);
+    data << uint32(WeeklyRoundsWon);
+    data << uint32(SeasonRoundsPlayed);
+    data << uint32(SeasonRoundsWon);
     data.WriteBit(Disqualified);
     data.FlushBits();
 }
@@ -2586,7 +2624,7 @@ void PVPInfo::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const
     if (ignoreChangesMask)
         changesMask.SetAll();
 
-    data.WriteBits(changesMask.GetBlock(0), 13);
+    data.WriteBits(changesMask.GetBlock(0), 19);
 
     if (changesMask[0])
     {
@@ -2600,48 +2638,72 @@ void PVPInfo::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const
     {
         if (changesMask[2])
         {
-            data << uint32(WeeklyPlayed);
+            data << int8(Bracket);
         }
         if (changesMask[3])
         {
-            data << uint32(WeeklyWon);
+            data << int32(PvpRatingID);
         }
         if (changesMask[4])
         {
-            data << uint32(SeasonPlayed);
+            data << uint32(WeeklyPlayed);
         }
         if (changesMask[5])
         {
-            data << uint32(SeasonWon);
+            data << uint32(WeeklyWon);
         }
         if (changesMask[6])
         {
-            data << uint32(Rating);
+            data << uint32(SeasonPlayed);
         }
         if (changesMask[7])
         {
-            data << uint32(WeeklyBestRating);
+            data << uint32(SeasonWon);
         }
         if (changesMask[8])
         {
-            data << uint32(SeasonBestRating);
+            data << uint32(Rating);
         }
         if (changesMask[9])
         {
-            data << uint32(PvpTierID);
+            data << uint32(WeeklyBestRating);
         }
         if (changesMask[10])
         {
-            data << uint32(WeeklyBestWinPvpTierID);
+            data << uint32(SeasonBestRating);
         }
         if (changesMask[11])
         {
-            data << uint32(Field_28);
+            data << uint32(PvpTierID);
         }
         if (changesMask[12])
         {
+            data << uint32(WeeklyBestWinPvpTierID);
+        }
+        if (changesMask[13])
+        {
+            data << uint32(Field_28);
+        }
+        if (changesMask[14])
+        {
             data << uint32(Field_2C);
         }
+        if (changesMask[15])
+        {
+            data << uint32(WeeklyRoundsPlayed);
+        }
+        if (changesMask[16])
+        {
+            data << uint32(WeeklyRoundsWon);
+        }
+        if (changesMask[17])
+        {
+            data << uint32(SeasonRoundsPlayed);
+        }
+        if (changesMask[18])
+        {
+            data << uint32(SeasonRoundsWon);
+        }
     }
     data.FlushBits();
 }
@@ -2649,6 +2711,8 @@ void PVPInfo::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const
 void PVPInfo::ClearChangesMask()
 {
     Base::ClearChangesMask(Disqualified);
+    Base::ClearChangesMask(Bracket);
+    Base::ClearChangesMask(PvpRatingID);
     Base::ClearChangesMask(WeeklyPlayed);
     Base::ClearChangesMask(WeeklyWon);
     Base::ClearChangesMask(SeasonPlayed);
@@ -2660,6 +2724,10 @@ void PVPInfo::ClearChangesMask()
     Base::ClearChangesMask(WeeklyBestWinPvpTierID);
     Base::ClearChangesMask(Field_28);
     Base::ClearChangesMask(Field_2C);
+    Base::ClearChangesMask(WeeklyRoundsPlayed);
+    Base::ClearChangesMask(WeeklyRoundsWon);
+    Base::ClearChangesMask(SeasonRoundsPlayed);
+    Base::ClearChangesMask(SeasonRoundsWon);
     _changesMask.ResetAll();
 }
 
@@ -2926,9 +2994,514 @@ void ReplayedQuest::ClearChangesMask()
     _changesMask.ResetAll();
 }
 
+void TraitEntry::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
+{
+    data << int32(TraitNodeID);
+    data << int32(TraitNodeEntryID);
+    data << int32(Rank);
+    data << int32(GrantedRanks);
+}
+
+void TraitEntry::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
+{
+    data << int32(TraitNodeID);
+    data << int32(TraitNodeEntryID);
+    data << int32(Rank);
+    data << int32(GrantedRanks);
+}
+
+bool TraitEntry::operator==(TraitEntry const& right) const
+{
+    return TraitNodeID == right.TraitNodeID
+        && TraitNodeEntryID == right.TraitNodeEntryID
+        && Rank == right.Rank
+        && GrantedRanks == right.GrantedRanks;
+}
+
+void TraitConfig::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
+{
+    data << int32(ID);
+    data << int32(Type);
+    data << uint32(Entries.size());
+    if (Type == 2)
+    {
+        data << int32(SkillLineID);
+    }
+    if (Type == 1)
+    {
+        data << int32(ChrSpecializationID);
+        data << int32(CombatConfigFlags);
+        data << int32(LocalIdentifier);
+    }
+    if (Type == 3)
+    {
+        data << int32(TraitSystemID);
+    }
+    for (uint32 i = 0; i < Entries.size(); ++i)
+    {
+        Entries[i].WriteCreate(data, owner, receiver);
+    }
+    data.WriteBits(Name->size(), 9);
+    data.WriteString(Name);
+    data.FlushBits();
+}
+
+void TraitConfig::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
+{
+    Mask changesMask = _changesMask;
+    if (ignoreChangesMask)
+        changesMask.SetAll();
+
+    data.WriteBits(changesMask.GetBlock(0), 12);
+
+    if (changesMask[0])
+    {
+        if (changesMask[1])
+        {
+            if (!ignoreChangesMask)
+                Entries.WriteUpdateMask(data);
+            else
+                WriteCompleteDynamicFieldUpdateMask(Entries.size(), data);
+        }
+    }
+    data.FlushBits();
+    if (changesMask[0])
+    {
+        if (changesMask[1])
+        {
+            for (uint32 i = 0; i < Entries.size(); ++i)
+            {
+                if (Entries.HasChanged(i) || ignoreChangesMask)
+                {
+                    Entries[i].WriteUpdate(data, ignoreChangesMask, owner, receiver);
+                }
+            }
+        }
+        if (changesMask[2])
+        {
+            data << int32(ID);
+        }
+    }
+    if (changesMask[4])
+    {
+        if (changesMask[5])
+        {
+            data << int32(Type);
+        }
+        if (changesMask[6])
+        {
+            if (Type == 2)
+            {
+                data << int32(SkillLineID);
+            }
+        }
+        if (changesMask[7])
+        {
+            if (Type == 1)
+            {
+                data << int32(ChrSpecializationID);
+            }
+        }
+    }
+    if (changesMask[8])
+    {
+        if (changesMask[9])
+        {
+            if (Type == 1)
+            {
+                data << int32(CombatConfigFlags);
+            }
+        }
+        if (changesMask[10])
+        {
+            if (Type == 1)
+            {
+                data << int32(LocalIdentifier);
+            }
+        }
+        if (changesMask[11])
+        {
+            if (Type == 3)
+            {
+                data << int32(TraitSystemID);
+            }
+        }
+    }
+    if (changesMask[0])
+    {
+        if (changesMask[3])
+        {
+            data.WriteBits(Name->size(), 9);
+            data.WriteString(Name);
+        }
+    }
+    data.FlushBits();
+}
+
+void TraitConfig::ClearChangesMask()
+{
+    Base::ClearChangesMask(Entries);
+    Base::ClearChangesMask(ID);
+    Base::ClearChangesMask(Name);
+    Base::ClearChangesMask(Type);
+    Base::ClearChangesMask(SkillLineID);
+    Base::ClearChangesMask(ChrSpecializationID);
+    Base::ClearChangesMask(CombatConfigFlags);
+    Base::ClearChangesMask(LocalIdentifier);
+    Base::ClearChangesMask(TraitSystemID);
+    _changesMask.ResetAll();
+}
+
+void CraftingOrderItem::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
+{
+    data << uint64(Field_0);
+    data << ItemGUID;
+    data << OwnerGUID;
+    data << int32(ItemID);
+    data << uint32(Quantity);
+    data << int32(ReagentQuality);
+    data.WriteBits(DataSlotIndex.has_value(), 1);
+    if (DataSlotIndex.has_value())
+    {
+        data << uint8(DataSlotIndex);
+    }
+}
+
+void CraftingOrderItem::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
+{
+    Mask changesMask = _changesMask;
+    if (ignoreChangesMask)
+        changesMask.SetAll();
+
+    data.WriteBits(changesMask.GetBlock(0), 7);
+
+    data.FlushBits();
+    if (changesMask[0])
+    {
+        data << uint64(Field_0);
+    }
+    if (changesMask[1])
+    {
+        data << ItemGUID;
+    }
+    if (changesMask[2])
+    {
+        data << OwnerGUID;
+    }
+    if (changesMask[3])
+    {
+        data << int32(ItemID);
+    }
+    if (changesMask[4])
+    {
+        data << uint32(Quantity);
+    }
+    if (changesMask[5])
+    {
+        data << int32(ReagentQuality);
+    }
+    data.WriteBits(DataSlotIndex.has_value(), 1);
+    if (changesMask[6])
+    {
+        if (DataSlotIndex.has_value())
+        {
+            data << uint8(DataSlotIndex);
+        }
+    }
+}
+
+void CraftingOrderItem::ClearChangesMask()
+{
+    Base::ClearChangesMask(Field_0);
+    Base::ClearChangesMask(ItemGUID);
+    Base::ClearChangesMask(OwnerGUID);
+    Base::ClearChangesMask(ItemID);
+    Base::ClearChangesMask(Quantity);
+    Base::ClearChangesMask(ReagentQuality);
+    Base::ClearChangesMask(DataSlotIndex);
+    _changesMask.ResetAll();
+}
+
+void CraftingOrderData::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
+{
+    data << int32(Field_0);
+    data << uint64(OrderID);
+    data << int32(SkillLineAbilityID);
+    data << uint8(OrderState);
+    data << uint8(OrderType);
+    data << uint8(MinQuality);
+    data << int64(ExpirationTime);
+    data << int64(ClaimEndTime);
+    data << int64(TipAmount);
+    data << int64(ConsortiumCut);
+    data << uint32(Flags);
+    data << CustomerGUID;
+    data << CustomerAccountGUID;
+    data << CrafterGUID;
+    data << PersonalCrafterGUID;
+    data << uint32(Reagents.size());
+    data.WriteBits(CustomerNotes->size(), 10);
+    data.WriteBits(OutputItem.has_value(), 1);
+    data.WriteBits(OutputItemData.has_value(), 1);
+    for (uint32 i = 0; i < Reagents.size(); ++i)
+    {
+        Reagents[i].WriteCreate(data, owner, receiver);
+    }
+    data.WriteString(CustomerNotes);
+    if (OutputItem.has_value())
+    {
+        OutputItem->WriteCreate(data, owner, receiver);
+    }
+    if (OutputItemData.has_value())
+    {
+        data << OutputItemData;
+    }
+    data.FlushBits();
+}
+
+void CraftingOrderData::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
+{
+    Mask changesMask = _changesMask;
+    if (ignoreChangesMask)
+        changesMask.SetAll();
+
+    data.WriteBits(changesMask.GetBlock(0), 24);
+
+    if (changesMask[0])
+    {
+        if (changesMask[1])
+        {
+            if (!ignoreChangesMask)
+                Reagents.WriteUpdateMask(data);
+            else
+                WriteCompleteDynamicFieldUpdateMask(Reagents.size(), data);
+        }
+    }
+    data.FlushBits();
+    if (changesMask[0])
+    {
+        if (changesMask[1])
+        {
+            for (uint32 i = 0; i < Reagents.size(); ++i)
+            {
+                if (Reagents.HasChanged(i) || ignoreChangesMask)
+                {
+                    Reagents[i].WriteUpdate(data, ignoreChangesMask, owner, receiver);
+                }
+            }
+        }
+        if (changesMask[2])
+        {
+            data << int32(Field_0);
+        }
+        if (changesMask[3])
+        {
+            data << uint64(OrderID);
+        }
+        if (changesMask[4])
+        {
+            data << int32(SkillLineAbilityID);
+        }
+    }
+    if (changesMask[5])
+    {
+        if (changesMask[6])
+        {
+            data << uint8(OrderState);
+        }
+        if (changesMask[7])
+        {
+            data << uint8(OrderType);
+        }
+        if (changesMask[8])
+        {
+            data << uint8(MinQuality);
+        }
+        if (changesMask[9])
+        {
+            data << int64(ExpirationTime);
+        }
+    }
+    if (changesMask[10])
+    {
+        if (changesMask[11])
+        {
+            data << int64(ClaimEndTime);
+        }
+        if (changesMask[12])
+        {
+            data << int64(TipAmount);
+        }
+        if (changesMask[13])
+        {
+            data << int64(ConsortiumCut);
+        }
+        if (changesMask[14])
+        {
+            data << uint32(Flags);
+        }
+    }
+    if (changesMask[15])
+    {
+        if (changesMask[16])
+        {
+            data << CustomerGUID;
+        }
+        if (changesMask[17])
+        {
+            data << CustomerAccountGUID;
+        }
+        if (changesMask[18])
+        {
+            data << CrafterGUID;
+        }
+        if (changesMask[19])
+        {
+            data << PersonalCrafterGUID;
+        }
+    }
+    if (changesMask[20])
+    {
+        if (changesMask[21])
+        {
+            data.WriteBits(CustomerNotes->size(), 10);
+            data.WriteString(CustomerNotes);
+        }
+        data.WriteBits(OutputItem.has_value(), 1);
+        data.WriteBits(OutputItemData.has_value(), 1);
+        if (changesMask[22])
+        {
+            if (OutputItem.has_value())
+            {
+                OutputItem->WriteUpdate(data, ignoreChangesMask, owner, receiver);
+            }
+        }
+        if (changesMask[23])
+        {
+            if (OutputItemData.has_value())
+            {
+                data << OutputItemData;
+            }
+        }
+    }
+    data.FlushBits();
+}
+
+void CraftingOrderData::ClearChangesMask()
+{
+    Base::ClearChangesMask(Reagents);
+    Base::ClearChangesMask(Field_0);
+    Base::ClearChangesMask(OrderID);
+    Base::ClearChangesMask(SkillLineAbilityID);
+    Base::ClearChangesMask(OrderState);
+    Base::ClearChangesMask(OrderType);
+    Base::ClearChangesMask(MinQuality);
+    Base::ClearChangesMask(ExpirationTime);
+    Base::ClearChangesMask(ClaimEndTime);
+    Base::ClearChangesMask(TipAmount);
+    Base::ClearChangesMask(ConsortiumCut);
+    Base::ClearChangesMask(Flags);
+    Base::ClearChangesMask(CustomerGUID);
+    Base::ClearChangesMask(CustomerAccountGUID);
+    Base::ClearChangesMask(CrafterGUID);
+    Base::ClearChangesMask(PersonalCrafterGUID);
+    Base::ClearChangesMask(CustomerNotes);
+    Base::ClearChangesMask(OutputItem);
+    Base::ClearChangesMask(OutputItemData);
+    _changesMask.ResetAll();
+}
+
+void CraftingOrder::WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const
+{
+    Data->WriteCreate(data, owner, receiver);
+    data.WriteBits(RecraftItemInfo.has_value(), 1);
+    data.WriteBits(Enchantments.size(), 4);
+    data.WriteBits(Gems.size(), 2);
+    if (RecraftItemInfo.has_value())
+    {
+        data << RecraftItemInfo;
+    }
+    for (uint32 i = 0; i < Enchantments.size(); ++i)
+    {
+        data << Enchantments[i];
+    }
+    for (uint32 i = 0; i < Gems.size(); ++i)
+    {
+        data << Gems[i];
+    }
+    data.FlushBits();
+}
+
+void CraftingOrder::WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const
+{
+    Mask changesMask = _changesMask;
+    if (ignoreChangesMask)
+        changesMask.SetAll();
+
+    data.WriteBits(changesMask.GetBlock(0), 4);
+
+    if (changesMask[0])
+    {
+        if (!ignoreChangesMask)
+            Enchantments.WriteUpdateMask(data, 4);
+        else
+            WriteCompleteDynamicFieldUpdateMask(Enchantments.size(), data, 4);
+    }
+    if (changesMask[1])
+    {
+        if (!ignoreChangesMask)
+            Gems.WriteUpdateMask(data, 2);
+        else
+            WriteCompleteDynamicFieldUpdateMask(Gems.size(), data, 2);
+    }
+    data.FlushBits();
+    if (changesMask[0])
+    {
+        for (uint32 i = 0; i < Enchantments.size(); ++i)
+        {
+            if (Enchantments.HasChanged(i) || ignoreChangesMask)
+            {
+                data << Enchantments[i];
+            }
+        }
+    }
+    if (changesMask[1])
+    {
+        for (uint32 i = 0; i < Gems.size(); ++i)
+        {
+            if (Gems.HasChanged(i) || ignoreChangesMask)
+            {
+                data << Gems[i];
+            }
+        }
+    }
+    if (changesMask[2])
+    {
+        Data->WriteUpdate(data, ignoreChangesMask, owner, receiver);
+    }
+    data.WriteBits(RecraftItemInfo.has_value(), 1);
+    if (changesMask[3])
+    {
+        if (RecraftItemInfo.has_value())
+        {
+            data << RecraftItemInfo;
+        }
+    }
+    data.FlushBits();
+}
+
+void CraftingOrder::ClearChangesMask()
+{
+    Base::ClearChangesMask(Enchantments);
+    Base::ClearChangesMask(Gems);
+    Base::ClearChangesMask(Data);
+    Base::ClearChangesMask(RecraftItemInfo);
+    _changesMask.ResetAll();
+}
+
 void ActivePlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, Player const* owner, Player const* receiver) const
 {
-    for (uint32 i = 0; i < 199; ++i)
+    for (uint32 i = 0; i < 218; ++i)
     {
         data << InvSlots[i];
     }
@@ -3014,6 +3587,7 @@ void ActivePlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> f
     {
         data << int32(CombatRatings[i]);
     }
+    data << uint32(PvpInfo.size());
     data << int32(MaxLevel);
     data << int32(ScalingPlayerLevelDelta);
     data << int32(MaxCreatureScalingLevel);
@@ -3040,7 +3614,7 @@ void ActivePlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> f
     data << uint32(OverrideZonePVPType);
     data << BnetAccount;
     data << uint64(GuildClubMemberID);
-    for (uint32 i = 0; i < 4; ++i)
+    for (uint32 i = 0; i < 5; ++i)
     {
         data << uint32(BagSlotFlags[i]);
     }
@@ -3088,6 +3662,9 @@ void ActivePlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> f
     data << int32(TransportServerTime);
     data << uint32(WeeklyRewardsPeriodSinceOrigin);
     data << int16(DEBUGSoulbindConduitRank);
+    data << uint32(TraitConfigs.size());
+    data << uint32(ActiveCombatTraitConfigID);
+    data << uint32(CraftingOrders.size());
     for (uint32 i = 0; i < KnownTitles.size(); ++i)
     {
         data << uint64(KnownTitles[i]);
@@ -3172,10 +3749,6 @@ void ActivePlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> f
     {
         data << int32(DisabledSpells[i]);
     }
-    for (uint32 i = 0; i < 6; ++i)
-    {
-        PvpInfo[i].WriteCreate(data, owner, receiver);
-    }
     data.FlushBits();
     data.WriteBit(BackpackAutoSortDisabled);
     data.WriteBit(BankAutoSortDisabled);
@@ -3188,10 +3761,22 @@ void ActivePlayerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> f
         QuestSession->WriteCreate(data, owner, receiver);
     }
     data << DungeonScore;
+    for (uint32 i = 0; i < PvpInfo.size(); ++i)
+    {
+        PvpInfo[i].WriteCreate(data, owner, receiver);
+    }
     for (uint32 i = 0; i < CharacterRestrictions.size(); ++i)
     {
         CharacterRestrictions[i].WriteCreate(data, owner, receiver);
     }
+    for (uint32 i = 0; i < TraitConfigs.size(); ++i)
+    {
+        TraitConfigs[i].WriteCreate(data, owner, receiver);
+    }
+    for (uint32 i = 0; i < CraftingOrders.size(); ++i)
+    {
+        CraftingOrders[i].WriteCreate(data, owner, receiver);
+    }
     data.FlushBits();
 }
 
@@ -3204,8 +3789,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), 17);
-    for (uint32 i = 0; i < 49; ++i)
+    data.WriteBits(changesMask.GetBlocksMask(1), 18);
+    for (uint32 i = 0; i < 50; ++i)
         if (changesMask.GetBlock(i))
             data.WriteBits(changesMask.GetBlock(i), 32);
 
@@ -3237,109 +3822,116 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
         if (changesMask[6])
         {
             if (!ignoreNestedChangesMask)
+                PvpInfo.WriteUpdateMask(data);
+            else
+                WriteCompleteDynamicFieldUpdateMask(PvpInfo.size(), data);
+        }
+        if (changesMask[7])
+        {
+            if (!ignoreNestedChangesMask)
                 ResearchSites.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(ResearchSites.size(), data);
         }
-        if (changesMask[7])
+        if (changesMask[8])
         {
             if (!ignoreNestedChangesMask)
                 ResearchSiteProgress.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(ResearchSiteProgress.size(), data);
         }
-        if (changesMask[8])
+        if (changesMask[9])
         {
             if (!ignoreNestedChangesMask)
                 DailyQuestsCompleted.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(DailyQuestsCompleted.size(), data);
         }
-        if (changesMask[9])
+        if (changesMask[10])
         {
             if (!ignoreNestedChangesMask)
                 AvailableQuestLineXQuestIDs.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(AvailableQuestLineXQuestIDs.size(), data);
         }
-        if (changesMask[10])
+        if (changesMask[11])
         {
             if (!ignoreNestedChangesMask)
                 Heirlooms.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(Heirlooms.size(), data);
         }
-        if (changesMask[11])
+        if (changesMask[12])
         {
             if (!ignoreNestedChangesMask)
                 HeirloomFlags.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(HeirloomFlags.size(), data);
         }
-        if (changesMask[12])
+        if (changesMask[13])
         {
             if (!ignoreNestedChangesMask)
                 Toys.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(Toys.size(), data);
         }
-        if (changesMask[13])
+        if (changesMask[14])
         {
             if (!ignoreNestedChangesMask)
                 ToyFlags.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(ToyFlags.size(), data);
         }
-        if (changesMask[14])
+        if (changesMask[15])
         {
             if (!ignoreNestedChangesMask)
                 Transmog.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(Transmog.size(), data);
         }
-        if (changesMask[15])
+        if (changesMask[16])
         {
             if (!ignoreNestedChangesMask)
                 ConditionalTransmog.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(ConditionalTransmog.size(), data);
         }
-        if (changesMask[16])
+        if (changesMask[17])
         {
             if (!ignoreNestedChangesMask)
                 SelfResSpells.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(SelfResSpells.size(), data);
         }
-        if (changesMask[17])
+        if (changesMask[18])
         {
             if (!ignoreNestedChangesMask)
                 RuneforgePowers.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(RuneforgePowers.size(), data);
         }
-        if (changesMask[18])
+        if (changesMask[19])
         {
             if (!ignoreNestedChangesMask)
                 TransmogIllusions.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(TransmogIllusions.size(), data);
         }
-        if (changesMask[19])
+        if (changesMask[20])
         {
             if (!ignoreNestedChangesMask)
                 CharacterRestrictions.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(CharacterRestrictions.size(), data);
         }
-        if (changesMask[20])
+        if (changesMask[21])
         {
             if (!ignoreNestedChangesMask)
                 SpellPctModByLabel.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(SpellPctModByLabel.size(), data);
         }
-        if (changesMask[21])
+        if (changesMask[22])
         {
             if (!ignoreNestedChangesMask)
                 SpellFlatModByLabel.WriteUpdateMask(data);
@@ -3347,11 +3939,11 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 WriteCompleteDynamicFieldUpdateMask(SpellFlatModByLabel.size(), data);
         }
     }
-    if (changesMask[27])
+    if (changesMask[30])
     {
         for (uint32 i = 0; i < 1; ++i)
         {
-            if (changesMask[28 + i])
+            if (changesMask[31 + i])
             {
                 if (!ignoreNestedChangesMask)
                     Research[i].WriteUpdateMask(data);
@@ -3370,41 +3962,55 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
     data.FlushBits();
     if (changesMask[0])
     {
-        if (changesMask[22])
+        if (changesMask[23])
         {
             if (!ignoreNestedChangesMask)
                 MawPowers.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(MawPowers.size(), data);
         }
-        if (changesMask[23])
+        if (changesMask[24])
         {
             if (!ignoreNestedChangesMask)
                 MultiFloorExploration.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(MultiFloorExploration.size(), data);
         }
-        if (changesMask[24])
+        if (changesMask[25])
         {
             if (!ignoreNestedChangesMask)
                 RecipeProgression.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(RecipeProgression.size(), data);
         }
-        if (changesMask[25])
+        if (changesMask[26])
         {
             if (!ignoreNestedChangesMask)
                 ReplayedQuests.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(ReplayedQuests.size(), data);
         }
-        if (changesMask[26])
+        if (changesMask[27])
         {
             if (!ignoreNestedChangesMask)
                 DisabledSpells.WriteUpdateMask(data);
             else
                 WriteCompleteDynamicFieldUpdateMask(DisabledSpells.size(), data);
         }
+        if (changesMask[28])
+        {
+            if (!ignoreNestedChangesMask)
+                TraitConfigs.WriteUpdateMask(data);
+            else
+                WriteCompleteDynamicFieldUpdateMask(TraitConfigs.size(), data);
+        }
+        if (changesMask[29])
+        {
+            if (!ignoreNestedChangesMask)
+                CraftingOrders.WriteUpdateMask(data);
+            else
+                WriteCompleteDynamicFieldUpdateMask(CraftingOrders.size(), data);
+        }
     }
     data.FlushBits();
     if (changesMask[0])
@@ -3419,7 +4025,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[6])
+        if (changesMask[7])
         {
             for (uint32 i = 0; i < ResearchSites.size(); ++i)
             {
@@ -3429,7 +4035,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[7])
+        if (changesMask[8])
         {
             for (uint32 i = 0; i < ResearchSiteProgress.size(); ++i)
             {
@@ -3439,7 +4045,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[8])
+        if (changesMask[9])
         {
             for (uint32 i = 0; i < DailyQuestsCompleted.size(); ++i)
             {
@@ -3449,7 +4055,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[9])
+        if (changesMask[10])
         {
             for (uint32 i = 0; i < AvailableQuestLineXQuestIDs.size(); ++i)
             {
@@ -3459,7 +4065,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[10])
+        if (changesMask[11])
         {
             for (uint32 i = 0; i < Heirlooms.size(); ++i)
             {
@@ -3469,7 +4075,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[11])
+        if (changesMask[12])
         {
             for (uint32 i = 0; i < HeirloomFlags.size(); ++i)
             {
@@ -3479,7 +4085,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[12])
+        if (changesMask[13])
         {
             for (uint32 i = 0; i < Toys.size(); ++i)
             {
@@ -3489,7 +4095,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[13])
+        if (changesMask[14])
         {
             for (uint32 i = 0; i < ToyFlags.size(); ++i)
             {
@@ -3499,7 +4105,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[14])
+        if (changesMask[15])
         {
             for (uint32 i = 0; i < Transmog.size(); ++i)
             {
@@ -3509,7 +4115,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[15])
+        if (changesMask[16])
         {
             for (uint32 i = 0; i < ConditionalTransmog.size(); ++i)
             {
@@ -3519,7 +4125,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[16])
+        if (changesMask[17])
         {
             for (uint32 i = 0; i < SelfResSpells.size(); ++i)
             {
@@ -3529,7 +4135,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[17])
+        if (changesMask[18])
         {
             for (uint32 i = 0; i < RuneforgePowers.size(); ++i)
             {
@@ -3539,7 +4145,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[18])
+        if (changesMask[19])
         {
             for (uint32 i = 0; i < TransmogIllusions.size(); ++i)
             {
@@ -3549,7 +4155,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[20])
+        if (changesMask[21])
         {
             for (uint32 i = 0; i < SpellPctModByLabel.size(); ++i)
             {
@@ -3559,7 +4165,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[21])
+        if (changesMask[22])
         {
             for (uint32 i = 0; i < SpellFlatModByLabel.size(); ++i)
             {
@@ -3569,7 +4175,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[22])
+        if (changesMask[23])
         {
             for (uint32 i = 0; i < MawPowers.size(); ++i)
             {
@@ -3579,7 +4185,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[23])
+        if (changesMask[24])
         {
             for (uint32 i = 0; i < MultiFloorExploration.size(); ++i)
             {
@@ -3589,7 +4195,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[24])
+        if (changesMask[25])
         {
             for (uint32 i = 0; i < RecipeProgression.size(); ++i)
             {
@@ -3599,7 +4205,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[25])
+        if (changesMask[26])
         {
             for (uint32 i = 0; i < ReplayedQuests.size(); ++i)
             {
@@ -3609,7 +4215,7 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[26])
+        if (changesMask[27])
         {
             for (uint32 i = 0; i < DisabledSpells.size(); ++i)
             {
@@ -3619,7 +4225,17 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[19])
+        if (changesMask[6])
+        {
+            for (uint32 i = 0; i < PvpInfo.size(); ++i)
+            {
+                if (PvpInfo.HasChanged(i) || ignoreNestedChangesMask)
+                {
+                    PvpInfo[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
+                }
+            }
+        }
+        if (changesMask[20])
         {
             for (uint32 i = 0; i < CharacterRestrictions.size(); ++i)
             {
@@ -3629,493 +4245,507 @@ void ActivePlayerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bo
                 }
             }
         }
-        if (changesMask[29])
-        {
-            data << FarsightObject;
-        }
-        if (changesMask[30])
+        if (changesMask[28])
         {
-            data << SummonedBattlePetGUID;
+            for (uint32 i = 0; i < TraitConfigs.size(); ++i)
+            {
+                if (TraitConfigs.HasChanged(i) || ignoreNestedChangesMask)
+                {
+                    TraitConfigs[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
+                }
+            }
         }
-        if (changesMask[31])
+        if (changesMask[29])
         {
-            data << uint64(Coinage);
+            for (uint32 i = 0; i < CraftingOrders.size(); ++i)
+            {
+                if (CraftingOrders.HasChanged(i) || ignoreNestedChangesMask)
+                {
+                    CraftingOrders[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
+                }
+            }
         }
         if (changesMask[32])
         {
-            data << int32(XP);
+            data << FarsightObject;
         }
         if (changesMask[33])
         {
-            data << int32(NextLevelXP);
+            data << SummonedBattlePetGUID;
         }
     }
     if (changesMask[34])
     {
         if (changesMask[35])
         {
-            data << int32(TrialXP);
+            data << uint64(Coinage);
         }
         if (changesMask[36])
         {
-            Skill->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
+            data << int32(XP);
         }
         if (changesMask[37])
         {
-            data << int32(CharacterPoints);
+            data << int32(NextLevelXP);
         }
         if (changesMask[38])
         {
-            data << int32(MaxTalentTiers);
+            data << int32(TrialXP);
         }
         if (changesMask[39])
         {
-            data << uint32(TrackCreatureMask);
+            Skill->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
         if (changesMask[40])
         {
-            data << float(MainhandExpertise);
+            data << int32(CharacterPoints);
         }
         if (changesMask[41])
         {
-            data << float(OffhandExpertise);
+            data << int32(MaxTalentTiers);
         }
         if (changesMask[42])
         {
-            data << float(RangedExpertise);
+            data << uint32(TrackCreatureMask);
         }
         if (changesMask[43])
         {
-            data << float(CombatRatingExpertise);
+            data << float(MainhandExpertise);
         }
         if (changesMask[44])
         {
-            data << float(BlockPercentage);
+            data << float(OffhandExpertise);
         }
         if (changesMask[45])
         {
-            data << float(DodgePercentage);
+            data << float(RangedExpertise);
         }
         if (changesMask[46])
         {
-            data << float(DodgePercentageFromAttribute);
+            data << float(CombatRatingExpertise);
         }
         if (changesMask[47])
         {
-            data << float(ParryPercentage);
+            data << float(BlockPercentage);
         }
         if (changesMask[48])
         {
-            data << float(ParryPercentageFromAttribute);
+            data << float(DodgePercentage);
         }
         if (changesMask[49])
         {
-            data << float(CritPercentage);
+            data << float(DodgePercentageFromAttribute);
         }
         if (changesMask[50])
         {
-            data << float(RangedCritPercentage);
+            data << float(ParryPercentage);
         }
         if (changesMask[51])
         {
-            data << float(OffhandCritPercentage);
+            data << float(ParryPercentageFromAttribute);
         }
         if (changesMask[52])
         {
-            data << float(SpellCritPercentage);
+            data << float(CritPercentage);
         }
         if (changesMask[53])
         {
-            data << int32(ShieldBlock);
+            data << float(RangedCritPercentage);
         }
         if (changesMask[54])
         {
-            data << float(ShieldBlockCritPercentage);
+            data << float(OffhandCritPercentage);
         }
         if (changesMask[55])
         {
-            data << float(Mastery);
+            data << float(SpellCritPercentage);
         }
         if (changesMask[56])
         {
-            data << float(Speed);
+            data << int32(ShieldBlock);
         }
         if (changesMask[57])
         {
-            data << float(Avoidance);
+            data << float(ShieldBlockCritPercentage);
         }
         if (changesMask[58])
         {
-            data << float(Sturdiness);
+            data << float(Mastery);
         }
         if (changesMask[59])
         {
-            data << int32(Versatility);
+            data << float(Speed);
         }
         if (changesMask[60])
         {
-            data << float(VersatilityBonus);
+            data << float(Avoidance);
         }
         if (changesMask[61])
         {
-            data << float(PvpPowerDamage);
+            data << float(Sturdiness);
         }
         if (changesMask[62])
         {
-            data << float(PvpPowerHealing);
+            data << int32(Versatility);
         }
         if (changesMask[63])
         {
-            data << int32(ModHealingDonePos);
+            data << float(VersatilityBonus);
         }
         if (changesMask[64])
         {
-            data << float(ModHealingPercent);
+            data << float(PvpPowerDamage);
         }
         if (changesMask[65])
         {
-            data << float(ModPeriodicHealingDonePercent);
+            data << float(PvpPowerHealing);
         }
     }
     if (changesMask[66])
     {
         if (changesMask[67])
         {
-            data << float(ModSpellPowerPercent);
+            data << int32(ModHealingDonePos);
         }
         if (changesMask[68])
         {
-            data << float(ModResiliencePercent);
+            data << float(ModHealingPercent);
         }
         if (changesMask[69])
         {
-            data << float(OverrideSpellPowerByAPPercent);
+            data << float(ModPeriodicHealingDonePercent);
         }
         if (changesMask[70])
         {
-            data << float(OverrideAPBySpellPowerPercent);
+            data << float(ModSpellPowerPercent);
         }
         if (changesMask[71])
         {
-            data << int32(ModTargetResistance);
+            data << float(ModResiliencePercent);
         }
         if (changesMask[72])
         {
-            data << int32(ModTargetPhysicalResistance);
+            data << float(OverrideSpellPowerByAPPercent);
         }
         if (changesMask[73])
         {
-            data << uint32(LocalFlags);
+            data << float(OverrideAPBySpellPowerPercent);
         }
         if (changesMask[74])
         {
-            data << uint8(GrantableLevels);
+            data << int32(ModTargetResistance);
         }
         if (changesMask[75])
         {
-            data << uint8(MultiActionBars);
+            data << int32(ModTargetPhysicalResistance);
         }
         if (changesMask[76])
         {
-            data << uint8(LifetimeMaxRank);
+            data << uint32(LocalFlags);
         }
         if (changesMask[77])
         {
-            data << uint8(NumRespecs);
+            data << uint8(GrantableLevels);
         }
         if (changesMask[78])
         {
-            data << uint32(PvpMedals);
+            data << uint8(MultiActionBars);
         }
         if (changesMask[79])
         {
-            data << uint16(TodayHonorableKills);
+            data << uint8(LifetimeMaxRank);
         }
         if (changesMask[80])
         {
-            data << uint16(YesterdayHonorableKills);
+            data << uint8(NumRespecs);
         }
         if (changesMask[81])
         {
-            data << uint32(LifetimeHonorableKills);
+            data << uint32(PvpMedals);
         }
         if (changesMask[82])
         {
-            data << int32(WatchedFactionIndex);
+            data << uint16(TodayHonorableKills);
         }
         if (changesMask[83])
         {
-            data << int32(MaxLevel);
+            data << uint16(YesterdayHonorableKills);
         }
         if (changesMask[84])
         {
-            data << int32(ScalingPlayerLevelDelta);
+            data << uint32(LifetimeHonorableKills);
         }
         if (changesMask[85])
         {
-            data << int32(MaxCreatureScalingLevel);
+            data << int32(WatchedFactionIndex);
         }
         if (changesMask[86])
         {
-            data << int32(PetSpellPower);
+            data << int32(MaxLevel);
         }
         if (changesMask[87])
         {
-            data << float(UiHitModifier);
+            data << int32(ScalingPlayerLevelDelta);
         }
         if (changesMask[88])
         {
-            data << float(UiSpellHitModifier);
+            data << int32(MaxCreatureScalingLevel);
         }
         if (changesMask[89])
         {
-            data << int32(HomeRealmTimeOffset);
+            data << int32(PetSpellPower);
         }
         if (changesMask[90])
         {
-            data << float(ModPetHaste);
+            data << float(UiHitModifier);
         }
         if (changesMask[91])
         {
-            data << int8(JailersTowerLevelMax);
+            data << float(UiSpellHitModifier);
         }
         if (changesMask[92])
         {
-            data << int8(JailersTowerLevel);
+            data << int32(HomeRealmTimeOffset);
         }
         if (changesMask[93])
         {
-            data << uint8(LocalRegenFlags);
+            data << float(ModPetHaste);
         }
         if (changesMask[94])
         {
-            data << uint8(AuraVision);
+            data << int8(JailersTowerLevelMax);
         }
         if (changesMask[95])
         {
-            data << uint8(NumBackpackSlots);
+            data << int8(JailersTowerLevel);
         }
         if (changesMask[96])
         {
-            data << int32(OverrideSpellsID);
+            data << uint8(LocalRegenFlags);
         }
         if (changesMask[97])
         {
-            data << uint16(LootSpecID);
+            data << uint8(AuraVision);
         }
     }
     if (changesMask[98])
     {
         if (changesMask[99])
         {
-            data << uint32(OverrideZonePVPType);
+            data << uint8(NumBackpackSlots);
         }
         if (changesMask[100])
         {
-            data << BnetAccount;
+            data << int32(OverrideSpellsID);
         }
         if (changesMask[101])
         {
-            data << uint64(GuildClubMemberID);
+            data << uint16(LootSpecID);
         }
         if (changesMask[102])
         {
-            data << int32(Honor);
+            data << uint32(OverrideZonePVPType);
         }
         if (changesMask[103])
         {
-            data << int32(HonorNextLevel);
+            data << BnetAccount;
         }
         if (changesMask[104])
         {
-            data << uint8(NumBankSlots);
+            data << uint64(GuildClubMemberID);
+        }
+        if (changesMask[105])
+        {
+            data << int32(Honor);
+        }
+        if (changesMask[106])
+        {
+            data << int32(HonorNextLevel);
         }
         if (changesMask[107])
         {
+            data << uint8(NumBankSlots);
+        }
+        if (changesMask[110])
+        {
             data << int32(UiChromieTimeExpansionID);
         }
-        if (changesMask[108])
+        if (changesMask[111])
         {
             data << int32(TransportServerTime);
         }
-        if (changesMask[109])
+        if (changesMask[112])
         {
             data << uint32(WeeklyRewardsPeriodSinceOrigin);
         }
-        if (changesMask[110])
+        if (changesMask[113])
         {
             data << int16(DEBUGSoulbindConduitRank);
         }
+        if (changesMask[115])
+        {
+            data << uint32(ActiveCombatTraitConfigID);
+        }
     }
     if (changesMask[98])
     {
         data.WriteBits(QuestSession.has_value(), 1);
-        if (changesMask[106])
+        if (changesMask[109])
         {
             Field_1410->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
-        if (changesMask[105])
+        if (changesMask[108])
         {
             if (QuestSession.has_value())
             {
                 QuestSession->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
             }
         }
-        if (changesMask[111])
+        if (changesMask[114])
         {
             data << DungeonScore;
         }
     }
-    if (changesMask[112])
+    if (changesMask[116])
     {
-        for (uint32 i = 0; i < 199; ++i)
+        for (uint32 i = 0; i < 218; ++i)
         {
-            if (changesMask[113 + i])
+            if (changesMask[117 + i])
             {
                 data << InvSlots[i];
             }
         }
     }
-    if (changesMask[312])
+    if (changesMask[335])
     {
         for (uint32 i = 0; i < 240; ++i)
         {
-            if (changesMask[313 + i])
+            if (changesMask[336 + i])
             {
                 data << uint64(ExploredZones[i]);
             }
         }
     }
-    if (changesMask[553])
+    if (changesMask[576])
     {
         for (uint32 i = 0; i < 2; ++i)
         {
-            if (changesMask[554 + i])
+            if (changesMask[577 + i])
             {
                 RestInfo[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
             }
         }
     }
-    if (changesMask[556])
+    if (changesMask[579])
     {
         for (uint32 i = 0; i < 7; ++i)
         {
-            if (changesMask[557 + i])
+            if (changesMask[580 + i])
             {
                 data << int32(ModDamageDonePos[i]);
             }
-            if (changesMask[564 + i])
+            if (changesMask[587 + i])
             {
                 data << int32(ModDamageDoneNeg[i]);
             }
-            if (changesMask[571 + i])
+            if (changesMask[594 + i])
             {
                 data << float(ModDamageDonePercent[i]);
             }
-            if (changesMask[578 + i])
+            if (changesMask[601 + i])
             {
                 data << float(ModHealingDonePercent[i]);
             }
         }
     }
-    if (changesMask[585])
+    if (changesMask[608])
     {
         for (uint32 i = 0; i < 3; ++i)
         {
-            if (changesMask[586 + i])
+            if (changesMask[609 + i])
             {
                 data << float(WeaponDmgMultipliers[i]);
             }
-            if (changesMask[589 + i])
+            if (changesMask[612 + i])
             {
                 data << float(WeaponAtkSpeedMultipliers[i]);
             }
         }
     }
-    if (changesMask[592])
+    if (changesMask[615])
     {
         for (uint32 i = 0; i < 12; ++i)
         {
-            if (changesMask[593 + i])
+            if (changesMask[616 + i])
             {
                 data << uint32(BuybackPrice[i]);
             }
-            if (changesMask[605 + i])
+            if (changesMask[628 + i])
             {
                 data << int64(BuybackTimestamp[i]);
             }
         }
     }
-    if (changesMask[617])
+    if (changesMask[640])
     {
         for (uint32 i = 0; i < 32; ++i)
         {
-            if (changesMask[618 + i])
+            if (changesMask[641 + i])
             {
                 data << int32(CombatRatings[i]);
             }
         }
     }
-    if (changesMask[657])
+    if (changesMask[673])
     {
         for (uint32 i = 0; i < 4; ++i)
         {
-            if (changesMask[658 + i])
+            if (changesMask[674 + i])
             {
                 data << uint32(NoReagentCostMask[i]);
             }
         }
     }
-    if (changesMask[662])
+    if (changesMask[678])
     {
         for (uint32 i = 0; i < 2; ++i)
         {
-            if (changesMask[663 + i])
+            if (changesMask[679 + i])
             {
                 data << int32(ProfessionSkillLine[i]);
             }
         }
     }
-    if (changesMask[665])
+    if (changesMask[681])
     {
-        for (uint32 i = 0; i < 4; ++i)
+        for (uint32 i = 0; i < 5; ++i)
         {
-            if (changesMask[666 + i])
+            if (changesMask[682 + i])
             {
                 data << uint32(BagSlotFlags[i]);
             }
         }
     }
-    if (changesMask[670])
+    if (changesMask[687])
     {
         for (uint32 i = 0; i < 7; ++i)
         {
-            if (changesMask[671 + i])
+            if (changesMask[688 + i])
             {
                 data << uint32(BankBagSlotFlags[i]);
             }
         }
     }
-    if (changesMask[678])
+    if (changesMask[695])
     {
         for (uint32 i = 0; i < 875; ++i)
         {
-            if (changesMask[679 + i])
+            if (changesMask[696 + i])
             {
                 data << uint64(QuestCompleted[i]);
             }
         }
     }
-    if (changesMask[650])
-    {
-        for (uint32 i = 0; i < 6; ++i)
-        {
-            if (changesMask[651 + i])
-            {
-                PvpInfo[i].WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
-            }
-        }
-    }
     data.FlushBits();
 }
 
@@ -4147,7 +4777,10 @@ void ActivePlayerData::ClearChangesMask()
     Base::ClearChangesMask(RecipeProgression);
     Base::ClearChangesMask(ReplayedQuests);
     Base::ClearChangesMask(DisabledSpells);
+    Base::ClearChangesMask(PvpInfo);
     Base::ClearChangesMask(CharacterRestrictions);
+    Base::ClearChangesMask(TraitConfigs);
+    Base::ClearChangesMask(CraftingOrders);
     Base::ClearChangesMask(FarsightObject);
     Base::ClearChangesMask(SummonedBattlePetGUID);
     Base::ClearChangesMask(Coinage);
@@ -4228,6 +4861,7 @@ void ActivePlayerData::ClearChangesMask()
     Base::ClearChangesMask(WeeklyRewardsPeriodSinceOrigin);
     Base::ClearChangesMask(DEBUGSoulbindConduitRank);
     Base::ClearChangesMask(DungeonScore);
+    Base::ClearChangesMask(ActiveCombatTraitConfigID);
     Base::ClearChangesMask(InvSlots);
     Base::ClearChangesMask(ExploredZones);
     Base::ClearChangesMask(RestInfo);
@@ -4240,7 +4874,6 @@ void ActivePlayerData::ClearChangesMask()
     Base::ClearChangesMask(BuybackPrice);
     Base::ClearChangesMask(BuybackTimestamp);
     Base::ClearChangesMask(CombatRatings);
-    Base::ClearChangesMask(PvpInfo);
     Base::ClearChangesMask(NoReagentCostMask);
     Base::ClearChangesMask(ProfessionSkillLine);
     Base::ClearChangesMask(BagSlotFlags);
@@ -4278,10 +4911,18 @@ void GameObjectData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fie
     data << uint32(CustomParam);
     data << int32(Level);
     data << uint32(AnimGroupInstance);
+    data << uint32(UiWidgetItemID);
+    data << uint32(UiWidgetItemQuality);
+    data << uint32(UiWidgetItemUnknown1000);
+    data << uint32(WorldEffects.size());
     for (uint32 i = 0; i < EnableDoodadSets.size(); ++i)
     {
         data << int32(EnableDoodadSets[i]);
     }
+    for (uint32 i = 0; i < WorldEffects.size(); ++i)
+    {
+        data << int32(WorldEffects[i]);
+    }
 }
 
 void GameObjectData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, GameObject const* owner, Player const* receiver) const
@@ -4291,7 +4932,7 @@ void GameObjectData::WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fie
 
 void GameObjectData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool ignoreNestedChangesMask, GameObject const* owner, Player const* receiver) const
 {
-    data.WriteBits(changesMask.GetBlock(0), 21);
+    data.WriteBits(changesMask.GetBlock(0), 25);
 
     if (changesMask[0])
     {
@@ -4314,6 +4955,13 @@ void GameObjectData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool
             else
                 WriteCompleteDynamicFieldUpdateMask(EnableDoodadSets.size(), data);
         }
+        if (changesMask[3])
+        {
+            if (!ignoreNestedChangesMask)
+                WorldEffects.WriteUpdateMask(data);
+            else
+                WriteCompleteDynamicFieldUpdateMask(WorldEffects.size(), data);
+        }
     }
     data.FlushBits();
     if (changesMask[0])
@@ -4330,79 +4978,101 @@ void GameObjectData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, bool
         }
         if (changesMask[3])
         {
-            data << int32(DisplayID);
+            for (uint32 i = 0; i < WorldEffects.size(); ++i)
+            {
+                if (WorldEffects.HasChanged(i) || ignoreNestedChangesMask)
+                {
+                    data << int32(WorldEffects[i]);
+                }
+            }
         }
         if (changesMask[4])
         {
-            data << uint32(SpellVisualID);
+            data << int32(DisplayID);
         }
         if (changesMask[5])
         {
-            data << uint32(StateSpellVisualID);
+            data << uint32(SpellVisualID);
         }
         if (changesMask[6])
         {
-            data << uint32(SpawnTrackingStateAnimID);
+            data << uint32(StateSpellVisualID);
         }
         if (changesMask[7])
         {
-            data << uint32(SpawnTrackingStateAnimKitID);
+            data << uint32(SpawnTrackingStateAnimID);
         }
         if (changesMask[8])
         {
-            data << uint32(StateWorldEffectsQuestObjectiveID);
+            data << uint32(SpawnTrackingStateAnimKitID);
         }
         if (changesMask[9])
         {
-            data << CreatedBy;
+            data << uint32(StateWorldEffectsQuestObjectiveID);
         }
         if (changesMask[10])
         {
-            data << GuildGUID;
+            data << CreatedBy;
         }
         if (changesMask[11])
         {
-            data << uint32(ViewerDependentValue<FlagsTag>::GetValue(this, owner, receiver));
+            data << GuildGUID;
         }
         if (changesMask[12])
         {
+            data << uint32(ViewerDependentValue<FlagsTag>::GetValue(this, owner, receiver));
+        }
+        if (changesMask[13])
+        {
             data << float(ParentRotation->x);
             data << float(ParentRotation->y);
             data << float(ParentRotation->z);
             data << float(ParentRotation->w);
         }
-        if (changesMask[13])
+        if (changesMask[14])
         {
             data << int32(FactionTemplate);
         }
-        if (changesMask[14])
+        if (changesMask[15])
         {
             data << int8(ViewerDependentValue<StateTag>::GetValue(this, owner, receiver));
         }
-        if (changesMask[15])
+        if (changesMask[16])
         {
             data << int8(TypeID);
         }
-        if (changesMask[16])
+        if (changesMask[17])
         {
             data << uint8(PercentHealth);
         }
-        if (changesMask[17])
+        if (changesMask[18])
         {
             data << uint32(ArtKit);
         }
-        if (changesMask[18])
+        if (changesMask[19])
         {
             data << uint32(CustomParam);
         }
-        if (changesMask[19])
+        if (changesMask[20])
         {
             data << int32(Level);
         }
-        if (changesMask[20])
+        if (changesMask[21])
         {
             data << uint32(AnimGroupInstance);
         }
+        if (changesMask[22])
+        {
+            data << uint32(UiWidgetItemID);
+        }
+        if (changesMask[23])
+        {
+            data << uint32(UiWidgetItemQuality);
+        }
+        if (changesMask[24])
+        {
+            data << uint32(UiWidgetItemUnknown1000);
+        }
     }
 }
 
@@ -4410,6 +5080,7 @@ void GameObjectData::ClearChangesMask()
 {
     Base::ClearChangesMask(StateWorldEffectIDs);
     Base::ClearChangesMask(EnableDoodadSets);
+    Base::ClearChangesMask(WorldEffects);
     Base::ClearChangesMask(DisplayID);
     Base::ClearChangesMask(SpellVisualID);
     Base::ClearChangesMask(StateSpellVisualID);
@@ -4428,6 +5099,9 @@ void GameObjectData::ClearChangesMask()
     Base::ClearChangesMask(CustomParam);
     Base::ClearChangesMask(Level);
     Base::ClearChangesMask(AnimGroupInstance);
+    Base::ClearChangesMask(UiWidgetItemID);
+    Base::ClearChangesMask(UiWidgetItemQuality);
+    Base::ClearChangesMask(UiWidgetItemUnknown1000);
     _changesMask.ResetAll();
 }
 
@@ -4746,6 +5420,7 @@ void AreaTriggerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fi
     data << uint32(TimeToTarget);
     data << uint32(TimeToTargetScale);
     data << uint32(TimeToTargetExtraScale);
+    data << uint32(Field_B0);
     data << int32(SpellID);
     data << int32(SpellForVisuals);
     SpellVisual->WriteCreate(data, owner, receiver);
@@ -4755,7 +5430,11 @@ void AreaTriggerData::WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fi
     data << uint32(Field_80);
     data << uint32(Field_84);
     data << Field_88;
+    data << Field_F8;
     ExtraScaleCurve->WriteCreate(data, owner, receiver);
+    Field_C38->WriteCreate(data, owner, receiver);
+    Field_C54->WriteCreate(data, owner, receiver);
+    Field_C70->WriteCreate(data, owner, receiver);
     VisualAnim->WriteCreate(data, owner, receiver);
 }
 
@@ -4766,7 +5445,7 @@ 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), 18);
+    data.WriteBits(changesMask.GetBlock(0), 23);
 
     data.FlushBits();
     if (changesMask[0])
@@ -4775,67 +5454,87 @@ void AreaTriggerData::WriteUpdate(ByteBuffer& data, Mask const& changesMask, boo
         {
             OverrideScaleCurve->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
-        if (changesMask[3])
+        if (changesMask[6])
         {
             data << Caster;
         }
-        if (changesMask[4])
+        if (changesMask[7])
         {
             data << uint32(Duration);
         }
-        if (changesMask[5])
+        if (changesMask[8])
         {
             data << uint32(TimeToTarget);
         }
-        if (changesMask[6])
+        if (changesMask[9])
         {
             data << uint32(TimeToTargetScale);
         }
-        if (changesMask[7])
+        if (changesMask[10])
         {
             data << uint32(TimeToTargetExtraScale);
         }
-        if (changesMask[8])
+        if (changesMask[11])
+        {
+            data << uint32(Field_B0);
+        }
+        if (changesMask[12])
         {
             data << int32(SpellID);
         }
-        if (changesMask[9])
+        if (changesMask[13])
         {
             data << int32(SpellForVisuals);
         }
-        if (changesMask[10])
+        if (changesMask[14])
         {
             SpellVisual->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
-        if (changesMask[11])
+        if (changesMask[15])
         {
             data << float(BoundsRadius2D);
         }
-        if (changesMask[12])
+        if (changesMask[16])
         {
             data << uint32(DecalPropertiesID);
         }
-        if (changesMask[13])
+        if (changesMask[17])
         {
             data << CreatingEffectGUID;
         }
-        if (changesMask[14])
+        if (changesMask[18])
         {
             data << uint32(Field_80);
         }
-        if (changesMask[15])
+        if (changesMask[19])
         {
             data << uint32(Field_84);
         }
-        if (changesMask[16])
+        if (changesMask[20])
         {
             data << Field_88;
         }
+        if (changesMask[21])
+        {
+            data << Field_F8;
+        }
         if (changesMask[2])
         {
             ExtraScaleCurve->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
-        if (changesMask[17])
+        if (changesMask[3])
+        {
+            Field_C38->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
+        }
+        if (changesMask[4])
+        {
+            Field_C54->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
+        }
+        if (changesMask[5])
+        {
+            Field_C70->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
+        }
+        if (changesMask[22])
         {
             VisualAnim->WriteUpdate(data, ignoreNestedChangesMask, owner, receiver);
         }
@@ -4846,11 +5545,15 @@ void AreaTriggerData::ClearChangesMask()
 {
     Base::ClearChangesMask(OverrideScaleCurve);
     Base::ClearChangesMask(ExtraScaleCurve);
+    Base::ClearChangesMask(Field_C38);
+    Base::ClearChangesMask(Field_C54);
+    Base::ClearChangesMask(Field_C70);
     Base::ClearChangesMask(Caster);
     Base::ClearChangesMask(Duration);
     Base::ClearChangesMask(TimeToTarget);
     Base::ClearChangesMask(TimeToTargetScale);
     Base::ClearChangesMask(TimeToTargetExtraScale);
+    Base::ClearChangesMask(Field_B0);
     Base::ClearChangesMask(SpellID);
     Base::ClearChangesMask(SpellForVisuals);
     Base::ClearChangesMask(SpellVisual);
@@ -4860,6 +5563,7 @@ void AreaTriggerData::ClearChangesMask()
     Base::ClearChangesMask(Field_80);
     Base::ClearChangesMask(Field_84);
     Base::ClearChangesMask(Field_88);
+    Base::ClearChangesMask(Field_F8);
     Base::ClearChangesMask(VisualAnim);
     _changesMask.ResetAll();
 }
diff --git a/src/server/game/Entities/Object/Updates/UpdateFields.h b/src/server/game/Entities/Object/Updates/UpdateFields.h
index 1d6d1499df8..a075a11ab81 100644
--- a/src/server/game/Entities/Object/Updates/UpdateFields.h
+++ b/src/server/game/Entities/Object/Updates/UpdateFields.h
@@ -19,6 +19,7 @@
 #define UpdateFields_h__
 
 #include "EnumFlag.h"
+#include "ItemPacketsCommon.h"
 #include "MythicPlusPacketsCommon.h"
 #include "ObjectGuid.h"
 #include "Position.h"
@@ -115,25 +116,25 @@ struct SocketedGem : public IsUpdateFieldStructureTag, public HasChangesMask<20>
 
 struct ItemData : public IsUpdateFieldStructureTag, public HasChangesMask<41>
 {
-    UpdateField<std::vector<int32>, 0, 1> BonusListIDs;
-    DynamicUpdateField<UF::ArtifactPower, 0, 2> ArtifactPowers;
-    DynamicUpdateField<UF::SocketedGem, 0, 3> Gems;
-    UpdateField<ObjectGuid, 0, 4> Owner;
-    UpdateField<ObjectGuid, 0, 5> ContainedIn;
-    UpdateField<ObjectGuid, 0, 6> Creator;
-    UpdateField<ObjectGuid, 0, 7> GiftCreator;
-    UpdateField<uint32, 0, 8> StackCount;
-    UpdateField<uint32, 0, 9> Expiration;
-    UpdateField<uint32, 0, 10> DynamicFlags;
-    UpdateField<uint32, 0, 11> Durability;
-    UpdateField<uint32, 0, 12> MaxDurability;
-    UpdateField<uint32, 0, 13> CreatePlayedTime;
-    UpdateField<int32, 0, 14> Context;
-    UpdateField<int64, 0, 15> CreateTime;
-    UpdateField<uint64, 0, 16> ArtifactXP;
-    UpdateField<uint8, 0, 17> ItemAppearanceModID;
-    UpdateField<UF::ItemModList, 0, 18> Modifiers;
-    UpdateField<uint32, 0, 19> DynamicFlags2;
+    DynamicUpdateField<UF::ArtifactPower, 0, 1> ArtifactPowers;
+    DynamicUpdateField<UF::SocketedGem, 0, 2> Gems;
+    UpdateField<ObjectGuid, 0, 3> Owner;
+    UpdateField<ObjectGuid, 0, 4> ContainedIn;
+    UpdateField<ObjectGuid, 0, 5> Creator;
+    UpdateField<ObjectGuid, 0, 6> GiftCreator;
+    UpdateField<uint32, 0, 7> StackCount;
+    UpdateField<uint32, 0, 8> Expiration;
+    UpdateField<uint32, 0, 9> DynamicFlags;
+    UpdateField<uint32, 0, 10> Durability;
+    UpdateField<uint32, 0, 11> MaxDurability;
+    UpdateField<uint32, 0, 12> CreatePlayedTime;
+    UpdateField<int32, 0, 13> Context;
+    UpdateField<int64, 0, 14> CreateTime;
+    UpdateField<uint64, 0, 15> ArtifactXP;
+    UpdateField<uint8, 0, 16> ItemAppearanceModID;
+    UpdateField<UF::ItemModList, 0, 17> Modifiers;
+    UpdateField<uint32, 0, 18> DynamicFlags2;
+    UpdateField<WorldPackets::Item::ItemBonusKey, 0, 19> ItemBonusKey;
     UpdateField<uint16, 0, 20> DEBUGItemLevel;
     UpdateFieldArray<int32, 5, 21, 22> SpellCharges;
     UpdateFieldArray<UF::ItemEnchantment, 13, 27, 28> Enchantment;
@@ -254,7 +255,7 @@ struct PassiveSpellHistory : public IsUpdateFieldStructureTag
     bool operator!=(PassiveSpellHistory const& right) const { return !(*this == right); }
 };
 
-struct UnitData : public IsUpdateFieldStructureTag, public HasChangesMask<194>
+struct UnitData : public IsUpdateFieldStructureTag, public HasChangesMask<196>
 {
     UpdateField<std::vector<uint32>, 0, 1> StateWorldEffectIDs;
     DynamicUpdateField<UF::PassiveSpellHistory, 0, 2> PassiveSpells;
@@ -279,119 +280,121 @@ struct UnitData : public IsUpdateFieldStructureTag, public HasChangesMask<194>
     UpdateField<ObjectGuid, 0, 20> BattlePetCompanionGUID;
     UpdateField<uint64, 0, 21> BattlePetDBID;
     UpdateField<UF::UnitChannel, 0, 22> ChannelData;
-    UpdateField<uint32, 0, 23> SummonedByHomeRealm;
-    UpdateField<uint8, 0, 24> Race;
-    UpdateField<uint8, 0, 25> ClassId;
-    UpdateField<uint8, 0, 26> PlayerClassId;
-    UpdateField<uint8, 0, 27> Sex;
-    UpdateField<uint8, 0, 28> DisplayPower;
-    UpdateField<uint32, 0, 29> OverrideDisplayPowerID;
-    UpdateField<int64, 0, 30> Health;
-    UpdateField<int64, 0, 31> MaxHealth;
-    UpdateField<int32, 32, 33> Level;
-    UpdateField<int32, 32, 34> EffectiveLevel;
-    UpdateField<int32, 32, 35> ContentTuningID;
-    UpdateField<int32, 32, 36> ScalingLevelMin;
-    UpdateField<int32, 32, 37> ScalingLevelMax;
-    UpdateField<int32, 32, 38> ScalingLevelDelta;
-    UpdateField<int32, 32, 39> ScalingFactionGroup;
-    UpdateField<int32, 32, 40> ScalingHealthItemLevelCurveID;
-    UpdateField<int32, 32, 41> ScalingDamageItemLevelCurveID;
-    UpdateField<int32, 32, 42> FactionTemplate;
+    UpdateField<int8, 0, 23> SpellEmpowerStage;
+    UpdateField<uint32, 0, 24> SummonedByHomeRealm;
+    UpdateField<uint8, 0, 25> Race;
+    UpdateField<uint8, 0, 26> ClassId;
+    UpdateField<uint8, 0, 27> PlayerClassId;
+    UpdateField<uint8, 0, 28> Sex;
+    UpdateField<uint8, 0, 29> DisplayPower;
+    UpdateField<uint32, 0, 30> OverrideDisplayPowerID;
+    UpdateField<int64, 0, 31> Health;
+    UpdateField<int64, 32, 33> MaxHealth;
+    UpdateField<int32, 32, 34> Level;
+    UpdateField<int32, 32, 35> EffectiveLevel;
+    UpdateField<int32, 32, 36> ContentTuningID;
+    UpdateField<int32, 32, 37> ScalingLevelMin;
+    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;
     struct FactionTemplateTag : ViewerDependentValueTag<int32> {};
-    UpdateField<uint32, 32, 43> Flags;
+    UpdateField<uint32, 32, 44> Flags;
     struct FlagsTag : ViewerDependentValueTag<uint32> {};
-    UpdateField<uint32, 32, 44> Flags2;
-    UpdateField<uint32, 32, 45> Flags3;
+    UpdateField<uint32, 32, 45> Flags2;
+    UpdateField<uint32, 32, 46> Flags3;
     struct Flags3Tag : ViewerDependentValueTag<uint32> {};
-    UpdateField<uint32, 32, 46> AuraState;
+    UpdateField<uint32, 32, 47> AuraState;
     struct AuraStateTag : ViewerDependentValueTag<uint32> {};
-    UpdateField<uint32, 32, 47> RangedAttackRoundBaseTime;
-    UpdateField<float, 32, 48> BoundingRadius;
-    UpdateField<float, 32, 49> CombatReach;
-    UpdateField<float, 32, 50> DisplayScale;
-    UpdateField<int32, 32, 51> CreatureFamily;
-    UpdateField<int32, 32, 52> CreatureType;
-    UpdateField<int32, 32, 53> NativeDisplayID;
-    UpdateField<float, 32, 54> NativeXDisplayScale;
-    UpdateField<int32, 32, 55> MountDisplayID;
-    UpdateField<int32, 32, 56> CosmeticMountDisplayID;
-    UpdateField<float, 32, 57> MinDamage;
-    UpdateField<float, 32, 58> MaxDamage;
-    UpdateField<float, 32, 59> MinOffHandDamage;
-    UpdateField<float, 32, 60> MaxOffHandDamage;
-    UpdateField<uint8, 32, 61> StandState;
-    UpdateField<uint8, 32, 62> PetTalentPoints;
-    UpdateField<uint8, 32, 63> VisFlags;
-    UpdateField<uint8, 64, 65> AnimTier;
-    UpdateField<uint32, 64, 66> PetNumber;
-    UpdateField<uint32, 64, 67> PetNameTimestamp;
-    UpdateField<uint32, 64, 68> PetExperience;
-    UpdateField<uint32, 64, 69> PetNextLevelExperience;
-    UpdateField<float, 64, 70> ModCastingSpeed;
-    UpdateField<float, 64, 71> ModCastingSpeedNeg;
-    UpdateField<float, 64, 72> ModSpellHaste;
-    UpdateField<float, 64, 73> ModHaste;
-    UpdateField<float, 64, 74> ModRangedHaste;
-    UpdateField<float, 64, 75> ModHasteRegen;
-    UpdateField<float, 64, 76> ModTimeRate;
-    UpdateField<int32, 64, 77> CreatedBySpell;
-    UpdateField<int32, 64, 78> EmoteState;
-    UpdateField<int32, 64, 79> BaseMana;
-    UpdateField<int32, 64, 80> BaseHealth;
-    UpdateField<uint8, 64, 81> SheatheState;
-    UpdateField<uint8, 64, 82> PvpFlags;
+    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;
     struct PvpFlagsTag : ViewerDependentValueTag<uint8> {};
-    UpdateField<uint8, 64, 83> PetFlags;
-    UpdateField<uint8, 64, 84> ShapeshiftForm;
-    UpdateField<int32, 64, 85> AttackPower;
-    UpdateField<int32, 64, 86> AttackPowerModPos;
-    UpdateField<int32, 64, 87> AttackPowerModNeg;
-    UpdateField<float, 64, 88> AttackPowerMultiplier;
-    UpdateField<int32, 64, 89> RangedAttackPower;
-    UpdateField<int32, 64, 90> RangedAttackPowerModPos;
-    UpdateField<int32, 64, 91> RangedAttackPowerModNeg;
-    UpdateField<float, 64, 92> RangedAttackPowerMultiplier;
-    UpdateField<int32, 64, 93> MainHandWeaponAttackPower;
-    UpdateField<int32, 64, 94> OffHandWeaponAttackPower;
-    UpdateField<int32, 64, 95> RangedWeaponAttackPower;
-    UpdateField<int32, 96, 97> SetAttackSpeedAura;
-    UpdateField<float, 96, 98> Lifesteal;
-    UpdateField<float, 96, 99> MinRangedDamage;
-    UpdateField<float, 96, 100> MaxRangedDamage;
-    UpdateField<float, 96, 101> ManaCostMultiplier;
-    UpdateField<float, 96, 102> MaxHealthModifier;
-    UpdateField<float, 96, 103> HoverHeight;
-    UpdateField<int32, 96, 104> MinItemLevelCutoff;
-    UpdateField<int32, 96, 105> MinItemLevel;
-    UpdateField<int32, 96, 106> MaxItemLevel;
-    UpdateField<int32, 96, 107> AzeriteItemLevel;
-    UpdateField<int32, 96, 108> WildBattlePetLevel;
-    UpdateField<int32, 96, 109> BattlePetCompanionExperience;
-    UpdateField<uint32, 96, 110> BattlePetCompanionNameTimestamp;
-    UpdateField<int32, 96, 111> InteractSpellID;
-    UpdateField<int32, 96, 112> ScaleDuration;
-    UpdateField<int32, 96, 113> LooksLikeMountID;
-    UpdateField<int32, 96, 114> LooksLikeCreatureID;
-    UpdateField<int32, 96, 115> LookAtControllerID;
-    UpdateField<int32, 96, 116> TaxiNodesID;
-    UpdateField<ObjectGuid, 96, 117> GuildGUID;
-    UpdateField<uint32, 96, 118> SilencedSchoolMask;
-    UpdateField<ObjectGuid, 96, 119> NameplateAttachToGUID;                     // When set, nameplate of this unit will instead appear on that object
-    UpdateFieldArray<uint32, 2, 120, 121> NpcFlags;
+    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> RangedAttackPower;
+    UpdateField<int32, 64, 91> RangedAttackPowerModPos;
+    UpdateField<int32, 64, 92> RangedAttackPowerModNeg;
+    UpdateField<float, 64, 93> RangedAttackPowerMultiplier;
+    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;
+    UpdateField<int32, 96, 113> ScaleDuration;
+    UpdateField<int32, 96, 114> LooksLikeMountID;
+    UpdateField<int32, 96, 115> LooksLikeCreatureID;
+    UpdateField<int32, 96, 116> LookAtControllerID;
+    UpdateField<int32, 96, 117> TaxiNodesID;
+    UpdateField<ObjectGuid, 96, 118> GuildGUID;
+    UpdateField<int32, 96, 119> FlightCapabilityID;
+    UpdateField<uint32, 96, 120> SilencedSchoolMask;
+    UpdateField<ObjectGuid, 96, 121> NameplateAttachToGUID;                     // When set, nameplate of this unit will instead appear on that object
+    UpdateFieldArray<uint32, 2, 122, 123> NpcFlags;
     struct NpcFlagsTag : ViewerDependentValueTag<uint32> {};
-    UpdateFieldArray<int32, 7, 123, 124> Power;
-    UpdateFieldArray<int32, 7, 123, 131> MaxPower;
-    UpdateFieldArray<float, 7, 123, 138> PowerRegenFlatModifier;
-    UpdateFieldArray<float, 7, 123, 145> PowerRegenInterruptedFlatModifier;
-    UpdateFieldArray<UF::VisibleItem, 3, 152, 153> VirtualItems;
-    UpdateFieldArray<uint32, 2, 156, 157> AttackRoundBaseTime;
-    UpdateFieldArray<int32, 4, 159, 160> Stats;
-    UpdateFieldArray<int32, 4, 159, 164> StatPosBuff;
-    UpdateFieldArray<int32, 4, 159, 168> StatNegBuff;
-    UpdateFieldArray<int32, 7, 172, 173> Resistances;
-    UpdateFieldArray<int32, 7, 172, 180> BonusResistanceMods;
-    UpdateFieldArray<int32, 7, 172, 187> ManaCostModifier;
+    UpdateFieldArray<int32, 7, 125, 126> Power;
+    UpdateFieldArray<int32, 7, 125, 133> MaxPower;
+    UpdateFieldArray<float, 7, 125, 140> PowerRegenFlatModifier;
+    UpdateFieldArray<float, 7, 125, 147> PowerRegenInterruptedFlatModifier;
+    UpdateFieldArray<UF::VisibleItem, 3, 154, 155> VirtualItems;
+    UpdateFieldArray<uint32, 2, 158, 159> AttackRoundBaseTime;
+    UpdateFieldArray<int32, 4, 161, 162> Stats;
+    UpdateFieldArray<int32, 4, 161, 166> StatPosBuff;
+    UpdateFieldArray<int32, 4, 161, 170> StatNegBuff;
+    UpdateFieldArray<int32, 7, 174, 175> Resistances;
+    UpdateFieldArray<int32, 7, 174, 182> BonusResistanceMods;
+    UpdateFieldArray<int32, 7, 174, 189> 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;
@@ -453,44 +456,46 @@ struct CTROptions : public IsUpdateFieldStructureTag
     bool operator!=(CTROptions const& right) const { return !(*this == right); }
 };
 
-struct PlayerData : public IsUpdateFieldStructureTag, public HasChangesMask<188>
+struct PlayerData : public IsUpdateFieldStructureTag, public HasChangesMask<190>
 {
     UpdateField<bool, 0, 1> HasQuestSession;
     UpdateField<bool, 0, 2> HasLevelLink;
     DynamicUpdateField<UF::ChrCustomizationChoice, 0, 3> Customizations;
     DynamicUpdateField<UF::QuestLog, 0, 4> QuestSessionQuestLog;
     DynamicUpdateField<UF::ArenaCooldown, 0, 5> ArenaCooldowns;
-    UpdateField<ObjectGuid, 0, 6> DuelArbiter;
-    UpdateField<ObjectGuid, 0, 7> WowAccount;
-    UpdateField<ObjectGuid, 0, 8> LootTargetGUID;
-    UpdateField<uint32, 0, 9> PlayerFlags;
-    UpdateField<uint32, 0, 10> PlayerFlagsEx;
-    UpdateField<uint32, 0, 11> GuildRankID;
-    UpdateField<uint32, 0, 12> GuildDeleteDate;
-    UpdateField<int32, 0, 13> GuildLevel;
-    UpdateField<uint8, 0, 14> PartyType;
-    UpdateField<uint8, 0, 15> NativeSex;
-    UpdateField<uint8, 0, 16> Inebriation;
-    UpdateField<uint8, 0, 17> PvpTitle;
-    UpdateField<uint8, 0, 18> ArenaFaction;
-    UpdateField<uint32, 0, 19> DuelTeam;
-    UpdateField<int32, 0, 20> GuildTimeStamp;
-    UpdateField<int32, 0, 21> PlayerTitle;
-    UpdateField<int32, 0, 22> FakeInebriation;
-    UpdateField<uint32, 0, 23> VirtualPlayerRealm;
-    UpdateField<uint32, 0, 24> CurrentSpecID;
-    UpdateField<int32, 0, 25> TaxiMountAnimKitID;
-    UpdateField<uint8, 0, 26> CurrentBattlePetBreedQuality;
-    UpdateField<int32, 0, 27> HonorLevel;
-    UpdateField<int32, 0, 28> Field_B0;
-    UpdateField<int32, 0, 29> Field_B4;
-    UpdateField<UF::CTROptions, 0, 30> CtrOptions;
-    UpdateField<int32, 0, 31> CovenantID;
-    UpdateField<int32, 32, 33> SoulbindID;
-    UpdateField<WorldPackets::MythicPlus::DungeonScoreSummary, 32, 34> DungeonScore;
-    UpdateFieldArray<UF::QuestLog, 125, 35, 36> QuestLog;
-    UpdateFieldArray<UF::VisibleItem, 19, 161, 162> VisibleItems;
-    UpdateFieldArray<float, 6, 181, 182> AvgItemLevel;
+    DynamicUpdateField<int32, 0, 6> VisualItemReplacements;
+    UpdateField<ObjectGuid, 0, 7> DuelArbiter;
+    UpdateField<ObjectGuid, 0, 8> WowAccount;
+    UpdateField<ObjectGuid, 0, 9> LootTargetGUID;
+    UpdateField<uint32, 0, 10> PlayerFlags;
+    UpdateField<uint32, 0, 11> PlayerFlagsEx;
+    UpdateField<uint32, 0, 12> GuildRankID;
+    UpdateField<uint32, 0, 13> GuildDeleteDate;
+    UpdateField<int32, 0, 14> GuildLevel;
+    UpdateField<uint8, 0, 15> PartyType;
+    UpdateField<uint8, 0, 16> NativeSex;
+    UpdateField<uint8, 0, 17> Inebriation;
+    UpdateField<uint8, 0, 18> PvpTitle;
+    UpdateField<uint8, 0, 19> ArenaFaction;
+    UpdateField<uint32, 0, 20> DuelTeam;
+    UpdateField<int32, 0, 21> GuildTimeStamp;
+    UpdateField<int32, 0, 22> PlayerTitle;
+    UpdateField<int32, 0, 23> FakeInebriation;
+    UpdateField<uint32, 0, 24> VirtualPlayerRealm;
+    UpdateField<uint32, 0, 25> CurrentSpecID;
+    UpdateField<int32, 0, 26> TaxiMountAnimKitID;
+    UpdateField<uint8, 0, 27> CurrentBattlePetBreedQuality;
+    UpdateField<int32, 0, 28> HonorLevel;
+    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, 125, 37, 38> QuestLog;
+    UpdateFieldArray<UF::VisibleItem, 19, 163, 164> VisibleItems;
+    UpdateFieldArray<float, 6, 183, 184> AvgItemLevel;
 
     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;
@@ -526,20 +531,26 @@ struct RestInfo : public IsUpdateFieldStructureTag, public HasChangesMask<3>
     void ClearChangesMask();
 };
 
-struct PVPInfo : public IsUpdateFieldStructureTag, public HasChangesMask<13>
+struct PVPInfo : public IsUpdateFieldStructureTag, public HasChangesMask<19>
 {
     UpdateField<bool, 0, 1> Disqualified;
-    UpdateField<uint32, 0, 2> WeeklyPlayed;
-    UpdateField<uint32, 0, 3> WeeklyWon;
-    UpdateField<uint32, 0, 4> SeasonPlayed;
-    UpdateField<uint32, 0, 5> SeasonWon;
-    UpdateField<uint32, 0, 6> Rating;
-    UpdateField<uint32, 0, 7> WeeklyBestRating;
-    UpdateField<uint32, 0, 8> SeasonBestRating;
-    UpdateField<uint32, 0, 9> PvpTierID;
-    UpdateField<uint32, 0, 10> WeeklyBestWinPvpTierID;
-    UpdateField<uint32, 0, 11> Field_28;
-    UpdateField<uint32, 0, 12> Field_2C;
+    UpdateField<int8, 0, 2> Bracket;
+    UpdateField<int32, 0, 3> PvpRatingID;
+    UpdateField<uint32, 0, 4> WeeklyPlayed;
+    UpdateField<uint32, 0, 5> WeeklyWon;
+    UpdateField<uint32, 0, 6> SeasonPlayed;
+    UpdateField<uint32, 0, 7> SeasonWon;
+    UpdateField<uint32, 0, 8> Rating;
+    UpdateField<uint32, 0, 9> WeeklyBestRating;
+    UpdateField<uint32, 0, 10> SeasonBestRating;
+    UpdateField<uint32, 0, 11> PvpTierID;
+    UpdateField<uint32, 0, 12> WeeklyBestWinPvpTierID;
+    UpdateField<uint32, 0, 13> Field_28;
+    UpdateField<uint32, 0, 14> Field_2C;
+    UpdateField<uint32, 0, 15> WeeklyRoundsPlayed;
+    UpdateField<uint32, 0, 16> WeeklyRoundsWon;
+    UpdateField<uint32, 0, 17> SeasonRoundsPlayed;
+    UpdateField<uint32, 0, 18> SeasonRoundsWon;
 
     void WriteCreate(ByteBuffer& data, Player const* owner, Player const* receiver) const;
     void WriteUpdate(ByteBuffer& data, bool ignoreChangesMask, Player const* owner, Player const* receiver) const;
@@ -656,133 +667,220 @@ struct ReplayedQuest : public IsUpdateFieldStructureTag, public HasChangesMask<3
     void ClearChangesMask();
 };
 
-struct ActivePlayerData : public IsUpdateFieldStructureTag, public HasChangesMask<1554>
+struct TraitEntry : public IsUpdateFieldStructureTag
+{
+    int32 TraitNodeID;
+    int32 TraitNodeEntryID;
+    int32 Rank;
+    int32 GrantedRanks;
+
+    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==(TraitEntry const& right) const;
+    bool operator!=(TraitEntry const& right) const { return !(*this == right); }
+};
+
+struct TraitConfig : public IsUpdateFieldStructureTag, public HasChangesMask<12>
+{
+    DynamicUpdateField<UF::TraitEntry, 0, 1> Entries;
+    UpdateField<int32, 0, 2> ID;
+    UpdateField<std::string, 0, 3> Name;
+    UpdateField<int32, 4, 5> Type;
+    UpdateField<int32, 4, 6> SkillLineID;
+    UpdateField<int32, 4, 7> ChrSpecializationID;
+    UpdateField<int32, 8, 9> CombatConfigFlags;
+    UpdateField<int32, 8, 10> LocalIdentifier;
+    UpdateField<int32, 8, 11> TraitSystemID;
+
+    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 CraftingOrderItem : public IsUpdateFieldStructureTag, public HasChangesMask<7>
+{
+    UpdateField<uint64, -1, 0> Field_0;
+    UpdateField<ObjectGuid, -1, 1> ItemGUID;
+    UpdateField<ObjectGuid, -1, 2> OwnerGUID;
+    UpdateField<int32, -1, 3> ItemID;
+    UpdateField<uint32, -1, 4> Quantity;
+    UpdateField<int32, -1, 5> ReagentQuality;
+    OptionalUpdateField<uint8, -1, 6> DataSlotIndex;
+
+    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 CraftingOrderData : public IsUpdateFieldStructureTag, public HasChangesMask<24>
+{
+    DynamicUpdateField<UF::CraftingOrderItem, 0, 1> Reagents;
+    UpdateField<int32, 0, 2> Field_0;
+    UpdateField<uint64, 0, 3> OrderID;
+    UpdateField<int32, 0, 4> SkillLineAbilityID;
+    UpdateField<uint8, 5, 6> OrderState;
+    UpdateField<uint8, 5, 7> OrderType;
+    UpdateField<uint8, 5, 8> MinQuality;
+    UpdateField<int64, 5, 9> ExpirationTime;
+    UpdateField<int64, 10, 11> ClaimEndTime;
+    UpdateField<int64, 10, 12> TipAmount;
+    UpdateField<int64, 10, 13> ConsortiumCut;
+    UpdateField<uint32, 10, 14> Flags;
+    UpdateField<ObjectGuid, 15, 16> CustomerGUID;
+    UpdateField<ObjectGuid, 15, 17> CustomerAccountGUID;
+    UpdateField<ObjectGuid, 15, 18> CrafterGUID;
+    UpdateField<ObjectGuid, 15, 19> PersonalCrafterGUID;
+    UpdateField<std::string, 20, 21> CustomerNotes;
+    OptionalUpdateField<UF::CraftingOrderItem, 20, 22> OutputItem;
+    OptionalUpdateField<WorldPackets::Item::ItemInstance, 20, 23> OutputItemData;
+
+    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 CraftingOrder : public IsUpdateFieldStructureTag, public HasChangesMask<4>
+{
+    DynamicUpdateField<WorldPackets::Item::ItemEnchantData, -1, 0> Enchantments;
+    DynamicUpdateField<WorldPackets::Item::ItemGemData, -1, 1> Gems;
+    UpdateField<UF::CraftingOrderData, -1, 2> Data;
+    OptionalUpdateField<WorldPackets::Item::ItemInstance, -1, 3> RecraftItemInfo;
+
+    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 ActivePlayerData : public IsUpdateFieldStructureTag, public HasChangesMask<1571>
 {
     UpdateField<bool, 0, 1> BackpackAutoSortDisabled;
     UpdateField<bool, 0, 2> BankAutoSortDisabled;
     UpdateField<bool, 0, 3> SortBagsRightToLeft;
     UpdateField<bool, 0, 4> InsertItemsLeftToRight;
-    UpdateFieldArray<DynamicUpdateFieldBase<UF::Research>, 1, 27, 28> Research;
+    UpdateFieldArray<DynamicUpdateFieldBase<UF::Research>, 1, 30, 31> Research;
     DynamicUpdateField<uint64, 0, 5> KnownTitles;
-    DynamicUpdateField<uint16, 0, 6> ResearchSites;
-    DynamicUpdateField<uint32, 0, 7> ResearchSiteProgress;
-    DynamicUpdateField<int32, 0, 8> DailyQuestsCompleted;
-    DynamicUpdateField<int32, 0, 9> AvailableQuestLineXQuestIDs;
-    DynamicUpdateField<int32, 0, 10> Heirlooms;
-    DynamicUpdateField<uint32, 0, 11> HeirloomFlags;
-    DynamicUpdateField<int32, 0, 12> Toys;
-    DynamicUpdateField<uint32, 0, 13> ToyFlags;
-    DynamicUpdateField<uint32, 0, 14> Transmog;
-    DynamicUpdateField<int32, 0, 15> ConditionalTransmog;
-    DynamicUpdateField<int32, 0, 16> SelfResSpells;
-    DynamicUpdateField<uint32, 0, 17> RuneforgePowers;
-    DynamicUpdateField<uint32, 0, 18> TransmogIllusions;
-    DynamicUpdateField<UF::SpellPctModByLabel, 0, 20> SpellPctModByLabel;
-    DynamicUpdateField<UF::SpellFlatModByLabel, 0, 21> SpellFlatModByLabel;
-    DynamicUpdateField<UF::MawPower, 0, 22> MawPowers;
-    DynamicUpdateField<UF::MultiFloorExplore, 0, 23> MultiFloorExploration;
-    DynamicUpdateField<UF::RecipeProgressionInfo, 0, 24> RecipeProgression;
-    DynamicUpdateField<UF::ReplayedQuest, 0, 25> ReplayedQuests;
-    DynamicUpdateField<int32, 0, 26> DisabledSpells;
-    DynamicUpdateField<UF::CharacterRestriction, 0, 19> CharacterRestrictions;
-    UpdateField<ObjectGuid, 0, 29> FarsightObject;
-    UpdateField<ObjectGuid, 0, 30> SummonedBattlePetGUID;
-    UpdateField<uint64, 0, 31> Coinage;
-    UpdateField<int32, 0, 32> XP;
-    UpdateField<int32, 0, 33> NextLevelXP;
-    UpdateField<int32, 34, 35> TrialXP;
-    UpdateField<UF::SkillInfo, 34, 36> Skill;
-    UpdateField<int32, 34, 37> CharacterPoints;
-    UpdateField<int32, 34, 38> MaxTalentTiers;
-    UpdateField<uint32, 34, 39> TrackCreatureMask;
-    UpdateField<float, 34, 40> MainhandExpertise;
-    UpdateField<float, 34, 41> OffhandExpertise;
-    UpdateField<float, 34, 42> RangedExpertise;
-    UpdateField<float, 34, 43> CombatRatingExpertise;
-    UpdateField<float, 34, 44> BlockPercentage;
-    UpdateField<float, 34, 45> DodgePercentage;
-    UpdateField<float, 34, 46> DodgePercentageFromAttribute;
-    UpdateField<float, 34, 47> ParryPercentage;
-    UpdateField<float, 34, 48> ParryPercentageFromAttribute;
-    UpdateField<float, 34, 49> CritPercentage;
-    UpdateField<float, 34, 50> RangedCritPercentage;
-    UpdateField<float, 34, 51> OffhandCritPercentage;
-    UpdateField<float, 34, 52> SpellCritPercentage;
-    UpdateField<int32, 34, 53> ShieldBlock;
-    UpdateField<float, 34, 54> ShieldBlockCritPercentage;
-    UpdateField<float, 34, 55> Mastery;
-    UpdateField<float, 34, 56> Speed;
-    UpdateField<float, 34, 57> Avoidance;
-    UpdateField<float, 34, 58> Sturdiness;
-    UpdateField<int32, 34, 59> Versatility;
-    UpdateField<float, 34, 60> VersatilityBonus;
-    UpdateField<float, 34, 61> PvpPowerDamage;
-    UpdateField<float, 34, 62> PvpPowerHealing;
-    UpdateField<int32, 34, 63> ModHealingDonePos;
-    UpdateField<float, 34, 64> ModHealingPercent;
-    UpdateField<float, 34, 65> ModPeriodicHealingDonePercent;
-    UpdateField<float, 66, 67> ModSpellPowerPercent;
-    UpdateField<float, 66, 68> ModResiliencePercent;
-    UpdateField<float, 66, 69> OverrideSpellPowerByAPPercent;
-    UpdateField<float, 66, 70> OverrideAPBySpellPowerPercent;
-    UpdateField<int32, 66, 71> ModTargetResistance;
-    UpdateField<int32, 66, 72> ModTargetPhysicalResistance;
-    UpdateField<uint32, 66, 73> LocalFlags;
-    UpdateField<uint8, 66, 74> GrantableLevels;
-    UpdateField<uint8, 66, 75> MultiActionBars;
-    UpdateField<uint8, 66, 76> LifetimeMaxRank;
-    UpdateField<uint8, 66, 77> NumRespecs;
-    UpdateField<uint32, 66, 78> PvpMedals;
-    UpdateField<uint16, 66, 79> TodayHonorableKills;
-    UpdateField<uint16, 66, 80> YesterdayHonorableKills;
-    UpdateField<uint32, 66, 81> LifetimeHonorableKills;
-    UpdateField<int32, 66, 82> WatchedFactionIndex;
-    UpdateField<int32, 66, 83> MaxLevel;
-    UpdateField<int32, 66, 84> ScalingPlayerLevelDelta;
-    UpdateField<int32, 66, 85> MaxCreatureScalingLevel;
-    UpdateField<int32, 66, 86> PetSpellPower;
-    UpdateField<float, 66, 87> UiHitModifier;
-    UpdateField<float, 66, 88> UiSpellHitModifier;
-    UpdateField<int32, 66, 89> HomeRealmTimeOffset;
-    UpdateField<float, 66, 90> ModPetHaste;
-    UpdateField<int8, 66, 91> JailersTowerLevelMax;
-    UpdateField<int8, 66, 92> JailersTowerLevel;
-    UpdateField<uint8, 66, 93> LocalRegenFlags;
-    UpdateField<uint8, 66, 94> AuraVision;
-    UpdateField<uint8, 66, 95> NumBackpackSlots;
-    UpdateField<int32, 66, 96> OverrideSpellsID;
-    UpdateField<uint16, 66, 97> LootSpecID;
-    UpdateField<uint32, 98, 99> OverrideZonePVPType;
-    UpdateField<ObjectGuid, 98, 100> BnetAccount;
-    UpdateField<uint64, 98, 101> GuildClubMemberID;
-    UpdateField<int32, 98, 102> Honor;
-    UpdateField<int32, 98, 103> HonorNextLevel;
-    UpdateField<uint8, 98, 104> NumBankSlots;
-    UpdateField<UF::ActivePlayerUnk901, 98, 106> Field_1410;
-    OptionalUpdateField<UF::QuestSession, 98, 105> QuestSession;
-    UpdateField<int32, 98, 107> UiChromieTimeExpansionID;
-    UpdateField<int32, 98, 108> TransportServerTime;
-    UpdateField<uint32, 98, 109> WeeklyRewardsPeriodSinceOrigin;                // week count since Cfg_RegionsEntry::ChallengeOrigin
-    UpdateField<int16, 98, 110> DEBUGSoulbindConduitRank;
-    UpdateField<WorldPackets::MythicPlus::DungeonScoreData, 98, 111> DungeonScore;
-    UpdateFieldArray<ObjectGuid, 199, 112, 113> InvSlots;
-    UpdateFieldArray<uint64, 240, 312, 313> ExploredZones;
-    UpdateFieldArray<UF::RestInfo, 2, 553, 554> RestInfo;
-    UpdateFieldArray<int32, 7, 556, 557> ModDamageDonePos;
-    UpdateFieldArray<int32, 7, 556, 564> ModDamageDoneNeg;
-    UpdateFieldArray<float, 7, 556, 571> ModDamageDonePercent;
-    UpdateFieldArray<float, 7, 556, 578> ModHealingDonePercent;
-    UpdateFieldArray<float, 3, 585, 586> WeaponDmgMultipliers;
-    UpdateFieldArray<float, 3, 585, 589> WeaponAtkSpeedMultipliers;
-    UpdateFieldArray<uint32, 12, 592, 593> BuybackPrice;
-    UpdateFieldArray<int64, 12, 592, 605> BuybackTimestamp;
-    UpdateFieldArray<int32, 32, 617, 618> CombatRatings;
-    UpdateFieldArray<UF::PVPInfo, 6, 650, 651> PvpInfo;
-    UpdateFieldArray<uint32, 4, 657, 658> NoReagentCostMask;
-    UpdateFieldArray<int32, 2, 662, 663> ProfessionSkillLine;
-    UpdateFieldArray<uint32, 4, 665, 666> BagSlotFlags;
-    UpdateFieldArray<uint32, 7, 670, 671> BankBagSlotFlags;
-    UpdateFieldArray<uint64, 875, 678, 679> QuestCompleted;
+    DynamicUpdateField<uint16, 0, 7> ResearchSites;
+    DynamicUpdateField<uint32, 0, 8> ResearchSiteProgress;
+    DynamicUpdateField<int32, 0, 9> DailyQuestsCompleted;
+    DynamicUpdateField<int32, 0, 10> AvailableQuestLineXQuestIDs;
+    DynamicUpdateField<int32, 0, 11> Heirlooms;
+    DynamicUpdateField<uint32, 0, 12> HeirloomFlags;
+    DynamicUpdateField<int32, 0, 13> Toys;
+    DynamicUpdateField<uint32, 0, 14> ToyFlags;
+    DynamicUpdateField<uint32, 0, 15> Transmog;
+    DynamicUpdateField<int32, 0, 16> ConditionalTransmog;
+    DynamicUpdateField<int32, 0, 17> SelfResSpells;
+    DynamicUpdateField<uint32, 0, 18> RuneforgePowers;
+    DynamicUpdateField<uint32, 0, 19> TransmogIllusions;
+    DynamicUpdateField<UF::SpellPctModByLabel, 0, 21> SpellPctModByLabel;
+    DynamicUpdateField<UF::SpellFlatModByLabel, 0, 22> SpellFlatModByLabel;
+    DynamicUpdateField<UF::MawPower, 0, 23> MawPowers;
+    DynamicUpdateField<UF::MultiFloorExplore, 0, 24> MultiFloorExploration;
+    DynamicUpdateField<UF::RecipeProgressionInfo, 0, 25> RecipeProgression;
+    DynamicUpdateField<UF::ReplayedQuest, 0, 26> ReplayedQuests;
+    DynamicUpdateField<int32, 0, 27> DisabledSpells;
+    DynamicUpdateField<UF::PVPInfo, 0, 6> PvpInfo;
+    DynamicUpdateField<UF::CharacterRestriction, 0, 20> CharacterRestrictions;
+    DynamicUpdateField<UF::TraitConfig, 0, 28> TraitConfigs;
+    DynamicUpdateField<UF::CraftingOrder, 0, 29> CraftingOrders;
+    UpdateField<ObjectGuid, 0, 32> FarsightObject;
+    UpdateField<ObjectGuid, 0, 33> SummonedBattlePetGUID;
+    UpdateField<uint64, 34, 35> Coinage;
+    UpdateField<int32, 34, 36> XP;
+    UpdateField<int32, 34, 37> NextLevelXP;
+    UpdateField<int32, 34, 38> TrialXP;
+    UpdateField<UF::SkillInfo, 34, 39> Skill;
+    UpdateField<int32, 34, 40> CharacterPoints;
+    UpdateField<int32, 34, 41> MaxTalentTiers;
+    UpdateField<uint32, 34, 42> TrackCreatureMask;
+    UpdateField<float, 34, 43> MainhandExpertise;
+    UpdateField<float, 34, 44> OffhandExpertise;
+    UpdateField<float, 34, 45> RangedExpertise;
+    UpdateField<float, 34, 46> CombatRatingExpertise;
+    UpdateField<float, 34, 47> BlockPercentage;
+    UpdateField<float, 34, 48> DodgePercentage;
+    UpdateField<float, 34, 49> DodgePercentageFromAttribute;
+    UpdateField<float, 34, 50> ParryPercentage;
+    UpdateField<float, 34, 51> ParryPercentageFromAttribute;
+    UpdateField<float, 34, 52> CritPercentage;
+    UpdateField<float, 34, 53> RangedCritPercentage;
+    UpdateField<float, 34, 54> OffhandCritPercentage;
+    UpdateField<float, 34, 55> SpellCritPercentage;
+    UpdateField<int32, 34, 56> ShieldBlock;
+    UpdateField<float, 34, 57> ShieldBlockCritPercentage;
+    UpdateField<float, 34, 58> Mastery;
+    UpdateField<float, 34, 59> Speed;
+    UpdateField<float, 34, 60> Avoidance;
+    UpdateField<float, 34, 61> Sturdiness;
+    UpdateField<int32, 34, 62> Versatility;
+    UpdateField<float, 34, 63> VersatilityBonus;
+    UpdateField<float, 34, 64> PvpPowerDamage;
+    UpdateField<float, 34, 65> PvpPowerHealing;
+    UpdateField<int32, 66, 67> ModHealingDonePos;
+    UpdateField<float, 66, 68> ModHealingPercent;
+    UpdateField<float, 66, 69> ModPeriodicHealingDonePercent;
+    UpdateField<float, 66, 70> ModSpellPowerPercent;
+    UpdateField<float, 66, 71> ModResiliencePercent;
+    UpdateField<float, 66, 72> OverrideSpellPowerByAPPercent;
+    UpdateField<float, 66, 73> OverrideAPBySpellPowerPercent;
+    UpdateField<int32, 66, 74> ModTargetResistance;
+    UpdateField<int32, 66, 75> ModTargetPhysicalResistance;
+    UpdateField<uint32, 66, 76> LocalFlags;
+    UpdateField<uint8, 66, 77> GrantableLevels;
+    UpdateField<uint8, 66, 78> MultiActionBars;
+    UpdateField<uint8, 66, 79> LifetimeMaxRank;
+    UpdateField<uint8, 66, 80> NumRespecs;
+    UpdateField<uint32, 66, 81> PvpMedals;
+    UpdateField<uint16, 66, 82> TodayHonorableKills;
+    UpdateField<uint16, 66, 83> YesterdayHonorableKills;
+    UpdateField<uint32, 66, 84> LifetimeHonorableKills;
+    UpdateField<int32, 66, 85> WatchedFactionIndex;
+    UpdateField<int32, 66, 86> MaxLevel;
+    UpdateField<int32, 66, 87> ScalingPlayerLevelDelta;
+    UpdateField<int32, 66, 88> MaxCreatureScalingLevel;
+    UpdateField<int32, 66, 89> PetSpellPower;
+    UpdateField<float, 66, 90> UiHitModifier;
+    UpdateField<float, 66, 91> UiSpellHitModifier;
+    UpdateField<int32, 66, 92> HomeRealmTimeOffset;
+    UpdateField<float, 66, 93> ModPetHaste;
+    UpdateField<int8, 66, 94> JailersTowerLevelMax;
+    UpdateField<int8, 66, 95> JailersTowerLevel;
+    UpdateField<uint8, 66, 96> LocalRegenFlags;
+    UpdateField<uint8, 66, 97> AuraVision;
+    UpdateField<uint8, 98, 99> NumBackpackSlots;
+    UpdateField<int32, 98, 100> OverrideSpellsID;
+    UpdateField<uint16, 98, 101> LootSpecID;
+    UpdateField<uint32, 98, 102> OverrideZonePVPType;
+    UpdateField<ObjectGuid, 98, 103> BnetAccount;
+    UpdateField<uint64, 98, 104> GuildClubMemberID;
+    UpdateField<int32, 98, 105> Honor;
+    UpdateField<int32, 98, 106> HonorNextLevel;
+    UpdateField<uint8, 98, 107> NumBankSlots;
+    UpdateField<UF::ActivePlayerUnk901, 98, 109> Field_1410;
+    OptionalUpdateField<UF::QuestSession, 98, 108> QuestSession;
+    UpdateField<int32, 98, 110> UiChromieTimeExpansionID;
+    UpdateField<int32, 98, 111> TransportServerTime;
+    UpdateField<uint32, 98, 112> WeeklyRewardsPeriodSinceOrigin;                // week count since Cfg_RegionsEntry::ChallengeOrigin
+    UpdateField<int16, 98, 113> DEBUGSoulbindConduitRank;
+    UpdateField<WorldPackets::MythicPlus::DungeonScoreData, 98, 114> DungeonScore;
+    UpdateField<uint32, 98, 115> ActiveCombatTraitConfigID;
+    UpdateFieldArray<ObjectGuid, 218, 116, 117> InvSlots;
+    UpdateFieldArray<uint64, 240, 335, 336> ExploredZones;
+    UpdateFieldArray<UF::RestInfo, 2, 576, 577> RestInfo;
+    UpdateFieldArray<int32, 7, 579, 580> ModDamageDonePos;
+    UpdateFieldArray<int32, 7, 579, 587> ModDamageDoneNeg;
+    UpdateFieldArray<float, 7, 579, 594> ModDamageDonePercent;
+    UpdateFieldArray<float, 7, 579, 601> ModHealingDonePercent;
+    UpdateFieldArray<float, 3, 608, 609> WeaponDmgMultipliers;
+    UpdateFieldArray<float, 3, 608, 612> WeaponAtkSpeedMultipliers;
+    UpdateFieldArray<uint32, 12, 615, 616> BuybackPrice;
+    UpdateFieldArray<int64, 12, 615, 628> BuybackTimestamp;
+    UpdateFieldArray<int32, 32, 640, 641> CombatRatings;
+    UpdateFieldArray<uint32, 4, 673, 674> NoReagentCostMask;
+    UpdateFieldArray<int32, 2, 678, 679> ProfessionSkillLine;
+    UpdateFieldArray<uint32, 5, 681, 682> BagSlotFlags;
+    UpdateFieldArray<uint32, 7, 687, 688> BankBagSlotFlags;
+    UpdateFieldArray<uint64, 875, 695, 696> QuestCompleted;
 
     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;
@@ -790,30 +888,34 @@ struct ActivePlayerData : public IsUpdateFieldStructureTag, public HasChangesMas
     void ClearChangesMask();
 };
 
-struct GameObjectData : public IsUpdateFieldStructureTag, public HasChangesMask<21>
+struct GameObjectData : public IsUpdateFieldStructureTag, public HasChangesMask<25>
 {
     UpdateField<std::vector<uint32>, 0, 1> StateWorldEffectIDs;
     DynamicUpdateField<int32, 0, 2> EnableDoodadSets;
-    UpdateField<int32, 0, 3> DisplayID;
-    UpdateField<uint32, 0, 4> SpellVisualID;
-    UpdateField<uint32, 0, 5> StateSpellVisualID;
-    UpdateField<uint32, 0, 6> SpawnTrackingStateAnimID;
-    UpdateField<uint32, 0, 7> SpawnTrackingStateAnimKitID;
-    UpdateField<uint32, 0, 8> StateWorldEffectsQuestObjectiveID;
-    UpdateField<ObjectGuid, 0, 9> CreatedBy;
-    UpdateField<ObjectGuid, 0, 10> GuildGUID;
-    UpdateField<uint32, 0, 11> Flags;
+    DynamicUpdateField<int32, 0, 3> WorldEffects;
+    UpdateField<int32, 0, 4> DisplayID;
+    UpdateField<uint32, 0, 5> SpellVisualID;
+    UpdateField<uint32, 0, 6> StateSpellVisualID;
+    UpdateField<uint32, 0, 7> SpawnTrackingStateAnimID;
+    UpdateField<uint32, 0, 8> SpawnTrackingStateAnimKitID;
+    UpdateField<uint32, 0, 9> StateWorldEffectsQuestObjectiveID;
+    UpdateField<ObjectGuid, 0, 10> CreatedBy;
+    UpdateField<ObjectGuid, 0, 11> GuildGUID;
+    UpdateField<uint32, 0, 12> Flags;
     struct FlagsTag : ViewerDependentValueTag<uint32> {};
-    UpdateField<QuaternionData, 0, 12> ParentRotation;
-    UpdateField<int32, 0, 13> FactionTemplate;
-    UpdateField<int8, 0, 14> State;
+    UpdateField<QuaternionData, 0, 13> ParentRotation;
+    UpdateField<int32, 0, 14> FactionTemplate;
+    UpdateField<int8, 0, 15> State;
     struct StateTag : ViewerDependentValueTag<int8> {};
-    UpdateField<int8, 0, 15> TypeID;
-    UpdateField<uint8, 0, 16> PercentHealth;
-    UpdateField<uint32, 0, 17> ArtKit;
-    UpdateField<uint32, 0, 18> CustomParam;
-    UpdateField<int32, 0, 19> Level;
-    UpdateField<uint32, 0, 20> AnimGroupInstance;
+    UpdateField<int8, 0, 16> TypeID;
+    UpdateField<uint8, 0, 17> PercentHealth;
+    UpdateField<uint32, 0, 18> ArtKit;
+    UpdateField<uint32, 0, 19> CustomParam;
+    UpdateField<int32, 0, 20> Level;
+    UpdateField<uint32, 0, 21> AnimGroupInstance;
+    UpdateField<uint32, 0, 22> UiWidgetItemID;
+    UpdateField<uint32, 0, 23> UiWidgetItemQuality;
+    UpdateField<uint32, 0, 24> UiWidgetItemUnknown1000;
 
     void WriteCreate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, GameObject const* owner, Player const* receiver) const;
     void WriteUpdate(ByteBuffer& data, EnumFlag<UpdateFieldFlag> fieldVisibilityFlags, GameObject const* owner, Player const* receiver) const;
@@ -882,25 +984,30 @@ struct VisualAnim : public IsUpdateFieldStructureTag, public HasChangesMask<5>
     void ClearChangesMask();
 };
 
-struct AreaTriggerData : public IsUpdateFieldStructureTag, public HasChangesMask<18>
+struct AreaTriggerData : public IsUpdateFieldStructureTag, public HasChangesMask<23>
 {
     UpdateField<UF::ScaleCurve, 0, 1> OverrideScaleCurve;
     UpdateField<UF::ScaleCurve, 0, 2> ExtraScaleCurve;
-    UpdateField<ObjectGuid, 0, 3> Caster;
-    UpdateField<uint32, 0, 4> Duration;
-    UpdateField<uint32, 0, 5> TimeToTarget;
-    UpdateField<uint32, 0, 6> TimeToTargetScale;
-    UpdateField<uint32, 0, 7> TimeToTargetExtraScale;
-    UpdateField<int32, 0, 8> SpellID;
-    UpdateField<int32, 0, 9> SpellForVisuals;
-    UpdateField<UF::SpellCastVisual, 0, 10> SpellVisual;
-    UpdateField<float, 0, 11> BoundsRadius2D;
-    UpdateField<uint32, 0, 12> DecalPropertiesID;
-    UpdateField<ObjectGuid, 0, 13> CreatingEffectGUID;
-    UpdateField<uint32, 0, 14> Field_80;
-    UpdateField<uint32, 0, 15> Field_84;
-    UpdateField<ObjectGuid, 0, 16> Field_88;
-    UpdateField<UF::VisualAnim, 0, 17> VisualAnim;
+    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;
 
     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;