fixed: checking owner

Update readme

README.md

@@ -26,9 +26,6 @@ Ragon is fully free, small and high perfomance room based game server with plugi
 ### Dependencies
 * ENet-Sharp [v2.4.8]
 
-### License
-MIT
-
 ### Tips
 \* Limited to 4095 CCU by library ENet-Sharp (1)
 \* Non finally (2)

Ragon.Client/Sources/Entity/RagonProperty.cs

@@ -23,7 +23,7 @@ namespace Ragon.Client
   {
     public string Name => _name;
     public RagonEntity Entity => _entity;
-    
+
     public event Action Changed;
     public bool IsDirty => _dirty && _ticks >= _priority;
     public bool IsFixed => _fixed;
@@ -32,13 +32,13 @@ namespace Ragon.Client
     private bool _fixed;
     private string _name;
     protected bool _invokeLocal;
-    
+
     private RagonEntity _entity;
     private bool _dirty;
     private int _size;
     private int _ticks;
     private int _priority;
- 
+
     protected RagonProperty(int priority, bool invokeLocal)
     {
       _size = 0;
@@ -46,12 +46,12 @@ namespace Ragon.Client
       _fixed = false;
       _invokeLocal = invokeLocal;
     }
-    
+
     public void SetName(string name)
     {
       _name = name;
     }
-    
+
     protected void SetFixedSize(int size)
     {
       _size = size;
@@ -62,18 +62,19 @@ namespace Ragon.Client
     {
       if (!_invokeLocal)
         return;
-      
+
       Changed?.Invoke();
     }
 
     protected void MarkAsChanged()
     {
       InvokeChanged();
-      
-      if (_dirty) return;
-      _dirty = true;
 
-      _entity?.TrackChangedProperty(this);
+      if (_dirty || _entity == null)
+        return;
+
+      _dirty = true;
+      _entity.TrackChangedProperty(this);
     }
 
     internal void Flush()
@@ -86,10 +87,10 @@ namespace Ragon.Client
     {
       _ticks++;
     }
-    
+
-    internal void AssignEntity(RagonEntity obj)
+    internal void AssignEntity(RagonEntity ent)
     {
-      _entity = obj;
+      _entity = ent;
       
       Changed?.Invoke();
     }
@@ -107,8 +108,8 @@ namespace Ragon.Client
       var propOffset = buffer.WriteOffset;
 
       Serialize(buffer);
-      
+
-      var propSize = (uint) (buffer.WriteOffset - propOffset);
+      var propSize = (uint)(buffer.WriteOffset - propOffset);
       buffer.Write(propSize, 16, sizeOffset);
     }
 

Ragon.Client/Sources/RagonClient.cs

@@ -23,7 +23,7 @@ namespace Ragon.Client
     private readonly INetworkConnection _connection;
     private readonly IRagonEntityListener _entityListener;
     private readonly IRagonSceneCollector _sceneCollector;
-    private Handler[] _processors;
+    private Handler[] _handlers;
     private RagonBuffer _readBuffer;
     private RagonBuffer _writeBuffer;
     private RagonRoom _room;
@@ -35,8 +35,8 @@ namespace Ragon.Client
     private RagonStatus _status;
     private NetworkStatistics _stats;
 
-    private float _replicatationRate = 0;
+    private float _replicationRate = 0;
-    private float _replicatationTime = 0;
+    private float _replicationTime = 0;
 
     public IRagonConnection Connection => _connection;
     public RagonStatus Status => _status;
@@ -67,24 +67,14 @@ namespace Ragon.Client
       _connection.OnConnected += OnConnected;
       _connection.OnDisconnected += OnDisconnected;
 
-      _replicatationRate = (1000.0f / rate) / 1000.0f;
+      _replicationRate = (1000.0f / rate) / 1000.0f;
-      _replicatationTime = 0;
+      _replicationTime = 0;
 
       _eventCache = new RagonEventCache();
       _stats = new NetworkStatistics();
       _status = RagonStatus.DISCONNECTED;
     }
-
+    
-    public void AddListener(IRagonListener listener)
-    {
-      _listenerList.Add(listener);
-    }
-
-    public void RemoveListener(IRagonListener listener)
-    {
-      _listenerList.Remove(listener);
-    }
-
     public void Connect(string address, ushort port, string protocol)
     {
       _writeBuffer = new RagonBuffer();
@@ -94,25 +84,25 @@ namespace Ragon.Client
       _playerCache = new RagonPlayerCache();
       _entityCache = new RagonEntityCache(this, _playerCache, _entityListener, _sceneCollector);
 
-      _processors = new Handler[byte.MaxValue];
+      _handlers = new Handler[byte.MaxValue];
-      _processors[(byte)RagonOperation.AUTHORIZED_SUCCESS] = new AuthorizeSuccessHandler(_listenerList);
+      _handlers[(byte)RagonOperation.AUTHORIZED_SUCCESS] = new AuthorizeSuccessHandler(_listenerList);
-      _processors[(byte)RagonOperation.AUTHORIZED_FAILED] = new AuthorizeFailedHandler(_listenerList);
+      _handlers[(byte)RagonOperation.AUTHORIZED_FAILED] = new AuthorizeFailedHandler(_listenerList);
-      _processors[(byte)RagonOperation.JOIN_SUCCESS] =
+      _handlers[(byte)RagonOperation.JOIN_SUCCESS] =
         new JoinSuccessHandler(this, _readBuffer, _listenerList, _playerCache, _entityCache);
-      _processors[(byte)RagonOperation.JOIN_FAILED] = new JoinFailedHandler(_listenerList);
+      _handlers[(byte)RagonOperation.JOIN_FAILED] = new JoinFailedHandler(_listenerList);
-      _processors[(byte)RagonOperation.LEAVE_ROOM] = new LeaveRoomHandler(this, _listenerList, _entityCache);
+      _handlers[(byte)RagonOperation.LEAVE_ROOM] = new LeaveRoomHandler(this, _listenerList, _entityCache);
-      _processors[(byte)RagonOperation.OWNERSHIP_CHANGED] =
+      _handlers[(byte)RagonOperation.OWNERSHIP_CHANGED] =
         new OwnershipHandler(_listenerList, _playerCache, _entityCache);
-      _processors[(byte)RagonOperation.PLAYER_JOINED] = new PlayerJoinHandler(_playerCache, _listenerList);
+      _handlers[(byte)RagonOperation.PLAYER_JOINED] = new PlayerJoinHandler(_playerCache, _listenerList);
-      _processors[(byte)RagonOperation.PLAYER_LEAVED] =
+      _handlers[(byte)RagonOperation.PLAYER_LEAVED] =
         new PlayerLeftHandler(_entityCache, _playerCache, _listenerList);
-      _processors[(byte)RagonOperation.LOAD_SCENE] = new SceneLoadHandler(this, _listenerList);
+      _handlers[(byte)RagonOperation.LOAD_SCENE] = new SceneLoadHandler(this, _listenerList);
-      _processors[(byte)RagonOperation.CREATE_ENTITY] = new EntityCreateHandler(this, _playerCache, _entityCache);
+      _handlers[(byte)RagonOperation.CREATE_ENTITY] = new EntityCreateHandler(this, _playerCache, _entityCache);
-      _processors[(byte)RagonOperation.DESTROY_ENTITY] = new EntityDestroyHandler(_entityCache);
+      _handlers[(byte)RagonOperation.DESTROY_ENTITY] = new EntityDestroyHandler(_entityCache);
-      _processors[(byte)RagonOperation.REPLICATE_ENTITY_STATE] = new StateEntityHandler(_entityCache);
+      _handlers[(byte)RagonOperation.REPLICATE_ENTITY_STATE] = new StateEntityHandler(_entityCache);
-      _processors[(byte)RagonOperation.REPLICATE_ENTITY_EVENT] =
+      _handlers[(byte)RagonOperation.REPLICATE_ENTITY_EVENT] =
         new EntityEventHandler(this, _playerCache, _entityCache);
-      _processors[(byte)RagonOperation.SNAPSHOT] =
+      _handlers[(byte)RagonOperation.SNAPSHOT] =
         new SnapshotHandler(this, _listenerList, _entityCache, _playerCache);
 
       var protocolRaw = RagonVersion.Parse(protocol);
@@ -129,11 +119,11 @@ namespace Ragon.Client
 
     public void Update(float dt)
     {
-      _replicatationTime += dt;
+      _replicationTime += dt;
-      if (_replicatationTime >= _replicatationRate)
+      if (_replicationTime >= _replicationRate)
       {
         _entityCache.WriteState(_readBuffer);
-        _replicatationTime = 0;
+        _replicationTime = 0;
       }
 
       _stats.Update(_connection.BytesSent, _connection.BytesReceived, _connection.Ping, dt);
@@ -147,6 +137,28 @@ namespace Ragon.Client
       _connection.Dispose();
     }
 
+    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(IRagonFailedListener listener) => _listenerList.Add(listener);
+    public void AddListener(IRagonJoinListener listener) => _listenerList.Add(listener);
+    public void AddListener(IRagonLeftListener listener) => _listenerList.Add(listener);
+    public void AddListener(IRagonLevelListener listener) => _listenerList.Add(listener);
+    public void AddListener(IRagonOwnershipChangedListener listener) => _listenerList.Add(listener);
+    public void AddListener(IRagonPlayerJoinListener listener) => _listenerList.Add(listener);
+    public void AddListener(IRagonPlayerLeftListener listener) => _listenerList.Add(listener);
+
+    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(IRagonFailedListener listener) => _listenerList.Remove(listener);
+    public void RemoveListener(IRagonJoinListener listener) => _listenerList.Remove(listener);
+    public void RemoveListener(IRagonLeftListener listener) => _listenerList.Remove(listener);
+    public void RemoveListener(IRagonLevelListener listener) => _listenerList.Remove(listener);
+    public void RemoveListener(IRagonOwnershipChangedListener listener) => _listenerList.Remove(listener);
+    public void RemoveListener(IRagonPlayerJoinListener listener) => _listenerList.Remove(listener);
+    public void RemoveListener(IRagonPlayerLeftListener listener) => _listenerList.Remove(listener);
+    
     #endregion
 
     #region INTERNAL
@@ -183,7 +195,7 @@ namespace Ragon.Client
       _readBuffer.FromArray(data);
 
       var operation = _readBuffer.ReadByte();
-      _processors[operation].Handle(_readBuffer);
+      _handlers[operation].Handle(_readBuffer);
     }
 
     #endregion

Ragon.Client/Sources/RagonListenerList.cs

@@ -18,10 +18,17 @@ namespace Ragon.Client
 {
   internal class RagonListenerList
   {
-    public int Count => _listeners.Count;
+    private readonly RagonClient _client;
-    private List<IRagonListener> _listeners = new();
+    private readonly List<IRagonAuthorizationListener> _authorizationListeners = new();
-    private RagonClient _client;
+    private readonly List<IRagonConnectedListener> _connectionListeners = new();
-
+    private readonly List<IRagonFailedListener> _failedListeners = new();
+    private readonly List<IRagonJoinListener> _joinListeners = new();
+    private readonly List<IRagonLeftListener> _leftListeners = new();
+    private readonly List<IRagonLevelListener> _levelListeners = new();
+    private readonly List<IRagonOwnershipChangedListener> _ownershipChangedListeners = new();
+    private readonly List<IRagonPlayerJoinListener> _playerJoinListeners = new();
+    private readonly List<IRagonPlayerLeftListener> _playerLeftListeners = new();
+    
     public RagonListenerList(RagonClient client)
     {
       _client = client;
@@ -29,77 +36,183 @@ namespace Ragon.Client
     
     public void Add(IRagonListener listener)
     {
-      _listeners.Add(listener);
+      _authorizationListeners.Add(listener);
+      _connectionListeners.Add(listener);
+      _failedListeners.Add(listener);
+      _joinListeners.Add(listener);
+      _leftListeners.Add(listener);
+      _levelListeners.Add(listener);
+      _ownershipChangedListeners.Add(listener);
+      _playerJoinListeners.Add(listener);
+      _playerLeftListeners.Add(listener);
     }
 
     public void Remove(IRagonListener listener)
     {
-      _listeners.Remove(listener);
+      _authorizationListeners.Remove(listener);
+      _connectionListeners.Remove(listener);
+      _failedListeners.Remove(listener);
+      _joinListeners.Remove(listener);
+      _leftListeners.Remove(listener);
+      _levelListeners.Remove(listener);
+      _ownershipChangedListeners.Remove(listener);
+      _playerJoinListeners.Remove(listener);
+      _playerLeftListeners.Remove(listener);
     }
     
+    public void Add(IRagonAuthorizationListener listener)
+    {
+      _authorizationListeners.Add(listener);
+    }
+    
+    public void Add(IRagonConnectedListener listener)
+    {
+      _connectionListeners.Add(listener);
+    }
+    
+    public void Add(IRagonFailedListener listener)
+    {
+      _failedListeners.Add(listener);
+    }
+    
+    public void Add(IRagonJoinListener listener)
+    {
+      _joinListeners.Add(listener);
+    }
+    
+    public void Add(IRagonLeftListener  listener)
+    {
+      _leftListeners.Add(listener);
+    }
+    
+    public void Add(IRagonLevelListener  listener)
+    {
+      _levelListeners.Add(listener);
+    }
+    
+    public void Add(IRagonOwnershipChangedListener  listener)
+    {
+      _ownershipChangedListeners.Add(listener);
+    }
+
+    public void Add(IRagonPlayerJoinListener  listener)
+    {
+      _playerJoinListeners.Add(listener);
+    }
+    
+    public void Add(IRagonPlayerLeftListener  listener)
+    {
+      _playerLeftListeners.Add(listener);
+    }
+
+    public void Remove(IRagonAuthorizationListener listener)
+    {
+      _authorizationListeners.Remove(listener);
+    }
+    
+    public void Remove(IRagonConnectedListener listener)
+    {
+      _connectionListeners.Remove(listener);
+    }
+    
+    public void Remove(IRagonFailedListener listener)
+    {
+      _failedListeners.Remove(listener);
+    }
+    
+    public void Remove(IRagonJoinListener listener)
+    {
+      _joinListeners.Remove(listener);
+    }
+    
+    public void Remove(IRagonLeftListener  listener)
+    {
+      _leftListeners.Remove(listener);
+    }
+    
+    public void Remove(IRagonLevelListener  listener)
+    {
+      _levelListeners.Remove(listener);
+    }
+    
+    public void Remove(IRagonOwnershipChangedListener  listener)
+    {
+      _ownershipChangedListeners.Remove(listener);
+    }
+
+    public void Remove(IRagonPlayerJoinListener  listener)
+    {
+      _playerJoinListeners.Remove(listener);
+    }
+    
+    public void Remove(IRagonPlayerLeftListener  listener)
+    {
+      _playerLeftListeners.Remove(listener);
+    }
+
     public void OnAuthorizationSuccess(string playerId, string playerName)
     {
-      foreach (var listener in _listeners)
+      foreach (var listener in _authorizationListeners)
         listener.OnAuthorizationSuccess(_client, playerId, playerName);
     }
     
     public void OnAuthorizationFailed(string message)
     {
-      foreach (var listener in _listeners)
+      foreach (var listener in _authorizationListeners)
         listener.OnAuthorizationFailed(_client, message);
     }
     
     public void OnLeft()
     {
-      foreach (var listener in _listeners)
+      foreach (var listener in _leftListeners)
         listener.OnLeft(_client);
     }
 
     public void OnFailed(string message)
     {
-      foreach (var listener in _listeners)
+      foreach (var listener in _failedListeners)
         listener.OnFailed(_client, message);
     }
 
     public void OnOwnershipChanged(RagonPlayer player)
     {
-      foreach (var listener in _listeners)
+      foreach (var listener in _ownershipChangedListeners)
         listener.OnOwnershipChanged(_client, player);
     }
 
     public void OnPlayerLeft(RagonPlayer player)
     {
-      foreach (var listener in _listeners)
+      foreach (var listener in _playerLeftListeners)
         listener.OnPlayerLeft(_client, player);
     }
 
     public void OnPlayerJoined(RagonPlayer player)
     {
-      foreach (var listener in _listeners)
+      foreach (var listener in _playerJoinListeners)
         listener.OnPlayerJoined(_client, player);
     }
 
     public void OnLevel(string sceneName)
     {
-      foreach (var listener in _listeners)
+      foreach (var listener in _levelListeners)
         listener.OnLevel(_client, sceneName);
     }
 
     public void OnJoined()
     {
-      foreach (var listener in _listeners)
+      foreach (var listener in _joinListeners)
         listener.OnJoined(_client);
     }
 
     public void OnConnected()
     {
-      foreach (var listener in _listeners)
+      foreach (var listener in _connectionListeners)
         listener.OnConnected(_client);
     }
 
     public void OnDisconnected()
     {
-      foreach (var listener in _listeners)
+      foreach (var listener in _connectionListeners)
         listener.OnDisconnected(_client);
     }
   }

Ragon.Server/Sources/Entity/RagonEntityState.cs

@@ -27,7 +27,7 @@ public class RagonEntityState
   public RagonEntityState(RagonEntity entity, int capacity = 10)
   {
     _entity = entity;
-    _properties = new List<RagonProperty>(10);
+    _properties = new List<RagonProperty>(capacity);
   }
 
   public void AddProperty(RagonProperty property)

Ragon.Server/Sources/Handler/EntityStateOperation.cs

@@ -31,7 +31,7 @@ public sealed class EntityStateOperation: IRagonOperation
     for (var entityIndex = 0; entityIndex < entitiesCount; entityIndex++)
     {
       var entityId = reader.ReadUShort();
-      if (room.Entities.TryGetValue(entityId, out var entity))
+      if (room.Entities.TryGetValue(entityId, out var entity) && entity.Owner.Connection.Id == context.Connection.Id)
       {
         entity.State.Read(reader);
         room.Track(entity);

Ragon.Server/Sources/RagonServer.cs

@@ -51,7 +51,7 @@ public class RagonServer : INetworkListener
     
     _reader = new RagonBuffer();
     _writer = new RagonBuffer();
-    _tickrate = _configuration.ServerTickRate;
+    _tickrate = 1000 / _configuration.ServerTickRate;
     _timer = new Stopwatch();
     
     _handlers = new IRagonOperation[byte.MaxValue];
@@ -66,6 +66,8 @@ public class RagonServer : INetworkListener
     _handlers[(byte) RagonOperation.DESTROY_ENTITY] = new EntityDestroyOperation();
     _handlers[(byte) RagonOperation.REPLICATE_ENTITY_EVENT] = new EntityEventOperation();
     _handlers[(byte) RagonOperation.REPLICATE_ENTITY_STATE] = new EntityStateOperation();
+    
+    _logger.Trace($"Server Tick Rate: {_configuration.ServerTickRate}");
   }
 
   public void Execute()
@@ -76,12 +78,11 @@ public class RagonServer : INetworkListener
       if (_timer.ElapsedMilliseconds > _tickrate)
       {
         _executor.Update();
+        _scheduler.Update();
         _timer.Restart();
       }
       
-      _scheduler.Update();
       _server.Update();
-      
       Thread.Sleep(1);
     }
   }

Ragon.Server/Sources/RagonServerConfiguration.cs

@@ -38,7 +38,7 @@ public struct Configuration
   public int LimitRooms;
 
   private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
-  private static readonly string ServerVersion = "1.1.0-rc";
+  private static readonly string ServerVersion = "1.1.3-rc";
   private static Dictionary<string, ServerType> _serverTypes = new Dictionary<string, ServerType>()
   {
     {"enet", Server.ServerType.ENET},