1 files changed, 37 insertions, 39 deletions

diff --git a/Net.cs b/Net.cs
index 497c66d..b99a0f6 100644
--- a/Net.cs
+++ b/Net.cs
@@ -1,85 +1,83 @@
 using System.Buffers.Binary;
-using System.Net.Sockets;
+using LiteNetLib.Utils;
 
 namespace OnekoOnline.Net;
 
-static class NetBase
+public static class NetExtensions
 {
-    public static async Task<Packet> GetReliableData(NetworkStream stream, CancellationToken token = default)
+    public static void Put(this NetDataWriter writer, PacketInfo info)
     {
-        byte[] infoBytes = new byte[PacketInfo.SizeOf];
-        await stream.ReadExactlyAsync(infoBytes, token);
-        PacketInfo info = PacketInfo.Deserialize(infoBytes);
-        if (info.Type == PacketType.Ping || info.Type == PacketType.Disconnect) return new(info.Type, [], info.FromId);
-
-        byte[] data = new byte[info.DataSize];
-        await stream.ReadExactlyAsync(data, token);
+        writer.Put(info.Serialize());
+    }
 
-        return new Packet(info.Type, data, info.FromId);
+    public static PacketInfo GetPacketInfo(this NetDataReader reader)
+    {
+        return PacketInfo.Deserialize(reader.GetBytesSegment(PacketInfo.SizeOf));
     }
 
-    public static async Task SendReliableData(Packet packet, NetworkStream stream, CancellationToken token = default)
+    public static PacketInfo PeekPacketInfo(this NetDataReader reader)
     {
-        byte[] info = new byte[PacketInfo.SizeOf];
-        new PacketInfo(packet).Serialize(info);
+        if (reader.AvailableBytes < PacketInfo.SizeOf) return PacketInfo.InvalidPacket;
+        return PacketInfo.Deserialize(reader.RawData.AsSpan(0, PacketInfo.SizeOf));
+    }
 
-        await stream.WriteAsync(info, token);
-        await stream.WriteAsync(packet.Data, token);
+    public static void ResetWithInfo(this NetDataWriter writer, PacketInfo info)
+    {
+        writer.Reset();
+        writer.Put(info);
     }
-}
 
-public readonly struct Packet(PacketType type, byte[] data, int id)
-{
-    public readonly PacketType Type = type;
-    public readonly byte[] Data = data;
-    public readonly int FromId = id;
+    public static void ResetWithInfo(this NetDataWriter writer, PacketInfo info, int size)
+    {
+        writer.Reset(size+PacketInfo.SizeOf);
+        writer.Put(info);
+    }
 }
 
 public enum PacketType : byte
 {
     MousePosition,
     OnekoState,
-    Ping,
     OnekoSpritesheet,
     Username,
     UserId,
-    Disconnect
+    Disconnect,
+    Invalid
 }
 
 public struct PacketInfo
 {
-    public readonly int DataSize;
     public readonly PacketType Type;
     public readonly int FromId;
-    public const int SizeOf = (sizeof(int)*2) + 1;
+    public const int SizeOf = sizeof(int) + 1;
+    public readonly bool IsValid => Type != PacketType.Invalid;
 
-    public PacketInfo(Packet packet)
-    {
-        DataSize = packet.Data.Length;
-        Type = packet.Type;
-        FromId = packet.FromId;
-    }
+    public static readonly PacketInfo InvalidPacket = new(PacketType.Invalid, -1);
 
-    public PacketInfo(PacketType type, int size, int id)
+    public PacketInfo(PacketType type, int id)
     {
         Type = type;
-        DataSize = size;
         FromId = id;
     }
 
     public readonly void Serialize(Span<byte> span)
     {
         span[0] = (byte)Type;
-        BinaryPrimitives.WriteInt32LittleEndian(span[1..], DataSize);
-        BinaryPrimitives.WriteInt32LittleEndian(span[(1+sizeof(int))..], FromId);
+        BinaryPrimitives.WriteInt32LittleEndian(span[1..], FromId);
+    }
+
+    public readonly byte[] Serialize()
+    {
+        byte[] bytes = new byte[SizeOf];
+        Serialize(bytes);
+        return bytes;
     }
 
     public static PacketInfo Deserialize(ReadOnlySpan<byte> span)
     {
         PacketType type = (PacketType)span[0];
-        int size = BinaryPrimitives.ReadInt32LittleEndian(span[1..]);
-        int id = BinaryPrimitives.ReadInt32LittleEndian(span[(1+sizeof(int))..]);
-        return new PacketInfo(type, size, id);
+        int id = BinaryPrimitives.ReadInt32LittleEndian(span[1..]);
+        return new PacketInfo(type, id);
     }
 }