1
0

Packets now parse themselves from a cByteBuffer object (1st part of packeting rewrite, http://forum.mc-server.org/showthread.php?tid=524 )

git-svn-id: http://mc-server.googlecode.com/svn/trunk@744 0a769ca7-a7f5-676a-18bf-c427514a06d6
This commit is contained in:
madmaxoft@gmail.com 2012-08-17 10:18:07 +00:00
parent 33ca4d5003
commit 70a4ca5bc1
57 changed files with 684 additions and 352 deletions

View File

@ -285,6 +285,14 @@
RelativePath="..\source\BlockID.h"
>
</File>
<File
RelativePath="..\source\ByteBuffer.cpp"
>
</File>
<File
RelativePath="..\source\ByteBuffer.h"
>
</File>
<File
RelativePath="..\source\cAuthenticator.cpp"
>

324
source/ByteBuffer.cpp Normal file
View File

@ -0,0 +1,324 @@
// ByteBuffer.cpp
// Implements the cByteBuffer class representing a ringbuffer of bytes
#include "Globals.h"
#include "ByteBuffer.h"
#include "Endianness.h"
#define NEEDBYTES(Num) if (!CanReadBytes(Num)) return false;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// cByteBuffer:
cByteBuffer::cByteBuffer(int a_BufferSize) :
m_Buffer(new char[a_BufferSize + 1]),
m_BufferSize(a_BufferSize + 1),
m_DataStart(0),
m_WritePos(0),
m_ReadPos(0)
{
// Allocating one byte more than the buffer size requested, so that we can distinguish between
// completely-full and completely-empty states
}
cByteBuffer::~cByteBuffer()
{
delete m_Buffer;
}
bool cByteBuffer::Write(const char * a_Bytes, int a_Count)
{
if (GetFreeSpace() < a_Count)
{
return false;
}
int TillEnd = m_BufferSize - m_WritePos;
if (TillEnd < a_Count)
{
// Need to wrap around the ringbuffer end
memcpy(m_Buffer + m_WritePos, a_Bytes, TillEnd);
m_WritePos = 0;
a_Bytes += TillEnd;
a_Count -= TillEnd;
}
// We're guaranteed that we'll fit in a single write op
memcpy(m_Buffer + m_WritePos, a_Bytes, a_Count);
m_WritePos += a_Count;
return true;
}
int cByteBuffer::GetFreeSpace(void) const
{
if (m_WritePos >= m_DataStart)
{
// Wrap around the buffer end:
return m_BufferSize - m_WritePos + m_DataStart - 1;
}
// Single free space partition:
return m_DataStart - m_WritePos - 1;
}
/// Returns the number of bytes that are currently in the ringbuffer. Note GetReadableBytes()
int cByteBuffer::GetUsedSpace(void) const
{
return m_BufferSize - GetFreeSpace();
}
/// Returns the number of bytes that are currently available for reading (may be less than UsedSpace due to some data having been read already)
int cByteBuffer::GetReadableSpace(void) const
{
if (m_ReadPos > m_WritePos)
{
// Wrap around the buffer end:
return m_BufferSize - m_ReadPos + m_WritePos;
}
// Single readable space partition:
return m_WritePos - m_ReadPos ;
}
bool cByteBuffer::CanReadBytes(int a_Count) const
{
return (a_Count <= GetReadableSpace());
}
bool cByteBuffer::ReadChar(char & a_Value)
{
NEEDBYTES(1);
a_Value = m_Buffer[m_ReadPos++];
return true;
}
bool cByteBuffer::ReadByte(unsigned char & a_Value)
{
NEEDBYTES(1);
a_Value = (unsigned char)(m_Buffer[m_ReadPos++]);
return true;
}
bool cByteBuffer::ReadBEShort(short & a_Value)
{
NEEDBYTES(2);
ReadBuf(&a_Value, 2);
a_Value = ntohs(a_Value);
return true;
}
bool cByteBuffer::ReadBEInt(int & a_Value)
{
NEEDBYTES(4);
ReadBuf(&a_Value, 4);
a_Value = ntohl(a_Value);
return true;
}
bool cByteBuffer::ReadBEInt64(Int64 & a_Value)
{
NEEDBYTES(8);
ReadBuf(&a_Value, 8);
a_Value = NetworkToHostLong8(&a_Value);
return true;
}
bool cByteBuffer::ReadBEFloat(float & a_Value)
{
NEEDBYTES(4);
ReadBuf(&a_Value, 4);
a_Value = NetworkToHostFloat4(&a_Value);
return true;
}
bool cByteBuffer::ReadBEDouble(double & a_Value)
{
NEEDBYTES(8);
ReadBuf(&a_Value, 8);
a_Value = NetworkToHostDouble8(&a_Value);
return true;
}
bool cByteBuffer::ReadBool(bool & a_Value)
{
NEEDBYTES(1);
a_Value = (m_Buffer[m_ReadPos++] != 0);
return true;
}
bool cByteBuffer::ReadBEUTF16String16(AString & a_Value)
{
short Length;
if (!ReadBEShort(Length))
{
return false;
}
return ReadUTF16String(a_Value, Length);
}
bool cByteBuffer::ReadBuf(void * a_Buffer, int a_Count)
{
NEEDBYTES(a_Count);
char * Dst = (char *)a_Buffer; // So that we can do byte math
int BytesToEndOfBuffer = m_BufferSize - m_ReadPos;
if (BytesToEndOfBuffer < a_Count)
{
// Reading across the ringbuffer end, read the first part and adjust parameters:
memcpy(Dst, m_Buffer + m_ReadPos, BytesToEndOfBuffer);
Dst += BytesToEndOfBuffer;
a_Count -= BytesToEndOfBuffer;
m_ReadPos = 0;
}
// Read the rest of the bytes in a single read (guaranteed to fit):
memcpy(Dst, m_Buffer + m_ReadPos, a_Count);
m_ReadPos += a_Count;
return true;
}
bool cByteBuffer::ReadString(AString & a_String, int a_Count)
{
NEEDBYTES(a_Count);
a_String.clear();
a_String.reserve(a_Count);
int BytesToEndOfBuffer = m_BufferSize - m_ReadPos;
if (BytesToEndOfBuffer < a_Count)
{
// Reading across the ringbuffer end, read the first part and adjust parameters:
a_String.assign(m_Buffer + m_ReadPos, BytesToEndOfBuffer);
a_Count -= BytesToEndOfBuffer;
m_ReadPos = 0;
}
// Read the rest of the bytes in a single read (guaranteed to fit):
a_String.append(m_Buffer + m_ReadPos, a_Count);
m_ReadPos += a_Count;
return true;
}
bool cByteBuffer::ReadUTF16String(AString & a_String, int a_NumChars)
{
// Reads 2 * a_NumChars bytes and interprets it as a UTF16 string, converting it into UTF8 string a_String
AString RawData;
if (!ReadString(RawData, a_NumChars * 2))
{
return false;
}
RawBEToUTF8((short *)(RawData.data()), a_NumChars, a_String);
return true;
}
void cByteBuffer::CommitRead(void)
{
m_DataStart = m_ReadPos;
}
void cByteBuffer::ResetRead(void)
{
m_ReadPos = m_DataStart;
}
void cByteBuffer::AdvanceReadPos(int a_Count)
{
m_ReadPos += a_Count;
if (m_ReadPos > m_BufferSize)
{
m_ReadPos -= m_BufferSize;
}
}

90
source/ByteBuffer.h Normal file
View File

@ -0,0 +1,90 @@
// ByteStream.h
// Interfaces to the cByteBuffer class representing a ringbuffer of bytes
#pragma once
/** An object that can store incoming bytes and lets its clients read the bytes sequentially
The bytes are stored in a ringbuffer of constant size; if more than that size
is requested, the write operation fails.
The bytes stored can be retrieved using various ReadXXX functions; these assume that the needed
number of bytes are present in the buffer (ASSERT; for performance reasons).
The reading doesn't actually remove the bytes, it only moves the internal read ptr.
To remove the bytes, call CommitRead().
To re-start reading from the beginning, call ResetRead().
This class doesn't implement thread safety, the clients of this class need to provide
their own synchronization.
*/
class cByteBuffer
{
public:
cByteBuffer(int a_BufferSize);
~cByteBuffer();
/// Writes the bytes specified to the ringbuffer. Returns true if successful, false if not
bool Write(const char * a_Bytes, int a_Count);
/// Returns the number of bytes that can be successfully written to the ringbuffer
int GetFreeSpace(void) const;
/// Returns the number of bytes that are currently in the ringbuffer. Note GetReadableBytes()
int GetUsedSpace(void) const;
/// Returns the number of bytes that are currently available for reading (may be less than UsedSpace due to some data having been read already)
int GetReadableSpace(void) const;
/// Returns true if the specified amount of bytes are available for reading
bool CanReadBytes(int a_Count) const;
// Read the specified datatype and advance the read pointer; return true if successfully read:
bool ReadChar (char & a_Value);
bool ReadByte (unsigned char & a_Value);
bool ReadBEShort (short & a_Value);
bool ReadBEInt (int & a_Value);
bool ReadBEInt64 (Int64 & a_Value);
bool ReadBEFloat (float & a_Value);
bool ReadBEDouble (double & a_Value);
bool ReadBool (bool & a_Value);
bool ReadBEUTF16String16(AString & a_Value);
/// Reads a_Count bytes into a_Buffer; return true if successful
bool ReadBuf(void * a_Buffer, int a_Count);
/// Reads a_Count bytes into a_String; return true if successful
bool ReadString(AString & a_String, int a_Count);
/// Reads 2 * a_NumChars bytes and interprets it as a UTF16 string, converting it into UTF8 string a_String
bool ReadUTF16String(AString & a_String, int a_NumChars);
/// Skips reading by a_Count bytes
void SkipRead(int a_Count);
/// Removes the bytes that have been read from the ringbuffer
void CommitRead(void);
/// Restarts next reading operation at the start of the ringbuffer
void ResetRead(void);
protected:
char * m_Buffer;
int m_BufferSize; // Total size of the ringbuffer
int m_DataStart; // Where the data starts in the ringbuffer
int m_WritePos; // Where the data ends in the ringbuffer
int m_ReadPos; // Where the next read will start in the ringbuffer
/// Advances the m_ReadPos by a_Count bytes
void AdvanceReadPos(int a_Count);
} ;

View File

@ -95,6 +95,11 @@ typedef short Int16;
// Windows SDK defines min and max macros, messing up with our std::min and std::max usage
#undef min
#undef max
// Windows SDK defines GetFreeSpace as a constant, probably a Win16 API remnant
#ifdef GetFreeSpace
#undef GetFreeSpace
#endif // GetFreeSpace
#else
#include <sys/types.h>
#include <sys/stat.h> // for mkdir

View File

@ -233,3 +233,49 @@ AStringList GetDirectoryContents(const char * a_Directory)
// Converts a stream of BE shorts into UTF-8 string; returns a ref to a_UTF8
AString & RawBEToUTF8(short * a_RawData, int a_NumShorts, AString & a_UTF8)
{
a_UTF8.clear();
a_UTF8.reserve(3 * a_NumShorts / 2); // a quick guess of the resulting size
for (int i = 0; i < a_NumShorts; i++)
{
int c = ntohs(*(a_RawData + i));
if (c < 0x80)
{
a_UTF8.push_back((char)c);
}
else if (c < 0x800)
{
a_UTF8.push_back((char)(192 + c / 64));
a_UTF8.push_back((char)(128 + c % 64));
}
else if (c - 0xd800u < 0x800)
{
// Error, silently drop
}
else if (c < 0x10000)
{
a_UTF8.push_back((char)(224 + c / 4096));
a_UTF8.push_back((char)(128 + c / 64 % 64));
a_UTF8.push_back((char)(128 + c % 64));
}
else if (c < 0x110000)
{
a_UTF8.push_back((char)(240 + c / 262144));
a_UTF8.push_back((char)(128 + c / 4096 % 64));
a_UTF8.push_back((char)(128 + c / 64 % 64));
a_UTF8.push_back((char)(128 + c % 64));
}
else
{
// Error, silently drop
}
}
return a_UTF8;
}

View File

@ -48,6 +48,9 @@ extern void ReplaceString(AString & iHayStack, const AString & iNeedle, const AS
/// Returns the list of all items in the specified directory (files, folders, nix pipes, whatever's there)
extern AStringList GetDirectoryContents(const char * a_Directory);
/// Converts a stream of BE shorts into UTF-8 string; returns a ref to a_UTF8
extern AString & RawBEToUTF8(short * a_RawData, int a_NumShorts, AString & a_UTF8);
// If you have any other string helper functions, declare them here

View File

@ -112,6 +112,7 @@ int cClientHandle::s_ClientCount = 0;
cClientHandle::cClientHandle(const cSocket & a_Socket, int a_ViewDistance)
: m_ViewDistance(a_ViewDistance)
, m_ProtocolVersion(MCS_PROTOCOL_VERSION)
, m_ReceivedData(64 KiB)
, m_Socket(a_Socket)
, m_bDestroyed(false)
, m_Player(NULL)
@ -1357,6 +1358,16 @@ void cClientHandle::Send(const cPacket & a_Packet, ENUM_PRIORITY a_Priority /* =
void cClientHandle::SendDisconnect(const AString & a_Reason)
{
cPacket_Disconnect DC(a_Reason);
m_Socket.Send(&DC);
}
void cClientHandle::CheckIfWorldDownloaded(void)
{
if (m_State != csDownloadingWorld)
@ -1453,32 +1464,43 @@ void cClientHandle::AddWantedChunk(int a_ChunkX, int a_ChunkZ)
void cClientHandle::DataReceived(const char * a_Data, int a_Size)
{
// Data is received from the client
m_ReceivedData.append(a_Data, a_Size);
if (!m_ReceivedData.Write(a_Data, a_Size))
{
// Too much data in the incoming queue, the server is probably too busy, kick the client:
LOGERROR("Too much data in queue for client \"%s\" @ %s, kicking them.", m_Username.c_str(), m_Socket.GetIPString().c_str());
SendDisconnect("Server busy");
// TODO: QueueDestroy();
cSleep::MilliSleep(1000); // Give packet some time to be received
Destroy();
return;
}
// Parse and handle all complete packets in m_ReceivedData:
while (!m_ReceivedData.empty())
while (m_ReceivedData.CanReadBytes(1))
{
cPacket* pPacket = m_PacketMap[(unsigned char)m_ReceivedData[0]];
unsigned char PacketType;
m_ReceivedData.ReadByte(PacketType);
cPacket* pPacket = m_PacketMap[PacketType];
if (pPacket == NULL)
{
LOGERROR("Unknown packet type 0x%02x from client \"%s\"", (unsigned char)m_ReceivedData[0], m_Username.c_str());
LOGERROR("Unknown packet type 0x%02x from client \"%s\" @ %s", PacketType, m_Username.c_str(), m_Socket.GetIPString().c_str());
AString Reason;
Printf(Reason, "[C->S] Unknown PacketID: 0x%02x", (unsigned char)m_ReceivedData[0]);
cPacket_Disconnect DC(Reason);
m_Socket.Send(&DC);
Printf(Reason, "[C->S] Unknown PacketID: 0x%02x", PacketType);
SendDisconnect(Reason);
// TODO: QueueDestroy();
cSleep::MilliSleep(1000); // Give packet some time to be received
Destroy();
return;
}
int NumBytes = pPacket->Parse(m_ReceivedData.data() + 1, m_ReceivedData.size() - 1);
int NumBytes = pPacket->Parse(m_ReceivedData);
if (NumBytes == PACKET_ERROR)
{
LOGERROR("Protocol error while parsing packet type 0x%02x; disconnecting client \"%s\"", (unsigned char)m_ReceivedData[0], m_Username.c_str());
cPacket_Disconnect DC("Protocol error");
m_Socket.Send(&DC);
LOGERROR("Protocol error while parsing packet type 0x%02x; disconnecting client \"%s\"", PacketType, m_Username.c_str());
SendDisconnect("Protocol error");
// TODO: QueueDestroy();
cSleep::MilliSleep(1000); // Give packet some time to be received
Destroy();
return;
@ -1486,6 +1508,7 @@ void cClientHandle::DataReceived(const char * a_Data, int a_Size)
else if (NumBytes == PACKET_INCOMPLETE)
{
// Not a complete packet
m_ReceivedData.ResetRead();
break;
}
else
@ -1493,10 +1516,9 @@ void cClientHandle::DataReceived(const char * a_Data, int a_Size)
// Packet parsed successfully, add it to internal queue:
HandlePacket(pPacket);
// Erase the packet from the buffer:
ASSERT(m_ReceivedData.size() > (size_t)NumBytes);
m_ReceivedData.erase(0, NumBytes + 1);
m_ReceivedData.CommitRead();
}
} // while (!Received.empty())
} // while (!Received.CanReadBytes(1))
}

View File

@ -39,6 +39,7 @@
#include "packets/cPacket_WindowClose.h"
#include "packets/cPacket_UpdateSign.h"
#include "packets/cPacket_Ping.h"
#include "ByteBuffer.h"
@ -100,6 +101,8 @@ public:
bool IsPlaying(void) const {return (m_State == csPlaying); }
void Send(const cPacket & a_Packet, ENUM_PRIORITY a_Priority = E_PRIORITY_NORMAL);
void SendDisconnect(const AString & a_Reason);
const AString & GetUsername(void) const; //tolua_export
@ -122,11 +125,11 @@ private:
static const int GENERATEDISTANCE = 2; // Server generates this many chunks AHEAD of player sight. 2 is the minimum, since foliage is generated 1 step behind chunk terrain generation
int m_ProtocolVersion;
int m_ProtocolVersion;
AString m_Username;
AString m_Password;
AString m_ReceivedData; // Accumulator for the data received from the socket, waiting to be parsed; accessed from the cSocketThreads' thread only!
cByteBuffer m_ReceivedData; // Accumulator for the data received from the socket, waiting to be parsed; accessed from the cSocketThreads' thread only!
cCriticalSection m_CSPackets;
PacketList m_PendingNrmSendPackets;

View File

@ -28,160 +28,6 @@
int cPacket::ReadString16(const char * a_Data, int a_Size, AString & a_OutString )
{
int TotalBytes = 0;
short StrLen;
HANDLE_PACKET_READ(ReadShort, StrLen, TotalBytes);
if (2 * StrLen > a_Size - TotalBytes)
{
// The string is not yet complete in the buffer
return PACKET_INCOMPLETE;
}
// Simple UTF-16 to UTF-8 conversion - discard higher bits, ignore multishort sequences:
a_OutString.clear();
a_OutString.reserve(StrLen);
short * UTF16 = (short *)(a_Data + TotalBytes);
for ( int i = 0; i < StrLen; ++i )
{
a_OutString.push_back( (char)ntohs(UTF16[i]) );
}
return TotalBytes + StrLen * sizeof(short);
}
int cPacket::ReadShort(const char * a_Data, int a_Size, short & a_OutShort )
{
if (a_Size < 2)
{
return PACKET_INCOMPLETE;
}
a_OutShort = ntohs(*((short *)a_Data));
return 2;
}
int cPacket::ReadInteger(const char * a_Data, int a_Size, int & a_OutInteger )
{
if (a_Size < 4)
{
return PACKET_INCOMPLETE;
}
a_OutInteger = ntohl(*((int *)a_Data));
return 4;
}
int cPacket::ReadInteger(const char * a_Data, int a_Size, unsigned int & a_OutInteger )
{
if (a_Size < 4)
{
return PACKET_INCOMPLETE;
}
a_OutInteger = ntohl(*((unsigned int *)a_Data));
return 4;
}
int cPacket::ReadFloat(const char * a_Data, int a_Size, float & a_OutFloat )
{
if (a_Size < sizeof(float))
{
return PACKET_INCOMPLETE;
}
a_OutFloat = NetworkToHostFloat4(a_Data);
return sizeof(float);
}
int cPacket::ReadDouble(const char * a_Data, int a_Size, double & a_OutDouble )
{
if (a_Size < sizeof(double))
{
return PACKET_INCOMPLETE;
}
a_OutDouble = NetworkToHostDouble8(a_Data);
return sizeof(double);
}
int cPacket::ReadByte(const char * a_Data, int a_Size, char & a_OutByte )
{
if (a_Size < 1)
{
return PACKET_INCOMPLETE;
}
a_OutByte = *a_Data;
return 1;
}
int cPacket::ReadByte(const char * a_Data, int a_Size, unsigned char & a_OutByte )
{
if (a_Size < 1)
{
return PACKET_INCOMPLETE;
}
a_OutByte = *((unsigned char *)a_Data);
return 1;
}
int cPacket::ReadLong(const char * a_Data, int a_Size, long long & a_OutLong )
{
if (a_Size < sizeof(a_OutLong))
{
return PACKET_INCOMPLETE;
}
a_OutLong = NetworkToHostLong8(a_Data);
return sizeof(a_OutLong);
}
int cPacket::ReadBool(const char * a_Data, int a_Size, bool & a_OutBool )
{
if (a_Size < sizeof(bool))
{
return PACKET_INCOMPLETE;
}
a_OutBool = (*a_Data != 0);
return sizeof(bool);
}
void cPacket::AppendString(AString & a_Dst, const AString & a_String)
{
AppendShort(a_Dst, (unsigned short)a_String.size());

View File

@ -3,6 +3,7 @@
#include "../cSocket.h"
#include "../PacketID.h"
#include "../ByteBuffer.h"
@ -10,6 +11,7 @@
#define PACKET_INCOMPLETE -2
#define PACKET_ERROR -1
#define PACKET_OK 1
@ -18,12 +20,11 @@
// Use this macro to simplify handling several ReadXXX in a row. It assumes that you want [a_Data, a_Size] parsed (which is true for all Parse() functions)
#define HANDLE_PACKET_READ(Proc, Var, TotalBytes) \
{ \
int res = Proc(a_Data + TotalBytes, a_Size - TotalBytes, Var); \
if (res < 0) \
if (!a_Buffer.Proc(Var)) \
{ \
return res; \
return PACKET_INCOMPLETE; \
} \
TotalBytes += res; \
TotalBytes = PACKET_OK; \
}
@ -38,22 +39,23 @@ public:
{}
virtual ~cPacket() {}
/// Called to parse the packet. Packet type has already been read and the correct packet type created. Return the number of characters processed, PACKET_INCOMPLETE for incomplete data, PACKET_ERROR for error
virtual int Parse(const char * a_Data, int a_Size)
/// Called to parse the packet. Packet type has already been read and the correct packet type created. Return PACKET_INCOMPLETE for incomplete data, PACKET_ERROR for error, any positive number for success
virtual int Parse(cByteBuffer & a_Buffer)
{
UNUSED(a_Data);
UNUSED(a_Size);
LOGERROR("Undefined Parse function for packet type 0x%x\n", m_PacketID );
ASSERT(!"Undefined Parse function");
return -1;
// There are packets that are sent S->C only, those don't have a parsing function
UNUSED(a_Buffer);
LOGERROR("Packet type 0x%02x has no parser defined!", m_PacketID);
ASSERT(!"Unparsed packet type!");
return PACKET_ERROR;
}
/// Called to serialize the packet into a string. Append all packet data to a_Data, including the packet type!
virtual void Serialize(AString & a_Data) const
{
// There are packets that are sent C->S only, those don't have a serializing function
UNUSED(a_Data);
LOGERROR("Undefined Serialize function for packet type 0x%x\n", m_PacketID );
ASSERT(!"Undefined Serialize function");
LOGERROR("Packet type 0x%02x has no serializer defined!", m_PacketID);
ASSERT(!"Unserialized packet");
}
virtual cPacket * Clone() const = 0;
@ -61,19 +63,6 @@ public:
unsigned char m_PacketID;
protected:
// These return the number of characters processed, PACKET_INCOMPLETE for incomplete data, PACKET_ERROR for error:
static int ReadString16(const char * a_Data, int a_Size, AString & a_OutString );
static int ReadShort (const char * a_Data, int a_Size, short & a_Short );
static int ReadInteger (const char * a_Data, int a_Size, int & a_OutInteger );
static int ReadInteger (const char * a_Data, int a_Size, unsigned int & a_OutInteger );
static int ReadFloat (const char * a_Data, int a_Size, float & a_OutFloat );
static int ReadDouble (const char * a_Data, int a_Size, double & a_OutDouble );
static int ReadByte (const char * a_Data, int a_Size, char & a_OutByte );
static int ReadByte (const char * a_Data, int a_Size, unsigned char & a_OutByte );
static int ReadLong (const char * a_Data, int a_Size, long long & a_OutLong );
static int ReadBool (const char * a_Data, int a_Size, bool & a_OutBool );
// These append the data into the a_Dst string:
static void AppendString ( AString & a_Dst, const AString & a_String);
static void AppendString16( AString & a_Dst, const AString & a_String);

View File

@ -7,11 +7,11 @@
int cPacket_13::Parse(const char * a_Data, int a_Size)
int cPacket_13::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadInteger, m_EntityID, TotalBytes);
HANDLE_PACKET_READ(ReadByte , m_ActionID, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_EntityID, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_ActionID, TotalBytes);
return TotalBytes;
}

View File

@ -21,7 +21,7 @@ public:
{ m_PacketID = E_PACKET_13; }
virtual cPacket* Clone() const { return new cPacket_13( *this ); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
int m_EntityID;
char m_ActionID;

View File

@ -7,11 +7,11 @@
int cPacket_ArmAnim::Parse(const char * a_Data, int a_Size)
int cPacket_ArmAnim::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadInteger, m_EntityID, TotalBytes);
HANDLE_PACKET_READ(ReadByte , m_Animation, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_EntityID, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_Animation, TotalBytes);
return TotalBytes;
}

View File

@ -12,7 +12,7 @@ public:
{ m_PacketID = E_ANIMATION; }
virtual cPacket* Clone() const { return new cPacket_ArmAnim(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
int m_EntityID;

View File

@ -20,14 +20,14 @@ void cPacket_BlockDig::Serialize(AString & a_Data) const
int cPacket_BlockDig::Parse(const char * a_Data, int a_Size)
int cPacket_BlockDig::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadByte, m_Status, TotalBytes);
HANDLE_PACKET_READ(ReadInteger, m_PosX, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_PosY, TotalBytes);
HANDLE_PACKET_READ(ReadInteger, m_PosZ, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_Direction, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_Status, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_PosX, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_PosY, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_PosZ, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_Direction, TotalBytes);
return TotalBytes;
}

View File

@ -15,7 +15,7 @@ public:
{ m_PacketID = E_BLOCK_DIG; } //tolua_export
virtual cPacket* Clone() const { return new cPacket_BlockDig(*this); } //tolua_export
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
char m_Status; // tolua_export

View File

@ -8,16 +8,16 @@
int cPacket_BlockPlace::Parse(const char * a_Data, int a_Size)
int cPacket_BlockPlace::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadInteger, m_PosX, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_PosY, TotalBytes);
HANDLE_PACKET_READ(ReadInteger, m_PosZ, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_Direction, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_PosX, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_PosY, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_PosZ, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_Direction, TotalBytes);
cPacket_ItemData Item;
int res = Item.Parse(a_Data + TotalBytes, a_Size - TotalBytes);
int res = Item.Parse(a_Buffer);
if (res < 0)
{
return res;

View File

@ -21,7 +21,7 @@ public:
{ m_PacketID = E_BLOCK_PLACE; }
virtual cPacket* Clone() const { return new cPacket_BlockPlace(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
int m_PosX; //tolua_export
unsigned char m_PosY; //tolua_export

View File

@ -7,10 +7,10 @@
int cPacket_Chat::Parse(const char * a_Data, int a_Size)
int cPacket_Chat::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadString16, m_Message, TotalBytes);
HANDLE_PACKET_READ(ReadBEUTF16String16, m_Message, TotalBytes);
return TotalBytes;
}

View File

@ -10,7 +10,7 @@ public:
cPacket_Chat( const std::string & a_Message ) : m_Message( a_Message) { m_PacketID = E_CHAT; }
virtual cPacket* Clone() const { return new cPacket_Chat(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
AString m_Message;

View File

@ -21,13 +21,13 @@ cPacket_CreativeInventoryAction::cPacket_CreativeInventoryAction( const cPacket_
int cPacket_CreativeInventoryAction::Parse(const char * a_Data, int a_Size)
int cPacket_CreativeInventoryAction::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadShort, m_Slot, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_Slot, TotalBytes);
cPacket_ItemData Item;
int res = Item.Parse(a_Data + TotalBytes, a_Size - TotalBytes);
int res = Item.Parse(a_Buffer);
if (res < 0)
{
return res;

View File

@ -21,7 +21,7 @@ public:
cPacket_CreativeInventoryAction( const cPacket_CreativeInventoryAction & a_Copy );
virtual cPacket* Clone() const { return new cPacket_CreativeInventoryAction(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
short m_Slot; // 0 = hold 1-4 = armor

View File

@ -7,10 +7,10 @@
int cPacket_Disconnect::Parse(const char * a_Data, int a_Size)
int cPacket_Disconnect::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadString16, m_Reason, TotalBytes);
HANDLE_PACKET_READ(ReadBEUTF16String16, m_Reason, TotalBytes);
return TotalBytes;
}

View File

@ -14,7 +14,7 @@ public:
cPacket_Disconnect(const AString & a_Reason) { m_PacketID = E_DISCONNECT; m_Reason = a_Reason; }
virtual cPacket* Clone() const { return new cPacket_Disconnect(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
AString m_Reason;

View File

@ -20,13 +20,13 @@ cPacket_EntityEquipment::cPacket_EntityEquipment( const cPacket_EntityEquipment
int cPacket_EntityEquipment::Parse(const char * a_Data, int a_Size)
int cPacket_EntityEquipment::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadInteger, m_UniqueID, TotalBytes);
HANDLE_PACKET_READ(ReadShort, m_Slot, TotalBytes);
HANDLE_PACKET_READ(ReadShort, m_ItemID, TotalBytes);
HANDLE_PACKET_READ(ReadShort, m_Short, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_UniqueID, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_Slot, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_ItemID, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_Short, TotalBytes);
return TotalBytes;
}

View File

@ -18,7 +18,7 @@ public:
cPacket_EntityEquipment( const cPacket_EntityEquipment & a_Copy );
virtual cPacket* Clone() const { return new cPacket_EntityEquipment(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
int m_UniqueID;

View File

@ -7,7 +7,7 @@
int cPacket_Flying::Parse(const char * a_Data, int a_Size)
int cPacket_Flying::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes= 0;
HANDLE_PACKET_READ(ReadBool, m_bFlying, TotalBytes);

View File

@ -16,7 +16,7 @@ public:
{ m_PacketID = E_FLYING; }
virtual cPacket* Clone() const { return new cPacket_Flying(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
bool m_bFlying;
static const unsigned int c_Size = 2;

View File

@ -7,10 +7,10 @@
int cPacket_Handshake::Parse(const char * a_Data, int a_Size)
int cPacket_Handshake::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadString16, m_Username, TotalBytes);
HANDLE_PACKET_READ(ReadBEUTF16String16, m_Username, TotalBytes);
return TotalBytes;
}

View File

@ -13,7 +13,7 @@ public:
cPacket_Handshake() { m_PacketID = E_HANDSHAKE; }
virtual cPacket* Clone() const { return new cPacket_Handshake(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
std::string m_Username;

View File

@ -7,10 +7,10 @@
int cPacket_ItemData::Parse(const char * a_Data, int a_Size)
int cPacket_ItemData::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadShort, m_ItemID, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_ItemID, TotalBytes);
if (m_ItemID <= -1)
{
@ -19,12 +19,12 @@ int cPacket_ItemData::Parse(const char * a_Data, int a_Size)
return TotalBytes;
}
HANDLE_PACKET_READ(ReadByte , m_ItemCount, TotalBytes);
HANDLE_PACKET_READ(ReadShort, m_ItemUses, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_ItemCount, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_ItemUses, TotalBytes);
if (cItem::IsEnchantable((ENUM_ITEM_ID) m_ItemID))
{
HANDLE_PACKET_READ(ReadShort, m_EnchantNums, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_EnchantNums, TotalBytes);
if ( m_EnchantNums > -1 )
{

View File

@ -17,7 +17,7 @@ public:
virtual cPacket* Clone() const { return new cPacket_ItemData(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
static void AppendItem(AString & a_Data, short a_ItemID, char a_Quantity, short a_Damage);
static void AppendItem(AString & a_Data, const cItem * a_Item);

View File

@ -7,10 +7,10 @@
int cPacket_ItemSwitch::Parse(const char * a_Data, int a_Size)
int cPacket_ItemSwitch::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadShort, m_SlotNum, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_SlotNum, TotalBytes);
return TotalBytes;
}

View File

@ -15,7 +15,7 @@ public:
{ m_PacketID = E_ITEM_SWITCH; }
virtual cPacket* Clone() const { return new cPacket_ItemSwitch(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
short m_SlotNum;

View File

@ -17,10 +17,10 @@ void cPacket_KeepAlive::Serialize(AString & a_Data) const
int cPacket_KeepAlive::Parse(const char * a_Data, int a_Size)
int cPacket_KeepAlive::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadInteger, m_KeepAliveID, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_KeepAliveID, TotalBytes);
return TotalBytes;
}

View File

@ -14,7 +14,7 @@ public:
cPacket_KeepAlive(int a_PingID) { m_KeepAliveID = a_PingID; }
virtual cPacket* Clone() const { return new cPacket_KeepAlive(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
int m_KeepAliveID;

View File

@ -14,19 +14,19 @@ const std::string cPacket_Login::LEVEL_TYPE_SUPERFLAT = "SUPERFLAT";
int cPacket_Login::Parse(const char * a_Data, int a_Size)
int cPacket_Login::Parse(cByteBuffer & a_Buffer)
{
//printf("Parse: NEW Login\n");
int TotalBytes = 0;
m_Username.clear();
HANDLE_PACKET_READ(ReadInteger, m_ProtocolVersion, TotalBytes);
HANDLE_PACKET_READ(ReadString16, m_Username, TotalBytes);
HANDLE_PACKET_READ(ReadString16, m_LevelType, TotalBytes);
HANDLE_PACKET_READ(ReadInteger, m_ServerMode, TotalBytes);
HANDLE_PACKET_READ(ReadInteger, m_Dimension, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_Difficulty, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_WorldHeight, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_MaxPlayers, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_ProtocolVersion, TotalBytes);
HANDLE_PACKET_READ(ReadBEUTF16String16, m_Username, TotalBytes);
HANDLE_PACKET_READ(ReadBEUTF16String16, m_LevelType, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_ServerMode, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_Dimension, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_Difficulty, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_WorldHeight, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_MaxPlayers, TotalBytes);
return TotalBytes;
}

View File

@ -21,7 +21,7 @@ public:
{ m_PacketID = E_LOGIN; }
virtual cPacket* Clone() const { return new cPacket_Login(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
int m_ProtocolVersion; //tolua_export

View File

@ -18,11 +18,11 @@ cPacket_NewInvalidState::cPacket_NewInvalidState( const cPacket_NewInvalidState
int cPacket_NewInvalidState::Parse(const char * a_Data, int a_Size)
int cPacket_NewInvalidState::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadByte, m_Reason, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_GameMode, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_Reason, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_GameMode, TotalBytes);
return TotalBytes;
}

View File

@ -17,7 +17,7 @@ public:
cPacket_NewInvalidState( const cPacket_NewInvalidState & a_Copy );
virtual cPacket* Clone() const { return new cPacket_NewInvalidState(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
char m_Reason; // 0 = Invalid Bed, 1 = Begin Raining, 2 End Raining, 3 = Change Gamemode

View File

@ -7,19 +7,19 @@
int cPacket_PickupSpawn::Parse(const char * a_Data, int a_Size)
int cPacket_PickupSpawn::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadInteger, m_UniqueID, TotalBytes);
HANDLE_PACKET_READ(ReadShort, m_Item, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_Count, TotalBytes);
HANDLE_PACKET_READ(ReadShort, m_Health, TotalBytes);
HANDLE_PACKET_READ(ReadInteger, m_PosX, TotalBytes);
HANDLE_PACKET_READ(ReadInteger, m_PosY, TotalBytes);
HANDLE_PACKET_READ(ReadInteger, m_PosZ, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_Rotation, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_Pitch, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_Roll, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_UniqueID, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_Item, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_Count, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_Health, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_PosX, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_PosY, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_PosZ, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_Rotation, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_Pitch, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_Roll, TotalBytes);
return TotalBytes;
}

View File

@ -24,7 +24,7 @@ public:
{ m_PacketID = E_PICKUP_SPAWN; }
virtual cPacket* Clone() const { return new cPacket_PickupSpawn(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
int m_UniqueID;

View File

@ -14,7 +14,7 @@ public:
{ m_PacketID = E_PING; }
virtual cPacket* Clone() const { return new cPacket_Ping(*this); }
virtual int Parse(const char * a_Data, int a_Size) override {return 0; }
virtual int Parse(cByteBuffer & a_Buffer) override {return 0; }
static const unsigned int c_Size = 1;
};

View File

@ -22,17 +22,14 @@
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// cPacket_PlayerAbilities:
int cPacket_PlayerAbilities::Parse(const char * a_Data, int a_Size)
int cPacket_PlayerAbilities::Parse(cByteBuffer & a_Buffer)
{
if (a_Size < 4)
{
return PACKET_INCOMPLETE;
}
m_Invulnerable = (a_Data[0] != 0);
m_IsFlying = (a_Data[1] != 0);
m_CanFly = (a_Data[2] != 0);
m_InstaMine = (a_Data[3] != 0);
return 4;
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadBool, m_Invulnerable, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_IsFlying, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_CanFly, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_InstaMine, TotalBytes);
return TotalBytes;
}
@ -69,12 +66,12 @@ cPacket_PlayerListItem::cPacket_PlayerListItem(const AString & a_PlayerName, boo
int cPacket_PlayerListItem::Parse(const char * a_Data, int a_Size)
int cPacket_PlayerListItem::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadString16, m_PlayerName, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_Online, TotalBytes);
HANDLE_PACKET_READ(ReadShort, m_Ping, TotalBytes);
HANDLE_PACKET_READ(ReadBEUTF16String16, m_PlayerName, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_Online, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_Ping, TotalBytes);
return TotalBytes;
}
@ -119,12 +116,12 @@ cPacket_PlayerLook::cPacket_PlayerLook( cPlayer* a_Player )
int cPacket_PlayerLook::Parse(const char * a_Data, int a_Size)
int cPacket_PlayerLook::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadFloat, m_Rotation, TotalBytes);
HANDLE_PACKET_READ(ReadFloat, m_Pitch, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_bFlying, TotalBytes);
HANDLE_PACKET_READ(ReadBEFloat, m_Rotation, TotalBytes);
HANDLE_PACKET_READ(ReadBEFloat, m_Pitch, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_bFlying, TotalBytes);
return TotalBytes;
}
@ -162,16 +159,16 @@ cPacket_PlayerMoveLook::cPacket_PlayerMoveLook( cPlayer* a_Player )
int cPacket_PlayerMoveLook::Parse(const char * a_Data, int a_Size)
int cPacket_PlayerMoveLook::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadDouble, m_PosX, TotalBytes);
HANDLE_PACKET_READ(ReadDouble, m_PosY, TotalBytes);
HANDLE_PACKET_READ(ReadDouble, m_Stance, TotalBytes);
HANDLE_PACKET_READ(ReadDouble, m_PosZ, TotalBytes);
HANDLE_PACKET_READ(ReadFloat, m_Rotation, TotalBytes);
HANDLE_PACKET_READ(ReadFloat, m_Pitch, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_bFlying, TotalBytes);
HANDLE_PACKET_READ(ReadBEDouble, m_PosX, TotalBytes);
HANDLE_PACKET_READ(ReadBEDouble, m_PosY, TotalBytes);
HANDLE_PACKET_READ(ReadBEDouble, m_Stance, TotalBytes);
HANDLE_PACKET_READ(ReadBEDouble, m_PosZ, TotalBytes);
HANDLE_PACKET_READ(ReadBEFloat, m_Rotation, TotalBytes);
HANDLE_PACKET_READ(ReadBEFloat, m_Pitch, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_bFlying, TotalBytes);
return TotalBytes;
}
@ -213,14 +210,14 @@ cPacket_PlayerPosition::cPacket_PlayerPosition( cPlayer* a_Player )
int cPacket_PlayerPosition::Parse(const char * a_Data, int a_Size)
int cPacket_PlayerPosition::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadDouble, m_PosX, TotalBytes);
HANDLE_PACKET_READ(ReadDouble, m_PosY, TotalBytes);
HANDLE_PACKET_READ(ReadDouble, m_Stance, TotalBytes);
HANDLE_PACKET_READ(ReadDouble, m_PosZ, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_bFlying, TotalBytes);
HANDLE_PACKET_READ(ReadBEDouble, m_PosX, TotalBytes);
HANDLE_PACKET_READ(ReadBEDouble, m_PosY, TotalBytes);
HANDLE_PACKET_READ(ReadBEDouble, m_Stance, TotalBytes);
HANDLE_PACKET_READ(ReadBEDouble, m_PosZ, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_bFlying, TotalBytes);
return TotalBytes;
}

View File

@ -33,7 +33,7 @@ class cPacket_PlayerAbilities : public cPacket
public:
cPacket_PlayerAbilities(void) { m_PacketID = E_PLAYER_LIST_ITEM; }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
virtual cPacket * Clone() const { return new cPacket_PlayerAbilities(*this); }
@ -54,7 +54,7 @@ public:
cPacket_PlayerListItem() { m_PacketID = E_PLAYER_LIST_ITEM; }
cPacket_PlayerListItem(const AString & a_PlayerName, bool a_Online, short a_Ping);
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
virtual cPacket* Clone() const { return new cPacket_PlayerListItem(*this); }
@ -79,7 +79,7 @@ public:
cPacket_PlayerLook( cPlayer* a_Player );
virtual cPacket* Clone() const { return new cPacket_PlayerLook(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
float m_Rotation;
@ -106,7 +106,7 @@ public:
cPacket_PlayerMoveLook( cPlayer* a_Player );
virtual cPacket* Clone() const { return new cPacket_PlayerMoveLook(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
double m_PosX;
@ -135,7 +135,7 @@ public:
{ m_PacketID = E_PLAYERPOS; }
virtual cPacket* Clone() const { return new cPacket_PlayerPosition(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
double m_PosX;

View File

@ -22,15 +22,15 @@ void cPacket_Respawn::Serialize(AString & a_Data) const
int cPacket_Respawn::Parse(const char * a_Data, int a_Size)
int cPacket_Respawn::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadInteger, m_Dimension, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_Difficulty, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_CreativeMode, TotalBytes);
HANDLE_PACKET_READ(ReadShort, m_WorldHeight, TotalBytes);
HANDLE_PACKET_READ(ReadString16, m_LevelType, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_Dimension, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_Difficulty, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_CreativeMode, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_WorldHeight, TotalBytes);
HANDLE_PACKET_READ(ReadBEUTF16String16, m_LevelType, TotalBytes);
return TotalBytes;
}

View File

@ -22,7 +22,7 @@ public:
virtual cPacket* Clone() const { return new cPacket_Respawn( *this ); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
int m_Dimension;

View File

@ -7,10 +7,10 @@
int cPacket_TimeUpdate::Parse(const char * a_Data, int a_Size)
int cPacket_TimeUpdate::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadLong, m_Time, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt64, m_Time, TotalBytes);
return TotalBytes;
}

View File

@ -16,7 +16,7 @@ public:
cPacket_TimeUpdate( long long a_Time ) { m_PacketID = E_UPDATE_TIME; m_Time = a_Time; }
virtual cPacket* Clone() const { return new cPacket_TimeUpdate(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
long long m_Time;

View File

@ -7,16 +7,16 @@
int cPacket_UpdateSign::Parse(const char * a_Data, int a_Size)
int cPacket_UpdateSign::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadInteger, m_PosX, TotalBytes);
HANDLE_PACKET_READ(ReadShort, m_PosY, TotalBytes);
HANDLE_PACKET_READ(ReadInteger, m_PosZ, TotalBytes);
HANDLE_PACKET_READ(ReadString16, m_Line1, TotalBytes);
HANDLE_PACKET_READ(ReadString16, m_Line2, TotalBytes);
HANDLE_PACKET_READ(ReadString16, m_Line3, TotalBytes);
HANDLE_PACKET_READ(ReadString16, m_Line4, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_PosX, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_PosY, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_PosZ, TotalBytes);
HANDLE_PACKET_READ(ReadBEUTF16String16, m_Line1, TotalBytes);
HANDLE_PACKET_READ(ReadBEUTF16String16, m_Line2, TotalBytes);
HANDLE_PACKET_READ(ReadBEUTF16String16, m_Line3, TotalBytes);
HANDLE_PACKET_READ(ReadBEUTF16String16, m_Line4, TotalBytes);
return TotalBytes;
}

View File

@ -17,7 +17,7 @@ public:
{ m_PacketID = E_UPDATE_SIGN; }
virtual cPacket* Clone() const { return new cPacket_UpdateSign( *this ); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
int m_PosX;

View File

@ -7,12 +7,12 @@
int cPacket_UseEntity::Parse(const char * a_Data, int a_Size)
int cPacket_UseEntity::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadInteger, m_UniqueID, TotalBytes);
HANDLE_PACKET_READ(ReadInteger, m_TargetID, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_bLeftClick, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_UniqueID, TotalBytes);
HANDLE_PACKET_READ(ReadBEInt, m_TargetID, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_bLeftClick, TotalBytes);
return TotalBytes;
}

View File

@ -17,7 +17,7 @@ public:
{ m_PacketID = E_USE_ENTITY; }
virtual cPacket* Clone() const { return new cPacket_UseEntity(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
int m_UniqueID;
int m_TargetID;

View File

@ -9,18 +9,17 @@
int cPacket_WindowClick::Parse(const char * a_Data, int a_Size)
int cPacket_WindowClick::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadByte, m_WindowID, TotalBytes);
HANDLE_PACKET_READ(ReadShort, m_SlotNum, TotalBytes);
HANDLE_PACKET_READ(ReadByte, m_RightMouse, TotalBytes);
HANDLE_PACKET_READ(ReadShort, m_NumClicks, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_IsShiftPressed, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_WindowID, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_SlotNum, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_RightMouse, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_NumClicks, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_IsShiftPressed, TotalBytes);
cPacket_ItemData Item;
int res = Item.Parse(a_Data + TotalBytes, a_Size - TotalBytes);
int res = Item.Parse(a_Buffer);
if (res < 0)
{
return res;

View File

@ -23,7 +23,7 @@ public:
{ m_PacketID = E_WINDOW_CLICK; }
virtual cPacket* Clone() const { return new cPacket_WindowClick(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
char m_WindowID;
short m_SlotNum; // Slot

View File

@ -7,10 +7,10 @@
int cPacket_WindowClose::Parse(const char * a_Data, int a_Size)
int cPacket_WindowClose::Parse(cByteBuffer & a_Buffer)
{
int TotalBytes = 0;
HANDLE_PACKET_READ(ReadByte, m_Close, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_Close, TotalBytes);
return TotalBytes;
}

View File

@ -15,7 +15,7 @@ public:
{ m_PacketID = E_WINDOW_CLOSE; }
virtual cPacket* Clone() const { return new cPacket_WindowClose(*this); }
virtual int Parse(const char * a_Data, int a_Size) override;
virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override;
char m_Close; // m_Close == cWindow WindowType number