Merge branch 'develop' into fix/INetworkSerializable_in_NetworkList_develop

Author: 0xFA11

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -23,6 +23,8 @@ Additional documentation and release notes are available at [Multiplayer Documen
 - Fixed overloading RPC methods causing collisions and failing on IL2CPP targets. (#1694)
 - Fixed spawn flow to propagate `IsSceneObject` down to children NetworkObjects, decouple implicit relationship between object spawning & `IsSceneObject` flag (#1685)
 - Fixed NetworkList now properly calls INetworkSerializable's NetworkSerialize() method (#1682)
+- Fixed error when serializing ConnectionApprovalMessage with scene management disabled when one or more objects is hidden via the CheckObjectVisibility delegate (#1720)
+- Fixed CheckObjectVisibility delegate not being properly invoked for connecting clients when Scene Management is enabled. (#1680)
 
 ## [1.0.0-pre.5] - 2022-01-26
 

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

@@ -1706,7 +1706,6 @@ internal void HandleApproval(ulong ownerClientId, bool createPlayerObject, uint?
                     {
                         if (SpawnManager.SpawnedObjectsList.Count != 0)
                         {
-                            message.SceneObjectCount = SpawnManager.SpawnedObjectsList.Count;
                             message.SpawnedObjectsList = SpawnManager.SpawnedObjectsList;
                         }
                     }

com.unity.netcode.gameobjects/Runtime/Messaging/Messages/ConnectionApprovedMessage.cs

@@ -7,7 +7,6 @@ internal struct ConnectionApprovedMessage : INetworkMessage
     {
         public ulong OwnerClientId;
         public int NetworkTick;
-        public int SceneObjectCount;
 
         // Not serialized, held as references to serialize NetworkVariable data
         public HashSet<NetworkObject> SpawnedObjectsList;
@@ -18,15 +17,17 @@ public void Serialize(FastBufferWriter writer)
         {
             if (!writer.TryBeginWrite(sizeof(ulong) + sizeof(int) + sizeof(int)))
             {
-                throw new OverflowException(
-                    $"Not enough space in the write buffer to serialize {nameof(ConnectionApprovedMessage)}");
+                throw new OverflowException($"Not enough space in the write buffer to serialize {nameof(ConnectionApprovedMessage)}");
             }
             writer.WriteValue(OwnerClientId);
             writer.WriteValue(NetworkTick);
-            writer.WriteValue(SceneObjectCount);
 
-            if (SceneObjectCount != 0)
+            uint sceneObjectCount = 0;
+            if (SpawnedObjectsList != null)
             {
+                var pos = writer.Position;
+                writer.Seek(writer.Position + FastBufferWriter.GetWriteSize(sceneObjectCount));
+
                 // Serialize NetworkVariable data
                 foreach (var sobj in SpawnedObjectsList)
                 {
@@ -35,8 +36,16 @@ public void Serialize(FastBufferWriter writer)
                         sobj.Observers.Add(OwnerClientId);
                         var sceneObject = sobj.GetMessageSceneObject(OwnerClientId);
                         sceneObject.Serialize(writer);
+                        ++sceneObjectCount;
                     }
                 }
+                writer.Seek(pos);
+                writer.WriteValue(sceneObjectCount);
+                writer.Seek(writer.Length);
+            }
+            else
+            {
+                writer.WriteValue(sceneObjectCount);
             }
         }
 
@@ -50,13 +59,11 @@ public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
 
             if (!reader.TryBeginRead(sizeof(ulong) + sizeof(int) + sizeof(int)))
             {
-                throw new OverflowException(
-                    $"Not enough space in the buffer to read {nameof(ConnectionApprovedMessage)}");
+                throw new OverflowException($"Not enough space in the buffer to read {nameof(ConnectionApprovedMessage)}");
             }
 
             reader.ReadValue(out OwnerClientId);
             reader.ReadValue(out NetworkTick);
-            reader.ReadValue(out SceneObjectCount);
             m_ReceivedSceneObjectData = reader;
             return true;
         }
@@ -77,10 +84,11 @@ public void Handle(ref NetworkContext context)
             if (!networkManager.NetworkConfig.EnableSceneManagement)
             {
                 networkManager.SpawnManager.DestroySceneObjects();
+                m_ReceivedSceneObjectData.ReadValue(out uint sceneObjectCount);
 
                 // Deserializing NetworkVariable data is deferred from Receive() to Handle to avoid needing
                 // to create a list to hold the data. This is a breach of convention for performance reasons.
-                for (ushort i = 0; i < SceneObjectCount; i++)
+                for (ushort i = 0; i < sceneObjectCount; i++)
                 {
                     var sceneObject = new NetworkObject.SceneObject();
                     sceneObject.Deserialize(m_ReceivedSceneObjectData);

com.unity.netcode.gameobjects/Runtime/SceneManagement/SceneEventData.cs

@@ -233,7 +233,14 @@ internal void InitializeForSynch()
 
         internal void AddSpawnedNetworkObjects()
         {
-            m_NetworkObjectsSync = m_NetworkManager.SpawnManager.SpawnedObjectsList.ToList();
+            m_NetworkObjectsSync.Clear();
+            foreach (var sobj in m_NetworkManager.SpawnManager.SpawnedObjectsList)
+            {
+                if (sobj.Observers.Contains(TargetClientId))
+                {
+                    m_NetworkObjectsSync.Add(sobj);
+                }
+            }
             m_NetworkObjectsSync.Sort(SortNetworkObjects);
         }
 

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

@@ -835,7 +835,7 @@ internal void UpdateObservedNetworkObjects(ulong clientId)
         {
             foreach (var sobj in SpawnedObjectsList)
             {
-                if (sobj.CheckObjectVisibility == null || NetworkManager.IsServer)
+                if (sobj.CheckObjectVisibility == null)
                 {
                     if (!sobj.Observers.Contains(clientId))
                     {

com.unity.netcode.gameobjects/Tests/Runtime/Components/NetworkVisibilityComponent.cs

@@ -0,0 +1,13 @@
+namespace Unity.Netcode.RuntimeTests
+{
+    public class NetworkVisibilityComponent : NetworkBehaviour
+    {
+        public void Hide()
+        {
+            GetComponent<NetworkObject>().CheckObjectVisibility += HandleCheckObjectVisibility;
+        }
+
+        protected virtual bool HandleCheckObjectVisibility(ulong clientId) => false;
+
+    }
+}

com.unity.netcode.gameobjects/Tests/Runtime/Components/NetworkVisibilityComponent.cs.meta

@@ -263,15 +263,17 @@ private static void SceneManagerValidationAndTestRunnerInitialization(NetworkMan
             }
         }
 
+        public delegate void BeforeClientStartCallback();
+
         /// <summary>
         /// Starts NetworkManager instances created by the Create method.
         /// </summary>
         /// <param name="host">Whether or not to create a Host instead of Server</param>
         /// <param name="server">The Server NetworkManager</param>
         /// <param name="clients">The Clients NetworkManager</param>
-        /// <param name="startInitializationCallback">called immediately after server and client(s) are started</param>
+        /// <param name="callback">called immediately after server is started and before client(s) are started</param>
         /// <returns></returns>
-        public static bool Start(bool host, NetworkManager server, NetworkManager[] clients)
+        public static bool Start(bool host, NetworkManager server, NetworkManager[] clients, BeforeClientStartCallback callback = null)
         {
             if (s_IsStarted)
             {
@@ -293,6 +295,8 @@ public static bool Start(bool host, NetworkManager server, NetworkManager[] clie
             // if set, then invoke this for the server
             RegisterHandlers(server);
 
+            callback?.Invoke();
+
             for (int i = 0; i < clients.Length; i++)
             {
                 clients[i].StartClient();

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

@@ -0,0 +1,70 @@
+using System.Collections;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    public class NetworkVisibilityTests
+    {
+        private NetworkObject m_NetSpawnedObject;
+        private GameObject m_TestNetworkPrefab;
+
+        [TearDown]
+        public void TearDown()
+        {
+            MultiInstanceHelpers.Destroy();
+            if (m_TestNetworkPrefab)
+            {
+                Object.Destroy(m_TestNetworkPrefab);
+                m_TestNetworkPrefab = null;
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator HiddenObjectsTest([Values] bool enableSeneManagement)
+        {
+
+            const int numClients = 1;
+            Assert.True(MultiInstanceHelpers.Create(numClients, out NetworkManager server, out NetworkManager[] clients));
+            m_TestNetworkPrefab = new GameObject("Object");
+            var networkObject = m_TestNetworkPrefab.AddComponent<NetworkObject>();
+            m_TestNetworkPrefab.AddComponent<NetworkVisibilityComponent>();
+
+            // Make it a prefab
+            MultiInstanceHelpers.MakeNetworkObjectTestPrefab(networkObject);
+
+            var validNetworkPrefab = new NetworkPrefab();
+            validNetworkPrefab.Prefab = m_TestNetworkPrefab;
+            server.NetworkConfig.NetworkPrefabs.Add(validNetworkPrefab);
+            server.NetworkConfig.EnableSceneManagement = enableSeneManagement;
+            foreach (var client in clients)
+            {
+                client.NetworkConfig.NetworkPrefabs.Add(validNetworkPrefab);
+                client.NetworkConfig.EnableSceneManagement = enableSeneManagement;
+            }
+
+            // Start the instances
+            if (!MultiInstanceHelpers.Start(true, server, clients, () =>
+            {
+                var serverObject = Object.Instantiate(m_TestNetworkPrefab, Vector3.zero, Quaternion.identity);
+                NetworkObject serverNetworkObject = serverObject.GetComponent<NetworkObject>();
+                serverNetworkObject.NetworkManagerOwner = server;
+                serverNetworkObject.Spawn();
+                serverObject.GetComponent<NetworkVisibilityComponent>().Hide();
+            }))
+            {
+                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));
+
+            Assert.AreEqual(2, Object.FindObjectsOfType<NetworkVisibilityComponent>().Length);
+        }
+    }
+}