update

Delay in-game state for new connections to provide NGO time to start synchronization.

Author: NoelStephensUnity

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);