Merge branch 'experimental/v2-x-x/ngo-and-n4e' into experimental/v2-x-x/ngo-and-n4e-kitty

Author: ShadauxCat

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

@@ -13,6 +13,8 @@ public struct NetcodeConnection
         internal Entity Entity;
         public int NetworkId;
 
+        internal float ConnectedTime;
+
         public bool IsServer => World.IsServer();
         public void GoInGame()
         {
@@ -29,8 +31,12 @@ public void SendMessage<T>(T message) where T : unmanaged, IRpcCommand
     internal partial class UnifiedUpdateConnections : SystemBase
     {
         private List<NetcodeConnection> m_TempConnections = new List<NetcodeConnection>();
+
+        private Dictionary<int, NetcodeConnection> m_NewConnections = new Dictionary<int, NetcodeConnection>();
+
         protected override void OnUpdate()
         {
+            var isServer = World.IsServer();
             var commandBuffer = new EntityCommandBuffer(Allocator.Temp);
             foreach (var (networkId, connectionState, entity) in SystemAPI.Query<NetworkId, ConnectionState>().WithNone<NetworkStreamConnection>().WithEntityAccess())
             {
@@ -44,18 +50,40 @@ protected override void OnUpdate()
 
             m_TempConnections.Clear();
 
+
             foreach (var (networkId, entity) in SystemAPI.Query<NetworkId>().WithAll<NetworkStreamConnection>().WithNone<NetworkStreamInGame>().WithEntityAccess())
             {
-                commandBuffer.AddComponent<NetworkStreamInGame>(entity);
-                commandBuffer.AddComponent(entity, default(ConnectionState));
-                m_TempConnections.Add(new NetcodeConnection { World = World, Entity = entity, NetworkId = networkId.Value });
+                // 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 newConnection = new NetcodeConnection { World = World, Entity = entity, NetworkId = networkId.Value, ConnectedTime = UnityEngine.Time.realtimeSinceStartup + 1.0f };
+                    m_NewConnections.Add(networkId.Value, newConnection);
+                }
             }
 
-            foreach (var con in m_TempConnections)
+            // If we have any pending connections
+            if (m_NewConnections.Count > 0)
             {
-                NetworkManager.OnNetCodeConnect?.Invoke(con);
+                foreach (var entry in m_NewConnections)
+                {
+                    // Check if the delay time has passed.
+                    if (entry.Value.ConnectedTime < UnityEngine.Time.realtimeSinceStartup)
+                    {
+                        // Set the connection in-game
+                        commandBuffer.AddComponent<NetworkStreamInGame>(entry.Value.Entity);
+                        commandBuffer.AddComponent(entry.Value.Entity, default(ConnectionState));
+                        NetworkManager.OnNetCodeConnect?.Invoke(entry.Value);
+                        m_TempConnections.Add(entry.Value);
+                    }
+                }
+                // Remove any connections that have "gone in-game".
+                foreach (var connection in m_TempConnections)
+                {
+                    m_NewConnections.Remove(connection.NetworkId);
+                }
             }
-
             m_TempConnections.Clear();
 
             commandBuffer.Playback(EntityManager);

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

@@ -349,6 +349,11 @@ public void NetworkUpdate(NetworkUpdateStage updateStage)
                         {
                             NetworkConfig.Prefabs.RegisterGhostPrefabs(this);
                         }
+
+                        if (!IsServer)
+                        {
+                            SpawnManager?.CheckGhostsPendingNetworkObjectId();
+                        }
 #endif
 
                         UpdateTopology();

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

@@ -3854,13 +3854,27 @@ private void InitGhost()
             }
         }
 
-        private void RegisterGhostBridge()
+        internal bool IsGhostNetworkObjectIdValid()
+        {
+            if (NetworkObjectBridge == null)
+            {
+                return false;
+            }
+            // TODO-UNIFIED: Sometimes the GhostField can be latent. Need a way to know the GhostField has been set.
+            return NetworkObjectBridge.NetworkObjectId.Value < 1000000;
+        }
+
+        internal void RegisterGhostBridge()
         {
             if (NetworkManager.LogLevel == LogLevel.Developer)
             {
                 Debug.Log($"[{nameof(NetworkObject)}][{nameof(NetworkObjectId)}] NetworkObjectBridge notified instance exists with assigned ID of: {NetworkObjectBridge.NetworkObjectId.Value}");
             }
-            NetworkManager.SpawnManager.RegisterGhostPendingSpawn(this, NetworkObjectBridge.NetworkObjectId.Value);
+
+            if (!NetworkManager.IsServer)
+            {
+                NetworkManager.SpawnManager.RegisterGhostPendingSpawn(this, NetworkObjectBridge.NetworkObjectId.Value);
+            }
         }
 
         private void OnNetworkObjectIdChanged(ulong networkObjectId)

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

@@ -34,16 +34,59 @@ public class NetworkSpawnManager
 
         internal readonly Dictionary<ulong, NetworkObject> GhostsPendingSpawn = new Dictionary<ulong, NetworkObject>();
 
-        public void RegisterGhostPendingSpawn(NetworkObject networkObject, ulong networkObjectId)
+        internal readonly List<NetworkObject> GhostsPendingNetworkObjectId = new List<NetworkObject>();
+
+        internal void CheckGhostsPendingNetworkObjectId()
+        {
+            if (GhostsPendingNetworkObjectId.Count == 0)
+            {
+                return;
+            }
+
+            for(int i = GhostsPendingNetworkObjectId.Count - 1; i >= 0; i--)
+            {
+                var networkObject = GhostsPendingNetworkObjectId[i];
+                if (networkObject.IsGhostNetworkObjectIdValid())
+                {
+                    GhostsPendingNetworkObjectId.Remove(networkObject);
+                    if (NetworkManager.LogLevel == LogLevel.Developer)
+                    {
+                        Debug.Log($"[{nameof(RegisterGhostPendingSpawn)}] {networkObject.name}'s Ghost {nameof(NetworkObject.NetworkObjectId)} is valid. Re-registering.");
+                    }
+                    networkObject.RegisterGhostBridge();
+                }
+            }
+        }
+
+        internal void RegisterGhostPendingSpawn(NetworkObject networkObject, ulong networkObjectId)
         {
+            if (!networkObject.IsGhostNetworkObjectIdValid())
+            {
+                GhostsPendingNetworkObjectId.Add(networkObject);
+                if (NetworkManager.LogLevel == LogLevel.Developer)
+                {
+                    Debug.Log($"[{nameof(RegisterGhostPendingSpawn)}] {networkObject.name}'s Ghost {nameof(NetworkObject.NetworkObjectId)} ({networkObjectId}) seems invalid. Adding to the pending NetworkObjectId list.");
+                }
+                return;
+            }
             if (NetworkManager.LogLevel == LogLevel.Developer)
             {
                 Debug.Log($"[{nameof(RegisterGhostPendingSpawn)}] Registering {networkObject.name} with a {nameof(NetworkObject.NetworkObjectId)} of {networkObjectId}.");
             }
-            GhostsPendingSpawn.TryAdd(networkObjectId, networkObject);
+            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);
+            }
+
             NetworkManager.DeferredMessageManager.ProcessTriggers(IDeferredNetworkMessageManager.TriggerType.OnGhostSpawned, networkObjectId);
             if (GhostsArePendingSynchronization && GhostsPendingSynchronization.ContainsKey(networkObjectId))
             {
+                // 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);
             }
@@ -58,6 +101,9 @@ internal NetworkObject GetGhostNetworkObjectForSpawn(ulong networkObjectId)
             }
             var networkObject = GhostsPendingSpawn[networkObjectId];
             GhostsPendingSpawn.Remove(networkObjectId);
+            // 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());
             return networkObject;
         }
 
@@ -94,7 +140,6 @@ internal void ProcessGhostPendingSynchronization(ulong networkObjectId, bool rem
             //{
             //    networkObject.InternalInSceneNetworkObjectsSpawned();
             //}
-
             if (removeUponSpawn)
             {
                 GhostsArePendingSynchronization = GhostsPendingSynchronization.Count > 0;
@@ -2011,6 +2056,12 @@ internal NetworkSpawnManager(NetworkManager networkManager)
 
         internal void Shutdown()
         {
+#if UNIFIED_NETCODE
+            GhostsPendingNetworkObjectId.Clear();
+            GhostsPendingNetworkObjectId.Clear();
+            GhostsPendingSpawn.Clear();
+            GhostsPendingSynchronization.Clear();
+#endif
             NetworkObjectsToSynchronizeSceneChanges.Clear();
             CleanUpDisposedObjects.Clear();
         }