1
0
cuberite-2a/src/Protocol/Protocol16x.cpp

313 lines
6.3 KiB
C++
Raw Normal View History

// Protocol16x.cpp
/*
Implements the 1.6.x protocol classes:
- cProtocol161
- release 1.6.1 protocol (#73)
- cProtocol162
- release 1.6.2 protocol (#74)
- release 1.6.3 protocol (#77) - no relevant changes
- release 1.6.4 protocol (#78) - no relevant changes
(others may be added later in the future for the 1.6 release series)
*/
#include "Globals.h"
#include "Protocol16x.h"
#include "../ClientHandle.h"
#include "../Entities/Entity.h"
#include "../Entities/Player.h"
#include "../UI/Window.h"
#include "../CompositeChat.h"
#define HANDLE_PACKET_READ(Proc, Type, Var) \
Type Var; \
{ \
if (!m_ReceivedData.Proc(Var)) \
{ \
m_ReceivedData.CheckValid(); \
return PARSE_INCOMPLETE; \
} \
m_ReceivedData.CheckValid(); \
}
enum
{
PACKET_CHAT = 0x03,
PACKET_UPDATE_HEALTH = 0x08,
PACKET_STEER_VEHICLE = 0x1b,
PACKET_ATTACH_ENTITY = 0x27,
PACKET_ENTITY_PROPERTIES = 0x2c,
PACKET_WINDOW_OPEN = 0x64,
PACKET_TILE_EDITOR_OPEN = 0x85,
PACKET_PLAYER_ABILITIES = 0xca,
} ;
////////////////////////////////////////////////////////////////////////////////
// cProtocol161:
cProtocol161::cProtocol161(cClientHandle * a_Client) :
super(a_Client)
{
}
void cProtocol161::SendAttachEntity(const cEntity & a_Entity, const cEntity * a_Vehicle)
{
cCSLock Lock(m_CSPacket);
WriteByte(PACKET_ATTACH_ENTITY);
WriteInt(a_Entity.GetUniqueID());
WriteInt((a_Vehicle == NULL) ? -1 : a_Vehicle->GetUniqueID());
WriteBool(false); // TODO: "Should use leash?" -> no
Flush();
}
void cProtocol161::SendChat(const AString & a_Message)
{
super::SendChat(Printf("{\"text\":\"%s\"}", EscapeString(a_Message).c_str()));
}
void cProtocol161::SendChat(const cCompositeChat & a_Message)
{
// This protocol version doesn't support composite messages to the full
// Just extract each part's text and use it:
super::SendChat(Printf("{\"text\":\"%s\"}", EscapeString(a_Message.ExtractText()).c_str()));
}
void cProtocol161::SendEditSign(int a_BlockX, int a_BlockY, int a_BlockZ)
{
cCSLock Lock(m_CSPacket);
WriteByte(PACKET_TILE_EDITOR_OPEN);
WriteByte(0);
WriteInt(a_BlockX);
WriteInt(a_BlockY);
WriteInt(a_BlockZ);
Flush();
}
void cProtocol161::SendGameMode(eGameMode a_GameMode)
{
super::SendGameMode(a_GameMode);
SendPlayerMaxSpeed();
}
void cProtocol161::SendHealth(void)
{
cCSLock Lock(m_CSPacket);
WriteByte (PACKET_UPDATE_HEALTH);
cPlayer * Player = m_Client->GetPlayer();
WriteFloat((float)Player->GetHealth());
WriteShort((short)Player->GetFoodLevel());
WriteFloat((float)Player->GetFoodSaturationLevel());
Flush();
}
void cProtocol161::SendPlayerMaxSpeed(void)
{
cCSLock Lock(m_CSPacket);
cPlayer * Player = m_Client->GetPlayer();
WriteByte(PACKET_ENTITY_PROPERTIES);
WriteInt(Player->GetUniqueID());
WriteInt(1);
WriteString("generic.movementSpeed");
WriteDouble(0.1 * Player->GetMaxSpeed());
Flush();
}
2014-06-29 17:44:01 -04:00
void cProtocol161::SendRespawn(const cWorld & a_World, bool a_ShouldIgnoreDimensionChecks)
{
// Besides sending the respawn, we need to also send the player max speed, otherwise the client reverts to super-fast
2014-06-29 17:44:01 -04:00
super::SendRespawn(a_World, a_ShouldIgnoreDimensionChecks);
SendPlayerMaxSpeed();
}
void cProtocol161::SendWindowOpen(const cWindow & a_Window)
{
if (a_Window.GetWindowType() < 0)
{
// Do not send for inventory windows
return;
}
cCSLock Lock(m_CSPacket);
WriteByte (PACKET_WINDOW_OPEN);
WriteChar (a_Window.GetWindowID());
WriteByte ((Byte)a_Window.GetWindowType());
WriteString(a_Window.GetWindowTitle());
WriteByte ((Byte)a_Window.GetNumNonInventorySlots());
WriteByte (1); // Use title
if (a_Window.GetWindowType() == cWindow::wtAnimalChest)
{
WriteInt(0); // TODO: The animal's EntityID
}
Flush();
}
int cProtocol161::ParseEntityAction(void)
{
HANDLE_PACKET_READ(ReadBEInt, int, EntityID);
HANDLE_PACKET_READ(ReadChar, char, ActionID);
HANDLE_PACKET_READ(ReadBEInt, int, UnknownHorseVal);
2014-03-08 13:26:32 -05:00
switch (ActionID)
{
case 1: m_Client->HandleEntityCrouch(EntityID, true); break; // Crouch
case 2: m_Client->HandleEntityCrouch(EntityID, false); break; // Uncrouch
case 3: m_Client->HandleEntityLeaveBed(EntityID); break; // Leave Bed
case 4: m_Client->HandleEntitySprinting(EntityID, true); break; // Start sprinting
case 5: m_Client->HandleEntitySprinting(EntityID, false); break; // Stop sprinting
}
return PARSE_OK;
}
int cProtocol161::ParseLogin(void)
{
// The login packet is sent by Forge clients only
// Only parse the packet, do no extra processing
// Note that the types and the names have been only guessed and are not verified at all!
HANDLE_PACKET_READ(ReadBEInt, int, Int1);
HANDLE_PACKET_READ(ReadBEUTF16String16, AString, String1);
HANDLE_PACKET_READ(ReadChar, char, Char1);
HANDLE_PACKET_READ(ReadChar, char, Char2);
HANDLE_PACKET_READ(ReadChar, char, Char3);
HANDLE_PACKET_READ(ReadByte, Byte, Byte1);
HANDLE_PACKET_READ(ReadByte, Byte, Byte2);
return PARSE_OK;
}
int cProtocol161::ParsePlayerAbilities(void)
{
HANDLE_PACKET_READ(ReadByte, Byte, Flags);
HANDLE_PACKET_READ(ReadBEFloat, float, FlyingSpeed);
HANDLE_PACKET_READ(ReadBEFloat, float, WalkingSpeed);
// TODO: m_Client->HandlePlayerAbilities(...);
return PARSE_OK;
}
int cProtocol161::ParseSteerVehicle(void)
{
HANDLE_PACKET_READ(ReadBEFloat, float, Sideways);
HANDLE_PACKET_READ(ReadBEFloat, float, Forward);
HANDLE_PACKET_READ(ReadBool, bool, Jump);
HANDLE_PACKET_READ(ReadBool, bool, Unmount);
if (Unmount)
{
m_Client->HandleUnmount();
}
2013-09-05 18:04:49 -04:00
else
{
m_Client->HandleSteerVehicle(Forward, Sideways);
}
return PARSE_OK;
}
int cProtocol161::ParsePacket(unsigned char a_PacketType)
{
switch (a_PacketType)
{
case PACKET_STEER_VEHICLE: return ParseSteerVehicle();
default: return super::ParsePacket(a_PacketType);
}
}
////////////////////////////////////////////////////////////////////////////////
// cProtocol162:
cProtocol162::cProtocol162(cClientHandle * a_Client) :
super(a_Client)
{
}
void cProtocol162::SendPlayerMaxSpeed(void)
{
cCSLock Lock(m_CSPacket);
cPlayer * Player = m_Client->GetPlayer();
WriteByte(PACKET_ENTITY_PROPERTIES);
WriteInt(Player->GetUniqueID());
WriteInt(1);
WriteString("generic.movementSpeed");
WriteDouble(0.1 * Player->GetMaxSpeed());
WriteShort(0);
Flush();
}