feat: Room Properties and Player Properties

Ragon.Client/Sources/Handler/PlayerUserDataHandler.cs

@@ -39,9 +39,9 @@ namespace Ragon.Client
 
       if (player != null)
       {
-        player.UserData.Read(reader);
+        var changes = player.UserData.Read(reader);
         
-        _listenerList.OnPlayerUserData(player);
+        _listenerList.OnPlayerUserData(player, changes);
         
         return;
       }

Ragon.Client/Sources/Handler/RoomUserDataHandler.cs

@@ -31,8 +31,8 @@ namespace Ragon.Client
 
     public void Handle(RagonBuffer reader)
     {
-      _client.Room?.HandleUserData(reader);
+      var changes = _client.Room?.UserData.Read(reader);
-      _listenerList.OnRoomUserData();
+      _listenerList.OnRoomUserData(changes);
     }
   }
 }

Ragon.Client/Sources/IUserData.cs

@@ -22,6 +22,6 @@ public interface IUserData
 {
   public byte[] this[string key] { get; set; }
   bool Dirty { get; }
-  void Read(RagonBuffer buffer);
+  IReadOnlyList<string> Read(RagonBuffer buffer);
   void Write(RagonBuffer buffer);
 }

Ragon.Client/Sources/Listener/IRagonPlayerUserDataListener.cs

@@ -18,5 +18,5 @@ namespace Ragon.Client;
 
 public interface IRagonPlayerUserDataListener
 {
-  void OnPlayerUserDataUpdated(RagonClient client, RagonPlayer player);
+  void OnPlayerUserDataUpdated(RagonClient client, RagonPlayer player, IReadOnlyList<string> changes);
 }

Ragon.Client/Sources/Listener/IRagonRoomUserDataListener.cs

@@ -2,5 +2,5 @@ namespace Ragon.Client;
 
 public interface IRagonRoomUserDataListener
 {
-  public void OnUserDataUpdated(RagonClient client);
+  public void OnUserDataUpdated(RagonClient client, IReadOnlyList<string> changes);
 }

Ragon.Client/Sources/RagonListenerList.cs

@@ -307,16 +307,16 @@ namespace Ragon.Client
         listListener.OnRoomListUpdate(roomInfos);
     }
 
-    public void OnRoomUserData()
+    public void OnRoomUserData(IReadOnlyList<string> changes)
     {
       foreach (var userDataListener in _roomUserDataListeners)
-        userDataListener.OnUserDataUpdated(_client);
+        userDataListener.OnUserDataUpdated(_client, changes);
     }
 
-    public void OnPlayerUserData(RagonPlayer player)
+    public void OnPlayerUserData(RagonPlayer player, IReadOnlyList<string> changes)
     {
       foreach(var playerUserDataListener in _playerUserDataListeners)
-        playerUserDataListener.OnPlayerUserDataUpdated(_client, player);
+        playerUserDataListener.OnPlayerUserDataUpdated(_client, player, changes);
     }
   }
 }

Ragon.Client/Sources/RagonUserData.cs

@@ -26,45 +26,81 @@ namespace Ragon.Client
       set
       {
         _properties[key] = value;
-        
+
-        _dirty = true;
+        if (!_changesCache.ContainsKey(key))
+        {
+          _localChanges.Add(key);
+          _changesCache.Add(key, true);
+        }
       }
     }
-    public bool Dirty => _dirty;
+    
+    public void Remove(string key)
+    {
+      if (_properties.Remove(key))
+      {
+        if (!_changesCache.ContainsKey(key))
+        {
+          _localChanges.Add(key);
+          _changesCache.Add(key, true);
+        }
+      }
+    }
+    
+    public bool Dirty => _localChanges.Count > 0;
 
-    private bool _dirty = false;
+    private readonly List<string> _localChanges = new ();
+    private readonly Dictionary<string, bool> _changesCache = new();
     private readonly Dictionary<string, byte[]> _properties = new();
     
     public RagonUserData()
     {
+     
     }
 
-    public void Read(RagonBuffer buffer)
+    public IReadOnlyList<string> Read(RagonBuffer buffer)
     {
-      _properties.Clear();
-      
       var len = buffer.ReadUShort();
+      var changes = new List<string>(len);
       for (int i = 0; i < len; i++)
       {
         var key = buffer.ReadString();
-        var valueSize = buffer.ReadUShort();
+        var valueSize = buffer.ReadUShort();  
-        var value = buffer.ReadBytes(valueSize);
+        if (valueSize > 0)
+        {
+          var value = buffer.ReadBytes(valueSize);
+          _properties[key] = value;
+          
+        }
+        else
+        {
+          _properties.Remove(key);
+        }
+        
+        changes.Add(key);
+      }
 
-        _properties[key] = value;
+      return changes;
-      }  
     }
 
     public void Write(RagonBuffer buffer)
     {
-      buffer.WriteUShort((ushort)_properties.Count);
+      buffer.WriteUShort((ushort)_localChanges.Count);
-      foreach (var property in _properties)
+      foreach (var propertyChanged in _localChanges)
       {
-        buffer.WriteString(property.Key);
+        buffer.WriteString(propertyChanged);
-        buffer.WriteUShort((ushort) property.Value.Length);
+        if (_properties.TryGetValue(propertyChanged, out var property))
-        buffer.WriteBytes(property.Value);
+        {
+          buffer.WriteUShort((ushort) property.Length);
+          buffer.WriteBytes(property);          
+        }
+        else
+        {
+          buffer.WriteUShort(0);
+        }
       }
       
-      _dirty = false;
+      _localChanges.Clear();
     }
   }
 }

Ragon.Client/Sources/RagonUserDataReadOnly.cs

@@ -37,29 +37,31 @@ public class RagonUserDataReadOnly : IUserData
 
   public void Write(RagonBuffer buffer)
   {
-    buffer.WriteUShort((ushort)_properties.Count);
+  
-    foreach (var property in _properties)
-    {
-      buffer.WriteString(property.Key);
-      buffer.WriteUShort((ushort)property.Value.Length);
-      buffer.WriteBytes(property.Value);
-    }
-
-    _dirty = false;
   }
 
-  public void Read(RagonBuffer buffer)
+  public IReadOnlyList<string> Read(RagonBuffer buffer)
   {
-    _properties.Clear();
-
     var len = buffer.ReadUShort();
+    var changes = new List<string>(len);
     for (int i = 0; i < len; i++)
     {
       var key = buffer.ReadString();
-      var valueSize = buffer.ReadUShort();
+      var valueSize = buffer.ReadUShort();  
-      var value = buffer.ReadBytes(valueSize);
+      if (valueSize > 0)
-
+      {
-      _properties[key] = value;
+        var value = buffer.ReadBytes(valueSize);
+        _properties[key] = value;
+          
+      }
+      else
+      {
+        _properties.Remove(key);
+      }
+        
+      changes.Add(key);
     }
+
+    return changes;
   }
 }