feat: add sync elements debugging codes

insthync · insthync · commit ab49b92108c0 · 2025-09-02T22:24:11.000+07:00
diff --git a/Scripts/GameApi/LiteNetLibElement.cs b/Scripts/GameApi/LiteNetLibElement.cs
@@ -96,7 +96,7 @@ public int ElementId
             get { return _elementId; }
         }
 
-        public string logTagName;
+        public string logTagName = null;
         public virtual string LogTag
         {
             get
@@ -123,6 +123,8 @@ public virtual string LogTag
             }
         }
 
+        public bool isDebug = false;
+
         public LiteNetLibElementInfo GetInfo()
         {
             return new LiteNetLibElementInfo()
diff --git a/Scripts/GameApi/LiteNetLibGameManager.cs b/Scripts/GameApi/LiteNetLibGameManager.cs
@@ -1207,7 +1207,8 @@ protected LiteNetLibIdentity SpawnPlayer(long connectionId, int hashAssetId)
         #region Game State Syncing
         private void WriteSyncElement(NetDataWriter writer, LiteNetLibSyncElement syncElement)
         {
-            writer.PutPackedUInt(Tick);
+            uint tick = Tick;
+            writer.PutPackedUInt(tick);
             writer.PutPackedUInt(syncElement.ObjectId);
             writer.PutPackedInt(syncElement.ElementId);
             if (safeGameStatePacket)
@@ -1218,7 +1219,7 @@ private void WriteSyncElement(NetDataWriter writer, LiteNetLibSyncElement syncEl
                 writer.Put(dataLength);
                 int posAfterWriteDataLen = writer.Length;
                 // Write sync data
-                syncElement.WriteSyncData(false, writer);
+                syncElement.WriteSyncData(false, tick, false, writer);
                 dataLength = writer.Length - posAfterWriteDataLen;
                 // Put data length
                 int posAfterWriteData = writer.Length;
@@ -1228,7 +1229,7 @@ private void WriteSyncElement(NetDataWriter writer, LiteNetLibSyncElement syncEl
             }
             else
             {
-                syncElement.WriteSyncData(false, writer);
+                syncElement.WriteSyncData(false, tick, false, writer);
             }
         }
 
@@ -1248,7 +1249,7 @@ private bool ReadSyncElement(NetDataReader reader)
                 {
                     try
                     {
-                        element.ReadSyncData(tick, false, reader);
+                        element.ReadSyncData(false, tick, false, reader);
                     }
                     catch
                     {
@@ -1270,7 +1271,7 @@ private bool ReadSyncElement(NetDataReader reader)
                 {
                     try
                     {
-                        element.ReadSyncData(tick, false, reader);
+                        element.ReadSyncData(false, tick, false, reader);
                     }
                     catch
                     {
@@ -1289,7 +1290,8 @@ private bool ReadSyncElement(NetDataReader reader)
 
         private int WriteGameStateFromServer(NetDataWriter writer, LiteNetLibPlayer player, Dictionary<uint, GameStateSyncData> syncingStatesByObjectIds)
         {
-            writer.PutPackedUInt(Tick);
+            uint tick = Tick;
+            writer.PutPackedUInt(tick);
             // Reserve position for state length
             int posBeforeWriteStateCount = writer.Length;
             int stateCount = 0;
@@ -1308,7 +1310,7 @@ private int WriteGameStateFromServer(NetDataWriter writer, LiteNetLibPlayer play
                         if (Assets.TryGetSpawnedObject(objectId, out identity) && identity != null && identity.transform != null)
                         {
                             writer.Put(GameStateSyncData.STATE_TYPE_SPAWN);
-                            WriteSpawnGameState(writer, player, identity, syncingStatesByObjectId.Value);
+                            WriteSpawnGameState(writer, player, identity, syncingStatesByObjectId.Value, tick);
                             // TODO: Move this to somewhere else
                             if (player.ConnectionId == ClientConnectionId)
                             {
@@ -1323,7 +1325,7 @@ private int WriteGameStateFromServer(NetDataWriter writer, LiteNetLibPlayer play
                         if (Assets.TryGetSpawnedObject(objectId, out identity) && identity != null && identity.transform != null)
                         {
                             writer.Put(GameStateSyncData.STATE_TYPE_SYNC);
-                            WriteSyncGameState(writer, objectId, syncingStatesByObjectId.Value);
+                            WriteSyncGameState(writer, objectId, syncingStatesByObjectId.Value, tick);
                             ++stateCount;
                         }
                         break;
@@ -1353,7 +1355,8 @@ private int WriteGameStateFromServer(NetDataWriter writer, LiteNetLibPlayer play
 
         private int WriteGameStateFromClient(NetDataWriter writer, byte syncChannelId, Dictionary<uint, GameStateSyncData> syncingStatesByObjectIds)
         {
-            writer.PutPackedUInt(Tick);
+            uint tick = Tick;
+            writer.PutPackedUInt(tick);
             // Reserve position for state length
             int posBeforeWriteStateCount = writer.Length;
             int stateCount = 0;
@@ -1367,7 +1370,7 @@ private int WriteGameStateFromClient(NetDataWriter writer, byte syncChannelId, D
                 switch (syncingStatesByObjectId.Value.StateType)
                 {
                     case GameStateSyncData.STATE_TYPE_SYNC:
-                        WriteSyncGameState(writer, objectId, syncingStatesByObjectId.Value);
+                        WriteSyncGameState(writer, objectId, syncingStatesByObjectId.Value, tick);
                         ++stateCount;
                         break;
                 }
@@ -1417,7 +1420,7 @@ private void ReadGameStateFromClient(NetDataReader reader)
             }
         }
 
-        private void WriteSpawnGameState(NetDataWriter writer, LiteNetLibPlayer player, LiteNetLibIdentity identity, GameStateSyncData syncData)
+        private void WriteSpawnGameState(NetDataWriter writer, LiteNetLibPlayer player, LiteNetLibIdentity identity, GameStateSyncData syncData, uint tick)
         {
             writer.Put(identity.IsSceneObject);
             if (identity.IsSceneObject)
@@ -1439,7 +1442,7 @@ private void WriteSpawnGameState(NetDataWriter writer, LiteNetLibPlayer player,
                     continue;
                 syncData.SyncElements.Add(syncElement);
             }
-            WriteSyncElements(writer, syncData.SyncElements, true);
+            WriteSyncElements(writer, syncData.SyncElements, tick, true);
             syncData.SyncElements.Clear();
         }
 
@@ -1494,10 +1497,10 @@ private bool ReadSpawnGameState(NetDataReader reader, uint tick)
             return false;
         }
 
-        private void WriteSyncGameState(NetDataWriter writer, uint objectId, GameStateSyncData syncData)
+        private void WriteSyncGameState(NetDataWriter writer, uint objectId, GameStateSyncData syncData, uint tick)
         {
             writer.PutPackedUInt(objectId);
-            WriteSyncElements(writer, syncData.SyncElements, false);
+            WriteSyncElements(writer, syncData.SyncElements, tick, false);
             syncData.SyncElements.Clear();
         }
 
@@ -1523,7 +1526,7 @@ private bool ReadDestroyGameState(NetDataReader reader)
             return true;
         }
 
-        private void WriteSyncElements(NetDataWriter writer, ICollection<LiteNetLibSyncElement> elements, bool initial)
+        private void WriteSyncElements(NetDataWriter writer, ICollection<LiteNetLibSyncElement> elements, uint tick, bool initial)
         {
             writer.PutPackedInt(elements.Count);
             if (elements.Count == 0)
@@ -1540,7 +1543,7 @@ private void WriteSyncElements(NetDataWriter writer, ICollection<LiteNetLibSyncE
                     writer.Put(dataLength);
                     int posAfterWriteDataLen = writer.Length;
                     // Write sync data
-                    syncElement.WriteSyncData(initial, writer);
+                    syncElement.WriteSyncData(true, tick, initial, writer);
                     dataLength = writer.Length - posAfterWriteDataLen;
                     // Put data length
                     int posAfterWriteData = writer.Length;
@@ -1550,7 +1553,7 @@ private void WriteSyncElements(NetDataWriter writer, ICollection<LiteNetLibSyncE
                 }
                 else
                 {
-                    syncElement.WriteSyncData(initial, writer);
+                    syncElement.WriteSyncData(true, tick, initial, writer);
                 }
             }
         }
@@ -1572,7 +1575,7 @@ private bool ReadSyncElements(NetDataReader reader, LiteNetLibIdentity identity,
                     {
                         try
                         {
-                            element.ReadSyncData(tick, initial, reader);
+                            element.ReadSyncData(true, tick, initial, reader);
                         }
                         catch
                         {
@@ -1594,7 +1597,7 @@ private bool ReadSyncElements(NetDataReader reader, LiteNetLibIdentity identity,
                     {
                         try
                         {
-                            element.ReadSyncData(tick, initial, reader);
+                            element.ReadSyncData(true, tick, initial, reader);
                         }
                         catch
                         {
diff --git a/Scripts/GameApi/LiteNetLibSyncElement.cs b/Scripts/GameApi/LiteNetLibSyncElement.cs
@@ -41,8 +41,8 @@ internal virtual bool WillSyncFromOwnerClientUnreliably(uint tick)
         }
 
         internal abstract void Reset();
-        internal abstract void WriteSyncData(bool initial, NetDataWriter writer);
-        internal abstract void ReadSyncData(uint tick, bool initial, NetDataReader reader);
+        internal abstract void WriteSyncData(bool isState, uint tick, bool initial, NetDataWriter writer);
+        internal abstract void ReadSyncData(bool isState, uint tick, bool initial, NetDataReader reader);
 
         public void RegisterUpdating()
         {
diff --git a/Scripts/GameApi/LiteNetLibSyncField.cs b/Scripts/GameApi/LiteNetLibSyncField.cs
@@ -161,12 +161,14 @@ internal override sealed void Setup(LiteNetLibBehaviour behaviour, int elementId
             }
         }
 
-        internal override void WriteSyncData(bool initial, NetDataWriter writer)
+        internal override void WriteSyncData(bool isState, uint tick, bool initial, NetDataWriter writer)
         {
+            if (isDebug)
+                Logging.Log(LogTag, $"Write sync data, syncMode {syncMode}, connectionId {ConnectionId}, isOwnerClient {IsOwnerClient}, objectId {ObjectId}, isState {isState}, tick {tick}, initial {initial}, value {GetValue()}");
             SerializeValue(writer);
         }
 
-        internal override void ReadSyncData(uint tick, bool initial, NetDataReader reader)
+        internal override void ReadSyncData(bool isState, uint tick, bool initial, NetDataReader reader)
         {
             object oldValue = GetValue();
             DeserializeValue(reader);
@@ -177,6 +179,8 @@ internal override void ReadSyncData(uint tick, bool initial, NetDataReader reade
                 return;
             }
             _latestReceiveTick = tick;
+            if (isDebug)
+                Logging.Log(LogTag, $"Read sync data, syncMode {syncMode}, connectionId {ConnectionId}, isOwnerClient {IsOwnerClient}, objectId {ObjectId}, isState {isState}, tick {tick}, initial {initial}, oldValue {oldValue}, newValue {GetValue()}");
             OnChange(initial, oldValue, GetValue());
             if (syncMode == LiteNetLibSyncFieldMode.ClientMulticast && IsServer)
                 ValueChangedState(true);
diff --git a/Scripts/GameApi/LiteNetLibSyncList.cs b/Scripts/GameApi/LiteNetLibSyncList.cs
@@ -313,7 +313,7 @@ private void RemoveDirtyOperations(List<OperationEntry> operationEntries, int in
             }
         }
 
-        internal override void WriteSyncData(bool initial, NetDataWriter writer)
+        internal override void WriteSyncData(bool isState, uint tick, bool initial, NetDataWriter writer)
         {
             if (initial)
             {
@@ -338,7 +338,7 @@ internal override void WriteSyncData(bool initial, NetDataWriter writer)
             }
         }
 
-        internal override void ReadSyncData(uint tick, bool initial, NetDataReader reader)
+        internal override void ReadSyncData(bool isState, uint tick, bool initial, NetDataReader reader)
         {
             if (initial)
             {

Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ public int ElementId`
`96`	`96`	`get { return _elementId; }`
`97`	`97`	`}`
`98`	`98`
`99`		`- public string logTagName;`
	`99`	`+ public string logTagName = null;`
`100`	`100`	`public virtual string LogTag`
`101`	`101`	`{`
`102`	`102`	`get`
`@@ -123,6 +123,8 @@ public virtual string LogTag`
`123`	`123`	`}`
`124`	`124`	`}`
`125`	`125`
	`126`	`+ public bool isDebug = false;`
	`127`	`+`
`126`	`128`	`public LiteNetLibElementInfo GetInfo()`
`127`	`129`	`{`
`128`	`130`	`return new LiteNetLibElementInfo()`
Original file line number	Diff line number	Diff line change
`@@ -1207,7 +1207,8 @@ protected LiteNetLibIdentity SpawnPlayer(long connectionId, int hashAssetId)`
`1207`	`1207`	`#region Game State Syncing`
`1208`	`1208`	`private void WriteSyncElement(NetDataWriter writer, LiteNetLibSyncElement syncElement)`
`1209`	`1209`	`{`
`1210`		`- writer.PutPackedUInt(Tick);`
	`1210`	`+ uint tick = Tick;`
	`1211`	`+ writer.PutPackedUInt(tick);`
`1211`	`1212`	`writer.PutPackedUInt(syncElement.ObjectId);`
`1212`	`1213`	`writer.PutPackedInt(syncElement.ElementId);`
`1213`	`1214`	`if (safeGameStatePacket)`
`@@ -1218,7 +1219,7 @@ private void WriteSyncElement(NetDataWriter writer, LiteNetLibSyncElement syncEl`
`1218`	`1219`	`writer.Put(dataLength);`
`1219`	`1220`	`int posAfterWriteDataLen = writer.Length;`
`1220`	`1221`	`// Write sync data`
`1221`		`- syncElement.WriteSyncData(false, writer);`
	`1222`	`+ syncElement.WriteSyncData(false, tick, false, writer);`
`1222`	`1223`	`dataLength = writer.Length - posAfterWriteDataLen;`
`1223`	`1224`	`// Put data length`
`1224`	`1225`	`int posAfterWriteData = writer.Length;`
`@@ -1228,7 +1229,7 @@ private void WriteSyncElement(NetDataWriter writer, LiteNetLibSyncElement syncEl`
`1228`	`1229`	`}`
`1229`	`1230`	`else`
`1230`	`1231`	`{`
`1231`		`- syncElement.WriteSyncData(false, writer);`
	`1232`	`+ syncElement.WriteSyncData(false, tick, false, writer);`
`1232`	`1233`	`}`
`1233`	`1234`	`}`
`1234`	`1235`
`@@ -1248,7 +1249,7 @@ private bool ReadSyncElement(NetDataReader reader)`
`1248`	`1249`	`{`
`1249`	`1250`	`try`
`1250`	`1251`	`{`
`1251`		`- element.ReadSyncData(tick, false, reader);`
	`1252`	`+ element.ReadSyncData(false, tick, false, reader);`
`1252`	`1253`	`}`
`1253`	`1254`	`catch`
`1254`	`1255`	`{`
`@@ -1270,7 +1271,7 @@ private bool ReadSyncElement(NetDataReader reader)`
`1270`	`1271`	`{`
`1271`	`1272`	`try`
`1272`	`1273`	`{`
`1273`		`- element.ReadSyncData(tick, false, reader);`
	`1274`	`+ element.ReadSyncData(false, tick, false, reader);`
`1274`	`1275`	`}`
`1275`	`1276`	`catch`
`1276`	`1277`	`{`
`@@ -1289,7 +1290,8 @@ private bool ReadSyncElement(NetDataReader reader)`
`1289`	`1290`
`1290`	`1291`	`private int WriteGameStateFromServer(NetDataWriter writer, LiteNetLibPlayer player, Dictionary<uint, GameStateSyncData> syncingStatesByObjectIds)`
`1291`	`1292`	`{`
`1292`		`- writer.PutPackedUInt(Tick);`
	`1293`	`+ uint tick = Tick;`
	`1294`	`+ writer.PutPackedUInt(tick);`
`1293`	`1295`	`// Reserve position for state length`
`1294`	`1296`	`int posBeforeWriteStateCount = writer.Length;`
`1295`	`1297`	`int stateCount = 0;`
`@@ -1308,7 +1310,7 @@ private int WriteGameStateFromServer(NetDataWriter writer, LiteNetLibPlayer play`
`1308`	`1310`	`if (Assets.TryGetSpawnedObject(objectId, out identity) && identity != null && identity.transform != null)`
`1309`	`1311`	`{`
`1310`	`1312`	`writer.Put(GameStateSyncData.STATE_TYPE_SPAWN);`
`1311`		`- WriteSpawnGameState(writer, player, identity, syncingStatesByObjectId.Value);`
	`1313`	`+ WriteSpawnGameState(writer, player, identity, syncingStatesByObjectId.Value, tick);`
`1312`	`1314`	`// TODO: Move this to somewhere else`
`1313`	`1315`	`if (player.ConnectionId == ClientConnectionId)`
`1314`	`1316`	`{`
`@@ -1323,7 +1325,7 @@ private int WriteGameStateFromServer(NetDataWriter writer, LiteNetLibPlayer play`
`1323`	`1325`	`if (Assets.TryGetSpawnedObject(objectId, out identity) && identity != null && identity.transform != null)`
`1324`	`1326`	`{`
`1325`	`1327`	`writer.Put(GameStateSyncData.STATE_TYPE_SYNC);`
`1326`		`- WriteSyncGameState(writer, objectId, syncingStatesByObjectId.Value);`
	`1328`	`+ WriteSyncGameState(writer, objectId, syncingStatesByObjectId.Value, tick);`
`1327`	`1329`	`++stateCount;`
`1328`	`1330`	`}`
`1329`	`1331`	`break;`
`@@ -1353,7 +1355,8 @@ private int WriteGameStateFromServer(NetDataWriter writer, LiteNetLibPlayer play`
`1353`	`1355`
`1354`	`1356`	`private int WriteGameStateFromClient(NetDataWriter writer, byte syncChannelId, Dictionary<uint, GameStateSyncData> syncingStatesByObjectIds)`
`1355`	`1357`	`{`
`1356`		`- writer.PutPackedUInt(Tick);`
	`1358`	`+ uint tick = Tick;`
	`1359`	`+ writer.PutPackedUInt(tick);`
`1357`	`1360`	`// Reserve position for state length`
`1358`	`1361`	`int posBeforeWriteStateCount = writer.Length;`
`1359`	`1362`	`int stateCount = 0;`
`@@ -1367,7 +1370,7 @@ private int WriteGameStateFromClient(NetDataWriter writer, byte syncChannelId, D`
`1367`	`1370`	`switch (syncingStatesByObjectId.Value.StateType)`
`1368`	`1371`	`{`
`1369`	`1372`	`case GameStateSyncData.STATE_TYPE_SYNC:`
`1370`		`- WriteSyncGameState(writer, objectId, syncingStatesByObjectId.Value);`
	`1373`	`+ WriteSyncGameState(writer, objectId, syncingStatesByObjectId.Value, tick);`
`1371`	`1374`	`++stateCount;`
`1372`	`1375`	`break;`
`1373`	`1376`	`}`
`@@ -1417,7 +1420,7 @@ private void ReadGameStateFromClient(NetDataReader reader)`
`1417`	`1420`	`}`
`1418`	`1421`	`}`
`1419`	`1422`
`1420`		`- private void WriteSpawnGameState(NetDataWriter writer, LiteNetLibPlayer player, LiteNetLibIdentity identity, GameStateSyncData syncData)`
	`1423`	`+ private void WriteSpawnGameState(NetDataWriter writer, LiteNetLibPlayer player, LiteNetLibIdentity identity, GameStateSyncData syncData, uint tick)`
`1421`	`1424`	`{`
`1422`	`1425`	`writer.Put(identity.IsSceneObject);`
`1423`	`1426`	`if (identity.IsSceneObject)`
`@@ -1439,7 +1442,7 @@ private void WriteSpawnGameState(NetDataWriter writer, LiteNetLibPlayer player,`
`1439`	`1442`	`continue;`
`1440`	`1443`	`syncData.SyncElements.Add(syncElement);`
`1441`	`1444`	`}`
`1442`		`- WriteSyncElements(writer, syncData.SyncElements, true);`
	`1445`	`+ WriteSyncElements(writer, syncData.SyncElements, tick, true);`
`1443`	`1446`	`syncData.SyncElements.Clear();`
`1444`	`1447`	`}`
`1445`	`1448`
`@@ -1494,10 +1497,10 @@ private bool ReadSpawnGameState(NetDataReader reader, uint tick)`
`1494`	`1497`	`return false;`
`1495`	`1498`	`}`
`1496`	`1499`
`1497`		`- private void WriteSyncGameState(NetDataWriter writer, uint objectId, GameStateSyncData syncData)`
	`1500`	`+ private void WriteSyncGameState(NetDataWriter writer, uint objectId, GameStateSyncData syncData, uint tick)`
`1498`	`1501`	`{`
`1499`	`1502`	`writer.PutPackedUInt(objectId);`
`1500`		`- WriteSyncElements(writer, syncData.SyncElements, false);`
	`1503`	`+ WriteSyncElements(writer, syncData.SyncElements, tick, false);`
`1501`	`1504`	`syncData.SyncElements.Clear();`
`1502`	`1505`	`}`
`1503`	`1506`
`@@ -1523,7 +1526,7 @@ private bool ReadDestroyGameState(NetDataReader reader)`
`1523`	`1526`	`return true;`
`1524`	`1527`	`}`
`1525`	`1528`
`1526`		`- private void WriteSyncElements(NetDataWriter writer, ICollection<LiteNetLibSyncElement> elements, bool initial)`
	`1529`	`+ private void WriteSyncElements(NetDataWriter writer, ICollection<LiteNetLibSyncElement> elements, uint tick, bool initial)`
`1527`	`1530`	`{`
`1528`	`1531`	`writer.PutPackedInt(elements.Count);`
`1529`	`1532`	`if (elements.Count == 0)`
`@@ -1540,7 +1543,7 @@ private void WriteSyncElements(NetDataWriter writer, ICollection<LiteNetLibSyncE`
`1540`	`1543`	`writer.Put(dataLength);`
`1541`	`1544`	`int posAfterWriteDataLen = writer.Length;`
`1542`	`1545`	`// Write sync data`
`1543`		`- syncElement.WriteSyncData(initial, writer);`
	`1546`	`+ syncElement.WriteSyncData(true, tick, initial, writer);`
`1544`	`1547`	`dataLength = writer.Length - posAfterWriteDataLen;`
`1545`	`1548`	`// Put data length`
`1546`	`1549`	`int posAfterWriteData = writer.Length;`
`@@ -1550,7 +1553,7 @@ private void WriteSyncElements(NetDataWriter writer, ICollection<LiteNetLibSyncE`
`1550`	`1553`	`}`
`1551`	`1554`	`else`
`1552`	`1555`	`{`
`1553`		`- syncElement.WriteSyncData(initial, writer);`
	`1556`	`+ syncElement.WriteSyncData(true, tick, initial, writer);`
`1554`	`1557`	`}`
`1555`	`1558`	`}`
`1556`	`1559`	`}`
`@@ -1572,7 +1575,7 @@ private bool ReadSyncElements(NetDataReader reader, LiteNetLibIdentity identity,`
`1572`	`1575`	`{`
`1573`	`1576`	`try`
`1574`	`1577`	`{`
`1575`		`- element.ReadSyncData(tick, initial, reader);`
	`1578`	`+ element.ReadSyncData(true, tick, initial, reader);`
`1576`	`1579`	`}`
`1577`	`1580`	`catch`
`1578`	`1581`	`{`
`@@ -1594,7 +1597,7 @@ private bool ReadSyncElements(NetDataReader reader, LiteNetLibIdentity identity,`
`1594`	`1597`	`{`
`1595`	`1598`	`try`
`1596`	`1599`	`{`
`1597`		`- element.ReadSyncData(tick, initial, reader);`
	`1600`	`+ element.ReadSyncData(true, tick, initial, reader);`
`1598`	`1601`	`}`
`1599`	`1602`	`catch`
`1600`	`1603`	`{`
Original file line number	Diff line number	Diff line change
`@@ -41,8 +41,8 @@ internal virtual bool WillSyncFromOwnerClientUnreliably(uint tick)`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`internal abstract void Reset();`
`44`		`- internal abstract void WriteSyncData(bool initial, NetDataWriter writer);`
`45`		`- internal abstract void ReadSyncData(uint tick, bool initial, NetDataReader reader);`
	`44`	`+ internal abstract void WriteSyncData(bool isState, uint tick, bool initial, NetDataWriter writer);`
	`45`	`+ internal abstract void ReadSyncData(bool isState, uint tick, bool initial, NetDataReader reader);`
`46`	`46`
`47`	`47`	`public void RegisterUpdating()`
`48`	`48`	`{`
Original file line number	Diff line number	Diff line change
`@@ -161,12 +161,14 @@ internal override sealed void Setup(LiteNetLibBehaviour behaviour, int elementId`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`
`164`		`- internal override void WriteSyncData(bool initial, NetDataWriter writer)`
	`164`	`+ internal override void WriteSyncData(bool isState, uint tick, bool initial, NetDataWriter writer)`
`165`	`165`	`{`
	`166`	`+ if (isDebug)`
	`167`	`+ Logging.Log(LogTag, $"Write sync data, syncMode {syncMode}, connectionId {ConnectionId}, isOwnerClient {IsOwnerClient}, objectId {ObjectId}, isState {isState}, tick {tick}, initial {initial}, value {GetValue()}");`
`166`	`168`	`SerializeValue(writer);`
`167`	`169`	`}`
`168`	`170`
`169`		`- internal override void ReadSyncData(uint tick, bool initial, NetDataReader reader)`
	`171`	`+ internal override void ReadSyncData(bool isState, uint tick, bool initial, NetDataReader reader)`
`170`	`172`	`{`
`171`	`173`	`object oldValue = GetValue();`
`172`	`174`	`DeserializeValue(reader);`
`@@ -177,6 +179,8 @@ internal override void ReadSyncData(uint tick, bool initial, NetDataReader reade`
`177`	`179`	`return;`
`178`	`180`	`}`
`179`	`181`	`_latestReceiveTick = tick;`
	`182`	`+ if (isDebug)`
	`183`	`+ Logging.Log(LogTag, $"Read sync data, syncMode {syncMode}, connectionId {ConnectionId}, isOwnerClient {IsOwnerClient}, objectId {ObjectId}, isState {isState}, tick {tick}, initial {initial}, oldValue {oldValue}, newValue {GetValue()}");`
`180`	`184`	`OnChange(initial, oldValue, GetValue());`
`181`	`185`	`if (syncMode == LiteNetLibSyncFieldMode.ClientMulticast && IsServer)`
`182`	`186`	`ValueChangedState(true);`
Original file line number	Diff line number	Diff line change
`@@ -313,7 +313,7 @@ private void RemoveDirtyOperations(List<OperationEntry> operationEntries, int in`
`313`	`313`	`}`
`314`	`314`	`}`
`315`	`315`
`316`		`- internal override void WriteSyncData(bool initial, NetDataWriter writer)`
	`316`	`+ internal override void WriteSyncData(bool isState, uint tick, bool initial, NetDataWriter writer)`
`317`	`317`	`{`
`318`	`318`	`if (initial)`
`319`	`319`	`{`
`@@ -338,7 +338,7 @@ internal override void WriteSyncData(bool initial, NetDataWriter writer)`
`338`	`338`	`}`
`339`	`339`	`}`
`340`	`340`
`341`		`- internal override void ReadSyncData(uint tick, bool initial, NetDataReader reader)`
	`341`	`+ internal override void ReadSyncData(bool isState, uint tick, bool initial, NetDataReader reader)`
`342`	`342`	`{`
`343`	`343`	`if (initial)`
`344`	`344`	`{`