fix: [Backport] Ensure NetworkConnectionManager correctly handles multiple disconnect messages being sent (#3721)

EmandM · michalChrobot · web-flow · commit 9758607edb7a · 2025-10-16T15:32:57.000Z
* fix: [Backport] Ensure NetworkConnectionManager correctly handles multiple disconnect messages being sent

* Update CHANGELOG

* Simplify scripting defines in UnityTransport.GetEndpoint

---------

Co-authored-by: Michał Chrobot &lt;124174716+michalChrobot@users.noreply.github.com&gt;
diff --git a/com.unity.netcode.gameobjects/CHANGELOG.md b/com.unity.netcode.gameobjects/CHANGELOG.md
@@ -13,7 +13,8 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Changed
 
-* Changed minimum Unity version supported to 2022.3 LTS
+- The `NetworkManager` functions `GetTransportIdFromClientId` and `GetClientIdFromTransportId` will now return `ulong.MaxValue` when the clientId or transportId do not exist. (#3721)
+- Changed minimum Unity version supported to 2022.3 LTS
 
 ### Deprecated
 
@@ -23,6 +24,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Fixed
 
+- Multiple disconnect events from the same transport will no longer disconnect the host. (#3721)
 
 ### Security
 
diff --git a/com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs b/com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs
@@ -317,45 +317,45 @@ internal void RemovePendingClient(ulong clientId)
         private ulong m_NextClientId = 1;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal ulong TransportIdToClientId(ulong transportId)
+        internal (ulong, bool) TransportIdToClientId(ulong transportId)
         {
             if (transportId == GetServerTransportId())
             {
-                return NetworkManager.ServerClientId;
+                return (NetworkManager.ServerClientId, true);
             }
 
             if (TransportIdToClientIdMap.TryGetValue(transportId, out var clientId))
             {
-                return clientId;
+                return (clientId, true);
             }
 
             if (NetworkLog.CurrentLogLevel == LogLevel.Developer)
             {
                 NetworkLog.LogWarning($"Trying to get the NGO client ID map for the transport ID ({transportId}) but did not find the map entry! Returning default transport ID value.");
             }
 
-            return default;
+            return (0, false);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal ulong ClientIdToTransportId(ulong clientId)
+        internal (ulong, bool) ClientIdToTransportId(ulong clientId)
         {
             if (clientId == NetworkManager.ServerClientId)
             {
-                return GetServerTransportId();
+                return (GetServerTransportId(), true);
             }
 
             if (ClientIdToTransportIdMap.TryGetValue(clientId, out var transportClientId))
             {
-                return transportClientId;
+                return (transportClientId, true);
             }
 
             if (NetworkLog.CurrentLogLevel == LogLevel.Developer)
             {
                 NetworkLog.LogWarning($"Trying to get the transport client ID map for the NGO client ID ({clientId}) but did not find the map entry! Returning default transport ID value.");
             }
 
-            return default;
+            return (0, false);
         }
 
         /// <summary>
@@ -384,19 +384,24 @@ private ulong GetServerTransportId()
         /// Handles cleaning up the transport id/client id tables after receiving a disconnect event from transport.
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal ulong TransportIdCleanUp(ulong transportId)
+        internal (ulong, bool) TransportIdCleanUp(ulong transportId)
         {
             // This check is for clients that attempted to connect but failed.
             // When this happens, the client will not have an entry within the m_TransportIdToClientIdMap or m_ClientIdToTransportIdMap lookup tables so we exit early and just return 0 to be used for the disconnect event.
             if (!LocalClient.IsServer && !TransportIdToClientIdMap.ContainsKey(transportId))
             {
-                return NetworkManager.LocalClientId;
+                return (NetworkManager.LocalClientId, true);
+            }
+
+            var (clientId, isConnectedClient) = TransportIdToClientId(transportId);
+            if (!isConnectedClient)
+            {
+                return (default, false);
             }
 
-            var clientId = TransportIdToClientId(transportId);
             TransportIdToClientIdMap.Remove(transportId);
             ClientIdToTransportIdMap.Remove(clientId);
-            return clientId;
+            return (clientId, true);
         }
 
         internal void PollAndHandleNetworkEvents()
@@ -502,8 +507,11 @@ internal void DataEventHandler(ulong transportClientId, ref ArraySegment<byte> p
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             s_HandleIncomingData.Begin();
 #endif
-            var clientId = TransportIdToClientId(transportClientId);
-            MessageManager.HandleIncomingData(clientId, payload, receiveTime);
+            var (clientId, isConnectedClient) = TransportIdToClientId(transportClientId);
+            if (isConnectedClient)
+            {
+                MessageManager.HandleIncomingData(clientId, payload, receiveTime);
+            }
 
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             s_HandleIncomingData.End();
@@ -515,10 +523,15 @@ internal void DataEventHandler(ulong transportClientId, ref ArraySegment<byte> p
         /// </summary>
         internal void DisconnectEventHandler(ulong transportClientId)
         {
+            var (clientId, wasConnectedClient) = TransportIdCleanUp(transportClientId);
+            if (!wasConnectedClient)
+            {
+                return;
+            }
+
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             s_TransportDisconnect.Begin();
 #endif
-            var clientId = TransportIdCleanUp(transportClientId);
             if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
             {
                 NetworkLog.LogInfo($"Disconnect Event From {clientId}");
@@ -1040,9 +1053,9 @@ internal void OnClientDisconnectFromServer(ulong clientId)
             }
 
             // If the client ID transport map exists
-            if (ClientIdToTransportIdMap.ContainsKey(clientId))
+            var (transportId, isConnected) = ClientIdToTransportId(clientId);
+            if (isConnected)
             {
-                var transportId = ClientIdToTransportId(clientId);
                 NetworkManager.NetworkConfig.NetworkTransport.DisconnectRemoteClient(transportId);
 
                 InvokeOnClientDisconnectCallback(clientId);
diff --git a/com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs b/com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs
@@ -1156,15 +1156,27 @@ private void HostServerInitialize()
         /// Get the TransportId from the associated ClientId.
         /// </summary>
         /// <param name="clientId">The ClientId to get the TransportId from</param>
-        /// <returns>The TransportId associated with the given ClientId</returns>
-        public ulong GetTransportIdFromClientId(ulong clientId) => ConnectionManager.ClientIdToTransportId(clientId);
+        /// <returns>
+        /// The TransportId associated with the given ClientId if the given clientId is valid; otherwise <see cref="ulong.MaxValue"/>
+        /// </returns>
+        public ulong GetTransportIdFromClientId(ulong clientId)
+        {
+            var (id, success) = ConnectionManager.ClientIdToTransportId(clientId);
+            return success ? id : ulong.MaxValue;
+        }
 
         /// <summary>
         /// Get the ClientId from the associated TransportId.
         /// </summary>
         /// <param name="transportId">The TransportId to get the ClientId from</param>
-        /// <returns>The ClientId from the associated TransportId</returns>
-        public ulong GetClientIdFromTransportId(ulong transportId) => ConnectionManager.TransportIdToClientId(transportId);
+        /// <returns>
+        /// The ClientId from the associated TransportId if the given transportId is valid; otherwise <see cref="ulong.MaxValue"/>
+        /// </returns>
+        public ulong GetClientIdFromTransportId(ulong transportId)
+        {
+            var (id, success) = ConnectionManager.TransportIdToClientId(transportId);
+            return success ? id : ulong.MaxValue;
+        }
 
         /// <summary>
         /// Disconnects the remote client.
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/DefaultMessageSender.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/DefaultMessageSender.cs
@@ -19,8 +19,19 @@ public DefaultMessageSender(NetworkManager manager)
         public void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData)
         {
             var sendBuffer = batchData.ToTempByteArray();
+            var (transportId, clientExists) = m_ConnectionManager.ClientIdToTransportId(clientId);
 
-            m_NetworkTransport.Send(m_ConnectionManager.ClientIdToTransportId(clientId), sendBuffer, delivery);
+            if (!clientExists)
+            {
+                if (m_ConnectionManager.NetworkManager.LogLevel <= LogLevel.Error)
+                {
+                    NetworkLog.LogWarning("Trying to send a message to a client who doesn't have a transport connection");
+                }
+
+                return;
+            }
+
+            m_NetworkTransport.Send(transportId, sendBuffer, delivery);
         }
     }
 }
diff --git a/com.unity.netcode.gameobjects/Runtime/Transports/UTP/UnityTransport.cs b/com.unity.netcode.gameobjects/Runtime/Transports/UTP/UnityTransport.cs
@@ -868,7 +868,11 @@ private void SendBatchedMessages(SendTarget sendTarget, BatchedSendQueue queue)
             var mtu = 0;
             if (NetworkManager)
             {
-                var ngoClientId = NetworkManager.ConnectionManager.TransportIdToClientId(sendTarget.ClientId);
+                var (ngoClientId, isConnectedClient) = NetworkManager.ConnectionManager.TransportIdToClientId(sendTarget.ClientId);
+                if (!isConnectedClient)
+                {
+                    return;
+                }
                 mtu = NetworkManager.GetPeerMTU(ngoClientId);
             }
 
@@ -1278,7 +1282,7 @@ public override ulong GetCurrentRtt(ulong clientId)
 
             if (NetworkManager != null)
             {
-                var transportId = NetworkManager.ConnectionManager.ClientIdToTransportId(clientId);
+                var (transportId, _) = NetworkManager.ConnectionManager.ClientIdToTransportId(clientId);
 
                 var rtt = ExtractRtt(ParseClientId(transportId));
                 if (rtt > 0)
@@ -1290,7 +1294,6 @@ public override ulong GetCurrentRtt(ulong clientId)
             return (ulong)ExtractRtt(ParseClientId(clientId));
         }
 
-#if UTP_TRANSPORT_2_0_ABOVE
         /// <summary>
         /// Provides the <see cref="NetworkEndpoint"/> for the NGO client identifier specified.
         /// </summary>
@@ -1305,40 +1308,19 @@ public NetworkEndpoint GetEndpoint(ulong clientId)
         {
             if (m_Driver.IsCreated && NetworkManager != null && NetworkManager.IsListening)
             {
-                var transportId = NetworkManager.ConnectionManager.ClientIdToTransportId(clientId);
+                var (transportId, connectionExists) = NetworkManager.ConnectionManager.ClientIdToTransportId(clientId);
                 var networkConnection = ParseClientId(transportId);
-                if (m_Driver.GetConnectionState(networkConnection) == NetworkConnection.State.Connected)
+                if (connectionExists && m_Driver.GetConnectionState(networkConnection) == NetworkConnection.State.Connected)
                 {
+#if UTP_TRANSPORT_2_0_ABOVE
                     return m_Driver.GetRemoteEndpoint(networkConnection);
-                }
-            }
-            return new NetworkEndpoint();
-        }
 #else
-        /// <summary>
-        /// Provides the <see cref="NetworkEndpoint"/> for the NGO client identifier specified.
-        /// </summary>
-        /// <remarks>
-        /// - This is only really useful for direct connections.
-        /// - Relay connections and clients connected using a distributed authority network topology will not provide the client's actual endpoint information.
-        /// - For LAN topologies this should work as long as it is a direct connection and not a relay connection.
-        /// </remarks>
-        /// <param name="clientId">NGO client identifier to get endpoint information about.</param>
-        /// <returns><see cref="NetworkEndpoint"/></returns>
-        public NetworkEndpoint GetEndpoint(ulong clientId)
-        {
-            if (m_Driver.IsCreated && NetworkManager != null && NetworkManager.IsListening)
-            {
-                var transportId = NetworkManager.ConnectionManager.ClientIdToTransportId(clientId);
-                var networkConnection = ParseClientId(transportId);
-                if (m_Driver.GetConnectionState(networkConnection) == NetworkConnection.State.Connected)
-                {
                     return m_Driver.RemoteEndPoint(networkConnection);
+#endif
                 }
             }
             return new NetworkEndpoint();
         }
-#endif
 
 
         /// <summary>
@@ -1460,10 +1442,17 @@ public override void Send(ulong clientId, ArraySegment<byte> payload, NetworkDel
                     // If the message is sent reliably, then we're over capacity and we can't
                     // provide any reliability guarantees anymore. Disconnect the client since at
                     // this point they're bound to become desynchronized.
+                    if (NetworkManager != null)
+                    {
+                        var (ngoClientId, isConnectedClient) = NetworkManager.ConnectionManager.TransportIdToClientId(clientId);
+                        if (isConnectedClient)
+                        {
+                            clientId = ngoClientId;
+                        }
 
-                    var ngoClientId = NetworkManager?.ConnectionManager.TransportIdToClientId(clientId) ?? clientId;
+                    }
                     Debug.LogError($"Couldn't add payload of size {payload.Count} to reliable send queue. " +
-                        $"Closing connection {ngoClientId} as reliability guarantees can't be maintained.");
+                        $"Closing connection {clientId} as reliability guarantees can't be maintained.");
 
                     if (clientId == m_ServerClientId)
                     {
diff --git a/com.unity.netcode.gameobjects/TestHelpers/Runtime/NetcodeIntegrationTest.cs b/com.unity.netcode.gameobjects/TestHelpers/Runtime/NetcodeIntegrationTest.cs
@@ -287,6 +287,17 @@ public enum HostOrServer
         /// </summary>
         protected virtual bool m_EnableTimeTravel => false;
 
+        /// <summary>
+        /// When true, <see cref="CreateServerAndClients()"/> and <see cref="CreateNewClient"/> will use a <see cref="MockTransport"/>
+        /// as the <see cref="NetworkConfig.NetworkTransport"/> on the created server and/or clients.
+        /// When false, a <see cref="UnityTransport"/> is used.
+        /// </summary>
+        /// <remarks>
+        /// This defaults to, and is required to be true when <see cref="m_EnableTimeTravel"/> is true.
+        /// <see cref="m_EnableTimeTravel"/> will not work with the <see cref="UnityTransport"/> component.
+        /// </remarks>
+        protected virtual bool m_UseMockTransport => m_EnableTimeTravel;
+
         /// <summary>
         /// If this is false, SetUp will call OnInlineSetUp instead of OnSetUp.
         /// This is a performance advantage when not using the coroutine functionality, as a coroutine that
@@ -407,7 +418,7 @@ public IEnumerator SetUp()
         {
             VerboseDebug($"Entering {nameof(SetUp)}");
             NetcodeLogAssert = new NetcodeLogAssert();
-            if (m_EnableTimeTravel)
+            if (m_UseMockTransport)
             {
                 if (m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.AllTests)
                 {
@@ -417,9 +428,14 @@ public IEnumerator SetUp()
                 {
                     MockTransport.Reset();
                 }
-                // Setup the frames per tick for time travel advance to next tick
+            }
+
+            // Setup the frames per tick for time travel advance to next tick
+            if (m_EnableTimeTravel)
+            {
                 ConfigureFramesPerTick();
             }
+
             if (m_SetupIsACoroutine)
             {
                 yield return OnSetup();
@@ -577,7 +593,7 @@ protected virtual bool ShouldWaitForNewClientToConnect(NetworkManager networkMan
         /// <returns>An IEnumerator for use with Unity's coroutine system.</returns>
         protected IEnumerator CreateAndStartNewClient()
         {
-            var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_EnableTimeTravel);
+            var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_UseMockTransport);
             networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
 
             // Notification that the new client (NetworkManager) has been created
@@ -619,7 +635,7 @@ protected IEnumerator CreateAndStartNewClient()
         /// </summary>
         protected void CreateAndStartNewClientWithTimeTravel()
         {
-            var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_EnableTimeTravel);
+            var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_UseMockTransport);
             networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
 
             // Notification that the new client (NetworkManager) has been created
@@ -732,7 +748,7 @@ protected void CreateServerAndClients(int numberOfClients)
             }
 
             // Create multiple NetworkManager instances
-            if (!NetcodeIntegrationTestHelpers.Create(numberOfClients, out NetworkManager server, out NetworkManager[] clients, m_TargetFrameRate, m_CreateServerFirst, m_EnableTimeTravel))
+            if (!NetcodeIntegrationTestHelpers.Create(numberOfClients, out NetworkManager server, out NetworkManager[] clients, m_TargetFrameRate, m_CreateServerFirst, m_UseMockTransport))
             {
                 Debug.LogError("Failed to create instances");
                 Assert.Fail("Failed to create instances");
@@ -1219,7 +1235,7 @@ public IEnumerator TearDown()
             VerboseDebug($"Exiting {nameof(TearDown)}");
             LogWaitForMessages();
             NetcodeLogAssert.Dispose();
-            if (m_EnableTimeTravel)
+            if (m_UseMockTransport)
             {
                 if (m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.AllTests)
                 {
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/DisconnectTests.cs b/com.unity.netcode.gameobjects/Tests/Runtime/DisconnectTests.cs
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/Transports/TransportTests.cs b/com.unity.netcode.gameobjects/Tests/Runtime/Transports/TransportTests.cs
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/Transports/TransportTests.cs.meta b/com.unity.netcode.gameobjects/Tests/Runtime/Transports/TransportTests.cs.meta

Original file line number	Diff line number	Diff line change
`@@ -317,45 +317,45 @@ internal void RemovePendingClient(ulong clientId)`
`317`	`317`	`private ulong m_NextClientId = 1;`
`318`	`318`
`319`	`319`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`320`		`- internal ulong TransportIdToClientId(ulong transportId)`
	`320`	`+ internal (ulong, bool) TransportIdToClientId(ulong transportId)`
`321`	`321`	`{`
`322`	`322`	`if (transportId == GetServerTransportId())`
`323`	`323`	`{`
`324`		`- return NetworkManager.ServerClientId;`
	`324`	`+ return (NetworkManager.ServerClientId, true);`
`325`	`325`	`}`
`326`	`326`
`327`	`327`	`if (TransportIdToClientIdMap.TryGetValue(transportId, out var clientId))`
`328`	`328`	`{`
`329`		`- return clientId;`
	`329`	`+ return (clientId, true);`
`330`	`330`	`}`
`331`	`331`
`332`	`332`	`if (NetworkLog.CurrentLogLevel == LogLevel.Developer)`
`333`	`333`	`{`
`334`	`334`	`NetworkLog.LogWarning($"Trying to get the NGO client ID map for the transport ID ({transportId}) but did not find the map entry! Returning default transport ID value.");`
`335`	`335`	`}`
`336`	`336`
`337`		`- return default;`
	`337`	`+ return (0, false);`
`338`	`338`	`}`
`339`	`339`
`340`	`340`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`341`		`- internal ulong ClientIdToTransportId(ulong clientId)`
	`341`	`+ internal (ulong, bool) ClientIdToTransportId(ulong clientId)`
`342`	`342`	`{`
`343`	`343`	`if (clientId == NetworkManager.ServerClientId)`
`344`	`344`	`{`
`345`		`- return GetServerTransportId();`
	`345`	`+ return (GetServerTransportId(), true);`
`346`	`346`	`}`
`347`	`347`
`348`	`348`	`if (ClientIdToTransportIdMap.TryGetValue(clientId, out var transportClientId))`
`349`	`349`	`{`
`350`		`- return transportClientId;`
	`350`	`+ return (transportClientId, true);`
`351`	`351`	`}`
`352`	`352`
`353`	`353`	`if (NetworkLog.CurrentLogLevel == LogLevel.Developer)`
`354`	`354`	`{`
`355`	`355`	`NetworkLog.LogWarning($"Trying to get the transport client ID map for the NGO client ID ({clientId}) but did not find the map entry! Returning default transport ID value.");`
`356`	`356`	`}`
`357`	`357`
`358`		`- return default;`
	`358`	`+ return (0, false);`
`359`	`359`	`}`
`360`	`360`
`361`	`361`	`/// <summary>`
`@@ -384,19 +384,24 @@ private ulong GetServerTransportId()`
`384`	`384`	`/// Handles cleaning up the transport id/client id tables after receiving a disconnect event from transport.`
`385`	`385`	`/// </summary>`
`386`	`386`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`387`		`- internal ulong TransportIdCleanUp(ulong transportId)`
	`387`	`+ internal (ulong, bool) TransportIdCleanUp(ulong transportId)`
`388`	`388`	`{`
`389`	`389`	`// This check is for clients that attempted to connect but failed.`
`390`	`390`	`// When this happens, the client will not have an entry within the m_TransportIdToClientIdMap or m_ClientIdToTransportIdMap lookup tables so we exit early and just return 0 to be used for the disconnect event.`
`391`	`391`	`if (!LocalClient.IsServer && !TransportIdToClientIdMap.ContainsKey(transportId))`
`392`	`392`	`{`
`393`		`- return NetworkManager.LocalClientId;`
	`393`	`+ return (NetworkManager.LocalClientId, true);`
	`394`	`+ }`
	`395`	`+`
	`396`	`+ var (clientId, isConnectedClient) = TransportIdToClientId(transportId);`
	`397`	`+ if (!isConnectedClient)`
	`398`	`+ {`
	`399`	`+ return (default, false);`
`394`	`400`	`}`
`395`	`401`
`396`		`- var clientId = TransportIdToClientId(transportId);`
`397`	`402`	`TransportIdToClientIdMap.Remove(transportId);`
`398`	`403`	`ClientIdToTransportIdMap.Remove(clientId);`
`399`		`- return clientId;`
	`404`	`+ return (clientId, true);`
`400`	`405`	`}`
`401`	`406`
`402`	`407`	`internal void PollAndHandleNetworkEvents()`
`@@ -502,8 +507,11 @@ internal void DataEventHandler(ulong transportClientId, ref ArraySegment<byte> p`
`502`	`507`	`#if DEVELOPMENT_BUILD \|\| UNITY_EDITOR`
`503`	`508`	`s_HandleIncomingData.Begin();`
`504`	`509`	`#endif`
`505`		`- var clientId = TransportIdToClientId(transportClientId);`
`506`		`- MessageManager.HandleIncomingData(clientId, payload, receiveTime);`
	`510`	`+ var (clientId, isConnectedClient) = TransportIdToClientId(transportClientId);`
	`511`	`+ if (isConnectedClient)`
	`512`	`+ {`
	`513`	`+ MessageManager.HandleIncomingData(clientId, payload, receiveTime);`
	`514`	`+ }`
`507`	`515`
`508`	`516`	`#if DEVELOPMENT_BUILD \|\| UNITY_EDITOR`
`509`	`517`	`s_HandleIncomingData.End();`
`@@ -515,10 +523,15 @@ internal void DataEventHandler(ulong transportClientId, ref ArraySegment<byte> p`
`515`	`523`	`/// </summary>`
`516`	`524`	`internal void DisconnectEventHandler(ulong transportClientId)`
`517`	`525`	`{`
	`526`	`+ var (clientId, wasConnectedClient) = TransportIdCleanUp(transportClientId);`
	`527`	`+ if (!wasConnectedClient)`
	`528`	`+ {`
	`529`	`+ return;`
	`530`	`+ }`
	`531`	`+`
`518`	`532`	`#if DEVELOPMENT_BUILD \|\| UNITY_EDITOR`
`519`	`533`	`s_TransportDisconnect.Begin();`
`520`	`534`	`#endif`
`521`		`- var clientId = TransportIdCleanUp(transportClientId);`
`522`	`535`	`if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)`
`523`	`536`	`{`
`524`	`537`	`NetworkLog.LogInfo($"Disconnect Event From {clientId}");`
`@@ -1040,9 +1053,9 @@ internal void OnClientDisconnectFromServer(ulong clientId)`
`1040`	`1053`	`}`
`1041`	`1054`
`1042`	`1055`	`// If the client ID transport map exists`
`1043`		`- if (ClientIdToTransportIdMap.ContainsKey(clientId))`
	`1056`	`+ var (transportId, isConnected) = ClientIdToTransportId(clientId);`
	`1057`	`+ if (isConnected)`
`1044`	`1058`	`{`
`1045`		`- var transportId = ClientIdToTransportId(clientId);`
`1046`	`1059`	`NetworkManager.NetworkConfig.NetworkTransport.DisconnectRemoteClient(transportId);`
`1047`	`1060`
`1048`	`1061`	`InvokeOnClientDisconnectCallback(clientId);`
Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,19 @@ public DefaultMessageSender(NetworkManager manager)`
`19`	`19`	`public void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData)`
`20`	`20`	`{`
`21`	`21`	`var sendBuffer = batchData.ToTempByteArray();`
	`22`	`+ var (transportId, clientExists) = m_ConnectionManager.ClientIdToTransportId(clientId);`
`22`	`23`
`23`		`- m_NetworkTransport.Send(m_ConnectionManager.ClientIdToTransportId(clientId), sendBuffer, delivery);`
	`24`	`+ if (!clientExists)`
	`25`	`+ {`
	`26`	`+ if (m_ConnectionManager.NetworkManager.LogLevel <= LogLevel.Error)`
	`27`	`+ {`
	`28`	`+ NetworkLog.LogWarning("Trying to send a message to a client who doesn't have a transport connection");`
	`29`	`+ }`
	`30`	`+`
	`31`	`+ return;`
	`32`	`+ }`
	`33`	`+`
	`34`	`+ m_NetworkTransport.Send(transportId, sendBuffer, delivery);`
`24`	`35`	`}`
`25`	`36`	`}`
`26`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -287,6 +287,17 @@ public enum HostOrServer`
`287`	`287`	`/// </summary>`
`288`	`288`	`protected virtual bool m_EnableTimeTravel => false;`
`289`	`289`
	`290`	`+ /// <summary>`
	`291`	`+ /// When true, <see cref="CreateServerAndClients()"/> and <see cref="CreateNewClient"/> will use a <see cref="MockTransport"/>`
	`292`	`+ /// as the <see cref="NetworkConfig.NetworkTransport"/> on the created server and/or clients.`
	`293`	`+ /// When false, a <see cref="UnityTransport"/> is used.`
	`294`	`+ /// </summary>`
	`295`	`+ /// <remarks>`
	`296`	`+ /// This defaults to, and is required to be true when <see cref="m_EnableTimeTravel"/> is true.`
	`297`	`+ /// <see cref="m_EnableTimeTravel"/> will not work with the <see cref="UnityTransport"/> component.`
	`298`	`+ /// </remarks>`
	`299`	`+ protected virtual bool m_UseMockTransport => m_EnableTimeTravel;`
	`300`	`+`
`290`	`301`	`/// <summary>`
`291`	`302`	`/// If this is false, SetUp will call OnInlineSetUp instead of OnSetUp.`
`292`	`303`	`/// This is a performance advantage when not using the coroutine functionality, as a coroutine that`
`@@ -407,7 +418,7 @@ public IEnumerator SetUp()`
`407`	`418`	`{`
`408`	`419`	`VerboseDebug($"Entering {nameof(SetUp)}");`
`409`	`420`	`NetcodeLogAssert = new NetcodeLogAssert();`
`410`		`- if (m_EnableTimeTravel)`
	`421`	`+ if (m_UseMockTransport)`
`411`	`422`	`{`
`412`	`423`	`if (m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.AllTests)`
`413`	`424`	`{`
`@@ -417,9 +428,14 @@ public IEnumerator SetUp()`
`417`	`428`	`{`
`418`	`429`	`MockTransport.Reset();`
`419`	`430`	`}`
`420`		`- // Setup the frames per tick for time travel advance to next tick`
	`431`	`+ }`
	`432`	`+`
	`433`	`+ // Setup the frames per tick for time travel advance to next tick`
	`434`	`+ if (m_EnableTimeTravel)`
	`435`	`+ {`
`421`	`436`	`ConfigureFramesPerTick();`
`422`	`437`	`}`
	`438`	`+`
`423`	`439`	`if (m_SetupIsACoroutine)`
`424`	`440`	`{`
`425`	`441`	`yield return OnSetup();`
`@@ -577,7 +593,7 @@ protected virtual bool ShouldWaitForNewClientToConnect(NetworkManager networkMan`
`577`	`593`	`/// <returns>An IEnumerator for use with Unity's coroutine system.</returns>`
`578`	`594`	`protected IEnumerator CreateAndStartNewClient()`
`579`	`595`	`{`
`580`		`- var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_EnableTimeTravel);`
	`596`	`+ var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_UseMockTransport);`
`581`	`597`	`networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;`
`582`	`598`
`583`	`599`	`// Notification that the new client (NetworkManager) has been created`
`@@ -619,7 +635,7 @@ protected IEnumerator CreateAndStartNewClient()`
`619`	`635`	`/// </summary>`
`620`	`636`	`protected void CreateAndStartNewClientWithTimeTravel()`
`621`	`637`	`{`
`622`		`- var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_EnableTimeTravel);`
	`638`	`+ var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_UseMockTransport);`
`623`	`639`	`networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;`
`624`	`640`
`625`	`641`	`// Notification that the new client (NetworkManager) has been created`
`@@ -732,7 +748,7 @@ protected void CreateServerAndClients(int numberOfClients)`
`732`	`748`	`}`
`733`	`749`
`734`	`750`	`// Create multiple NetworkManager instances`
`735`		`- if (!NetcodeIntegrationTestHelpers.Create(numberOfClients, out NetworkManager server, out NetworkManager[] clients, m_TargetFrameRate, m_CreateServerFirst, m_EnableTimeTravel))`
	`751`	`+ if (!NetcodeIntegrationTestHelpers.Create(numberOfClients, out NetworkManager server, out NetworkManager[] clients, m_TargetFrameRate, m_CreateServerFirst, m_UseMockTransport))`
`736`	`752`	`{`
`737`	`753`	`Debug.LogError("Failed to create instances");`
`738`	`754`	`Assert.Fail("Failed to create instances");`
`@@ -1219,7 +1235,7 @@ public IEnumerator TearDown()`
`1219`	`1235`	`VerboseDebug($"Exiting {nameof(TearDown)}");`
`1220`	`1236`	`LogWaitForMessages();`
`1221`	`1237`	`NetcodeLogAssert.Dispose();`
`1222`		`- if (m_EnableTimeTravel)`
	`1238`	`+ if (m_UseMockTransport)`
`1223`	`1239`	`{`
`1224`	`1240`	`if (m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.AllTests)`
`1225`	`1241`	`{`