my god what a refractor. udp is working, websockets are not but it will get fixed..... eventually

Author: GuilhermeStrice

Infinity.Core/Events/DataReceivedEvent.cs

@@ -2,23 +2,7 @@
 {
     public struct DataReceivedEvent
     {
-        public NetworkConnection? Connection;
-        public MessageReader? Message;
-
-        public void Recycle(bool _recycle_message)
-        {
-            if (_recycle_message)
-            {
-                Message.Recycle();
-            }
-
-            Message = null;
-            Connection = null;
-        }
-
-        public void Recycle()
-        {
-            Recycle(true);
-        }
+        public NetworkConnection Connection;
+        public MessageReader Message;
     }
 }

Infinity.Core/Events/DisconnectedEvent.cs

@@ -2,25 +2,8 @@
 {
     public struct DisconnectedEvent
     {
-        public NetworkConnection? Connection;
-        public MessageReader? Message;
+        public NetworkConnection Connection;
+        public MessageReader Message;
         public string? Reason;
-
-        public void Recycle(bool _recycle_message)
-        {
-            if (_recycle_message)
-            {
-                Message?.Recycle();
-            }
-
-            Connection = null;
-            Message = null;
-            Reason = string.Empty;
-        }
-
-        public void Recycle()
-        {
-            Recycle(true);
-        }
     }
 }

Infinity.Core/Events/NewConnectionEvent.cs

@@ -2,26 +2,7 @@
 {
     public struct NewConnectionEvent
     {
-        public NetworkConnection? Connection;
-        public MessageReader? HandshakeData;
-
-        public void Recycle(bool _recycle_message)
-        {
-            if (_recycle_message)
-            {
-                if (HandshakeData != null)
-                {
-                    HandshakeData.Recycle();
-                }
-            }
-
-            Connection = null;
-            HandshakeData = null;
-        }
-
-        public void Recycle()
-        {
-            Recycle(true);
-        }
+        public NetworkConnection Connection;
+        public MessageReader HandshakeData;
     }
 }

Infinity.Core/Memory/Chunk.cs

@@ -0,0 +1,81 @@
+public unsafe class BufferChunk : IDisposable
+{
+    private byte* _ptr;
+    private int _capacity;
+    private int _length;
+    private readonly ChunkedByteAllocator _allocator;
+
+    public byte* Ptr => _ptr;
+    public int Length => _length;
+    public int Capacity => _capacity;
+
+    public BufferChunk(ChunkedByteAllocator allocator, int initialCapacity = 1024)
+    {
+        _allocator = allocator;
+        _capacity = initialCapacity;
+        _ptr = _allocator.Allocate(_capacity);
+        _length = 0;
+    }
+
+    /// <summary>
+    /// Ensures buffer has space for additional bytes. Grows automatically if needed.
+    /// </summary>
+    public void EnsureCapacity(int additional)
+    {
+        int required = _length + additional;
+        if (required <= _capacity) return;
+
+        int newCapacity = _capacity;
+        while (newCapacity < required) newCapacity *= 2;
+
+        byte* newPtr = _allocator.Allocate(newCapacity);
+        Buffer.MemoryCopy(_ptr, newPtr, newCapacity, _length);
+        _allocator.Free(_ptr, _capacity);
+
+        _ptr = newPtr;
+        _capacity = newCapacity;
+    }
+
+    /// <summary>
+    /// Increases the length after writing bytes.
+    /// </summary>
+    public void Advance(int count)
+    {
+        _length += count;
+    }
+
+    public void SetLength(int length)
+    {
+        if (length < 0 || length > _capacity)
+            throw new ArgumentOutOfRangeException(nameof(length), "Length must be between 0 and Capacity.");
+        _length = length;
+    }
+
+    public void Dispose()
+    {
+        Free();
+        GC.SuppressFinalize(this); // prevent finalizer from running twice
+    }
+
+    private void Free()
+    {
+        if (_ptr != null)
+        {
+            _allocator.Free(_ptr);
+            _ptr = null;
+            _capacity = 0;
+            _length = 0;
+        }
+    }
+
+    ~BufferChunk()
+    {
+        // This will run if Dispose was not called
+        Free();
+    }
+
+    /// <summary>
+    /// Returns a read-only span of written bytes.
+    /// </summary>
+    public ReadOnlySpan<byte> WrittenSpan => new ReadOnlySpan<byte>(_ptr, _length);
+}

Infinity.Core/Memory/ChunkAllocator.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+public unsafe class ChunkedByteAllocator : IDisposable
+{
+    private readonly int _slabSize;
+    private readonly Stack<IntPtr> _freeSlabs = new Stack<IntPtr>();
+
+    public ChunkedByteAllocator(int slabSize)
+    {
+        if (slabSize <= 0) throw new ArgumentOutOfRangeException(nameof(slabSize));
+        _slabSize = slabSize;
+    }
+
+    /// <summary>
+    /// Allocates a block of memory. If size <= slabSize, reuses slab; otherwise allocates exact size.
+    /// </summary>
+    public byte* Allocate(int size)
+    {
+        if (size <= 0) throw new ArgumentOutOfRangeException(nameof(size));
+
+        if (size <= _slabSize)
+        {
+            if (_freeSlabs.Count > 0)
+            {
+                return (byte*)_freeSlabs.Pop();
+            }
+            return (byte*)Marshal.AllocHGlobal(_slabSize);
+        }
+        else
+        {
+            return (byte*)Marshal.AllocHGlobal(size);
+        }
+    }
+
+    /// <summary>
+    /// Frees a previously allocated block.
+    /// </summary>
+    /// <param name="ptr">Pointer to free.</param>
+    /// <param name="size">Original allocation size. Determines if slab or large allocation.</param>
+    public void Free(byte* ptr, int size = -1)
+    {
+        if (ptr == null) return;
+
+        if (size <= _slabSize || size < 0)
+        {
+            // Return to slab pool
+            _freeSlabs.Push((IntPtr)ptr);
+        }
+        else
+        {
+            // Free large allocation
+            Marshal.FreeHGlobal((IntPtr)ptr);
+        }
+    }
+
+    public void Dispose()
+    {
+        while (_freeSlabs.Count > 0)
+        {
+            Marshal.FreeHGlobal(_freeSlabs.Pop());
+        }
+    }
+}

Infinity.Core/Memory/Manager.cs

@@ -0,0 +1,45 @@
+using System.Buffers;
+using System.Runtime.InteropServices;
+
+public unsafe class UnmanagedMemoryManager : MemoryManager<byte>
+{
+    private readonly byte* _ptr;
+    private readonly int _length;
+
+    public UnmanagedMemoryManager(byte* ptr, int length)
+    {
+        if (ptr == null)
+            throw new ArgumentNullException(nameof(ptr));
+        if (length < 0)
+            throw new ArgumentOutOfRangeException(nameof(length));
+
+        _ptr = ptr;
+        _length = length;
+    }
+
+    public override Span<byte> GetSpan() => new Span<byte>(_ptr, _length);
+
+    public override MemoryHandle Pin(int elementIndex = 0)
+    {
+        if (elementIndex < 0 || elementIndex > _length)
+            throw new ArgumentOutOfRangeException(nameof(elementIndex));
+
+        // No GCHandle needed because memory is unmanaged
+        return new MemoryHandle(_ptr + elementIndex);
+    }
+
+    public override void Unpin()
+    {
+        // Nothing to do for unmanaged memory
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        // Nothing to free: memory is externally owned
+    }
+
+    public void Dispose()
+    {
+        Dispose(true);
+    }
+}