✨ added new method for RagonBuffer

Ragon.Client/Ragon.Client.csproj

@@ -12,11 +12,11 @@
     <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
       <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
       <DebugType>none</DebugType>
-      <OutputPath>/Users/edmand46/RagonProjects/ragon-oss-examples/Assets/Ragon/Runtime/Plugins</OutputPath>
+      <OutputPath></OutputPath>
     </PropertyGroup>
 
     <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-      <OutputPath>/Users/edmand46/RagonProjects/ragon-oss-examples/Assets/Ragon/Plugins/</OutputPath>
+      <OutputPath></OutputPath>
     </PropertyGroup>
 
     <ItemGroup>

Ragon.Client/Sources/Entity/RagonEntity.cs

@@ -39,8 +39,8 @@ namespace Ragon.Client
 
       public void Dispose()
       {
-        _callbacks.Remove(_callback);
+        _callbacks?.Remove(_callback);
-        _localCallbacks.Remove(_callback);
+        _localCallbacks?.Remove(_callback);
 
         _callbacks = null!;
         _localCallbacks = null!;

Ragon.Client/Sources/Entity/RagonProperty.cs

@@ -63,7 +63,7 @@ namespace Ragon.Client
 
     protected void InvokeChanged()
     {
-      if (!InvokeLocal)
+      if (_entity.HasAuthority)
         return;
 
       Changed?.Invoke();
@@ -71,7 +71,8 @@ namespace Ragon.Client
 
     protected void MarkAsChanged()
     {
-      InvokeChanged();
+      if (InvokeLocal)
+        Changed?.Invoke();
       
       if (_dirty || _entity == null)
         return;
@@ -106,15 +107,15 @@ namespace Ragon.Client
       {
         Serialize(_propertyBuffer);
 
-        buffer.FromBuffer(_propertyBuffer, _size);
+        buffer.CopyFrom(_propertyBuffer, _size);
         return;
       }
 
       Serialize(_propertyBuffer);
 
       var propertySize = (ushort)_propertyBuffer.WriteOffset;
-      buffer.WriteUShort(propertySize);;
+      buffer.WriteUShort(propertySize);
-      buffer.FromBuffer(_propertyBuffer, propertySize);
+      buffer.CopyFrom(_propertyBuffer, propertySize);
     }
 
     internal void Read(RagonBuffer buffer)

Ragon.Client/Sources/Handler/EntityCreateHandler.cs

@@ -51,6 +51,8 @@ internal class EntityCreateHandler : IHandler
     if (player == null)
     {
       RagonLog.Warn($"Owner {ownerId}|{player.Name} not found in players");
+      
+      _playerCache.Dump();
       return;
     }
     

Ragon.Client/Sources/Handler/EntityEventHandler.cs

@@ -42,7 +42,9 @@ internal class EntityEventHandler : IHandler
     var player = _playerCache.GetPlayerByPeer(peerId);
     if (player == null)
     {
-            RagonLog.Warn($"Player not found for event {eventCode}");
+      RagonLog.Error($"Player with peerId:{peerId} not found as owner of event with code:{eventCode}");
+      
+      _playerCache.Dump();
       return;
     }
 

Ragon.Client/Sources/Handler/EntityOwnershipHandler.cs

@@ -41,6 +41,14 @@ internal class EntityOwnershipHandler: IHandler
     var entities = reader.ReadUShort();
     
     var player = _playerCache.GetPlayerByPeer(newOwnerId);
+    if (player == null)
+    {
+      RagonLog.Error($"Player with Id:{newOwnerId} not found in cache");
+      
+      _playerCache.Dump();
+      return;
+    }
+    
     for (var i = 0; i < entities; i++)
     {
       var entityId = reader.ReadUShort();

Ragon.Client/Sources/Handler/OwnershipRoomHandler.cs

@@ -39,6 +39,13 @@ internal class OwnershipRoomHandler: IHandler
   {
     var newOwnerId = reader.ReadUShort();
     var player = _playerCache.GetPlayerByPeer(newOwnerId);
+    if (player == null)
+    {
+      RagonLog.Warn($"Player with peerId:{newOwnerId} not found in cache");
+      
+      _playerCache.Dump();
+      return;
+    }
 
     _playerCache.OnOwnershipChanged(newOwnerId);
     _listenerList.OnOwnershipChanged(player);

Ragon.Client/Sources/Handler/PlayerJoinHandler.cs

@@ -45,6 +45,6 @@ internal class PlayerJoinHandler : IHandler
     if (player != null)
       _listenerList.OnPlayerJoined(player);
     else
-      RagonLog.Trace($"[Joined] {playerId}");
+      RagonLog.Warn($"Player with Id:{playerId} not found in cache");
   }
 }

Ragon.Client/Sources/Handler/PlayerLeftHandler.cs

@@ -57,5 +57,9 @@ internal class PlayerLeftHandler : IHandler
       foreach (var id in toDeleteIds)
         _entityCache.OnDestroy(id, emptyPayload);
     }
+    else
+    {
+      RagonLog.Warn($"Player with Id:{playerId} not found in cache");
+    }
   }
 }

Ragon.Client/Sources/Handler/RoomDataHandler.cs

@@ -37,6 +37,15 @@ internal class RoomDataHandler: IHandler
     var rawData = reader.RawData;
     var peerId = (ushort)(rawData[1] + (rawData[2] << 8));
     var player = _playerCache.GetPlayerByPeer(peerId);
+    
+    if (player == null)
+    {
+      RagonLog.Error($"Player with peerId:{peerId} not found");
+      
+      _playerCache.Dump();
+      return;
+    }
+    
     var headerSize = 3;
     var payload = new byte[rawData.Length - headerSize];
     

Ragon.Client/Sources/Handler/RoomEventHandler.cs

@@ -41,7 +41,9 @@ public class RoomEventHandler: IHandler
     var player = _playerCache.GetPlayerByPeer(peerId);
     if (player == null)
     {
-      RagonLog.Warn($"Player not found for event {eventCode}");
+      RagonLog.Error($"Player with peerId:{peerId} not found as owner of event with code:{eventCode}");
+      
+      _playerCache.Dump();
       return;
     }
 

Ragon.Client/Sources/Handler/SnapshotHandler.cs

@@ -45,6 +45,7 @@ internal class SnapshotHandler : IHandler
 
   public void Handle(RagonBuffer buffer)
   {
+    var entities = new List<RagonEntity>();
     var playersCount = buffer.ReadUShort();
     RagonLog.Trace("Players: " + playersCount);
     for (var i = 0; i < playersCount; i++)
@@ -70,7 +71,9 @@ internal class SnapshotHandler : IHandler
       var player = _playerCache.GetPlayerByPeer(ownerPeerId);
       if (player == null)
       {
-        RagonLog.Error($"Player not found with peerId: ${ownerPeerId}");
+        RagonLog.Error($"Player not found with peerId: {ownerPeerId}");
+
+        _playerCache.Dump();
         return;
       }
 
@@ -88,7 +91,8 @@ internal class SnapshotHandler : IHandler
       _entityListener.OnEntityCreated(entity);
       
       entity.Read(buffer);
-      entity.Attach();
+      
+      entities.Add(entity);
     }
 
     var staticEntities = buffer.ReadUShort();
@@ -104,7 +108,9 @@ internal class SnapshotHandler : IHandler
       var player = _playerCache.GetPlayerByPeer(ownerPeerId);
       if (player == null)
       {
-        RagonLog.Error($"Player not found with peerId: ${ownerPeerId}");
+        RagonLog.Error($"Player not found with peerId: {ownerPeerId}");
+        
+        _playerCache.Dump();
         return;
       }
 
@@ -112,9 +118,9 @@ internal class SnapshotHandler : IHandler
       var entity = _entityCache.TryGetEntity(0, entityType, staticId, entityId, hasAuthority, out _);
       
       entity.Prepare(_client, entityId, entityType, hasAuthority, player, RagonPayload.Empty);
-      
       entity.Read(buffer);
-      entity.Attach();
+      
+      entities.Add(entity);
     }
 
     if (_client.Status == RagonStatus.LOBBY)
@@ -123,6 +129,9 @@ internal class SnapshotHandler : IHandler
       _listenerList.OnJoined();
     }
 
+    foreach (var entity in entities)
+      entity.Attach();
+
     _listenerList.OnSceneLoaded();
   }
 }

Ragon.Client/Sources/RagonEntityCache.cs

@@ -186,12 +186,10 @@ public sealed class RagonEntityCache
       }
     }
 
-    if (_pendingEntities.TryGetValue(attachId, out var pendingEntity))
+    if (_pendingEntities.TryGetValue(attachId, out var pendingEntity) && hasAuthority)
     {
       _pendingEntities.Remove(attachId);
       _entityMap.Add(entityId, pendingEntity);
-
-      if (hasAuthority)
       _entityList.Add(pendingEntity);
 
       hasCreated = false;
@@ -199,7 +197,6 @@ public sealed class RagonEntityCache
       return pendingEntity;
     }
 
-
     var entity = new RagonEntity(entityType, sceneId);
 
     _entityMap.Add(entityId, entity);
@@ -217,7 +214,6 @@ public sealed class RagonEntityCache
   {
     if (_entityMap.TryGetValue(entityId, out var entity))
     {
-      
       _entityMap.Remove(entityId);
       _entityList.Remove(entity);
 

Ragon.Client/Sources/RagonPlayerCache.cs

@@ -27,8 +27,21 @@ public sealed class RagonPlayerCache
   public RagonPlayer Local { get; private set; }
   public bool IsRoomOwner => _ownerId == _localId;
 
-  public RagonPlayer? GetPlayerById(string playerId) => _playersById[playerId];
+  public RagonPlayer? GetPlayerById(string playerId)
-  public RagonPlayer? GetPlayerByPeer(ushort peerId) => _playersByConnection[peerId];
+  {
+    if (_playersById.TryGetValue(playerId, out var player))
+      return player;
+
+    return null;
+  }
+
+  public RagonPlayer? GetPlayerByPeer(ushort peerId)
+  {
+    if (_playersByConnection.TryGetValue(peerId, out var player))
+      return player;
+
+    return null;
+  }
 
   private string _ownerId;
   private string _localId;
@@ -91,4 +104,14 @@ public sealed class RagonPlayerCache
     _playersByConnection.Clear();
     _playersById.Clear();
   }
+
+  public void Dump()
+  {
+    RagonLog.Trace("Players: ");
+    RagonLog.Trace("[Connection] [ID] [Name]");
+    foreach (var player in _players)
+    {
+      RagonLog.Trace($"[{player.PeerId}] {player.Id} {player.Name}");
+    }
+  }
 }

Ragon.Client/Sources/RagonSession.cs

@@ -51,9 +51,9 @@ namespace Ragon.Client
       Create(null, new RagonRoomParameters() {Scene = sceneName, Min = minPlayers, Max = maxPlayers});
     }
 
-    public void Create(string roomId, string sceneNa, int minPlayers, int maxPlayers)
+    public void Create(string roomId, string sceneName, int minPlayers, int maxPlayers)
     {
-      Create(roomId, new RagonRoomParameters() {Scene = sceneNa, Min = minPlayers, Max = maxPlayers});
+      Create(roomId, new RagonRoomParameters() {Scene = sceneName, Min = minPlayers, Max = maxPlayers});
     }
     
     public  void Create(string roomId, RagonRoomParameters parameters)

Ragon.Protocol/Sources/RagonBuffer.cs

@@ -1,5 +1,5 @@
 /*
- * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ * Copyright 2023-2024 Eduard Kargin <kargin.eduard@gmail.com>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -75,7 +75,7 @@ namespace Ragon.Protocol
     public int ReadOffset => _read;
     public int WriteOffset => _write;
     public int Length => ((_write - 1) >> 3) + 1;
-    public int Capacity => _write - _read;
+    public int Capacity => _write - _read - 1;
 
     public RagonBuffer(int capacity = 128)
     {
@@ -121,6 +121,21 @@ namespace Ragon.Protocol
       return (RagonOperation)Read(8);
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void WriteFloat(float value)
+    {
+      var bytes = BitConverter.GetBytes(value);
+      WriteBytes(bytes);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public float ReadFloat()
+    {
+      var bytes = ReadBytes(4);
+      var value = BitConverter.ToSingle(bytes, 0);
+      return value;
+    }
+    
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void WriteFloat(float value, float min, float max, float precision)
     {
@@ -147,6 +162,23 @@ namespace Ragon.Protocol
       return adjusted;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void WriteInt(int value)
+    {
+      var bytes = BitConverter.GetBytes(value);
+      
+      WriteBytes(bytes);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int ReadInt()
+    {
+      var bytes = ReadBytes(4);
+      var value = BitConverter.ToInt32(bytes, 0);
+
+      return value;
+    }
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void WriteInt(int value, int min, int max)
     {
@@ -236,9 +268,6 @@ namespace Ragon.Protocol
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Write(uint value, int numBits = 16)
     {
-      Debug.Assert(!(numBits < 0));
-      Debug.Assert(!(numBits > 32));
-
       var currentBucketIndex = _write >> 5;
       var used = _write & 0x0000001F;
       var mask = (1UL << used) - 1;
@@ -284,10 +313,10 @@ namespace Ragon.Protocol
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [Obsolete("Do not use this method, will be removed")]
-    public byte[] ReadBytes(int lenght)
+    public byte[] ReadBytes(int len)
     {
-      var data = new byte[lenght];
+      var data = new byte[len];
-      for (int i = 0; i < lenght; i++)
+      for (int i = 0; i < len; i++)
         data[i] = (byte)Read(8);
 
       return data;
@@ -357,7 +386,7 @@ namespace Ragon.Protocol
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromBuffer(RagonBuffer buffer, int size)
+    public void CopyFrom(RagonBuffer buffer, int size)
     {
       WriteArray(buffer._buckets, size);
     }
@@ -434,7 +463,7 @@ namespace Ragon.Protocol
 
     public void ToArray(byte[] outData)
     {
-      Debug.Assert(outData.Length >= Length);
+      Write(1, 1);
 
       var bucketsCount = (_write >> 5) + 1;
       var length = Length;

Ragon.Protocol/Sources/RagonStream.cs

@@ -0,0 +1,309 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Ragon.Protocol
+{
+  [StructLayout(LayoutKind.Explicit)]
+  internal struct ValueConverter
+  {
+    [FieldOffset(0)] public int Int;
+    [FieldOffset(0)] public float Float;
+    [FieldOffset(0)] public long Long;
+    [FieldOffset(0)] public byte Byte0;
+    [FieldOffset(1)] public byte Byte1;
+    [FieldOffset(2)] public byte Byte2;
+    [FieldOffset(3)] public byte Byte3;
+    [FieldOffset(4)] public byte Byte4;
+    [FieldOffset(5)] public byte Byte5;
+    [FieldOffset(6)] public byte Byte6;
+    [FieldOffset(7)] public byte Byte7;
+  }
+
+  public class RagonStream
+  {
+    private byte[] _data;
+    private int _offset;
+    private int _size;
+
+    public int Lenght => _offset;
+    public int Size => _size - _offset;
+
+    public RagonStream(int capacity = 256)
+    {
+      _data = new byte[capacity];
+      _offset = 0;
+      _size = 0;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Reset()
+    {
+      _size = _offset;
+      _offset = 0;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void AddOffset(int offset)
+    {
+      _offset += offset;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int WriteByte(byte value)
+    {
+      ResizeIfNeed(1);
+      _data[_offset] = value;
+      _offset += 1;
+      return 1;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public byte ReadByte()
+    {
+      var value = _data[_offset];
+      _offset += 1;
+      return value;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int WriteBool(bool value)
+    {
+      ResizeIfNeed(1);
+      _data[_offset] = value ? (byte)1 : (byte)0;
+      _offset += 1;
+      return 1;
+    }
+
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool ReadBool()
+    {
+      var value = _data[_offset];
+      _offset += 1;
+      return value == 1;
+    }
+
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int WriteInt(int value)
+    {
+      ResizeIfNeed(4);
+      var converter = new ValueConverter() { Int = value };
+      _data[_offset] = converter.Byte0;
+      _data[_offset + 1] = converter.Byte1;
+      _data[_offset + 2] = converter.Byte2;
+      _data[_offset + 3] = converter.Byte3;
+      _offset += 4;
+      return 4;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int WriteInt(int value, int offset)
+    {
+      ResizeIfNeed(4);
+      var converter = new ValueConverter() { Int = value };
+      _data[offset] = converter.Byte0;
+      _data[offset + 1] = converter.Byte1;
+      _data[offset + 2] = converter.Byte2;
+      _data[offset + 3] = converter.Byte3;
+      return 4;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int ReadInt()
+    {
+      var converter = new ValueConverter
+        { Byte0 = _data[_offset], Byte1 = _data[_offset + 1], Byte2 = _data[_offset + 2], Byte3 = _data[_offset + 3] };
+      _offset += 4;
+      return converter.Int;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void WriteLong(long value)
+    {
+      ResizeIfNeed(8);
+      WriteLong(value, _offset);
+      _offset += 8;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int WriteLong(long value, int offset)
+    {
+      var converter = new ValueConverter() { Long = value };
+      _data[offset] = converter.Byte0;
+      _data[offset + 1] = converter.Byte1;
+      _data[offset + 2] = converter.Byte2;
+      _data[offset + 3] = converter.Byte3;
+      _data[offset + 4] = converter.Byte4;
+      _data[offset + 5] = converter.Byte5;
+      _data[offset + 6] = converter.Byte6;
+      _data[offset + 7] = converter.Byte7;
+      return 8;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public long ReadLong()
+    {
+      var converter = new ValueConverter
+      {
+        Byte0 = _data[_offset],
+        Byte1 = _data[_offset + 1],
+        Byte2 = _data[_offset + 2],
+        Byte3 = _data[_offset + 3],
+        Byte4 = _data[_offset + 4],
+        Byte5 = _data[_offset + 5],
+        Byte6 = _data[_offset + 6],
+        Byte7 = _data[_offset + 7],
+      };
+      _offset += 8;
+      return converter.Long;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int WriteFloat(float value)
+    {
+      var converter = new ValueConverter() { Float = value };
+      WriteInt(converter.Int);
+      return 4;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public float ReadFloat()
+    {
+      var rawValue = ReadInt();
+      var converter = new ValueConverter() { Int = rawValue };
+      var value = converter.Float;
+      return value;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int WriteString(string value)
+    {
+      var rawData = Encoding.UTF8.GetBytes(value);
+      var len = rawData.Length;
+      ResizeIfNeed(2 + len);
+      WriteUShort((ushort)len);
+
+      Buffer.BlockCopy(rawData, 0, _data, _offset, len);
+      
+      _offset += len;
+
+      return len + 2;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public string ReadString()
+    {
+      var len = ReadUShort();
+      var rawData = new byte[len];
+
+      Buffer.BlockCopy(_data, _offset, rawData, 0, len);
+
+      var str = Encoding.UTF8.GetString(rawData);
+      _offset += len;
+      return str;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public byte[] ReadBinary(int len)
+    {
+      if (len >= _data.Length)
+        return Array.Empty<byte>();
+
+      var payload = new byte[len];
+      Buffer.BlockCopy(_data, _offset, payload, 0, len);
+
+      _offset += len;
+
+      return payload;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void WriteBinary(byte[] payload)
+    {
+      ResizeIfNeed(payload.Length);
+
+      Array.Copy(payload, 0, _data, _offset, payload.Length);
+
+      _offset += payload.Length;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void WriteOperation(RagonOperation operation)
+    {
+      ResizeIfNeed(1);
+
+      _data[_offset] = (byte)operation;
+      _offset += 1;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public RagonOperation ReadOperation()
+    {
+      var op = (RagonOperation)_data[_offset];
+      _offset += 1;
+      return op;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void WriteUShort(ushort value)
+    {
+      ResizeIfNeed(2);
+
+      _data[_offset] = (byte)(value & 0x00FF);
+      _data[_offset + 1] = (byte)((value & 0xFF00) >> 8);
+      _offset += 2;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void WriteUShort(ushort value, int offset)
+    {
+      ResizeIfNeed(2);
+      _data[offset] = (byte)(value & 0x00FF);
+      _data[offset + 1] = (byte)((value & 0xFF00) >> 8);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ushort ReadUShort()
+    {
+      var value = (ushort)(_data[_offset] + (_data[_offset + 1] << 8));
+      _offset += 2;
+      return value;
+    }
+
+    public void Clear()
+    {
+      _offset = 0;
+      _size = 0;
+    }
+
+
+    public void FromArray(byte[] data)
+    {
+      Clear();
+      ResizeIfNeed(data.Length);
+      Buffer.BlockCopy(data, 0, _data, 0, data.Length);
+      _size = data.Length;
+    }
+
+
+    public byte[] ToArray()
+    {
+      var bytes = new byte[_offset];
+      Buffer.BlockCopy(_data, 0, bytes, 0, _offset);
+      return bytes;
+    }
+
+    private void ResizeIfNeed(int lenght)
+    {
+      if (_offset + lenght < _data.Length)
+        return;
+
+      var newData = new byte[_data.Length * 4 + lenght];
+      Buffer.BlockCopy(_data, 0, newData, 0, _data.Length);
+      _data = newData;
+    }
+  }
+}

Ragon.Relay/Ragon.Relay.csproj

@@ -3,7 +3,7 @@
     <PropertyGroup>
         <OutputType>Exe</OutputType>
         <RootNamespace>Ragon.Relay</RootNamespace>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFrameworks>net7.0;net8.0</TargetFrameworks>
     </PropertyGroup>
 
     <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">

Ragon.Relay/Sources/RelayServerPlugin.cs

@@ -1,5 +1,6 @@
 using System;
 using Newtonsoft.Json;
+using Ragon.Server;
 using Ragon.Server.Plugin;
 
 namespace Ragon.Relay;
@@ -21,4 +22,9 @@ public class RelayServerPlugin: BaseServerPlugin
     
     return true;
   }
+
+  public override IRoomPlugin CreateRoomPlugin(RoomInformation information)
+  {
+    return new RelayRoomPlugin();
+  }
 }

Ragon.Server/Sources/Entity/RagonEntityState.cs

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-
 using Ragon.Protocol;
 
 namespace Ragon.Server.Entity;

Ragon.Server/Sources/Entity/RagonProperty.cs

@@ -54,6 +54,13 @@ public class RagonProperty : RagonPayload
 
   public void Write(RagonBuffer buffer)
   {
+    if (IsFixed)
+    {
+      buffer.WriteArray(_data, Size);
+      return;
+    }
+    
+    buffer.Write((ushort) Size);
     buffer.WriteArray(_data, Size);
   }
 

Ragon.Server/Sources/Event/RagonEvent.cs

@@ -39,7 +39,7 @@ public class RagonEvent
   
   public void Read(RagonBuffer buffer)
   {
-    _size = buffer.Capacity - 1;
+    _size = buffer.Capacity;
     buffer.ReadArray(_data, _size);
   }
 

Ragon.Server/Sources/Lobby/RagonLobbyInMemory.cs

@@ -25,12 +25,20 @@ public class LobbyInMemory : IRagonLobby
   private readonly List<RagonRoom> _rooms = new();
   private readonly Logger _logger = LogManager.GetCurrentClassLogger();
 
-  public bool FindRoomById(string RagonRoomId, [MaybeNullWhen(false)] out RagonRoom room)
+  public bool FindRoomById(string roomId, [MaybeNullWhen(false)] out RagonRoom room)
   {
     foreach (var existRagonRoom in _rooms)
     {
-      if (existRagonRoom.Id == RagonRoomId && existRagonRoom.PlayerMin < existRagonRoom.PlayerMax)
+      if (existRagonRoom.Id == roomId)
       {
+        if (existRagonRoom.PlayerCount >= existRagonRoom.PlayerMax)
+        {
+          _logger.Warn($"Room with id {roomId} fulfilled");
+          
+          room = default;
+          return false;
+        }
+        
         room = existRagonRoom;
         return true;
       }
@@ -44,8 +52,16 @@ public class LobbyInMemory : IRagonLobby
   {
     foreach (var existsRoom in _rooms)
     {
-      if (existsRoom.Scene == sceneName && existsRoom.PlayerCount < existsRoom.PlayerMax)
+      if (existsRoom.Scene == sceneName)
       {
+        if (existsRoom.PlayerCount >= existsRoom.PlayerMax)
+        {
+          _logger.Warn($"Room with scene {sceneName} fulfilled");
+          
+          room = default;
+          return false;          
+        }
+        
         room = existsRoom;
         return true;
       }

Ragon.Server/Sources/Logging/IRagonLogger.cs

@@ -0,0 +1,9 @@
+namespace Ragon.Server.Logging;
+
+public interface IRagonLogger
+{
+  public void Warning(string tag, string message);
+  public void Info(string tag, string message);
+  public void Error(string tag, string message);
+  public void Trace(string tag, string message);
+}

Ragon.Server/Sources/Plugin/BaseServerPlugin.cs

@@ -49,7 +49,7 @@ public class BaseServerPlugin: IServerPlugin
     return true;
   }
 
-  public IRoomPlugin CreateRoomPlugin(RoomInformation information)
+  public virtual IRoomPlugin CreateRoomPlugin(RoomInformation information)
   {
     return new BaseRoomPlugin();
   }

Ragon.Server/Sources/RagonServer.cs

@@ -99,6 +99,11 @@ public class RagonServer : IRagonServer, INetworkListener
     _timer.Start();
     while (true)
     {
+      if (_timer.ElapsedMilliseconds > _tickRate * 2)
+      {
+        _logger.Warn($"Slow perfomance: {_timer.ElapsedMilliseconds}");
+      }
+
       if (_timer.ElapsedMilliseconds > _tickRate)
       {
         _timer.Restart();
@@ -197,7 +202,7 @@ public class RagonServer : IRagonServer, INetworkListener
         _reader.FromArray(data);
         
         var operation = _reader.ReadByte();
-        _handlers[operation].Handle(context, channel);
+        _handlers[operation]?.Handle(context, channel);
       }
     }
     catch (Exception ex)

Ragon.Server/Sources/RagonServerConfiguration.cs

@@ -42,7 +42,7 @@ public struct RagonServerConfiguration
   public Dictionary<string, string> WebHooks;
 
   private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
-  private static readonly string ServerVersion = "1.3.1";
+  private static readonly string ServerVersion = "1.3.2";
   private static Dictionary<string, ServerType> _serverTypes = new Dictionary<string, ServerType>()
   {
     {"enet", Server.ServerType.ENET},