Merge branch 'experimental/v2-x-x/ngo-and-n4e' into test-merge/v2-x-x/ngo-and-n4e-with-poc-transport

NoelStephensUnity · NoelStephensUnity · commit c31e7c296962 · 2026-03-05T15:11:35.000-06:00
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/Helpers/NetworkObjectBridge.cs b/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)
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/Helpers/UnifiedUpdateConnections.cs b/com.unity.netcode.gameobjects/Runtime/Components/Helpers/UnifiedUpdateConnections.cs
@@ -13,9 +13,6 @@ public struct NetcodeConnection
         internal Entity Entity;
         public int NetworkId;
 
-        internal float ConnectedTime;
-        internal bool IsSynced;
-
         public bool IsServer => World.IsServer();
         public void GoInGame()
         {
@@ -48,6 +45,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);
@@ -60,16 +59,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, IsSynced = isServer};
+                    var newConnection = new NetcodeConnection { World = World, Entity = entity, NetworkId = networkId.Value };
                     m_NewConnections.Add(networkId.Value, newConnection);
                 }
             }
@@ -79,8 +74,9 @@ protected override void OnUpdate()
             {
                 foreach (var entry in m_NewConnections)
                 {
-                    // Check if the delay time has passed.
-                    if (entry.Value.IsSynced && 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);
@@ -97,21 +93,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();
diff --git a/com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs b/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>
diff --git a/com.unity.netcode.gameobjects/Runtime/SceneManagement/NetworkSceneManager.cs b/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))
                     {
diff --git a/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs b/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();
             }

Original file line number	Diff line number	Diff line change
`@@ -13,9 +13,6 @@ public struct NetcodeConnection`
`13`	`13`	`internal Entity Entity;`
`14`	`14`	`public int NetworkId;`
`15`	`15`
`16`		`- internal float ConnectedTime;`
`17`		`- internal bool IsSynced;`
`18`		`-`
`19`	`16`	`public bool IsServer => World.IsServer();`
`20`	`17`	`public void GoInGame()`
`21`	`18`	`{`
`@@ -48,6 +45,8 @@ protected override void OnUpdate()`
`48`	`45`	`{`
`49`	`46`	`var isServer = World.IsServer();`
`50`	`47`	`var commandBuffer = new EntityCommandBuffer(Allocator.Temp);`
	`48`	`+ var networkManager = NetworkManager.Singleton;`
	`49`	`+`
`51`	`50`	`foreach (var (networkId, connectionState, entity) in SystemAPI.Query<NetworkId, ConnectionState>().WithNone<NetworkStreamConnection>().WithEntityAccess())`
`52`	`51`	`{`
`53`	`52`	`commandBuffer.RemoveComponent<ConnectionState>(entity);`
`@@ -60,16 +59,12 @@ protected override void OnUpdate()`
`60`	`59`
`61`	`60`	`m_TempConnections.Clear();`
`62`	`61`
`63`		`-`
	`62`	`+ // TODO: We should figure out how to associate the N4E NetworkId with the NGO ClientId`
`64`	`63`	`foreach (var (networkId, entity) in SystemAPI.Query<NetworkId>().WithAll<NetworkStreamConnection>().WithNone<NetworkStreamInGame>().WithEntityAccess())`
`65`	`64`	`{`
`66`		`- // 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.`
`67`		`- // 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`
`68`		`- // 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).`
`69`	`65`	`if (!m_NewConnections.ContainsKey(networkId.Value))`
`70`	`66`	`{`
`71`		`- var delayTime = 0.0f;// isServer ? 0.2f : 0.1f;`
`72`		`- var newConnection = new NetcodeConnection { World = World, Entity = entity, NetworkId = networkId.Value, ConnectedTime = UnityEngine.Time.realtimeSinceStartup + delayTime, IsSynced = isServer};`
	`67`	`+ var newConnection = new NetcodeConnection { World = World, Entity = entity, NetworkId = networkId.Value };`
`73`	`68`	`m_NewConnections.Add(networkId.Value, newConnection);`
`74`	`69`	`}`
`75`	`70`	`}`
`@@ -79,8 +74,9 @@ protected override void OnUpdate()`
`79`	`74`	`{`
`80`	`75`	`foreach (var entry in m_NewConnections)`
`81`	`76`	`{`
`82`		`- // Check if the delay time has passed.`
`83`		`- if (entry.Value.IsSynced && entry.Value.ConnectedTime < UnityEngine.Time.realtimeSinceStartup)`
	`77`	`+ // Server: always connect`
	`78`	`+ // Client: wait until we have synchronized before announcing we are ready to receive snapshots`
	`79`	`+ if (networkManager.IsServer \|\| (!networkManager.IsServer && networkManager.IsConnectedClient))`
`84`	`80`	`{`
`85`	`81`	`// Set the connection in-game`
`86`	`82`	`commandBuffer.AddComponent<NetworkStreamInGame>(entry.Value.Entity);`
`@@ -97,21 +93,29 @@ protected override void OnUpdate()`
`97`	`93`	`}`
`98`	`94`	`m_TempConnections.Clear();`
`99`	`95`
	`96`	`+ // If the local NetworkManager is shutting down or no longer connected, then`
	`97`	`+ // make sure we have disconnected all known connections.`
	`98`	`+ if (networkManager.ShutdownInProgress \|\| !networkManager.IsListening)`
	`99`	`+ {`
	`100`	`+ foreach (var (networkId, entity) in SystemAPI.Query<NetworkId>().WithEntityAccess())`
	`101`	`+ {`
	`102`	`+ commandBuffer.RemoveComponent<ConnectionState>(entity);`
	`103`	`+ NetworkManager.OnNetCodeDisconnect?.Invoke(new NetcodeConnection { World = World, Entity = entity, NetworkId = networkId.Value });`
	`104`	`+ }`
	`105`	`+ }`
`100`	`106`	`commandBuffer.Playback(EntityManager);`
`101`	`107`	`}`
`102`	`108`
	`109`	`+ /// <summary>`
	`110`	`+ /// Always disconnect all known connections when being destroyed.`
	`111`	`+ /// </summary>`
`103`	`112`	`protected override void OnDestroy()`
`104`	`113`	`{`
`105`	`114`	`var commandBuffer = new EntityCommandBuffer(Allocator.Temp);`
`106`	`115`	`foreach (var (networkId, entity) in SystemAPI.Query<NetworkId>().WithEntityAccess())`
`107`	`116`	`{`
`108`	`117`	`commandBuffer.RemoveComponent<ConnectionState>(entity);`
`109`		`- // TODO: maybe disconnect reason?`
`110`		`- m_TempConnections.Add(new NetcodeConnection { World = World, Entity = entity, NetworkId = networkId.Value });`
`111`		`- }`
`112`		`- foreach (var con in m_TempConnections)`
`113`		`- {`
`114`		`- NetworkManager.OnNetCodeDisconnect?.Invoke(con);`
	`118`	`+ NetworkManager.OnNetCodeDisconnect?.Invoke(new NetcodeConnection { World = World, Entity = entity, NetworkId = networkId.Value });`
`115`	`119`	`}`
`116`	`120`	`commandBuffer.Playback(EntityManager);`
`117`	`121`	`base.OnDestroy();`
Original file line number	Diff line number	Diff line change
`@@ -1732,8 +1732,15 @@ private void OnDestroy()`
`1732`	`1732`	`return;`
`1733`	`1733`	`}`
`1734`	`1734`
	`1735`	`+ var spawnManager = NetworkManager.SpawnManager;`
	`1736`	`+`
`1735`	`1737`	`// Always attempt to remove from scene changed updates`
`1736`		`- networkManager.SpawnManager?.RemoveNetworkObjectFromSceneChangedUpdates(this);`
	`1738`	`+ spawnManager?.RemoveNetworkObjectFromSceneChangedUpdates(this);`
	`1739`	`+`
	`1740`	`+#if UNIFIED_NETCODE`
	`1741`	`+ spawnManager?.GhostsPendingSpawn.Remove(NetworkObjectId);`
	`1742`	`+ spawnManager?.GhostsPendingSynchronization.Remove(NetworkObjectId);`
	`1743`	`+#endif`
`1737`	`1744`
`1738`	`1745`	`if (IsSpawned && !networkManager.ShutdownInProgress)`
`1739`	`1746`	`{`
`@@ -1763,11 +1770,11 @@ private void OnDestroy()`
`1763`	`1770`	`}`
`1764`	`1771`	`}`
`1765`	`1772`
`1766`		`- if (networkManager.SpawnManager != null && networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))`
	`1773`	`+ if (spawnManager != null && spawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))`
`1767`	`1774`	`{`
`1768`	`1775`	`if (this == networkObject)`
`1769`	`1776`	`{`
`1770`		`- networkManager.SpawnManager.OnDespawnObject(networkObject, false);`
	`1777`	`+ spawnManager.OnDespawnObject(networkObject, false);`
`1771`	`1778`	`}`
`1772`	`1779`	`}`
`1773`	`1780`	`}`
`@@ -3846,7 +3853,6 @@ private void InitGhost()`
`3846`	`3853`	`{`
`3847`	`3854`	`Debug.Log($"[{nameof(NetworkObject)}] GhostBridge {name} detected and instantiated.");`
`3848`	`3855`	`}`
`3849`		`- NetworkObjectBridge.NetworkObjectIdChanged += OnNetworkObjectIdChanged;`
`3850`	`3856`	`if (NetworkObjectBridge.NetworkObjectId.Value != 0)`
`3851`	`3857`	`{`
`3852`	`3858`	`RegisterGhostBridge();`
`@@ -3866,11 +3872,6 @@ internal void RegisterGhostBridge()`
`3866`	`3872`	`NetworkManager.SpawnManager.RegisterGhostPendingSpawn(this, NetworkObjectBridge.NetworkObjectId.Value);`
`3867`	`3873`	`}`
`3868`	`3874`	`}`
`3869`		`-`
`3870`		`- private void OnNetworkObjectIdChanged(ulong networkObjectId)`
`3871`		`- {`
`3872`		`- RegisterGhostBridge();`
`3873`		`- }`
`3874`	`3875`	`#endif`
`3875`	`3876`
`3876`	`3877`	`/// <summary>`