/// <summary>
/// Send a packet to multiple clients.
/// </summary>
/// <param name="excepts">clients to exclude</param>
public void Send(List <NecClient> clients, NecPacket packet, params NecClient[] excepts)
{
clients = GetClients(clients, excepts);
foreach (NecClient client in clients)
{
Send(client, packet);
}
}
/// <summary>
/// Send a packet to everyone in the map.
/// </summary>
public void Send(Map map, NecPacket packet, params NecClient[] excepts)
{
List <NecClient> clients = GetClients(map.ClientLookup.GetAll(), excepts);
foreach (NecClient client in clients)
{
Send(client, packet);
}
}
public NecPacket ToPacket()
{
if (_packet == null)
{
_packet = new NecPacket(id, ToBuffer(), serverType);
}
return(_packet);
}
public byte[] Write(NecPacket packet, NecClient client)
{
// TODO update arrowgene service to write uint*
byte[] data = packet.Data.GetAllBytes();
IBuffer buffer = BufferProvider.Provide();
ulong dataSize = (ushort)(data.Length + PacketIdSize);
PacketLengthType packetLengthType;
if (dataSize < byte.MaxValue)
{
packetLengthType = PacketLengthType.Byte;
buffer.WriteByte((byte)packetLengthType);
buffer.WriteByte((byte)dataSize);
}
else if (dataSize < ushort.MaxValue)
{
packetLengthType = PacketLengthType.UInt16;
buffer.WriteByte((byte)packetLengthType);
buffer.WriteInt16((ushort)dataSize);
}
else if (dataSize < uint.MaxValue)
{
packetLengthType = PacketLengthType.UInt32;
buffer.WriteByte((byte)packetLengthType);
buffer.WriteInt32((uint)dataSize);
}
else
{
_logger.Error($"{dataSize} to big");
return(null);
}
buffer.WriteInt16(packet.Id);
buffer.WriteBytes(data);
byte headerSize = CalculateHeaderSize(packetLengthType);
packet.Header = buffer.GetBytes(0, headerSize);
return(buffer.GetAllBytes());
}
public abstract void Handle(NecClient client, NecPacket packet);
public byte[] Write(NecPacket packet)
{
byte[] data = packet.Data.GetAllBytes();
IBuffer buffer = BufferProvider.Provide();
PacketType packetType;
switch (packet.PacketType)
{
case PacketType.HeartBeat:
packetType = PacketType.HeartBeat;
buffer.WriteByte((byte)packetType);
buffer.WriteBytes(data);
break;
case PacketType.Unknown1:
packetType = PacketType.Unknown1;
buffer.WriteByte((byte)packetType);
buffer.WriteBytes(data);
break;
case PacketType.Disconnect:
packetType = PacketType.Disconnect;
buffer.WriteByte((byte)packetType);
buffer.WriteBytes(data);
break;
default:
ulong dataSize = (ulong)(data.Length + PacketIdSize);
if (dataSize < byte.MaxValue)
{
packetType = PacketType.Byte;
buffer.WriteByte((byte)packetType);
buffer.WriteByte((byte)dataSize);
}
else if (dataSize < ushort.MaxValue)
{
packetType = PacketType.UInt16;
buffer.WriteByte((byte)packetType);
buffer.WriteUInt16((ushort)dataSize);
}
else if (dataSize < uint.MaxValue)
{
packetType = PacketType.UInt32;
buffer.WriteByte((byte)packetType);
buffer.WriteUInt32((uint)dataSize);
}
else
{
Logger.Error($"{dataSize} to big");
return(null);
}
buffer.WriteUInt16(packet.Id);
buffer.WriteBytes(data);
break;
}
byte headerSize = CalculateHeaderSize(packetType);
packet.Header = buffer.GetBytes(0, headerSize);
return(buffer.GetAllBytes());
}
public List <NecPacket> Read(byte[] data, ServerType serverType)
{
List <NecPacket> packets = new List <NecPacket>();
if (_buffer == null)
{
_buffer = BufferProvider.Provide(data);
}
else
{
_buffer.SetPositionEnd();
_buffer.WriteBytes(data);
}
_buffer.Position = _position;
bool read = true;
while (read)
{
read = false;
if (!_readPacketLengthType &&
_buffer.Size - _buffer.Position > PacketLengthTypeSize)
{
byte lengthType = _buffer.ReadByte();
if (!Enum.IsDefined(typeof(PacketType), lengthType))
{
Logger.Error($"PacketType: '{lengthType}' not found");
Reset();
return(packets);
}
_readPacketLengthType = true;
_packetType = (PacketType)lengthType;
_headerSize = CalculateHeaderSize(_packetType);
}
if (_readPacketLengthType &&
!_readHeader &&
_buffer.Size - _buffer.Position >= _headerSize - PacketLengthTypeSize)
{
// TODO acquire 1st byte differently in case -1 doesnt work
_header = _buffer.GetBytes(_buffer.Position - PacketLengthTypeSize, _headerSize);
switch (_packetType)
{
case PacketType.Byte:
{
_dataSize = _buffer.ReadByte();
_dataSize -= PacketIdSize;
_id = _buffer.ReadUInt16();
_readHeader = true;
break;
}
case PacketType.UInt16:
{
_dataSize = _buffer.ReadUInt16();
_dataSize -= PacketIdSize;
_id = _buffer.ReadUInt16();
_readHeader = true;
break;
}
case PacketType.UInt32:
{
_dataSize = _buffer.ReadUInt32();
_dataSize -= PacketIdSize;
_id = _buffer.ReadUInt16();
_readHeader = true;
break;
}
case PacketType.HeartBeat:
{
_dataSize = HeartbeatPacketBodySize;
_id = (ushort)CustomPacketId.SendHeartbeat;
_readHeader = true;
break;
}
case PacketType.Unknown1:
{
_dataSize = Unknown1PacketBodySize;
_id = (ushort)CustomPacketId.SendUnknown1;
_readHeader = true;
break;
}
case PacketType.Disconnect:
{
_dataSize = DisconnectPacketBodySize;
_id = (ushort)CustomPacketId.SendDisconnect;
_readHeader = true;
break;
}
default:
{
// TODO update arrowgene buffer to read uint24 && int24
Logger.Error($"PacketType: '{_packetType}' not supported");
Reset();
return(packets);
}
}
}
if (_readPacketLengthType &&
_readHeader &&
_buffer.Size - _buffer.Position >= _dataSize)
{
// TODO update arrowgene service to read uint
byte[] packetData = _buffer.ReadBytes((int)_dataSize);
IBuffer buffer = BufferProvider.Provide(packetData);
NecPacket packet = new NecPacket(_id, buffer, serverType);
packet.Header = _header;
packets.Add(packet);
_readPacketLengthType = false;
_readHeader = false;
read = _buffer.Position != _buffer.Size;
}
}
if (_buffer.Position == _buffer.Size)
{
Reset();
}
else
{
_position = _buffer.Position;
}
return(packets);
}
/// <summary>
/// Send a packet to a client.
/// </summary>
public void Send(NecClient client, ushort id, IBuffer data)
{
NecPacket packet = new NecPacket(id, data);
Send(client, packet);
}
/// <summary>
/// Send a packet to a client.
/// </summary>
public void Send(NecClient client, NecPacket packet)
{
client.Send(packet);
}
public List <NecPacket> Read(byte[] data, NecClient client)
{
List <NecPacket> packets = new List <NecPacket>();
if (_buffer == null)
{
_buffer = BufferProvider.Provide(data);
}
else
{
_buffer.SetPositionEnd();
_buffer.WriteBytes(data);
}
_buffer.Position = _position;
bool read = true;
while (read)
{
read = false;
if (!_readPacketLengthType &&
_buffer.Size - _buffer.Position > PacketLengthTypeSize)
{
byte lengthType = _buffer.ReadByte();
if (!Enum.IsDefined(typeof(PacketLengthType), lengthType))
{
_logger.Error($"PacketLengthType: '{lengthType}' not found");
byte[] dataDump = _buffer.GetBytes(_buffer.Position - 1, _buffer.Size);
_logger.LogErrorPacket(client, dataDump, null);
Reset();
return(packets);
}
_readPacketLengthType = true;
_packetLengthType = (PacketLengthType)lengthType;
_headerSize = CalculateHeaderSize(_packetLengthType);
}
if (_readPacketLengthType &&
!_readHeader &&
_buffer.Size - _buffer.Position >= _headerSize - PacketLengthTypeSize)
{
// TODO aquire 1st byte differently incase -1 doesnt work
_header = _buffer.GetBytes(_buffer.Position - PacketLengthTypeSize, _headerSize);
switch (_packetLengthType)
{
case PacketLengthType.Byte:
{
_dataSize = _buffer.ReadByte();
break;
}
case PacketLengthType.UInt16:
{
_dataSize = _buffer.ReadUInt16();
break;
}
case PacketLengthType.UInt32:
{
_dataSize = _buffer.ReadUInt32();
break;
}
default:
{
// TODO update arrowgene service to read uint24 && int24
_logger.Error($"PacketLengthType: '{_packetLengthType}' not supported");
Reset();
return(packets);
}
}
_dataSize -= PacketIdSize;
_id = _buffer.ReadUInt16();
_readHeader = true;
}
if (_readPacketLengthType &&
_readHeader &&
_buffer.Size - _buffer.Position >= _dataSize)
{
// TODO update arrowgene service to read uint
byte[] packetData = _buffer.ReadBytes((int)_dataSize);
IBuffer buffer = BufferProvider.Provide(packetData);
NecPacket packet = new NecPacket(_id, buffer);
packet.Header = _header;
packets.Add(packet);
_readPacketLengthType = false;
_readHeader = false;
read = _buffer.Position != _buffer.Size;
}
}
if (_buffer.Position == _buffer.Size)
{
Reset();
}
else
{
_position = _buffer.Position;
}
return(packets);
}
public abstract void Handle(NecConnection client, NecPacket packet);
/// <summary>
/// Send a packet to a connection.
/// </summary>
public void Send(NecConnection connection, ushort id, IBuffer data)
{
NecPacket packet = new NecPacket(id, data, connection.ServerType);
Send(connection, packet);
}
/// <summary>
/// Send a packet to a client.
/// </summary>
public void Send(NecClient client, ushort id, IBuffer data, ServerType serverType)
{
NecPacket packet = new NecPacket(id, data, serverType);
Send(client, packet);
}
/// <summary>
/// Send a packet to a connection.
/// </summary>
public void Send(NecConnection connection, NecPacket packet)
{
connection.Send(packet);
}
public override void Handle(NecClient client, NecPacket requestPacket)
{
T request = _deserializer.Deserialize(requestPacket);
HandleRequest(client, request);
}
