helpy4/Minecraft-Console-Client
1
0
Fork 0
mirror of https://github.com/MCCTeam/Minecraft-Console-Client synced 2025-10-14 21:22:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
Minecraft-Console-Client/MinecraftClient/Protocol/Handlers/Protocol18.cs
breadbyte 08551097c6
Add Sentry Error Tracking (#2670) 
* Add Sentry Error Tracking

* Omit personally identifiable information and add additional sentry context

* Remove debug message

* Make sentry opt-out and add related notices and strings

Also add Minecraft Version to error context

* Update build to send release info to sentry

* Adjust sentry error tracking

- Send the user-friendly Minecraft Version in the error logs
- Capture exceptions in more parts of the application

We now capture exceptions from the following locations:
- Protocol18 (1.8+) Packet errors
- Errors during client initialization phase (When client is about to start, session keys are NEVER sent to sentry)

* Make Sentry DSN configurable and repository-specific

The Sentry DSN will automatically be filled out on the main repository through the Github Actions build.

* Update build-and-release.yml

Update sed command

* style: change variable name

nitpick, just to make it a little bit more descriptive

* Add Sentry branding in README.

* remove old code (merge conflict)
2024-06-22 06:41:13 +08:00

4584 lines
203 KiB
C#
Raw Blame History

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Net.Sockets;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using MinecraftClient.Crypto;
using MinecraftClient.Inventory;
using MinecraftClient.Inventory.ItemPalettes;
using MinecraftClient.Logger;
using MinecraftClient.Mapping;
using MinecraftClient.Mapping.BlockPalettes;
using MinecraftClient.Mapping.EntityPalettes;
using MinecraftClient.Protocol.Handlers.Forge;
using MinecraftClient.Protocol.Handlers.packet.s2c;
using MinecraftClient.Protocol.Handlers.PacketPalettes;
using MinecraftClient.Protocol.Message;
using MinecraftClient.Protocol.ProfileKey;
using MinecraftClient.Protocol.Session;
using MinecraftClient.Proxy;
using MinecraftClient.Scripting;
using Sentry;
using static MinecraftClient.Settings;
using static MinecraftClient.Settings.MainConfigHelper.MainConfig.GeneralConfig;
namespace MinecraftClient.Protocol.Handlers
{
/// <summary>
/// Implementation for Minecraft 1.8.X+ Protocols
/// </summary>
/// <remarks>
/// Typical update steps for implementing protocol changes for a new Minecraft version:
/// - Perform a diff between latest supported version in MCC and new stable version to support on https://wiki.vg/Protocol
/// - If there are any changes in packets implemented by MCC, add MCXXXVersion field below and implement new packet layouts
/// - Add the packet type palette for that Minecraft version. Please see PacketTypePalette.cs for more information
/// - Also see Material.cs and ItemType.cs for updating block and item data inside MCC
/// </remarks>
class Protocol18Handler : IMinecraftCom
{
internal const int MC_1_8_Version = 47;
internal const int MC_1_9_Version = 107;
internal const int MC_1_9_1_Version = 108;
internal const int MC_1_10_Version = 210;
internal const int MC_1_11_Version = 315;
internal const int MC_1_11_2_Version = 316;
internal const int MC_1_12_Version = 335;
internal const int MC_1_12_2_Version = 340;
internal const int MC_1_13_Version = 393;
internal const int MC_1_13_2_Version = 404;
internal const int MC_1_14_Version = 477;
internal const int MC_1_15_Version = 573;
internal const int MC_1_15_2_Version = 578;
internal const int MC_1_16_Version = 735;
internal const int MC_1_16_1_Version = 736;
internal const int MC_1_16_2_Version = 751;
internal const int MC_1_16_3_Version = 753;
internal const int MC_1_16_5_Version = 754;
internal const int MC_1_17_Version = 755;
internal const int MC_1_17_1_Version = 756;
internal const int MC_1_18_1_Version = 757;
internal const int MC_1_18_2_Version = 758;
internal const int MC_1_19_Version = 759;
internal const int MC_1_19_2_Version = 760;
internal const int MC_1_19_3_Version = 761;
internal const int MC_1_19_4_Version = 762;
internal const int MC_1_20_Version = 763;
internal const int MC_1_20_2_Version = 764;
internal const int MC_1_20_4_Version = 765;
private int compression_treshold = 0;
private int autocomplete_transaction_id = 0;
private readonly Dictionary<int, short> window_actions = new();
private CurrentState currentState = CurrentState.Login;
private readonly int protocolVersion;
private int currentDimension;
private bool isOnlineMode = false;
private readonly BlockingCollection<Tuple<int, Queue<byte>>> packetQueue = new();
private float LastYaw, LastPitch;
private long chunkBatchStartTime;
private double aggregatedNanosPerChunk = 2000000.0;
private int oldSamplesWeight = 1;
private bool receiveDeclareCommands = false, receivePlayerInfo = false;
private object MessageSigningLock = new();
private Guid chatUuid = Guid.NewGuid();
private int pendingAcknowledgments = 0, messageIndex = 0;
private LastSeenMessagesCollector lastSeenMessagesCollector;
private LastSeenMessageList.AcknowledgedMessage? lastReceivedMessage = null;
readonly Protocol18Forge pForge;
readonly Protocol18Terrain pTerrain;
readonly IMinecraftComHandler handler;
readonly EntityPalette entityPalette;
readonly EntityMetadataPalette entityMetadataPalette;
readonly ItemPalette itemPalette;
readonly PacketTypePalette packetPalette;
readonly SocketWrapper socketWrapper;
readonly DataTypes dataTypes;
Tuple<Thread, CancellationTokenSource>? netMain = null; // main thread
Tuple<Thread, CancellationTokenSource>? netReader = null; // reader thread
readonly ILogger log;
readonly RandomNumberGenerator randomGen;
public Protocol18Handler(TcpClient Client, int protocolVersion, IMinecraftComHandler handler,
ForgeInfo? forgeInfo)
{
ConsoleIO.SetAutoCompleteEngine(this);
ChatParser.InitTranslations();
socketWrapper = new SocketWrapper(Client);
dataTypes = new DataTypes(protocolVersion);
this.protocolVersion = protocolVersion;
this.handler = handler;
pForge = new Protocol18Forge(forgeInfo, protocolVersion, dataTypes, this, handler);
pTerrain = new Protocol18Terrain(protocolVersion, dataTypes, handler);
packetPalette = new PacketTypeHandler(protocolVersion, forgeInfo != null).GetTypeHandler();
log = handler.GetLogger();
randomGen = RandomNumberGenerator.Create();
lastSeenMessagesCollector = protocolVersion >= MC_1_19_3_Version ? new(20) : new(5);
chunkBatchStartTime = GetNanos();
if (handler.GetTerrainEnabled() && protocolVersion > MC_1_20_4_Version)
{
log.Error($"§c{Translations.extra_terrainandmovement_disabled}");
handler.SetTerrainEnabled(false);
}
if (handler.GetInventoryEnabled() &&
protocolVersion is < MC_1_8_Version or > MC_1_20_4_Version)
{
log.Error($"§c{Translations.extra_inventory_disabled}");
handler.SetInventoryEnabled(false);
}
if (handler.GetEntityHandlingEnabled() &&
protocolVersion is < MC_1_8_Version or > MC_1_20_4_Version)
{
log.Error($"§c{Translations.extra_entity_disabled}");
handler.SetEntityHandlingEnabled(false);
}
Block.Palette = protocolVersion switch
{
// Block palette
> MC_1_20_4_Version when handler.GetTerrainEnabled() =>
throw new NotImplementedException(Translations.exception_palette_block),
>= MC_1_20_4_Version => new Palette1204(),
>= MC_1_20_Version => new Palette120(),
MC_1_19_4_Version => new Palette1194(),
MC_1_19_3_Version => new Palette1193(),
>= MC_1_19_Version => new Palette119(),
>= MC_1_17_Version => new Palette117(),
>= MC_1_16_Version => new Palette116(),
>= MC_1_15_Version => new Palette115(),
>= MC_1_14_Version => new Palette114(),
>= MC_1_13_Version => new Palette113(),
_ => new Palette112()
};
entityPalette = protocolVersion switch
{
// Entity palette
> MC_1_20_4_Version when handler.GetEntityHandlingEnabled() =>
throw new NotImplementedException(Translations.exception_palette_entity),
>= MC_1_20_4_Version => new EntityPalette1204(),
>= MC_1_20_Version => new EntityPalette120(),
MC_1_19_4_Version => new EntityPalette1194(),
MC_1_19_3_Version => new EntityPalette1193(),
>= MC_1_19_Version => new EntityPalette119(),
>= MC_1_17_Version => new EntityPalette117(),
>= MC_1_16_2_Version => new EntityPalette1162(),
>= MC_1_16_Version => new EntityPalette1161(),
>= MC_1_15_Version => new EntityPalette115(),
>= MC_1_14_Version => new EntityPalette114(),
>= MC_1_13_Version => new EntityPalette113(),
>= MC_1_12_Version => new EntityPalette112(),
_ => new EntityPalette18()
};
entityMetadataPalette = EntityMetadataPalette.GetPalette(protocolVersion);
itemPalette = protocolVersion switch
{
// Item palette
> MC_1_20_4_Version when handler.GetInventoryEnabled() =>
throw new NotImplementedException(Translations.exception_palette_item),
>= MC_1_20_4_Version => new ItemPalette1204(),
>= MC_1_20_Version => new ItemPalette120(),
MC_1_19_4_Version => new ItemPalette1194(),
MC_1_19_3_Version => new ItemPalette1193(),
>= MC_1_19_Version => new ItemPalette119(),
>= MC_1_18_1_Version => new ItemPalette118(),
>= MC_1_17_Version => new ItemPalette117(),
>= MC_1_16_2_Version => new ItemPalette1162(),
>= MC_1_16_1_Version => new ItemPalette1161(),
>= MC_1_15_Version => new ItemPalette115(),
>= MC_1_12_Version => new ItemPalette112(),
>= MC_1_11_Version => new ItemPalette111(),
>= MC_1_10_Version => new ItemPalette110(),
>= MC_1_9_Version => new ItemPalette19(),
_ => new ItemPalette18()
};
ChatParser.ChatId2Type = this.protocolVersion switch
{
// MessageType
// You can find it in https://wiki.vg/Protocol#Player_Chat_Message or /net/minecraft/network/message/MessageType.java
>= MC_1_19_2_Version => new()
{
{ 0, ChatParser.MessageType.CHAT },
{ 1, ChatParser.MessageType.SAY_COMMAND },
{ 2, ChatParser.MessageType.MSG_COMMAND_INCOMING },
{ 3, ChatParser.MessageType.MSG_COMMAND_OUTGOING },
{ 4, ChatParser.MessageType.TEAM_MSG_COMMAND_INCOMING },
{ 5, ChatParser.MessageType.TEAM_MSG_COMMAND_OUTGOING },
{ 6, ChatParser.MessageType.EMOTE_COMMAND },
},
MC_1_19_Version => new()
{
{ 0, ChatParser.MessageType.CHAT },
{ 1, ChatParser.MessageType.RAW_MSG },
{ 2, ChatParser.MessageType.RAW_MSG },
{ 3, ChatParser.MessageType.SAY_COMMAND },
{ 4, ChatParser.MessageType.MSG_COMMAND_INCOMING },
{ 5, ChatParser.MessageType.TEAM_MSG_COMMAND_INCOMING },
{ 6, ChatParser.MessageType.EMOTE_COMMAND },
{ 7, ChatParser.MessageType.RAW_MSG },
},
_ => ChatParser.ChatId2Type
};
}
/// <summary>
/// Separate thread. Network reading loop.
/// </summary>
private void Updater(object? o)
{
var cancelToken = (CancellationToken)o!;
if (cancelToken.IsCancellationRequested)
return;
try
{
Stopwatch stopWatch = new();
while (!packetQueue.IsAddingCompleted)
{
cancelToken.ThrowIfCancellationRequested();
handler.OnUpdate();
stopWatch.Restart();
while (packetQueue.TryTake(out var packetInfo))
{
var (packetId, packetData) = packetInfo;
HandlePacket(packetId, packetData);
if (stopWatch.Elapsed.Milliseconds < 100) continue;
handler.OnUpdate();
stopWatch.Restart();
}
var sleepLength = 100 - stopWatch.Elapsed.Milliseconds;
if (sleepLength > 0)
Thread.Sleep(sleepLength);
}
}
catch (ObjectDisposedException)
{
}
catch (OperationCanceledException)
{
}
catch (NullReferenceException)
{
}
if (cancelToken.IsCancellationRequested)
return;
handler.OnConnectionLost(ChatBot.DisconnectReason.ConnectionLost, "");
}
/// <summary>
/// Read and decompress packets.
/// </summary>
internal void PacketReader(object? o)
{
var cancelToken = (CancellationToken)o!;
while (socketWrapper.IsConnected() && !cancelToken.IsCancellationRequested)
{
try
{
while (socketWrapper.HasDataAvailable())
{
packetQueue.Add(ReadNextPacket(), cancelToken);
if (cancelToken.IsCancellationRequested)
break;
}
}
catch (OperationCanceledException)
{
break;
}
catch (System.IO.IOException)
{
break;
}
catch (SocketException)
{
break;
}
catch (NullReferenceException)
{
break;
}
catch (Ionic.Zlib.ZlibException)
{
break;
}
if (cancelToken.IsCancellationRequested)
break;
Thread.Sleep(10);
}
packetQueue.CompleteAdding();
}
/// <summary>
/// Read the next packet from the network
/// </summary>
/// <param name="packetId">will contain packet ID</param>
/// <param name="packetData">will contain raw packet Data</param>
internal Tuple<int, Queue<byte>> ReadNextPacket()
{
var size = dataTypes.ReadNextVarIntRAW(socketWrapper); //Packet size
Queue<byte> packetData = new(socketWrapper.ReadDataRAW(size)); //Packet contents
//Handle packet decompression
if (protocolVersion >= MC_1_8_Version
&& compression_treshold > 0)
{
var sizeUncompressed = dataTypes.ReadNextVarInt(packetData);
if (sizeUncompressed != 0) // != 0 means compressed, let's decompress
{
var toDecompress = packetData.ToArray();
var uncompressed = ZlibUtils.Decompress(toDecompress, sizeUncompressed);
packetData = new Queue<byte>(uncompressed);
}
}
var packetId = dataTypes.ReadNextVarInt(packetData); // Packet ID
if (handler.GetNetworkPacketCaptureEnabled())
handler.OnNetworkPacket(packetId, packetData.ToList(), currentState == CurrentState.Login, true);
return new(packetId, packetData);
}
/// <summary>
/// Handle the given packet
/// </summary>
/// <param name="packetId">Packet ID</param>
/// <param name="packetData">Packet contents</param>
/// <returns>TRUE if the packet was processed, FALSE if ignored or unknown</returns>
internal bool HandlePacket(int packetId, Queue<byte> packetData)
{
// This copy is necessary because by the time we get to the catch block,
// the packetData queue will have been processed and the data will be lost
var _copy = packetData.ToArray();
try
{
switch (currentState)
{
// https://wiki.vg/Protocol#Login
case CurrentState.Login:
switch (packetId)
{
// Set Compression
case 0x03:
if (protocolVersion >= MC_1_8_Version)
compression_treshold = dataTypes.ReadNextVarInt(packetData);
break;
// Login Plugin Request
case 0x04:
var messageId = dataTypes.ReadNextVarInt(packetData);
var channel = dataTypes.ReadNextString(packetData);
List<byte> responseData = new();
var understood = pForge.HandleLoginPluginRequest(channel, packetData, ref responseData);
SendLoginPluginResponse(messageId, understood, responseData.ToArray());
return understood;
// Ignore other packets at this stage
default:
return true;
}
break;
// https://wiki.vg/Protocol#Configuration
case CurrentState.Configuration:
switch (packetPalette.GetIncomingConfigurationTypeById(packetId))
{
case ConfigurationPacketTypesIn.Disconnect:
handler.OnConnectionLost(ChatBot.DisconnectReason.InGameKick,
dataTypes.ReadNextChat(packetData));
return false;
case ConfigurationPacketTypesIn.FinishConfiguration:
currentState = CurrentState.Play;
SendPacket(ConfigurationPacketTypesOut.FinishConfiguration, new List<byte>());
break;
case ConfigurationPacketTypesIn.KeepAlive:
SendPacket(ConfigurationPacketTypesOut.KeepAlive, packetData);
break;
case ConfigurationPacketTypesIn.Ping:
SendPacket(ConfigurationPacketTypesOut.Pong, packetData);
break;
case ConfigurationPacketTypesIn.RegistryData:
var registryCodec = dataTypes.ReadNextNbt(packetData);
ChatParser.ReadChatType(registryCodec);
if (handler.GetTerrainEnabled())
World.StoreDimensionList(registryCodec);
break;
case ConfigurationPacketTypesIn.RemoveResourcePack:
if (dataTypes.ReadNextBool(packetData)) // Has UUID
dataTypes.ReadNextUUID(packetData); // UUID
break;
case ConfigurationPacketTypesIn.ResourcePack:
HandleResourcePackPacket(packetData);
break;
// Ignore other packets at this stage
default:
return true;
}
break;
// https://wiki.vg/Protocol#Play
case CurrentState.Play:
return HandlePlayPackets(packetId, packetData);
default:
return true;
}
}
catch (Exception innerException)
{
if (innerException is ThreadAbortException || innerException is SocketException ||
innerException.InnerException is SocketException)
throw; //Thread abort or Connection lost rather than invalid data
var exception = new System.IO.InvalidDataException(
string.Format(Translations.exception_packet_process,
packetPalette.GetIncomingTypeById(packetId),
packetId,
protocolVersion,
currentState == CurrentState.Login,
innerException.GetType()),
innerException);
SentrySdk.AddBreadcrumb(new Breadcrumb("S -> C Packet", "network", new Dictionary<string, string>()
{
{ "Packet ID", packetId.ToString() },
{ "Packet Type ", packetPalette.GetIncomingTypeById(packetId).ToString() },
{ "Protocol Version", protocolVersion.ToString() },
{ "Minecraft Version", ProtocolHandler.ProtocolVersion2MCVer(protocolVersion) },
{ "Current State", currentState.ToString() },
{ "Packet Data", string.Join(" ", _copy.Select(b => b.ToString("X2"))) },
{ "Inner Exception", innerException.GetType().ToString() }
}, "packet", BreadcrumbLevel.Error));
SentrySdk.CaptureException(exception);
throw exception;
}
return true;
}
public void HandleResourcePackPacket(Queue<byte> packetData)
{
var uuid = Guid.Empty;
if (protocolVersion >= MC_1_20_4_Version)
uuid = dataTypes.ReadNextUUID(packetData);
var url = dataTypes.ReadNextString(packetData);
var hash = dataTypes.ReadNextString(packetData);
if (protocolVersion >= MC_1_17_Version)
{
dataTypes.ReadNextBool(packetData); // Forced
if (dataTypes.ReadNextBool(packetData)) // Has Prompt Message
dataTypes.ReadNextChat(packetData); // Prompt Message
}
// Some server plugins may send invalid resource packs to probe the client and we need to ignore them (issue #1056)
if (!url.StartsWith("http") &&
hash.Length != 40) // Some server may have null hash value
return;
//Send back "accepted" and "successfully loaded" responses for plugins or server config making use of resource pack mandatory
var responseHeader =
protocolVersion < MC_1_10_Version // After 1.10, the MC does not include resource pack hash in responses
? dataTypes.ConcatBytes(DataTypes.GetVarInt(hash.Length), Encoding.UTF8.GetBytes(hash))
: Array.Empty<byte>();
var basePacketData = protocolVersion >= MC_1_20_4_Version && uuid != Guid.Empty
? dataTypes.ConcatBytes(responseHeader, DataTypes.GetUUID(uuid))
: responseHeader;
var acceptedResourcePackData = dataTypes.ConcatBytes(basePacketData, DataTypes.GetVarInt(3));
var loadedResourcePackData = dataTypes.ConcatBytes(basePacketData, DataTypes.GetVarInt(0));
if (currentState == CurrentState.Configuration)
{
SendPacket(ConfigurationPacketTypesOut.ResourcePackResponse, acceptedResourcePackData); // Accepted
SendPacket(ConfigurationPacketTypesOut.ResourcePackResponse,
loadedResourcePackData); // Successfully loaded
}
else
{
SendPacket(PacketTypesOut.ResourcePackStatus, acceptedResourcePackData); // Accepted
SendPacket(PacketTypesOut.ResourcePackStatus, loadedResourcePackData); // Successfully loaded
}
}
private bool HandlePlayPackets(int packetId, Queue<byte> packetData)
{
switch (packetPalette.GetIncomingTypeById(packetId))
{
case PacketTypesIn.KeepAlive: // Keep Alive (Play)
SendPacket(PacketTypesOut.KeepAlive, packetData);
handler.OnServerKeepAlive();
break;
case PacketTypesIn.Ping:
SendPacket(PacketTypesOut.Pong, packetData);
break;
case PacketTypesIn.JoinGame:
// Temporary fix
log.Debug("Receive JoinGame");
receiveDeclareCommands = receivePlayerInfo = false;
messageIndex = 0;
pendingAcknowledgments = 0;
lastReceivedMessage = null;
lastSeenMessagesCollector = protocolVersion >= MC_1_19_3_Version ? new(20) : new(5);
handler.OnGameJoined(isOnlineMode);
var playerEntityId = dataTypes.ReadNextInt(packetData);
handler.OnReceivePlayerEntityID(playerEntityId);
if (protocolVersion >= MC_1_16_2_Version)
dataTypes.ReadNextBool(packetData); // Is hardcore - 1.16.2 and above
if (protocolVersion < MC_1_20_2_Version)
handler.OnGamemodeUpdate(Guid.Empty, dataTypes.ReadNextByte(packetData));
if (protocolVersion >= MC_1_16_Version)
{
if (protocolVersion < MC_1_20_2_Version)
dataTypes.ReadNextByte(packetData); // Previous Gamemode - 1.16 - 1.20.2
var worldCount =
dataTypes.ReadNextVarInt(
packetData); // Dimension Count (World Count) - 1.16 and above
for (var i = 0; i < worldCount; i++)
dataTypes.ReadNextString(
packetData); // Dimension Names (World Names) - 1.16 and above
if (protocolVersion < MC_1_20_2_Version)
{
var registryCodec =
dataTypes.ReadNextNbt(
packetData); // Registry Codec (Dimension Codec) - 1.16 and above
if (protocolVersion >= MC_1_19_Version)
ChatParser.ReadChatType(registryCodec);
if (handler.GetTerrainEnabled())
World.StoreDimensionList(registryCodec);
}
}
if (protocolVersion < MC_1_20_2_Version)
{
// Current dimension
// String: 1.19 and above
// NBT Tag Compound: [1.16.2 to 1.18.2]
// String identifier: 1.16 and 1.16.1
// varInt: [1.9.1 to 1.15.2]
// byte: below 1.9.1
string? dimensionTypeName = null;
Dictionary<string, object>? dimensionType = null;
switch (protocolVersion)
{
case >= MC_1_16_Version:
{
switch (protocolVersion)
{
case >= MC_1_19_Version:
dimensionTypeName =
dataTypes.ReadNextString(packetData); // Dimension Type: Identifier
break;
case >= MC_1_16_2_Version:
dimensionType =
dataTypes.ReadNextNbt(
packetData); // Dimension Type: NBT Tag Compound
break;
default:
dataTypes.ReadNextString(packetData);
break;
}
currentDimension = 0;
break;
}
case >= MC_1_9_1_Version:
currentDimension = dataTypes.ReadNextInt(packetData);
break;
default:
currentDimension = (sbyte)dataTypes.ReadNextByte(packetData);
break;
}
switch (protocolVersion)
{
case < MC_1_14_Version:
dataTypes.ReadNextByte(packetData); // Difficulty - 1.13 and below
break;
case >= MC_1_16_Version:
{
var dimensionName =
dataTypes.ReadNextString(
packetData); // Dimension Name (World Name) - 1.16 and above
if (handler.GetTerrainEnabled())
{
switch (protocolVersion)
{
case >= MC_1_16_2_Version and <= MC_1_18_2_Version:
World.StoreOneDimension(dimensionName, dimensionType!);
World.SetDimension(dimensionName);
break;
default:
World.SetDimension(dimensionTypeName!);
break;
}
}
break;
}
}
}
if (protocolVersion is >= MC_1_15_Version and < MC_1_20_2_Version)
dataTypes.ReadNextLong(packetData); // Hashed world seed - 1.15 - 1.20.2
if (protocolVersion >= MC_1_16_2_Version)
dataTypes.ReadNextVarInt(packetData); // Max Players - 1.16.2 and above
else
dataTypes.ReadNextByte(packetData); // Max Players - 1.16.1 and below
if (protocolVersion < MC_1_16_Version)
dataTypes.SkipNextString(packetData); // Level Type - 1.15 and below
if (protocolVersion >= MC_1_14_Version)
dataTypes.ReadNextVarInt(packetData); // View distance - 1.14 and above
if (protocolVersion >= MC_1_18_1_Version)
dataTypes.ReadNextVarInt(packetData); // Simulation Distance - 1.18 and above
if (protocolVersion >= MC_1_8_Version)
dataTypes.ReadNextBool(packetData); // Reduced debug info - 1.8 and above
if (protocolVersion >= MC_1_15_Version)
dataTypes.ReadNextBool(packetData); // Enable respawn screen - 1.15 and above
if (protocolVersion < MC_1_20_2_Version)
{
if (protocolVersion >= MC_1_16_Version)
{
dataTypes.ReadNextBool(packetData); // Is Debug - 1.16 and 1.20.2
dataTypes.ReadNextBool(packetData); // Is Flat - 1.16 and 1.20.2
}
if (protocolVersion >= MC_1_19_Version)
{
if (dataTypes.ReadNextBool(packetData)) // Has death location
{
dataTypes.SkipNextString(packetData); // Death dimension name: Identifier
dataTypes.ReadNextLocation(packetData); // Death location
}
}
if (protocolVersion >= MC_1_20_Version)
dataTypes.ReadNextVarInt(packetData); // Portal Cooldown - 1.20 and above
}
else
{
dataTypes.ReadNextBool(packetData); // Do limited crafting
var dimensionTypeName =
dataTypes.ReadNextString(packetData); // Dimension Type: Identifier
dataTypes.ReadNextString(packetData); // Dimension Name (World Name) - 1.16 and above
if (handler.GetTerrainEnabled())
World.SetDimension(dimensionTypeName);
dataTypes.ReadNextLong(packetData); // Hashed world seed
handler.OnGamemodeUpdate(Guid.Empty, dataTypes.ReadNextByte(packetData));
dataTypes.ReadNextByte(packetData); // Previous Gamemode
dataTypes.ReadNextBool(packetData); // Is Debug
dataTypes.ReadNextBool(packetData); // Is Flat
var hasDeathLocation = dataTypes.ReadNextBool(packetData); // Has death location
if (hasDeathLocation)
{
dataTypes.SkipNextString(packetData); // Death dimension name: Identifier
dataTypes.ReadNextLocation(packetData); // Death location
}
dataTypes.ReadNextVarInt(packetData); // Portal Cooldown
}
break;
case PacketTypesIn.SpawnPainting: // Just skip, no need for this
return true;
case PacketTypesIn.DeclareCommands:
if (protocolVersion >= MC_1_19_Version)
{
log.Debug("Receive DeclareCommands");
DeclareCommands.Read(dataTypes, packetData, protocolVersion);
receiveDeclareCommands = true;
if (receivePlayerInfo)
handler.SetCanSendMessage(true);
}
break;
case PacketTypesIn.ChatMessage:
var messageType = 0;
if (protocolVersion <= MC_1_18_2_Version) // 1.18 and bellow
{
var message = dataTypes.ReadNextString(packetData);
Guid senderUuid;
if (protocolVersion >= MC_1_8_Version)
{
//Hide system messages or xp bar messages?
messageType = dataTypes.ReadNextByte(packetData);
if (messageType == 1 && !Config.Main.Advanced.ShowSystemMessages
|| messageType == 2 && !Config.Main.Advanced.ShowSystemMessages)
break;
senderUuid = protocolVersion >= MC_1_16_5_Version
? dataTypes.ReadNextUUID(packetData)
: Guid.Empty;
}
else
senderUuid = Guid.Empty;
handler.OnTextReceived(new(message, null, true, messageType, senderUuid));
}
else if (protocolVersion == MC_1_19_Version) // 1.19
{
var signedChat = dataTypes.ReadNextString(packetData);
var hasUnsignedChatContent = dataTypes.ReadNextBool(packetData);
var unsignedChatContent = hasUnsignedChatContent ? dataTypes.ReadNextString(packetData) : null;
messageType = dataTypes.ReadNextVarInt(packetData);
if (messageType == 1 && !Config.Main.Advanced.ShowSystemMessages
|| messageType == 2 && !Config.Main.Advanced.ShowXPBarMessages)
break;
var senderUuid = dataTypes.ReadNextUUID(packetData);
var senderDisplayName = ChatParser.ParseText(dataTypes.ReadNextString(packetData));
var hasSenderTeamName = dataTypes.ReadNextBool(packetData);
var senderTeamName = hasSenderTeamName
? ChatParser.ParseText(dataTypes.ReadNextString(packetData))
: null;
var timestamp = dataTypes.ReadNextLong(packetData);
var salt = dataTypes.ReadNextLong(packetData);
var messageSignature = dataTypes.ReadNextByteArray(packetData);
bool verifyResult;
if (!isOnlineMode)
verifyResult = false;
else if (senderUuid == handler.GetUserUuid())
verifyResult = true;
else
{
var player = handler.GetPlayerInfo(senderUuid);
verifyResult = player != null && player.VerifyMessage(signedChat, timestamp, salt,
ref messageSignature);
}
ChatMessage chat = new(signedChat, true, messageType, senderUuid, unsignedChatContent,
senderDisplayName, senderTeamName, timestamp, messageSignature, verifyResult);
handler.OnTextReceived(chat);
}
else if (protocolVersion == MC_1_19_2_Version)
{
// 1.19.1 - 1.19.2
var precedingSignature = dataTypes.ReadNextBool(packetData)
? dataTypes.ReadNextByteArray(packetData)
: null;
var senderUuid = dataTypes.ReadNextUUID(packetData);
var headerSignature = dataTypes.ReadNextByteArray(packetData);
var signedChat = dataTypes.ReadNextString(packetData);
var decorated = dataTypes.ReadNextBool(packetData)
? dataTypes.ReadNextString(packetData)
: null;
var timestamp = dataTypes.ReadNextLong(packetData);
var salt = dataTypes.ReadNextLong(packetData);
var lastSeenMessageListLen = dataTypes.ReadNextVarInt(packetData);
var lastSeenMessageList =
new LastSeenMessageList.AcknowledgedMessage[lastSeenMessageListLen];
for (var i = 0; i < lastSeenMessageListLen; ++i)
{
var user = dataTypes.ReadNextUUID(packetData);
var lastSignature = dataTypes.ReadNextByteArray(packetData);
lastSeenMessageList[i] = new(user, lastSignature, true);
}
LastSeenMessageList lastSeenMessages = new(lastSeenMessageList);
var unsignedChatContent = dataTypes.ReadNextBool(packetData)
? dataTypes.ReadNextString(packetData)
: null;
var filterEnum = (MessageFilterType)dataTypes.ReadNextVarInt(packetData);
if (filterEnum == MessageFilterType.PartiallyFiltered)
dataTypes.ReadNextULongArray(packetData);
var chatTypeId = dataTypes.ReadNextVarInt(packetData);
var chatName = dataTypes.ReadNextString(packetData);
var targetName = dataTypes.ReadNextBool(packetData)
? dataTypes.ReadNextString(packetData)
: null;
var chatInfo = Json.ParseJson(chatName).Properties;
var senderDisplayName = chatInfo != null && chatInfo.Count > 0
? (chatInfo.ContainsKey("insertion") ? chatInfo["insertion"] : chatInfo["text"])
.StringValue
: "";
string? senderTeamName = null;
var messageTypeEnum =
ChatParser.ChatId2Type!.GetValueOrDefault(chatTypeId, ChatParser.MessageType.CHAT);
if (targetName != null &&
(messageTypeEnum == ChatParser.MessageType.TEAM_MSG_COMMAND_INCOMING ||
messageTypeEnum == ChatParser.MessageType.TEAM_MSG_COMMAND_OUTGOING))
senderTeamName = Json.ParseJson(targetName).Properties["with"].DataArray[0]
.Properties["text"].StringValue;
if (string.IsNullOrWhiteSpace(senderDisplayName))
{
var player = handler.GetPlayerInfo(senderUuid);
if (player != null && (player.DisplayName != null || player is { Name: not null }) &&
string.IsNullOrWhiteSpace(senderDisplayName))
{
senderDisplayName = ChatParser.ParseText(player.DisplayName ?? player.Name);
if (string.IsNullOrWhiteSpace(senderDisplayName))
senderDisplayName = player.DisplayName ?? player.Name;
else
senderDisplayName += "§r";
}
}
bool verifyResult;
if (!isOnlineMode)
verifyResult = false;
else if (senderUuid == handler.GetUserUuid())
verifyResult = true;
else
{
var player = handler.GetPlayerInfo(senderUuid);
if (player == null || !player.IsMessageChainLegal())
verifyResult = false;
else
{
var lastVerifyResult = player.IsMessageChainLegal();
verifyResult = player.VerifyMessage(signedChat, timestamp, salt,
ref headerSignature, ref precedingSignature, lastSeenMessages);
if (lastVerifyResult && !verifyResult)
log.Warn(string.Format(Translations.chat_message_chain_broken,
senderDisplayName));
}
}
ChatMessage chat = new(signedChat, false, chatTypeId, senderUuid, unsignedChatContent,
senderDisplayName, senderTeamName, timestamp, headerSignature, verifyResult);
if (isOnlineMode && !chat.LacksSender())
Acknowledge(chat);
handler.OnTextReceived(chat);
}
else if (protocolVersion >= MC_1_19_3_Version)
{
// 1.19.3+
// Header section
// net.minecraft.network.packet.s2c.play.ChatMessageS2CPacket#write
var senderUuid = dataTypes.ReadNextUUID(packetData);
var index = dataTypes.ReadNextVarInt(packetData);
// Signature is fixed size of 256 bytes
var messageSignature = dataTypes.ReadNextBool(packetData)
? dataTypes.ReadNextByteArray(packetData, 256)
: null;
// Body
// net.minecraft.network.message.MessageBody.Serialized#write
var message = dataTypes.ReadNextString(packetData);
var timestamp = dataTypes.ReadNextLong(packetData);
var salt = dataTypes.ReadNextLong(packetData);
// Previous Messages
// net.minecraft.network.message.LastSeenMessageList.Indexed#write
// net.minecraft.network.message.MessageSignatureData.Indexed#write
var totalPreviousMessages = dataTypes.ReadNextVarInt(packetData);
var previousMessageSignatures = new Tuple<int, byte[]?>[totalPreviousMessages];
for (var i = 0; i < totalPreviousMessages; i++)
{
// net.minecraft.network.message.MessageSignatureData.Indexed#fromBuf
var messageId = dataTypes.ReadNextVarInt(packetData) - 1;
if (messageId == -1)
previousMessageSignatures[i] = new Tuple<int, byte[]?>(messageId,
dataTypes.ReadNextByteArray(packetData, 256));
else
previousMessageSignatures[i] = new Tuple<int, byte[]?>(messageId, null);
}
// Other
var unsignedChatContent = dataTypes.ReadNextBool(packetData)
? dataTypes.ReadNextChat(packetData)
: null;
var filterType = (MessageFilterType)dataTypes.ReadNextVarInt(packetData);
if (filterType == MessageFilterType.PartiallyFiltered)
dataTypes.ReadNextULongArray(packetData);
// Network Target
// net.minecraft.network.message.MessageType.Serialized#write
var chatTypeId = dataTypes.ReadNextVarInt(packetData);
var chatName = dataTypes.ReadNextChat(packetData);
var targetName = dataTypes.ReadNextBool(packetData)
? dataTypes.ReadNextChat(packetData)
: null;
var messageTypeEnum =
ChatParser.ChatId2Type!.GetValueOrDefault(chatTypeId, ChatParser.MessageType.CHAT);
//var chatInfo = Json.ParseJson(targetName ?? chatName).Properties;
var senderDisplayName = chatName;
string? senderTeamName = targetName;
if (string.IsNullOrWhiteSpace(senderDisplayName))
{
var player = handler.GetPlayerInfo(senderUuid);
if (player != null && (player.DisplayName != null || player.Name != null) &&
string.IsNullOrWhiteSpace(senderDisplayName))
{
senderDisplayName = player.DisplayName ?? player.Name;
if (string.IsNullOrWhiteSpace(senderDisplayName))
senderDisplayName = player.DisplayName ?? player.Name;
else
senderDisplayName += "§r";
}
}
bool verifyResult;
if (!isOnlineMode || messageSignature == null)
verifyResult = false;
else
{
if (senderUuid == handler.GetUserUuid())
verifyResult = true;
else
{
var player = handler.GetPlayerInfo(senderUuid);
if (player == null || !player.IsMessageChainLegal())
verifyResult = false;
else
{
verifyResult = player.VerifyMessage(message, senderUuid, player.ChatUuid,
index, timestamp, salt, ref messageSignature,
previousMessageSignatures);
}
}
}
ChatMessage chat = new(message, false, chatTypeId, senderUuid, unsignedChatContent,
senderDisplayName, senderTeamName, timestamp, messageSignature, verifyResult);
lock (MessageSigningLock)
Acknowledge(chat);
handler.OnTextReceived(chat);
}
break;
case PacketTypesIn.ChunkBatchFinished:
var batchSize = dataTypes.ReadNextVarInt(packetData); // Number of chunks received
if (batchSize > 0)
{
var d = GetNanos() - chunkBatchStartTime;
var d2 = d / (double)batchSize;
var d3 = Math.Clamp(d2, aggregatedNanosPerChunk / 3.0, aggregatedNanosPerChunk * 3.0);
aggregatedNanosPerChunk =
(aggregatedNanosPerChunk * oldSamplesWeight + d3) / (oldSamplesWeight + 1);
oldSamplesWeight = Math.Min(49, oldSamplesWeight + 1);
}
SendChunkBatchReceived((float)(7000000.0 / aggregatedNanosPerChunk));
break;
case PacketTypesIn.ChunkBatchStarted:
chunkBatchStartTime = GetNanos();
break;
case PacketTypesIn.StartConfiguration:
currentState = CurrentState.Configuration;
SendAcknowledgeConfiguration();
break;
case PacketTypesIn.HideMessage:
var hideMessageSignature = dataTypes.ReadNextByteArray(packetData);
ConsoleIO.WriteLine(
$"HideMessage was not processed! (SigLen={hideMessageSignature.Length})");
break;
case PacketTypesIn.SystemChat:
var systemMessage = dataTypes.ReadNextChat(packetData);
if (protocolVersion >= MC_1_19_3_Version)
{
var isOverlay = dataTypes.ReadNextBool(packetData);
if (isOverlay)
{
if (!Config.Main.Advanced.ShowXPBarMessages)
break;
}
else
{
if (!Config.Main.Advanced.ShowSystemMessages)
break;
}
handler.OnTextReceived(new(systemMessage, null, false, -1, Guid.Empty, true));
}
else
{
var msgType = dataTypes.ReadNextVarInt(packetData);
if (msgType == 1 && !Config.Main.Advanced.ShowSystemMessages)
break;
handler.OnTextReceived(new(systemMessage, null, true, msgType, Guid.Empty, true));
}
break;
case PacketTypesIn.ProfilelessChatMessage:
var message_ = dataTypes.ReadNextChat(packetData);
var messageType_ = dataTypes.ReadNextVarInt(packetData);
var messageName = dataTypes.ReadNextChat(packetData);
var targetName_ = dataTypes.ReadNextBool(packetData)
? dataTypes.ReadNextChat(packetData)
: null;
ChatMessage profilelessChat = new(message_, targetName_ ?? messageName, false, messageType_,
Guid.Empty, true);
profilelessChat.isSenderJson = false;
handler.OnTextReceived(profilelessChat);
break;
case PacketTypesIn.CombatEvent:
// 1.8 - 1.16.5
if (protocolVersion is >= MC_1_8_Version and <= MC_1_16_5_Version)
{
var eventType = (CombatEventType)dataTypes.ReadNextVarInt(packetData);
if (eventType == CombatEventType.EntityDead)
{
dataTypes.SkipNextVarInt(packetData);
handler.OnPlayerKilled(
dataTypes.ReadNextInt(packetData),
ChatParser.ParseText(dataTypes.ReadNextString(packetData))
);
}
}
break;
case PacketTypesIn.DeathCombatEvent:
dataTypes.SkipNextVarInt(packetData);
handler.OnPlayerKilled(
protocolVersion >= MC_1_20_Version ? -1 : dataTypes.ReadNextInt(packetData),
ChatParser.ParseText(dataTypes.ReadNextChat(packetData))
);
break;
case PacketTypesIn.DamageEvent: // 1.19.4
if (handler.GetEntityHandlingEnabled() && protocolVersion >= MC_1_19_4_Version)
{
var entityId = dataTypes.ReadNextVarInt(packetData);
var sourceTypeId = dataTypes.ReadNextVarInt(packetData);
var sourceCauseId = dataTypes.ReadNextVarInt(packetData);
var sourceDirectId = dataTypes.ReadNextVarInt(packetData);
Location? sourcePosition;
if (dataTypes.ReadNextBool(packetData))
{
sourcePosition = new Location()
{
X = dataTypes.ReadNextDouble(packetData),
Y = dataTypes.ReadNextDouble(packetData),
Z = dataTypes.ReadNextDouble(packetData)
};
}
// TODO: Write a function to use this data ? But seems not too useful
}
break;
case PacketTypesIn.MessageHeader: // 1.19.2 only
if (protocolVersion == MC_1_19_2_Version)
{
var precedingSignature = dataTypes.ReadNextBool(packetData)
? dataTypes.ReadNextByteArray(packetData)
: null;
var senderUuid = dataTypes.ReadNextUUID(packetData);
var headerSignature = dataTypes.ReadNextByteArray(packetData);
var bodyDigest = dataTypes.ReadNextByteArray(packetData);
bool verifyResult;
if (!isOnlineMode)
verifyResult = false;
else if (senderUuid == handler.GetUserUuid())
verifyResult = true;
else
{
var player = handler.GetPlayerInfo(senderUuid);
if (player == null || !player.IsMessageChainLegal())
verifyResult = false;
else
{
var lastVerifyResult = player.IsMessageChainLegal();
verifyResult = player.VerifyMessageHead(ref precedingSignature,
ref headerSignature, ref bodyDigest);
if (lastVerifyResult && !verifyResult)
log.Warn(string.Format(Translations.chat_message_chain_broken,
player.Name));
}
}
}
break;
case PacketTypesIn.Respawn:
string? dimensionTypeNameRespawn = null;
Dictionary<string, object>? dimensionTypeRespawn = null;
if (protocolVersion >= MC_1_16_Version)
{
switch (protocolVersion)
{
case >= MC_1_19_Version:
dimensionTypeNameRespawn =
dataTypes.ReadNextString(packetData); // Dimension Type: Identifier
break;
case >= MC_1_16_2_Version:
dimensionTypeRespawn =
dataTypes.ReadNextNbt(packetData); // Dimension Type: NBT Tag Compound
break;
default:
dataTypes.ReadNextString(packetData);
break;
}
currentDimension = 0;
}
else
{
// 1.15 and below
currentDimension = dataTypes.ReadNextInt(packetData);
}
switch (protocolVersion)
{
case >= MC_1_16_Version:
{
var dimensionName =
dataTypes.ReadNextString(
packetData); // Dimension Name (World Name) - 1.16 and above
if (handler.GetTerrainEnabled())
{
switch (protocolVersion)
{
case >= MC_1_16_2_Version and <= MC_1_18_2_Version:
World.StoreOneDimension(dimensionName, dimensionTypeRespawn!);
World.SetDimension(dimensionName);
break;
case >= MC_1_19_Version:
World.SetDimension(dimensionTypeNameRespawn!);
break;
}
}
break;
}
case < MC_1_14_Version:
dataTypes.ReadNextByte(packetData); // Difficulty - 1.13 and below
break;
}
if (protocolVersion >= MC_1_15_Version)
dataTypes.ReadNextLong(packetData); // Hashed world seed - 1.15 and above
dataTypes.ReadNextByte(packetData); // Gamemode
switch (protocolVersion)
{
case >= MC_1_16_Version:
dataTypes.ReadNextByte(packetData); // Previous Game mode - 1.16 and above
break;
case < MC_1_16_Version:
dataTypes.SkipNextString(packetData); // Level Type - 1.15 and below
break;
}
if (protocolVersion >= MC_1_16_Version)
{
dataTypes.ReadNextBool(packetData); // Is Debug - 1.16 and above
dataTypes.ReadNextBool(packetData); // Is Flat - 1.16 and above
if (protocolVersion < MC_1_20_2_Version)
dataTypes.ReadNextBool(packetData); // Copy metadata (Data Kept) - 1.16 - 1.20.2
}
if (protocolVersion >= MC_1_19_Version)
{
if (dataTypes.ReadNextBool(packetData)) // Has death location
{
dataTypes.ReadNextString(packetData); // Death dimension name: Identifier
dataTypes.ReadNextLocation(packetData); // Death location
}
}
if (protocolVersion >= MC_1_20_Version)
dataTypes.ReadNextVarInt(packetData); // Portal Cooldown
if (protocolVersion >= MC_1_20_2_Version)
dataTypes.ReadNextBool(packetData); // Copy metadata (Data Kept) - 1.20.2 and above
handler.OnRespawn();
break;
case PacketTypesIn.PlayerPositionAndLook:
{
// These always need to be read, since we need the field after them for teleport confirm
var location = new Location(
dataTypes.ReadNextDouble(packetData), // X
dataTypes.ReadNextDouble(packetData), // Y
dataTypes.ReadNextDouble(packetData) // Z
);
var yaw = dataTypes.ReadNextFloat(packetData);
var pitch = dataTypes.ReadNextFloat(packetData);
var locMask = dataTypes.ReadNextByte(packetData);
// entity handling require player pos for distance calculating
if (handler.GetTerrainEnabled() || handler.GetEntityHandlingEnabled())
{
if (protocolVersion >= MC_1_8_Version)
{
var currentLocation = handler.GetCurrentLocation();
location.X = (locMask & 1 << 0) != 0 ? currentLocation.X + location.X : location.X;
location.Y = (locMask & 1 << 1) != 0 ? currentLocation.Y + location.Y : location.Y;
location.Z = (locMask & 1 << 2) != 0 ? currentLocation.Z + location.Z : location.Z;
}
}
if (protocolVersion >= MC_1_9_Version)
{
var teleportId = dataTypes.ReadNextVarInt(packetData);
if (teleportId < 0)
{
yaw = LastYaw;
pitch = LastPitch;
}
else
{
LastYaw = yaw;
LastPitch = pitch;
}
handler.UpdateLocation(location, yaw, pitch);
// Teleport confirm packet
SendPacket(PacketTypesOut.TeleportConfirm, DataTypes.GetVarInt(teleportId));
if (Config.Main.Advanced.TemporaryFixBadpacket)
{
SendLocationUpdate(location, true, yaw, pitch, true);
if (teleportId == 1)
SendLocationUpdate(location, true, yaw, pitch, true);
}
}
else
{
handler.UpdateLocation(location, yaw, pitch);
LastYaw = yaw;
LastPitch = pitch;
}
if (protocolVersion is >= MC_1_17_Version and < MC_1_19_4_Version)
dataTypes.ReadNextBool(packetData); // Dismount Vehicle - 1.17 to 1.19.3
}
break;
case PacketTypesIn.ChunkData:
if (handler.GetTerrainEnabled())
{
Interlocked.Increment(ref handler.GetWorld().chunkCnt);
Interlocked.Increment(ref handler.GetWorld().chunkLoadNotCompleted);
var chunkX = dataTypes.ReadNextInt(packetData);
var chunkZ = dataTypes.ReadNextInt(packetData);
if (protocolVersion >= MC_1_17_Version)
{
ulong[]? verticalStripBitmask = null;
if (protocolVersion is MC_1_17_Version or MC_1_17_1_Version)
verticalStripBitmask =
dataTypes.ReadNextULongArray(
packetData); // Bit Mask Length and Primary Bit Mask
dataTypes.ReadNextNbt(packetData); // Heightmaps
if (protocolVersion is MC_1_17_Version or MC_1_17_1_Version)
{
var biomesLength = dataTypes.ReadNextVarInt(packetData); // Biomes length
for (var i = 0; i < biomesLength; i++)
dataTypes.SkipNextVarInt(packetData); // Biomes
}
var dataSize = dataTypes.ReadNextVarInt(packetData); // Size
pTerrain.ProcessChunkColumnData(chunkX, chunkZ, verticalStripBitmask, packetData);
Interlocked.Decrement(ref handler.GetWorld().chunkLoadNotCompleted);
// Block Entity data: ignored
// Trust edges: ignored (Removed in 1.20)
// Light data: ignored
}
else
{
var chunksContinuous = dataTypes.ReadNextBool(packetData);
if (protocolVersion is >= MC_1_16_Version and <= MC_1_16_1_Version)
dataTypes.ReadNextBool(packetData); // Ignore old data - 1.16 to 1.16.1 only
var chunkMask = protocolVersion >= MC_1_9_Version
? (ushort)dataTypes.ReadNextVarInt(packetData)
: dataTypes.ReadNextUShort(packetData);
if (protocolVersion < MC_1_8_Version)
{
var addBitmap = dataTypes.ReadNextUShort(packetData);
var compressedDataSize = dataTypes.ReadNextInt(packetData);
var compressed = dataTypes.ReadData(compressedDataSize, packetData);
var decompressed = ZlibUtils.Decompress(compressed);
pTerrain.ProcessChunkColumnData(chunkX, chunkZ, chunkMask, addBitmap,
currentDimension == 0, chunksContinuous, currentDimension,
new Queue<byte>(decompressed));
Interlocked.Decrement(ref handler.GetWorld().chunkLoadNotCompleted);
}
else
{
if (protocolVersion >= MC_1_14_Version)
dataTypes.ReadNextNbt(packetData); // Heightmaps - 1.14 and above
var biomesLength = 0;
if (protocolVersion >= MC_1_16_2_Version)
if (chunksContinuous)
biomesLength =
dataTypes.ReadNextVarInt(
packetData); // Biomes length - 1.16.2 and above
if (protocolVersion >= MC_1_15_Version && chunksContinuous)
{
if (protocolVersion >= MC_1_16_2_Version)
{
for (var i = 0; i < biomesLength; i++)
{
// Biomes - 1.16.2 and above
// Don't use ReadNextVarInt because it cost too much time
dataTypes.SkipNextVarInt(packetData);
}
}
else dataTypes.DropData(1024 * 4, packetData); // Biomes - 1.15 and above
}
var dataSize = dataTypes.ReadNextVarInt(packetData);
pTerrain.ProcessChunkColumnData(chunkX, chunkZ, chunkMask, 0, false,
chunksContinuous, currentDimension, packetData);
Interlocked.Decrement(ref handler.GetWorld().chunkLoadNotCompleted);
}
}
}
break;
case PacketTypesIn.ChunksBiomes: // 1.19.4
// Biomes are not handled by MCC
break;
case PacketTypesIn.MapData:
if (protocolVersion < MC_1_8_Version)
break;
var mapId = dataTypes.ReadNextVarInt(packetData);
var scale = dataTypes.ReadNextByte(packetData);
// 1.9 +
var trackingPosition = true;
// 1.14+
var locked = false;
// 1.17+ (locked and trackingPosition switched places)
if (protocolVersion >= MC_1_17_Version)
{
if (protocolVersion >= MC_1_14_Version)
locked = dataTypes.ReadNextBool(packetData);
if (protocolVersion >= MC_1_9_Version)
trackingPosition = dataTypes.ReadNextBool(packetData);
}
else
{
if (protocolVersion >= MC_1_9_Version)
trackingPosition = dataTypes.ReadNextBool(packetData);
if (protocolVersion >= MC_1_14_Version)
locked = dataTypes.ReadNextBool(packetData);
}
var iconCount = 0;
List<MapIcon> icons = new();
// 1,9 + = needs tracking position to be true to get the icons
if (protocolVersion <= MC_1_16_5_Version || trackingPosition)
{
iconCount = dataTypes.ReadNextVarInt(packetData);
for (var i = 0; i < iconCount; i++)
{
MapIcon mapIcon = new();
switch (protocolVersion)
{
// 1.8 - 1.13
case < MC_1_13_2_Version:
{
var directionAndType = dataTypes.ReadNextByte(packetData);
byte direction, type;
// 1.12.2+
if (protocolVersion >= MC_1_12_2_Version)
{
direction = (byte)(directionAndType & 0xF);
type = (byte)(directionAndType >> 4 & 0xF);
}
else // 1.8 - 1.12
{
direction = (byte)(directionAndType >> 4 & 0xF);
type = (byte)(directionAndType & 0xF);
}
mapIcon.Type = (MapIconType)type;
mapIcon.Direction = direction;
break;
}
// 1.13.2+
case >= MC_1_13_2_Version:
mapIcon.Type = (MapIconType)dataTypes.ReadNextVarInt(packetData);
break;
}
mapIcon.X = dataTypes.ReadNextByte(packetData);
mapIcon.Z = dataTypes.ReadNextByte(packetData);
// 1.13.2+
if (protocolVersion >= MC_1_13_2_Version)
{
mapIcon.Direction = dataTypes.ReadNextByte(packetData);
if (dataTypes.ReadNextBool(packetData)) // Has Display Name?
mapIcon.DisplayName =
ChatParser.ParseText(dataTypes.ReadNextChat(packetData));
}
icons.Add(mapIcon);
}
}
var columnsUpdated = dataTypes.ReadNextByte(packetData); // width
byte rowsUpdated = 0; // height
byte mapColumnX = 0;
byte mapRowZ = 0;
byte[]? colors = null;
if (columnsUpdated > 0)
{
rowsUpdated = dataTypes.ReadNextByte(packetData); // height
mapColumnX = dataTypes.ReadNextByte(packetData);
mapRowZ = dataTypes.ReadNextByte(packetData);
colors = dataTypes.ReadNextByteArray(packetData);
}
handler.OnMapData(mapId, scale, trackingPosition, locked, icons, columnsUpdated,
rowsUpdated, mapColumnX, mapRowZ, colors);
break;
case PacketTypesIn.TradeList:
if (protocolVersion >= MC_1_14_Version && handler.GetInventoryEnabled())
{
// MC 1.14 or greater
var windowId = dataTypes.ReadNextVarInt(packetData);
int size = dataTypes.ReadNextByte(packetData);
List<VillagerTrade> trades = new();
for (var tradeId = 0; tradeId < size; tradeId++)
{
var trade = dataTypes.ReadNextTrade(packetData, itemPalette);
trades.Add(trade);
}
VillagerInfo villagerInfo = new()
{
Level = dataTypes.ReadNextVarInt(packetData),
Experience = dataTypes.ReadNextVarInt(packetData),
IsRegularVillager = dataTypes.ReadNextBool(packetData),
CanRestock = dataTypes.ReadNextBool(packetData)
};
handler.OnTradeList(windowId, trades, villagerInfo);
}
break;
case PacketTypesIn.Title:
if (protocolVersion >= MC_1_8_Version)
{
var action2 = dataTypes.ReadNextVarInt(packetData);
var titleText = string.Empty;
var subtitleText = string.Empty;
var actionBarText = string.Empty;
var json = string.Empty;
var fadein = -1;
var stay = -1;
var fadeout = -1;
if (protocolVersion >= MC_1_10_Version)
{
switch (action2)
{
case 0:
json = titleText;
titleText = ChatParser.ParseText(dataTypes.ReadNextString(packetData));
break;
case 1:
json = subtitleText;
subtitleText = ChatParser.ParseText(dataTypes.ReadNextString(packetData));
break;
case 2:
json = actionBarText;
actionBarText = ChatParser.ParseText(dataTypes.ReadNextString(packetData));
break;
case 3:
fadein = dataTypes.ReadNextInt(packetData);
stay = dataTypes.ReadNextInt(packetData);
fadeout = dataTypes.ReadNextInt(packetData);
break;
}
}
else
{
switch (action2)
{
case 0:
json = titleText;
titleText = ChatParser.ParseText(dataTypes.ReadNextString(packetData));
break;
case 1:
json = subtitleText;
subtitleText = ChatParser.ParseText(dataTypes.ReadNextString(packetData));
break;
case 2:
fadein = dataTypes.ReadNextInt(packetData);
stay = dataTypes.ReadNextInt(packetData);
fadeout = dataTypes.ReadNextInt(packetData);
break;
}
}
handler.OnTitle(action2, titleText, subtitleText, actionBarText, fadein, stay, fadeout,
json);
}
break;
case PacketTypesIn.MultiBlockChange:
if (handler.GetTerrainEnabled())
{
if (protocolVersion >= MC_1_16_2_Version)
{
var chunkSection = dataTypes.ReadNextLong(packetData);
var sectionX = (int)(chunkSection >> 42);
var sectionY = (int)(chunkSection << 44 >> 44);
var sectionZ = (int)(chunkSection << 22 >> 42);
if (protocolVersion < MC_1_20_Version)
dataTypes.ReadNextBool(packetData); // Useless boolean (Related to light update)
var blocksSize = dataTypes.ReadNextVarInt(packetData);
for (var i = 0; i < blocksSize; i++)
{
var chunkSectionPosition = (ulong)dataTypes.ReadNextVarLong(packetData);
var blockId = (int)(chunkSectionPosition >> 12);
var localX = (int)(chunkSectionPosition >> 8 & 0x0F);
var localZ = (int)(chunkSectionPosition >> 4 & 0x0F);
var localY = (int)(chunkSectionPosition & 0x0F);
var block = new Block((ushort)blockId);
var blockX = sectionX * 16 + localX;
var blockY = sectionY * 16 + localY;
var blockZ = sectionZ * 16 + localZ;
Location location = new(blockX, blockY, blockZ);
handler.OnBlockChange(location, block);
}
}
else
{
var chunkX = dataTypes.ReadNextInt(packetData);
var chunkZ = dataTypes.ReadNextInt(packetData);
var recordCount = protocolVersion < MC_1_8_Version
? dataTypes.ReadNextShort(packetData)
: dataTypes.ReadNextVarInt(packetData);
for (var i = 0; i < recordCount; i++)
{
byte locationXZ;
ushort blockIdMeta;
int blockY;
if (protocolVersion < MC_1_8_Version)
{
blockIdMeta = dataTypes.ReadNextUShort(packetData);
blockY = dataTypes.ReadNextByte(packetData);
locationXZ = dataTypes.ReadNextByte(packetData);
}
else
{
locationXZ = dataTypes.ReadNextByte(packetData);
blockY = dataTypes.ReadNextByte(packetData);
blockIdMeta = (ushort)dataTypes.ReadNextVarInt(packetData);
}
var blockX = locationXZ >> 4;
var blockZ = locationXZ & 0x0F;
Location location = new(chunkX, chunkZ, blockX, blockY, blockZ);
Block block = new(blockIdMeta);
handler.OnBlockChange(location, block);
}
}
}
break;
case PacketTypesIn.ServerData:
var motd = "-";
var hasMotd = false;
if (protocolVersion < MC_1_19_4_Version)
{
hasMotd = dataTypes.ReadNextBool(packetData);
if (hasMotd)
motd = ChatParser.ParseText(dataTypes.ReadNextChat(packetData));
}
else
{
hasMotd = true;
motd = ChatParser.ParseText(dataTypes.ReadNextChat(packetData));
}
var iconBase64 = "-";
var hasIcon = dataTypes.ReadNextBool(packetData);
if (hasIcon)
{
if (protocolVersion < MC_1_20_2_Version)
iconBase64 = dataTypes.ReadNextString(packetData);
else
{
var pngData = dataTypes.ReadNextByteArray(packetData);
iconBase64 = Convert.ToBase64String(pngData);
}
}
var previewsChat = false;
if (protocolVersion < MC_1_19_3_Version)
previewsChat = dataTypes.ReadNextBool(packetData);
handler.OnServerDataRecived(hasMotd, motd, hasIcon, iconBase64, previewsChat);
break;
case PacketTypesIn.BlockChange:
if (handler.GetTerrainEnabled())
{
if (protocolVersion < MC_1_8_Version)
{
var blockX = dataTypes.ReadNextInt(packetData);
var blockY = dataTypes.ReadNextByte(packetData);
var blockZ = dataTypes.ReadNextInt(packetData);
var blockId = (short)dataTypes.ReadNextVarInt(packetData);
var blockMeta = dataTypes.ReadNextByte(packetData);
Location location = new(blockX, blockY, blockZ);
Block block = new(blockId, blockMeta);
handler.OnBlockChange(location, block);
}
else
{
var location = dataTypes.ReadNextLocation(packetData);
Block block = new((ushort)dataTypes.ReadNextVarInt(packetData));
handler.OnBlockChange(location, block);
}
}
break;
case PacketTypesIn.SetDisplayChatPreview:
handler.OnChatPreviewSettingUpdate(dataTypes.ReadNextBool(packetData)); // Preview Chat Settings
break;
case PacketTypesIn.ChatSuggestions:
break;
case PacketTypesIn.MapChunkBulk:
if (protocolVersion < MC_1_9_Version && handler.GetTerrainEnabled())
{
int chunkCount;
bool hasSkyLight;
var chunkData = packetData;
//Read global fields
if (protocolVersion < MC_1_8_Version)
{
chunkCount = dataTypes.ReadNextShort(packetData);
var compressedDataSize = dataTypes.ReadNextInt(packetData);
hasSkyLight = dataTypes.ReadNextBool(packetData);
var compressed = dataTypes.ReadData(compressedDataSize, packetData);
var decompressed = ZlibUtils.Decompress(compressed);
chunkData = new Queue<byte>(decompressed);
}
else
{
hasSkyLight = dataTypes.ReadNextBool(packetData);
chunkCount = dataTypes.ReadNextVarInt(packetData);
}
//Read chunk records
var chunkXs = new int[chunkCount];
var chunkZs = new int[chunkCount];
var chunkMasks = new ushort[chunkCount];
var addBitmaps = new ushort[chunkCount];
for (var chunkColumnNo = 0; chunkColumnNo < chunkCount; chunkColumnNo++)
{
chunkXs[chunkColumnNo] = dataTypes.ReadNextInt(packetData);
chunkZs[chunkColumnNo] = dataTypes.ReadNextInt(packetData);
chunkMasks[chunkColumnNo] = dataTypes.ReadNextUShort(packetData);
addBitmaps[chunkColumnNo] = protocolVersion < MC_1_8_Version
? dataTypes.ReadNextUShort(packetData)
: (ushort)0;
}
//Process chunk records
for (var chunkColumnNo = 0; chunkColumnNo < chunkCount; chunkColumnNo++)
{
pTerrain.ProcessChunkColumnData(chunkXs[chunkColumnNo], chunkZs[chunkColumnNo],
chunkMasks[chunkColumnNo], addBitmaps[chunkColumnNo], hasSkyLight, true,
currentDimension, chunkData);
Interlocked.Decrement(ref handler.GetWorld().chunkLoadNotCompleted);
}
}
break;
case PacketTypesIn.UnloadChunk:
if (protocolVersion >= MC_1_9_Version && handler.GetTerrainEnabled())
{
var chunkX = dataTypes.ReadNextInt(packetData);
var chunkZ = dataTypes.ReadNextInt(packetData);
// Warning: It is legal to include unloaded chunks in the UnloadChunk packet.
// Since chunks that have not been loaded are not recorded, this may result
// in loading chunks that should be unloaded and inaccurate statistics.
if (handler.GetWorld()[chunkX, chunkZ] != null)
Interlocked.Decrement(ref handler.GetWorld().chunkCnt);
handler.GetWorld()[chunkX, chunkZ] = null;
}
break;
case PacketTypesIn.ChangeGameState:
if (protocolVersion >= MC_1_15_2_Version)
{
var reason = dataTypes.ReadNextByte(packetData);
var state = dataTypes.ReadNextFloat(packetData);
handler.OnGameEvent(reason, state);
}
break;
case PacketTypesIn.PlayerInfo:
if (protocolVersion >= MC_1_19_3_Version)
{
var actionBitset = dataTypes.ReadNextByte(packetData);
var numberOfActions = dataTypes.ReadNextVarInt(packetData);
for (var i = 0; i < numberOfActions; i++)
{
var playerUuid = dataTypes.ReadNextUUID(packetData);
PlayerInfo player;
if ((actionBitset & 1 << 0) > 0) // Actions bit 0: add player
{
var name = dataTypes.ReadNextString(packetData);
var numberOfProperties = dataTypes.ReadNextVarInt(packetData);
for (var j = 0; j < numberOfProperties; ++j)
{
dataTypes.SkipNextString(packetData);
dataTypes.SkipNextString(packetData);
if (dataTypes.ReadNextBool(packetData))
dataTypes.SkipNextString(packetData);
}
player = new(name, playerUuid);
handler.OnPlayerJoin(player);
}
else
{
var playerGet = handler.GetPlayerInfo(playerUuid);
if (playerGet == null)
{
player = new(string.Empty, playerUuid);
handler.OnPlayerJoin(player);
}
else
{
player = playerGet;
}
}
if ((actionBitset & 1 << 1) > 0) // Actions bit 1: initialize chat
{
var hasSignatureData = dataTypes.ReadNextBool(packetData);
if (hasSignatureData)
{
var chatUuid = dataTypes.ReadNextUUID(packetData);
var publicKeyExpiryTime = dataTypes.ReadNextLong(packetData);
var encodedPublicKey = dataTypes.ReadNextByteArray(packetData);
var publicKeySignature = dataTypes.ReadNextByteArray(packetData);
player.SetPublicKey(chatUuid, publicKeyExpiryTime, encodedPublicKey,
publicKeySignature);
if (playerUuid == handler.GetUserUuid())
{
log.Debug($"Receive ChatUuid = {chatUuid}");
this.chatUuid = chatUuid;
}
}
else
{
player.ClearPublicKey();
if (playerUuid == handler.GetUserUuid())
log.Debug("Receive ChatUuid = Empty");
}
if (playerUuid == handler.GetUserUuid())
{
receivePlayerInfo = true;
if (receiveDeclareCommands)
handler.SetCanSendMessage(true);
}
}
if ((actionBitset & 1 << 2) > 0) // Actions bit 2: update gamemode
handler.OnGamemodeUpdate(playerUuid, dataTypes.ReadNextVarInt(packetData));
if ((actionBitset & 1 << 3) > 0) // Actions bit 3: update listed
player.Listed = dataTypes.ReadNextBool(packetData);
if ((actionBitset & 1 << 4) > 0) // Actions bit 4: update latency
{
var latency = dataTypes.ReadNextVarInt(packetData);
handler.OnLatencyUpdate(playerUuid, latency); //Update latency;
}
// Actions bit 5: update display name
if ((actionBitset & 1 << 5) <= 0) continue;
player.DisplayName = dataTypes.ReadNextBool(packetData)
? dataTypes.ReadNextChat(packetData)
: null;
}
}
else if (protocolVersion >= MC_1_8_Version)
{
var action = dataTypes.ReadNextVarInt(packetData); // Action Name
var numberOfPlayers = dataTypes.ReadNextVarInt(packetData); // Number Of Players
for (var i = 0; i < numberOfPlayers; i++)
{
var uuid = dataTypes.ReadNextUUID(packetData); // Player UUID
switch (action)
{
case 0x00: //Player Join (Add player since 1.19)
var name = dataTypes.ReadNextString(packetData); // Player name
var propNum =
dataTypes.ReadNextVarInt(
packetData); // Number of properties in the following array
// Property: Tuple<Name, Value, Signature(empty if there is no signature)
// The Property field looks as in the response of https://wiki.vg/Mojang_API#UUID_to_Profile_and_Skin.2FCape
const bool useProperty = false;
#pragma warning disable CS0162 // Unreachable code detected
var properties =
useProperty ? new Tuple<string, string, string?>[propNum] : null;
for (var p = 0; p < propNum; p++)
{
var propertyName =
dataTypes.ReadNextString(packetData); // Name: String (32767)
var val =
dataTypes.ReadNextString(packetData); // Value: String (32767)
string? propertySignature = null;
if (dataTypes.ReadNextBool(packetData)) // Is Signed
propertySignature =
dataTypes.ReadNextString(
packetData); // Signature: String (32767)
if (useProperty)
properties![p] = new(propertyName, val, propertySignature);
}
#pragma warning restore CS0162 // Unreachable code detected
var gameMode = dataTypes.ReadNextVarInt(packetData); // Gamemode
handler.OnGamemodeUpdate(uuid, gameMode);
var ping = dataTypes.ReadNextVarInt(packetData); // Ping
string? displayName = null;
if (dataTypes.ReadNextBool(packetData)) // Has display name
displayName = dataTypes.ReadNextString(packetData); // Display name
// 1.19 Additions
long? keyExpiration = null;
byte[]? publicKey = null, signature = null;
if (protocolVersion >= MC_1_19_Version)
{
if (dataTypes.ReadNextBool(
packetData)) // Has Sig Data (if true, red the following fields)
{
keyExpiration = dataTypes.ReadNextLong(packetData); // Timestamp
var publicKeyLength =
dataTypes.ReadNextVarInt(packetData); // Public Key Length
if (publicKeyLength > 0)
publicKey = dataTypes.ReadData(publicKeyLength,
packetData); // Public key
var signatureLength =
dataTypes.ReadNextVarInt(packetData); // Signature Length
if (signatureLength > 0)
signature = dataTypes.ReadData(signatureLength,
packetData); // Public key
}
}
handler.OnPlayerJoin(new PlayerInfo(uuid, name, properties, gameMode, ping,
displayName, keyExpiration, publicKey, signature));
break;
case 0x01: // Update Gamemode
handler.OnGamemodeUpdate(uuid, dataTypes.ReadNextVarInt(packetData));
break;
case 0x02: // Update latency
var latency = dataTypes.ReadNextVarInt(packetData);
handler.OnLatencyUpdate(uuid, latency); // Update latency;
break;
case 0x03: // Update display name
if (dataTypes.ReadNextBool(packetData))
{
var player = handler.GetPlayerInfo(uuid);
if (player != null)
player.DisplayName = dataTypes.ReadNextString(packetData);
else
dataTypes.SkipNextString(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
{
var name = dataTypes.ReadNextString(packetData);
var online = dataTypes.ReadNextBool(packetData);
var ping = dataTypes.ReadNextShort(packetData);
var fakeUuid = new Guid(MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(name)).Take(16)
.ToArray());
if (online)
handler.OnPlayerJoin(new PlayerInfo(name, fakeUuid));
else handler.OnPlayerLeave(fakeUuid);
}
break;
case PacketTypesIn.PlayerRemove:
var numberOfLeavePlayers = dataTypes.ReadNextVarInt(packetData);
for (var i = 0; i < numberOfLeavePlayers; ++i)
{
var playerUuid = dataTypes.ReadNextUUID(packetData);
handler.OnPlayerLeave(playerUuid);
}
break;
case PacketTypesIn.TabComplete:
var oldTransactionId = autocomplete_transaction_id;
if (protocolVersion >= MC_1_13_Version)
{
autocomplete_transaction_id = dataTypes.ReadNextVarInt(packetData);
dataTypes.ReadNextVarInt(packetData); // Start of text to replace
dataTypes.ReadNextVarInt(packetData); // Length of text to replace
}
var autocompleteCount = dataTypes.ReadNextVarInt(packetData);
var autocompleteResult = new string[autocompleteCount];
for (var i = 0; i < autocompleteCount; i++)
{
autocompleteResult[i] = dataTypes.ReadNextString(packetData);
if (protocolVersion < MC_1_13_Version) continue;
// Skip optional tooltip for each tab-complete resul`t
if (dataTypes.ReadNextBool(packetData))
dataTypes.ReadNextChat(packetData);
}
handler.OnAutoCompleteDone(oldTransactionId, autocompleteResult);
break;
case PacketTypesIn.PluginMessage:
var channel = dataTypes.ReadNextString(packetData);
// Length is unneeded as the whole remaining packetData is the entire payload of the packet.
if (protocolVersion < MC_1_8_Version)
pForge.ReadNextVarShort(packetData);
handler.OnPluginChannelMessage(channel, packetData.ToArray());
return pForge.HandlePluginMessage(channel, packetData, ref currentDimension);
case PacketTypesIn.Disconnect:
handler.OnConnectionLost(ChatBot.DisconnectReason.InGameKick,
dataTypes.ReadNextChat(packetData));
return false;
case PacketTypesIn.SetCompression:
if (protocolVersion is >= MC_1_8_Version and < MC_1_9_Version)
compression_treshold = dataTypes.ReadNextVarInt(packetData);
break;
case PacketTypesIn.OpenWindow:
if (handler.GetInventoryEnabled())
{
if (protocolVersion < MC_1_14_Version)
{
// MC 1.13 or lower
var windowId = dataTypes.ReadNextByte(packetData);
var type = dataTypes.ReadNextString(packetData).Replace("minecraft:", "")
.ToUpper();
var inventoryType =
(ContainerTypeOld)Enum.Parse(typeof(ContainerTypeOld), type);
var title = dataTypes.ReadNextChat(packetData);
var slots = dataTypes.ReadNextByte(packetData);
Container inventory = new(windowId, inventoryType, ChatParser.ParseText(title));
handler.OnInventoryOpen(windowId, inventory);
}
else
{
// MC 1.14 or greater
var windowId = dataTypes.ReadNextVarInt(packetData);
var windowType = dataTypes.ReadNextVarInt(packetData);
var title = dataTypes.ReadNextChat(packetData);
Container inventory = new(windowId, windowType, ChatParser.ParseText(title));
handler.OnInventoryOpen(windowId, inventory);
}
}
break;
case PacketTypesIn.CloseWindow:
if (handler.GetInventoryEnabled())
{
var windowId = dataTypes.ReadNextByte(packetData);
lock (window_actions)
{
window_actions[windowId] = 0;
}
handler.OnInventoryClose(windowId);
}
break;
case PacketTypesIn.WindowItems:
if (handler.GetInventoryEnabled())
{
var windowId = dataTypes.ReadNextByte(packetData);
var stateId = -1;
var elements = 0;
if (protocolVersion >= MC_1_17_1_Version)
{
// State ID and Elements as VarInt - 1.17.1 and above
stateId = dataTypes.ReadNextVarInt(packetData);
elements = dataTypes.ReadNextVarInt(packetData);
}
else
{
// Elements as Short - 1.17.0 and below
dataTypes.ReadNextShort(packetData);
}
Dictionary<int, Item> inventorySlots = new();
for (var slotId = 0; slotId < elements; slotId++)
{
var item = dataTypes.ReadNextItemSlot(packetData, itemPalette);
if (item != null)
inventorySlots[slotId] = item;
}
if (protocolVersion >= MC_1_17_1_Version) // Carried Item - 1.17.1 and above
dataTypes.ReadNextItemSlot(packetData, itemPalette);
handler.OnWindowItems(windowId, inventorySlots, stateId);
}
break;
case PacketTypesIn.WindowProperty:
var containerId = dataTypes.ReadNextByte(packetData);
var propertyId = dataTypes.ReadNextShort(packetData);
var propertyValue = dataTypes.ReadNextShort(packetData);
handler.OnWindowProperties(containerId, propertyId, propertyValue);
break;
case PacketTypesIn.SetSlot:
if (handler.GetInventoryEnabled())
{
var windowId = dataTypes.ReadNextByte(packetData);
var stateId = -1;
if (protocolVersion >= MC_1_17_1_Version)
stateId = dataTypes.ReadNextVarInt(packetData); // State ID - 1.17.1 and above
var slotId = dataTypes.ReadNextShort(packetData);
var item = dataTypes.ReadNextItemSlot(packetData, itemPalette);
handler.OnSetSlot(windowId, slotId, item, stateId);
}
break;
case PacketTypesIn.WindowConfirmation:
if (handler.GetInventoryEnabled())
{
var windowId = dataTypes.ReadNextByte(packetData);
var actionId = dataTypes.ReadNextShort(packetData);
var accepted = dataTypes.ReadNextBool(packetData);
if (!accepted)
SendWindowConfirmation(windowId, actionId, true);
}
break;
case PacketTypesIn.RemoveResourcePack:
if (dataTypes.ReadNextBool(packetData)) // Has UUID
dataTypes.ReadNextUUID(packetData); // UUID
break;
case PacketTypesIn.ResourcePackSend:
HandleResourcePackPacket(packetData);
break;
case PacketTypesIn.ResetScore:
dataTypes.ReadNextString(packetData); // Entity Name
if (dataTypes.ReadNextBool(packetData)) // Has Objective Name
dataTypes.ReadNextString(packetData); // Objective Name
break;
case PacketTypesIn.SpawnEntity:
if (handler.GetEntityHandlingEnabled())
{
var entity = dataTypes.ReadNextEntity(packetData, entityPalette, false);
handler.OnSpawnEntity(entity);
}
break;
case PacketTypesIn.EntityEquipment:
if (handler.GetEntityHandlingEnabled())
{
var entityId = dataTypes.ReadNextVarInt(packetData);
if (protocolVersion >= MC_1_16_Version)
{
bool hasNext;
do
{
var bitsData = dataTypes.ReadNextByte(packetData);
// Top bit set if another entry follows, and otherwise unset if this is the last item in the array
hasNext = bitsData >> 7 == 1;
var slot2 = bitsData >> 1;
var item = dataTypes.ReadNextItemSlot(packetData, itemPalette);
handler.OnEntityEquipment(entityId, slot2, item);
} while (hasNext);
}
else
{
var slot2 = protocolVersion < MC_1_9_Version
? dataTypes.ReadNextShort(packetData)
: dataTypes.ReadNextVarInt(packetData);
var item = dataTypes.ReadNextItemSlot(packetData, itemPalette);
handler.OnEntityEquipment(entityId, slot2, item);
}
}
break;
case PacketTypesIn.SpawnLivingEntity:
if (handler.GetEntityHandlingEnabled())
{
var entity = dataTypes.ReadNextEntity(packetData, entityPalette, true);
// packet before 1.15 has metadata at the end
// this is not handled in dataTypes.ReadNextEntity()
// we are simply ignoring leftover data in packet
handler.OnSpawnEntity(entity);
}
break;
case PacketTypesIn.SpawnPlayer:
if (handler.GetEntityHandlingEnabled())
{
var entityId = dataTypes.ReadNextVarInt(packetData);
var uuid = dataTypes.ReadNextUUID(packetData);
double x, y, z;
if (protocolVersion < MC_1_9_Version)
{
x = dataTypes.ReadNextInt(packetData) / 32.0D;
y = dataTypes.ReadNextInt(packetData) / 32.0D;
z = dataTypes.ReadNextInt(packetData) / 32.0D;
}
else
{
x = dataTypes.ReadNextDouble(packetData);
y = dataTypes.ReadNextDouble(packetData);
z = dataTypes.ReadNextDouble(packetData);
}
var yaw = dataTypes.ReadNextByte(packetData);
var pitch = dataTypes.ReadNextByte(packetData);
handler.OnSpawnPlayer(entityId, uuid, new(x, y, z), yaw, pitch);
}
break;
case PacketTypesIn.EntityEffect:
if (handler.GetEntityHandlingEnabled())
{
var entityId = dataTypes.ReadNextVarInt(packetData);
var effectId = protocolVersion >= MC_1_18_2_Version
? dataTypes.ReadNextVarInt(packetData)
: dataTypes.ReadNextByte(packetData);
if (Enum.TryParse(effectId.ToString(), out Effects effect))
{
var amplifier = dataTypes.ReadNextByte(packetData);
var duration = dataTypes.ReadNextVarInt(packetData);
var flags = dataTypes.ReadNextByte(packetData);
var hasFactorData = false;
Dictionary<string, object>? factorCodec = null;
if (protocolVersion >= MC_1_19_Version)
{
hasFactorData = dataTypes.ReadNextBool(packetData);
if (hasFactorData)
factorCodec = dataTypes.ReadNextNbt(packetData);
}
handler.OnEntityEffect(entityId, effect, amplifier, duration, flags, hasFactorData,
factorCodec);
}
}
break;
case PacketTypesIn.DestroyEntities:
if (handler.GetEntityHandlingEnabled())
{
var entityCount = 1; // 1.17.0 has only one entity per packet
if (protocolVersion != MC_1_17_Version)
entityCount =
dataTypes.ReadNextVarInt(packetData); // All other versions have a "count" field
var entityList = new int[entityCount];
for (var i = 0; i < entityCount; i++)
entityList[i] = dataTypes.ReadNextVarInt(packetData);
handler.OnDestroyEntities(entityList);
}
break;
case PacketTypesIn.EntityPosition:
if (handler.GetEntityHandlingEnabled())
{
var entityId = dataTypes.ReadNextVarInt(packetData);
double deltaX, deltaY, deltaZ;
if (protocolVersion < MC_1_9_Version)
{
deltaX = Convert.ToDouble(dataTypes.ReadNextByte(packetData));
deltaY = Convert.ToDouble(dataTypes.ReadNextByte(packetData));
deltaZ = Convert.ToDouble(dataTypes.ReadNextByte(packetData));
}
else
{
deltaX = Convert.ToDouble(dataTypes.ReadNextShort(packetData));
deltaY = Convert.ToDouble(dataTypes.ReadNextShort(packetData));
deltaZ = Convert.ToDouble(dataTypes.ReadNextShort(packetData));
}
var isOnGround = dataTypes.ReadNextBool(packetData);
deltaX = deltaX / (128 * 32);
deltaY = deltaY / (128 * 32);
deltaZ = deltaZ / (128 * 32);
handler.OnEntityPosition(entityId, deltaX, deltaY, deltaZ, isOnGround);
}
break;
case PacketTypesIn.EntityPositionAndRotation:
if (handler.GetEntityHandlingEnabled())
{
var entityId = dataTypes.ReadNextVarInt(packetData);
double deltaX, deltaY, deltaZ;
if (protocolVersion < MC_1_9_Version)
{
deltaX = dataTypes.ReadNextByte(packetData) / 32.0D;
deltaY = dataTypes.ReadNextByte(packetData) / 32.0D;
deltaZ = dataTypes.ReadNextByte(packetData) / 32.0D;
}
else
{
deltaX = Convert.ToDouble(dataTypes.ReadNextShort(packetData));
deltaY = Convert.ToDouble(dataTypes.ReadNextShort(packetData));
deltaZ = Convert.ToDouble(dataTypes.ReadNextShort(packetData));
}
var yaw = dataTypes.ReadNextByte(packetData) * (1F / 256) * 360;
var pitch = dataTypes.ReadNextByte(packetData) * (1F / 256) * 360;
var isOnGround = dataTypes.ReadNextBool(packetData);
deltaX = deltaX / (128 * 32);
deltaY = deltaY / (128 * 32);
deltaZ = deltaZ / (128 * 32);
handler.OnEntityPosition(entityId, deltaX, deltaY, deltaZ, yaw, pitch, isOnGround);
}
break;
case PacketTypesIn.EntityRotation:
if (handler.GetEntityHandlingEnabled())
{
var entityId = dataTypes.ReadNextVarInt(packetData);
var yaw = dataTypes.ReadNextByte(packetData) * (1F / 256) * 360;
var pitch = dataTypes.ReadNextByte(packetData) * (1F / 256) * 360;
var isOnGround = dataTypes.ReadNextBool(packetData);
handler.OnEntityRotation(entityId, yaw, pitch, isOnGround);
}
break;
case PacketTypesIn.EntityProperties:
if (handler.GetEntityHandlingEnabled())
{
var entityId = dataTypes.ReadNextVarInt(packetData);
var numberOfProperties = protocolVersion >= MC_1_17_Version
? dataTypes.ReadNextVarInt(packetData)
: dataTypes.ReadNextInt(packetData);
Dictionary<string, double> keys = new();
for (var i = 0; i < numberOfProperties; i++)
{
var propertyKey = dataTypes.ReadNextString(packetData);
var propertyValue2 = dataTypes.ReadNextDouble(packetData);
List<double> op0 = new();
List<double> op1 = new();
List<double> op2 = new();
var numberOfModifiers = dataTypes.ReadNextVarInt(packetData);
for (var j = 0; j < numberOfModifiers; j++)
{
dataTypes.ReadNextUUID(packetData);
var amount = dataTypes.ReadNextDouble(packetData);
var operation = dataTypes.ReadNextByte(packetData);
switch (operation)
{
case 0:
op0.Add(amount);
break;
case 1:
op1.Add(amount);
break;
case 2:
op2.Add(amount + 1);
break;
}
}
if (op0.Count > 0) propertyValue2 += op0.Sum();
if (op1.Count > 0) propertyValue2 *= 1 + op1.Sum();
if (op2.Count > 0) propertyValue2 *= op2.Aggregate((a, _x) => a * _x);
keys.Add(propertyKey, propertyValue2);
}
handler.OnEntityProperties(entityId, keys);
}
break;
case PacketTypesIn.EntityMetadata:
if (handler.GetEntityHandlingEnabled())
{
var entityId = dataTypes.ReadNextVarInt(packetData);
var metadata = dataTypes.ReadNextMetadata(packetData, itemPalette, entityMetadataPalette);
// Also make a palette for field? Will be a lot of work
var healthField = protocolVersion switch
{
> MC_1_20_4_Version => throw new NotImplementedException(Translations
.exception_palette_healthfield),
// 1.17 and above
>= MC_1_17_Version => 9,
// 1.14 and above
>= MC_1_14_Version => 8,
// 1.10 and above
>= MC_1_10_Version => 7,
// 1.8 and above
>= MC_1_8_Version => 6,
_ => throw new NotImplementedException(Translations.exception_palette_healthfield)
};
if (metadata.TryGetValue(healthField, out var healthObj) && healthObj is float healthObj2)
handler.OnEntityHealth(entityId, healthObj2);
handler.OnEntityMetadata(entityId, metadata);
}
break;
case PacketTypesIn.EntityStatus:
if (handler.GetEntityHandlingEnabled())
{
var entityId = dataTypes.ReadNextInt(packetData);
var status = dataTypes.ReadNextByte(packetData);
handler.OnEntityStatus(entityId, status);
}
break;
case PacketTypesIn.TimeUpdate:
var worldAge = dataTypes.ReadNextLong(packetData);
var timeOfDay = dataTypes.ReadNextLong(packetData);
handler.OnTimeUpdate(worldAge, timeOfDay);
break;
case PacketTypesIn.EntityTeleport:
if (handler.GetEntityHandlingEnabled())
{
var entityId = dataTypes.ReadNextVarInt(packetData);
double x, y, z;
if (protocolVersion < MC_1_9_Version)
{
x = dataTypes.ReadNextInt(packetData) / 32.0D;
y = dataTypes.ReadNextInt(packetData) / 32.0D;
z = dataTypes.ReadNextInt(packetData) / 32.0D;
}
else
{
x = dataTypes.ReadNextDouble(packetData);
y = dataTypes.ReadNextDouble(packetData);
z = dataTypes.ReadNextDouble(packetData);
}
var entityYaw = dataTypes.ReadNextByte(packetData);
var entityPitch = dataTypes.ReadNextByte(packetData);
var isOnGround = dataTypes.ReadNextBool(packetData);
handler.OnEntityTeleport(entityId, x, y, z, isOnGround);
}
break;
case PacketTypesIn.UpdateHealth:
var health = dataTypes.ReadNextFloat(packetData);
var food = protocolVersion >= MC_1_8_Version
? dataTypes.ReadNextVarInt(packetData)
: dataTypes.ReadNextShort(packetData);
dataTypes.ReadNextFloat(packetData); // Food Saturation
handler.OnUpdateHealth(health, food);
break;
case PacketTypesIn.SetExperience:
var experienceBar = dataTypes.ReadNextFloat(packetData);
var level = dataTypes.ReadNextVarInt(packetData);
var totalExperience = dataTypes.ReadNextVarInt(packetData);
handler.OnSetExperience(experienceBar, level, totalExperience);
break;
case PacketTypesIn.Explosion:
Location explosionLocation;
if (protocolVersion >= MC_1_19_3_Version)
explosionLocation = new(dataTypes.ReadNextDouble(packetData),
dataTypes.ReadNextDouble(packetData), dataTypes.ReadNextDouble(packetData));
else
explosionLocation = new(dataTypes.ReadNextFloat(packetData),
dataTypes.ReadNextFloat(packetData), dataTypes.ReadNextFloat(packetData));
var explosionStrength = dataTypes.ReadNextFloat(packetData);
var explosionBlockCount = protocolVersion >= MC_1_17_Version
? dataTypes.ReadNextVarInt(packetData)
: dataTypes.ReadNextInt(packetData); // Record count
// Records
for (var i = 0; i < explosionBlockCount; i++)
dataTypes.ReadData(3, packetData);
// Maybe use in the future when the physics are implemented
dataTypes.ReadNextFloat(packetData); // Player Motion X
dataTypes.ReadNextFloat(packetData); // Player Motion Y
dataTypes.ReadNextFloat(packetData); // Player Motion Z
if (protocolVersion >= MC_1_20_4_Version)
{
dataTypes.ReadNextVarInt(packetData); // Block Interaction
dataTypes.ReadParticleData(packetData, itemPalette); // Small Explosion Particles
dataTypes.ReadParticleData(packetData, itemPalette); // Large Explosion Particles
// Explosion Sound
dataTypes.ReadNextString(packetData); // Sound Name
var hasFixedRange = dataTypes.ReadNextBool(packetData);
if (hasFixedRange)
dataTypes.ReadNextFloat(packetData); // Range
}
handler.OnExplosion(explosionLocation, explosionStrength, explosionBlockCount);
break;
case PacketTypesIn.HeldItemChange:
handler.OnHeldItemChange(dataTypes.ReadNextByte(packetData)); // Slot
break;
case PacketTypesIn.ScoreboardObjective:
var objectiveName = dataTypes.ReadNextString(packetData);
var mode = dataTypes.ReadNextByte(packetData);
var objectiveValue = string.Empty;
var objectiveType = -1;
var numberFormat = 0;
if (mode is 0 or 2)
{
objectiveValue = dataTypes.ReadNextChat(packetData);
objectiveType = dataTypes.ReadNextVarInt(packetData);
if (protocolVersion >= MC_1_20_4_Version)
{
if (dataTypes.ReadNextBool(packetData)) // Has Number Format
numberFormat = dataTypes.ReadNextVarInt(packetData); // Number Format
}
}
handler.OnScoreboardObjective(objectiveName, mode, objectiveValue, objectiveType, numberFormat);
break;
case PacketTypesIn.UpdateScore:
var entityName = dataTypes.ReadNextString(packetData);
var action3 = 0;
var objectiveName3 = string.Empty;
var objectiveValue2 = -1;
var objectiveDisplayName3 = string.Empty;
var numberFormat2 = 0;
if (protocolVersion >= MC_1_20_4_Version)
{
objectiveName3 = dataTypes.ReadNextString(packetData); // Objective Name
objectiveValue2 = dataTypes.ReadNextVarInt(packetData); // Value
if (dataTypes.ReadNextBool(packetData)) // Has Display Name
objectiveDisplayName3 =
ChatParser.ParseText(dataTypes.ReadNextString(packetData)); // Has Display Name
if (dataTypes.ReadNextBool(packetData)) // Has Number Format
numberFormat2 = dataTypes.ReadNextVarInt(packetData); // Number Format
}
else
{
action3 = protocolVersion >= MC_1_18_2_Version
? dataTypes.ReadNextVarInt(packetData)
: dataTypes.ReadNextByte(packetData);
if (action3 != 1 || protocolVersion >= MC_1_8_Version)
objectiveName3 = dataTypes.ReadNextString(packetData);
if (action3 != 1)
objectiveValue2 = dataTypes.ReadNextVarInt(packetData);
}
handler.OnUpdateScore(entityName, action3, objectiveName3, objectiveDisplayName3, objectiveValue2,
numberFormat2);
break;
case PacketTypesIn.BlockChangedAck:
handler.OnBlockChangeAck(dataTypes.ReadNextVarInt(packetData));
break;
case PacketTypesIn.BlockBreakAnimation:
if (handler.GetEntityHandlingEnabled() && handler.GetTerrainEnabled())
{
var playerId = dataTypes.ReadNextVarInt(packetData);
var blockLocation = dataTypes.ReadNextLocation(packetData);
var stage = dataTypes.ReadNextByte(packetData);
handler.OnBlockBreakAnimation(playerId, blockLocation, stage);
}
break;
case PacketTypesIn.EntityAnimation:
if (handler.GetEntityHandlingEnabled())
{
var playerId = dataTypes.ReadNextVarInt(packetData);
var animation = dataTypes.ReadNextByte(packetData);
handler.OnEntityAnimation(playerId, animation);
}
break;
case PacketTypesIn.OpenSignEditor:
var signLocation = dataTypes.ReadNextLocation(packetData);
var isFrontText = true;
if (protocolVersion >= MC_1_20_Version)
isFrontText = dataTypes.ReadNextBool(packetData);
// TODO: Use
break;
// Temporarily disabled until I find a fix
/*case PacketTypesIn.BlockEntityData:
var location_ = dataTypes.ReadNextLocation(packetData);
var type_ = dataTypes.ReadNextInt(packetData);
var nbt = dataTypes.ReadNextNbt(packetData);
var nbtJson = JsonConvert.SerializeObject(nbt["messages"]);
//log.Info($"BLOCK ENTITY DATA -> {location_.ToString()} [{type_}] -> NBT: {nbtJson}");
break;*/
case PacketTypesIn.SetTickingState:
dataTypes.ReadNextFloat(packetData);
dataTypes.ReadNextBool(packetData);
break;
default:
return false; //Ignored packet
}
return true; //Packet processed
}
/// <summary>
/// Start the updating thread. Should be called after login success.
/// </summary>
private void StartUpdating()
{
Thread threadUpdater = new(new ParameterizedThreadStart(Updater))
{
Name = "ProtocolPacketHandler"
};
netMain = new Tuple<Thread, CancellationTokenSource>(threadUpdater, new CancellationTokenSource());
threadUpdater.Start(netMain.Item2.Token);
Thread threadReader = new(new ParameterizedThreadStart(PacketReader))
{
Name = "ProtocolPacketReader"
};
netReader = new Tuple<Thread, CancellationTokenSource>(threadReader, new CancellationTokenSource());
threadReader.Start(netReader.Item2.Token);
}
/// <summary>
/// Get net read thread (main thread) ID
/// </summary>
/// <returns>Net read thread ID</returns>
public int GetNetMainThreadId()
{
return netMain != null ? netMain.Item1.ManagedThreadId : -1;
}
/// <summary>
/// Disconnect from the server, cancel network reading.
/// </summary>
public void Dispose()
{
try
{
if (netMain != null)
{
netMain.Item2.Cancel();
}
if (netReader != null)
{
netReader.Item2.Cancel();
socketWrapper.Disconnect();
}
}
catch
{
}
}
/// <summary>
/// Send a packet to the server. Packet ID, compression, and encryption will be handled automatically.
/// </summary>
/// <param name="packet">packet type</param>
/// <param name="packetData">packet Data</param>
private void SendPacket(PacketTypesOut packet, IEnumerable<byte> packetData)
{
SendPacket(packetPalette.GetOutgoingIdByType(packet), packetData);
}
/// <summary>
/// Send a configuration packet to the server. Packet ID, compression, and encryption will be handled automatically.
/// </summary>
/// <param name="packet">packet type</param>
/// <param name="packetData">packet Data</param>
private void SendPacket(ConfigurationPacketTypesOut packet, IEnumerable<byte> packetData)
{
SendPacket(packetPalette.GetOutgoingIdByTypeConfiguration(packet), packetData);
}
/// <summary>
/// Send a packet to the server. Compression and encryption will be handled automatically.
/// </summary>
/// <param name="packetId">packet ID</param>
/// <param name="packetData">packet Data</param>
private void SendPacket(int packetId, IEnumerable<byte> packetData)
{
if (handler.GetNetworkPacketCaptureEnabled())
{
var clone = packetData.ToList();
handler.OnNetworkPacket(packetId, clone, currentState == CurrentState.Login, false);
}
//log.Info($"[C -> S] Sending packet {packetId:X} > {dataTypes.ByteArrayToString(packetData.ToArray())}");
//The inner packet
var thePacket = dataTypes.ConcatBytes(DataTypes.GetVarInt(packetId), packetData.ToArray());
if (compression_treshold > 0) //Compression enabled?
{
thePacket = thePacket.Length >= compression_treshold
? dataTypes.ConcatBytes(DataTypes.GetVarInt(thePacket.Length), ZlibUtils.Compress(thePacket))
: dataTypes.ConcatBytes(DataTypes.GetVarInt(0), thePacket);
}
//log.Debug("[C -> S] Sending packet " + packetId + " > " + dataTypes.ByteArrayToString(dataTypes.ConcatBytes(dataTypes.GetVarInt(thePacket.Length), thePacket)));
socketWrapper.SendDataRAW(dataTypes.ConcatBytes(DataTypes.GetVarInt(thePacket.Length), thePacket));
}
/// <summary>
/// Do the Minecraft login.
/// </summary>
/// <returns>True if login successful</returns>
public bool Login(PlayerKeyPair? playerKeyPair, SessionToken session)
{
// 1. Send the handshake packet
SendPacket(0x00, dataTypes.ConcatBytes(
// Protocol Version
DataTypes.GetVarInt(protocolVersion),
// Server Address
dataTypes.GetString(pForge.GetServerAddress(handler.GetServerHost())),
// Server Port
dataTypes.GetUShort((ushort)handler.GetServerPort()),
// Next State
DataTypes.GetVarInt(2)) // 2 is for the Login state
);
// 2. Send the Login Start packet
List<byte> fullLoginPacket = new();
fullLoginPacket.AddRange(dataTypes.GetString(handler.GetUsername())); // Username
// 1.19 - 1.19.2
if (protocolVersion is >= MC_1_19_Version and < MC_1_19_3_Version)
{
if (playerKeyPair == null)
fullLoginPacket.AddRange(dataTypes.GetBool(false)); // Has Sig Data
else
{
fullLoginPacket.AddRange(dataTypes.GetBool(true)); // Has Sig Data
fullLoginPacket.AddRange(
DataTypes.GetLong(playerKeyPair.GetExpirationMilliseconds())); // Expiration time
fullLoginPacket.AddRange(
dataTypes.GetArray(playerKeyPair.PublicKey.Key)); // Public key received from Microsoft API
if (protocolVersion >= MC_1_19_2_Version)
fullLoginPacket.AddRange(
dataTypes.GetArray(playerKeyPair.PublicKey
.SignatureV2!)); // Public key signature received from Microsoft API
else
fullLoginPacket.AddRange(
dataTypes.GetArray(playerKeyPair.PublicKey
.Signature!)); // Public key signature received from Microsoft API
}
}
var uuid = handler.GetUserUuid();
switch (protocolVersion)
{
case >= MC_1_19_2_Version and < MC_1_20_2_Version:
{
if (uuid == Guid.Empty)
fullLoginPacket.AddRange(dataTypes.GetBool(false)); // Has UUID
else
{
fullLoginPacket.AddRange(dataTypes.GetBool(true)); // Has UUID
fullLoginPacket.AddRange(DataTypes.GetUUID(uuid)); // UUID
}
break;
}
case >= MC_1_20_2_Version:
uuid = handler.GetUserUuid();
if (uuid == Guid.Empty)
uuid = Guid.NewGuid();
fullLoginPacket.AddRange(DataTypes.GetUUID(uuid)); // UUID
break;
}
SendPacket(0x00, fullLoginPacket);
// 3. Encryption Request - 9. Login Acknowledged
while (true)
{
var (packetId, packetData) = ReadNextPacket();
switch (packetId)
{
// Login rejected
case 0x00:
handler.OnConnectionLost(ChatBot.DisconnectReason.LoginRejected,
ChatParser.ParseText(dataTypes.ReadNextString(packetData)));
return false;
// Encryption request
case 0x01:
{
isOnlineMode = true;
var serverId = dataTypes.ReadNextString(packetData);
var serverPublicKey = dataTypes.ReadNextByteArray(packetData);
var token = dataTypes.ReadNextByteArray(packetData);
return StartEncryption(handler.GetUserUuidStr(), handler.GetSessionID(),
Config.Main.General.AccountType, token, serverId,
serverPublicKey, playerKeyPair, session);
}
// Login successful
case 0x02:
{
log.Info($"§8{Translations.mcc_server_offline}");
currentState = protocolVersion < MC_1_20_2_Version
? CurrentState.Play
: CurrentState.Configuration;
if (protocolVersion >= MC_1_20_2_Version)
SendPacket(0x03, new List<byte>());
if (!pForge.CompleteForgeHandshake())
{
log.Error($"§8{Translations.error_forge}");
return false;
}
StartUpdating();
return true; //No need to check session or start encryption
}
default:
HandlePacket(packetId, packetData);
break;
}
}
}
/// <summary>
/// Start network encryption. Automatically called by Login() if the server requests encryption.
/// </summary>
/// <returns>True if encryption was successful</returns>
private bool StartEncryption(string uuid, string sessionID, LoginType type, byte[] token, string serverIDhash,
byte[] serverPublicKey, PlayerKeyPair? playerKeyPair, SessionToken session)
{
var RSAService = CryptoHandler.DecodeRSAPublicKey(serverPublicKey)!;
var secretKey = CryptoHandler.ClientAESPrivateKey ?? CryptoHandler.GenerateAESPrivateKey();
log.Debug($"§8{Translations.debug_crypto}");
if (serverIDhash != "-")
{
log.Info(Translations.mcc_session);
var needCheckSession = true;
if (session is { ServerPublicKey: not null, SessionPreCheckTask: not null }
&& serverIDhash == session.ServerIDhash &&
serverPublicKey.SequenceEqual(session.ServerPublicKey))
{
session.SessionPreCheckTask.Wait();
if (session.SessionPreCheckTask.Result) // PreCheck Success
needCheckSession = false;
}
if (needCheckSession)
{
var serverHash = CryptoHandler.GetServerHash(serverIDhash, serverPublicKey, secretKey);
if (ProtocolHandler.SessionCheck(uuid, sessionID, serverHash, type))
{
session.ServerIDhash = serverIDhash;
session.ServerPublicKey = serverPublicKey;
SessionCache.Store(InternalConfig.Account.Login.ToLower(), session);
}
else
{
handler.OnConnectionLost(ChatBot.DisconnectReason.LoginRejected, Translations.mcc_session_fail);
return false;
}
}
}
// Encryption Response packet
List<byte> encryptionResponse = new();
encryptionResponse.AddRange(dataTypes.GetArray(RSAService.Encrypt(secretKey, false))); // Shared Secret
// 1.19 - 1.19.2
if (protocolVersion is >= MC_1_19_Version and < MC_1_19_3_Version)
{
if (playerKeyPair == null)
{
encryptionResponse.AddRange(dataTypes.GetBool(true)); // Has Verify Token
encryptionResponse.AddRange(dataTypes.GetArray(RSAService.Encrypt(token, false))); // Verify Token
}
else
{
var salt = GenerateSalt();
var messageSignature = playerKeyPair.PrivateKey.SignData(dataTypes.ConcatBytes(token, salt));
encryptionResponse.AddRange(dataTypes.GetBool(false)); // Has Verify Token
encryptionResponse.AddRange(salt); // Salt
encryptionResponse.AddRange(dataTypes.GetArray(messageSignature)); // Message Signature
}
}
else
{
encryptionResponse.AddRange(dataTypes.GetArray(RSAService.Encrypt(token, false))); // Verify Token
}
SendPacket(0x01, encryptionResponse);
// Start client-side encryption
socketWrapper.SwitchToEncrypted(secretKey); // pre switch
// Process the next packet
int loopPrevention = ushort.MaxValue;
while (true)
{
var (packetId, packetData) = ReadNextPacket();
if (packetId < 0 || loopPrevention-- < 0) // Failed to read packet or too many iterations (issue #1150)
{
handler.OnConnectionLost(ChatBot.DisconnectReason.ConnectionLost,
$"§8{Translations.error_invalid_encrypt}");
return false;
}
switch (packetId)
{
//Login rejected
case 0x00:
handler.OnConnectionLost(ChatBot.DisconnectReason.LoginRejected,
ChatParser.ParseText(dataTypes.ReadNextString(packetData)));
return false;
//Login successful
case 0x02:
{
var uuidReceived = protocolVersion >= MC_1_16_Version
? dataTypes.ReadNextUUID(packetData)
: Guid.Parse(dataTypes.ReadNextString(packetData));
var userName = dataTypes.ReadNextString(packetData);
Tuple<string, string, string>[]? playerProperty = null;
if (protocolVersion >= MC_1_19_Version)
{
var count = dataTypes.ReadNextVarInt(packetData); // Number Of Properties
playerProperty = new Tuple<string, string, string>[count];
for (var i = 0; i < count; ++i)
{
var name = dataTypes.ReadNextString(packetData);
var value = dataTypes.ReadNextString(packetData);
var isSigned = dataTypes.ReadNextBool(packetData);
var signature = isSigned ? dataTypes.ReadNextString(packetData) : string.Empty;
playerProperty[i] = new Tuple<string, string, string>(name, value, signature);
}
}
currentState = protocolVersion < MC_1_20_2_Version
? CurrentState.Play
: CurrentState.Configuration;
if (protocolVersion >= MC_1_20_2_Version)
SendPacket(0x03, new List<byte>());
handler.OnLoginSuccess(uuidReceived, userName, playerProperty);
if (!pForge.CompleteForgeHandshake())
{
log.Error($"§8{Translations.error_forge_encrypt}");
return false;
}
StartUpdating();
return true;
}
default:
HandlePacket(packetId, packetData);
break;
}
}
}
/// <summary>
/// Disconnect from the server
/// </summary>
public void Disconnect()
{
socketWrapper.Disconnect();
}
/// <summary>
/// Autocomplete text while typing username or command
/// </summary>
/// <param name="BehindCursor">Text behind cursor</param>
/// <returns>Completed text</returns>
int IAutoComplete.AutoComplete(string BehindCursor)
{
if (string.IsNullOrEmpty(BehindCursor))
return -1;
var transactionId = DataTypes.GetVarInt(autocomplete_transaction_id);
var assumeCommand = new byte[] { 0x00 };
var hasPosition = new byte[] { 0x00 };
var tabCompletePacket = Array.Empty<byte>();
switch (protocolVersion)
{
case >= MC_1_8_Version and >= MC_1_13_Version:
tabCompletePacket = dataTypes.ConcatBytes(tabCompletePacket, transactionId);
tabCompletePacket = dataTypes.ConcatBytes(tabCompletePacket,
dataTypes.GetString(BehindCursor.Replace(' ', (char)0x00)));
break;
case >= MC_1_8_Version:
{
tabCompletePacket = dataTypes.ConcatBytes(tabCompletePacket, dataTypes.GetString(BehindCursor));
if (protocolVersion >= MC_1_9_Version)
tabCompletePacket = dataTypes.ConcatBytes(tabCompletePacket, assumeCommand);
tabCompletePacket = dataTypes.ConcatBytes(tabCompletePacket, hasPosition);
break;
}
default:
tabCompletePacket = dataTypes.ConcatBytes(dataTypes.GetString(BehindCursor));
break;
}
ConsoleIO.AutoCompleteDone = false;
SendPacket(PacketTypesOut.TabComplete, tabCompletePacket);
return autocomplete_transaction_id;
}
/// <summary>
/// Ping a Minecraft server to get information about the server
/// </summary>
/// <returns>True if ping was successful</returns>
public static bool DoPing(string host, int port, ref int protocolVersion, ref ForgeInfo? forgeInfo)
{
var version = "";
var tcp = ProxyHandler.NewTcpClient(host, port);
tcp.ReceiveTimeout = 30000; // 30 seconds
tcp.ReceiveBufferSize = 1024 * 1024;
SocketWrapper socketWrapper = new(tcp);
DataTypes dataTypes = new(MC_1_8_Version);
var serverPort = BitConverter.GetBytes((ushort)port);
Array.Reverse(serverPort);
// Ping Packet
var pingPacket = dataTypes.ConcatBytes(
// Packet Id
DataTypes.GetVarInt(0),
// Protocol Version
DataTypes.GetVarInt(-1),
// Server IP (Host)
dataTypes.GetString(host),
// Server port
serverPort,
// Next State
DataTypes.GetVarInt(1));
socketWrapper.SendDataRAW(dataTypes.ConcatBytes(DataTypes.GetVarInt(pingPacket.Length), pingPacket));
// Status Request Packet
var statusRequest = DataTypes.GetVarInt(0);
socketWrapper.SendDataRAW(dataTypes.ConcatBytes(DataTypes.GetVarInt(statusRequest.Length), statusRequest));
// Read Response length
var packetLength = dataTypes.ReadNextVarIntRAW(socketWrapper);
if (packetLength <= 0) return false;
// Read the Packet Id
var packetData = new Queue<byte>(socketWrapper.ReadDataRAW(packetLength));
if (dataTypes.ReadNextVarInt(packetData) != 0x00) return false;
var result = dataTypes.ReadNextString(packetData); // Get the Json data
if (Config.Logging.DebugMessages)
{
// May contain formatting codes, cannot use WriteLineFormatted
Console.ForegroundColor = ConsoleColor.DarkGray;
ConsoleIO.WriteLine(result);
Console.ForegroundColor = ConsoleColor.Gray;
}
if (string.IsNullOrEmpty(result) || !result.StartsWith("{") || !result.EndsWith("}")) return false;
var jsonData = Json.ParseJson(result);
if (jsonData.Type != Json.JSONData.DataType.Object || !jsonData.Properties.ContainsKey("version"))
return false;
var versionData = jsonData.Properties["version"];
//Retrieve display name of the Minecraft version
if (versionData.Properties.TryGetValue("name", out var property))
version = property.StringValue;
//Retrieve protocol version number for handling this server
if (versionData.Properties.TryGetValue("protocol", out var dataProperty))
protocolVersion = int.Parse(dataProperty.StringValue,
NumberStyles.Any, CultureInfo.CurrentCulture);
// Check for forge on the server.
Protocol18Forge.ServerInfoCheckForge(jsonData, ref forgeInfo);
ConsoleIO.WriteLineFormatted("§8" + string.Format(Translations.mcc_server_protocol, version,
protocolVersion + (forgeInfo != null ? Translations.mcc_with_forge : "")));
return true;
}
/// <summary>
/// Get max length for chat messages
/// </summary>
/// <returns>Max length, in characters</returns>
public int GetMaxChatMessageLength() => protocolVersion > MC_1_10_Version
? 256
: 100;
/// <summary>
/// Get the current protocol version.
/// </summary>
/// <remarks>
/// Version-specific operations should be handled inside the Protocol handled whenever possible.
/// </remarks>
/// <returns>Minecraft Protocol version number</returns>
public int GetProtocolVersion()
{
return protocolVersion;
}
/// <summary>
/// Send MessageAcknowledgment packet
/// </summary>
/// <param name="acknowledgment">Message acknowledgment</param>
/// <returns>True if properly sent</returns>
public bool SendMessageAcknowledgment(LastSeenMessageList.Acknowledgment acknowledgment)
{
try
{
var fields = dataTypes.GetAcknowledgment(acknowledgment,
isOnlineMode && Config.Signature.LoginWithSecureProfile);
SendPacket(PacketTypesOut.MessageAcknowledgment, fields);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
/// <summary>
/// Send MessageAcknowledgment packet
/// </summary>
/// <param name="acknowledgment">Message acknowledgment</param>
/// <returns>True if properly sent</returns>
public bool SendMessageAcknowledgment(int messageCount)
{
try
{
var fields = DataTypes.GetVarInt(messageCount);
SendPacket(PacketTypesOut.MessageAcknowledgment, fields);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public LastSeenMessageList.Acknowledgment ConsumeAcknowledgment()
{
pendingAcknowledgments = 0;
return new LastSeenMessageList.Acknowledgment(lastSeenMessagesCollector.GetLastSeenMessages(),
lastReceivedMessage);
}
public void Acknowledge(ChatMessage message)
{
var entry = message.ToLastSeenMessageEntry();
if (entry == null) return;
if (protocolVersion >= MC_1_19_3_Version)
{
if (!lastSeenMessagesCollector.Add_1_19_3(entry, true)) return;
if (lastSeenMessagesCollector.messageCount <= 64) return;
var messageCount = lastSeenMessagesCollector.ResetMessageCount();
if (messageCount > 0)
SendMessageAcknowledgment(messageCount);
}
else
{
lastSeenMessagesCollector.Add_1_19_2(entry);
lastReceivedMessage = null;
if (pendingAcknowledgments++ > 64)
SendMessageAcknowledgment(ConsumeAcknowledgment());
}
}
/// <summary>
/// Send a chat command to the server - 1.19 and above
/// </summary>
/// <param name="command">Command</param>
/// <param name="playerKeyPair">PlayerKeyPair</param>
/// <returns>True if properly sent</returns>
public bool SendChatCommand(string command, PlayerKeyPair? playerKeyPair)
{
if (string.IsNullOrEmpty(command))
return true;
command = Regex.Replace(command, @"\s+", " ");
command = Regex.Replace(command, @"\s$", string.Empty);
log.Debug($"chat command = {command}");
try
{
List<Tuple<string, string>>? needSigned = null; // List< Argument Name, Argument Value >
if (playerKeyPair != null && isOnlineMode && protocolVersion >= MC_1_19_Version
&& Config.Signature is { LoginWithSecureProfile: true, SignMessageInCommand: true })
needSigned = DeclareCommands.CollectSignArguments(command);
lock (MessageSigningLock)
{
var acknowledgment1192 =
protocolVersion == MC_1_19_2_Version ? ConsumeAcknowledgment() : null;
var (acknowledgment1193, bitset1193, messageCount1193) =
protocolVersion >= MC_1_19_3_Version
? lastSeenMessagesCollector.Collect_1_19_3()
: new(Array.Empty<LastSeenMessageList.AcknowledgedMessage>(), Array.Empty<byte>(), 0);
List<byte> fields = new();
// Command: String
fields.AddRange(dataTypes.GetString(command));
// Timestamp: Instant(Long)
var timeNow = DateTimeOffset.UtcNow;
fields.AddRange(DataTypes.GetLong(timeNow.ToUnixTimeMilliseconds()));
if (needSigned == null || needSigned!.Count == 0)
{
fields.AddRange(DataTypes.GetLong(0)); // Salt: Long
fields.AddRange(DataTypes.GetVarInt(0)); // Signature Length: VarInt
}
else
{
var uuid = handler.GetUserUuid();
var salt = GenerateSalt();
fields.AddRange(salt); // Salt: Long
fields.AddRange(DataTypes.GetVarInt(needSigned.Count)); // Signature Length: VarInt
foreach (var (argName, message) in needSigned)
{
fields.AddRange(dataTypes.GetString(argName)); // Argument name: String
var sign = protocolVersion switch
{
MC_1_19_Version => playerKeyPair!.PrivateKey.SignMessage(message, uuid, timeNow,
ref salt),
MC_1_19_2_Version => playerKeyPair!.PrivateKey.SignMessage(message, uuid, timeNow,
ref salt, acknowledgment1192!.lastSeen),
_ => playerKeyPair!.PrivateKey.SignMessage(message, uuid, chatUuid, messageIndex++,
timeNow, ref salt, acknowledgment1193)
};
if (protocolVersion <= MC_1_19_2_Version)
fields.AddRange(DataTypes.GetVarInt(sign.Length)); // Signature length: VarInt
fields.AddRange(sign); // Signature: Byte Array
}
}
if (protocolVersion <= MC_1_19_2_Version)
fields.AddRange(dataTypes.GetBool(false)); // Signed Preview: Boolean
switch (protocolVersion)
{
case MC_1_19_2_Version:
// Message Acknowledgment (1.19.2)
fields.AddRange(dataTypes.GetAcknowledgment(acknowledgment1192!,
isOnlineMode && Config.Signature.LoginWithSecureProfile));
break;
case >= MC_1_19_3_Version:
// message count
fields.AddRange(DataTypes.GetVarInt(messageCount1193));
// Acknowledged: BitSet
fields.AddRange(bitset1193);
break;
}
SendPacket(PacketTypesOut.ChatCommand, fields);
}
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
/// <summary>
/// Send a chat message to the server
/// </summary>
/// <param name="message">Message</param>
/// <param name="playerKeyPair">PlayerKeyPair</param>
/// <returns>True if properly sent</returns>
public bool SendChatMessage(string message, PlayerKeyPair? playerKeyPair)
{
if (string.IsNullOrEmpty(message))
return true;
// Process Chat Command - 1.19 and above
if (protocolVersion >= MC_1_19_Version && message.StartsWith('/'))
return SendChatCommand(message[1..], playerKeyPair);
try
{
List<byte> fields = new();
// Message: String (up to 256 chars)
fields.AddRange(dataTypes.GetString(message));
if (protocolVersion >= MC_1_19_Version)
{
lock (MessageSigningLock)
{
var acknowledgment1192 =
protocolVersion == MC_1_19_2_Version ? ConsumeAcknowledgment() : null;
var (acknowledgment1193, bitset1193, messageCount1193) =
protocolVersion >= MC_1_19_3_Version
? lastSeenMessagesCollector.Collect_1_19_3()
: new(Array.Empty<LastSeenMessageList.AcknowledgedMessage>(), Array.Empty<byte>(), 0);
// Timestamp: Instant(Long)
var timeNow = DateTimeOffset.UtcNow;
fields.AddRange(DataTypes.GetLong(timeNow.ToUnixTimeMilliseconds()));
if (!isOnlineMode || playerKeyPair == null || !Config.Signature.LoginWithSecureProfile ||
!Config.Signature.SignChat)
{
fields.AddRange(DataTypes.GetLong(0)); // Salt: Long
fields.AddRange(protocolVersion < MC_1_19_3_Version
? DataTypes.GetVarInt(0) // Signature Length: VarInt (1.19 - 1.19.2)
: dataTypes.GetBool(false)); // Has signature: bool (1.19.3)
}
else
{
// Salt: Long
var salt = GenerateSalt();
fields.AddRange(salt);
// Signature Length & Signature: (VarInt) and Byte Array
var playerUuid = handler.GetUserUuid();
var sign = protocolVersion switch
{
MC_1_19_Version => playerKeyPair.PrivateKey.SignMessage(message, playerUuid, timeNow,
ref salt),
MC_1_19_2_Version => playerKeyPair.PrivateKey.SignMessage(message, playerUuid, timeNow,
ref salt, acknowledgment1192!.lastSeen),
_ => playerKeyPair.PrivateKey.SignMessage(message, playerUuid, chatUuid, messageIndex++,
timeNow, ref salt, acknowledgment1193)
};
fields.AddRange(protocolVersion >= MC_1_19_3_Version
? dataTypes.GetBool(true)
: DataTypes.GetVarInt(sign.Length));
fields.AddRange(sign);
}
if (protocolVersion <= MC_1_19_2_Version)
fields.AddRange(dataTypes.GetBool(false)); // Signed Preview: Boolean
switch (protocolVersion)
{
case >= MC_1_19_3_Version:
// message count
fields.AddRange(DataTypes.GetVarInt(messageCount1193));
// Acknowledged: BitSet
fields.AddRange(bitset1193);
break;
case MC_1_19_2_Version:
// Message Acknowledgment
fields.AddRange(dataTypes.GetAcknowledgment(acknowledgment1192!,
isOnlineMode && Config.Signature.LoginWithSecureProfile));
break;
}
}
}
SendPacket(PacketTypesOut.ChatMessage, fields);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SendEntityAction(int PlayerEntityID, int ActionID)
{
try
{
List<byte> fields = new();
fields.AddRange(DataTypes.GetVarInt(PlayerEntityID));
fields.AddRange(DataTypes.GetVarInt(ActionID));
fields.AddRange(DataTypes.GetVarInt(0));
SendPacket(PacketTypesOut.EntityAction, fields);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
/// <summary>
/// Send a respawn packet to the server
/// </summary>
/// <returns>True if properly sent</returns>
public bool SendRespawnPacket()
{
try
{
SendPacket(PacketTypesOut.ClientStatus, new byte[] { 0 });
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
/// <summary>
/// Tell the server what client is being used to connect to the server
/// </summary>
/// <param name="brandInfo">Client string describing the client</param>
/// <returns>True if brand info was successfully sent</returns>
public bool SendBrandInfo(string brandInfo)
{
if (string.IsNullOrEmpty(brandInfo))
return false;
// Plugin channels were significantly changed between Minecraft 1.12 and 1.13
// https://wiki.vg/index.php?title=Pre-release_protocol&oldid=14132#Plugin_Channels
return SendPluginChannelPacket(protocolVersion >= MC_1_13_Version ? "minecraft:brand" : "MC|Brand",
dataTypes.GetString(brandInfo));
}
/// <summary>
/// Inform the server of the client's Minecraft settings
/// </summary>
/// <param name="language">Client language eg en_US</param>
/// <param name="viewDistance">View distance, in chunks</param>
/// <param name="difficulty">Game difficulty (client-side...)</param>
/// <param name="chatMode">Chat mode (allows muting yourself)</param>
/// <param name="chatColors">Show chat colors</param>
/// <param name="skinParts">Show skin layers</param>
/// <param name="mainHand">1.9+ main hand</param>
/// <returns>True if client settings were successfully sent</returns>
public bool SendClientSettings(string language, byte viewDistance, byte difficulty, byte chatMode,
bool chatColors, byte skinParts, byte mainHand)
{
try
{
List<byte> fields = new();
fields.AddRange(dataTypes.GetString(language));
fields.Add(viewDistance);
fields.AddRange(protocolVersion >= MC_1_9_Version
? DataTypes.GetVarInt(chatMode)
: new byte[] { chatMode });
fields.Add(chatColors ? (byte)1 : (byte)0);
if (protocolVersion < MC_1_8_Version)
{
fields.Add(difficulty);
fields.Add((byte)(skinParts & 0x1)); //show cape
}
else fields.Add(skinParts);
if (protocolVersion >= MC_1_9_Version)
fields.AddRange(DataTypes.GetVarInt(mainHand));
if (protocolVersion >= MC_1_17_Version)
{
fields.Add(protocolVersion >= MC_1_18_1_Version
? (byte)0
: (byte)1); // 1.17 and 1.17.1 - Disable text filtering. (Always true)
// 1.18 and above - Enable text filtering. (Always false)
}
if (protocolVersion >= MC_1_18_1_Version)
fields.Add(1); // 1.18 and above - Allow server listings
SendPacket(PacketTypesOut.ClientSettings, fields);
}
catch (SocketException)
{
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
return false;
}
/// <summary>
/// Send a location update to the server
/// </summary>
/// <param name="location">The new location of the player</param>
/// <param name="onGround">True if the player is on the ground</param>
/// <param name="yaw">Optional new yaw for updating player look</param>
/// <param name="pitch">Optional new pitch for updating player look</param>
/// <returns>True if the location update was successfully sent</returns>
public bool SendLocationUpdate(Location location, bool onGround, float? yaw, float? pitch)
{
return SendLocationUpdate(location, onGround, yaw, pitch, true);
}
public bool SendLocationUpdate(Location location, bool onGround, float? yaw = null, float? pitch = null,
bool forceUpdate = false)
{
if (handler.GetTerrainEnabled())
{
var yawPitch = Array.Empty<byte>();
var packetType = PacketTypesOut.PlayerPosition;
if (Config.Main.Advanced.TemporaryFixBadpacket)
{
if (yaw.HasValue && pitch.HasValue &&
(forceUpdate || yaw.Value != LastYaw || pitch.Value != LastPitch))
{
yawPitch = dataTypes.ConcatBytes(dataTypes.GetFloat(yaw.Value),
dataTypes.GetFloat(pitch.Value));
packetType = PacketTypesOut.PlayerPositionAndRotation;
LastYaw = yaw.Value;
LastPitch = pitch.Value;
}
}
else
{
if (yaw.HasValue && pitch.HasValue)
{
yawPitch = dataTypes.ConcatBytes(dataTypes.GetFloat(yaw.Value),
dataTypes.GetFloat(pitch.Value));
packetType = PacketTypesOut.PlayerPositionAndRotation;
LastYaw = yaw.Value;
LastPitch = pitch.Value;
}
}
try
{
SendPacket(packetType, dataTypes.ConcatBytes(
dataTypes.GetDouble(location.X),
dataTypes.GetDouble(location.Y),
protocolVersion < MC_1_8_Version
? dataTypes.GetDouble(location.Y + 1.62)
: Array.Empty<byte>(),
dataTypes.GetDouble(location.Z),
yawPitch,
new byte[] { onGround ? (byte)1 : (byte)0 })
);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
else return false;
}
/// <summary>
/// Send a plugin channel packet (0x17) to the server, compression and encryption will be handled automatically
/// </summary>
/// <param name="channel">Channel to send packet on</param>
/// <param name="data">packet Data</param>
public bool SendPluginChannelPacket(string channel, byte[] data)
{
try
{
// In 1.7, length needs to be included.
// In 1.8, it must not be.
if (protocolVersion < MC_1_8_Version)
{
var length = BitConverter.GetBytes((short)data.Length);
Array.Reverse(length);
SendPacket(PacketTypesOut.PluginMessage,
dataTypes.ConcatBytes(dataTypes.GetString(channel), length, data));
}
else
{
SendPacket(PacketTypesOut.PluginMessage, dataTypes.ConcatBytes(dataTypes.GetString(channel), data));
}
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
/// <summary>
/// Send a Login Plugin Response packet (0x02)
/// </summary>
/// <param name="messageId">Login Plugin Request message Id </param>
/// <param name="understood">TRUE if the request was understood</param>
/// <param name="data">Response to the request</param>
/// <returns>TRUE if successfully sent</returns>
public bool SendLoginPluginResponse(int messageId, bool understood, byte[] data)
{
try
{
SendPacket(0x02,
dataTypes.ConcatBytes(DataTypes.GetVarInt(messageId), dataTypes.GetBool(understood), data));
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
/// <summary>
/// Send an Interact Entity Packet to server
/// </summary>
/// <param name="EntityID"></param>
/// <param name="type"></param>
/// <returns></returns>
public bool SendInteractEntity(int EntityID, int type)
{
try
{
List<byte> fields = new();
fields.AddRange(DataTypes.GetVarInt(EntityID));
fields.AddRange(DataTypes.GetVarInt(type));
// Is player Sneaking (Only 1.16 and above)
// Currently hardcoded to false
// TODO: Update to reflect the real player state
if (protocolVersion >= MC_1_16_Version)
fields.AddRange(dataTypes.GetBool(false));
SendPacket(PacketTypesOut.InteractEntity, fields);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
// TODO: Interact at block location (e.g. chest minecart)
public bool SendInteractEntity(int EntityID, int type, float X, float Y, float Z, int hand)
{
try
{
List<byte> fields = new();
fields.AddRange(DataTypes.GetVarInt(EntityID));
fields.AddRange(DataTypes.GetVarInt(type));
fields.AddRange(dataTypes.GetFloat(X));
fields.AddRange(dataTypes.GetFloat(Y));
fields.AddRange(dataTypes.GetFloat(Z));
fields.AddRange(DataTypes.GetVarInt(hand));
// Is player Sneaking (Only 1.16 and above)
// Currently hardcoded to false
// TODO: Update to reflect the real player state
if (protocolVersion >= MC_1_16_Version)
fields.AddRange(dataTypes.GetBool(false));
SendPacket(PacketTypesOut.InteractEntity, fields);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SendInteractEntity(int EntityID, int type, int hand)
{
try
{
List<byte> fields = new();
fields.AddRange(DataTypes.GetVarInt(EntityID));
fields.AddRange(DataTypes.GetVarInt(type));
fields.AddRange(DataTypes.GetVarInt(hand));
// Is player Sneaking (Only 1.16 and above)
// Currently hardcoded to false
// TODO: Update to reflect the real player state
if (protocolVersion >= MC_1_16_Version)
fields.AddRange(dataTypes.GetBool(false));
SendPacket(PacketTypesOut.InteractEntity, fields);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SendInteractEntity(int EntityID, int type, float X, float Y, float Z)
{
return false;
}
public bool SendUseItem(int hand, int sequenceId)
{
if (protocolVersion < MC_1_9_Version)
return false; // Packet does not exist prior to MC 1.9
// According to https://wiki.vg/index.php?title=Protocol&oldid=5486#Player_Block_Placement
// MC 1.7 does this using Player Block Placement with special values
// TODO once Player Block Placement is implemented for older versions
try
{
List<byte> packet = new();
packet.AddRange(DataTypes.GetVarInt(hand));
if (protocolVersion >= MC_1_19_Version)
packet.AddRange(DataTypes.GetVarInt(sequenceId));
SendPacket(PacketTypesOut.UseItem, packet);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SendPlayerDigging(int status, Location location, Direction face, int sequenceId)
{
try
{
List<byte> packet = new();
packet.AddRange(DataTypes.GetVarInt(status));
packet.AddRange(dataTypes.GetLocation(location));
packet.AddRange(DataTypes.GetVarInt(dataTypes.GetBlockFace(face)));
if (protocolVersion >= MC_1_19_Version)
packet.AddRange(DataTypes.GetVarInt(sequenceId));
SendPacket(PacketTypesOut.PlayerDigging, packet);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SendPlayerBlockPlacement(int hand, Location location, Direction face, int sequenceId)
{
try
{
var packet = new List<byte>();
switch (protocolVersion)
{
case < MC_1_9_Version:
packet.AddRange(dataTypes.GetLocation(location));
packet.Add(dataTypes.GetBlockFace(face));
var playerInventory = handler.GetInventory(0);
if (playerInventory?.Items is null)
return false;
var slotWindowIds = new int[]{ 36, 37, 38, 39, 40, 41, 42, 43, 44 };
var currentSlot = ((McClient)handler).GetCurrentSlot();
playerInventory.Items.TryGetValue(slotWindowIds[currentSlot], out var item);
packet.AddRange(dataTypes.GetItemSlot(item, itemPalette));
packet.Add(0); // cursorX
packet.Add(0); // cursorY
packet.Add(0); // cursorZ
return true;
case < MC_1_14_Version:
packet.AddRange(dataTypes.GetLocation(location));
packet.AddRange(DataTypes.GetVarInt(dataTypes.GetBlockFace(face)));
packet.AddRange(DataTypes.GetVarInt(hand));
break;
default:
packet.AddRange(DataTypes.GetVarInt(hand));
packet.AddRange(dataTypes.GetLocation(location));
packet.AddRange(DataTypes.GetVarInt(dataTypes.GetBlockFace(face)));
break;
}
packet.AddRange(dataTypes.GetFloat(0.5f)); // cursorX
packet.AddRange(dataTypes.GetFloat(0.5f)); // cursorY
packet.AddRange(dataTypes.GetFloat(0.5f)); // cursorZ
if(protocolVersion >= MC_1_14_Version)
packet.Add(0); // insideBlock = false
if (protocolVersion >= MC_1_19_Version)
packet.AddRange(DataTypes.GetVarInt(sequenceId));
SendPacket(PacketTypesOut.PlayerBlockPlacement, packet);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SendHeldItemChange(short slot)
{
try
{
List<byte> packet = new();
packet.AddRange(dataTypes.GetShort(slot));
SendPacket(PacketTypesOut.HeldItemChange, packet);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SendWindowAction(int windowId, int slotId, WindowActionType action, Item? item,
List<Tuple<short, Item?>> changedSlots, int stateId)
{
try
{
short actionNumber;
lock (window_actions)
{
if (!window_actions.ContainsKey(windowId))
window_actions[windowId] = 0;
actionNumber = (short)(window_actions[windowId] + 1);
window_actions[windowId] = actionNumber;
}
byte button = 0;
byte mode = 0;
switch (action)
{
case WindowActionType.LeftClick:
button = 0;
break;
case WindowActionType.RightClick:
button = 1;
break;
case WindowActionType.MiddleClick:
button = 2;
mode = 3;
break;
case WindowActionType.ShiftClick:
button = 0;
mode = 1;
item = new Item(ItemType.Null, 0, null);
break;
case WindowActionType.ShiftRightClick: // Right-shift click uses button 1
button = 1;
mode = 1;
item = new Item(ItemType.Null, 0, null);
break;
case WindowActionType.DropItem:
button = 0;
mode = 4;
item = new Item(ItemType.Null, 0, null);
break;
case WindowActionType.DropItemStack:
button = 1;
mode = 4;
item = new Item(ItemType.Null, 0, null);
break;
case WindowActionType.StartDragLeft:
button = 0;
mode = 5;
item = new Item(ItemType.Null, 0, null);
slotId = -999;
break;
case WindowActionType.StartDragRight:
button = 4;
mode = 5;
item = new Item(ItemType.Null, 0, null);
slotId = -999;
break;
case WindowActionType.StartDragMiddle:
button = 8;
mode = 5;
item = new Item(ItemType.Null, 0, null);
slotId = -999;
break;
case WindowActionType.EndDragLeft:
button = 2;
mode = 5;
item = new Item(ItemType.Null, 0, null);
slotId = -999;
break;
case WindowActionType.EndDragRight:
button = 6;
mode = 5;
item = new Item(ItemType.Null, 0, null);
slotId = -999;
break;
case WindowActionType.EndDragMiddle:
button = 10;
mode = 5;
item = new Item(ItemType.Null, 0, null);
slotId = -999;
break;
case WindowActionType.AddDragLeft:
button = 1;
mode = 5;
item = new Item(ItemType.Null, 0, null);
break;
case WindowActionType.AddDragRight:
button = 5;
mode = 5;
item = new Item(ItemType.Null, 0, null);
break;
case WindowActionType.AddDragMiddle:
button = 9;
mode = 5;
item = new Item(ItemType.Null, 0, null);
break;
}
List<byte> packet = new()
{
(byte)windowId // Window ID
};
switch (protocolVersion)
{
// 1.18+
case >= MC_1_18_1_Version:
packet.AddRange(DataTypes.GetVarInt(stateId)); // State ID
packet.AddRange(dataTypes.GetShort((short)slotId)); // Slot ID
break;
// 1.17.1
case MC_1_17_1_Version:
packet.AddRange(dataTypes.GetShort((short)slotId)); // Slot ID
packet.AddRange(DataTypes.GetVarInt(stateId)); // State ID
break;
// Older
default:
packet.AddRange(dataTypes.GetShort((short)slotId)); // Slot ID
break;
}
packet.Add(button); // Button
if (protocolVersion < MC_1_17_Version)
packet.AddRange(dataTypes.GetShort(actionNumber));
if (protocolVersion >= MC_1_9_Version)
packet.AddRange(DataTypes.GetVarInt(mode)); // Mode
else packet.Add(mode);
// 1.17+ Array of changed slots
if (protocolVersion >= MC_1_17_Version)
{
packet.AddRange(DataTypes.GetVarInt(changedSlots.Count)); // Length of the array
foreach (var slot in changedSlots)
{
packet.AddRange(dataTypes.GetShort(slot.Item1)); // slot ID
packet.AddRange(dataTypes.GetItemSlot(slot.Item2, itemPalette)); // slot Data
}
}
packet.AddRange(dataTypes.GetItemSlot(item, itemPalette)); // Carried item (Clicked item)
SendPacket(PacketTypesOut.ClickWindow, packet);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SendCreativeInventoryAction(int slot, ItemType itemType, int count, Dictionary<string, object>? nbt)
{
try
{
List<byte> packet = new();
packet.AddRange(dataTypes.GetShort((short)slot));
packet.AddRange(dataTypes.GetItemSlot(new Item(itemType, count, nbt), itemPalette));
SendPacket(PacketTypesOut.CreativeInventoryAction, packet);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SendChunkBatchReceived(float desiredNumberOfChunksPerBatch)
{
try
{
List<byte> packet = new();
packet.AddRange(dataTypes.GetFloat(desiredNumberOfChunksPerBatch));
SendPacket(PacketTypesOut.ChunkBatchReceived, packet);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SendAcknowledgeConfiguration()
{
try
{
SendPacket(PacketTypesOut.AcknowledgeConfiguration, new List<byte>());
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool ClickContainerButton(int windowId, int buttonId)
{
try
{
var packet = new List<byte>
{
(byte)windowId,
(byte)buttonId
};
SendPacket(PacketTypesOut.ClickWindowButton, packet);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SendAnimation(int animation, int playerId)
{
try
{
if (animation is not (0 or 1)) return false;
List<byte> packet = new();
switch (protocolVersion)
{
case < MC_1_8_Version:
packet.AddRange(DataTypes.GetInt(playerId));
packet.Add(1); // Swing arm
break;
case < MC_1_9_Version:
// No fields in 1.8.X
break;
// MC 1.9+
default:
packet.AddRange(DataTypes.GetVarInt(animation));
break;
}
SendPacket(PacketTypesOut.Animation, packet);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SendCloseWindow(int windowId)
{
try
{
lock (window_actions)
{
if (window_actions.ContainsKey(windowId))
window_actions[windowId] = 0;
}
SendPacket(PacketTypesOut.CloseWindow, new[] { (byte)windowId });
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SendUpdateSign(Location sign, string line1, string line2, string line3, string line4,
bool isFrontText = true)
{
try
{
if (line1.Length > 23)
line1 = line1[..23];
if (line2.Length > 23)
line2 = line2[..23];
if (line3.Length > 23)
line3 = line3[..23];
if (line4.Length > 23)
line4 = line4[..23];
List<byte> packet = new();
packet.AddRange(dataTypes.GetLocation(sign));
if (protocolVersion >= MC_1_20_Version)
packet.AddRange(dataTypes.GetBool(isFrontText));
packet.AddRange(dataTypes.GetString(line1));
packet.AddRange(dataTypes.GetString(line2));
packet.AddRange(dataTypes.GetString(line3));
packet.AddRange(dataTypes.GetString(line4));
SendPacket(PacketTypesOut.UpdateSign, packet);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool UpdateCommandBlock(Location location, string command, CommandBlockMode mode,
CommandBlockFlags flags)
{
if (protocolVersion > MC_1_13_Version) return false;
try
{
List<byte> packet = new();
packet.AddRange(dataTypes.GetLocation(location));
packet.AddRange(dataTypes.GetString(command));
packet.AddRange(DataTypes.GetVarInt((int)mode));
packet.Add((byte)flags);
SendPacket(PacketTypesOut.UpdateSign, packet);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SendWindowConfirmation(byte windowID, short actionID, bool accepted)
{
try
{
var packet = new List<byte>() { windowID };
packet.AddRange(dataTypes.GetShort(actionID));
packet.Add(accepted ? (byte)1 : (byte)0);
SendPacket(PacketTypesOut.WindowConfirmation, packet);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SelectTrade(int selectedSlot)
{
// MC 1.13 or greater
if (protocolVersion < MC_1_13_Version) return false;
try
{
List<byte> packet = new();
packet.AddRange(DataTypes.GetVarInt(selectedSlot));
SendPacket(PacketTypesOut.SelectTrade, packet);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SendSpectate(Guid uuid)
{
// MC 1.8 or greater
if (protocolVersion < MC_1_8_Version) return false;
try
{
List<byte> packet = new();
packet.AddRange(DataTypes.GetUUID(uuid));
SendPacket(PacketTypesOut.Spectate, packet);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
public bool SendPlayerSession(PlayerKeyPair? playerKeyPair)
{
if (playerKeyPair == null || !isOnlineMode)
return false;
if (protocolVersion >= MC_1_19_3_Version)
{
try
{
List<byte> packet = new();
packet.AddRange(DataTypes.GetUUID(chatUuid));
packet.AddRange(DataTypes.GetLong(playerKeyPair.GetExpirationMilliseconds()));
packet.AddRange(DataTypes.GetVarInt(playerKeyPair.PublicKey.Key.Length));
packet.AddRange(playerKeyPair.PublicKey.Key);
packet.AddRange(DataTypes.GetVarInt(playerKeyPair.PublicKey.SignatureV2!.Length));
packet.AddRange(playerKeyPair.PublicKey.SignatureV2);
log.Debug(
$"SendPlayerSession MessageUUID = {chatUuid.ToString()}, len(PublicKey) = {playerKeyPair.PublicKey.Key.Length}, len(SignatureV2) = {playerKeyPair.PublicKey.SignatureV2!.Length}");
SendPacket(PacketTypesOut.PlayerSession, packet);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
return false;
}
public bool SendRenameItem(string itemName)
{
try
{
List<byte> packet = new();
packet.AddRange(dataTypes.GetString(itemName.Length > 50 ? itemName[..50] : itemName));
SendPacket(PacketTypesOut.NameItem, packet);
return true;
}
catch (SocketException)
{
return false;
}
catch (System.IO.IOException)
{
return false;
}
catch (ObjectDisposedException)
{
return false;
}
}
private byte[] GenerateSalt()
{
var salt = new byte[8];
randomGen.GetNonZeroBytes(salt);
return salt;
}
private static long GetNanos()
{
var nano = 10000L * Stopwatch.GetTimestamp();
nano /= TimeSpan.TicksPerMillisecond;
nano *= 100L;
return nano;
}
}
internal enum CurrentState
{
Login = 0,
Configuration,
Play
}
}
Reference in a new issue View git blame Copy permalink