Merge branch 'develop-2.0.0' into ci-corrections-develop-2.0.0

Author: michalChrobot

.yamato/desktop-standalone-tests.yml

@@ -70,9 +70,31 @@ desktop_standalone_test_{{ project.name }}_{{ platform.name }}_{{ backend }}_{{
     type: {% if platform.name == "mac" %} {{ platform.type }} {% else %} {{ platform.type }}::GPU {% endif %}
     image: {{ platform.image }}
     flavor: {{ platform.flavor }}
+
+# Set additional variables for running the echo server
+{% if platform.name != "win" %}
+  variables:
+    ECHO_SERVER_PORT: "7788"
+    # Set this to ensure the DA codec tests will fail if they cannot connect to the echo-server
+    # The default is to ignore the codec tests if the echo-server fails to connect
+    ENSURE_CODEC_TESTS: "true"
+{% endif %}
+
   commands:
     - unity-downloader-cli -u {{ editor }} -c Editor {% if backend == "il2cpp" %} -c il2cpp {% endif %}
     - UnifiedTestRunner --suite=playmode --player-load-path=build/players --artifacts-path=test-results --testproject={{ project.path }} --editor-location=.Editor --playergraphicsapi=Null --fail-on-assert --reruncount=1 --clean-library-on-rerun --timeout=1800
+
+# If ubuntu, run rust echo server
+{% if platform.name != "win" %}
+    - git clone https://github.com/Unity-Technologies/mps-common-multiplayer-backend.git
+    # Install rust
+    - curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+    # Build the echo server
+    - cd ./mps-common-multiplayer-backend/runtime && $HOME/.cargo/bin/cargo build --example ngo_echo_server
+    # Run the echo server in the background - this will reuse the artifacts from the build
+    - cd ./mps-common-multiplayer-backend/runtime && $HOME/.cargo/bin/cargo run --example ngo_echo_server -- --port $ECHO_SERVER_PORT &
+{% endif %}
+
   artifacts:
     logs:
       paths:

com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs

@@ -1173,16 +1173,17 @@ internal void OnClientDisconnectFromServer(ulong clientId)
                     if (ownedObject)
                     {
                         // If destroying with owner, then always despawn and destroy (or defer destroying to prefab handler)
-                        if (!ownedObject.DontDestroyWithOwner)
+                        // Handle an object with no observers other than the current disconnecting client as destroying with owner
+                        if (!ownedObject.DontDestroyWithOwner || ownedObject.Observers.Count == 0 || (ownedObject.Observers.Count == 1 && ownedObject.Observers.Contains(clientId)))
                         {
-                            if (NetworkManager.PrefabHandler.ContainsHandler(clientOwnedObjects[i].GlobalObjectIdHash))
+                            if (NetworkManager.PrefabHandler.ContainsHandler(ownedObject.GlobalObjectIdHash))
                             {
                                 if (ownedObject.IsSpawned)
                                 {
                                     // Don't destroy (prefab handler will determine this, but always notify
                                     NetworkManager.SpawnManager.DespawnObject(ownedObject, false, true);
                                 }
-                                NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(clientOwnedObjects[i]);
+                                NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(ownedObject);
                             }
                             else
                             {
@@ -1240,6 +1241,12 @@ internal void OnClientDisconnectFromServer(ulong clientId)
                                     {
                                         continue;
                                     }
+
+                                    // Skip destroy with owner objects as they will be processed by the outer loop
+                                    if (!childObject.DontDestroyWithOwner || childObject.Observers.Count == 0 || (childObject.Observers.Count == 1 && childObject.Observers.Contains(clientId)))
+                                    {
+                                        continue;
+                                    }
                                     // If the client owner disconnected, it is ok to unlock this at this point in time.
                                     if (childObject.IsOwnershipLocked)
                                     {

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

@@ -1975,8 +1975,8 @@ internal void DistributeNetworkObjects(ulong clientId)
                             // the owned distributable parent with the owned distributable children
                             foreach (var child in children)
                             {
-                                // Ignore the parent and any child that does not have the same owner or that is already owned by the currently targeted client
-                                if (child == ownerList.Value[i] || child.OwnerClientId != ownerList.Value[i].OwnerClientId || child.OwnerClientId == clientId)
+                                // Ignore any child that does not have the same owner, that is already owned by the currently targeted client, or that doesn't have the targeted client as an observer
+                                if (child == ownerList.Value[i] || child.OwnerClientId != ownerList.Value[i].OwnerClientId || child.OwnerClientId == clientId || !child.Observers.Contains(clientId))
                                 {
                                     continue;
                                 }

com.unity.netcode.gameobjects/Tests/Runtime/DistributedAuthority/DistributedAuthorityCodecTests.cs

@@ -16,6 +16,20 @@
 
 namespace Unity.Netcode.RuntimeTests
 {
+    /// <summary>
+    /// This class tests the NGO message codec between the C# SDK and the Rust runtime.
+    /// </summary>
+    /// <remarks>
+    /// These tests are run against a rust echo-server.
+    /// This server decodes incoming messages, and then re-encodes them before sending them back to the client.
+    /// Any errors in decoding or encoding messages will not echo the messages back, causing the tests to fail
+    /// No message handling logic is tested in these tests. They are only testing the codec.
+    /// The tests check if they can bind to a rust echo-server at the given address and port, if all tests are ignored.
+    /// The rust echo-server is run using `cargo run --example ngo_echo_server -- --port {port}`
+    /// The C# port can be configured using the environment variable "ECHO_SERVER_PORT"
+    /// The default behaviour when unity fails to connect to the echo-server is to ignore all tests in this class.
+    /// This can be overridden by setting the environment variable "ENSURE_CODEC_TESTS" to any value - then the tests will fail.
+    /// </remarks>
     internal class DistributedAuthorityCodecTests : NetcodeIntegrationTest
     {
         protected override int NumberOfClients => 1;
@@ -30,9 +44,19 @@ internal class DistributedAuthorityCodecTests : NetcodeIntegrationTest
         private NetworkManager Client => m_ClientNetworkManagers[0];
 
         private string m_TransportHost = Environment.GetEnvironmentVariable("NGO_HOST") ?? "127.0.0.1";
-        private const int k_TransportPort = 7777;
+        private static readonly ushort k_TransportPort = GetPortToBind();
         private const int k_ClientId = 0;
 
+        /// <summary>
+        /// Configures the port to look for the rust echo-server.
+        /// </summary>
+        /// <returns>The port from the environment variable "ECHO_SERVER_PORT" if it is set and valid; otherwise uses port 7777</returns>
+        private static ushort GetPortToBind()
+        {
+            var value = Environment.GetEnvironmentVariable("ECHO_SERVER_PORT");
+            return ushort.TryParse(value, out var configuredPort) ? configuredPort : (ushort)7777;
+        }
+
         private GameObject m_SpawnObject;
 
         internal class TestNetworkComponent : NetworkBehaviour
@@ -54,7 +78,15 @@ protected override void OnOneTimeSetup()
 #else
             if (!CanConnectToServer(m_TransportHost, k_TransportPort))
             {
-                Assert.Ignore("ignoring DA codec tests because UTP transport cannot connect to the runtime");
+                var shouldFail = Environment.GetEnvironmentVariable("ENSURE_CODEC_TESTS");
+                if (string.IsNullOrEmpty(shouldFail) || shouldFail.ToLower() == "false")
+                {
+                    Assert.Ignore($"ignoring DA codec tests because UTP transport cannot connect to the rust echo-server at {m_TransportHost}:{k_TransportPort}");
+                }
+                else
+                {
+                    Assert.Fail($"Failed to connect to the rust echo-server at {m_TransportHost}:{k_TransportPort}");
+                }
             }
 #endif
             base.OnOneTimeSetup();