Delay buffered field syncing until 200ms pass without further changes

This reduces network traffic while improving UX by ensuring only the
final change is sent. It prevents the field from snapping back to older
values mid-interaction due to intermediate syncs being sent back by
the server.

Author: mibac138

Source/Client/Syncing/Handler/SyncField.cs

@@ -141,21 +141,16 @@ public ISyncField PostApply(Action<object, object> action)
             return this;
         }
 
-        /// Throttles network updates for this field to reduce network chatter. An update
-        /// is sent immediately unless another was already sent within the last 200ms. If
-        /// additional updates occur during that cooldown period, they are not sent
-        /// immediately; only the most recent update is queued and will be sent once the
-        /// 200ms interval has passed. All intermediate updates are discarded.
+        /// Throttles network updates for this field to reduce network chatter.
+        /// An update is sent only after the field has remained unchanged for 200ms.
+        /// If changes continue occurring within that window, the timer resets, and only
+        /// the latest value is eventually sent. All intermediate updates are discarded.
         ///
-        /// The UI reflects the latest value instantly, without waiting for server
-        /// confirmation — avoiding rollback, and re-apply behavior when the server
-        /// responds. However, in some cases the UI may briefly display stale information:
-        /// this can occur when the client sends an update to the host, which then sends a
-        /// confirmation back that overwrites the current client-side value, potentially
-        /// during an ongoing user interaction.
+        /// The UI reflects the latest value immediately, without waiting for server
+        /// confirmation — avoiding rollback, and reapply behavior on server response.
         ///
-        /// This mechanism is typically used for rapidly changing values (e.g., sliders),
-        /// where sending every intermediate update would be inefficient and unnecessary.
+        /// Ideal for rapidly changing fields (e.g., sliders) where sending every
+        /// intermediate value would be inefficient and unnecessary.
         public ISyncField SetBufferChanges()
         {
             SyncFieldUtil.bufferedChanges[this] = new();

Source/Client/Syncing/SyncFieldUtil.cs

@@ -70,6 +70,7 @@ public static void FieldWatchPostfix()
                 if (cachedData != null)
                 {
                     cachedData.sent = false;
+                    cachedData.lastChangedAtMillis = Utils.MillisNow;
                     cachedData.toSend = SnapshotValueIfNeeded(handler, newValue);
                     continue;
                 }
@@ -94,14 +95,13 @@ private static bool SyncPendingAndPruneFinished(BufferTarget target, BufferData
                 return true;
 
             var millisNow = Utils.MillisNow;
-            if (!data.sent && millisNow - data.timestamp > 200)
+            if (!data.sent && millisNow - data.lastChangedAtMillis > 200)
             {
                 // If syncing fails with an exception don't try to reattempt and just give up.
                 if (data.field.DoSyncCatch(target.target, data.toSend, target.index) is false)
                     return true;
 
                 data.sent = true;
-                data.timestamp = millisNow;
             }
 
             return false;
@@ -219,22 +219,15 @@ public override int GetHashCode()
         }
     }
 
-    public class BufferData
+    public class BufferData(SyncField field, object actualValue, object toSend)
     {
-        public SyncField field;
+        public SyncField field = field;
         /// This is the real field's value. If this were an unbuffered field, it'd be equivalent to `FieldData.oldValue`,
         /// however for buffered fields `oldValue` reflects the value prior to the last GUI update. Use this field to
         /// access the original value before any user interaction occurred.
-        public object actualValue;
-        public object toSend;
-        public long timestamp;
+        public object actualValue = actualValue;
+        public object toSend = toSend;
+        public long lastChangedAtMillis = Utils.MillisNow;
         public bool sent;
-
-        public BufferData(SyncField field, object actualValue, object toSend)
-        {
-            this.field = field;
-            this.actualValue = actualValue;
-            this.toSend = toSend;
-        }
     }
 }