feat: snapshot spawn pre-requisite 2

com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviour.cs

@@ -714,6 +714,14 @@ internal void HandleNetworkVariableDeltas(Stream stream, ulong clientId)
             }
         }
 
+        internal void MarkVariablesDirty()
+        {
+            for (int j = 0; j < NetworkVariableFields.Count; j++)
+            {
+                NetworkVariableFields[j].SetDirty(true);
+            }
+        }
+
         internal void WriteNetworkVariableData(Stream stream, ulong clientId)
         {
             if (NetworkVariableFields.Count == 0)

com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs

@@ -852,6 +852,15 @@ internal void WriteNetworkVariableData(Stream stream, ulong clientId)
             }
         }
 
+        internal void MarkVariablesDirty()
+        {
+            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
+            {
+                var behavior = ChildNetworkBehaviours[i];
+                behavior.MarkVariablesDirty();
+            }
+        }
+
         internal void SetNetworkVariableData(Stream stream)
         {
             for (int i = 0; i < ChildNetworkBehaviours.Count; i++)

com.unity.netcode.gameobjects/Runtime/NetworkVariable/Collections/NetworkList.cs

@@ -73,10 +73,20 @@ public override bool IsDirty()
         public override void WriteDelta(Stream stream)
         {
             using var writer = PooledNetworkWriter.Get(stream);
+
+            if (base.IsDirty())
+            {
+                writer.WriteUInt16Packed(1);
+                writer.WriteByte((byte)NetworkListEvent<T>.EventType.Full);
+                WriteField(stream);
+
+                return;
+            }
+
             writer.WriteUInt16Packed((ushort)m_DirtyEvents.Length);
             for (int i = 0; i < m_DirtyEvents.Length; i++)
             {
-                writer.WriteBits((byte)m_DirtyEvents[i].Type, 3);
+                writer.WriteByte((byte)m_DirtyEvents[i].Type);
                 switch (m_DirtyEvents[i].Type)
                 {
                     case NetworkListEvent<T>.EventType.Add:
@@ -145,7 +155,7 @@ public override void ReadDelta(Stream stream, bool keepDirtyDelta)
             ushort deltaCount = reader.ReadUInt16Packed();
             for (int i = 0; i < deltaCount; i++)
             {
-                var eventType = (NetworkListEvent<T>.EventType)reader.ReadBits(3);
+                var eventType = (NetworkListEvent<T>.EventType)reader.ReadByte();
                 switch (eventType)
                 {
                     case NetworkListEvent<T>.EventType.Add:
@@ -311,6 +321,12 @@ public override void ReadDelta(Stream stream, bool keepDirtyDelta)
                             }
                         }
                         break;
+                    case NetworkListEvent<T>.EventType.Full:
+                        {
+                            ReadField(stream);
+                            ResetDirty();
+                        }
+                        break;
                 }
             }
         }
@@ -495,7 +511,12 @@ public enum EventType
             /// <summary>
             /// Clear
             /// </summary>
-            Clear
+            Clear,
+
+            /// <summary>
+            /// Full list refresh
+            /// </summary>
+            Full
         }
 
         /// <summary>

com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs

@@ -391,6 +391,8 @@ internal void SendSpawnCallForObject(ulong clientId, NetworkObject networkObject
                     var size = bufferSizeCapture.StopMeasureSegment();
                     NetworkManager.NetworkMetrics.TrackObjectSpawnSent(clientId, networkObject.NetworkObjectId, networkObject.name, size);
                 }
+
+                networkObject.MarkVariablesDirty();
             }
         }
 
@@ -451,7 +453,6 @@ internal void WriteSpawnCallForObject(PooledNetworkWriter writer, ulong clientId
                 var (isReparented, latestParent) = networkObject.GetNetworkParenting();
                 NetworkObject.WriteNetworkParenting(writer, isReparented, latestParent);
             }
-            networkObject.WriteNetworkVariableData(writer.GetStream(), clientId);
         }
 
         internal void DespawnObject(NetworkObject networkObject, bool destroyObject = false)

com.unity.netcode.gameobjects/Tests/Runtime/HiddenVariableTests.cs

@@ -1,4 +1,5 @@
 using System.Collections;
+using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.TestTools;
 
@@ -13,30 +14,29 @@ public class HiddenVariableObject : NetworkBehaviour
         public NetworkVariable<int> MyNetworkVariable = new NetworkVariable<int>();
         public NetworkList<int> MyNetworkList = new NetworkList<int>();
 
-        public static int ChangeCount = 0;
-        public static int ListChangeCount = 0;
+        public static Dictionary<ulong, int> ValueOnClient = new Dictionary<ulong, int>();
         public static int ExpectedSize = 0;
+        public static int SpawnCount = 0;
 
         public override void OnNetworkSpawn()
         {
-            Debug.Log($"{nameof(HiddenVariableObject)}.{nameof(OnNetworkSpawn)}()");
+            Debug.Log($"{nameof(HiddenVariableObject)}.{nameof(OnNetworkSpawn)}() with value {MyNetworkVariable.Value}");
 
             MyNetworkVariable.OnValueChanged += Changed;
             MyNetworkList.OnListChanged += ListChanged;
+            SpawnCount++;
 
             base.OnNetworkSpawn();
         }
 
         public void Changed(int before, int after)
         {
             Debug.Log($"Value changed from {before} to {after} on {NetworkManager.LocalClientId}");
-            ChangeCount++;
+            ValueOnClient[NetworkManager.LocalClientId] = after;
         }
         public void ListChanged(NetworkListEvent<int> listEvent)
         {
             Debug.Log($"ListEvent received: type {listEvent.Type}, index {listEvent.Index}, value {listEvent.Value}");
-            ListChangeCount++;
-
             Debug.Assert(ExpectedSize == MyNetworkList.Count);
         }
     }
@@ -46,6 +46,7 @@ public class HiddenVariableTests : BaseMultiInstanceTest
         protected override int NbClients => 4;
 
         private NetworkObject m_NetSpawnedObject;
+        private List<NetworkObject> m_NetSpawnedObjectOnClient = new List<NetworkObject>();
         private GameObject m_TestNetworkPrefab;
 
         [UnitySetUp]
@@ -83,75 +84,158 @@ public IEnumerator WaitForConnectedCount(int targetCount)
             }
         }
 
-        public IEnumerator WaitForChangeCount(int targetCount)
+        public IEnumerator WaitForSpawnCount(int targetCount)
         {
             var endTime = Time.realtimeSinceStartup + 1.0;
-            while ((HiddenVariableObject.ChangeCount != targetCount ||
-                    HiddenVariableObject.ListChangeCount != targetCount) &&
+            while (HiddenVariableObject.SpawnCount != targetCount &&
                    Time.realtimeSinceStartup < endTime)
             {
                 yield return new WaitForSeconds(0.01f);
             }
         }
 
+        public void VerifyLists()
+        {
+            NetworkList<int> prev = null;
+            int numComparison = 0;
+
+            // for all the instances of NetworkList
+            foreach (var gameObject in m_NetSpawnedObjectOnClient)
+            {
+                // this skips despawned/hidden objects
+                if (gameObject != null)
+                {
+                    // if we've seen another one before
+                    if (prev != null)
+                    {
+                        var curr = gameObject.GetComponent<HiddenVariableObject>().MyNetworkList;
+
+                        // check that the two lists are identical
+                        Debug.Assert(curr.Count == prev.Count);
+                        for (int index = 0; index < curr.Count; index++)
+                        {
+                            Debug.Assert(curr[index] == prev[index]);
+                        }
+                        numComparison++;
+                    }
+                    // store the list
+                    prev = gameObject.GetComponent<HiddenVariableObject>().MyNetworkList;
+                }
+            }
+            Debug.Log($"{numComparison} comparisons done.");
+        }
+
+        public IEnumerator RefreshGameObects()
+        {
+            m_NetSpawnedObjectOnClient.Clear();
+
+            foreach (var netMan in m_ClientNetworkManagers)
+            {
+                var serverClientPlayerResult = new MultiInstanceHelpers.CoroutineResultWrapper<NetworkObject>();
+                yield return MultiInstanceHelpers.Run(
+                    MultiInstanceHelpers.GetNetworkObjectByRepresentation(
+                        x => x.NetworkObjectId == m_NetSpawnedObject.NetworkObjectId,
+                        netMan,
+                        serverClientPlayerResult));
+                m_NetSpawnedObjectOnClient.Add(serverClientPlayerResult.Result);
+            }
+        }
+
         [UnityTest]
         public IEnumerator HiddenVariableTest()
         {
+            HiddenVariableObject.SpawnCount = 0;
+            HiddenVariableObject.ValueOnClient.Clear();
+            HiddenVariableObject.ExpectedSize = 0;
+            HiddenVariableObject.SpawnCount = 0;
+
             Debug.Log("Running test");
 
             var spawnedObject = Object.Instantiate(m_TestNetworkPrefab);
             m_NetSpawnedObject = spawnedObject.GetComponent<NetworkObject>();
             m_NetSpawnedObject.NetworkManagerOwner = m_ServerNetworkManager;
             yield return WaitForConnectedCount(NbClients);
+            Debug.Log("Clients connected");
 
-            // Spawn object with ownership on one client
+            // ==== Spawn object with ownership on one client
             var client = m_ServerNetworkManager.ConnectedClientsList[1];
             var otherClient = m_ServerNetworkManager.ConnectedClientsList[2];
             m_NetSpawnedObject.SpawnWithOwnership(client.ClientId);
 
-            // Set the NetworkVariable value to 2
+            yield return RefreshGameObects();
+
+            // === Check spawn occured
+            yield return WaitForSpawnCount(NbClients + 1);
+            Debug.Assert(HiddenVariableObject.SpawnCount == NbClients + 1);
+            Debug.Log("Objects spawned");
+
+            // ==== Set the NetworkVariable value to 2
             HiddenVariableObject.ExpectedSize = 1;
-            HiddenVariableObject.ChangeCount = 0;
-            HiddenVariableObject.ListChangeCount = 0;
+            HiddenVariableObject.SpawnCount = 0;
 
             m_NetSpawnedObject.GetComponent<HiddenVariableObject>().MyNetworkVariable.Value = 2;
             m_NetSpawnedObject.GetComponent<HiddenVariableObject>().MyNetworkList.Add(2);
 
-            yield return WaitForChangeCount(NbClients + 1);
-            Debug.Assert(HiddenVariableObject.ChangeCount == NbClients + 1);
-            Debug.Assert(HiddenVariableObject.ListChangeCount == NbClients + 1);
+            yield return new WaitForSeconds(1.0f);
+
+            foreach (var id in m_ServerNetworkManager.ConnectedClientsIds)
+            {
+                Debug.Assert(HiddenVariableObject.ValueOnClient[id] == 2);
+            }
+
+            VerifyLists();
 
-            // Hide our object to a different client
+            Debug.Log("Value changed");
+
+            // ==== Hide our object to a different client
             HiddenVariableObject.ExpectedSize = 2;
-            HiddenVariableObject.ChangeCount = 0;
-            HiddenVariableObject.ListChangeCount = 0;
             m_NetSpawnedObject.NetworkHide(otherClient.ClientId);
 
-            // Change the NetworkVariable value
+            // ==== Change the NetworkVariable value
             // we should get one less notification of value changing and no errors or exception
             m_NetSpawnedObject.GetComponent<HiddenVariableObject>().MyNetworkVariable.Value = 3;
             m_NetSpawnedObject.GetComponent<HiddenVariableObject>().MyNetworkList.Add(3);
 
             yield return new WaitForSeconds(1.0f);
-            Debug.Assert(HiddenVariableObject.ChangeCount == NbClients);
-            Debug.Assert(HiddenVariableObject.ListChangeCount == NbClients);
+            foreach (var id in m_ServerNetworkManager.ConnectedClientsIds)
+            {
+                if (id != otherClient.ClientId)
+                {
+                    Debug.Assert(HiddenVariableObject.ValueOnClient[id] == 3);
+                }
+            }
 
-            // Show our object again to this client
+            VerifyLists();
+            Debug.Log("Values changed");
+
+            // ==== Show our object again to this client
             HiddenVariableObject.ExpectedSize = 3;
-            HiddenVariableObject.ChangeCount = 0;
-            HiddenVariableObject.ListChangeCount = 0;
             m_NetSpawnedObject.NetworkShow(otherClient.ClientId);
 
-            // Change the NetworkVariable value
+            // ==== Wait for object to be spawned
+            yield return WaitForSpawnCount(1);
+            Debug.Assert(HiddenVariableObject.SpawnCount == 1);
+            Debug.Log("Object spawned");
+
+            // ==== We need a refresh for the newly re-spawned object
+            yield return RefreshGameObects();
+
+            // ==== Change the NetworkVariable value
             // we should get all notifications of value changing and no errors or exception
             m_NetSpawnedObject.GetComponent<HiddenVariableObject>().MyNetworkVariable.Value = 4;
             m_NetSpawnedObject.GetComponent<HiddenVariableObject>().MyNetworkList.Add(4);
 
-            yield return WaitForChangeCount(NbClients + 1);
-            Debug.Assert(HiddenVariableObject.ChangeCount == NbClients + 1);
-            Debug.Assert(HiddenVariableObject.ListChangeCount == NbClients + 1);
+            yield return new WaitForSeconds(1.0f);
+
+            foreach (var id in m_ServerNetworkManager.ConnectedClientsIds)
+            {
+                Debug.Assert(HiddenVariableObject.ValueOnClient[id] == 4);
+            }
+
+            VerifyLists();
+            Debug.Log("Values changed");
 
-            // Hide our object to that different client again, and then destroy it
+            // ==== Hide our object to that different client again, and then destroy it
             m_NetSpawnedObject.NetworkHide(otherClient.ClientId);
             yield return new WaitForSeconds(0.2f);
             m_NetSpawnedObject.Despawn();