update

Fixes for connection sequence where clients don't announce they are ready to receive snapshots until fully synchronized by NGO.
Fixes for removing pending ghosts and ghost spawn data (especially when being destroyed).
Fixes for NetworkSceneManager detecting pending ghosts as in-scene placed.
Fixes for NetworkSpawnManager.RegisterGhostPendingSpawn trying to double process triggers and/or process triggers when it should not.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/Runtime/Components/Helpers/NetworkObjectBridge.cs

@@ -7,15 +7,17 @@ namespace Unity.Netcode
 {
 
     /// <summary>
-    /// TODO-UNIFIED: Would need to be reviewed for alternate ways of handling this.
+    /// TODO-UNIFIED: Needs further peer review and exploring alternate ways of handling this.
     /// </summary>
     /// <remarks>
     /// If used, we most likely would make this internal
     /// </remarks>
     public partial class NetworkObjectBridge : GhostBehaviour
     {
-        public Action<ulong> NetworkObjectIdChanged;
-
+        /// <summary>
+        /// This is used to link <see cref="NetworkObject.SerializedObject"/> data to
+        /// N4E-spawned hybrid prefab instances.
+        /// </summary>
         internal GhostField<ulong> NetworkObjectId = new GhostField<ulong>();
 
         public void SetNetworkObjectId(ulong value)

com.unity.netcode.gameobjects/Runtime/Components/Helpers/UnifiedUpdateConnections.cs

@@ -13,8 +13,6 @@ public struct NetcodeConnection
         internal Entity Entity;
         public int NetworkId;
 
-        internal float ConnectedTime;
-
         public bool IsServer => World.IsServer();
         public void GoInGame()
         {
@@ -38,6 +36,8 @@ protected override void OnUpdate()
         {
             var isServer = World.IsServer();
             var commandBuffer = new EntityCommandBuffer(Allocator.Temp);
+            var networkManager = NetworkManager.Singleton;
+
             foreach (var (networkId, connectionState, entity) in SystemAPI.Query<NetworkId, ConnectionState>().WithNone<NetworkStreamConnection>().WithEntityAccess())
             {
                 commandBuffer.RemoveComponent<ConnectionState>(entity);
@@ -50,16 +50,12 @@ protected override void OnUpdate()
 
             m_TempConnections.Clear();
 
-
+            // TODO: We should figure out how to associate the N4E NetworkId with the NGO ClientId
             foreach (var (networkId, entity) in SystemAPI.Query<NetworkId>().WithAll<NetworkStreamConnection>().WithNone<NetworkStreamInGame>().WithEntityAccess())
             {
-                // TODO-Unified: For new connections, we have a delay before the N4E in-game state for the client to provide time for the NGO side of the client to synchronize.
-                // Note: Once both are using the same transport we should be able to get the transport id and determine the NGO assigned client-id and at that point once the
-                // client has signaled that it has synchronized (or has been sent the synchronization data) we finalize the in-game connection state (or something along those lines).
                 if (!m_NewConnections.ContainsKey(networkId.Value))
                 {
-                    var delayTime = 0.0f;// isServer ? 0.2f : 0.1f;
-                    var newConnection = new NetcodeConnection { World = World, Entity = entity, NetworkId = networkId.Value, ConnectedTime = UnityEngine.Time.realtimeSinceStartup + delayTime};
+                    var newConnection = new NetcodeConnection { World = World, Entity = entity, NetworkId = networkId.Value };
                     m_NewConnections.Add(networkId.Value, newConnection);
                 }
             }
@@ -69,8 +65,9 @@ protected override void OnUpdate()
             {
                 foreach (var entry in m_NewConnections)
                 {
-                    // Check if the delay time has passed.
-                    if (entry.Value.ConnectedTime < UnityEngine.Time.realtimeSinceStartup)
+                    // Server: always connect
+                    // Client: wait until we have synchronized before announcing we are ready to receive snapshots
+                    if (networkManager.IsServer || (!networkManager.IsServer && networkManager.IsConnectedClient))
                     {
                         // Set the connection in-game
                         commandBuffer.AddComponent<NetworkStreamInGame>(entry.Value.Entity);
@@ -87,21 +84,29 @@ protected override void OnUpdate()
             }
             m_TempConnections.Clear();
 
+            // If the local NetworkManager is shutting down or no longer connected, then
+            // make sure we have disconnected all known connections.
+            if (networkManager.ShutdownInProgress || !networkManager.IsListening)
+            {
+                foreach (var (networkId, entity) in SystemAPI.Query<NetworkId>().WithEntityAccess())
+                {
+                    commandBuffer.RemoveComponent<ConnectionState>(entity);
+                    NetworkManager.OnNetCodeDisconnect?.Invoke(new NetcodeConnection { World = World, Entity = entity, NetworkId = networkId.Value });
+                }
+            }
             commandBuffer.Playback(EntityManager);
         }
 
+        /// <summary>
+        /// Always disconnect all known connections when being destroyed.
+        /// </summary>
         protected override void OnDestroy()
         {
             var commandBuffer = new EntityCommandBuffer(Allocator.Temp);
             foreach (var (networkId, entity) in SystemAPI.Query<NetworkId>().WithEntityAccess())
             {
                 commandBuffer.RemoveComponent<ConnectionState>(entity);
-                // TODO: maybe disconnect reason?
-                m_TempConnections.Add(new NetcodeConnection { World = World, Entity = entity, NetworkId = networkId.Value });
-            }
-            foreach (var con in m_TempConnections)
-            {
-                NetworkManager.OnNetCodeDisconnect?.Invoke(con);
+                NetworkManager.OnNetCodeDisconnect?.Invoke(new NetcodeConnection { World = World, Entity = entity, NetworkId = networkId.Value });
             }
             commandBuffer.Playback(EntityManager);
             base.OnDestroy();

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

@@ -1732,8 +1732,15 @@ private void OnDestroy()
                 return;
             }
 
+            var spawnManager = NetworkManager.SpawnManager;
+
             // Always attempt to remove from scene changed updates
-            networkManager.SpawnManager?.RemoveNetworkObjectFromSceneChangedUpdates(this);
+            spawnManager?.RemoveNetworkObjectFromSceneChangedUpdates(this);
+
+#if UNIFIED_NETCODE
+            spawnManager?.GhostsPendingSpawn.Remove(NetworkObjectId);
+            spawnManager?.GhostsPendingSynchronization.Remove(NetworkObjectId);
+#endif
 
             if (IsSpawned && !networkManager.ShutdownInProgress)
             {
@@ -1763,11 +1770,11 @@ private void OnDestroy()
                 }
             }
 
-            if (networkManager.SpawnManager != null && networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
+            if (spawnManager != null && spawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
             {
                 if (this == networkObject)
                 {
-                    networkManager.SpawnManager.OnDespawnObject(networkObject, false);
+                    spawnManager.OnDespawnObject(networkObject, false);
                 }
             }
         }
@@ -3846,7 +3853,6 @@ private void InitGhost()
                 {
                     Debug.Log($"[{nameof(NetworkObject)}] GhostBridge {name} detected and instantiated.");
                 }
-                NetworkObjectBridge.NetworkObjectIdChanged += OnNetworkObjectIdChanged;
                 if (NetworkObjectBridge.NetworkObjectId.Value != 0)
                 {
                     RegisterGhostBridge();
@@ -3866,11 +3872,6 @@ internal void RegisterGhostBridge()
                 NetworkManager.SpawnManager.RegisterGhostPendingSpawn(this, NetworkObjectBridge.NetworkObjectId.Value);
             }
         }
-
-        private void OnNetworkObjectIdChanged(ulong networkObjectId)
-        {
-            RegisterGhostBridge();
-        }
 #endif
 
         /// <summary>

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

@@ -2740,8 +2740,14 @@ internal void PopulateScenePlacedObjects(Scene sceneToFilterBy, bool clearSceneP
                 var globalObjectIdHash = networkObjectInstance.GlobalObjectIdHash;
                 var sceneHandle = networkObjectInstance.gameObject.scene.handle;
                 // We check to make sure the NetworkManager instance is the same one to be "NetcodeIntegrationTestHelpers" compatible and filter the list on a per scene basis (for additive scenes)
+#if UNIFIED_NETCODE
+                if (!networkObjectInstance.HasGhost && networkObjectInstance.IsSceneObject != false && (networkObjectInstance.NetworkManager == NetworkManager ||
+                    networkObjectInstance.NetworkManagerOwner == null) && sceneHandle == sceneToFilterBy.handle)
+#else
                 if (networkObjectInstance.IsSceneObject != false && (networkObjectInstance.NetworkManager == NetworkManager ||
                     networkObjectInstance.NetworkManagerOwner == null) && sceneHandle == sceneToFilterBy.handle)
+
+#endif
                 {
                     if (!ScenePlacedObjects.ContainsKey(globalObjectIdHash))
                     {

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

@@ -43,19 +43,35 @@ internal void RegisterGhostPendingSpawn(NetworkObject networkObject, ulong netwo
             if (GhostsPendingSpawn.TryAdd(networkObjectId, networkObject))
             {
                 // TODO-UNIFIED: We need a better way to preserve any hybrid instances pending NGO spawn.
-                // For now, move any pending object into the DDOL.
-                UnityEngine.Object.DontDestroyOnLoad(networkObject.gameObject);
+                // Edge-Case scenario: During initial client synchronization (i.e. !NetworkManager.IsConnectedClient).
+                //
+                // Description: A client can receive snapshots before finishing the NGO synchronization process.
+                // This is when an edge case scenario can happen where the initial NGO synchronization information
+                // can include new scenes to load. If one of those scenes is configured to load in SingleMode, then
+                // any instantiated ghosts pending synchronization would be instantiated in whatever the currently
+                // active scene was when the client was processing the synchronization data. If the ghosts pending
+                // synchrpnization are in the currently active scene when the new scene is loaded in SingleMode, then
+                // they would be destroyed.
+                // 
+                // Current Fix:
+                // If the client is not yet synchronized, then any ghost pending spawn get migrated into the DDOL.
+                // 
+                // Further review:
+                // We need to make sure that we are migrating NetworkObjects into their assigned scene (if scene
+                // management is enabled). Currently, we assume all instances were in the DDOL and just migrate
+                // them into the currently active scene upon spawn.
+                if (!NetworkManager.IsConnectedClient && !GhostsPendingSynchronization.ContainsKey(networkObjectId))
+                {
+                    UnityEngine.Object.DontDestroyOnLoad(networkObject.gameObject);
+                }
+                else // There is matching spawn data for this pending Ghost, process the pending spawn for this hybrid instance.
+                {
+                    NetworkManager.DeferredMessageManager.ProcessTriggers(IDeferredNetworkMessageManager.TriggerType.OnGhostSpawned, networkObjectId);
+                }
             }
-
-            NetworkManager.DeferredMessageManager.ProcessTriggers(IDeferredNetworkMessageManager.TriggerType.OnGhostSpawned, networkObjectId);
-            if (GhostsArePendingSynchronization && GhostsPendingSynchronization.ContainsKey(networkObjectId))
+            else
             {
-                // TODO-UNIFIED: We need a better way to preserve any hybrid instances pending NGO spawn.
-                // NOTE: We might be able to use the NetworkSceneHandle to get the associated local scene handle to which we can use to get the targeted scene.
-                UnityEngine.SceneManagement.SceneManager.MoveGameObjectToScene(networkObject.gameObject, UnityEngine.SceneManagement.SceneManager.GetActiveScene());
-
-                // When the object is spawned, it will invoke GetGhostNetworkObjectForSpawn below which removes the entry from GhostsPendingSpawn
-                ProcessGhostPendingSynchronization(networkObjectId);
+                Debug.LogError($"[{networkObject.name}-{networkObjectId}] Has already been registered as a pending ghost!");
             }
         }
 
@@ -109,6 +125,7 @@ internal void ProcessGhostPendingSynchronization(ulong networkObjectId, bool rem
             //}
             if (removeUponSpawn)
             {
+                GhostsPendingSynchronization.Remove(networkObjectId);
                 GhostsArePendingSynchronization = GhostsPendingSynchronization.Count > 0;
                 ghostPendingSynch.Buffer.Dispose();
             }