♻️ plugin api

Plugins

Ragon.Client.Simulation/Sources/Game.cs

@@ -18,7 +18,7 @@ public class Game : IRagonListener
     public void OnConnected(RagonClient client)
     {
         RagonLog.Trace("Connected");
-        _client.Session.AuthorizeWithKey("defaultkey", "Player Eduard", Array.Empty<byte>());
+        _client.Session.AuthorizeWithKey("defaultkey", "Player Eduard");
     }
 
     public void OnAuthorizationSuccess(RagonClient client, string playerId, string playerName)

Ragon.Client/Ragon.Client.csproj

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

Ragon.Client/Sources/Handler/AuthorizeSuccessHandler.cs

@@ -32,7 +32,8 @@ internal  class AuthorizeSuccessHandler: Handler
   {
     var playerId = buffer.ReadString();
     var playerName = buffer.ReadString();
+    var playerPayload = buffer.ReadString();
 
-    _listenerList.OnAuthorizationSuccess(playerId, playerName);
+    _listenerList.OnAuthorizationSuccess(playerId, playerName, playerPayload);
   }
 }

Ragon.Client/Sources/Handler/EntityRemoveHandler.cs

@@ -19,11 +19,11 @@ using Ragon.Protocol;
 
 namespace Ragon.Client;
 
-internal  class EntityDestroyHandler: Handler
+internal  class EntityRemoveHandler: Handler
 {
   private readonly RagonEntityCache _entityCache;
   
-  public EntityDestroyHandler(RagonEntityCache entityCache)
+  public EntityRemoveHandler(RagonEntityCache entityCache)
   {
     _entityCache = entityCache;
   }

Ragon.Client/Sources/Listener/IRagonConnectionListener.cs

@@ -16,7 +16,7 @@
 
 namespace Ragon.Client;
 
-public interface IRagonConnectedListener
+public interface IRagonConnectionListener
 {
   void OnConnected(RagonClient client);
   void OnDisconnected(RagonClient client);

Ragon.Client/Sources/Listener/IRagonListener.cs

@@ -18,7 +18,7 @@ namespace Ragon.Client
 {
   public interface IRagonListener : 
     IRagonAuthorizationListener, 
-    IRagonConnectedListener, 
+    IRagonConnectionListener, 
     IRagonFailedListener,
     IRagonJoinListener, 
     IRagonLeftListener, 

Ragon.Client/Sources/RagonClient.cs

@@ -87,23 +87,18 @@ namespace Ragon.Client
       _handlers = new Handler[byte.MaxValue];
       _handlers[(byte)RagonOperation.AUTHORIZED_SUCCESS] = new AuthorizeSuccessHandler(_listenerList);
       _handlers[(byte)RagonOperation.AUTHORIZED_FAILED] = new AuthorizeFailedHandler(_listenerList);
-      _handlers[(byte)RagonOperation.JOIN_SUCCESS] =
+      _handlers[(byte)RagonOperation.JOIN_SUCCESS] = new JoinSuccessHandler(this, _readBuffer, _listenerList, _playerCache, _entityCache);
-        new JoinSuccessHandler(this, _readBuffer, _listenerList, _playerCache, _entityCache);
       _handlers[(byte)RagonOperation.JOIN_FAILED] = new JoinFailedHandler(_listenerList);
       _handlers[(byte)RagonOperation.LEAVE_ROOM] = new LeaveRoomHandler(this, _listenerList, _entityCache);
-      _handlers[(byte)RagonOperation.OWNERSHIP_CHANGED] =
+      _handlers[(byte)RagonOperation.OWNERSHIP_CHANGED] = new OwnershipHandler(_listenerList, _playerCache, _entityCache);
-        new OwnershipHandler(_listenerList, _playerCache, _entityCache);
       _handlers[(byte)RagonOperation.PLAYER_JOINED] = new PlayerJoinHandler(_playerCache, _listenerList);
-      _handlers[(byte)RagonOperation.PLAYER_LEAVED] =
+      _handlers[(byte)RagonOperation.PLAYER_LEAVED] = new PlayerLeftHandler(_entityCache, _playerCache, _listenerList);
-        new PlayerLeftHandler(_entityCache, _playerCache, _listenerList);
       _handlers[(byte)RagonOperation.LOAD_SCENE] = new SceneLoadHandler(this, _listenerList);
       _handlers[(byte)RagonOperation.CREATE_ENTITY] = new EntityCreateHandler(this, _playerCache, _entityCache);
-      _handlers[(byte)RagonOperation.DESTROY_ENTITY] = new EntityDestroyHandler(_entityCache);
+      _handlers[(byte)RagonOperation.REMOVE_ENTITY] = new EntityRemoveHandler(_entityCache);
       _handlers[(byte)RagonOperation.REPLICATE_ENTITY_STATE] = new StateEntityHandler(_entityCache);
-      _handlers[(byte)RagonOperation.REPLICATE_ENTITY_EVENT] =
+      _handlers[(byte)RagonOperation.REPLICATE_ENTITY_EVENT] = new EntityEventHandler(this, _playerCache, _entityCache);
-        new EntityEventHandler(this, _playerCache, _entityCache);
+      _handlers[(byte)RagonOperation.SNAPSHOT] = new SnapshotHandler(this, _listenerList, _entityCache, _playerCache);
-      _handlers[(byte)RagonOperation.SNAPSHOT] =
-        new SnapshotHandler(this, _listenerList, _entityCache, _playerCache);
 
       var protocolRaw = RagonVersion.Parse(protocol);
       _connection.Connect(address, port, protocolRaw);
@@ -114,19 +109,24 @@ namespace Ragon.Client
       _status = RagonStatus.DISCONNECTED;
       _room.Cleanup();
       _connection.Disconnect();
+      
       OnDisconnected(DisconnectReason.MANUAL);
     }
 
     public void Update(float dt)
     {
-      _replicationTime += dt;
+      if (_status != RagonStatus.DISCONNECTED)
-      if (_replicationTime >= _replicationRate)
       {
-        _entityCache.WriteState(_readBuffer);
+        _replicationTime += dt;
-        _replicationTime = 0;
+        if (_replicationTime >= _replicationRate)
+        {
+          _entityCache.WriteState(_readBuffer);
+          _replicationTime = 0;
+        }
+
+        _stats.Update(_connection.BytesSent, _connection.BytesReceived, _connection.Ping, dt);
       }
 
-      _stats.Update(_connection.BytesSent, _connection.BytesReceived, _connection.Ping, dt);
       _connection.Update();
     }
 
@@ -139,7 +139,7 @@ namespace Ragon.Client
 
     public void AddListener(IRagonListener listener) => _listenerList.Add(listener);
     public void AddListener(IRagonAuthorizationListener listener) => _listenerList.Add(listener);
-    public void AddListener(IRagonConnectedListener listener) => _listenerList.Add(listener);
+    public void AddListener(IRagonConnectionListener listener) => _listenerList.Add(listener);
     public void AddListener(IRagonFailedListener listener) => _listenerList.Add(listener);
     public void AddListener(IRagonJoinListener listener) => _listenerList.Add(listener);
     public void AddListener(IRagonLeftListener listener) => _listenerList.Add(listener);
@@ -150,7 +150,7 @@ namespace Ragon.Client
 
     public void RemoveListener(IRagonListener listener) => _listenerList.Remove(listener);
     public void RemoveListener(IRagonAuthorizationListener listener) => _listenerList.Remove(listener);
-    public void RemoveListener(IRagonConnectedListener listener) => _listenerList.Remove(listener);
+    public void RemoveListener(IRagonConnectionListener listener) => _listenerList.Remove(listener);
     public void RemoveListener(IRagonFailedListener listener) => _listenerList.Remove(listener);
     public void RemoveListener(IRagonJoinListener listener) => _listenerList.Remove(listener);
     public void RemoveListener(IRagonLeftListener listener) => _listenerList.Remove(listener);

Ragon.Client/Sources/RagonEntityCache.cs

@@ -81,7 +81,7 @@ public sealed class RagonEntityCache
     var buffer = _client.Buffer;
     
     buffer.Clear();
-    buffer.WriteOperation(RagonOperation.DESTROY_ENTITY);
+    buffer.WriteOperation(RagonOperation.REMOVE_ENTITY);
     buffer.WriteUShort(entity.Id);
 
     destroyPayload?.Serialize(buffer);

Ragon.Client/Sources/RagonListenerList.cs

@@ -20,7 +20,7 @@ namespace Ragon.Client
   {
     private readonly RagonClient _client;
     private readonly List<IRagonAuthorizationListener> _authorizationListeners = new();
-    private readonly List<IRagonConnectedListener> _connectionListeners = new();
+    private readonly List<IRagonConnectionListener> _connectionListeners = new();
     private readonly List<IRagonFailedListener> _failedListeners = new();
     private readonly List<IRagonJoinListener> _joinListeners = new();
     private readonly List<IRagonLeftListener> _leftListeners = new();
@@ -65,7 +65,7 @@ namespace Ragon.Client
       _authorizationListeners.Add(listener);
     }
     
-    public void Add(IRagonConnectedListener listener)
+    public void Add(IRagonConnectionListener listener)
     {
       _connectionListeners.Add(listener);
     }
@@ -110,7 +110,7 @@ namespace Ragon.Client
       _authorizationListeners.Remove(listener);
     }
     
-    public void Remove(IRagonConnectedListener listener)
+    public void Remove(IRagonConnectionListener listener)
     {
       _connectionListeners.Remove(listener);
     }
@@ -150,7 +150,7 @@ namespace Ragon.Client
       _playerLeftListeners.Remove(listener);
     }
 
-    public void OnAuthorizationSuccess(string playerId, string playerName)
+    public void OnAuthorizationSuccess(string playerId, string playerName, string payload)
     {
       foreach (var listener in _authorizationListeners)
         listener.OnAuthorizationSuccess(_client, playerId, playerName);

Ragon.Client/Sources/RagonSession.cs

@@ -93,13 +93,13 @@ namespace Ragon.Client
       _client.Reliable.Send(sendData);
     }
 
-    public  void AuthorizeWithKey(string key, string playerName, byte[] additonalData)
+    public  void AuthorizeWithKey(string key, string playerName, string payload = "")
     {
       _buffer.Clear();
       _buffer.WriteOperation(RagonOperation.AUTHORIZE);
       _buffer.WriteString(key);
       _buffer.WriteString(playerName);
-      _buffer.WriteBytes(additonalData);
+      _buffer.WriteString(payload);
 
       var sendData = _buffer.ToArray();
       _client.Reliable.Send(sendData);

Ragon.Protocol/Sources/RagonOperation.cs

@@ -34,7 +34,7 @@ namespace Ragon.Protocol
     PLAYER_JOINED,
     PLAYER_LEAVED,
     CREATE_ENTITY,
-    DESTROY_ENTITY,
+    REMOVE_ENTITY,
     SNAPSHOT,
     REPLICATE_ENTITY_STATE,
     REPLICATE_ENTITY_EVENT,

Ragon.Relay/Sources/Command/KickPlayerCommand.cs

@@ -0,0 +1,6 @@
+namespace Ragon.Relay;
+
+public class KickPlayerCommand
+{
+  public string Id;
+}

Ragon.Relay/Sources/Relay.cs

@@ -18,7 +18,8 @@ using NLog;
 using Ragon.Server;
 using Ragon.Server.ENet;
 using Ragon.Server.DotNetWebsockets;
-
+using Ragon.Server.IO;
+using Ragon.Server.Plugin;
 
 namespace Ragon.Relay;
 
@@ -32,21 +33,19 @@ public class Relay
     var configuration = Configuration.Load("relay.config.json");
     var serverType = Configuration.GetServerType(configuration.ServerType);
 
-    INetworkServer server = null;
+    INetworkServer networkServer = new ENetServer();
+    IServerPlugin plugin = new RelayServerPlugin();
     switch (serverType)
     {
       case ServerType.ENET:
-        server = new ENetServer();
+        networkServer = new ENetServer();
         break;
       case ServerType.WEBSOCKET:
-        server = new DotNetWebSocketServer();
+        networkServer = new DotNetWebSocketServer();
-        break;
-      default:
-        server = new ENetServer();
         break;
     }
 
-    var relay = new RagonServer(server, configuration);
+    var relay = new RagonServer(networkServer, plugin, configuration);
     logger.Info("Started");
     relay.Start();
   }

Ragon.Relay/Sources/RelayRoomPlugin.cs

@@ -0,0 +1,37 @@
+using System;
+using Ragon.Server;
+using Ragon.Server.Entity;
+using Ragon.Server.Plugin;
+using Ragon.Server.Room;
+
+namespace Ragon.Relay;
+
+public class RelayRoomPlugin: BaseRoomPlugin
+{
+  public void Tick(float dt)
+  {
+    
+  }
+
+  public void OnAttached()
+  {
+    Console.WriteLine("Room attached");
+  }
+
+  public void OnDetached()
+  {
+    Console.WriteLine("Room detached");
+  }
+
+  public bool OnEntityCreate(RagonRoomPlayer creator, RagonEntity entity)
+  {
+    Console.WriteLine($"Entity created: {entity.Id}");
+    return true;
+  }
+
+  public bool OnEntityRemove(RagonRoomPlayer destroyer, RagonEntity entity)
+  {
+    Console.WriteLine($"Entity destroyed: {entity.Id}");
+    return true;
+  }
+}

Ragon.Relay/Sources/RelayServerPlugin.cs

@@ -0,0 +1,24 @@
+using System;
+using Newtonsoft.Json;
+using Ragon.Server.Plugin;
+
+namespace Ragon.Relay;
+
+public class RelayServerPlugin: BaseServerPlugin
+{
+  public override bool OnCommand(string command, string payload)
+  {
+    Console.WriteLine(command);
+    if (command == "kick-player")
+    {
+      var commandPayload = JsonConvert.DeserializeObject<KickPlayerCommand>(payload);
+      var player = Server.GetPlayerById(commandPayload.Id);
+      if (player != null)
+        player.Connection.Close();
+      else
+        Console.WriteLine($"Player not found with Id {commandPayload.Id}");
+    }
+    
+    return true;
+  }
+}

Ragon.Relay/relay.config.json

@@ -3,8 +3,17 @@
   "serverType": "enet",
   "serverTickRate": 30,
   "gameProtocol": "1.0.0",
-  "port": 5001,
+  "port": 5000,
+  "httpPort": 5001,
+  "httpKey": "defaultkey",
   "limitConnections": 4095,
   "limitPlayersPerRoom": 20,
-  "limitRooms": 200
+  "limitRooms": 200,
+  "webHooks":
+  {
+    "room-created": "http://127.0.0.1:3000/service/create-room",
+    "room-removed": "http://127.0.0.1:3000/service/remove-room",
+    "room-joined": "http://127.0.0.1:3000/service/join-room",
+    "room-leaved": "http://127.0.0.1:3000/service/leave-room"
+  }
 }

Ragon.Server.DotNetWebSockets/Sources/WebSocketConnection.cs

@@ -14,8 +14,9 @@
  * limitations under the License.
  */
 
-using System.Net.WebSockets;
 using NLog;
+using System.Net.WebSockets;
+using Ragon.Server.IO;
 
 namespace Ragon.Server.DotNetWebsockets;
 
@@ -43,6 +44,11 @@ public sealed class WebSocketConnection : INetworkConnection
         Unreliable = unreliableChannel;
     }
 
+    public void Close()
+    {
+        Socket.CloseAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None);
+    }
+    
     public async Task Flush()
     {
         foreach (var channel in _channels)

Ragon.Server.DotNetWebSockets/Sources/WebSocketReliableChannel.cs

@@ -15,7 +15,7 @@
  */
 
 using System.Net.WebSockets;
-using Ragon.Server;
+using Ragon.Server.IO;
 
 namespace Ragon.Server.DotNetWebsockets;
 

Ragon.Server.DotNetWebSockets/Sources/WebSocketServer.cs

@@ -18,6 +18,7 @@ using System.Net;
 using System.Net.WebSockets;
 using NLog;
 using Ragon.Protocol;
+using Ragon.Server.IO;
 
 namespace Ragon.Server.DotNetWebsockets;
 

Ragon.Server.ENet/Sources/ENetConnection.cs

@@ -15,6 +15,7 @@
  */
 
 using ENet;
+using Ragon.Server.IO;
 
 namespace Ragon.Server.ENet;
 
@@ -23,11 +24,19 @@ public sealed class ENetConnection: INetworkConnection
   public ushort Id { get; }
   public INetworkChannel Reliable { get; private set; }
   public INetworkChannel Unreliable { get; private set; }
+  private Peer _peer;
   
   public ENetConnection(Peer peer)
   {
+    _peer = peer;
+    
     Id = (ushort) peer.ID;
     Reliable = new ENetReliableChannel(peer, 0);
     Unreliable = new ENetUnreliableChannel(peer, 1);
   }
+  
+  public void Close()
+  {
+    _peer.Disconnect(0);
+  }
 }

Ragon.Server.ENet/Sources/ENetReliableChannel.cs

@@ -15,6 +15,7 @@
  */
 
 using ENet;
+using Ragon.Server.IO;
 
 namespace Ragon.Server.ENet;
 

Ragon.Server.ENet/Sources/ENetServer.cs

@@ -17,6 +17,7 @@
 using ENet;
 using NLog;
 using Ragon.Protocol;
+using Ragon.Server.IO;
 
 namespace Ragon.Server.ENet
 {

Ragon.Server.ENet/Sources/ENetUnreliableChannel.cs

@@ -15,6 +15,7 @@
  */
 
 using ENet;
+using Ragon.Server.IO;
 
 namespace Ragon.Server.ENet;
 

Ragon.Server/Sources/Entity/IRagonEntity.cs

@@ -0,0 +1,16 @@
+using Ragon.Protocol;
+using Ragon.Server.Room;
+
+namespace Ragon.Server.Entity;
+
+public interface IRagonEntity
+{
+  public ushort Id { get; }
+  public ushort Type { get; }
+  public ushort StaticId { get; }
+  public ushort AttachId { get; }
+  public RagonRoomPlayer Owner { get; }
+  public RagonAuthority Authority { get; }
+  public RagonPayload Payload { get; }
+  public IRagonEntityState State { get; }
+}

Ragon.Server/Sources/Entity/IRagonEntityState.cs

@@ -0,0 +1,8 @@
+using Ragon.Protocol;
+
+namespace Ragon.Server.Entity;
+
+public interface IRagonEntityState
+{
+  
+}

Ragon.Server/Sources/Entity/RagonEntity.cs

@@ -16,10 +16,11 @@
 
 
 using Ragon.Protocol;
+using Ragon.Server.Room;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Entity;
 
-public class RagonEntity
+public class RagonEntity: IRagonEntity
 {
   private static ushort _idGenerator = 100;
   public ushort Id { get; private set; }
@@ -29,30 +30,35 @@ public class RagonEntity
   public RagonRoomPlayer Owner { get; private set; }
   public RagonAuthority Authority { get; private set; }
   public RagonPayload Payload { get; private set; }
-  public RagonEntityState State { get; private set; }
+  public IRagonEntityState State => _state;
   
   private readonly List<RagonEvent> _bufferedEvents;
+  private readonly RagonEntityState _state;
   
-  public RagonEntity(RagonRoomPlayer owner, ushort type, ushort staticId, ushort attachId, RagonAuthority eventAuthority)
+  public RagonEntity(RagonEntityParameters parameters)
   {
-    Owner = owner;
-    StaticId = staticId;
-    Type = type;
-    AttachId = attachId;
     Id = _idGenerator++;
-    Authority = eventAuthority;
+    
-    State = new RagonEntityState(this);
+    StaticId = parameters.StaticId;
+    Type = parameters.Type;
+    AttachId = parameters.AttachId;
+    Authority = parameters.Authority;
     Payload = new RagonPayload();
     
+    _state = new RagonEntityState(this);
     _bufferedEvents = new List<RagonEvent>();
   }
   
-
+  public void Attach(RagonRoomPlayer owner)
-  public void SetOwner(RagonRoomPlayer owner)
   {
     Owner = owner;
   }
 
+  public void Detach()
+  {
+    
+  } 
+
   public void RestoreBufferedEvents(RagonRoomPlayer roomPlayer, RagonBuffer writer)
   {
     foreach (var evnt in _bufferedEvents)
@@ -96,7 +102,7 @@ public class RagonEntity
     var buffer = room.Writer;
 
     buffer.Clear();
-    buffer.WriteOperation(RagonOperation.DESTROY_ENTITY);
+    buffer.WriteOperation(RagonOperation.REMOVE_ENTITY);
     buffer.WriteUShort(Id);
 
     Payload.Write(buffer);
@@ -116,7 +122,8 @@ public class RagonEntity
 
     buffer.WriteUShort(Payload.Size);
     Payload.Write(buffer);
-    State.Snapshot(buffer);
+    
+    _state.Snapshot(buffer);
   }
 
   public void ReplicateEvent(
@@ -209,4 +216,24 @@ public class RagonEntity
       }
     }
   }
+
+  public void AddProperty(RagonProperty property)
+  {
+    _state.AddProperty(property);
+  }
+  
+  public void WriteState(RagonBuffer writer)
+  {
+    _state.Write(writer);
+  }
+
+  public bool TryReadState(RagonRoomPlayer player, RagonBuffer reader)
+  {
+    if (Owner.Connection.Id != player.Connection.Id)
+      return false;
+    
+    _state.Read(reader);
+    
+    return true;
+  }
 }

Ragon.Server/Sources/Entity/RagonEntityParameters.cs

@@ -14,37 +14,14 @@
  * limitations under the License.
  */
 
-using Ragon.Client;
 using Ragon.Protocol;
-using Xunit.Abstractions;
 
-namespace Ragon.Core.Tests;
+namespace Ragon.Server.Entity;
 
-public class RagonXUnitLogger: IRagonLogger
+public ref struct RagonEntityParameters
 {
-  private ITestOutputHelper _outputHelper;
+  public ushort Type;
-  public RagonXUnitLogger(ITestOutputHelper outputHelper)
+  public ushort StaticId;
-  {
+  public ushort AttachId;
-    _outputHelper = outputHelper;
+  public RagonAuthority Authority;
-  }
-  
-  public void Warn(string message)
-  {
-    _outputHelper.WriteLine($"[Warn] {message}");
-  }
-
-  public void Trace(string message)
-  {
-    _outputHelper.WriteLine($"[Trace] {message}");
-  }
-
-  public void Info(string message)
-  {
-    _outputHelper.WriteLine($"[Info] {message}");
-  }
-
-  public void Error(string message)
-  {
-    _outputHelper.WriteLine($"[Error] {message}");
-  }
 }

Ragon.Server/Sources/Entity/RagonEntityState.cs

@@ -17,16 +17,18 @@
 
 using Ragon.Protocol;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Entity;
 
-public class RagonEntityState
+public class RagonEntityState: IRagonEntityState
 {
   private List<RagonProperty> _properties;
   private RagonEntity _entity;
+  private RagonBuffer _buffer;
   
   public RagonEntityState(RagonEntity entity, int capacity = 10)
   {
     _entity = entity;
+    _buffer = new RagonBuffer(8);
     _properties = new List<RagonProperty>(capacity);
   }
 
@@ -65,8 +67,8 @@ public class RagonEntityState
   {
     foreach (var property in _properties)
     {
-      var hasPayload = property.IsFixed || !property.IsFixed && property.Size > 0;
+      var hasPayloadOrFixed = property.IsFixed || property is { IsFixed: false, Size: > 0 };
-      if (hasPayload)
+      if (hasPayloadOrFixed)
       {
         buffer.WriteBool(true);
         property.Write(buffer);

Ragon.Server/Sources/Entity/RagonEvent.cs

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-
 using Ragon.Protocol;
+using Ragon.Server.Room;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Entity;
 
 public class RagonEvent
 {

Ragon.Server/Sources/Entity/RagonPayload.cs

@@ -17,7 +17,7 @@
 
 using Ragon.Protocol;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Entity;
 
 public class RagonPayload
 {

Ragon.Server/Sources/Entity/RagonProperty.cs

@@ -14,11 +14,9 @@
  * limitations under the License.
  */
 
-
-using System.ComponentModel;
 using Ragon.Protocol;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Entity;
 
 public class RagonProperty : RagonPayload
 {

Ragon.Server/Sources/Handler/AuthorizationOperation.cs

@@ -16,40 +16,98 @@
 
 using NLog;
 using Ragon.Protocol;
+using Ragon.Server.Lobby;
+using Ragon.Server.Plugin;
+using Ragon.Server.Plugin.Web;
 
-namespace Ragon.Server;
+
+namespace Ragon.Server.Handler;
 
 public sealed class AuthorizationOperation: IRagonOperation
 {
   private Logger _logger = LogManager.GetCurrentClassLogger();
+  private readonly RagonWebHookPlugin _ragonWebHook;
+  private readonly RagonContextObserver _contextObserver;
+  private readonly Configuration _configuration;
+  private readonly RagonBuffer _writer;
+  
+  public AuthorizationOperation(RagonWebHookPlugin ragonWebHook,
+    RagonContextObserver contextObserver,
+    RagonBuffer writer,
+    Configuration configuration)
+  {
+    _ragonWebHook = ragonWebHook;
+    _configuration = configuration;
+    _contextObserver = contextObserver;
+    _writer = writer;
+  }
   
   public void Handle(RagonContext context, RagonBuffer reader, RagonBuffer writer)
   {
-    if (context.LobbyPlayer.Status == LobbyPlayerStatus.Authorized)
+    if (context.ConnectionStatus == ConnectionStatus.Authorized)
     {
-      _logger.Warn("Player already authorized");    
+      _logger.Warn("Player already authorized!");    
+      return;
+    }
+
+    if (context.ConnectionStatus == ConnectionStatus.InProcess)
+    {
+      _logger.Warn("Player already request authorization!");    
       return;
     }
     
     var key = reader.ReadString();
-    var playerName = reader.ReadString();
+    var name = reader.ReadString();
-    var additionalPayload = new RagonPayload();
+    var payload = reader.ReadString();
-    additionalPayload.Read(reader);
     
-    context.LobbyPlayer.Name = playerName;
+    if (key == _configuration.ServerKey)
-    context.LobbyPlayer.AdditionalData = Array.Empty<byte>();
+    {
-    context.LobbyPlayer.Status = LobbyPlayerStatus.Authorized;
+      if (_ragonWebHook.RequestAuthorization(context, name, payload)) 
+        return;
+      
+      var lobbyPlayer = new RagonLobbyPlayer(context.Connection, Guid.NewGuid().ToString(), name, payload);
+      context.SetPlayer(lobbyPlayer);
+      
+      Approve(context);
+    }
+    else
+    {
+      Reject(context);
+    }
+  }
+
+  public void Approve(RagonContext context)
+  {
+    context.ConnectionStatus  = ConnectionStatus.Authorized;
+
+    _contextObserver.OnAuthorized(context);
     
     var playerId = context.LobbyPlayer.Id;
+    var playerName = context.LobbyPlayer.Name;
+    var playerPayload = context.LobbyPlayer.Payload;
 
-    writer.Clear();
+    _writer.Clear();
-    writer.WriteOperation(RagonOperation.AUTHORIZED_SUCCESS);
+    _writer.WriteOperation(RagonOperation.AUTHORIZED_SUCCESS);
-    writer.WriteString(playerId);
+    _writer.WriteString(playerId);
-    writer.WriteString(playerName);
+    _writer.WriteString(playerName);
+    _writer.WriteString(playerPayload);
     
-    var sendData = writer.ToArray();
+    var sendData = _writer.ToArray();
     context.Connection.Reliable.Send(sendData);
     
     _logger.Trace($"Connection {context.Connection.Id} as {playerId}|{context.LobbyPlayer.Name} authorized");   
   }
+
+  public void Reject(RagonContext context)
+  {
+    _writer.Clear();
+    _writer.WriteOperation(RagonOperation.AUTHORIZED_FAILED);
+
+    var sendData = _writer.ToArray();
+    
+    context.Connection.Reliable.Send(sendData);
+    context.Connection.Close();
+      
+    _logger.Trace($"Connection {context.Connection.Id}");
+  }
 }

Ragon.Server/Sources/Handler/EntityCreateOperation.cs

@@ -16,12 +16,13 @@
 
 using NLog;
 using Ragon.Protocol;
+using Ragon.Server.Entity;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Handler;
 
 public sealed class EntityCreateOperation : IRagonOperation
 {
-  private Logger _logger = LogManager.GetCurrentClassLogger();
+  private readonly Logger _logger = LogManager.GetCurrentClassLogger();
 
   public void Handle(RagonContext context, RagonBuffer reader, RagonBuffer writer)
   {
@@ -32,18 +33,31 @@ public sealed class EntityCreateOperation : IRagonOperation
     var eventAuthority = (RagonAuthority) reader.ReadByte();
     var propertiesCount = reader.ReadUShort();
 
-    var entity = new RagonEntity(player, entityType, 0, attachId, eventAuthority);
+    var entityParameters = new RagonEntityParameters()
+    {
+      Type = entityType,
+      Authority = eventAuthority,
+      AttachId = attachId,
+      StaticId = 0
+    };
+    
+    var entity = new RagonEntity(entityParameters);
     for (var i = 0; i < propertiesCount; i++)
     {
       var propertyType = reader.ReadBool();
       var propertySize = reader.ReadUShort();
 
-      entity.State.AddProperty(new RagonProperty(propertySize, propertyType));
+      entity.AddProperty(new RagonProperty(propertySize, propertyType));
     }
     
     if (reader.Capacity > 0)
       entity.Payload.Read(reader);
     
+    var roomPlugin = room.Plugin;
+    if (!roomPlugin.OnEntityCreate(player, entity))
+      return;
+    
+    entity.Attach(player);
     room.AttachEntity(entity);
     player.AttachEntity(entity);
     

Ragon.Server/Sources/Handler/EntityEventOperation.cs

@@ -16,12 +16,13 @@
 
 using NLog;
 using Ragon.Protocol;
+using Ragon.Server.Entity;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Handler;
 
 public sealed class EntityEventOperation : IRagonOperation
 {
-  private Logger _logger = LogManager.GetCurrentClassLogger();
+  private readonly Logger _logger = LogManager.GetCurrentClassLogger();
 
   public void Handle(RagonContext context, RagonBuffer reader, RagonBuffer writer)
   {

Ragon.Server/Sources/Handler/EntityRemoveOperation.cs

@@ -16,12 +16,13 @@
 
 using NLog;
 using Ragon.Protocol;
+using Ragon.Server.Entity;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Handler;
 
 public sealed class EntityDestroyOperation: IRagonOperation
 {
-  private Logger _logger = LogManager.GetCurrentClassLogger();
+  private readonly Logger _logger = LogManager.GetCurrentClassLogger();
   
   public void Handle(RagonContext context, RagonBuffer reader, RagonBuffer writer)
   {

Ragon.Server/Sources/Handler/EntityStateOperation.cs

@@ -17,23 +17,23 @@
 using NLog;
 using Ragon.Protocol;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Handler;
 
 public sealed class EntityStateOperation: IRagonOperation
 {
-  private ILogger _logger = LogManager.GetCurrentClassLogger();
+  private readonly ILogger _logger = LogManager.GetCurrentClassLogger();
   
   public void Handle(RagonContext context, RagonBuffer reader, RagonBuffer writer)
   {
     var room = context.Room;
+    var player = context.RoomPlayer;
     var entitiesCount = reader.ReadUShort();
     
     for (var entityIndex = 0; entityIndex < entitiesCount; entityIndex++)
     {
       var entityId = reader.ReadUShort();
-      if (room.Entities.TryGetValue(entityId, out var entity) && entity.Owner.Connection.Id == context.Connection.Id)
+      if (room.Entities.TryGetValue(entityId, out var entity) && entity.TryReadState(player, reader))
       {
-        entity.State.Read(reader);
         room.Track(entity);
       }
       else

Ragon.Server/Sources/Handler/IRagonOperation.cs

@@ -16,7 +16,7 @@
 
 using Ragon.Protocol;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Handler;
 
 public interface IRagonOperation
 {

Ragon.Server/Sources/Handler/RoomCreateOperation.cs

@@ -16,17 +16,29 @@
 
 using NLog;
 using Ragon.Protocol;
+using Ragon.Server.Lobby;
+using Ragon.Server.Plugin;
+using Ragon.Server.Plugin.Web;
+using Ragon.Server.Room;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Handler;
 
 public sealed class RoomCreateOperation: IRagonOperation
 {
-  private RagonRoomParameters _roomParameters = new();
+  private readonly RagonRoomParameters _roomParameters = new();
-  private Logger _logger = LogManager.GetCurrentClassLogger();
+  private readonly Logger _logger = LogManager.GetCurrentClassLogger();
+  private readonly IServerPlugin _serverPlugin;
+  private readonly RagonWebHookPlugin _ragonWebHookPlugin;
+  
+  public RoomCreateOperation(IServerPlugin serverPlugin, RagonWebHookPlugin ragonWebHook)
+  {
+    _serverPlugin = serverPlugin;
+    _ragonWebHookPlugin = ragonWebHook;
+  }
 
   public void Handle(RagonContext context, RagonBuffer reader, RagonBuffer writer)
   {
-    if (context.LobbyPlayer.Status == LobbyPlayerStatus.Unauthorized)
+    if (context.ConnectionStatus == ConnectionStatus.Unauthorized)
     {
       _logger.Warn($"Player {context.Connection.Id} not authorized for this request");
       return;
@@ -62,17 +74,22 @@ public sealed class RoomCreateOperation: IRagonOperation
     };
 
     var lobbyPlayer = context.LobbyPlayer;
+    var roomPlayer = new RagonRoomPlayer(context.Connection, lobbyPlayer.Id, lobbyPlayer.Name);
+    
+    var roomPlugin = _serverPlugin.CreateRoomPlugin(information);
+    var room = new RagonRoom(roomId, information, roomPlugin);
+    
+    roomPlayer.OnAttached(room);
     
-    var room = new RagonRoom(roomId, information);
     context.Scheduler.Run(room);
     context.Lobby.Persist(room);
+    context.SetRoom(room, roomPlayer);
     
-    var player = new RagonRoomPlayer(lobbyPlayer.Connection, lobbyPlayer.Id, lobbyPlayer.Name);
+    _ragonWebHookPlugin.RoomCreated(context, room, roomPlayer);
-    context.SetRoom(room, player);
     
-    _logger.Trace($"Player {context.Connection.Id}|{context.LobbyPlayer.Name} create room {room.Id} {information}");
+    _logger.Trace($"Player {context.Connection.Id}|{context.LobbyPlayer.Name} create room {room.Id} with map {information.Map}");
     
-    JoinSuccess(player, room, writer);
+    JoinSuccess(roomPlayer, room, writer);
     
     _logger.Trace($"Player {context.Connection.Id}|{context.LobbyPlayer.Name} joined to room {room.Id}");
   }
@@ -84,9 +101,9 @@ public sealed class RoomCreateOperation: IRagonOperation
     writer.WriteString(room.Id);
     writer.WriteString(player.Id);
     writer.WriteString(room.Owner.Id);
-    writer.WriteUShort((ushort) room.Info.Min);
+    writer.WriteUShort((ushort) room.PlayerMin);
-    writer.WriteUShort((ushort) room.Info.Max);
+    writer.WriteUShort((ushort) room.PlayerMax);
-    writer.WriteString(room.Info.Map);
+    writer.WriteString(room.Map);
 
     var sendData = writer.ToArray();
     player.Connection.Reliable.Send(sendData);

Ragon.Server/Sources/Handler/RoomJoinOperation.cs

@@ -16,12 +16,22 @@
 
 using NLog;
 using Ragon.Protocol;
+using Ragon.Server.Plugin;
+using Ragon.Server.Plugin.Web;
+using Ragon.Server.Room;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Handler;
 
 public sealed class RoomJoinOperation : IRagonOperation
 {
-  private Logger _logger = LogManager.GetCurrentClassLogger();
+  private readonly Logger _logger = LogManager.GetCurrentClassLogger();
+
+  private readonly RagonWebHookPlugin _webHook;
+  
+  public RoomJoinOperation(RagonWebHookPlugin plugin)
+  {
+    _webHook = plugin;
+  }
 
   public void Handle(RagonContext context, RagonBuffer reader, RagonBuffer writer)
   {
@@ -30,42 +40,47 @@ public sealed class RoomJoinOperation : IRagonOperation
 
     if (!context.Lobby.FindRoomById(roomId, out var existsRoom))
     {
-      JoinFailed(lobbyPlayer, writer);
+      JoinFailed(context, writer);
       
       _logger.Trace($"Player {context.Connection.Id}|{context.LobbyPlayer.Name} failed to join room {roomId}");
       return;
     }
 
-    var player = new RagonRoomPlayer(lobbyPlayer.Connection, lobbyPlayer.Id, lobbyPlayer.Name);
+    var player = new RagonRoomPlayer(context.Connection, lobbyPlayer.Id, lobbyPlayer.Name);
     context.SetRoom(existsRoom, player);
     
-    JoinSuccess(player, existsRoom, writer);
+    if (!existsRoom.Plugin.OnPlayerJoined(player))
+      return;
+    
+    _webHook.RoomJoined(context, existsRoom, player);
+    
+    JoinSuccess(context, existsRoom, writer);
     
     _logger.Trace($"Player {context.Connection.Id}|{context.LobbyPlayer.Name} joined to {existsRoom.Id}");
   }
 
-  private void JoinSuccess(RagonRoomPlayer player, RagonRoom room, RagonBuffer writer)
+  private void JoinSuccess(RagonContext context, RagonRoom room, RagonBuffer writer)
   {
     writer.Clear();
     writer.WriteOperation(RagonOperation.JOIN_SUCCESS);
     writer.WriteString(room.Id);
-    writer.WriteString(player.Id);
+    writer.WriteString(context.RoomPlayer.Id);
     writer.WriteString(room.Owner.Id);
-    writer.WriteUShort((ushort) room.Info.Min);
+    writer.WriteUShort((ushort) room.PlayerMin);
-    writer.WriteUShort((ushort) room.Info.Max);
+    writer.WriteUShort((ushort) room.PlayerMax);
-    writer.WriteString(room.Info.Map);
+    writer.WriteString(room.Map);
 
     var sendData = writer.ToArray();
-    player.Connection.Reliable.Send(sendData);
+    context.Connection.Reliable.Send(sendData);
   }
 
-  private void JoinFailed(RagonLobbyPlayer player, RagonBuffer writer)
+  private void JoinFailed(RagonContext context, RagonBuffer writer)
   {
     writer.Clear();
     writer.WriteOperation(RagonOperation.JOIN_FAILED);
     writer.WriteString($"Room not exists");
 
     var sendData = writer.ToArray();
-    player.Connection.Reliable.Send(sendData);
+    context.Connection.Reliable.Send(sendData);
   }
 }

Ragon.Server/Sources/Handler/RoomJoinOrCreateOperation.cs

@@ -16,17 +16,29 @@
 
 using NLog;
 using Ragon.Protocol;
+using Ragon.Server.Lobby;
+using Ragon.Server.Plugin;
+using Ragon.Server.Plugin.Web;
+using Ragon.Server.Room;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Handler;
 
 public sealed class RoomJoinOrCreateOperation : IRagonOperation
 {
-  private RagonRoomParameters _roomParameters = new();
+  private readonly RagonRoomParameters _roomParameters = new();
-  private Logger _logger = LogManager.GetCurrentClassLogger();
+  private readonly Logger _logger = LogManager.GetCurrentClassLogger();
+  private readonly IServerPlugin _serverPlugin;
+  private readonly RagonWebHookPlugin _ragonWebHookPlugin;
+  
+  public RoomJoinOrCreateOperation(IServerPlugin serverPlugin, RagonWebHookPlugin plugin)
+  {
+    _serverPlugin = serverPlugin;
+    _ragonWebHookPlugin = plugin;
+  }
 
   public void Handle(RagonContext context, RagonBuffer reader, RagonBuffer writer)
   {
-    if (context.LobbyPlayer.Status == LobbyPlayerStatus.Unauthorized)
+    if (context.ConnectionStatus == ConnectionStatus.Unauthorized)
     {
       _logger.Warn("Player not authorized for this request");
       return;
@@ -39,9 +51,11 @@ public sealed class RoomJoinOrCreateOperation : IRagonOperation
 
     if (context.Lobby.FindRoomByMap(_roomParameters.Map, out var existsRoom))
     {
-      var player = new RagonRoomPlayer(lobbyPlayer.Connection, lobbyPlayer.Id, lobbyPlayer.Name);
+      var player = new RagonRoomPlayer(context.Connection, lobbyPlayer.Id, lobbyPlayer.Name);
       context.SetRoom(existsRoom, player);
       
+      _ragonWebHookPlugin.RoomJoined(context, existsRoom, player);
+      
       JoinSuccess(player, existsRoom, writer);
     }
     else
@@ -53,14 +67,17 @@ public sealed class RoomJoinOrCreateOperation : IRagonOperation
         Min = _roomParameters.Min,
       };
 
-      var room = new RagonRoom(roomId, information);
+      var roomPlayer = new RagonRoomPlayer(context.Connection, lobbyPlayer.Id, lobbyPlayer.Name);
+      var roomPlugin = _serverPlugin.CreateRoomPlugin(information);
+      var room = new RagonRoom(roomId, information, roomPlugin);
+      
+      _ragonWebHookPlugin.RoomCreated(context, room, roomPlayer);
+      
       context.Lobby.Persist(room);
       context.Scheduler.Run(room);
-      
-      var roomPlayer = new RagonRoomPlayer(lobbyPlayer.Connection, lobbyPlayer.Id, lobbyPlayer.Name);
       context.SetRoom(room, roomPlayer);
       
-      _logger.Trace($"Player {context.Connection.Id}|{context.LobbyPlayer.Name} create room {room.Id} {information}");
+      _logger.Trace($"Player {context.Connection.Id}|{context.LobbyPlayer.Name} create room {room.Id} with map {information.Map}");
 
       JoinSuccess(roomPlayer, room, writer);
     }
@@ -73,9 +90,9 @@ public sealed class RoomJoinOrCreateOperation : IRagonOperation
     writer.WriteString(room.Id);
     writer.WriteString(player.Id);
     writer.WriteString(room.Owner.Id);
-    writer.WriteUShort((ushort) room.Info.Min);
+    writer.WriteUShort((ushort) room.PlayerMin);
-    writer.WriteUShort((ushort) room.Info.Max);
+    writer.WriteUShort((ushort) room.PlayerMax);
-    writer.WriteString(room.Info.Map);
+    writer.WriteString(room.Map);
 
     var sendData = writer.ToArray();
     player.Connection.Reliable.Send(sendData);

Ragon.Server/Sources/Handler/RoomLeaveOperation.cs

@@ -16,19 +16,34 @@
 
 using NLog;
 using Ragon.Protocol;
+using Ragon.Server.Plugin;
+using Ragon.Server.Plugin.Web;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Handler;
 
 public sealed class RoomLeaveOperation: IRagonOperation
 {
-  private Logger _logger = LogManager.GetCurrentClassLogger();
+  private readonly Logger _logger = LogManager.GetCurrentClassLogger();
+  private readonly RagonWebHookPlugin _webHook;
+  public RoomLeaveOperation(RagonWebHookPlugin plugin)
+  {
+    _webHook = plugin;
+  }
+
   public void Handle(RagonContext context, RagonBuffer reader, RagonBuffer writer)
   {
     var room = context.Room;
     var roomPlayer = context.RoomPlayer;
+    
     if (room != null)
     {
-      context.Room?.DetachPlayer(roomPlayer);
+      var plugin = room.Plugin; 
+      
+      plugin.OnPlayerLeaved(roomPlayer);
+      room.DetachPlayer(roomPlayer);
+      
+      _webHook.RoomLeaved(context, room, roomPlayer);
+      
       _logger.Trace($"Player {context.Connection.Id}|{context.LobbyPlayer.Name} leaved from {room.Id}");
     }
   }

Ragon.Server/Sources/Handler/SceneLoadOperation.cs

@@ -18,11 +18,11 @@
 using NLog;
 using Ragon.Protocol;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Handler;
 
 public class SceneLoadOperation: IRagonOperation
 {
-  private Logger _logger = LogManager.GetCurrentClassLogger();
+  private readonly Logger _logger = LogManager.GetCurrentClassLogger();
   
   public void Handle(RagonContext context, RagonBuffer reader, RagonBuffer writer)
   {

Ragon.Server/Sources/Handler/SceneLoadedOperation.cs

@@ -16,16 +16,24 @@
 
 using NLog;
 using Ragon.Protocol;
+using Ragon.Server.Entity;
+using Ragon.Server.Lobby;
+using Ragon.Server.Room;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Handler;
 
 public sealed class SceneLoadedOperation : IRagonOperation
 {
-  private Logger _logger = LogManager.GetCurrentClassLogger();
+  private readonly Logger _logger = LogManager.GetCurrentClassLogger();
+  
+  public SceneLoadedOperation()
+  {
+   
+  }
 
   public void Handle(RagonContext context, RagonBuffer reader, RagonBuffer writer)
   {
-    if (context.LobbyPlayer.Status == LobbyPlayerStatus.Unauthorized)
+    if (context.ConnectionStatus == ConnectionStatus.Unauthorized)
       return;
 
     var owner = context.Room.Owner;
@@ -34,6 +42,7 @@ public sealed class SceneLoadedOperation : IRagonOperation
 
     if (player == owner)
     {
+      
       var statics = reader.ReadUShort();
       for (var staticIndex = 0; staticIndex < statics; staticIndex++)
       {
@@ -42,19 +51,31 @@ public sealed class SceneLoadedOperation : IRagonOperation
         var staticId = reader.ReadUShort();
         var propertiesCount = reader.ReadUShort();
 
-        var entity = new RagonEntity(player, entityType, staticId, 0, eventAuthority);
+        var entityParameters = new RagonEntityParameters()
+        {
+          Type = entityType,
+          Authority = eventAuthority,
+          AttachId = 0,
+          StaticId = staticId,
+        };
+
+        var entity = new RagonEntity(entityParameters);
         for (var propertyIndex = 0; propertyIndex < propertiesCount; propertyIndex++)
         {
           var propertyType = reader.ReadBool();
           var propertySize = reader.ReadUShort();
-          entity.State.AddProperty(new RagonProperty(propertySize, propertyType));
+          entity.AddProperty(new RagonProperty(propertySize, propertyType));
         }
         
+        var roomPlugin = room.Plugin;
+        if (roomPlugin.OnEntityCreate(player, entity)) continue;
+        
         var playerInfo = $"Player {context.Connection.Id}|{context.LobbyPlayer.Name}";
         var entityInfo = $"{entity.Id}:{entity.Type}";
 
         _logger.Trace($"{playerInfo} created entity {entityInfo}");
 
+        entity.Attach(player);
         room.AttachEntity(entity);
         player.AttachEntity(entity);
       }

Ragon.Server/Sources/Http/RagonHttpServer.cs

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2023 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.
+ */
+
+using NLog;
+using System.Net;
+using System.Text.Json;
+using Ragon.Server.IO;
+using Ragon.Server.Plugin;
+
+namespace Ragon.Server.Http;
+
+public class RagonHttpServer
+{
+  private readonly ILogger _logger = LogManager.GetCurrentClassLogger();
+  private readonly IExecutor _executor;
+  private readonly IServerPlugin _serverPlugin;
+  private HttpListener _httpListener;
+  private CancellationTokenSource _cancellationTokenSource;
+
+  public RagonHttpServer(IExecutor executor, IServerPlugin serverPlugin)
+  {
+    _serverPlugin = serverPlugin;
+    _executor = executor;
+  }
+
+  public async void StartAccept(CancellationToken cancellationToken)
+  {
+    while (!cancellationToken.IsCancellationRequested)
+    {
+      var context = await _httpListener.GetContextAsync();
+
+      if (context.Request.HttpMethod != "POST")
+      {
+        context.Response.StatusCode = 404;
+        context.Response.ContentLength64 = 0;
+        context.Response.Close();
+      }
+
+      var request = context.Request;
+      var reader = new StreamReader(request.InputStream, request.ContentEncoding);
+      var rawJson = await reader.ReadToEndAsync();
+      var httpCommand = JsonDocument.Parse(rawJson);
+      if (httpCommand != null)
+      {
+        try
+        {
+          var command = httpCommand.RootElement.GetProperty("command");
+          var payload = httpCommand.RootElement.GetProperty("payload");
+
+          if (_serverPlugin.OnCommand(command.GetString() ?? "none", payload.GetRawText()))
+          {
+            context.Response.StatusCode = 200;
+            context.Response.ContentLength64 = 0;
+            context.Response.Close(); 
+          }
+          else
+          {
+            context.Response.StatusCode = 403;
+            context.Response.ContentLength64 = 0;
+            context.Response.Close();
+          }
+        }
+        catch (Exception ex)
+        {
+          _logger.Error(ex);
+          
+          context.Response.StatusCode = 505;
+          context.Response.ContentLength64 = 0;
+          context.Response.Close();
+        }
+        
+        continue;
+      }
+
+      context.Response.StatusCode = 403;
+      context.Response.ContentLength64 = 0;
+      context.Response.Close();
+    }
+  }
+
+  public void Start(Configuration configuration)
+  {
+    _cancellationTokenSource = new CancellationTokenSource();
+    _logger.Info($"Listen at http://0.0.0.0:{configuration.HttpPort}/");
+
+    _httpListener = new HttpListener();
+    _httpListener.Prefixes.Add($"http://127.0.0.1:{configuration.HttpPort}/");
+    _httpListener.Start();
+
+    _executor.Run(() => StartAccept(_cancellationTokenSource.Token), TaskCreationOptions.LongRunning);
+  }
+
+  public void Stop()
+  {
+    _cancellationTokenSource.Cancel();
+    _httpListener.Stop();
+  }
+}

Ragon.Server/Sources/IO/Executor.cs

@@ -16,23 +16,28 @@
 
 using System.Threading.Channels;
 
-namespace Ragon.Server;
+namespace Ragon.Server.IO;
 
-public class Executor: TaskScheduler, IExecutor
+public class Executor : TaskScheduler, IExecutor
 {
-  private ChannelReader<Task> _reader;
+  private readonly ChannelReader<Task> _reader;
-  private ChannelWriter<Task> _writer;
+  private readonly ChannelWriter<Task> _writer;
-  private Queue<Task> _pendingTasks;
+  private readonly Queue<Task> _pendingTasks;
-  private TaskFactory _taskFactory;
+  private readonly TaskFactory _taskFactory;
 
-  public void Run(Action action)
+  public Task Run(Action action, TaskCreationOptions task = TaskCreationOptions.None)
   {
-    _taskFactory.StartNew(action);
+    return _taskFactory.StartNew(action, task);
   }
 
   public Executor()
   {
-    var channel = Channel.CreateUnbounded<Task>();
+    var channel = Channel.CreateUnbounded<Task>(new UnboundedChannelOptions()
+    {
+      SingleReader = true, 
+      SingleWriter = true,
+    });
+    
     _reader = channel.Reader;
     _writer = channel.Writer;
 

Ragon.Server/Sources/IO/IExecutor.cs

@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-namespace Ragon.Server;
+namespace Ragon.Server.IO;
 
 public interface IExecutor
 {
-  public void Run(Action action);
+  public Task Run(Action action, TaskCreationOptions task = TaskCreationOptions.None);
 }

Ragon.Server/Sources/IO/INetworkChannel.cs

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-namespace Ragon.Server;
+namespace Ragon.Server.IO;
 
 public interface INetworkChannel
 {

Ragon.Server/Sources/IO/INetworkConnection.cs

@@ -14,11 +14,12 @@
  * limitations under the License.
  */
 
-namespace Ragon.Server;
+namespace Ragon.Server.IO;
 
 public interface INetworkConnection
 {
     public ushort Id { get; }
     public INetworkChannel Reliable { get; }
     public INetworkChannel Unreliable { get; }
+    public void Close();
 }

Ragon.Server/Sources/IO/INetworkListener.cs

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-namespace Ragon.Server;
+namespace Ragon.Server.IO;
 
 public interface INetworkListener
 {

Ragon.Server/Sources/IO/INetworkServer.cs

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-namespace Ragon.Server;
+namespace Ragon.Server.IO;
 
 public interface INetworkServer
 {

Ragon.Server/Sources/IO/NetworkConfiguration.cs

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-namespace Ragon.Server;
+namespace Ragon.Server.IO;
 
 public struct NetworkConfiguration
 {

Ragon.Server/Sources/IRagonContextObserver.cs

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2023 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;
+
+public class RagonContextObserver
+{
+  private Dictionary<string, RagonContext> _contexts;
+  public RagonContextObserver(Dictionary<string, RagonContext> contexts)
+  {
+    _contexts = contexts;
+  }
+
+  public void OnAuthorized(RagonContext context) 
+  {
+    _contexts.Add(context.LobbyPlayer.Id, context);
+  }
+}

Ragon.Server/Sources/IRagonServer.cs

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2023 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.
+ */
+
+using Ragon.Server.IO;
+using Ragon.Server.Lobby;
+
+namespace Ragon.Server;
+
+public interface IRagonServer
+{
+  RagonLobbyPlayer? GetPlayerByConnection(INetworkConnection connection);
+  RagonLobbyPlayer? GetPlayerById(string id);
+}

Ragon.Server/Sources/Lobby/IRagonLobby.cs

@@ -15,13 +15,14 @@
  */
 
 using System.Diagnostics.CodeAnalysis;
+using Ragon.Server.Room;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Lobby;
 
 public interface IRagonLobby
 {
   public bool FindRoomById(string roomId, [MaybeNullWhen(false)] out RagonRoom room);
   public bool FindRoomByMap(string map, [MaybeNullWhen(false)] out RagonRoom room);
   public void Persist(RagonRoom room);
-  public void RemoveIfEmpty(RagonRoom room);
+  public bool RemoveIfEmpty(RagonRoom room);
 }

Ragon.Server/Sources/Lobby/RagonLobbyInMemory.cs

@@ -16,8 +16,9 @@
 
 using System.Diagnostics.CodeAnalysis;
 using NLog;
+using Ragon.Server.Room;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Lobby;
 
 public class LobbyInMemory : IRagonLobby
 {
@@ -28,8 +29,7 @@ public class LobbyInMemory : IRagonLobby
   {
     foreach (var existRagonRoom in _rooms)
     {
-      var info = existRagonRoom.Info;
+      if (existRagonRoom.Id == RagonRoomId && existRagonRoom.PlayerMin < existRagonRoom.PlayerMax)
-      if (existRagonRoom.Id == RagonRoomId && info.Min < info.Max)
       {
         room = existRagonRoom;
         return true;
@@ -44,8 +44,7 @@ public class LobbyInMemory : IRagonLobby
   {
     foreach (var existsRoom in _rooms)
     {
-      var info = existsRoom.Info;
+      if (existsRoom.Map == map && existsRoom.PlayerCount < existsRoom.PlayerMax)
-      if (info.Map == map && existsRoom.Players.Count < info.Max)
       {
         room = existsRoom;
         return true;
@@ -62,18 +61,23 @@ public class LobbyInMemory : IRagonLobby
     _logger.Trace($"New room: {room.Id}");
     
     foreach (var r in _rooms)
-      _logger.Trace($"Room: {r.Id} {r.Info} Players: {r.Players.Count} Entities: {r.Entities.Count}");
+      _logger.Trace($"Room: {r.Id} Map: {r.Map} Players: {r.Players.Count} Entities: {r.Entities.Count}");
   }
 
-  public void RemoveIfEmpty(RagonRoom room)
+  public bool RemoveIfEmpty(RagonRoom room)
   {
+    var result = false;
     if (room.Players.Count == 0)
     {
       _rooms.Remove(room);
       _logger.Trace($"Room {room.Id} removed");
+
+      result = true;
     }
 
     foreach (var r in _rooms)
-      _logger.Trace($"Room: {r.Id} {r.Info} Players: {r.Players.Count} Entities: {r.Entities.Count}");
+      _logger.Trace($"Room: {r.Id} Map: {r.Map} Players: {r.Players.Count} Entities: {r.Entities.Count}");
+
+    return result;
   }
 }

Ragon.Server/Sources/Lobby/RagonLobbyPlayer.cs

@@ -14,28 +14,29 @@
  * limitations under the License.
  */
 
-namespace Ragon.Server;
+using Ragon.Server.IO;
 
-public enum LobbyPlayerStatus
+namespace Ragon.Server.Lobby;
+
+public enum ConnectionStatus
 {
   Unauthorized,
+  InProcess,
   Authorized,
 }
 
 public class RagonLobbyPlayer
 {
+  public INetworkConnection Connection { get; }
   public string Id { get; private set; }
-  public string Name { get; set; }
+  public string Name { get; private set; }
-  public byte[] AdditionalData { get; set; }
+  public string Payload { get; private set; }
-  public LobbyPlayerStatus Status { get; set; }
-  public INetworkConnection Connection { get; private set; }
   
-  public RagonLobbyPlayer(INetworkConnection connection)
+  public RagonLobbyPlayer(INetworkConnection connection, string id, string name, string payload)
   {
-    Id = Guid.NewGuid().ToString();
+    Id = id;
+    Name = name;
+    Payload = payload;
     Connection = connection;
-    Status = LobbyPlayerStatus.Unauthorized;
-    Name = "None";
-    AdditionalData = Array.Empty<byte>();
   }
 }

Ragon.Server/Sources/Plugin/BaseRoomPlugin.cs

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2023 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.
+ */
+
+using Ragon.Server.Entity;
+using Ragon.Server.IO;
+using Ragon.Server.Room;
+
+namespace Ragon.Server.Plugin;
+
+public class BaseRoomPlugin: IRoomPlugin
+{
+  public IRagonRoom Room { get; private set; }
+  
+  public virtual void OnAttached(IRagonRoom room)
+  {
+    Room = room;
+  }
+  
+  public virtual void OnDetached()
+  {
+    
+  }
+  
+  #region VIRTUAL
+
+  public virtual bool OnPlayerJoined(RagonRoomPlayer player)
+  {
+    return true;
+  }
+
+  public virtual bool OnPlayerLeaved(RagonRoomPlayer player)
+  {
+    return true;
+  }
+
+  public virtual void Tick(float dt)
+  {
+    
+  }
+  
+  public virtual bool OnEntityCreate(RagonRoomPlayer creator, IRagonEntity entity)
+  {
+    
+    return true;
+  }
+
+  public virtual bool OnEntityRemove(RagonRoomPlayer remover, IRagonEntity entity)
+  {
+    
+    return true;
+  }
+  
+  #endregion
+}

Ragon.Server/Sources/Plugin/BaseServerPlugin.cs

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2023 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.
+ */
+
+using Ragon.Server.IO;
+using Ragon.Server.Lobby;
+using Ragon.Server.Room;
+
+namespace Ragon.Server.Plugin;
+
+public class BaseServerPlugin: IServerPlugin
+{
+  public IRagonServer Server { get; protected set; }
+  
+  public virtual void OnAttached(IRagonServer server)
+  {
+    Server  = server;
+  }
+
+  public virtual void OnDetached()
+  {
+    
+  }
+
+  public virtual bool OnRoomCreate(RagonLobbyPlayer player, RagonRoom room)
+  {
+    return true;
+  }
+
+  public virtual bool OnRoomRemove(RagonLobbyPlayer player, RagonRoom room)
+  {
+    return true;
+  }
+
+  public virtual bool OnCommand(string command, string payload)
+  {
+    return true;
+  }
+
+  public IRoomPlugin CreateRoomPlugin(RoomInformation information)
+  {
+    return new BaseRoomPlugin();
+  }
+}

Ragon.Server/Sources/Plugin/IRoomPlugin.cs

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2023 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.
+ */
+
+using Ragon.Server.Entity;
+using Ragon.Server.Room;
+
+namespace Ragon.Server.Plugin;
+
+public interface IRoomPlugin
+{
+  void Tick(float dt);
+  void OnAttached(IRagonRoom room);
+  void OnDetached();
+  bool OnPlayerJoined(RagonRoomPlayer player);
+  bool OnPlayerLeaved(RagonRoomPlayer player);
+  bool OnEntityCreate(RagonRoomPlayer player, IRagonEntity entity);
+  bool OnEntityRemove(RagonRoomPlayer player, IRagonEntity entity);
+}

Ragon.Server/Sources/Plugin/IServerPlugin.cs

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2023 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.
+ */
+
+using Ragon.Server.Http;
+using Ragon.Server.Lobby;
+using Ragon.Server.Room;
+
+namespace Ragon.Server.Plugin;
+
+public interface IServerPlugin
+{
+  void OnAttached(IRagonServer server);
+  void OnDetached();
+  bool OnRoomCreate(RagonLobbyPlayer player, RagonRoom room);
+  bool OnRoomRemove(RagonLobbyPlayer player, RagonRoom room);
+  bool OnCommand(string command, string payload);
+  IRoomPlugin CreateRoomPlugin(RoomInformation information);
+}

Ragon.Server/Sources/Plugin/Web/Dto/PlayerDto.cs

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2023 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.
+ */
+
+using Ragon.Server.Room;
+
+namespace Ragon.Server.Plugin.Web;
+
+[Serializable]
+public class PlayerDto
+{
+  public string Id { get; set;}
+  public string Name { get; set; }
+  
+  public PlayerDto(RagonRoomPlayer ragonRoomPlayer)
+  {
+    Id = ragonRoomPlayer.Id;
+    Name = ragonRoomPlayer.Name;
+  }
+}

Ragon.Server/Sources/Plugin/Web/Dto/RoomDto.cs

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2023 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.
+ */
+
+using Ragon.Server.Room;
+
+namespace Ragon.Server.Plugin.Web;
+
+[Serializable]
+public class RoomDto
+{
+  public string Id { get; set;}
+  public int PlayerMin { get; set; }
+  public int PlayerMax { get; set; }
+  public int PlayerCount { get; set; }
+  public PlayerDto[] Players { get; set; }
+
+  public RoomDto(RagonRoom room)
+  {
+    Id = room.Id;
+    PlayerMin = room.PlayerMin;
+    PlayerMax = room.PlayerMax;
+    PlayerCount = room.PlayerCount;
+
+    Players = room.PlayerList.Select(p => new PlayerDto(p)).ToArray();
+  }
+}

Ragon.Server/Sources/Plugin/Web/RagonWebHookPlugin.cs

@@ -0,0 +1,135 @@
+/*
+ * Copyright 2023 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.
+ */
+
+using System.Net;
+using System.Net.Http.Json;
+using Newtonsoft.Json;
+using Ragon.Protocol;
+using Ragon.Server.Handler;
+using Ragon.Server.Lobby;
+using Ragon.Server.Room;
+
+namespace Ragon.Server.Plugin.Web;
+
+public class RagonWebHookPlugin
+{
+  private Dictionary<string, string> _webHooks;
+
+  private RagonServer _server;
+  private HttpClient _httpClient;
+
+  public RagonWebHookPlugin(RagonServer server, Configuration configuration)
+  {
+    _webHooks = new Dictionary<string, string>(configuration.WebHooks);
+    _httpClient = new HttpClient();
+    _server = server;
+  }
+
+  public bool RequestAuthorization(RagonContext context, string name, string password)
+  {
+    if (_webHooks.TryGetValue("authorization-request", out var value))
+    {
+      var httpContent = new StringContent("");
+      var executor = context.Executor;
+      executor.Run(async () =>
+      {
+        var authorizationOperation = (AuthorizationOperation) _server.ResolveOperation(RagonOperation.AUTHORIZE);
+        var response = await _httpClient.PostAsync(new Uri(value), httpContent);
+        if (response.StatusCode != HttpStatusCode.OK)
+        {
+          authorizationOperation.Reject(context);
+          return;
+        }
+
+        var content = await response.Content.ReadAsStringAsync();
+        var authorizationResponse = JsonConvert.DeserializeObject<AuthorizationResponse>(content);
+        if (authorizationResponse != null)
+        {
+          var lobbyPlayer = new RagonLobbyPlayer(context.Connection, authorizationResponse.Id, authorizationResponse.Name, authorizationResponse.Payload);
+
+          context.SetPlayer(lobbyPlayer);
+          authorizationOperation.Approve(context);
+        }
+        else
+        {
+          authorizationOperation.Reject(context);
+        }
+      });
+      return true;
+    }
+
+    return false;
+  }
+
+  public void RoomCreated(RagonContext context, RagonRoom room, RagonRoomPlayer player)
+  {
+    if (_webHooks.TryGetValue("room-created", out var value) && !string.IsNullOrEmpty(value))
+    {
+      var request = new RoomCreatedRequest()
+      {
+        Room = new RoomDto(room),
+        Player = new PlayerDto(player)
+      };
+      var content = JsonContent.Create(request);
+      var executor = context.Executor;
+      executor.Run(() => _httpClient.PostAsync(new Uri(value), content, CancellationToken.None));
+    }
+  }
+
+  public void RoomRemoved(RagonContext context, RagonRoom ragonRoom)
+  {
+    if (_webHooks.TryGetValue("room-removed", out var value) && !string.IsNullOrEmpty(value))
+    {
+      var request = new RoomRemovedRequest()
+      {
+        Room = new RoomDto(ragonRoom)
+      };
+      var content = JsonContent.Create(request);
+      var executor = context.Executor;
+      executor.Run(() => _httpClient.PostAsync(new Uri(value), content, CancellationToken.None));
+    }
+  }
+
+  public void RoomJoined(RagonContext context, RagonRoom existsRoom, RagonRoomPlayer player)
+  {
+    if (_webHooks.TryGetValue("room-joined", out var value) && !string.IsNullOrEmpty(value))
+    {
+      var request = new RoomJoinedRequest()
+      {
+        Room = new RoomDto(existsRoom),
+        Player = new PlayerDto(player)
+      };
+      var content = JsonContent.Create(request);
+      var executor = context.Executor;
+      executor.Run(() => _httpClient.PostAsync(new Uri(value), content, CancellationToken.None));
+    }
+  }
+
+  public void RoomLeaved(RagonContext context, RagonRoom room, RagonRoomPlayer roomPlayer)
+  {
+    if (_webHooks.TryGetValue("room-leaved", out var value) && !string.IsNullOrEmpty(value))
+    {
+      var request = new RoomLeavedRequest()
+      {
+        Room = new RoomDto(room),
+        Player = new PlayerDto(roomPlayer)
+      };
+      var content = JsonContent.Create(request);
+      var executor = context.Executor;
+      executor.Run(() => _httpClient.PostAsync(new Uri(value), content, CancellationToken.None));
+    }
+  }
+}

Ragon.Server/Sources/Plugin/Web/Request/AuthorizationRequest.cs

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2023 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.Plugin.Web;
+
+[Serializable]
+public class AuthorizationRequest
+{
+  public string Name;
+  public string Token;
+}

Ragon.Server/Sources/Plugin/Web/Request/RoomCreatedRequest.cs

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2023 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.Plugin.Web;
+
+[Serializable]
+public class RoomCreatedRequest
+{
+  public RoomDto Room { get; set; }
+  public PlayerDto Player { get; set; }
+}

Ragon.Server/Sources/Plugin/Web/Request/RoomJoinedRequest.cs

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2023 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.Plugin.Web;
+
+public class RoomJoinedRequest
+{
+  public RoomDto Room { get; set; }
+  public PlayerDto Player { get; set; }
+}

Ragon.Server/Sources/Plugin/Web/Request/RoomLeavedRequest.cs

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2023 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.Plugin.Web;
+
+[Serializable]
+public class RoomLeavedRequest
+{
+  public RoomDto Room { get; set; }
+  public PlayerDto Player { get; set; }
+}

Ragon.Server/Sources/Plugin/Web/Request/RoomRemovedRequest.cs

@@ -14,4 +14,11 @@
  * limitations under the License.
  */
 
-global using Xunit;
+
+namespace Ragon.Server.Plugin.Web;
+
+[Serializable]
+public class RoomRemovedRequest
+{
+  public RoomDto Room { get; set; }
+}

Ragon.Server/Sources/Plugin/Web/Response/AuthorizationResponse.cs

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2023 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.Plugin.Web;
+
+[Serializable]
+public class AuthorizationResponse
+{
+    public string Id; 
+    public string Name;
+    public string Payload;
+}

Ragon.Server/Sources/RagonContext.cs

@@ -14,31 +14,43 @@
  * limitations under the License.
  */
 
-using Ragon.Core.Time;
+using Ragon.Server.IO;
-using Ragon.Server;
+using Ragon.Server.Lobby;
+using Ragon.Server.Time;
+using Ragon.Server.Room;
 
 namespace Ragon.Server;
 
 public class RagonContext
 {
+  public ConnectionStatus ConnectionStatus { get; set; }
   public INetworkConnection Connection { get; }
   public IExecutor Executor { get; private set; }
   
   public IRagonLobby Lobby { get; private set; }
-  public RagonLobbyPlayer LobbyPlayer { get; private set; }
+  public RagonLobbyPlayer? LobbyPlayer { get; private set; }
 
   public RagonRoom? Room { get; private set; }
   public RagonRoomPlayer? RoomPlayer { get; private set; }
 
   public RagonScheduler Scheduler { get; private set; }
 
-  public RagonContext(INetworkConnection connection, IExecutor executor, IRagonLobby lobby, RagonScheduler scheduler, RagonLobbyPlayer lobbyPlayer)
+  public RagonContext(
+    INetworkConnection connection, 
+    IExecutor executor, 
+    IRagonLobby lobby, 
+    RagonScheduler scheduler)
   {
+    ConnectionStatus = ConnectionStatus.Unauthorized;
     Connection = connection;
     Executor = executor;
     Lobby = lobby;
     Scheduler = scheduler;
-    LobbyPlayer = lobbyPlayer;
+  }
+
+  internal void SetPlayer(RagonLobbyPlayer player)
+  {
+    LobbyPlayer = player;
   }
   
   internal void SetRoom(RagonRoom room, RagonRoomPlayer player)

Ragon.Server/Sources/RagonEntityCache.cs

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+using Ragon.Server.Entity;
+
 namespace Ragon.Server;
 
 public class RagonEntityCache

Ragon.Server/Sources/RagonServer.cs

@@ -16,54 +16,73 @@
 
 using System.Diagnostics;
 using NLog;
-using Ragon.Core.Time;
 using Ragon.Protocol;
-using Ragon.Server;
+using Ragon.Server.Handler;
+using Ragon.Server.Http;
+using Ragon.Server.IO;
+using Ragon.Server.Lobby;
+using Ragon.Server.Plugin;
+using Ragon.Server.Plugin.Web;
+using Ragon.Server.Time;
 
 namespace Ragon.Server;
 
-public class RagonServer : INetworkListener
+public class RagonServer : IRagonServer, INetworkListener
 {
   private readonly Logger _logger = LogManager.GetCurrentClassLogger();
   private readonly INetworkServer _server;
+  private readonly IRagonOperation[] _handlers;
+  private readonly IRagonLobby _lobby;
+  private readonly IServerPlugin _serverPlugin;
   private readonly Thread _dedicatedThread;
   private readonly Executor _executor;
   private readonly Configuration _configuration;
-  private readonly IRagonOperation[] _handlers;
+  private readonly RagonWebHookPlugin _webhooks;
+  private readonly RagonHttpServer _httpServer;
   private readonly RagonBuffer _reader;
   private readonly RagonBuffer _writer;
-  private readonly IRagonLobby _lobby;
   private readonly RagonScheduler _scheduler;
-  private readonly Dictionary<ushort, RagonContext> _contexts;
+  private readonly Dictionary<ushort, RagonContext> _contextsByConnection;
-  private long _tickrate = 0;
+  private readonly Dictionary<string, RagonContext> _contextsByPlayerId;
-  private Stopwatch _timer;
+  private readonly Stopwatch _timer;
+  private readonly long _tickRate = 0;
   
-  public RagonServer(INetworkServer server, Configuration configuration)
+  public RagonServer(
+    INetworkServer server,
+    IServerPlugin plugin,
+    Configuration configuration)
   {
     _server = server;
     _executor = _server.Executor;
     _configuration = configuration;
-    _dedicatedThread = new Thread(Execute);
+    _serverPlugin = plugin;
-    _dedicatedThread.IsBackground = true;
+    _contextsByConnection = new Dictionary<ushort, RagonContext>();
-    _contexts = new Dictionary<ushort, RagonContext>();
+    _contextsByPlayerId = new Dictionary<string, RagonContext>();
     _lobby = new LobbyInMemory();
     _scheduler = new RagonScheduler();
-    
+    _webhooks = new RagonWebHookPlugin(this, configuration);
+    _dedicatedThread = new Thread(Execute);
+    _dedicatedThread.IsBackground = true;
+    _httpServer = new RagonHttpServer(_executor, plugin);
     _reader = new RagonBuffer();
     _writer = new RagonBuffer();
-    _tickrate = 1000 / _configuration.ServerTickRate;
+    _tickRate = 1000 / _configuration.ServerTickRate;
     _timer = new Stopwatch();
     
+    var contextObserver = new RagonContextObserver(_contextsByPlayerId);
+    
+    _serverPlugin.OnAttached(this);
+    
     _handlers = new IRagonOperation[byte.MaxValue];
-    _handlers[(byte) RagonOperation.AUTHORIZE] = new AuthorizationOperation();
+    _handlers[(byte) RagonOperation.AUTHORIZE] = new AuthorizationOperation(_webhooks, contextObserver, _writer, configuration);
-    _handlers[(byte) RagonOperation.JOIN_OR_CREATE_ROOM] = new RoomJoinOrCreateOperation();
+    _handlers[(byte) RagonOperation.JOIN_OR_CREATE_ROOM] = new RoomJoinOrCreateOperation(plugin, _webhooks);
-    _handlers[(byte) RagonOperation.CREATE_ROOM] = new RoomCreateOperation();
+    _handlers[(byte) RagonOperation.CREATE_ROOM] = new RoomCreateOperation(plugin, _webhooks);
-    _handlers[(byte) RagonOperation.JOIN_ROOM] = new RoomJoinOperation();
+    _handlers[(byte) RagonOperation.JOIN_ROOM] = new RoomJoinOperation(_webhooks);
-    _handlers[(byte) RagonOperation.LEAVE_ROOM] = new RoomLeaveOperation();
+    _handlers[(byte) RagonOperation.LEAVE_ROOM] = new RoomLeaveOperation(_webhooks);
     _handlers[(byte) RagonOperation.LOAD_SCENE] = new SceneLoadOperation();
     _handlers[(byte) RagonOperation.SCENE_LOADED] = new SceneLoadedOperation();
     _handlers[(byte) RagonOperation.CREATE_ENTITY] = new EntityCreateOperation();
-    _handlers[(byte) RagonOperation.DESTROY_ENTITY] = new EntityDestroyOperation();
+    _handlers[(byte) RagonOperation.REMOVE_ENTITY] = new EntityDestroyOperation();
     _handlers[(byte) RagonOperation.REPLICATE_ENTITY_EVENT] = new EntityEventOperation();
     _handlers[(byte) RagonOperation.REPLICATE_ENTITY_STATE] = new EntityStateOperation();
     
@@ -75,13 +94,13 @@ public class RagonServer : INetworkListener
     _timer.Start();
     while (true)
     {
-      if (_timer.ElapsedMilliseconds > _tickrate)
+      if (_timer.ElapsedMilliseconds > _tickRate)
       {
-        _executor.Update();
+        _scheduler.Update(_timer.ElapsedMilliseconds / 1000.0f);
-        _scheduler.Update();
         _timer.Restart();
       }
       
+      _executor.Update();
       _server.Update();
       Thread.Sleep(1);
     }
@@ -97,6 +116,7 @@ public class RagonServer : INetworkListener
       Port = _configuration.Port,
     };
     
+    _httpServer.Start(_configuration);
     _server.Start(this, networkConfiguration);
 
     if (executeInDedicatedThread)
@@ -107,31 +127,32 @@ public class RagonServer : INetworkListener
 
   public void Dispose()
   {
+    _serverPlugin.OnDetached();
     _server.Stop();
     _dedicatedThread.Interrupt();
   }
 
   public void OnConnected(INetworkConnection connection)
   {
-    var lobbyPlayer = new RagonLobbyPlayer(connection);
+    var context = new RagonContext(connection, _executor, _lobby, _scheduler);
-    var context = new RagonContext(connection, _executor, _lobby, _scheduler, lobbyPlayer);
    
     _logger.Trace($"Connected: {connection.Id}");
-    _contexts.Add(connection.Id, context);
+    _contextsByConnection.Add(connection.Id, context);
   }
 
   public void OnDisconnected(INetworkConnection connection)
   {
-    if (_contexts.Remove(connection.Id, out var context))
+    if (_contextsByConnection.Remove(connection.Id, out var context))
     {
       var room = context.Room;
       if (room != null)
       {
         room.DetachPlayer(context.RoomPlayer);
-        _lobby.RemoveIfEmpty(room);
+        if (_lobby.RemoveIfEmpty(room)) 
+          _webhooks.RoomRemoved(context, room);
       }
       
-      _logger.Trace($"Disconnected: {connection.Id}|{context.LobbyPlayer.Name}|{context.LobbyPlayer.Id}");
+      _logger.Trace($"Disconnected: {connection.Id}");
     }
     else
     {
@@ -141,7 +162,7 @@ public class RagonServer : INetworkListener
 
   public void OnTimeout(INetworkConnection connection)
   {
-    if (_contexts.Remove(connection.Id, out var context))
+    if (_contextsByConnection.Remove(connection.Id, out var context))
     {
       var room = context.Room;
       if (room != null)
@@ -162,13 +183,12 @@ public class RagonServer : INetworkListener
   {
     try
     {
-      if (_contexts.TryGetValue(connection.Id, out var context))
+      if (_contextsByConnection.TryGetValue(connection.Id, out var context))
       {
         _writer.Clear();
         _reader.Clear();
         _reader.FromArray(data);
         
-        // Console.WriteLine($"{string.Join(",", data.Select(d => d.ToString()))}");
         var operation = _reader.ReadByte();
         _handlers[operation].Handle(context, _reader, _writer);
       }
@@ -178,4 +198,23 @@ public class RagonServer : INetworkListener
       _logger.Error(ex);
     }
   }
+
+  public IRagonOperation ResolveOperation(RagonOperation operation)
+  {
+    return _handlers[(byte)operation];
+  }
+
+  public RagonLobbyPlayer? GetPlayerByConnection(INetworkConnection connection)
+  {
+    return _contextsByConnection.TryGetValue(connection.Id, out var context) ? 
+      context.LobbyPlayer : 
+      null;
+  }
+
+  public RagonLobbyPlayer? GetPlayerById(string playerId)
+  {
+    return _contextsByPlayerId.TryGetValue(playerId, out var context) ? 
+      context.LobbyPlayer :
+      null;
+  }
 }

Ragon.Server/Sources/RagonServerConfiguration.cs

@@ -25,6 +25,11 @@ public enum ServerType
   WEBSOCKET,
 }
 
+public class WebHook
+{
+  
+}
+
 [Serializable]
 public struct Configuration
 {
@@ -33,32 +38,21 @@ public struct Configuration
   public ushort ServerTickRate;
   public string GameProtocol;
   public ushort Port;
+  public ushort HttpPort;
+  public string HttpKey;
   public int LimitConnections;
   public int LimitPlayersPerRoom;
   public int LimitRooms;
+  public Dictionary<string, string> WebHooks;
 
   private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
-  private static readonly string ServerVersion = "1.1.3-rc";
+  private static readonly string ServerVersion = "1.2.0-rc";
   private static Dictionary<string, ServerType> _serverTypes = new Dictionary<string, ServerType>()
   {
     {"enet", Server.ServerType.ENET},
     {"websocket", Server.ServerType.WEBSOCKET}
   };
 
-  private static void CopyrightInfo()
-  {
-    Logger.Info($"Server Version: {ServerVersion}");
-    Logger.Info($"Machine Name: {Environment.MachineName}");
-    Logger.Info($"OS: {Environment.OSVersion}");
-    Logger.Info($"Processors: {Environment.ProcessorCount}");
-    Logger.Info($"Runtime Version: {Environment.Version}");
-    Logger.Info("==================================");
-    Logger.Info("|                                |");
-    Logger.Info("|            Ragon               |");
-    Logger.Info("|                                |");
-    Logger.Info("==================================");
-  }
-
   public static Configuration Load(string filePath)
   {
     CopyrightInfo();
@@ -68,5 +62,20 @@ public struct Configuration
     return configuration;
   }
 
+  private static void CopyrightInfo()
+  {
+    Logger.Info($"Server Version: {ServerVersion}");
+    Logger.Info($"Machine Name: {Environment.MachineName}");
+    Logger.Info($"OS: {Environment.OSVersion}");
+    Logger.Info($"Processors: {Environment.ProcessorCount}");
+    Logger.Info($"Runtime Version: {Environment.Version}");
+    Logger.Info("==================================");
+    Logger.Info(@"   ___    _   ___  ___  _  _ ");
+    Logger.Info(@"  | _ \  /_\ / __|/ _ \| \| |");
+    Logger.Info(@"  |   / / _ \ (_ | (_) | .` |");
+    Logger.Info(@"  |_|_\/_/ \_\___|\___/|_|\_|");
+    Logger.Info("==================================");
+  }
+
   public static ServerType GetServerType(string type) => _serverTypes[type];
 }

Ragon.Server/Sources/Room/IRagonRoom.cs

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2023 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.
+ */
+
+using Ragon.Server.Entity;
+using Ragon.Server.IO;
+
+namespace Ragon.Server.Room;
+
+public interface IRagonRoom
+{
+  RagonRoomPlayer GetPlayerByConnection(INetworkConnection connection);
+  RagonRoomPlayer GetPlayerById(string id);
+  IRagonEntity GetEntityById(ushort id);
+  IRagonEntity[] GetEntitiesOfPlayer(RagonRoomPlayer id);
+}

Ragon.Server/Sources/Room/RagonRoom.cs

@@ -14,17 +14,26 @@
  * limitations under the License.
  */
 
-using Ragon.Core.Time;
 using Ragon.Protocol;
+using Ragon.Server.Entity;
+using Ragon.Server.IO;
+using Ragon.Server.Plugin;
+using Ragon.Server.Time;
 
-namespace Ragon.Server;
+namespace Ragon.Server.Room;
 
-public class RagonRoom: IRagonAction
+public class RagonRoom : IRagonRoom, IRagonAction
 {
   public string Id { get; private set; }
-  public RoomInformation Info { get; private set; }
+  public string Map { get; private set; }
+  public int PlayerMax { get; private set; }
+  public int PlayerMin { get; private set; }
+  public int PlayerCount => WaitPlayersList.Count;
+  
   public RagonRoomPlayer Owner { get; private set; }
-  public RagonBuffer  Writer { get; }
+  public RagonBuffer Writer { get; }
+  public IRoomPlugin Plugin { get; private set; }
+  
   public Dictionary<ushort, RagonRoomPlayer> Players { get; private set; }
   public List<RagonRoomPlayer> WaitPlayersList { get; private set; }
   public List<RagonRoomPlayer> ReadyPlayersList { get; private set; }
@@ -37,10 +46,13 @@ public class RagonRoom: IRagonAction
 
   private readonly HashSet<RagonEntity> _entitiesDirtySet;
   
-  public RagonRoom(string roomId, RoomInformation info)
+  public RagonRoom(string roomId, RoomInformation info, IRoomPlugin roomPlugin)
   {
     Id = roomId;
-    Info = info;
+    Map = info.Map;
+    PlayerMax = info.Max;
+    PlayerMin = info.Min;
+    Plugin = roomPlugin;
 
     Players = new Dictionary<ushort, RagonRoomPlayer>(info.Max);
     WaitPlayersList = new List<RagonRoomPlayer>(info.Max);
@@ -78,9 +90,9 @@ public class RagonRoom: IRagonAction
     _entitiesDirtySet.Remove(entity);
   }
 
-  public void Tick()
+  public void Tick(float dt)
   {
-    var entities = (ushort) _entitiesDirtySet.Count;
+    var entities = (ushort)_entitiesDirtySet.Count;
     if (entities > 0)
     {
       Writer.Clear();
@@ -88,7 +100,7 @@ public class RagonRoom: IRagonAction
       Writer.WriteUShort(entities);
 
       foreach (var entity in _entitiesDirtySet)
-        entity.State.Write(Writer);
+        entity.WriteState(Writer);
 
       _entitiesDirtySet.Clear();
 
@@ -121,7 +133,7 @@ public class RagonRoom: IRagonAction
         Writer.WriteString(player.Id);
 
         var entitiesToDelete = player.Entities.DynamicList;
-        Writer.WriteUShort((ushort) entitiesToDelete.Count);
+        Writer.WriteUShort((ushort)entitiesToDelete.Count);
         foreach (var entity in entitiesToDelete)
         {
           Writer.WriteUShort(entity.Id);
@@ -138,18 +150,18 @@ public class RagonRoom: IRagonAction
 
         Owner = nextOwner;
 
-        var entitiesToUpdate =  roomPlayer.Entities.StaticList;
+        var entitiesToUpdate = roomPlayer.Entities.StaticList;
 
         Writer.Clear();
         Writer.WriteOperation(RagonOperation.OWNERSHIP_CHANGED);
         Writer.WriteString(Owner.Id);
-        Writer.WriteUShort((ushort) entitiesToUpdate.Count);
+        Writer.WriteUShort((ushort)entitiesToUpdate.Count);
 
         foreach (var entity in entitiesToUpdate)
         {
           Writer.WriteUShort(entity.Id);
 
-          entity.SetOwner(nextOwner);
+          entity.Attach(nextOwner);
           nextOwner.Entities.Add(entity);
         }
 
@@ -170,12 +182,7 @@ public class RagonRoom: IRagonAction
 
   public void UpdateMap(string sceneName)
   {
-    Info = new RoomInformation()
+    Map = sceneName;
-    {
-      Max = Info.Max,
-      Min = Info.Min,
-      Map = sceneName,
-    };
 
     DynamicEntitiesList.Clear();
     StaticEntitiesList.Clear();
@@ -198,4 +205,26 @@ public class RagonRoom: IRagonAction
     foreach (var readyPlayer in ReadyPlayersList)
       readyPlayer.Connection.Reliable.Send(data);
   }
+
+  public RagonRoomPlayer GetPlayerByConnection(INetworkConnection connection)
+  {
+    return Players[connection.Id];
+  }
+
+  public RagonRoomPlayer? GetPlayerById(string id)
+  {
+    return PlayerList.FirstOrDefault(p => p.Id == id);
+  }
+
+  public IRagonEntity? GetEntityById(ushort id)
+  {
+    return Entities.TryGetValue(id, out var entity) ? 
+      entity : 
+      null;
+  }
+
+  public IRagonEntity[] GetEntitiesOfPlayer(RagonRoomPlayer player)
+  {
+    return EntityList.Where(e => e.Owner.Connection.Id == player.Connection.Id).ToArray();
+  }
 }

Ragon.Server/Sources/Room/RagonRoomInformation.cs

@@ -16,14 +16,9 @@
 
 namespace Ragon.Server;
 
-public class RoomInformation
+public ref struct RoomInformation
 {
-  public string Map { get; init; } = "none";
+  public string Map;
-  public int Min { get; init; }
+  public int Min;
-  public int Max { get; init; }
+  public int Max;
-
-  public override string ToString()
-  {
-    return $"Map: {Map} Count: {Min}/{Max}";
-  }
 }

Ragon.Server/Sources/Room/RagonRoomPlayer.cs

@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
-namespace Ragon.Server;
+using Ragon.Server.Entity;
+using Ragon.Server.IO;
+
+namespace Ragon.Server.Room;
 
 public class RagonRoomPlayer
 {

Ragon.Server/Sources/Time/IRagonAction.cs

@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-namespace Ragon.Core.Time;
+namespace Ragon.Server.Time;
 
 public interface IRagonAction
 {
-    public void Tick();
+    public void Tick(float dt);
 }

Ragon.Server/Sources/Time/RagonActionExecutor.cs

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-namespace Ragon.Core.Time;
+namespace Ragon.Server.Time;
 
 public class RagonScheduler
 {
@@ -35,9 +35,9 @@ public class RagonScheduler
     _tasks.Remove(task);
   }
 
-  public void Update()
+  public void Update(float dt)
   {
     foreach (var task in _tasks)
-      task.Tick();
+      task.Tick(dt);
   }
 }

Ragon.Tests/Basic.cs

@@ -1,154 +0,0 @@
-/*
- * Copyright 2023 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.
- */
-
-using NLog;
-using Ragon.Client;
-using Ragon.Protocol;
-using Xunit.Abstractions;
-
-namespace Ragon.Core.Tests;
-
-public class Connection
-{
-  private readonly ITestOutputHelper _testOutputHelper;
-
-  public Connection(ITestOutputHelper testOutputHelper)
-  {
-    _testOutputHelper = testOutputHelper;
-  }
-
-  public class Game : IRagonListener
-  {
-    private RagonClient _client;
-
-    public Game(RagonClient client, TaskCompletionSource taskCompletionSource)
-    {
-      _client = client;
-    }
-
-    public void OnConnected(RagonClient client)
-    {
-      Console.WriteLine("Console Connected");
-      RagonLog.Trace("Connected");
-
-      client.Session.AuthorizeWithKey("defaultkey", "Player Eduard", Array.Empty<byte>());
-    }
-
-    public void OnAuthorizationSuccess(RagonClient client, string playerId, string playerName)
-    {
-      RagonLog.Trace("Authorized");
-
-      client.Session.Create("Example", 1, 20);
-    }
-
-    public void OnAuthorizationFailed(RagonClient client, string message)
-    {
-      RagonLog.Trace($"Authorization failed: {message}");
-    }
-
-    public void OnJoined(RagonClient client)
-    {
-    }
-
-    public void OnFailed(RagonClient client, string message)
-    {
-      RagonLog.Trace("Failed to join");
-    }
-
-    public void OnLeft(RagonClient client)
-    {
-      RagonLog.Trace("Left");
-    }
-
-    public void OnDisconnected(RagonClient client)
-    {
-      RagonLog.Trace("Disconnected");
-    }
-
-    public void OnPlayerJoined(RagonClient client, RagonPlayer player)
-    {
-      RagonLog.Trace("Player joined");
-    }
-
-    public void OnPlayerLeft(RagonClient client, RagonPlayer player)
-    {
-      RagonLog.Trace("Player left");
-    }
-
-    public void OnOwnershipChanged(RagonClient client, RagonPlayer player)
-    {
-      RagonLog.Trace("Owner ship changed");
-    }
-
-    public void OnLevel(RagonClient client, string sceneName)
-    {
-      RagonLog.Trace($"New level: {sceneName}");
-      client.Room.SceneLoaded();
-    }
-  }
-
-  // [Fact]
-  // public async void Connect()
-  // {
-  //   RagonLog.Set(new RagonXUnitLogger(_testOutputHelper));
-  //
-  //   var joining = new TaskCompletionSource();
-  //   var network = new RagonNetwork();
-  //   var game = new Game(network, joining);
-  //   
-  //   network.AddListener(game);
-  //   
-  //   var clientConfiguration = new RagonConnectionConfiguration();
-  //   clientConfiguration.Type = RagonConnectionType.UDP;
-  //   clientConfiguration.Protocol = "1.0.0";
-  //   clientConfiguration.Address = "127.0.0.1";
-  //   clientConfiguration.Port = 5000;
-  //
-  //   network.Connect(clientConfiguration);
-  //   
-  //   var relayConfiguration = new Configuration()
-  //   {
-  //     GameProtocol = "1.0.0",
-  //     LimitConnections = 4095,
-  //     LimitRooms = 20,
-  //     LimitPlayersPerRoom = 20,
-  //     Port = 5000,
-  //     ServerKey = "defaultkey",
-  //     ServerTickRate = 30,
-  //     ServerType = "enet"
-  //   };
-  //   
-  //   var relay = new RagonServer(relayConfiguration);
-  //   relay.Start(true);
-  //
-  //   var ticks = 0;
-  //   while (true)
-  //   {
-  //     ticks += 1;
-  //     network.Update();
-  //     
-  //     if (ticks > 100)
-  //       break;
-  //     
-  //     await Task.Delay(100);
-  //   }
-  //
-  //   Assert.Equal(network.Status, RagonStatus.ROOM);
-  //   
-  //   network.Dispose();
-  //   relay.Dispose();
-  // }
-}

Ragon.Tests/Ragon.Tests.csproj

@@ -1,32 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-    <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
-        <ImplicitUsings>enable</ImplicitUsings>
-        <Nullable>enable</Nullable>
-
-        <IsPackable>false</IsPackable>
-
-        <RootNamespace>Ragon.Core.Tests</RootNamespace>
-    </PropertyGroup>
-
-    <ItemGroup>
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
-        <PackageReference Include="xunit" Version="2.4.2" />
-        <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
-            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-            <PrivateAssets>all</PrivateAssets>
-        </PackageReference>
-        <PackageReference Include="coverlet.collector" Version="3.1.2">
-            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-            <PrivateAssets>all</PrivateAssets>
-        </PackageReference>
-    </ItemGroup>
-
-    <ItemGroup>
-      <ProjectReference Include="..\Ragon.Client\Ragon.Client.csproj" />
-      <ProjectReference Include="..\Ragon.Server\Ragon.Server.csproj" />
-      <ProjectReference Include="..\Ragon.Protocol\Ragon.Protocol.csproj" />
-    </ItemGroup>
-
-</Project>

Ragon.sln

@@ -14,8 +14,6 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Ragon.Client", "Ragon.Clien
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Ragon.Client.Simulation", "Ragon.Client.Simulation\Ragon.Client.Simulation.csproj", "{0384848D-3B63-4B3A-B15F-A836EBB3E95D}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Ragon.Tests", "Ragon.Tests\Ragon.Tests.csproj", "{D1F44471-A700-4E7C-B047-334685850A5C}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Ragon.Client.Property", "Ragon.Client.Property\Ragon.Client.Property.csproj", "{46A60DAB-F854-4BB6-A119-BD4C5B2B0D29}"
 EndProject
 Global
@@ -52,10 +50,6 @@ Global
 		{0384848D-3B63-4B3A-B15F-A836EBB3E95D}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{0384848D-3B63-4B3A-B15F-A836EBB3E95D}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{0384848D-3B63-4B3A-B15F-A836EBB3E95D}.Release|Any CPU.Build.0 = Release|Any CPU
-		{D1F44471-A700-4E7C-B047-334685850A5C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{D1F44471-A700-4E7C-B047-334685850A5C}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{D1F44471-A700-4E7C-B047-334685850A5C}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{D1F44471-A700-4E7C-B047-334685850A5C}.Release|Any CPU.Build.0 = Release|Any CPU
 		{46A60DAB-F854-4BB6-A119-BD4C5B2B0D29}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{46A60DAB-F854-4BB6-A119-BD4C5B2B0D29}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{46A60DAB-F854-4BB6-A119-BD4C5B2B0D29}.Release|Any CPU.ActiveCfg = Release|Any CPU