Implement archive-based serialization for PropertyCollection

Author: Crypto137

src/MHServerEmu.Games/Common/Serializer.cs

@@ -140,25 +140,6 @@ public static bool Transfer(Archive archive, ref PropertyId ioData)
             return success;
         }
 
-        public static bool Transfer(Archive archive, ref PropertyValue ioData)
-        {
-            bool success = true;
-
-            if (archive.IsPacking)
-            {
-                ulong value = ioData;
-                success &= Transfer(archive, ref value);
-            }
-            else
-            {
-                ulong value = 0;
-                success &= Transfer(archive, ref value);
-                ioData = value;
-            }
-
-            return success;
-        }
-
         // Other
 
         public static bool Transfer(Archive archive, ref TimeSpan ioData)

src/MHServerEmu.Games/Properties/PropertyCollection.cs

@@ -2,7 +2,9 @@
 using Google.ProtocolBuffers;
 using MHServerEmu.Core.Extensions;
 using MHServerEmu.Core.Logging;
+using MHServerEmu.Core.Serialization;
 using MHServerEmu.Core.VectorMath;
+using MHServerEmu.Games.Common;
 using MHServerEmu.Games.GameData;
 using MHServerEmu.Games.GameData.Calligraphy;
 using MHServerEmu.Games.GameData.Prototypes;
@@ -12,7 +14,7 @@ namespace MHServerEmu.Games.Properties
     /// <summary>
     /// An aggregatable collection of key/value pairs of <see cref="PropertyId"/> and <see cref="PropertyValue"/>.
     /// </summary>
-    public class PropertyCollection : IEnumerable<KeyValuePair<PropertyId, PropertyValue>>
+    public class PropertyCollection : IEnumerable<KeyValuePair<PropertyId, PropertyValue>>, ISerialize
     {
         // TODO: Eval
         // TODO: PropertyChangeWatcher API: AttachWatcher(), RemoveWatcher(), RemoveAllWatchers()
@@ -25,7 +27,7 @@ public class PropertyCollection : IEnumerable<KeyValuePair<PropertyId, PropertyV
         private readonly Dictionary<PropertyId, CurveProperty> _curveList = new();
 
         // Parent and child collections
-        // NOTE: The client uses a tabletree structure to store those with PropertyCollection as key and an empty struct called EmptyDummyValue as value.
+        // NOTE: The client uses a tabletree structure to store these with PropertyCollection as key and an empty struct called EmptyDummyValue as value.
         // I'm not sure what the intention there was, but it makes zero sense for us to do it the same way.
         private readonly HashSet<PropertyCollection> _parentCollections = new();
         private readonly HashSet<PropertyCollection> _childCollections = new();
@@ -399,7 +401,52 @@ public bool RemoveFromParent(PropertyCollection parentCollection)
 
         #endregion
 
-        // TODO: PropertyCollection::serializeWithDefault
+        public virtual bool Serialize(Archive archive)
+        {
+            return SerializeWithDefault(archive, null);
+        }
+
+        public virtual bool SerializeWithDefault(Archive archive, PropertyCollection defaultCollection)
+        {
+            bool success = true;
+
+            // TODO: skip properties that match the default collection
+
+            if (archive.IsPacking)
+            {
+                // NOTE: PropertyCollection::serializeWithDefault() does a weird thing where it manipulates the archive buffer directly.
+                // First it allocates 4 bytes for the number of properties, than it writes all the properties, and then it goes back
+                // and updates the number. This is most likely a side effect of not all properties being saved to the database in the
+                // original implementation.
+                archive.WriteUnencodedStream((uint)_baseList.Count);
+
+                foreach (var kvp in _baseList)
+                    success &= SerializePropertyForPacking(kvp, archive, defaultCollection);
+            }
+            else
+            {
+                uint numProperties = 0;
+                success &= archive.ReadUnencodedStream(ref numProperties);
+
+                for (uint i = 0; i < numProperties; i++)
+                {
+                    PropertyId id = new();
+                    success &= Serializer.Transfer(archive, ref id);
+
+                    PropertyInfo info = GameDatabase.PropertyInfoTable.LookupPropertyInfo(id.Enum);
+
+                    ulong bits = 0;
+                    success &= Serializer.Transfer(archive, ref bits);
+
+                    if (success)
+                        SetPropertyValue(id, ConvertBitsToValue(bits, info.DataType));
+                }
+            }
+
+            return success;
+        }
+
+        #region REMOVEME: Old Serialization
 
         /// <summary>
         /// Decodes <see cref="PropertyCollection"/> data from a <see cref="CodedInputStream"/>.
@@ -423,9 +470,24 @@ public virtual void Encode(CodedOutputStream stream)
         {
             stream.WriteRawUInt32((uint)_baseList.Count);
             foreach (var kvp in _baseList)
-                SerializePropertyForPacking(kvp, stream);
+                OLD_SerializePropertyForPacking(kvp, stream);
+        }
+
+        /// <summary>
+        /// Serializes a key/value pair of <see cref="PropertyId"/> and <see cref="PropertyValue"/> to a <see cref="CodedOutputStream"/>.
+        /// </summary>
+        protected static bool OLD_SerializePropertyForPacking(KeyValuePair<PropertyId, PropertyValue> kvp, CodedOutputStream stream)
+        {
+            // TODO: Serialize only properties that are different from the base collection for replication 
+            PropertyInfo info = GameDatabase.PropertyInfoTable.LookupPropertyInfo(kvp.Key.Enum);
+            ulong valueBits = ConvertValueToBits(kvp.Value, info.DataType);
+            stream.WriteRawVarint64(kvp.Key.Raw.ReverseBytes());
+            stream.WriteRawVarint64(valueBits);
+            return true;
         }
 
+        #endregion
+
         /// <summary>
         /// Returns the <see cref="PropertyValue"/> with the specified <see cref="PropertyId"/>.
         /// Falls back to the default value for the property if this <see cref="PropertyCollection"/> does not contain it.
@@ -474,17 +536,19 @@ protected bool SetPropertyValue(PropertyId id, PropertyValue value, SetPropertyF
             return hasChanged || flags.HasFlag(SetPropertyFlags.Flag2);  // Some kind of flag that forces property value update
         }
 
-        /// <summary>
-        /// Serializes a key/value pair of <see cref="PropertyId"/> and <see cref="PropertyValue"/> to a <see cref="CodedOutputStream"/>.
-        /// </summary>
-        protected static bool SerializePropertyForPacking(KeyValuePair<PropertyId, PropertyValue> kvp, CodedOutputStream stream)
+        protected static bool SerializePropertyForPacking(KeyValuePair<PropertyId, PropertyValue> kvp, Archive archive, PropertyCollection defaultCollection)
         {
+            bool success = true;
+
             // TODO: Serialize only properties that are different from the base collection for replication 
             PropertyInfo info = GameDatabase.PropertyInfoTable.LookupPropertyInfo(kvp.Key.Enum);
-            ulong valueBits = ConvertValueToBits(kvp.Value, info.DataType);
-            stream.WriteRawVarint64(kvp.Key.Raw.ReverseBytes());    // Id is reversed so that it can be efficiently encoded into varint when all params are 0
-            stream.WriteRawVarint64(valueBits);
-            return true;
+
+            ulong id = kvp.Key.Raw.ReverseBytes();  // Id is reversed so that it can be efficiently encoded into varint when all params are 0
+            ulong value = ConvertValueToBits(kvp.Value, info.DataType);
+            success &= Serializer.Transfer(archive, ref id);
+            success &= Serializer.Transfer(archive, ref value);
+
+            return success;
         }
 
         // TODO: make value <-> bits conversion protected once we no longer need it for hacks

src/MHServerEmu.Games/Properties/ReplicatedPropertyCollection.cs

@@ -1,34 +1,53 @@
 using System.Text;
 using Google.ProtocolBuffers;
+using MHServerEmu.Core.Serialization;
+using MHServerEmu.Games.Common;
 using MHServerEmu.Games.Network;
 
 namespace MHServerEmu.Games.Properties
 {
     public class ReplicatedPropertyCollection : PropertyCollection, IArchiveMessageHandler
     {
-        public ulong ReplicationId { get; set; }
+        private ulong _replicationId;
+
+        public ulong ReplicationId { get => _replicationId; set => _replicationId = value; }
+
+        public ReplicatedPropertyCollection(ulong replicationId = 0)
+        {
+            _replicationId = replicationId;
+        }
 
         public ReplicatedPropertyCollection(CodedInputStream stream)
         {
-            ReplicationId = stream.ReadRawVarint64();
+            _replicationId = stream.ReadRawVarint64();
             Decode(stream);
         }
 
-        public ReplicatedPropertyCollection(ulong replicationId = 0)
+        public override bool SerializeWithDefault(Archive archive, PropertyCollection defaultCollection)
         {
-            ReplicationId = replicationId;
+            bool success = true;
+
+            // ArchiveMessageHandler::Serialize() -> move this to a common helper class?
+            if (archive.IsReplication)
+            {
+                success &= Serializer.Transfer(archive, ref _replicationId);
+                // TODO: register message dispatcher
+            }
+            
+            success &= base.SerializeWithDefault(archive, defaultCollection);
+            return success;
         }
 
         public override void Encode(CodedOutputStream stream)
         {
-            stream.WriteRawVarint64(ReplicationId);
+            stream.WriteRawVarint64(_replicationId);
             base.Encode(stream);
         }
 
         public override string ToString()
         {
             StringBuilder sb = new();
-            sb.AppendLine($"{nameof(ReplicationId)}: {ReplicationId}");
+            sb.AppendLine($"{nameof(_replicationId)}: {_replicationId}");
             sb.Append(base.ToString());
             return sb.ToString();
         }