public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
if (player.GetInventoryEnabled())
{
byte id = dataTypes.ReadNextByte(packetData);
short elements = dataTypes.ReadNextShort(packetData);
for (int i = 0; i < elements; i++)
{
short itemID = dataTypes.ReadNextShort(packetData);
if (itemID == -1)
{
continue;
}
byte itemCount = dataTypes.ReadNextByte(packetData);
short itemDamage = dataTypes.ReadNextShort(packetData);
Item item = new Item(itemID, itemCount, itemDamage, 0);
//TODO: Add to the dictionary for the inventory its in using the id
if (packetData.ToArray().Count() > 0)
{
dataTypes.ReadNextNbt(packetData);
}
}
}
return(true);
}
private void SendPacket(IncomingPacket packet)
{
List <byte> buffer = new List <byte>();
PacketIncomingType type = packet.GetBuffer(protocol.protocolVersion, buffer);
SendPacket(type, buffer);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
if (protocolversion >= (int)McVersion.V113)
{
protocol18Handler.autocomplete_transaction_id = dataTypes.ReadNextVarInt(packetData);
dataTypes.ReadNextVarInt(packetData); // Start of text to replace
dataTypes.ReadNextVarInt(packetData); // Length of text to replace
}
int autocomplete_count = dataTypes.ReadNextVarInt(packetData);
protocol18Handler.autocomplete_result.Clear();
for (int i = 0; i < autocomplete_count; i++)
{
protocol18Handler.autocomplete_result.Add(dataTypes.ReadNextString(packetData));
if (protocolversion >= (int)McVersion.V113)
{
// Skip optional tooltip for each tab-complete result
if (dataTypes.ReadNextBool(packetData))
{
dataTypes.ReadNextString(packetData);
}
}
}
protocol18Handler.autocomplete_received = true;
return(true);
}
public override int getPacketIncomingID(PacketIncomingType packet)
{
switch (packet)
{
case PacketIncomingType.TabCompleteResult: return(0x0E);
case PacketIncomingType.ChatMessage: return(0x0F);
case PacketIncomingType.ConfirmTransaction: return(0x11);
case PacketIncomingType.PluginMessage: return(0x18);
case PacketIncomingType.Disconnect: return(0x1A);
case PacketIncomingType.KeepAlive: return(0x1F);
case PacketIncomingType.ChunkData: return(0x20);
case PacketIncomingType.JoinGame: return(0x23);
case PacketIncomingType.Respawn: return(0x35);
case PacketIncomingType.SpawnPosition: return(0x46);
default: return(0xFF);
}
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
int chunkX = dataTypes.ReadNextInt(packetData);
int chunkZ = dataTypes.ReadNextInt(packetData);
int recordCount = protocolversion < (int)McVersion.V18
? (int)dataTypes.ReadNextShort(packetData)
: dataTypes.ReadNextVarInt(packetData);
for (int i = 0; i < recordCount; i++)
{
byte locationXZ;
ushort blockIdMeta;
int blockY;
if (protocolversion < (int)McVersion.V18)
{
blockIdMeta = dataTypes.ReadNextUShort(packetData);
blockY = (ushort)dataTypes.ReadNextByte(packetData);
locationXZ = dataTypes.ReadNextByte(packetData);
}
else
{
locationXZ = dataTypes.ReadNextByte(packetData);
blockY = (ushort)dataTypes.ReadNextByte(packetData);
blockIdMeta = (ushort)dataTypes.ReadNextVarInt(packetData);
}
int blockX = locationXZ >> 4;
int blockZ = locationXZ & 0x0F;
Block block = new Block(blockIdMeta);
handler.GetWorld().SetBlock(new Location(chunkX, chunkZ, blockX, blockY, blockZ), block);
}
return(true);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> data)
{
double x = dataTypes.ReadNextDouble(data);
double y = dataTypes.ReadNextDouble(data);
double z = dataTypes.ReadNextDouble(data);
float yaw = dataTypes.ReadNextFloat(data);
float pitch = dataTypes.ReadNextFloat(data);
byte locMask = dataTypes.ReadNextByte(data);
if (protocolversion >= (int)McVersion.V18)
{
Location location = player.GetCurrentLocation();
location.X = (locMask & 1 << 0) != 0 ? location.X + x : x;
location.Y = (locMask & 1 << 1) != 0 ? location.Y + y : y;
location.Z = (locMask & 1 << 2) != 0 ? location.Z + z : z;
player.UpdateLocation(location, yaw, pitch);
}
else
{
player.UpdateLocation(new Location(x, y, z), yaw, pitch);
}
if (protocolversion >= (int)McVersion.V19)
{
int teleportID = dataTypes.ReadNextVarInt(data);
// Teleport confirm packet
packetSender.WritePacket(PacketOutgoingType.TeleportConfirm, dataTypes.GetVarInt(teleportID));
}
return(true);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> data)
{
handler.OnGameJoined();
dataTypes.ReadNextInt(data);
dataTypes.ReadNextByte(data);
if (protocolversion >= (int)McVersion.V191)
{
worldInfo.dimension = dataTypes.ReadNextInt(data);
}
else
{
worldInfo.dimension = (sbyte)dataTypes.ReadNextByte(data);
}
if (protocolversion < (int)McVersion.V114)
{
dataTypes.ReadNextByte(data); // Difficulty - 1.13 and below
}
dataTypes.ReadNextByte(data);
dataTypes.ReadNextString(data);
if (protocolversion >= (int)McVersion.V114)
{
dataTypes.ReadNextVarInt(data); // View distance - 1.14 and above
}
if (protocolversion >= (int)McVersion.V18)
{
dataTypes.ReadNextBool(data); // Reduced debug info - 1.8 and above
}
return(true);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
int chunkX = dataTypes.ReadNextInt(packetData);
int chunkZ = dataTypes.ReadNextInt(packetData);
bool chunksContinuous = dataTypes.ReadNextBool(packetData);
ushort chunkMask = protocolversion >= (int)McVersion.V19
? (ushort)dataTypes.ReadNextVarInt(packetData)
: dataTypes.ReadNextUShort(packetData);
if (protocolversion < (int)McVersion.V18)
{
ushort addBitmap = dataTypes.ReadNextUShort(packetData);
int compressedDataSize = dataTypes.ReadNextInt(packetData);
byte[] compressed = dataTypes.ReadData(compressedDataSize, packetData);
byte[] decompressed = ZlibUtils.Decompress(compressed);
pTerrain.ProcessChunkColumnData(chunkX, chunkZ, chunkMask, addBitmap, worldInfo.dimension == 0, chunksContinuous, worldInfo.dimension, new List <byte>(decompressed));
}
else
{
if (protocolversion >= (int)McVersion.V114)
{
dataTypes.ReadNextNbt(packetData); // Heightmaps - 1.14 and above
}
int dataSize = dataTypes.ReadNextVarInt(packetData);
pTerrain.ProcessChunkColumnData(chunkX, chunkZ, chunkMask, 0, false, chunksContinuous, worldInfo.dimension, packetData);
}
return(true);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
if (protocolversion >= (int)McVersion.V18 && protocolversion < (int)McVersion.V19)
{
Protocol18Handler.connectionInfo.compressionThreshold = dataTypes.ReadNextVarInt(packetData);
}
return(true);
}
public void receivePacket(int packetID, List <byte> packetData)
{
PacketIncomingType type = protocol.getPacketIncomingType(packetID);
switch (type)
{
case PacketIncomingType.JoinGame:
List <byte> tmp = new List <byte>();
tmp.AddRange(packetData);
int EntityID = readNextInt(tmp);
byte GameMode = readNextByte(tmp);
int Dimension = 0;
byte Difficulty = 0;
if (protocol.protocolVersion >= MCVersion.MC191Version)
{
Dimension = readNextInt(tmp);
}
else
{
Dimension = readNextByte(tmp);
}
if (protocol.protocolVersion < MCVersion.MC114Version)
{
Difficulty = readNextByte(tmp);
}
readNextByte(tmp);
string LevelType = readNextString(tmp);
if (Dimensions.ContainsKey(Dimension))
{
Dimensions[Dimension] = LevelType;
}
else
{
Dimensions.Add(Dimension, LevelType);
}
if (trans_server)
{
SendPacket(packetID, packetData);
Proxy.SendPacket(clientSettings);
foreach (int d in Dimensions.Keys)
{
Respawn respawnPacket = new Respawn(d, Difficulty, GameMode, Dimensions[d]);
SendPacket(respawnPacket);
}
trans_server = false;
return;
}
break;
case PacketIncomingType.KickPacket:
OnConnectionLost(Conn.DisconnectReason.InGameKick, readNextString(packetData));
return;
}
//Console.Write(packetID + " ");
SendPacket(packetID, packetData);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
if (player.GetInventoryEnabled())
{
byte windowID = dataTypes.ReadNextByte(packetData);
player.onInventoryClose(windowID);
}
return(true);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
if (protocolversion >= (int)McVersion.V19)
{
int chunkX = dataTypes.ReadNextInt(packetData);
int chunkZ = dataTypes.ReadNextInt(packetData);
handler.GetWorld()[chunkX, chunkZ] = null;
}
return(true);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
worldInfo.dimension = dataTypes.ReadNextInt(packetData);
if (protocolversion < (int)McVersion.V114)
{
dataTypes.ReadNextByte(packetData); // Difficulty - 1.13 and below
}
dataTypes.ReadNextByte(packetData);
dataTypes.ReadNextString(packetData);
handler.OnRespawn();
return(true);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
IPacketHandler packetHandler;
if (packetHandlers.TryGetValue(packetType, out packetHandler))
{
packetHandler.HandlePacket(packetType, packetData);
return(true);
}
return(false);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
String channel = dataTypes.ReadNextString(packetData);
// Length is unneeded as the whole remaining packetData is the entire payload of the packet.
if (protocolversion < (int)McVersion.V18)
{
pForge.ReadNextVarShort(packetData);
}
handler.OnPluginChannelMessage(channel, packetData.ToArray());
return(pForge.HandlePluginMessage(channel, packetData, ref worldInfo.dimension));
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
int blockX = dataTypes.ReadNextInt(packetData);
int blockY = dataTypes.ReadNextByte(packetData);
int blockZ = dataTypes.ReadNextInt(packetData);
short blockId = (short)dataTypes.ReadNextVarInt(packetData);
byte blockMeta = dataTypes.ReadNextByte(packetData);
handler.GetWorld().SetBlock(new Location(blockX, blockY, blockZ), new Block(blockId, blockMeta));
return(true);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
string url = dataTypes.ReadNextString(packetData);
string hash = dataTypes.ReadNextString(packetData);
//Send back "accepted" and "successfully loaded" responses for plugins making use of resource pack mandatory
byte[] responseHeader = new byte[0];
if (protocolversion < (int)McVersion.V110) //MC 1.10 does not include resource pack hash in responses
{
responseHeader = dataTypes.ConcatBytes(dataTypes.GetVarInt(hash.Length), Encoding.UTF8.GetBytes(hash));
}
packetSender.WritePacket(PacketOutgoingType.ResourcePackStatus, dataTypes.ConcatBytes(responseHeader, dataTypes.GetVarInt(3))); //Accepted pack
packetSender.WritePacket(PacketOutgoingType.ResourcePackStatus, dataTypes.ConcatBytes(responseHeader, dataTypes.GetVarInt(0))); //Successfully loaded
return(true);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
if (player.GetInventoryEnabled())
{
byte windowID = dataTypes.ReadNextByte(packetData);
string type = dataTypes.ReadNextString(packetData).Replace("minecraft:", "").ToUpper();
InventoryType inventoryType = (InventoryType)Enum.Parse(typeof(InventoryType), type);
string title = dataTypes.ReadNextString(packetData);
byte slots = dataTypes.ReadNextByte(packetData);
Inventory inventory = new Inventory(windowID, inventoryType, title, slots);
player.onInventoryOpen(inventory);
}
return(true);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> data)
{
string message = dataTypes.ReadNextString(data);
try
{
//Hide system messages or xp bar messages?
byte messageType = dataTypes.ReadNextByte(data);
if ((messageType == 1 && !Settings.DisplaySystemMessages) || (messageType == 2 && !Settings.DisplayXPBarMessages))
{
return(true);
}
}
catch (ArgumentOutOfRangeException) { /* No message type */ }
handler.OnTextReceived(message, true);
return(true);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
int chunkCount;
bool hasSkyLight;
List <byte> chunkData = packetData;
//Read global fields
if (protocolversion < (int)McVersion.V18)
{
chunkCount = dataTypes.ReadNextShort(packetData);
int compressedDataSize = dataTypes.ReadNextInt(packetData);
hasSkyLight = dataTypes.ReadNextBool(packetData);
byte[] compressed = dataTypes.ReadData(compressedDataSize, packetData);
byte[] decompressed = ZlibUtils.Decompress(compressed);
chunkData = new List <byte>(decompressed);
}
else
{
hasSkyLight = dataTypes.ReadNextBool(packetData);
chunkCount = dataTypes.ReadNextVarInt(packetData);
}
//Read chunk records
int[] chunkXs = new int[chunkCount];
int[] chunkZs = new int[chunkCount];
ushort[] chunkMasks = new ushort[chunkCount];
ushort[] addBitmaps = new ushort[chunkCount];
for (int chunkColumnNo = 0; chunkColumnNo < chunkCount; chunkColumnNo++)
{
chunkXs[chunkColumnNo] = dataTypes.ReadNextInt(packetData);
chunkZs[chunkColumnNo] = dataTypes.ReadNextInt(packetData);
chunkMasks[chunkColumnNo] = dataTypes.ReadNextUShort(packetData);
addBitmaps[chunkColumnNo] = protocolversion < (int)McVersion.V18
? dataTypes.ReadNextUShort(packetData)
: (ushort)0;
}
//Process chunk records
for (int chunkColumnNo = 0; chunkColumnNo < chunkCount; chunkColumnNo++)
{
pTerrain.ProcessChunkColumnData(chunkXs[chunkColumnNo], chunkZs[chunkColumnNo], chunkMasks[chunkColumnNo], addBitmaps[chunkColumnNo], hasSkyLight, true, worldInfo.dimension, chunkData);
}
return(true);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> data)
{
//Use better algorthim for getting the packet handler.
int minimumVersion = -1;
PacketHandlerInfo closestPacketHandler = null;
foreach (PacketHandlerInfo packetHandlerInfo in packetHandlerInfos)
{
int handlerVersion = packetHandlerInfo.version;
if (handlerVersion <= version && handlerVersion > minimumVersion)
{
minimumVersion = handlerVersion;
closestPacketHandler = packetHandlerInfo;
}
}
return(closestPacketHandler.packetHandler.HandlePacket(packetType, data));
}
public override int getPacketIncomingID(PacketIncomingType packet)
{
switch (packet)
{
case PacketIncomingType.KeepAlive: return(0x00);
case PacketIncomingType.JoinGame: return(0x01);
case PacketIncomingType.ChatMessage: return(0x02);
case PacketIncomingType.Respawn: return(0x07);
case PacketIncomingType.Entity: return(0x14);
case PacketIncomingType.PluginMessage: return(0x3F);
case PacketIncomingType.KickPacket: return(0x40);
default: return(0xFF);
}
}
public abstract int getPacketIncomingID(PacketIncomingType packet);
private void SendPacket(PacketIncomingType type, IEnumerable <byte> packetData)
{
SendPacket(protocol.getPacketIncomingID(type), packetData);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
handler.OnConnectionLost(DisconnectReason.InGameKick, ChatParser.ParseText(dataTypes.ReadNextString(packetData)));
return(false);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> data)
{
packetSender.WritePacket(PacketOutgoingType.KeepAlive, data);
return(true);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
handler.GetWorld().SetBlock(dataTypes.ReadNextLocation(packetData), new Block((ushort)dataTypes.ReadNextVarInt(packetData)));
return(true);
}
public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
{
if (protocolversion >= (int)McVersion.V18)
{
int action = dataTypes.ReadNextVarInt(packetData);
int numActions = dataTypes.ReadNextVarInt(packetData);
for (int i = 0; i < numActions; i++)
{
Guid uuid = dataTypes.ReadNextUUID(packetData);
switch (action)
{
case 0x00: //Player Join
string name = dataTypes.ReadNextString(packetData);
int propNum = dataTypes.ReadNextVarInt(packetData);
for (int p = 0; p < propNum; p++)
{
string key = dataTypes.ReadNextString(packetData);
string val = dataTypes.ReadNextString(packetData);
if (dataTypes.ReadNextBool(packetData))
{
dataTypes.ReadNextString(packetData);
}
}
dataTypes.ReadNextVarInt(packetData);
dataTypes.ReadNextVarInt(packetData);
if (dataTypes.ReadNextBool(packetData))
{
dataTypes.ReadNextString(packetData);
}
handler.OnPlayerJoin(uuid, name);
break;
case 0x01: //Update gamemode
case 0x02: //Update latency
dataTypes.ReadNextVarInt(packetData);
break;
case 0x03: //Update display name
if (dataTypes.ReadNextBool(packetData))
{
dataTypes.ReadNextString(packetData);
}
break;
case 0x04: //Player Leave
handler.OnPlayerLeave(uuid);
break;
default:
//Unknown player list item type
break;
}
}
}
else //MC 1.7.X does not provide UUID in tab-list updates
{
string name = dataTypes.ReadNextString(packetData);
bool online = dataTypes.ReadNextBool(packetData);
short ping = dataTypes.ReadNextShort(packetData);
Guid FakeUUID = new Guid(MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(name)).Take(16).ToArray());
if (online)
{
handler.OnPlayerJoin(FakeUUID, name);
}
else
{
handler.OnPlayerLeave(FakeUUID);
}
}
return(true);
}
