Core/PacketIO: Updated SMSG_UPDATE_OBJECT

5 files changed, 239 insertions, 216 deletions

diff --git a/src/server/game/Entities/Item/Item.cpp b/src/server/game/Entities/Item/Item.cpp
index a049256f0a7..ab6e26627be 100644
--- a/src/server/game/Entities/Item/Item.cpp
+++ b/src/server/game/Entities/Item/Item.cpp
@@ -1157,7 +1157,7 @@ void Item::BuildDynamicValuesUpdate(uint8 updateType, ByteBuffer* data, Player*
 
             }
 
-            fieldBuffer << uint8(arrayMask.GetBlockCount());
+            fieldBuffer << uint16(arrayMask.GetBlockCount());
             arrayMask.AppendToPacket(&fieldBuffer);
             fieldBuffer.append(buffer);
         }
diff --git a/src/server/game/Entities/Object/Object.cpp b/src/server/game/Entities/Object/Object.cpp
index 67d8d89cdf6..0a1a0739616 100644
--- a/src/server/game/Entities/Object/Object.cpp
+++ b/src/server/game/Entities/Object/Object.cpp
@@ -352,9 +352,9 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
     bool HasAreaTrigger = false;
     bool HasGameObject = false;
     bool ThisIsYou = (flags & UPDATEFLAG_SELF) != 0;
-    bool ReplaceActive = false;
+    bool SmoothPhasing = false;
     bool SceneObjCreate = false;
-    bool ScenePendingInstances = false;
+    bool PlayerCreateData = false;
     uint32 PauseTimesCount = 0;
     if (GameObject const* go = ToGameObject())
         if (go->GetGoType() == GAMEOBJECT_TYPE_TRANSPORT)
@@ -374,11 +374,11 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
     data->WriteBit(Rotation);
     data->WriteBit(HasAreaTrigger);
     data->WriteBit(HasGameObject);
+    data->WriteBit(SmoothPhasing);
     data->WriteBit(ThisIsYou);
-    data->WriteBit(ReplaceActive);
     data->WriteBit(SceneObjCreate);
-    data->WriteBit(ScenePendingInstances);
-    *data << uint32(PauseTimesCount);
+    data->WriteBit(PlayerCreateData);
+    data->FlushBits();
 
     if (HasMovementUpdate)
     {
@@ -389,7 +389,7 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
 
         *data << GetPackGUID();                                         // MoverGUID
 
-        *data << uint32(unit->m_movementInfo.time);                     // MoveIndex
+        *data << uint32(unit->m_movementInfo.time);                     // MoveTime
         *data << float(unit->GetPositionX());
         *data << float(unit->GetPositionY());
         *data << float(unit->GetPositionZ());
@@ -398,15 +398,14 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
         *data << float(unit->m_movementInfo.pitch);                     // Pitch
         *data << float(unit->m_movementInfo.splineElevation);           // StepUpStartElevation
 
-        uint32 removeMovementForcesCount = 0;
-        *data << uint32(removeMovementForcesCount);                     // Count of RemoveForcesIDs
-        *data << uint32(0);                                             // Unknown
+        *data << uint32(0);                                             // RemoveForcesIDs.size()
+        *data << uint32(0);                                             // MoveIndex
 
-        //for (uint32 i = 0; i < removeMovementForcesCount; ++i)
+        //for (std::size_t i = 0; i < RemoveForcesIDs.size(); ++i)
         //    *data << ObjectGuid(RemoveForcesIDs);
 
         data->WriteBits(unit->GetUnitMovementFlags(), 30);
-        data->WriteBits(unit->GetExtraUnitMovementFlags(), 16);
+        data->WriteBits(unit->GetExtraUnitMovementFlags(), 18);
         data->WriteBit(!unit->m_movementInfo.transport.guid.IsEmpty()); // HasTransport
         data->WriteBit(HasFall);                                        // HasFall
         data->WriteBit(HasSpline);                                      // HasSpline - marks that the unit uses spline movement
@@ -439,29 +438,26 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
         *data << float(unit->GetSpeed(MOVE_TURN_RATE));
         *data << float(unit->GetSpeed(MOVE_PITCH_RATE));
 
-        uint32 MovementForceCount = 0;
-        *data << uint32(MovementForceCount);
+        *data << uint32(0);                                                   // unit->m_movementInfo.forces.size()
 
-        //for (uint32 i = 0; i < MovementForceCount; ++i)
+        data->WriteBit(HasSpline);
+        data->FlushBits();
+
+        //for (std::size_t i = 0; i < unit->m_movementInfo.forces.size(); ++i)
         //{
         //    *data << ObjectGuid(ID);
+        //    *data << Vector3(Origin);
         //    *data << Vector3(Direction);
-        //    *data << Vector3(force.TransportPosition);
         //    *data << int32(TransportID);
         //    *data << float(Magnitude);
-        //    *data << uint8(Type);
+        //    data->WriteBits(Type, 2);
         //}
 
-        // HasMovementSpline - marks that spline data is present in packet
-        if (data->WriteBit(HasSpline))
+        if (HasSpline)
             WorldPackets::Movement::CommonMovement::WriteCreateObjectSplineDataBlock(*unit->movespline, *data);
     }
 
-    if (HasMovementTransport)
-    {
-        WorldObject const* self = static_cast<WorldObject const*>(this);
-        *data << self->m_movementInfo.transport;
-    }
+    *data << uint32(PauseTimesCount);
 
     if (Stationary)
     {
@@ -507,243 +503,263 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
     if (Rotation)
         *data << uint64(ToGameObject()->GetRotation());                 // Rotation
 
+    if (GameObject const* go = ToGameObject())
+        for (uint32 i = 0; i < PauseTimesCount; ++i)
+            *data << uint32(go->GetGOValue()->Transport.StopFrames->at(i));
+
+    if (HasMovementTransport)
+    {
+        WorldObject const* self = static_cast<WorldObject const*>(this);
+        *data << self->m_movementInfo.transport;
+    }
+
     //if (AreaTrigger)
     //{
-    //    packet.ReadInt32("ElapsedMs", index);
-
-    //    packet.ReadVector3("RollPitchYaw1", index);
-
-    //    packet.ResetBitReader();
-
-    //    var HasAbsoluteOrientation = packet.ReadBit("HasAbsoluteOrientation", index);
-    //    var HasDynamicShape = packet.ReadBit("HasDynamicShape", index);
-    //    var HasAttached = packet.ReadBit("HasAttached", index);
-    //    var HasFaceMovementDir = packet.ReadBit("HasFaceMovementDir", index);
-    //    var HasFollowsTerrain = packet.ReadBit("HasFollowsTerrain", index);
-    //    var HasTargetRollPitchYaw = packet.ReadBit("HasTargetRollPitchYaw", index);
-    //    var HasScaleCurveID = packet.ReadBit("HasScaleCurveID", index);
-    //    var HasMorphCurveID = packet.ReadBit("HasMorphCurveID", index);
-    //    var HasFacingCurveID = packet.ReadBit("HasFacingCurveID", index);
-    //    var HasMoveCurveID = packet.ReadBit("HasMoveCurveID", index);
-    //    var HasAreaTriggerSphere = packet.ReadBit("HasAreaTriggerSphere", index);
-    //    var HasAreaTriggerBox = packet.ReadBit("HasAreaTriggerBox", index);
-    //    var HasAreaTriggerPolygon = packet.ReadBit("HasAreaTriggerPolygon", index);
-    //    var HasAreaTriggerCylinder = packet.ReadBit("HasAreaTriggerCylinder", index);
-    //    var HasAreaTriggerSpline = packet.ReadBit("HasAreaTriggerSpline", index);
+    //    *data << uint32(ElapsedMs);
+    //    *data << Vector3(RollPitchYaw);
+    //    data->WriteBit(HasAbsoluteOrientation);
+    //    data->WriteBit(HasDynamicShape);
+    //    data->WriteBit(HasAttached);
+    //    data->WriteBit(HasFaceMovementDir);
+    //    data->WriteBit(HasFollowsTerrain);
+    //    data->WriteBit(Unknown_1);
+    //    data->WriteBit(HasTargetRollPitchYaw);
+    //    data->WriteBit(HasScaleCurveID);
+    //    data->WriteBit(HasMorphCurveID);
+    //    data->WriteBit(HasFacingCurveID);
+    //    data->WriteBit(HasMoveCurveID);
+    //    data->WriteBit(HasAreaTriggerSphere);
+    //    data->WriteBit(HasAreaTriggerBox);
+    //    data->WriteBit(HasAreaTriggerPolygon);
+    //    data->WriteBit(HasAreaTriggerCylinder);
+    //    data->WriteBit(HasAreaTriggerSpline);
+    //    data->WriteBit(HasAreaTriggerUnkType);
+
+    //    if (HasAreaTriggerUnkType)
+    //    {
+    //        data->WriteBit(Unk_1);
+    //        data->WriteBit(HasCenter);
+    //        data->WriteBit(Unk_3);
+    //        data->WriteBit(Unk_4);
+
+    //        *data << uint32();
+    //        *data << int32();
+    //        *data << uint32();
+    //        *data << float(Radius);
+    //        *data << float(BlendFromRadius);
+    //        *data << float(InitialAngel);
+    //        *data << float(ZOffset);
+
+    //        if (Unk_1)
+    //            *data << ObjectGuid();
+
+    //        if (HasCenter)
+    //            *data << Vector3(Center);
+    //    }
 
     //    if (HasTargetRollPitchYaw)
-    //        packet.ReadVector3("TargetRollPitchYaw", index);
+    //        *data << Vector3(TargetRollPitchYaw);
 
     //    if (HasScaleCurveID)
-    //        packet.ReadInt32("ScaleCurveID, index");
+    //        *data << uint32(ScaleCurveID);
 
     //    if (HasMorphCurveID)
-    //        packet.ReadInt32("MorphCurveID", index);
+    //        *data << uint32(MorphCurveID);
 
     //    if (HasFacingCurveID)
-    //        packet.ReadInt32("FacingCurveID", index);
+    //        *data << uint32(FacingCurveID);
 
     //    if (HasMoveCurveID)
-    //        packet.ReadInt32("MoveCurveID", index);
+    //        *data << uint32(MoveCurveID);
 
     //    if (HasAreaTriggerSphere)
     //    {
-    //        packet.ReadSingle("Radius", index);
-    //        packet.ReadSingle("RadiusTarget", index);
+    //        *data << float(Radius);
+    //        *data << float(RadiusTarget);
     //    }
 
     //    if (HasAreaTriggerBox)
     //    {
-    //        packet.ReadVector3("Extents", index);
-    //        packet.ReadVector3("ExtentsTarget", index);
+    //        *data << Vector3(Extents);
+    //        *data << Vector3(ExtentsTarget);
     //    }
 
     //    if (HasAreaTriggerPolygon)
     //    {
-    //        var VerticesCount = packet.ReadInt32("VerticesCount", index);
-    //        var VerticesTargetCount = packet.ReadInt32("VerticesTargetCount", index);
-    //        packet.ReadSingle("Height", index);
-    //        packet.ReadSingle("HeightTarget", index);
+    //        *data << uint32(Vertices.size());
+    //        *data << uint32(VerticesTarget.size());
+    //        *data << float(Height);
+    //        *data << float(HeightTarget);
 
-    //        for (var i = 0; i < VerticesCount; ++i)
-    //            packet.ReadVector2("Vertices", index, i);
+    //        for (std::size_t i = 0; i < Vertices.size(); ++i)
+    //            *data << Vector2(Vertices[i]);
 
-    //        for (var i = 0; i < VerticesTargetCount; ++i)
-    //            packet.ReadVector2("VerticesTarget", index, i);
+    //        for (std::size_t i = 0; i < VerticesTarget.size(); ++i)
+    //            *data << Vector2(VerticesTarget[i]);
     //    }
 
     //    if (HasAreaTriggerCylinder)
     //    {
-    //        packet.ReadSingle("Radius", index);
-    //        packet.ReadSingle("RadiusTarget", index);
-    //        packet.ReadSingle("Height", index);
-    //        packet.ReadSingle("HeightTarget", index);
-    //        packet.ReadSingle("Float4", index);
-    //        packet.ReadSingle("Float5", index);
+    //        *data << float(Radius);
+    //        *data << float(RadiusTarget);
+    //        *data << float(Height);
+    //        *data << float(HeightTarget);
+    //        *data << float(LocationZOffset);
+    //        *data << float(LocationZOffsetTarget);
     //    }
 
     //    if (HasAreaTriggerSpline)
     //    {
-    //        packet.ReadInt32("TimeToTarget", index);
-    //        packet.ReadInt32("ElapsedTimeForMovement", index);
-    //        var int8 = packet.ReadInt32("VerticesCount", index);
+    //        *data << uint32(TimeToTarget);
+    //        *data << uint32(ElapsedTimeForMovement);
+    //        *data << uint32(Points.size());
 
-    //        for (var i = 0; i < int8; ++i)
-    //            packet.ReadVector3("Points", index, i);
+    //        for (std::size_t i = 0; i < Points.size(); ++i)
+    //            *data << Vector3(Points[i]);
     //    }
     //}
 
     //if (GameObject)
     //{
-    //    packet.ReadInt32("WorldEffectID", index);
+    //    *data << uint32(WorldEffectID);
 
-    //    packet.ResetBitReader();
-
-    //    var bit8 = packet.ReadBit("bit8", index);
+    //    data->WriteBit(bit8);
     //    if (bit8)
-    //        packet.ReadInt32("Int1", index);
+    //        *data << uint32(Int1);
     //}
 
-    //if (SceneObjCreate)
+    //if (SmoothPhasing)
     //{
-    //    packet.ResetBitReader();
+    //    data->WriteBit(ReplaceActive);
+    //    data->WriteBit(HasReplaceObjectt);
+    //    if (HasReplaceObject)
+    //        *data << ObjectGuid(ReplaceObject);
+    //}
 
-    //    var CliSceneLocalScriptData = packet.ReadBit("CliSceneLocalScriptData", index);
-    //    var PetBattleFullUpdate = packet.ReadBit("PetBattleFullUpdate", index);
+    //if (SceneObjCreate)
+    //{
+    //    data->WriteBit(HasLocalScriptData);
+    //    data->WriteBit(HasPetBattleFullUpdate);
 
-    //    if (CliSceneLocalScriptData)
+    //    if (HasLocalScriptData)
     //    {
-    //        packet.ResetBitReader();
-    //        var DataLength = packet.ReadBits(7);
-    //        packet.ReadWoWString("Data", DataLength, index);
+    //        data->WriteBits(Data.length(), 7);
+    //        data->WriteString(Data);
     //    }
 
-    //    if (PetBattleFullUpdate)
+    //    if (HasPetBattleFullUpdate)
     //    {
-    //        for (var i = 0; i < 2; ++i)
+    //        for (std::size_t i = 0; i < 2; ++i)
     //        {
-    //            packet.ReadPackedGuid128("CharacterID", index, i);
-
-    //            packet.ReadInt32("TrapAbilityID", index, i);
-    //            packet.ReadInt32("TrapStatus", index, i);
-
-    //            packet.ReadInt16("RoundTimeSecs", index, i);
-
-    //            packet.ReadByte("FrontPet", index, i);
-    //            packet.ReadByte("InputFlags", index, i);
-
-    //            packet.ResetBitReader();
-
-    //            var PetBattlePetUpdateCount = packet.ReadBits("PetBattlePetUpdateCount", 2, index, i);
-
-    //            for (var j = 0; j < PetBattlePetUpdateCount; ++j)
+    //            *data << ObjectGuid(Players[i].CharacterID);
+    //            *data << int32(Players[i].TrapAbilityID);
+    //            *data << int32(Players[i].TrapStatus);
+    //            *data << uint16(Players[i].RoundTimeSecs);
+    //            *data << int8(Players[i].FrontPet);
+    //            *data << uint8(Players[i].InputFlags);
+
+    //            data->WriteBits(Players[i].Pets.size(), 2);
+    //            for (std::size_t j = 0; j < Players[i].Pets.size(); ++j)
     //            {
-    //                packet.ReadPackedGuid128("BattlePetGUID", index, i, j);
-
-    //                packet.ReadInt32("SpeciesID", index, i, j);
-    //                packet.ReadInt32("DisplayID", index, i, j);
-    //                packet.ReadInt32("CollarID", index, i, j);
-
-    //                packet.ReadInt16("Level", index, i, j);
-    //                packet.ReadInt16("Xp", index, i, j);
-
-
-    //                packet.ReadInt32("CurHealth", index, i, j);
-    //                packet.ReadInt32("MaxHealth", index, i, j);
-    //                packet.ReadInt32("Power", index, i, j);
-    //                packet.ReadInt32("Speed", index, i, j);
-    //                packet.ReadInt32("NpcTeamMemberID", index, i, j);
-
-    //                packet.ReadInt16("BreedQuality", index, i, j);
-    //                packet.ReadInt16("StatusFlags", index, i, j);
-
-    //                packet.ReadByte("Slot", index, i, j);
-
-    //                var PetBattleActiveAbility = packet.ReadInt32("PetBattleActiveAbility", index, i, j);
-    //                var PetBattleActiveAura = packet.ReadInt32("PetBattleActiveAura", index, i, j);
-    //                var PetBattleActiveState = packet.ReadInt32("PetBattleActiveState", index, i, j);
-
-    //                for (var k = 0; k < PetBattleActiveAbility; ++k)
+    //                *data << ObjectGuid(Players[i].Pets[j].BattlePetGUID);
+    //                *data << int32(Players[i].Pets[j].SpeciesID);
+    //                *data << int32(Players[i].Pets[j].DisplayID);
+    //                *data << int32(Players[i].Pets[j].CollarID);
+    //                *data << int16(Players[i].Pets[j].Level);
+    //                *data << int16(Players[i].Pets[j].Xp);
+    //                *data << int32(Players[i].Pets[j].CurHealth);
+    //                *data << int32(Players[i].Pets[j].MaxHealth);
+    //                *data << int32(Players[i].Pets[j].Power);
+    //                *data << int32(Players[i].Pets[j].Speed);
+    //                *data << int32(Players[i].Pets[j].NpcTeamMemberID);
+    //                *data << uint16(Players[i].Pets[j].BreedQuality);
+    //                *data << uint16(Players[i].Pets[j].StatusFlags);
+    //                *data << int8(Players[i].Pets[j].Slot);
+
+    //                *data << uint32(Players[i].Pets[j].Abilities.size());
+    //                *data << uint32(Players[i].Pets[j].Auras.size());
+    //                *data << uint32(Players[i].Pets[j].States.size());
+    //                for (std::size_t k = 0; k < Players[i].Pets[j].Abilities.size(); ++k)
     //                {
-    //                    packet.ReadInt32("AbilityID", index, i, j, k);
-    //                    packet.ReadInt16("CooldownRemaining", index, i, j, k);
-    //                    packet.ReadInt16("LockdownRemaining", index, i, j, k);
-    //                    packet.ReadByte("AbilityIndex", index, i, j, k);
-    //                    packet.ReadByte("Pboid", index, i, j, k);
+    //                    *data << int32(Players[i].Pets[j].Abilities[k].AbilityID);
+    //                    *data << int16(Players[i].Pets[j].Abilities[k].CooldownRemaining);
+    //                    *data << int16(Players[i].Pets[j].Abilities[k].LockdownRemaining);
+    //                    *data << int8(Players[i].Pets[j].Abilities[k].AbilityIndex);
+    //                    *data << uint8(Players[i].Pets[j].Abilities[k].Pboid);
     //                }
 
-    //                for (var k = 0; k < PetBattleActiveAura; ++k)
+    //                for (std::size_t k = 0; k < Players[i].Pets[j].Auras.size(); ++k)
     //                {
-    //                    packet.ReadInt32("AbilityID", index, i, j, k);
-    //                    packet.ReadInt32("InstanceID", index, i, j, k);
-    //                    packet.ReadInt32("RoundsRemaining", index, i, j, k);
-    //                    packet.ReadInt32("CurrentRound", index, i, j, k);
-    //                    packet.ReadByte("CasterPBOID", index, i, j, k);
+    //                    *data << int32(Players[i].Pets[j].Auras[k].AbilityID);
+    //                    *data << uint32(Players[i].Pets[j].Auras[k].InstanceID);
+    //                    *data << int32(Players[i].Pets[j].Auras[k].RoundsRemaining);
+    //                    *data << int32(Players[i].Pets[j].Auras[k].CurrentRound);
+    //                    *data << uint8(Players[i].Pets[j].Auras[k].CasterPBOID);
     //                }
 
-    //                for (var k = 0; k < PetBattleActiveState; ++k)
+    //                for (std::size_t k = 0; k < Players[i].Pets[j].States.size(); ++k)
     //                {
-    //                    packet.ReadInt32("StateID", index, i, j, k);
-    //                    packet.ReadInt32("StateValue", index, i, j, k);
+    //                    *data << uint32(Players[i].Pets[j].States[k].StateID);
+    //                    *data << int32(Players[i].Pets[j].States[k].StateValue);
     //                }
 
-    //                packet.ResetBitReader();
-    //                var bits57 = packet.ReadBits(7);
-    //                packet.ReadWoWString("CustomName", bits57, index, i, j);
+    //                data->WriteBits(Players[i].Pets[j].CustomName.length(), 7);
+    //                data->WriteString(Players[i].Pets[j].CustomName);
     //            }
     //        }
 
-    //        for (var i = 0; i < 3; ++i)
+    //        for (std::size_t i = 0; i < 3; ++i)
     //        {
-    //            var PetBattleActiveAura = packet.ReadInt32("PetBattleActiveAura", index, i);
-    //            var PetBattleActiveState = packet.ReadInt32("PetBattleActiveState", index, i);
-
-    //            for (var j = 0; j < PetBattleActiveAura; ++j)
+    //            *data << uint32(Enviros[j].Auras.size());
+    //            *data << uint32(Enviros[j].States.size());
+    //            for (std::size_t j = 0; j < Enviros[j].Auras.size(); ++j)
     //            {
-    //                packet.ReadInt32("AbilityID", index, i, j);
-    //                packet.ReadInt32("InstanceID", index, i, j);
-    //                packet.ReadInt32("RoundsRemaining", index, i, j);
-    //                packet.ReadInt32("CurrentRound", index, i, j);
-    //                packet.ReadByte("CasterPBOID", index, i, j);
+    //                *data << int32(Enviros[j].Auras[j].AbilityID);
+    //                *data << uint32(Enviros[j].Auras[j].InstanceID);
+    //                *data << int32(Enviros[j].Auras[j].RoundsRemaining);
+    //                *data << int32(Enviros[j].Auras[j].CurrentRound);
+    //                *data << uint8(Enviros[j].Auras[j].CasterPBOID);
     //            }
 
-    //            for (var j = 0; j < PetBattleActiveState; ++j)
+    //            for (std::size_t j = 0; j < Enviros[j].States.size(); ++j)
     //            {
-    //                packet.ReadInt32("StateID", index, i, j);
-    //                packet.ReadInt32("StateValue", index, i, j);
+    //                *data << uint32(Enviros[i].States[j].StateID);
+    //                *data << int32(Enviros[i].States[j].StateValue);
     //            }
     //        }
 
-    //        packet.ReadInt16("WaitingForFrontPetsMaxSecs", index);
-    //        packet.ReadInt16("PvpMaxRoundTime", index);
-
-    //        packet.ReadInt32("CurRound", index);
-    //        packet.ReadInt32("NpcCreatureID", index);
-    //        packet.ReadInt32("NpcDisplayID", index);
-
-    //        packet.ReadByte("CurPetBattleState");
-    //        packet.ReadByte("ForfeitPenalty");
-
-    //        packet.ReadPackedGuid128("InitialWildPetGUID");
-
-    //        packet.ReadBit("IsPVP");
-    //        packet.ReadBit("CanAwardXP");
+    //        *data << uint16(WaitingForFrontPetsMaxSecs);
+    //        *data << uint16(PvpMaxRoundTime);
+    //        *data << int32(CurRound);
+    //        *data << uint32(NpcCreatureID);
+    //        *data << uint32(NpcDisplayID);
+    //        *data << int8(CurPetBattleState);
+    //        *data << uint8(ForfeitPenalty);
+    //        *data << ObjectGuid(InitialWildPetGUID);
+    //        data->WriteBit(IsPVP);
+    //        data->WriteBit(CanAwardXP);
     //    }
     //}
 
-    //if (ScenePendingInstances)
+    //if (PlayerCreateData)
     //{
-    //    var SceneInstanceIDs = packet.ReadInt32("SceneInstanceIDsCount");
-
-    //    for (var i = 0; i < SceneInstanceIDs; ++i)
-    //        packet.ReadInt32("SceneInstanceIDs", index, i);
+    //    data->WriteBit(HasSceneInstanceIDs);
+    //    data->WriteBit(HasRuneState);
+    //    if (HasSceneInstanceIDs)
+    //    {
+    //        *data << uint32(SceneInstanceIDs.size());
+    //        for (std::size_t i = 0; i < SceneInstanceIDs.size(); ++i)
+    //            *data << uint32(SceneInstanceIDs[i]);
+    //    }
+    //    if (HasRuneState)
+    //    {
+    //        *data << uint8(RechargingRuneMask);
+    //        *data << uint8(UsableRuneMask);
+    //        *data << uint32(ToUnit()->GetMaxPower(POWER_RUNES));
+    //        for (uint32 i = 0; i < ToUnit()->GetMaxPower(POWER_RUNES); ++i)
+    //            *data << uint8(255 - (ToUnit()->ToPlayer()->GetRuneCooldown(i) * 51));
+    //    }
     //}
-
-    if (GameObject const* go = ToGameObject())
-        for (uint32 i = 0; i < PauseTimesCount; ++i)
-            *data << uint32(go->GetGOValue()->Transport.StopFrames->at(i));
-
-    data->FlushBits();
 }
 
 void Object::BuildValuesUpdate(uint8 updateType, ByteBuffer* data, Player* target) const
@@ -806,7 +822,7 @@ void Object::BuildDynamicValuesUpdate(uint8 updateType, ByteBuffer* data, Player
                 }
             }
 
-            fieldBuffer << uint8(arrayMask.GetBlockCount());
+            fieldBuffer << uint16(arrayMask.GetBlockCount());
             arrayMask.AppendToPacket(&fieldBuffer);
             fieldBuffer.append(buffer);
         }
diff --git a/src/server/game/Entities/Object/Updates/UpdateData.cpp b/src/server/game/Entities/Object/Updates/UpdateData.cpp
index 2d5ffc85c50..0d9c4cd94af 100644
--- a/src/server/game/Entities/Object/Updates/UpdateData.cpp
+++ b/src/server/game/Entities/Object/Updates/UpdateData.cpp
@@ -50,7 +50,7 @@ bool UpdateData::BuildPacket(WorldPacket* packet)
 
     if (packet->WriteBit(!m_outOfRangeGUIDs.empty()))
     {
-        *packet << uint16(0);
+        *packet << uint16(0);   // object limit to instantly destroy - objects before this index on m_outOfRangeGUIDs list get "smoothly phased out"
         *packet << uint32(m_outOfRangeGUIDs.size());
 
         for (GuidSet::const_iterator i = m_outOfRangeGUIDs.begin(); i != m_outOfRangeGUIDs.end(); ++i)
diff --git a/src/server/game/Server/Packets/MovementPackets.cpp b/src/server/game/Server/Packets/MovementPackets.cpp
index 582a057e09f..0270526576b 100644
--- a/src/server/game/Server/Packets/MovementPackets.cpp
+++ b/src/server/game/Server/Packets/MovementPackets.cpp
@@ -47,7 +47,7 @@ ByteBuffer& operator<<(ByteBuffer& data, MovementInfo& movementInfo)
     }*/
 
     data.WriteBits(movementInfo.flags, 30);
-    data.WriteBits(movementInfo.flags2, 16);
+    data.WriteBits(movementInfo.flags2, 18);
 
     data.WriteBit(hasTransportData);
     data.WriteBit(hasFallData);
@@ -102,7 +102,7 @@ ByteBuffer& operator>>(ByteBuffer& data, MovementInfo& movementInfo)
     }
 
     movementInfo.flags = data.ReadBits(30);
-    movementInfo.flags2 = data.ReadBits(16);
+    movementInfo.flags2 = data.ReadBits(18);
 
     bool hasTransport = data.ReadBit();
     bool hasFall = data.ReadBit();
@@ -277,13 +277,20 @@ void WorldPackets::Movement::CommonMovement::WriteCreateObjectSplineDataBlock(::
     else
         data << G3D::Vector3::zero();
 
-    if (data.WriteBit(!moveSpline.Finalized()))                                 // MovementSplineMove
-    {
-        data.FlushBits();
+    data.WriteBit(!moveSpline.Finalized());
+    data.FlushBits();
 
+    if (!moveSpline.Finalized())                                                // MovementSplineMove
+    {
         ::Movement::MoveSplineFlag const& splineFlags = moveSpline.splineflags;
 
-        data.WriteBits(moveSpline.splineflags.raw(), 28);                       // SplineFlags
+        data << uint32(moveSpline.splineflags.raw());                           // SplineFlags
+        data << int32(moveSpline.timePassed());                                 // Elapsed
+        data << uint32(moveSpline.Duration());                                  // Duration
+        data << float(1.0f);                                                    // DurationModifier
+        data << float(1.0f);                                                    // NextDurationModifier
+        data << uint32(moveSpline.getPath().size());
+        data.append<G3D::Vector3>(&moveSpline.getPath()[0], moveSpline.getPath().size());
 
         uint8 face = ::Movement::MONSTER_MOVE_NORMAL;
         if (splineFlags.final_angle)
@@ -294,21 +301,25 @@ void WorldPackets::Movement::CommonMovement::WriteCreateObjectSplineDataBlock(::
             face = ::Movement::MONSTER_MOVE_FACING_SPOT;
 
         data.WriteBits(face, 2);                                                // Face
-
         bool HasJumpGravity = data.WriteBit(moveSpline.splineflags & (::Movement::MoveSplineFlag::Parabolic | ::Movement::MoveSplineFlag::Animation));                 // HasJumpGravity
         bool HasSpecialTime = data.WriteBit((moveSpline.splineflags & ::Movement::MoveSplineFlag::Parabolic) && moveSpline.effect_start_time < moveSpline.Duration()); // HasSpecialTime
-
         data.WriteBits(uint8(moveSpline.spline.mode()), 2);                     // Mode
+        data.WriteBit(0);                                                       // HasSplineFilter
+        data.WriteBit(0);                                                       // Unknown_1
+        data.FlushBits();
 
-        data.WriteBit(0);                                                       // HasSplineFilterKey
-
-        data << int32(moveSpline.timePassed());                                 // Elapsed
-        data << uint32(moveSpline.Duration());                                  // Duration
-        data << float(1.0f);                                                    // DurationModifier
-        data << float(1.0f);                                                    // NextDurationModifier
+        //if (HasSplineFilterKey)
+        //{
+        //    data << uint32(FilterKeysCount);
+        //    for (var i = 0; i < FilterKeysCount; ++i)
+        //    {
+        //        data << float(In);
+        //        data << float(Out);
+        //    }
 
-        uint32 PointsCount = moveSpline.getPath().size();
-        data << uint32(PointsCount);
+        //    data.WriteBits(FilterFlags, 2);
+        //    data.FlushBits();
+        //}
 
         switch (face)
         {
@@ -329,20 +340,16 @@ void WorldPackets::Movement::CommonMovement::WriteCreateObjectSplineDataBlock(::
         if (HasSpecialTime)
             data << uint32(moveSpline.effect_start_time);                       // SpecialTime
 
-        //if (HasSplineFilterKey)
+        //if (Unknown_1)
         //{
-        //    data << uint32(FilterKeysCount);
-        //    for (var i = 0; i < PointsCount; ++i)
-        //    {
-        //        data << float(In);
-        //        data << float(Out);
-        //    }
-
-        //    data.WriteBits(FilterFlags, 2);
+        //    data << ObjectGuid();
+        //    data << uint32();
+        //    data << uint32();
+        //    data << uint32();
         //}
-
-        data.append<G3D::Vector3>(&moveSpline.getPath()[0], PointsCount);            // Points
     }
+    else
+        data.FlushBits();
 }
 
 void WorldPackets::Movement::MonsterMove::InitializeSplineData(::Movement::MoveSpline const& moveSpline)
diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp
index aa0d8e363ae..2254dcdaf6a 100644
--- a/src/server/game/Server/Protocol/Opcodes.cpp
+++ b/src/server/game/Server/Protocol/Opcodes.cpp
@@ -1019,7 +1019,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_DAILY_QUESTS_RESET,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_DAMAGE_CALC_LOG,                         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_DANCE_STUDIO_CREATE_RESULT,              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_DB_REPLY,                                STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_DB_REPLY,                                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_DEATH_RELEASE_LOC,                       STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_DEFENSE_MESSAGE,                         STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_DELETE_CHAR,                             STATUS_NEVER,        CONNECTION_TYPE_REALM);
@@ -1475,7 +1475,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PVP_SEASON,                              STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_BATTLE_PET_NAME_RESPONSE,          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_CREATURE_RESPONSE,                 STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_GAME_OBJECT_RESPONSE,              STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_GAME_OBJECT_RESPONSE,              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_GARRISON_CREATURE_NAME_RESPONSE,   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_GUILD_INFO_RESPONSE,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_ITEM_TEXT_RESPONSE,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1694,7 +1694,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_UPDATE_EXPANSION_LEVEL,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_UPDATE_INSTANCE_OWNERSHIP,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_UPDATE_LAST_INSTANCE,                    STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_UPDATE_OBJECT,                           STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_UPDATE_OBJECT,                           STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_UPDATE_TALENT_DATA,                      STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_UPDATE_TASK_PROGRESS,                    STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_UPDATE_WEEKLY_SPELL_USAGE,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);