Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-19 00:48:56 +01:00
Code Issues Packages Projects Releases Wiki Activity

Core/Movement: converted collision height and move update opcodes back to movement structures and implement new movement status elements for future use

Browse Source
This commit is contained in:
Ovahlord
2020-05-10 19:21:33 +02:00
parent a2cea3ce08
commit d8ec67df50
8 changed files with 459 additions and 635 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/server/game/Entities/Player/Player.cpp
View File

@@ -27974,6 +27974,9 @@ void Player::ReadMovementInfo(WorldPacket& data, MovementInfo* mi, Movement::Ext
case MSEHasSpline:
data.ReadBit();
break;
case MSEHasHeightChangeFailed:
data.ReadBit();
break;
case MSEMovementFlags:
if (hasMovementFlags)
mi->flags = data.ReadBits(30);

368
src/server/game/Entities/Unit/Unit.cpp
View File

@@ -13732,187 +13732,193 @@ void Unit::WriteMovementInfo(WorldPacket& data, Movement::ExtraMovementStatusEle
switch (element)
{
case MSEHasGuidByte0:
case MSEHasGuidByte1:
case MSEHasGuidByte2:
case MSEHasGuidByte3:
case MSEHasGuidByte4:
case MSEHasGuidByte5:
case MSEHasGuidByte6:
case MSEHasGuidByte7:
data.WriteBit(guid[element - MSEHasGuidByte0]);
break;
case MSEHasTransportGuidByte0:
case MSEHasTransportGuidByte1:
case MSEHasTransportGuidByte2:
case MSEHasTransportGuidByte3:
case MSEHasTransportGuidByte4:
case MSEHasTransportGuidByte5:
case MSEHasTransportGuidByte6:
case MSEHasTransportGuidByte7:
if (hasTransportData)
data.WriteBit(tguid[element - MSEHasTransportGuidByte0]);
break;
case MSEGuidByte0:
case MSEGuidByte1:
case MSEGuidByte2:
case MSEGuidByte3:
case MSEGuidByte4:
case MSEGuidByte5:
case MSEGuidByte6:
case MSEGuidByte7:
data.WriteByteSeq(guid[element - MSEGuidByte0]);
break;
case MSETransportGuidByte0:
case MSETransportGuidByte1:
case MSETransportGuidByte2:
case MSETransportGuidByte3:
case MSETransportGuidByte4:
case MSETransportGuidByte5:
case MSETransportGuidByte6:
case MSETransportGuidByte7:
if (hasTransportData)
data.WriteByteSeq(tguid[element - MSETransportGuidByte0]);
break;
case MSEHasMovementFlags:
data.WriteBit(!hasMovementFlags);
break;
case MSEHasMovementFlags2:
data.WriteBit(!hasMovementFlags2);
break;
case MSEHasTimestamp:
data.WriteBit(!hasTimestamp);
break;
case MSEHasOrientation:
data.WriteBit(!hasOrientation);
break;
case MSEHasTransportData:
data.WriteBit(hasTransportData);
break;
case MSEHasTransportTime2:
if (hasTransportData)
data.WriteBit(hasTransportTime2);
break;
case MSEHasVehicleId:
if (hasTransportData)
data.WriteBit(hasTransportVehicleId);
break;
case MSEHasPitch:
data.WriteBit(!hasPitch);
break;
case MSEHasFallData:
data.WriteBit(hasFallData);
break;
case MSEHasFallDirection:
if (hasFallData)
data.WriteBit(hasFallDirection);
break;
case MSEHasSplineElevation:
data.WriteBit(!hasSplineElevation);
break;
case MSEHasSpline:
data.WriteBit(hasSpline);
break;
case MSEMovementFlags:
if (hasMovementFlags)
data.WriteBits(GetUnitMovementFlags(), 30);
break;
case MSEMovementFlags2:
if (hasMovementFlags2)
data.WriteBits(GetExtraUnitMovementFlags(), 12);
break;
case MSETimestamp:
if (hasTimestamp)
data << mi.time;
break;
case MSEPositionX:
data << GetPositionX();
break;
case MSEPositionY:
data << GetPositionY();
break;
case MSEPositionZ:
data << GetPositionZ();
break;
case MSEOrientation:
if (hasOrientation)
data << GetOrientation();
break;
case MSETransportPositionX:
if (hasTransportData)
data << GetTransOffsetX();
break;
case MSETransportPositionY:
if (hasTransportData)
data << GetTransOffsetY();
break;
case MSETransportPositionZ:
if (hasTransportData)
data << GetTransOffsetZ();
break;
case MSETransportOrientation:
if (hasTransportData)
data << GetTransOffsetO();
break;
case MSETransportSeat:
if (hasTransportData)
data << GetTransSeat();
break;
case MSETransportTime:
if (hasTransportData)
data << GetTransTime();
break;
case MSETransportTime2:
if (hasTransportData && hasTransportTime2)
data << mi.transport.time2;
break;
case MSETransportVehicleId:
if (hasTransportData && hasTransportVehicleId)
data << mi.transport.vehicleId;
break;
case MSEPitch:
if (hasPitch)
data << mi.pitch;
break;
case MSEFallTime:
if (hasFallData)
data << mi.jump.fallTime;
break;
case MSEFallVerticalSpeed:
if (hasFallData)
data << mi.jump.zspeed;
break;
case MSEFallCosAngle:
if (hasFallData && hasFallDirection)
data << mi.jump.cosAngle;
break;
case MSEFallSinAngle:
if (hasFallData && hasFallDirection)
data << mi.jump.sinAngle;
break;
case MSEFallHorizontalSpeed:
if (hasFallData && hasFallDirection)
data << mi.jump.xyspeed;
break;
case MSESplineElevation:
if (hasSplineElevation)
data << mi.splineElevation;
break;
case MSECounter:
data << m_movementCounter++;
break;
case MSEZeroBit:
data.WriteBit(0);
break;
case MSEOneBit:
data.WriteBit(1);
break;
case MSEExtraElement:
extras->WriteNextElement(data);
break;
default:
ASSERT(Movement::PrintInvalidSequenceElement(element, __FUNCTION__));
break;
case MSEHasGuidByte0:
case MSEHasGuidByte1:
case MSEHasGuidByte2:
case MSEHasGuidByte3:
case MSEHasGuidByte4:
case MSEHasGuidByte5:
case MSEHasGuidByte6:
case MSEHasGuidByte7:
data.WriteBit(guid[element - MSEHasGuidByte0]);
break;
case MSEHasTransportGuidByte0:
case MSEHasTransportGuidByte1:
case MSEHasTransportGuidByte2:
case MSEHasTransportGuidByte3:
case MSEHasTransportGuidByte4:
case MSEHasTransportGuidByte5:
case MSEHasTransportGuidByte6:
case MSEHasTransportGuidByte7:
if (hasTransportData)
data.WriteBit(tguid[element - MSEHasTransportGuidByte0]);
break;
case MSEGuidByte0:
case MSEGuidByte1:
case MSEGuidByte2:
case MSEGuidByte3:
case MSEGuidByte4:
case MSEGuidByte5:
case MSEGuidByte6:
case MSEGuidByte7:
data.WriteByteSeq(guid[element - MSEGuidByte0]);
break;
case MSETransportGuidByte0:
case MSETransportGuidByte1:
case MSETransportGuidByte2:
case MSETransportGuidByte3:
case MSETransportGuidByte4:
case MSETransportGuidByte5:
case MSETransportGuidByte6:
case MSETransportGuidByte7:
if (hasTransportData)
data.WriteByteSeq(tguid[element - MSETransportGuidByte0]);
break;
case MSEHasMovementFlags:
data.WriteBit(!hasMovementFlags);
break;
case MSEHasMovementFlags2:
data.WriteBit(!hasMovementFlags2);
break;
case MSEHasTimestamp:
data.WriteBit(!hasTimestamp);
break;
case MSEHasOrientation:
data.WriteBit(!hasOrientation);
break;
case MSEHasTransportData:
data.WriteBit(hasTransportData);
break;
case MSEHasTransportTime2:
if (hasTransportData)
data.WriteBit(hasTransportTime2);
break;
case MSEHasVehicleId:
if (hasTransportData)
data.WriteBit(hasTransportVehicleId);
break;
case MSEHasPitch:
data.WriteBit(!hasPitch);
break;
case MSEHasFallData:
data.WriteBit(hasFallData);
break;
case MSEHasFallDirection:
if (hasFallData)
data.WriteBit(hasFallDirection);
break;
case MSEHasSplineElevation:
data.WriteBit(!hasSplineElevation);
break;
case MSEHasSpline:
data.WriteBit(hasSpline);
break;
case MSEHasHeightChangeFailed:
data.WriteBit(mi.HasHeightChangeFailed());
break;
case MSEMovementFlags:
if (hasMovementFlags)
data.WriteBits(GetUnitMovementFlags(), 30);
break;
case MSEMovementFlags2:
if (hasMovementFlags2)
data.WriteBits(GetExtraUnitMovementFlags(), 12);
break;
case MSETimestamp:
if (hasTimestamp)
data << mi.time;
break;
case MSEPositionX:
data << GetPositionX();
break;
case MSEPositionY:
data << GetPositionY();
break;
case MSEPositionZ:
data << GetPositionZ();
break;
case MSEOrientation:
if (hasOrientation)
data << GetOrientation();
break;
case MSETransportPositionX:
if (hasTransportData)
data << GetTransOffsetX();
break;
case MSETransportPositionY:
if (hasTransportData)
data << GetTransOffsetY();
break;
case MSETransportPositionZ:
if (hasTransportData)
data << GetTransOffsetZ();
break;
case MSETransportOrientation:
if (hasTransportData)
data << GetTransOffsetO();
break;
case MSETransportSeat:
if (hasTransportData)
data << GetTransSeat();
break;
case MSETransportTime:
if (hasTransportData)
data << GetTransTime();
break;
case MSETransportTime2:
if (hasTransportData && hasTransportTime2)
data << mi.transport.time2;
break;
case MSETransportVehicleId:
if (hasTransportData && hasTransportVehicleId)
data << mi.transport.vehicleId;
break;
case MSEPitch:
if (hasPitch)
data << mi.pitch;
break;
case MSEFallTime:
if (hasFallData)
data << mi.jump.fallTime;
break;
case MSEFallVerticalSpeed:
if (hasFallData)
data << mi.jump.zspeed;
break;
case MSEFallCosAngle:
if (hasFallData && hasFallDirection)
data << mi.jump.cosAngle;
break;
case MSEFallSinAngle:
if (hasFallData && hasFallDirection)
data << mi.jump.sinAngle;
break;
case MSEFallHorizontalSpeed:
if (hasFallData && hasFallDirection)
data << mi.jump.xyspeed;
break;
case MSESplineElevation:
if (hasSplineElevation)
data << mi.splineElevation;
break;
case MSECounter:
data << m_movementCounter++;
break;
case MSEZeroBit:
data.WriteBit(0);
break;
case MSEOneBit:
data.WriteBit(1);
break;
case MSEFlushBits:
data.FlushBits();
break;
case MSEExtraElement:
extras->WriteNextElement(data);
break;
default:
ASSERT(Movement::PrintInvalidSequenceElement(element, __FUNCTION__));
break;
}
}
}

53
src/server/game/Handlers/MovementHandler.cpp
View File

@@ -303,8 +303,16 @@ void WorldSession::HandleMoveTeleportAck(WorldPacket& recvPacket)
void WorldSession::HandleMovementOpcodes(WorldPacket& recvPacket)
{
/* extract packet */
MovementInfo movementInfo;
GetPlayer()->ReadMovementInfo(recvPacket, &movementInfo);
uint16 opcode = recvPacket.GetOpcode();
HandleMovementOpcode(opcode, movementInfo);
}
void WorldSession::HandleMovementOpcode(uint16 opcode, MovementInfo& movementInfo)
{
Unit* mover = _player->m_unitMovedByMe;
// there must always be a mover
@@ -315,14 +323,9 @@ void WorldSession::HandleMovementOpcodes(WorldPacket& recvPacket)
// ignore, waiting processing in WorldSession::HandleMoveWorldportAckOpcode and WorldSession::HandleMoveTeleportAck
if (plrMover && plrMover->IsBeingTeleported())
{
recvPacket.rfinish(); // prevent warnings spam
return;
}
/* extract packet */
MovementInfo movementInfo;
GetPlayer()->ReadMovementInfo(recvPacket, &movementInfo);
GetPlayer()->ValidateMovementInfo(&movementInfo);
// prevent tampered movement data
if (movementInfo.guid != mover->GetGUID())
@@ -340,33 +343,21 @@ void WorldSession::HandleMovementOpcodes(WorldPacket& recvPacket)
if (plrMover && (plrMover->GetUInt32Value(UNIT_NPC_EMOTESTATE) != 0))
plrMover->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_ONESHOT_NONE);
if (plrMover && opcode == MSG_MOVE_JUMP)
plrMover->ProcSkillsAndAuras(nullptr, PROC_FLAG_JUMP, PROC_FLAG_NONE, PROC_SPELL_TYPE_MASK_ALL, PROC_SPELL_PHASE_NONE, PROC_HIT_NONE, nullptr, nullptr, nullptr);
/* handle special cases */
if (movementInfo.transport.guid)
if (!movementInfo.transport.guid.IsEmpty())
{
// We were teleported, skip packets that were broadcast before teleport
if (movementInfo.pos.GetExactDist2d(mover) > SIZE_OF_GRIDS)
{
recvPacket.rfinish(); // prevent warnings spam
return;
}
// transports size limited
// (also received at zeppelin leave by some reason with t_* as absolute in continent coordinates, can be safely skipped)
if (fabs(movementInfo.transport.pos.GetPositionX()) > 75.0f || fabs(movementInfo.transport.pos.GetPositionY()) > 75.0f || fabs(movementInfo.transport.pos.GetPositionZ()) > 75.0f)
{
recvPacket.rfinish(); // prevent warnings spam
return;
}
if (!Trinity::IsValidMapCoord(movementInfo.pos.GetPositionX() + movementInfo.transport.pos.GetPositionX(), movementInfo.pos.GetPositionY() + movementInfo.transport.pos.GetPositionY(),
movementInfo.pos.GetPositionZ() + movementInfo.transport.pos.GetPositionZ(), movementInfo.pos.GetOrientation() + movementInfo.transport.pos.GetOrientation()))
{
recvPacket.rfinish(); // prevent warnings spam
return;
}
// if we boarded a transport, add us to it
if (plrMover)
@@ -440,9 +431,9 @@ void WorldSession::HandleMovementOpcodes(WorldPacket& recvPacket)
mover->UpdatePosition(movementInfo.pos);
WorldPackets::Movement::MoveUpdate moveUpdate;
moveUpdate.Status = &mover->m_movementInfo;
mover->SendMessageToSet(moveUpdate.Write(), _player);
WorldPacket data(SMSG_MOVE_UPDATE);
mover->WriteMovementInfo(data);
mover->SendMessageToSet(&data, _player);
if (plrMover) // nothing is charmed, or player charmed
{
@@ -470,6 +461,12 @@ void WorldSession::HandleMovementOpcodes(WorldPacket& recvPacket)
}
}
}
if (opcode == MSG_MOVE_JUMP)
{
plrMover->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_JUMP, 605); // Mind Control
plrMover->ProcSkillsAndAuras(nullptr, PROC_FLAG_JUMP, PROC_FLAG_NONE, PROC_SPELL_TYPE_MASK_ALL, PROC_SPELL_PHASE_NONE, PROC_HIT_NONE, nullptr, nullptr, nullptr);
}
}
}
@@ -682,14 +679,14 @@ void WorldSession::HandleSummonResponseOpcode(WorldPacket& recvData)
_player->SummonIfPossible(agree);
}
void WorldSession::HandleSetCollisionHeightAck(WorldPackets::Movement::MoveSetCollisionHeightAck& packet)
void WorldSession::HandleSetCollisionHeightAck(WorldPacket& recvData)
{
_player->ValidateMovementInfo(&packet.Data.Status);
MovementInfo movementInfo;
static MovementStatusElements const heightElement = MSEExtraFloat;
Movement::ExtraMovementStatusElement extras(&heightElement);
GetPlayer()->ReadMovementInfo(recvData, &movementInfo, &extras);
WorldPackets::Movement::MoveUpdateCollisionHeight updateCollisionHeight;
updateCollisionHeight.Height = packet.Height;
updateCollisionHeight.Status = &_player->m_movementInfo;
_player->SendMessageToSet(updateCollisionHeight.Write(), false);
Movement::PacketSender(_player, NULL_OPCODE, NULL_OPCODE, SMSG_MOVE_UPDATE_COLLISION_HEIGHT, &extras).Send();
}
void WorldSession::HandleMoveTimeSkippedOpcode(WorldPacket& recvData)

271
src/server/game/Movement/MovementStructures.cpp
View File

@@ -15,11 +15,83 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "MovementPackets.h"
#include "MovementStructures.h"
#include "Log.h"
#include "Player.h"
MovementStatusElements const MovementUpdate[] =
{
MSEHasFallData,
MSEHasGuidByte3,
MSEHasGuidByte6,
MSEHasMovementFlags2,
MSEHasSpline,
MSEHasTimestamp,
MSEHasGuidByte0,
MSEHasGuidByte1,
MSEMovementFlags2,
MSEHasGuidByte7,
MSEHasMovementFlags,
MSEHasOrientation,
MSEHasGuidByte2,
MSEHasSplineElevation,
MSEHasHeightChangeFailed,
MSEHasGuidByte4,
MSEHasFallDirection,
MSEHasGuidByte5,
MSEHasTransportData,
MSEMovementFlags,
MSEHasTransportGuidByte3,
MSEHasVehicleId,
MSEHasTransportGuidByte6,
MSEHasTransportGuidByte1,
MSEHasTransportGuidByte7,
MSEHasTransportGuidByte0,
MSEHasTransportGuidByte4,
MSEHasTransportTime2,
MSEHasTransportGuidByte5,
MSEHasTransportGuidByte2,
MSEHasPitch,
MSEFlushBits,
MSEGuidByte5,
MSEFallHorizontalSpeed,
MSEFallSinAngle,
MSEFallCosAngle,
MSEFallVerticalSpeed,
MSEFallTime,
MSESplineElevation,
MSEGuidByte7,
MSEPositionY,
MSEGuidByte3,
MSETransportVehicleId,
MSETransportGuidByte6,
MSETransportSeat,
MSETransportGuidByte5,
MSETransportPositionX,
MSETransportGuidByte1,
MSETransportOrientation,
MSETransportGuidByte2,
MSETransportTime2,
MSETransportGuidByte0,
MSETransportPositionZ,
MSETransportGuidByte7,
MSETransportGuidByte4,
MSETransportGuidByte3,
MSETransportPositionY,
MSETransportTime,
MSEGuidByte4,
MSEPositionX,
MSEGuidByte6,
MSEPositionZ,
MSETimestamp,
MSEGuidByte2,
MSEPitch,
MSEGuidByte0,
MSEOrientation,
MSEGuidByte1,
MSEEnd
};
MovementStatusElements const MovementFallLand[] =
{
MSEPositionX,
@@ -1919,7 +1991,6 @@ MovementStatusElements const MoveUpdateTeleport[] =
MSEPositionY,
MSEPositionX,
MSEHasOrientation,
MSEHasSpline,
MSEHasMovementFlags,
MSEHasGuidByte2,
@@ -1929,7 +2000,6 @@ MovementStatusElements const MoveUpdateTeleport[] =
MSEHasGuidByte0,
MSEHasTransportData,
MSEHasGuidByte5,
MSEHasTransportGuidByte1,
MSEHasTransportGuidByte4,
MSEHasTransportGuidByte5,
@@ -1940,21 +2010,18 @@ MovementStatusElements const MoveUpdateTeleport[] =
MSEHasTransportGuidByte6,
MSEHasVehicleId,
MSEHasTransportGuidByte2,
MSEZeroBit,
MSEHasGuidByte7,
MSEHasGuidByte3,
MSEHasPitch,
MSEHasMovementFlags2,
MSEHasTimestamp,
MSEHasFallDirection,
MSEMovementFlags2,
MSEHasSplineElevation,
MSEMovementFlags,
MSEHasGuidByte1,
MSEFlushBits,
MSEGuidByte7,
MSETransportGuidByte3,
MSETransportGuidByte4,
@@ -1972,7 +2039,6 @@ MovementStatusElements const MoveUpdateTeleport[] =
MSETransportTime,
MSETransportPositionY,
MSETransportPositionX,
MSEGuidByte6,
MSEPitch,
MSESplineElevation,
@@ -1980,19 +2046,16 @@ MovementStatusElements const MoveUpdateTeleport[] =
MSEGuidByte2,
MSEGuidByte3,
MSEGuidByte1,
MSEFallTime,
MSEFallHorizontalSpeed,
MSEFallCosAngle,
MSEFallSinAngle,
MSEFallVerticalSpeed,
MSEGuidByte5,
MSEGuidByte4,
MSETimestamp,
MSEGuidByte0,
MSEEnd,
MSEEnd
};
MovementStatusElements const MovementSetRunMode[] =
@@ -2317,6 +2380,7 @@ MovementStatusElements const MovementUpdateSwimSpeed[] =
MSEHasPitch,
MSEMovementFlags2,
MSEHasGuidByte1,
MSEFlushBits,
MSETransportGuidByte2,
MSETransportPositionX,
MSETransportVehicleId,
@@ -2394,6 +2458,7 @@ MovementStatusElements const MovementUpdateRunSpeed[] =
MSEHasFallDirection,
MSEHasGuidByte4,
MSEZeroBit,
MSEFlushBits,
MSETransportGuidByte4,
MSETransportGuidByte5,
MSETransportPositionX,
@@ -2467,6 +2532,7 @@ MovementStatusElements const MovementUpdateFlightSpeed[] =
MSEMovementFlags2,
MSEHasFallDirection,
MSEHasGuidByte0,
MSEFlushBits,
MSESplineElevation,
MSEPitch,
MSEGuidByte0,
@@ -2503,6 +2569,80 @@ MovementStatusElements const MovementUpdateFlightSpeed[] =
MSEEnd
};
MovementStatusElements const MovementUpdateCollisionHeight[] =
{
MSEPositionZ,
MSEExtraElement,
MSEPositionX,
MSEPositionY,
MSEHasGuidByte6,
MSEHasGuidByte7,
MSEHasSplineElevation,
MSEHasTransportData,
MSEHasTransportGuidByte6,
MSEHasTransportGuidByte4,
MSEHasTransportGuidByte3,
MSEHasTransportGuidByte7,
MSEHasTransportGuidByte5,
MSEHasVehicleId,
MSEHasTransportGuidByte1,
MSEHasTransportGuidByte0,
MSEHasTransportGuidByte2,
MSEHasTransportTime2,
MSEHasGuidByte3,
MSEHasOrientation,
MSEHasGuidByte4,
MSEHasGuidByte5,
MSEHasTimestamp,
MSEHasFallData,
MSEHasGuidByte0,
MSEHasPitch,
MSEHasHeightChangeFailed,
MSEHasGuidByte2,
MSEHasMovementFlags,
MSEHasFallDirection,
MSEHasGuidByte1,
MSEHasMovementFlags2,
MSEHasSpline,
MSEMovementFlags2,
MSEMovementFlags,
MSEFlushBits,
MSEGuidByte3,
MSETransportGuidByte7,
MSETransportTime,
MSETransportGuidByte4,
MSETransportVehicleId,
MSETransportTime2,
MSETransportGuidByte5,
MSETransportOrientation,
MSETransportPositionX,
MSETransportGuidByte6,
MSETransportGuidByte0,
MSETransportPositionY,
MSETransportGuidByte2,
MSETransportPositionZ,
MSETransportGuidByte3,
MSETransportGuidByte1,
MSETransportSeat,
MSEPitch,
MSEGuidByte6,
MSEFallCosAngle,
MSEFallSinAngle,
MSEFallHorizontalSpeed,
MSEFallVerticalSpeed,
MSEFallTime,
MSEGuidByte7,
MSEOrientation,
MSEGuidByte0,
MSEGuidByte5,
MSEGuidByte4,
MSESplineElevation,
MSETimestamp,
MSEGuidByte2,
MSEGuidByte1,
MSEEnd,
};
MovementStatusElements const MovementForceRunSpeedChangeAck[] =
{
MSECounter,
@@ -2577,6 +2717,82 @@ MovementStatusElements const MovementForceRunSpeedChangeAck[] =
MSEEnd,
};
MovementStatusElements const MovementSetCollisionHeightAck[] =
{
MSEExtraElement,
MSEPositionX,
MSEPositionZ,
MSECounter,
MSEPositionY,
MSEHasGuidByte6,
MSEHasGuidByte4,
MSEZeroBit, // Reason bit 1
MSEZeroBit, // Reason bit 2
MSEHasPitch,
MSEHasGuidByte5,
MSEHasHeightChangeFailed,
MSEHasGuidByte2,
MSEHasGuidByte1,
MSEHasFallData,
MSEHasGuidByte3,
MSEHasSpline,
MSEHasGuidByte7,
MSEHasMovementFlags,
MSEHasTransportData,
MSEHasTimestamp,
MSEHasSplineElevation,
MSEHasMovementFlags2,
MSEHasOrientation,
MSEHasGuidByte0,
MSEHasTransportGuidByte4,
MSEHasTransportGuidByte3,
MSEHasTransportTime2,
MSEHasVehicleId,
MSEHasTransportGuidByte5,
MSEHasTransportGuidByte1,
MSEHasTransportGuidByte7,
MSEHasTransportGuidByte2,
MSEHasTransportGuidByte6,
MSEHasTransportGuidByte0,
MSEMovementFlags2,
MSEMovementFlags,
MSEHasFallDirection,
MSEGuidByte0,
MSEGuidByte3,
MSEGuidByte1,
MSEGuidByte5,
MSEGuidByte7,
MSEGuidByte6,
MSEGuidByte2,
MSEGuidByte4,
MSETransportPositionX,
MSETransportGuidByte4,
MSETransportTime2,
MSETransportGuidByte0,
MSETransportOrientation,
MSETransportPositionY,
MSETransportGuidByte7,
MSETransportSeat,
MSETransportGuidByte5,
MSETransportGuidByte2,
MSETransportTime,
MSETransportGuidByte6,
MSETransportGuidByte3,
MSETransportGuidByte1,
MSETransportVehicleId,
MSETransportPositionZ,
MSEFallVerticalSpeed,
MSEFallTime,
MSEFallCosAngle,
MSEFallSinAngle,
MSEFallHorizontalSpeed,
MSETimestamp,
MSESplineElevation,
MSEOrientation,
MSEPitch,
MSEEnd,
};
MovementStatusElements const MovementForceFlightSpeedChangeAck[] =
{
MSECounter,
@@ -3135,6 +3351,7 @@ MovementStatusElements const MovementUpdateRunBackSpeed[] =
MSEHasTransportGuidByte4,
MSEHasTransportGuidByte0,
MSEHasGuidByte7,
MSEFlushBits,
MSETransportPositionX,
MSETransportGuidByte2,
MSETransportGuidByte5,
@@ -3195,6 +3412,7 @@ MovementStatusElements const MovementUpdateWalkSpeed[] =
MSEHasFallDirection,
MSEMovementFlags,
MSEHasGuidByte4,
MSEFlushBits,
MSEPitch,
MSETransportGuidByte6,
MSETransportGuidByte0,
@@ -3385,7 +3603,6 @@ MovementStatusElements MoveUpdateSwimBackSpeed[] =
MSEHasGuidByte2,
MSEHasTransportData,
MSEHasGuidByte1,
MSEHasTransportGuidByte2,
MSEHasTransportGuidByte1,
MSEHasTransportGuidByte0,
@@ -3396,7 +3613,6 @@ MovementStatusElements MoveUpdateSwimBackSpeed[] =
MSEHasTransportTime2,
MSEHasTransportGuidByte5,
MSEHasVehicleId,
MSEHasPitch,
MSEHasOrientation,
MSEZeroBit,
@@ -3408,21 +3624,16 @@ MovementStatusElements MoveUpdateSwimBackSpeed[] =
MSEHasMovementFlags,
MSEHasGuidByte0,
MSEHasFallData,
MSEHasFallDirection,
MSEMovementFlags,
MSEHasTimestamp,
MSEHasSplineElevation,
MSEHasMovementFlags2,
MSEMovementFlags2,
MSEFlushBits,
MSEGuidByte0,
MSEGuidByte4,
MSEPositionY,
MSETransportGuidByte7,
MSETransportVehicleId,
MSETransportGuidByte6,
@@ -3439,13 +3650,11 @@ MovementStatusElements MoveUpdateSwimBackSpeed[] =
MSETransportTime2,
MSETransportPositionY,
MSETransportSeat,
MSEFallSinAngle,
MSEFallCosAngle,
MSEFallHorizontalSpeed,
MSEFallVerticalSpeed,
MSEFallTime,
MSEPitch,
MSEGuidByte2,
MSEGuidByte7,
@@ -3459,7 +3668,7 @@ MovementStatusElements MoveUpdateSwimBackSpeed[] =
MSEOrientation,
MSEGuidByte6,
MSEGuidByte1,
MSEEnd,
MSEEnd
};
MovementStatusElements const MovementFallReset[] =
@@ -3995,6 +4204,7 @@ MovementStatusElements const MovementUpdateKnockBack[] =
MSEMovementFlags,
MSEHasFallDirection,
MSEHasOrientation,
MSEFlushBits,
MSEOrientation,
MSEFallSinAngle,
MSEFallHorizontalSpeed,
@@ -5234,6 +5444,7 @@ MovementStatusElements const MoveUpdateFlightBackSpeed[] =
MSEHasFallData,
MSEHasOrientation,
MSEHasFallDirection,
MSEFlushBits,
MSEFallCosAngle,
MSEFallSinAngle,
MSEFallVerticalSpeed,
@@ -5425,14 +5636,6 @@ void Movement::PacketSender::Send() const
if (_broadcast != NULL_OPCODE)
{
if (_broadcast == SMSG_MOVE_UPDATE)
{
WorldPackets::Movement::MoveUpdate moveUpdate;
moveUpdate.Status = &_unit->m_movementInfo;
_unit->SendMessageToSet(moveUpdate.Write(), !isPlayerMovement);
return;
}
///! Need to reset current extra element index before writing another packet
if (_extraElements)
_extraElements->ResetIndex();
@@ -5537,12 +5740,18 @@ MovementStatusElements const* GetMovementStatusElementsSequence(uint32 opcode)
return MovementSetCanFlyAck;
case CMSG_MOVE_SET_CAN_TRANSITION_BETWEEN_SWIM_AND_FLY_ACK:
return MovementSetCanTransitionBetweenSwimAndFlyAck;
case CMSG_MOVE_SET_COLLISION_HEIGHT_ACK:
return MovementSetCollisionHeightAck;
case SMSG_MOVE_UPDATE_COLLISION_HEIGHT:
return MovementUpdateCollisionHeight;
case CMSG_MOVE_WATER_WALK_ACK:
return MovementWaterWalkAck;
case MSG_MOVE_SET_RUN_MODE:
return MovementSetRunMode;
case MSG_MOVE_SET_WALK_MODE:
return MovementSetWalkMode;
case SMSG_MOVE_UPDATE:
return MovementUpdate;
case SMSG_MOVE_UPDATE_FLIGHT_SPEED:
return MovementUpdateFlightSpeed;
case SMSG_MOVE_UPDATE_RUN_SPEED:

2
src/server/game/Movement/MovementStructures.h
View File

@@ -54,6 +54,7 @@ enum MovementStatusElements
MSEHasFallDirection,
MSEHasSplineElevation,
MSEHasSpline,
MSEHasHeightChangeFailed,
MSEGuidByte0,
MSEGuidByte1,
@@ -99,6 +100,7 @@ enum MovementStatusElements
// Special
MSEZeroBit, // writes bit value 1 or skips read bit
MSEOneBit, // writes bit value 0 or skips read bit
MSEFlushBits, // flushes bits
MSEEnd, // marks end of parsing
MSEExtraElement, // Used to signalize reading into ExtraMovementStatusElement, element sequence inside it is declared as separate array
// Allowed internal elements are: GUID markers (not transport), MSEExtraFloat, MSEExtraInt8

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

@@ -22,245 +22,6 @@
#include "PacketUtilities.h"
#include "Unit.h"
WorldPacket const* WorldPackets::Movement::MoveUpdate::Write()
{
ObjectGuid guid = Status->guid;
ObjectGuid transportGuid = Status->transport.guid;
_worldPacket.WriteBit(Status->HasFallData());
_worldPacket.WriteBit(guid[3]);
_worldPacket.WriteBit(guid[6]);
_worldPacket.WriteBit(!Status->HasExtraMovementFlags());
_worldPacket.WriteBit(Status->HasSpline());
_worldPacket.WriteBit(!Status->HasTime());
_worldPacket.WriteBit(guid[0]);
_worldPacket.WriteBit(guid[1]);
if (Status->HasExtraMovementFlags())
_worldPacket.WriteBits(Status->GetExtraMovementFlags(), 12);
_worldPacket.WriteBit(guid[7]);
_worldPacket.WriteBit(!Status->HasMovementFlags());
_worldPacket.WriteBit(!Status->HasOrientation());
_worldPacket.WriteBit(guid[2]);
_worldPacket.WriteBit(!Status->HasSplineElevation());
_worldPacket.WriteBit(Status->HasHeightChangeFailed());
_worldPacket.WriteBit(guid[4]);
if (Status->HasFallData())
_worldPacket.WriteBit(Status->HasFallDirection());
_worldPacket.WriteBit(guid[5]);
_worldPacket.WriteBit(Status->HasTransportData());
if (Status->HasMovementFlags())
_worldPacket.WriteBits(Status->GetMovementFlags(), 30);
if (Status->HasTransportData())
{
_worldPacket.WriteBit(transportGuid[3]);
_worldPacket.WriteBit(Status->HasTransportVehicleId());
_worldPacket.WriteBit(transportGuid[6]);
_worldPacket.WriteBit(transportGuid[1]);
_worldPacket.WriteBit(transportGuid[7]);
_worldPacket.WriteBit(transportGuid[0]);
_worldPacket.WriteBit(transportGuid[4]);
_worldPacket.WriteBit(Status->HasTransportTime2());
_worldPacket.WriteBit(transportGuid[5]);
_worldPacket.WriteBit(transportGuid[2]);
}
_worldPacket.WriteBit(!Status->HasPitch());
_worldPacket.FlushBits();
_worldPacket.WriteByteSeq(guid[5]);
if (Status->HasFallData())
{
if (Status->HasFallDirection())
{
_worldPacket << float(Status->jump.xyspeed);
_worldPacket << float(Status->jump.sinAngle);
_worldPacket << float(Status->jump.cosAngle);
}
_worldPacket << float(Status->jump.zspeed);
_worldPacket << uint32(Status->jump.fallTime);
}
if (Status->HasSplineElevation())
_worldPacket << float(Status->splineElevation);
_worldPacket.WriteByteSeq(guid[7]);
_worldPacket << float(Status->pos.GetPositionY());
_worldPacket.WriteByteSeq(guid[3]);
if (Status->HasTransportData())
{
if (Status->HasTransportVehicleId())
_worldPacket << uint32(Status->transport.vehicleId);
_worldPacket.WriteByteSeq(transportGuid[6]);
_worldPacket << int8(Status->transport.seat);
_worldPacket.WriteByteSeq(transportGuid[5]);
_worldPacket << float(Status->transport.pos.GetPositionX());
_worldPacket.WriteByteSeq(transportGuid[1]);
_worldPacket << float(Status->transport.pos.GetOrientation());
_worldPacket.WriteByteSeq(transportGuid[2]);
if (Status->HasTransportTime2())
_worldPacket << uint32(Status->transport.time2);
_worldPacket.WriteByteSeq(transportGuid[0]);
_worldPacket << float(Status->transport.pos.GetPositionZ());
_worldPacket.WriteByteSeq(transportGuid[7]);
_worldPacket.WriteByteSeq(transportGuid[4]);
_worldPacket.WriteByteSeq(transportGuid[3]);
_worldPacket << float(Status->transport.pos.GetPositionY());
_worldPacket << uint32(Status->transport.time);
}
_worldPacket.WriteByteSeq(guid[4]);
_worldPacket << float(Status->pos.GetPositionX());
_worldPacket.WriteByteSeq(guid[6]);
_worldPacket << float(Status->pos.GetPositionZ());
if (Status->HasTime())
_worldPacket << uint32(Status->time);
_worldPacket.WriteByteSeq(guid[2]);
if (Status->HasPitch())
_worldPacket << float(Status->pitch);
_worldPacket.WriteByteSeq(guid[0]);
if (Status->HasOrientation())
_worldPacket << float(Status->pos.GetOrientation());
_worldPacket.WriteByteSeq(guid[1]);
return &_worldPacket;
}
void WorldPackets::Movement::MoveSetCollisionHeightAck::Read()
{
_worldPacket >> Height;
_worldPacket >> Data.Status.pos.m_positionX;
_worldPacket >> Data.Status.pos.m_positionZ;
_worldPacket >> Data.AckIndex;
_worldPacket >> Data.Status.pos.m_positionY;
Data.Status.guid[6] = _worldPacket.ReadBit();
Data.Status.guid[4] = _worldPacket.ReadBit();
Reason = UpdateCollisionHeightReason(_worldPacket.ReadBits(2));
bool hasPitch = !_worldPacket.ReadBit();
Data.Status.guid[5] = _worldPacket.ReadBit();
_worldPacket.ReadBit(); // HeightChangeFailed
Data.Status.guid[2] = _worldPacket.ReadBit();
Data.Status.guid[1] = _worldPacket.ReadBit();
bool hasFallData = _worldPacket.ReadBit();
Data.Status.guid[3] = _worldPacket.ReadBit();
_worldPacket.ReadBit(); // HasSpline
Data.Status.guid[7] = _worldPacket.ReadBit();
bool hasMovementFlags = !_worldPacket.ReadBit();
bool hasTransportData = _worldPacket.ReadBit();
bool hasTime = !_worldPacket.ReadBit();
bool hasSplineElevation = !_worldPacket.ReadBit();
bool hasExtraMovementFlags = !_worldPacket.ReadBit();
bool hasOrientation = !_worldPacket.ReadBit();
Data.Status.guid[0] = _worldPacket.ReadBit();
bool hasTransportTime2 = false;
bool hasVehicleId = false;
if (hasTransportData)
{
Data.Status.transport.guid[4] = _worldPacket.ReadBit();
Data.Status.transport.guid[3] = _worldPacket.ReadBit();
hasTransportTime2 = _worldPacket.ReadBit();
hasVehicleId = _worldPacket.ReadBit();
Data.Status.transport.guid[5] = _worldPacket.ReadBit();
Data.Status.transport.guid[1] = _worldPacket.ReadBit();
Data.Status.transport.guid[7] = _worldPacket.ReadBit();
Data.Status.transport.guid[2] = _worldPacket.ReadBit();
Data.Status.transport.guid[6] = _worldPacket.ReadBit();
Data.Status.transport.guid[0] = _worldPacket.ReadBit();
}
if (hasExtraMovementFlags)
Data.Status.flags2 = _worldPacket.ReadBits(12);
if (hasMovementFlags)
Data.Status.flags = _worldPacket.ReadBits(30);
bool hasFallDirection = false;
if (hasFallData)
hasFallDirection = _worldPacket.ReadBit();
_worldPacket.ReadByteSeq(Data.Status.guid[0]);
_worldPacket.ReadByteSeq(Data.Status.guid[3]);
_worldPacket.ReadByteSeq(Data.Status.guid[1]);
_worldPacket.ReadByteSeq(Data.Status.guid[5]);
_worldPacket.ReadByteSeq(Data.Status.guid[7]);
_worldPacket.ReadByteSeq(Data.Status.guid[6]);
_worldPacket.ReadByteSeq(Data.Status.guid[2]);
_worldPacket.ReadByteSeq(Data.Status.guid[4]);
if (hasTransportData)
{
_worldPacket >> Data.Status.transport.pos.m_positionX;
_worldPacket.ReadByteSeq(Data.Status.transport.guid[4]);
if (hasTransportTime2)
_worldPacket >> Data.Status.transport.time2;
_worldPacket.ReadByteSeq(Data.Status.transport.guid[0]);
float o = 0.f;
_worldPacket >> o;
Data.Status.transport.pos.SetOrientation(o);
_worldPacket >> Data.Status.transport.pos.m_positionY;
_worldPacket.ReadByteSeq(Data.Status.transport.guid[7]);
_worldPacket >> Data.Status.transport.seat;
_worldPacket.ReadByteSeq(Data.Status.transport.guid[5]);
_worldPacket.ReadByteSeq(Data.Status.transport.guid[2]);
_worldPacket >> Data.Status.transport.time;
_worldPacket.ReadByteSeq(Data.Status.transport.guid[6]);
_worldPacket.ReadByteSeq(Data.Status.transport.guid[3]);
_worldPacket.ReadByteSeq(Data.Status.transport.guid[1]);
if (hasVehicleId)
_worldPacket >> Data.Status.transport.vehicleId;
_worldPacket >> Data.Status.transport.pos.m_positionZ;
}
if (hasFallData)
{
_worldPacket >> Data.Status.jump.zspeed;
_worldPacket >> Data.Status.jump.fallTime;
if (hasFallDirection)
{
_worldPacket >> Data.Status.jump.cosAngle;
_worldPacket >> Data.Status.jump.sinAngle;
_worldPacket >> Data.Status.jump.xyspeed;
}
}
if (hasTime)
_worldPacket >> Data.Status.time;
if (hasSplineElevation)
_worldPacket >> Data.Status.splineElevation;
if (hasOrientation)
{
float o = 0.f;
_worldPacket >> o;
Data.Status.pos.SetOrientation(o);
}
if (hasPitch)
_worldPacket >> Data.Status.pitch;
}
WorldPacket const* WorldPackets::Movement::TransferPending::Write()
{
_worldPacket.WriteBit(TransferSpellID.is_initialized());
@@ -335,125 +96,6 @@ WorldPacket const* WorldPackets::Movement::MoveSetCollisionHeight::Write()
return &_worldPacket;
}
WorldPacket const* WorldPackets::Movement::MoveUpdateCollisionHeight::Write()
{
_worldPacket << float(Status->pos.GetPositionZ());
_worldPacket << float(Height);
_worldPacket << float(Status->pos.GetPositionX());
_worldPacket << float(Status->pos.GetPositionY());
_worldPacket.WriteBit(Status->guid[6]);
_worldPacket.WriteBit(Status->guid[7]);
_worldPacket.WriteBit(!Status->HasSplineElevation());
_worldPacket.WriteBit(Status->HasTransportData());
if (Status->HasTransportData())
{
_worldPacket.WriteBit(Status->transport.guid[6]);
_worldPacket.WriteBit(Status->transport.guid[4]);
_worldPacket.WriteBit(Status->transport.guid[3]);
_worldPacket.WriteBit(Status->transport.guid[7]);
_worldPacket.WriteBit(Status->transport.guid[5]);
_worldPacket.WriteBit(Status->HasTransportVehicleId());
_worldPacket.WriteBit(Status->transport.guid[1]);
_worldPacket.WriteBit(Status->transport.guid[0]);
_worldPacket.WriteBit(Status->transport.guid[2]);
_worldPacket.WriteBit(Status->HasTransportTime2());
}
_worldPacket.WriteBit(Status->guid[3]);
_worldPacket.WriteBit(!Status->HasOrientation());
_worldPacket.WriteBit(Status->guid[4]);
_worldPacket.WriteBit(Status->guid[5]);
_worldPacket.WriteBit(!Status->HasTime());
_worldPacket.WriteBit(Status->HasFallData());
_worldPacket.WriteBit(Status->guid[0]);
_worldPacket.WriteBit(!Status->HasPitch());
_worldPacket.WriteBit(Status->HasHeightChangeFailed());
_worldPacket.WriteBit(Status->guid[2]);
_worldPacket.WriteBit(!Status->HasMovementFlags());
if (Status->HasFallData())
_worldPacket.WriteBit(Status->HasFallDirection());
_worldPacket.WriteBit(Status->guid[1]);
_worldPacket.WriteBit(!Status->HasExtraMovementFlags());
_worldPacket.WriteBit(Status->HasSpline());
if (Status->HasExtraMovementFlags())
_worldPacket.WriteBits(Status->GetExtraMovementFlags(), 12);
if (Status->HasMovementFlags())
_worldPacket.WriteBits(Status->GetMovementFlags(), 30);
_worldPacket.FlushBits();
_worldPacket.WriteByteSeq(Status->guid[3]);
if (Status->HasTransportData())
{
_worldPacket.WriteByteSeq(Status->transport.guid[7]);
_worldPacket << uint32(Status->transport.time);
_worldPacket.WriteByteSeq(Status->transport.guid[4]);
if (Status->HasTransportVehicleId())
_worldPacket << uint32(Status->transport.vehicleId);
if (Status->HasTransportTime2())
_worldPacket << uint32(Status->transport.time2);
_worldPacket.WriteByteSeq(Status->transport.guid[5]);
_worldPacket << float(Status->transport.pos.GetOrientation());
_worldPacket << float(Status->transport.pos.GetPositionX());
_worldPacket.WriteByteSeq(Status->transport.guid[6]);
_worldPacket.WriteByteSeq(Status->transport.guid[0]);
_worldPacket << float(Status->transport.pos.GetPositionY());
_worldPacket.WriteByteSeq(Status->transport.guid[2]);
_worldPacket << float(Status->transport.pos.GetPositionZ());
_worldPacket.WriteByteSeq(Status->transport.guid[3]);
_worldPacket.WriteByteSeq(Status->transport.guid[1]);
_worldPacket << int8(Status->transport.seat);
}
if (Status->HasPitch())
_worldPacket << float(Status->pitch);
_worldPacket.WriteByteSeq(Status->guid[6]);
if (Status->HasFallData())
{
if (Status->HasFallDirection())
{
_worldPacket << float(Status->jump.cosAngle);
_worldPacket << float(Status->jump.sinAngle);
_worldPacket << float(Status->jump.xyspeed);
}
_worldPacket << float(Status->jump.zspeed);
_worldPacket << uint32(Status->jump.fallTime);
}
_worldPacket.WriteByteSeq(Status->guid[7]);
if (Status->HasOrientation())
_worldPacket << float(Status->pos.GetOrientation());
_worldPacket.WriteByteSeq(Status->guid[0]);
_worldPacket.WriteByteSeq(Status->guid[5]);
_worldPacket.WriteByteSeq(Status->guid[4]);
if (Status->HasSplineElevation())
_worldPacket << float(Status->splineElevation);
if (Status->HasTime())
_worldPacket << uint32(Status->time);
_worldPacket.WriteByteSeq(Status->guid[2]);
_worldPacket.WriteByteSeq(Status->guid[1]);
return &_worldPacket;
}
WorldPacket const* WorldPackets::Movement::MoveKnockBack::Write()
{
_worldPacket.WriteBit(MoverGUID[0]);

35
src/server/game/Server/Packets/MovementPackets.h
View File

@@ -32,30 +32,6 @@ namespace WorldPackets
int32 AckIndex = 0;
};
class TC_GAME_API MoveUpdate final : public ServerPacket
{
public:
MoveUpdate() : ServerPacket(SMSG_MOVE_UPDATE) { }
WorldPacket const* Write() override;
MovementInfo* Status = nullptr;
};
class MoveSetCollisionHeightAck final : public ClientPacket
{
public:
MoveSetCollisionHeightAck(WorldPacket&& packet) : ClientPacket(CMSG_MOVE_SET_COLLISION_HEIGHT_ACK, std::move(packet)) { }
void Read() override;
MovementAck Data;
UpdateCollisionHeightReason Reason = UPDATE_COLLISION_HEIGHT_MOUNT;
float Height = 1.0f;
};
class TransferPending final : public ServerPacket
{
struct ShipTransferPending
@@ -119,17 +95,6 @@ namespace WorldPackets
UpdateCollisionHeightReason Reason = UPDATE_COLLISION_HEIGHT_MOUNT;
};
class MoveUpdateCollisionHeight final : public ServerPacket
{
public:
MoveUpdateCollisionHeight() : ServerPacket(SMSG_MOVE_UPDATE_COLLISION_HEIGHT) { }
WorldPacket const* Write() override;
MovementInfo* Status = nullptr;
float Height = 1.0f;
};
struct MoveKnockBackSpeeds
{
float HorzSpeed = 0.0f;

4
src/server/game/Server/WorldSession.h
View File

@@ -143,7 +143,6 @@ namespace WorldPackets
namespace Movement
{
class MoveSetCollisionHeightAck;
class SuspendTokenResponse;
}
@@ -652,7 +651,7 @@ class TC_GAME_API WorldSession
void HandleGravityAckMessage(WorldPacket & recvData);
void HandleMoveTeleportAck(WorldPacket& recvPacket);
void HandleForceSpeedChangeAck(WorldPacket& recvData);
void HandleSetCollisionHeightAck(WorldPackets::Movement::MoveSetCollisionHeightAck& packet);
void HandleSetCollisionHeightAck(WorldPacket& recvData);
void HandlePingOpcode(WorldPacket& recvPacket);
void HandleRepopRequestOpcode(WorldPacket& recvPacket);
@@ -721,6 +720,7 @@ class TC_GAME_API WorldSession
void HandleSuspendTokenResponse(WorldPackets::Movement::SuspendTokenResponse& suspendTokenResponse);
void HandleMovementOpcodes(WorldPacket& recvPacket);
void HandleMovementOpcode(uint16 opcode, MovementInfo& movementInfo);
void HandleSetActiveMoverOpcode(WorldPacket& recvData);
void HandleMoveNotActiveMover(WorldPacket& recvData);
void HandleDismissControlledVehicle(WorldPacket& recvData);