fix: ensure server netvar initialization in OnNetworkSpawn replicates correctly to clients as initialization and not delta (#1266)

Co-authored-by: Matt Walsh <[email protected]>

Author: ShadauxCat

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

@@ -413,7 +413,7 @@ internal void SendSpawnCallForObject(ulong clientId, NetworkObject networkObject
 
                 var message = new CreateObjectMessage
                 {
-                    ObjectInfo = networkObject.GetMessageSceneObject(clientId, false)
+                    ObjectInfo = networkObject.GetMessageSceneObject(clientId)
                 };
                 var size = NetworkManager.SendMessage(message, NetworkDelivery.ReliableFragmentedSequenced, clientId);
                 NetworkManager.NetworkMetrics.TrackObjectSpawnSent(clientId, networkObject.NetworkObjectId, networkObject.name, size);

testproject/Assets/Tests/Runtime/NetworkVariableInitializationOnNetworkSpawnTest.cs

@@ -0,0 +1,102 @@
+using System.Collections;
+using NUnit.Framework;
+using TestProject.RuntimeTests.Support;
+using Unity.Netcode;
+using Unity.Netcode.RuntimeTests;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace TestProject.RuntimeTests
+{
+    public class NetworkVariableInitializationOnNetworkSpawnTest
+    {
+        private GameObject m_Prefab;
+
+        [UnitySetUp]
+        public IEnumerator SetUp()
+        {
+            // Make sure these static values are reset
+            NetworkVariableInitOnNetworkSpawn.NetworkSpawnCalledOnClient = false;
+            NetworkVariableInitOnNetworkSpawn.NetworkSpawnCalledOnServer = false;
+            yield break;
+        }
+
+        [UnityTearDown]
+        public IEnumerator Teardown()
+        {
+            // Shutdown and clean up both of our NetworkManager instances
+            if (m_Prefab)
+            {
+                MultiInstanceHelpers.Destroy();
+                Object.Destroy(m_Prefab);
+                m_Prefab = null;
+            }
+            NetworkVariableInitOnNetworkSpawn.NetworkSpawnCalledOnClient = false;
+            NetworkVariableInitOnNetworkSpawn.NetworkSpawnCalledOnServer = false;
+            yield break;
+        }
+
+        [UnityTest]
+        [Description("When a network variable is initialized in OnNetworkSpawn on the server, the spawned object's NetworkVariable on the client is initialized with the same value.")]
+        public IEnumerator WhenANetworkVariableIsInitializedInOnNetworkSpawnOnTheServer_TheSpawnedObjectsNetworkVariableOnTheClientIsInitializedWithTheSameValue()
+        {
+            const int numClients = 1;
+            Assert.True(MultiInstanceHelpers.Create(numClients, out NetworkManager server, out NetworkManager[] clients));
+            m_Prefab = new GameObject("Object");
+            var networkObject = m_Prefab.AddComponent<NetworkObject>();
+            m_Prefab.AddComponent<NetworkVariableInitOnNetworkSpawn>();
+
+            // Make it a prefab
+            MultiInstanceHelpers.MakeNetworkObjectTestPrefab(networkObject);
+
+            var validNetworkPrefab = new NetworkPrefab();
+            validNetworkPrefab.Prefab = m_Prefab;
+            server.NetworkConfig.NetworkPrefabs.Add(validNetworkPrefab);
+            foreach (var client in clients)
+            {
+                client.NetworkConfig.NetworkPrefabs.Add(validNetworkPrefab);
+            }
+
+            // Start the instances
+            if (!MultiInstanceHelpers.Start(true, server, clients))
+            {
+                Debug.LogError("Failed to start instances");
+                Assert.Fail("Failed to start instances");
+            }
+
+            // [Client-Side] Wait for a connection to the server
+            yield return MultiInstanceHelpers.Run(MultiInstanceHelpers.WaitForClientsConnected(clients, null, 512));
+
+            // [Host-Side] Check to make sure all clients are connected
+            yield return MultiInstanceHelpers.Run(
+                MultiInstanceHelpers.WaitForClientsConnectedToServer(server, clients.Length + 1, null, 512));
+
+            var serverObject = Object.Instantiate(m_Prefab, Vector3.zero, Quaternion.identity);
+            NetworkObject serverNetworkObject = serverObject.GetComponent<NetworkObject>();
+            serverNetworkObject.NetworkManagerOwner = server;
+            serverNetworkObject.Spawn();
+
+            // Wait until all objects have spawned.
+            const int expectedNetworkObjects = numClients + 2; // +2 = one for prefab, one for server.
+            const int maxFrames = 240;
+            var doubleCheckTime = Time.realtimeSinceStartup + 5.0f;
+            while (Object.FindObjectsOfType<NetworkObject>().Length != expectedNetworkObjects)
+            {
+                if (Time.frameCount > maxFrames)
+                {
+                    // This is here in the event a platform is running at a higher
+                    // frame rate than expected
+                    if (doubleCheckTime < Time.realtimeSinceStartup)
+                    {
+                        Assert.Fail("Did not successfully spawn all expected NetworkObjects");
+                        break;
+                    }
+                }
+                var nextFrameNumber = Time.frameCount + 1;
+                yield return new WaitUntil(() => Time.frameCount >= nextFrameNumber);
+            }
+            Assert.IsTrue(NetworkVariableInitOnNetworkSpawn.NetworkSpawnCalledOnServer);
+            Assert.IsTrue(NetworkVariableInitOnNetworkSpawn.NetworkSpawnCalledOnClient);
+        }
+    }
+}

testproject/Assets/Tests/Runtime/NetworkVariableInitializationOnNetworkSpawnTest.cs.meta

@@ -0,0 +1,27 @@
+using Unity.Netcode;
+using NUnit.Framework;
+
+namespace TestProject.RuntimeTests.Support
+{
+    public class NetworkVariableInitOnNetworkSpawn : NetworkBehaviour
+    {
+        private NetworkVariable<int> m_Variable = new NetworkVariable<int>();
+        public static bool NetworkSpawnCalledOnServer;
+        public static bool NetworkSpawnCalledOnClient;
+
+        public override void OnNetworkSpawn()
+        {
+            base.OnNetworkSpawn();
+            if (IsServer)
+            {
+                NetworkSpawnCalledOnServer = true;
+                m_Variable.Value = 5;
+            }
+            else
+            {
+                NetworkSpawnCalledOnClient = true;
+            }
+            Assert.AreEqual(5, m_Variable.Value);
+        }
+    }
+}