chore: update version

fix: websocket server now can receive large messages
fix: buffer resize on read array

Ragon.Protocol/Sources/RagonBuffer.cs

@@ -65,6 +65,8 @@ namespace Ragon.Protocol
 {
   public class RagonBuffer
   {
+    private const int MaxBufferSize = 1024 * 1024; // 1MB max buffer size
+
     private int _read;
     private int _write;
     private uint[] _buckets;
@@ -331,6 +333,9 @@ namespace Ragon.Protocol
       var limit = (size + 32 - 1) / 32;
       var capacity = size;
 
+      if (index + limit >= _buckets.Length)
+        Resize(size);
+      
       for (int i = 0; i < limit; i++)
       {
         var dataSize = capacity > 32 ? 32 : capacity;
@@ -401,6 +406,12 @@ namespace Ragon.Protocol
     public void FromArray(byte[] data)
     {
       var length = data.Length;
+
+      if (length > MaxBufferSize)
+      {
+        throw new InvalidOperationException($"Input data exceeds maximum buffer size: {length} bytes > {MaxBufferSize} bytes");
+      }
+
       var bucketsCount = length / 4 + 1;
 
       if (_buckets.Length < bucketsCount)
@@ -490,7 +501,14 @@ namespace Ragon.Protocol
 
     private void Resize(int capacity)
     {
-      var buckets = new uint[_buckets.Length * 2 + capacity];
+      var newSize = _buckets.Length * 2 + capacity;
+
+      if (newSize * 4 > MaxBufferSize)
+      {
+        throw new InvalidOperationException($"Buffer size limit exceeded: {newSize * 4} bytes > {MaxBufferSize} bytes");
+      }
+
+      var buckets = new uint[newSize];
       Array.Copy(_buckets, buckets, _buckets.Length);
       _buckets = buckets;
     }

Ragon.Relay/Ragon.Relay.csproj

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

Ragon.Relay/Sources/Relay.cs

@@ -56,13 +56,16 @@ namespace Ragon.Relay
       var serverConfiguration = new RagonServerConfiguration()
       {
         LimitConnections = configuration.LimitConnections,
-        LimitRooms = configuration.LimitConnections,
-        LimitBufferedEvents = configuration.LimitConnections,
-        LimitPlayersPerRoom = configuration.LimitConnections,
+        LimitRooms = configuration.LimitRooms,
+        LimitBufferedEvents = configuration.LimitBufferedEvents,
+        LimitPlayersPerRoom = configuration.LimitPlayersPerRoom,
+        LimitUserDataSize = configuration.LimitUserDataSize,
+        LimitPropertySize = configuration.LimitPropertySize,
         Port = configuration.Port,
         Protocol = configuration.Protocol,
         ServerKey = configuration.ServerKey,
         ServerTickRate = configuration.ServerTickRate,
+        ServerAddress = configuration.ServerAddress,
       };
       
       var relay = new RagonServer(networkServer, plugin, serverConfiguration);

Ragon.Relay/Sources/RelayConfiguration.cs

@@ -7,6 +7,7 @@ namespace Ragon.Relay
   {
     public string ServerKey;
     public string ServerType;
+    public string ServerAddress;
     public ushort ServerTickRate;
     public string Protocol;
     public ushort Port;
@@ -14,6 +15,7 @@ namespace Ragon.Relay
     public int LimitPlayersPerRoom;
     public int LimitRooms;
     public int LimitBufferedEvents;
-    public int LimitUserData;
+    public int LimitUserDataSize;
+    public int LimitPropertySize;
   }
 }

Ragon.Relay/relay.config.json

@@ -1,12 +1,15 @@
 {
   "serverKey": "defaultkey",
   "serverType": "enet",
+  "serverAddress": "*",
   "serverTickRate": 30,
   "protocol": "1.0.0",
-  "port": 5000,
+  "port": 8000,
   "limitConnections": 4095,
   "limitPlayersPerRoom": 20,
   "limitRooms": 200,
   "limitBufferedEvents": 50,
-  "limitUserData": 1024
+  "limitUserDataSize": 1024,
+  "limitPropertySize": 512,
+  "limitConnectionsPerProject": 100
 }

Ragon.Server.ENetServer/Sources/ENetServer.cs

@@ -49,7 +49,7 @@ namespace Ragon.Server.ENetServer
       _host.Create(address, _connections.Length, 2, 0, 0, 1024 * 1024);
 
       var protocolDecoded = RagonVersion.Parse(_protocol);
-      _logger.Info($"Listen at 127.0.0.1:{configuration.Port}");
+      _logger.Info($"Listen at {configuration.Address}:{configuration.Port}");
       _logger.Info($"Protocol: {protocolDecoded}");
     }
 

Ragon.Server.WebSocketServer/Sources/WebSocketServer.cs

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+using System.Buffers;
 using System.Net;
 using System.Net.WebSockets;
 using Ragon.Protocol;
@@ -42,7 +43,7 @@ public class WebSocketServer : INetworkServer
     _executor = new Executor();
   }
   
-  public async void StartAccept(CancellationToken cancellationToken)
+  public async ValueTask StartAccept(CancellationToken cancellationToken)
   {
     while (!cancellationToken.IsCancellationRequested)
     {
@@ -57,45 +58,55 @@ public class WebSocketServer : INetworkServer
           context.Response.Close();
           continue;
         }
-        
+
         var webSocketContext = await context.AcceptWebSocketAsync(null);
         var webSocket = webSocketContext.WebSocket;
         var peerId = _sequencer.Pop();
-        
-        connection = new WebSocketConnection(webSocket, peerId);  
+
+        connection = new WebSocketConnection(webSocket, peerId);
       }
       catch (Exception ex)
       {
           _logger.Error(ex);
           continue;
       }
-      
+
       _connections[connection.Id] = connection;
-      
-      StartListen(connection, cancellationToken);
+
+      _ = StartListen(connection, cancellationToken);
     }
   }
 
-  async void StartListen(WebSocketConnection connection, CancellationToken cancellationToken)
+  async ValueTask StartListen(WebSocketConnection connection, CancellationToken cancellationToken)
   {
     _activeConnections.Add(connection);
     _networkListener.OnConnected(connection);
 
     var webSocket = connection.Socket;
-    var bytes = new byte[2048];
-    var buffer = new Memory<byte>(bytes);
-    
-    while (
-      webSocket.State == WebSocketState.Open ||
-      !cancellationToken.IsCancellationRequested)
+    var rawData = new byte[2048];
+    var rawDataBuffer = new Memory<byte>(rawData);
+    var data = new ArrayBufferWriter<byte>();
+
+    while (webSocket.State == WebSocketState.Open || !cancellationToken.IsCancellationRequested)
     {
       try
       {
-        var result = await webSocket.ReceiveAsync(buffer, cancellationToken);
-        if (result.Count > 0)
+        while (true)
         {
-          var payload = buffer.Slice(0, result.Count);
-          _networkListener.OnData(connection, NetworkChannel.RELIABLE, payload.ToArray());
+          var result = await webSocket.ReceiveAsync(rawDataBuffer, cancellationToken);
+          var payload = rawDataBuffer.Slice(0, result.Count);
+
+          data.Write(payload.Span);
+
+          if (result.EndOfMessage)
+            break;
+        }
+
+        if (data.WrittenCount > 0)
+        {
+          _networkListener.OnData(connection, NetworkChannel.RELIABLE, data.WrittenMemory.ToArray());
+
+          data.Clear();
         }
       }
       catch (Exception ex)
@@ -106,15 +117,15 @@ public class WebSocketServer : INetworkServer
 
     _sequencer.Push(connection.Id);
     _activeConnections.Remove(connection);
-    
+
     _networkListener.OnDisconnected(connection);
   }
 
   public void Update()
   {
     _executor.Update();
-    
-    Flush();
+
+    _ = Flush();
   }
 
   public void Broadcast(byte[] data, NetworkChannel channel)
@@ -123,7 +134,7 @@ public class WebSocketServer : INetworkServer
       activeConnection.Reliable.Send(data);    
   }
 
-  public async void Flush()
+  public async ValueTask Flush()
   {
     foreach (var conn in _activeConnections)
       await conn.Flush();
@@ -146,13 +157,13 @@ public class WebSocketServer : INetworkServer
     _connections = new WebSocketConnection[configuration.LimitConnections];
 
     _httpListener = new HttpListener();
-    _httpListener.Prefixes.Add($"http://+:{configuration.Port}/");
+    _httpListener.Prefixes.Add($"http://{configuration.Address}:{configuration.Port}/");
     _httpListener.Start();
 
     _executor.Run(() => StartAccept(_cancellationTokenSource.Token));
 
     var protocolDecoded = RagonVersion.Parse(configuration.Protocol);
-    _logger.Info($"Listen at http://0.0.0.0:{configuration.Port}/");
+    _logger.Info($"Listen at http://{configuration.Address}:{configuration.Port}/");
     _logger.Info($"Protocol: {protocolDecoded}");
   }
 

Ragon.Server/Sources/Data/RagonData.cs

@@ -12,13 +12,25 @@ public class RagonData
   {
   }
 
-  public void Read(RagonBuffer buffer)
+  public void Read(RagonBuffer buffer, int maxSize = 0)
   {
     var len = buffer.ReadUShort();
+    var totalSize = 0;
+
     for (int i = 0; i < len; i++)
     {
       var key = buffer.ReadString();
       var valueSize = buffer.ReadUShort();
+
+      if (maxSize > 0)
+      {
+        totalSize += valueSize;
+        if (totalSize > maxSize)
+        {
+          throw new InvalidOperationException($"User data exceeds limit: {totalSize} > {maxSize}");
+        }
+      }
+
       if (valueSize > 0)
       {
         var value = buffer.ReadBytes(valueSize);
@@ -59,8 +71,6 @@ public class RagonData
       buffer.WriteString(prop.Key);
       buffer.WriteUShort((ushort)prop.Value.Length);
       buffer.WriteBytes(prop.Value);
-      
-      Console.WriteLine($"Key: {prop.Key} Value: {prop.Value.Length}");
     }
   }
 }

Ragon.Server/Sources/Entity/RagonProperty.cs

@@ -27,13 +27,13 @@ public class RagonProperty : RagonPayload
 
   private uint[] _data;
 
-  public RagonProperty(int size, bool isFixed)
+  public RagonProperty(int size, bool isFixed, int limit)
   {
     Size = size;
     IsFixed = isFixed;
     IsDirty = false;
-
-    _data = new uint[128];
+    
+    _data = new uint[limit / 4 + 1]; 
   }
 
   public void Read(RagonBuffer buffer)

Ragon.Server/Sources/Handler/AuthorizationOperation.cs

@@ -19,6 +19,7 @@ using Ragon.Server.IO;
 using Ragon.Server.Lobby;
 using Ragon.Server.Logging;
 using Ragon.Server.Plugin;
+using Ragon.Server.Project;
 
 namespace Ragon.Server.Handler
 {
@@ -30,19 +31,22 @@ namespace Ragon.Server.Handler
     private readonly RagonContextObserver _observer;
     private readonly RagonServerConfiguration _configuration;
     private readonly RagonBuffer _writer;
+    private readonly ProjectRegistry _projectRegistry;
 
     public AuthorizationOperation(RagonBuffer reader,
       RagonBuffer writer,
       IRagonServer server,
       IServerPlugin serverPlugin,
       RagonContextObserver observer,
-      RagonServerConfiguration configuration) : base(reader, writer)
+      RagonServerConfiguration configuration,
+      ProjectRegistry projectRegistry) : base(reader, writer)
     {
       _serverPlugin = serverPlugin;
       _configuration = configuration;
       _observer = observer;
       _writer = writer;
       _server = server;
+      _projectRegistry = projectRegistry;
     }
 
     public override void Handle(RagonContext context, NetworkChannel channel)
@@ -59,29 +63,45 @@ namespace Ragon.Server.Handler
         return;
       }
 
-      var configuration = _configuration;
-      var key = Reader.ReadString();
+      var projectKey = Reader.ReadString();
       var name = Reader.ReadString();
       var payload = Reader.ReadString();
 
-      if (key == configuration.ServerKey)
-      {
-        var authorizeViaPlugin = _serverPlugin.OnAuthorize(new ConnectionRequest(_server, context.Connection.Id, payload));
-        if (authorizeViaPlugin)
-          return;
-
-        var id = Guid.NewGuid().ToString();
-        Approve(context, new ConnectionResponse(id, name, payload));
-      }
-      else
+      if (!_projectRegistry.ValidateKey(projectKey))
       {
+        _logger.Warning($"Invalid project key from connection {context.Connection.Id}");
         Reject(context);
+        return;
       }
+
+      if (!_projectRegistry.CanConnect(projectKey))
+      {
+        _logger.Warning($"Connection limit reached for project key: {projectKey}");
+        Reject(context);
+        return;
+      }
+
+      var authorizeViaPlugin = _serverPlugin.OnAuthorize(new ConnectionRequest(_server, context.Connection.Id, payload));
+      if (authorizeViaPlugin)
+        return;
+
+      var project = _projectRegistry.GetOrCreateProject(projectKey);
+      if (project == null)
+      {
+        _logger.Warning($"Failed to create project for key: {projectKey}");
+        Reject(context);
+        return;
+      }
+
+      var id = Guid.NewGuid().ToString();
+      Approve(context, new ConnectionResponse(id, name, payload), project.Id);
+
+      _projectRegistry.RegisterConnection(project.Id);
     }
 
-    public void Approve(RagonContext context, ConnectionResponse result)
+    public void Approve(RagonContext context, ConnectionResponse result, int projectId)
     {
-      var lobbyPlayer = new RagonLobbyPlayer(context.Connection, result.Id, result.Name, result.Payload);
+      var lobbyPlayer = new RagonLobbyPlayer(context.Connection, result.Id, result.Name, result.Payload, projectId);
       context.SetPlayer(lobbyPlayer);
       context.ConnectionStatus = ConnectionStatus.Authorized;
 
@@ -100,7 +120,7 @@ namespace Ragon.Server.Handler
       var sendData = _writer.ToArray();
       context.Connection.Reliable.Send(sendData);
 
-      _logger.Trace($"Connection {context.Connection.Id} as {playerId}|{context.LobbyPlayer.Name} authorized");
+      _logger.Trace($"Approved {context.Connection.Id} as {playerId}|{context.LobbyPlayer.Name} for project {projectId}");
     }
 
     public void Reject(RagonContext context)
@@ -113,7 +133,7 @@ namespace Ragon.Server.Handler
       context.Connection.Reliable.Send(sendData);
       context.Connection.Close();
 
-      _logger.Trace($"Connection {context.Connection.Id}");
+      _logger.Trace($"Rejected  Connectin:{context.Connection.Id}");
     }
   }
 }

Ragon.Server/Sources/Handler/EntityCreateOperation.cs

@@ -24,11 +24,14 @@ namespace Ragon.Server.Handler;
 public sealed class EntityCreateOperation : BaseOperation
 {
   private readonly IRagonLogger _logger = LoggerManager.GetLogger(nameof(EntityCreateOperation));
-  
-  public EntityCreateOperation(RagonBuffer reader, RagonBuffer writer) : base(reader, writer)
+  private RagonServerConfiguration _configuration;
+
+  public EntityCreateOperation(RagonBuffer reader, RagonBuffer writer, RagonServerConfiguration configuration) :
+    base(reader, writer)
   {
+    _configuration = configuration;
   }
-    
+
   public override void Handle(RagonContext context, NetworkChannel channel)
   {
     var player = context.RoomPlayer;
@@ -53,7 +56,7 @@ public sealed class EntityCreateOperation : BaseOperation
       var propertyType = Reader.ReadBool();
       var propertySize = Reader.ReadUShort();
 
-      entity.AddProperty(new RagonProperty(propertySize, propertyType));
+      entity.AddProperty(new RagonProperty(propertySize, propertyType, _configuration.LimitPropertySize));
     }
     
     if (Reader.Capacity > 0)

Ragon.Server/Sources/Handler/PlayerUserDataOperation.cs

@@ -27,7 +27,7 @@ namespace Ragon.Server.Handler
         return;
       }
 
-      context.UserData.Read(Reader);
+      context.UserData.Read(Reader, _userDataLimit);
     }
   }
 }

Ragon.Server/Sources/Handler/RoomCreateOperation.cs

@@ -88,7 +88,7 @@ namespace Ragon.Server.Handler
       var roomPlayer = new RagonRoomPlayer(context, lobbyPlayer.Id, lobbyPlayer.Name);
 
       var roomPlugin = _serverPlugin.CreateRoomPlugin(information);
-      var room = new RagonRoom(roomId, information, roomPlugin);
+      var room = new RagonRoom(roomId, information, roomPlugin, lobbyPlayer.ProjectId);
 
       room.Plugin.OnAttached(room);
       roomPlayer.OnAttached(room);

Ragon.Server/Sources/Handler/RoomJoinOperation.cs

@@ -43,6 +43,13 @@ public sealed class RoomJoinOperation : BaseOperation
       return;
     }
 
+    if (existsRoom.ProjectId != lobbyPlayer.ProjectId)
+    {
+      JoinFailed(context, Writer);
+      _logger.Warning($"Player {context.Connection.Id}|{lobbyPlayer.Name} tried to join room from different project");
+      return;
+    }
+
     var player = new RagonRoomPlayer(context, lobbyPlayer.Id, lobbyPlayer.Name);
     context.SetRoom(existsRoom, player);
     

Ragon.Server/Sources/Handler/RoomJoinOrCreateOperation.cs

@@ -57,6 +57,12 @@ public sealed class RoomJoinOrCreateOperation : BaseOperation
 
     if (context.Lobby.FindRoomByScene(_roomParameters.Scene, out var existsRoom))
     {
+      if (existsRoom.ProjectId != lobbyPlayer.ProjectId)
+      {
+        _logger.Warning($"Player {context.Connection.Id}|{lobbyPlayer.Name} tried to join room from different project");
+        return;
+      }
+
       var player = new RagonRoomPlayer(context, lobbyPlayer.Id, lobbyPlayer.Name);
 
       context.SetRoom(existsRoom, player);
@@ -81,7 +87,7 @@ public sealed class RoomJoinOrCreateOperation : BaseOperation
 
       var roomPlayer = new RagonRoomPlayer(context, lobbyPlayer.Id, lobbyPlayer.Name);
       var roomPlugin = _serverPlugin.CreateRoomPlugin(information);
-      var room = new RagonRoom(roomId, information, roomPlugin);
+      var room = new RagonRoom(roomId, information, roomPlugin, lobbyPlayer.ProjectId);
 
       _serverPlugin.OnRoomCreate(lobbyPlayer, room);
 

Ragon.Server/Sources/Handler/RoomUserDataOperation.cs

@@ -45,6 +45,6 @@ public sealed class RoomUserDataOperation : BaseOperation
     
     var room = context.Room;
     if (room != null)
-      room.UserData.Read(Reader);
+      room.UserData.Read(Reader, _userDataLimit);
   }
 }

Ragon.Server/Sources/Handler/SceneLoadedOperation.cs

@@ -27,9 +27,11 @@ namespace Ragon.Server.Handler
   public sealed class SceneLoadedOperation : BaseOperation
   {
     private readonly IRagonLogger _logger = LoggerManager.GetLogger(nameof(SceneLoadedOperation));
-
-    public SceneLoadedOperation(RagonBuffer reader, RagonBuffer writer) : base(reader, writer)
+    private RagonServerConfiguration _configuration;
+    
+    public SceneLoadedOperation(RagonBuffer reader, RagonBuffer writer, RagonServerConfiguration serverConfiguration) : base(reader, writer)
     {
+      _configuration = serverConfiguration;
     }
 
     public override void Handle(RagonContext context, NetworkChannel channel)
@@ -40,6 +42,7 @@ namespace Ragon.Server.Handler
       var owner = context.Room.Owner;
       var player = context.RoomPlayer;
       var room = context.Room;
+     
       if (player.IsLoaded)
       {
         _logger.Warning($"Player {player.Name}:{player.Connection.Id} already ready");
@@ -70,10 +73,11 @@ namespace Ragon.Server.Handler
           {
             var propertyType = Reader.ReadBool();
             var propertySize = Reader.ReadUShort();
-            entity.AddProperty(new RagonProperty(propertySize, propertyType));
+            entity.AddProperty(new RagonProperty(propertySize, propertyType, _configuration.LimitPropertySize));
           }
 
           var roomPlugin = room.Plugin;
+          
           if (!roomPlugin.OnEntityCreate(player, entity)) continue;
 
           var playerInfo = $"Player {context.Connection.Id}|{context.LobbyPlayer.Name}";

Ragon.Server/Sources/Lobby/RagonLobbyDispatcher.cs

@@ -12,12 +12,17 @@ public class RagonLobbyDispatcher
     _lobby = lobby;
   }
 
-  public void Write(RagonBuffer writer)
+  public void Write(RagonBuffer writer, int projectId = 0)
   {
     writer.Clear();
     writer.WriteOperation(RagonOperation.ROOM_LIST_UPDATED);
     var rooms = _lobby.Rooms;
 
+    if (projectId > 0)
+    {
+      rooms = rooms.Where(r => r.ProjectId == projectId).ToList();
+    }
+
     writer.WriteUShort((ushort)rooms.Count);
     for (int i = 0; i < rooms.Count; i++)
     {

Ragon.Server/Sources/Lobby/RagonLobbyPlayer.cs

@@ -32,12 +32,14 @@ public class RagonLobbyPlayer
   public string Id { get; private set; }
   public string Name { get; private set; }
   public string Payload { get; private set; }
-  
-  public RagonLobbyPlayer(INetworkConnection connection, string id, string name, string payload)
+  public int ProjectId { get; private set; }
+
+  public RagonLobbyPlayer(INetworkConnection connection, string id, string name, string payload, int projectId)
   {
     Id = id;
     Name = name;
     Connection = connection;
     Payload = payload;
+    ProjectId = projectId;
   }
 }

Ragon.Server/Sources/Plugin/BaseServerPlugin.cs

@@ -47,7 +47,7 @@ namespace Ragon.Server.Plugin
         return;
 
       var operation = (AuthorizationOperation)_server.ResolveHandler(RagonOperation.AUTHORIZE);
-      operation.Approve(ctx, new ConnectionResponse(id, name, payload));
+      operation.Approve(ctx, new ConnectionResponse(id, name, payload), 0);
     }
 
     public void Reject()

Ragon.Server/Sources/Project/ProjectRegistry.cs

@@ -0,0 +1,89 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Server.Project;
+
+public class ProjectRegistry
+{
+  private readonly Dictionary<string, RagonProject> _projectsByKey;
+  private readonly Dictionary<int, RagonProject> _projectsById;
+  private readonly int _connectionLimitPerProject;
+
+  public ProjectRegistry(int connectionLimitPerProject)
+  {
+    _projectsByKey = new Dictionary<string, RagonProject>();
+    _projectsById = new Dictionary<int, RagonProject>();
+    _connectionLimitPerProject = connectionLimitPerProject;
+  }
+
+  public bool ValidateKey(string key)
+  {
+    if (string.IsNullOrWhiteSpace(key))
+      return false;
+
+    if (key.Length < 4)
+      return false;
+
+    return true;
+  }
+
+  public RagonProject? GetOrCreateProject(string projectKey)
+  {
+    if (!_projectsByKey.TryGetValue(projectKey, out var project))
+    {
+      project = new RagonProject(projectKey);
+      _projectsByKey[projectKey] = project;
+      _projectsById[project.Id] = project;
+    }
+
+    return project;
+  }
+
+  public bool CanConnect(string projectKey)
+  {
+    if (!_projectsByKey.TryGetValue(projectKey, out var project))
+      return true;
+
+    return project.ActiveConnections < _connectionLimitPerProject;
+  }
+
+  public void RegisterConnection(int projectId)
+  {
+    if (_projectsById.TryGetValue(projectId, out var project))
+    {
+      project.IncrementConnections();
+    }
+  }
+
+  public void UnregisterConnection(int projectId)
+  {
+    if (_projectsById.TryGetValue(projectId, out var project))
+    {
+      project.DecrementConnections();
+
+      if (project.ActiveConnections <= 0)
+      {
+        _projectsByKey.Remove(project.Key);
+        _projectsById.Remove(projectId);
+      }
+    }
+  }
+
+  public RagonProject? GetProjectById(int projectId)
+  {
+    return _projectsById.TryGetValue(projectId, out var project) ? project : null;
+  }
+}

Ragon.Server/Sources/Project/RagonProject.cs

@@ -0,0 +1,44 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Server.Project;
+
+public class RagonProject
+{
+  private static int _idGenerator = 0;
+
+  public int Id { get; }
+  public string Key { get; }
+  public int ActiveConnections { get; private set; }
+
+  public RagonProject(string key)
+  {
+    Id = Interlocked.Increment(ref _idGenerator);
+    Key = key;
+    ActiveConnections = 0;
+  }
+
+  public void IncrementConnections()
+  {
+    ActiveConnections++;
+  }
+
+  public void DecrementConnections()
+  {
+    if (ActiveConnections > 0)
+      ActiveConnections--;
+  }
+}

Ragon.Server/Sources/RagonServer.cs

@@ -21,14 +21,15 @@ using Ragon.Server.IO;
 using Ragon.Server.Lobby;
 using Ragon.Server.Logging;
 using Ragon.Server.Plugin;
+using Ragon.Server.Project;
 using Ragon.Server.Time;
 
 namespace Ragon.Server;
 
 public class RagonServer : IRagonServer, INetworkListener
 {
-  private const string ServerVersion = "1.4.0";
-  
+  private const string ServerVersion = "1.4.3";
+
   private readonly IRagonLogger _logger = LoggerManager.GetLogger(nameof(RagonServer));
   private readonly INetworkServer _server;
   private readonly BaseOperation[] _handlers;
@@ -40,12 +41,14 @@ public class RagonServer : IRagonServer, INetworkListener
   private readonly RagonScheduler _scheduler;
   private readonly Dictionary<ushort, RagonContext> _contextsByConnection;
   private readonly Dictionary<string, RagonContext> _contextsByPlayerId;
+  private readonly ProjectRegistry _projectRegistry;
   private readonly Stopwatch _timer;
   private readonly RagonLobbyDispatcher _lobbySerializer;
   private readonly long _tickRate = 0;
   private bool _isRunning = false;
 
   public bool IsRunning => _isRunning;
+  public ProjectRegistry ProjectRegistry => _projectRegistry;
 
   public RagonServer(
     INetworkServer server,
@@ -57,6 +60,7 @@ public class RagonServer : IRagonServer, INetworkListener
     _serverPlugin = plugin;
     _contextsByConnection = new Dictionary<ushort, RagonContext>();
     _contextsByPlayerId = new Dictionary<string, RagonContext>();
+    _projectRegistry = new ProjectRegistry(configuration.LimitConnectionsPerProject);
     _lobby = new LobbyInMemory();
     _lobbySerializer = new RagonLobbyDispatcher(_lobby);
     _scheduler = new RagonScheduler();
@@ -66,7 +70,6 @@ public class RagonServer : IRagonServer, INetworkListener
     _timer = new Stopwatch();
     
     var contextObserver = new RagonContextObserver(_contextsByPlayerId);
-    
     _scheduler.Run(new RagonActionTimer(SendRoomList, 2.0f));
     _scheduler.Run(new RagonActionTimer(SendPlayerUserData, 0.1f));
     _scheduler.Run(new RagonActionTimer(SendRoomUserData, 0.1f));
@@ -74,14 +77,14 @@ public class RagonServer : IRagonServer, INetworkListener
     _serverPlugin.OnAttached(this);
 
     _handlers = new BaseOperation[byte.MaxValue];
-    _handlers[(byte)RagonOperation.AUTHORIZE] = new AuthorizationOperation(_reader, _writer, this, _serverPlugin, contextObserver, configuration);
+    _handlers[(byte)RagonOperation.AUTHORIZE] = new AuthorizationOperation(_reader, _writer, this, _serverPlugin, contextObserver, configuration, _projectRegistry);
     _handlers[(byte)RagonOperation.JOIN_OR_CREATE_ROOM] = new RoomJoinOrCreateOperation(_reader, _writer, plugin, _configuration);
     _handlers[(byte)RagonOperation.CREATE_ROOM] = new RoomCreateOperation(_reader, _writer, plugin, _configuration);
     _handlers[(byte)RagonOperation.JOIN_ROOM] = new RoomJoinOperation(_reader, _writer);
     _handlers[(byte)RagonOperation.LEAVE_ROOM] = new RoomLeaveOperation(_reader, _writer);
     _handlers[(byte)RagonOperation.LOAD_SCENE] = new SceneLoadOperation(_reader, _writer);
-    _handlers[(byte)RagonOperation.SCENE_LOADED] = new SceneLoadedOperation(_reader, _writer);
-    _handlers[(byte)RagonOperation.CREATE_ENTITY] = new EntityCreateOperation(_reader, _writer);
+    _handlers[(byte)RagonOperation.SCENE_LOADED] = new SceneLoadedOperation(_reader, _writer, _configuration);
+    _handlers[(byte)RagonOperation.CREATE_ENTITY] = new EntityCreateOperation(_reader, _writer, _configuration);
     _handlers[(byte)RagonOperation.REMOVE_ENTITY] = new EntityDestroyOperation(_reader, _writer);
     _handlers[(byte)RagonOperation.REPLICATE_ENTITY_EVENT] = new EntityEventOperation(_reader, _writer);
     _handlers[(byte)RagonOperation.REPLICATE_ENTITY_STATE] = new EntityStateOperation(_reader, _writer);
@@ -90,8 +93,8 @@ public class RagonServer : IRagonServer, INetworkListener
     _handlers[(byte)RagonOperation.TIMESTAMP_SYNCHRONIZATION] = new TimestampSyncOperation(_reader, _writer);
     _handlers[(byte)RagonOperation.REPLICATE_ROOM_EVENT] = new RoomEventOperation(_reader, _writer);
     _handlers[(byte)RagonOperation.REPLICATE_RAW_DATA] = new RoomDataOperation(_reader, _writer);
-    _handlers[(byte)RagonOperation.ROOM_DATA_UPDATED] = new RoomUserDataOperation(_reader, _writer, _configuration.LimitUserData);
-    _handlers[(byte)RagonOperation.PLAYER_DATA_UPDATED] = new PlayerUserDataOperation(_reader, _writer, _configuration.LimitUserData);
+    _handlers[(byte)RagonOperation.ROOM_DATA_UPDATED] = new RoomUserDataOperation(_reader, _writer, _configuration.LimitUserDataSize);
+    _handlers[(byte)RagonOperation.PLAYER_DATA_UPDATED] = new PlayerUserDataOperation(_reader, _writer, _configuration.LimitUserDataSize);
   }
   public void Tick()
   {
@@ -119,7 +122,7 @@ public class RagonServer : IRagonServer, INetworkListener
     {
       LimitConnections = _configuration.LimitConnections,
       Protocol = RagonVersion.Parse(_configuration.Protocol),
-      Address = "0.0.0.0",
+      Address = _configuration.ServerAddress,
       Port = _configuration.Port,
     };
 
@@ -153,10 +156,15 @@ public class RagonServer : IRagonServer, INetworkListener
       if (room != null)
       {
         room.DetachPlayer(context.RoomPlayer);
-        
+
         _lobby.RemoveIfEmpty(room);
       }
-      _contextsByPlayerId.Remove(context.LobbyPlayer.Id);
+
+      if (context.ConnectionStatus == ConnectionStatus.Authorized)
+      {
+        _contextsByPlayerId.Remove(context.LobbyPlayer.Id);
+        _projectRegistry.UnregisterConnection(context.LobbyPlayer.ProjectId);
+      }
 
       _logger.Trace($"Disconnected: {connection.Id}");
     }
@@ -176,8 +184,13 @@ public class RagonServer : IRagonServer, INetworkListener
         room.DetachPlayer(context.RoomPlayer);
         _lobby.RemoveIfEmpty(room);
       }
-      _contextsByPlayerId.Remove(context.LobbyPlayer.Id);
-      
+
+      if (context.ConnectionStatus == ConnectionStatus.Authorized)
+      {
+        _contextsByPlayerId.Remove(context.LobbyPlayer.Id);
+        _projectRegistry.UnregisterConnection(context.LobbyPlayer.ProjectId);
+      }
+
       _logger.Trace($"Timeout: {connection.Id}|{context.LobbyPlayer.Name}|{context.LobbyPlayer.Id}");
     }
     else
@@ -195,9 +208,16 @@ public class RagonServer : IRagonServer, INetworkListener
         _writer.Clear();
         _reader.Clear();
         _reader.FromArray(data);
-        
+
         var operation = _reader.ReadByte();
-        _handlers[operation]?.Handle(context, channel);
+
+        if (operation >= _handlers.Length || _handlers[operation] == null)
+        {
+          _logger.Warning($"Invalid operation code: {operation} from connection {connection.Id}");
+          return;
+        }
+
+        _handlers[operation].Handle(context, channel);
       }
     }
     catch (Exception ex)
@@ -225,13 +245,14 @@ public class RagonServer : IRagonServer, INetworkListener
 
   public void SendRoomList()
   {
-    _lobbySerializer.Write(_writer);
-
-    var sendData = _writer.ToArray();
-    foreach (var (_, value) in _contextsByPlayerId)
+    foreach (var (_, context) in _contextsByPlayerId)
     {
-      if (value.Room == null) // If only in lobby, then send room list data
-        value.Connection.Reliable.Send(sendData);
+      if (context.Room == null) // If only in lobby, then send room list data
+      {
+        _lobbySerializer.Write(_writer, context.LobbyPlayer.ProjectId);
+        var sendData = _writer.ToArray();
+        context.Connection.Reliable.Send(sendData);
+      }
     }
   }
 
@@ -284,10 +305,10 @@ public class RagonServer : IRagonServer, INetworkListener
   {
     return _contextsByPlayerId.TryGetValue(playerId, out var context) ? context : null;
   }
-  
+
   private void CopyrightInfo()
   {
-    _logger.Info($"Ragon Server Version: {ServerVersion}");
+    _logger.Info($"Server Version: {ServerVersion}");
     _logger.Info($"Machine Name: {Environment.MachineName}");
     _logger.Info($"OS: {Environment.OSVersion}");
     _logger.Info($"Processors: {Environment.ProcessorCount}");

Ragon.Server/Sources/RagonServerConfiguration.cs

@@ -26,6 +26,7 @@ public enum ServerType
 public struct RagonServerConfiguration
 {
   public string ServerKey;
+  public string ServerAddress;
   public ushort ServerTickRate;
   public string Protocol;
   public ushort Port;
@@ -33,7 +34,9 @@ public struct RagonServerConfiguration
   public int LimitPlayersPerRoom;
   public int LimitRooms;
   public int LimitBufferedEvents;
-  public int LimitUserData;
+  public int LimitUserDataSize;
+  public int LimitPropertySize;
+  public int LimitConnectionsPerProject;
 
   private static Dictionary<string, ServerType> _serverTypes = new Dictionary<string, ServerType>()
   {

Ragon.Server/Sources/Room/IRagonRoom.cs

@@ -24,6 +24,7 @@ public interface IRagonRoom
 {
   public string Id { get; }
   public string Scene { get; }
+  public int ProjectId { get; }
   public int PlayerMin { get; }
   public int PlayerMax { get; }
   public int PlayerCount { get; }

Ragon.Server/Sources/Room/RagonRoom.cs

@@ -31,7 +31,8 @@ public class RagonRoom : IRagonRoom, IRagonAction
   public int PlayerMax { get; private set; }
   public int PlayerMin { get; private set; }
   public int PlayerCount => WaitPlayersList.Count;
-  
+  public int ProjectId { get; private set; }
+
   public bool IsDone { get; private set; }
 
   public RagonData UserData { get; set; }
@@ -53,13 +54,14 @@ public class RagonRoom : IRagonRoom, IRagonAction
   private readonly List<RagonEvent> _bufferedEvents;
   private readonly int _limitBufferedEvents;
 
-  public RagonRoom(string roomId, RoomInformation info, IRoomPlugin roomPlugin)
+  public RagonRoom(string roomId, RoomInformation info, IRoomPlugin roomPlugin, int projectId)
   {
     Id = roomId;
     Scene = info.Scene;
     PlayerMax = info.Max;
     PlayerMin = info.Min;
     Plugin = roomPlugin;
+    ProjectId = projectId;
 
     Players = new Dictionary<ushort, RagonRoomPlayer>(info.Max);
     WaitPlayersList = new List<RagonRoomPlayer>(info.Max);