Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-23 02:25:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

Core/PacketIO: Updated SMSG_UPDATE_OBJECT

Browse Source
This commit is contained in:
Shauren
2016-06-01 20:14:16 +02:00
parent f682e155c8
commit cc03d7ca24
5 changed files with 234 additions and 211 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/server/game/Entities/Item/Item.cpp
View File

@@ -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);
}

374
src/server/game/Entities/Object/Object.cpp
View File

@@ -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);
// *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);
// packet.ReadVector3("RollPitchYaw1", index);
// if (HasAreaTriggerUnkType)
// {
// data->WriteBit(Unk_1);
// data->WriteBit(HasCenter);
// data->WriteBit(Unk_3);
// data->WriteBit(Unk_4);
// packet.ResetBitReader();
// *data << uint32();
// *data << int32();
// *data << uint32();
// *data << float(Radius);
// *data << float(BlendFromRadius);
// *data << float(InitialAngel);
// *data << float(ZOffset);
// 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);
// 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 (SmoothPhasing)
//{
// data->WriteBit(ReplaceActive);
// data->WriteBit(HasReplaceObjectt);
// if (HasReplaceObject)
// *data << ObjectGuid(ReplaceObject);
//}
//if (SceneObjCreate)
//{
// packet.ResetBitReader();
// data->WriteBit(HasLocalScriptData);
// data->WriteBit(HasPetBattleFullUpdate);
// var CliSceneLocalScriptData = packet.ReadBit("CliSceneLocalScriptData", index);
// var PetBattleFullUpdate = packet.ReadBit("PetBattleFullUpdate", index);
// 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);
// *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);
// 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->WriteBits(Players[i].Pets.size(), 2);
// for (std::size_t j = 0; j < Players[i].Pets.size(); ++j)
// {
// packet.ReadPackedGuid128("BattlePetGUID", index, i, j);
// *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);
// 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 << 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);
}

2
src/server/game/Entities/Object/Updates/UpdateData.cpp
View File

@@ -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)

61
src/server/game/Server/Packets/MovementPackets.cpp
View File

@@ -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
//if (HasSplineFilterKey)
//{
// data << uint32(FilterKeysCount);
// for (var i = 0; i < FilterKeysCount; ++i)
// {
// data << float(In);
// data << float(Out);
// }
data << int32(moveSpline.timePassed()); // Elapsed
data << uint32(moveSpline.Duration()); // Duration
data << float(1.0f); // DurationModifier
data << float(1.0f); // NextDurationModifier
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)

6
src/server/game/Server/Protocol/Opcodes.cpp
View File

@@ -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);