chore: added logging

Ragon.Client/Sources/Handler/EntityCreateHandler.cs

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

Ragon.Client/Sources/Handler/EntityEventHandler.cs

@@ -20,35 +20,37 @@ namespace Ragon.Client;
 
 internal class EntityEventHandler : IHandler
 {
-    private readonly RagonPlayerCache _playerCache;
+  private readonly RagonPlayerCache _playerCache;
-    private readonly RagonEntityCache _entityCache;
+  private readonly RagonEntityCache _entityCache;
 
-    public EntityEventHandler(
+  public EntityEventHandler(
-        RagonPlayerCache playerCache,
+    RagonPlayerCache playerCache,
-        RagonEntityCache entityCache
+    RagonEntityCache entityCache
-    )
+  )
+  {
+    _playerCache = playerCache;
+    _entityCache = entityCache;
+  }
+
+  public void Handle(RagonBuffer reader)
+  {
+    var eventCode = reader.ReadUShort();
+    var peerId = reader.ReadUShort();
+    var executionMode = (RagonReplicationMode)reader.ReadByte();
+    var entityId = reader.ReadUShort();
+
+    var player = _playerCache.GetPlayerByPeer(peerId);
+    if (player == null)
     {
-        _playerCache = playerCache;
+      RagonLog.Error($"Player with peerId:{peerId} not found as owner of event with code:{eventCode}");
-        _entityCache = entityCache;
+      
+      _playerCache.Dump();
+      return;
     }
-    
-    public void Handle(RagonBuffer reader)
-    {
-        var eventCode = reader.ReadUShort();
-        var peerId = reader.ReadUShort();
-        var executionMode = (RagonReplicationMode)reader.ReadByte();
-        var entityId = reader.ReadUShort();
 
-        var player = _playerCache.GetPlayerByPeer(peerId);
+    if (player.IsLocal && executionMode == RagonReplicationMode.LocalAndServer)
-        if (player == null)
+      return;
-        {
-            RagonLog.Warn($"Player not found for event {eventCode}");
-            return;
-        }
 
-        if (player.IsLocal && executionMode == RagonReplicationMode.LocalAndServer)
+    _entityCache.OnEvent(player, entityId, eventCode, reader);
-            return;
+  }
-
-        _entityCache.OnEvent(player, entityId, eventCode, reader);
-    }
 }

Ragon.Client/Sources/Handler/EntityOwnershipHandler.cs

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

Ragon.Client/Sources/Handler/OwnershipRoomHandler.cs

@@ -19,12 +19,12 @@ using Ragon.Protocol;
 
 namespace Ragon.Client;
 
-internal class OwnershipRoomHandler: IHandler
+internal class OwnershipRoomHandler : IHandler
 {
   private readonly RagonListenerList _listenerList;
   private readonly RagonPlayerCache _playerCache;
   private readonly RagonEntityCache _entityCache;
-  
+
   public OwnershipRoomHandler(
     RagonListenerList listenerList,
     RagonPlayerCache playerCache,
@@ -34,11 +34,18 @@ internal class OwnershipRoomHandler: IHandler
     _playerCache = playerCache;
     _entityCache = entityCache;
   }
-  
+
   public void Handle(RagonBuffer reader)
   {
     var newOwnerId = reader.ReadUShort();
     var player = _playerCache.GetPlayerByPeer(newOwnerId);
+    if (player == null)
+    {
+      RagonLog.Warn($"Player with peerId:{newOwnerId} not found in cache");
+      
+      _playerCache.Dump();
+      return;
+    }
 
     _playerCache.OnOwnershipChanged(newOwnerId);
     _listenerList.OnOwnershipChanged(player);

Ragon.Client/Sources/Handler/PlayerJoinHandler.cs

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

Ragon.Client/Sources/Handler/PlayerLeftHandler.cs

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

Ragon.Client/Sources/Handler/RoomDataHandler.cs

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

Ragon.Client/Sources/Handler/RoomEventHandler.cs

@@ -18,11 +18,11 @@ using Ragon.Protocol;
 
 namespace Ragon.Client;
 
-public class RoomEventHandler: IHandler
+public class RoomEventHandler : IHandler
 {
   private readonly RagonClient _client;
   private readonly RagonPlayerCache _playerCache;
-  
+
   public RoomEventHandler(
     RagonClient client,
     RagonPlayerCache playerCache
@@ -31,23 +31,25 @@ public class RoomEventHandler: IHandler
     _client = client;
     _playerCache = playerCache;
   }
-  
+
   public void Handle(RagonBuffer buffer)
   {
     var eventCode = buffer.ReadUShort();
     var peerId = buffer.ReadUShort();
     var executionMode = (RagonReplicationMode)buffer.ReadByte();
-    
+
     var player = _playerCache.GetPlayerByPeer(peerId);
     if (player == null)
     {
-      RagonLog.Warn($"Player not found for event {eventCode}");
+      RagonLog.Error($"Player with peerId:{peerId} not found as owner of event with code:{eventCode}");
+      
+      _playerCache.Dump();
       return;
     }
 
     if (player.IsLocal && executionMode == RagonReplicationMode.LocalAndServer)
       return;
 
-    _client.Room.Event(eventCode, player, buffer); 
+    _client.Room.Event(eventCode, player, buffer);
   }
 }

Ragon.Client/Sources/Handler/SnapshotHandler.cs

@@ -71,6 +71,8 @@ internal class SnapshotHandler : IHandler
       if (player == null)
       {
         RagonLog.Error($"Player not found with peerId: ${ownerPeerId}");
+
+        _playerCache.Dump();
         return;
       }
 
@@ -105,6 +107,8 @@ internal class SnapshotHandler : IHandler
       if (player == null)
       {
         RagonLog.Error($"Player not found with peerId: ${ownerPeerId}");
+        
+        _playerCache.Dump();
         return;
       }
 
@@ -112,7 +116,6 @@ internal class SnapshotHandler : IHandler
       var entity = _entityCache.TryGetEntity(0, entityType, staticId, entityId, hasAuthority, out _);
       
       entity.Prepare(_client, entityId, entityType, hasAuthority, player, RagonPayload.Empty);
-      
       entity.Read(buffer);
       entity.Attach();
     }

Ragon.Client/Sources/RagonPlayerCache.cs

@@ -31,7 +31,7 @@ public sealed class RagonPlayerCache
   {
     if (_playersById.TryGetValue(playerId, out var player))
       return player;
-    
+
     return null;
   }
 
@@ -39,7 +39,7 @@ public sealed class RagonPlayerCache
   {
     if (_playersByConnection.TryGetValue(peerId, out var player))
       return player;
-    
+
     return null;
   }
 
@@ -104,4 +104,14 @@ public sealed class RagonPlayerCache
     _playersByConnection.Clear();
     _playersById.Clear();
   }
+
+  public void Dump()
+  {
+    RagonLog.Trace("Players: ");
+    RagonLog.Trace("[Connection] [ID] [Name]");
+    foreach (var player in _players)
+    {
+      RagonLog.Trace($"[{player.PeerId}] {player.Id} {player.Name}");
+    }
+  }
 }