public void ClientOnPackageReceived(IPacketInfo packet)
{
try
{
var offsets = PacketInfo.GetOffsetInfo(packet.Buffer, packet.Offset);
foreach (var item in offsets)
{
try
{
var operationCode = MessageBase.GetOperationCode(packet.Buffer, item.Offset);
if (operationCode != ShamanOperationCode.Bundle)
{
_logger.Debug($"Shaman message received. Operation code: {operationCode}");
_shamanMessageHandler.ProcessMessage(operationCode, packet.Buffer, item.Offset, item.Length);
}
else
{
_logger.Debug($"Bundle message received. Operation code: {operationCode}");
var bundleOperationCode = MessageBase.GetOperationCode(packet.Buffer, item.Offset + 1);
_bundleMessageHandler.ProcessMessage(bundleOperationCode, packet.Buffer, item.Offset + 1, item.Length - 1);
}
}
catch (Exception ex)
{
_logger.Error(ex);
SetAndReportStatus(_status, _statusCallback, false, ex.Message);
}
}
}
finally
{
packet.Dispose();
}
}
private IPacket ReadPacket(byte packetId, byte[] data)
{
// TODO: f**k. direction wont work
IPacketInfo packetInfo = _packetInfoSource.GetPacketInfo(packetId, PacketDirection.Clientbound, _currentState);
if (packetInfo == null)
{
// TODO: Change back to warning once more packets are implemented
Log.DebugFormat("S->C Unkown packet 0x{0:X2}. Size: {1} bytes", packetId, data.Length);
return(null);
}
IPacket packet;
using (var memoryStream = new MemoryStream(data))
using (var reader = new MinecraftStreamReader(memoryStream))
{
packet = packetInfo.ReadPacketFromStream(reader);
if (memoryStream.Position < data.Length)
{
Log.WarnFormat("Packet {0} did not read all available data. Remaining bytes: {1}", packetInfo.Type.Name, data.Length - memoryStream.Position);
}
}
return(packet);
}
//in unity this should be overriden to process messages inside the main thread
protected virtual void StartProcessingMessagesLoop()
{
_pollingTask = _taskScheduler.ScheduleOnInterval(() =>
{
IPacketInfo pack = null;
while ((pack = PopNextPacket()) != null)
{
//launch callback in another thread
var pack1 = pack;
_taskScheduler.ScheduleOnceOnNow(() => { ClientOnPackageReceived(pack1); });
}
}, 0, _pollPackageQueueIntervalMs);
}
public TestClientPeer(IShamanLogger logger, ITaskSchedulerFactory taskSchedulerFactory, ISerializer serializer)
{
_logger = logger;
_serializer = serializer;
_taskScheduler = taskSchedulerFactory.GetTaskScheduler();
_clientPeer = new ClientPeer(logger, taskSchedulerFactory, 300, 10);
//_clientPeer.OnPackageReceived += ClientOnPackageReceived;
_clientPeer.OnDisconnectedFromServer = OnDisconnected;
_taskScheduler.ScheduleOnInterval(() =>
{
IPacketInfo pack = null;
while ((pack = _clientPeer.PopNextPacket()) != null)
{
ClientOnPackageReceived(pack);
}
}, 0, 10);
}
private void ClientOnPackageReceived(IPacketInfo packet)
{
lock (_syncCollection)
{
var offsets = PacketInfo.GetOffsetInfo(packet.Buffer, packet.Offset);
foreach (var item in offsets)
{
try
{
ProcessMessage(packet.Buffer, item.Offset, item.Length);
}
catch (Exception ex)
{
_logger.Error($"Error processing message: {ex}");
}
}
packet.Dispose();
}
}
private void StartProcessingMessagesLoop()
{
_pollingTask = _taskScheduler.ScheduleOnInterval(() =>
{
IPacketInfo pack = null;
while ((pack = PopNextPacket()) != null)
{
//launch callback in another thread
var pack1 = pack;
_taskScheduler.ScheduleOnceOnNow(() =>
{
try
{
ClientOnPackageReceived(pack1);
}
catch (Exception e)
{
_logger.Error($"ClientOnPackageReceived error: {e}");
}
});
}
}, 0, _pollPackageQueueIntervalMs);
}
private void WritePacket(IPacket packet)
{
Log.TraceFormat("C->S {0}", packet.GetType().Name);
IPacketInfo packetInfo = _packetInfoSource.GetPacketInfo(packet);
// TODO: Error handling
if (packetInfo == null)
{
return;
}
var dataStream = new MemoryStream();
var dataWriter = new MinecraftStreamWriter(dataStream);
dataWriter.WriteVarInt(packetInfo.Id);
packetInfo.WritePacketToStream(packet, dataWriter);
if (_compressionEnabled)
{
// Packet ID + Data
byte[] compressedData;
int dataLength;
if (dataStream.Length > _compressionThreshold)
{
// Compress the packet id + data
using (var outputStream = new MemoryStream())
using (var inputStream = new DeflaterOutputStream(outputStream, new Deflater(0)))
{
inputStream.Write(dataStream.GetBuffer(), 0, (int)dataStream.Length);
inputStream.Close();
compressedData = outputStream.ToArray();
}
dataLength = compressedData.Length;
}
else
{
// Not really compressed
compressedData = dataStream.ToArray();
dataLength = 0;
}
int packetLength = dataLength.GetVarIntLength() + compressedData.Length;
// Packet length, data length, then compressed data
_writer.WriteVarInt(packetLength);
_writer.WriteVarInt(dataLength);
_baseStream.Write(compressedData, 0, compressedData.Length);
}
else
{
// Write packet length and ID
_writer.WriteVarInt((int)dataStream.Length);
//_writer.WriteVarInt(packetInfo.Id);
_baseStream.Write(dataStream.GetBuffer(), 0, (int)dataStream.Length);
}
_networkStream.Flush();
}
