com.unity.netcode.gameobjects@1.4.0

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com). ## [1.4.0] - 2023-04-10 ### Added - Added a way to access the GlobalObjectIdHash via PrefabIdHash for use in the Connection Approval Callback. (#2437) - Added `OnServerStarted` and `OnServerStopped` events that will trigger only on the server (or host player) to notify that the server just started or is no longer active (#2420) - Added `OnClientStarted` and `OnClientStopped` events that will trigger only on the client (or host player) to notify that the client just started or is no longer active (#2420) - Added `NetworkTransform.UseHalfFloatPrecision` property that, when enabled, will use half float values for position, rotation, and scale. This yields a 50% bandwidth savings a the cost of precision. (#2388) - Added `NetworkTransform.UseQuaternionSynchronization` property that, when enabled, will synchronize the entire quaternion. (#2388) - Added `NetworkTransform.UseQuaternionCompression` property that, when enabled, will use a smallest three implementation reducing a full quaternion synchronization update to the size of an unsigned integer. (#2388) - Added `NetworkTransform.SlerpPosition` property that, when enabled along with interpolation being enabled, will interpolate using `Vector3.Slerp`. (#2388) - Added `BufferedLinearInterpolatorVector3` that replaces the float version, is now used by `NetworkTransform`, and provides the ability to enable or disable `Slerp`. (#2388) - Added `HalfVector3` used for scale when half float precision is enabled. (#2388) - Added `HalfVector4` used for rotation when half float precision and quaternion synchronization is enabled. (#2388) - Added `HalfVector3DeltaPosition` used for position when half float precision is enabled. This handles loss in position precision by updating only the delta position as opposed to the full position. (#2388) - Added `NetworkTransform.GetSpaceRelativePosition` and `NetworkTransform.GetSpaceRelativeRotation` helper methods to return the proper values depending upon whether local or world space. (#2388) - Added `NetworkTransform.OnAuthorityPushTransformState` virtual method that is invoked just prior to sending the `NetworkTransformState` to non-authoritative instances. This provides users with the ability to obtain more precise delta values for prediction related calculations. (#2388) - Added `NetworkTransform.OnNetworkTransformStateUpdated` virtual method that is invoked just after the authoritative `NetworkTransformState` is applied. This provides users with the ability to obtain more precise delta values for prediction related calculations. (#2388) - Added `NetworkTransform.OnInitialize`virtual method that is invoked after the `NetworkTransform` has been initialized or re-initialized when ownership changes. This provides for a way to make adjustments when `NetworkTransform` is initialized (i.e. resetting client prediction etc) (#2388) - Added `NetworkObject.SynchronizeTransform` property (default is true) that provides users with another way to help with bandwidth optimizations where, when set to false, the `NetworkObject`'s associated transform will not be included when spawning and/or synchronizing late joining players. (#2388) - Added `NetworkSceneManager.ActiveSceneSynchronizationEnabled` property, disabled by default, that enables client synchronization of server-side active scene changes. (#2383) - Added `NetworkObject.ActiveSceneSynchronization`, disabled by default, that will automatically migrate a `NetworkObject` to a newly assigned active scene. (#2383) - Added `NetworkObject.SceneMigrationSynchronization`, enabled by default, that will synchronize client(s) when a `NetworkObject` is migrated into a new scene on the server side via `SceneManager.MoveGameObjectToScene`. (#2383) ### Changed - Made sure the `CheckObjectVisibility` delegate is checked and applied, upon `NetworkShow` attempt. Found while supporting (#2454), although this is not a fix for this (already fixed) issue. (#2463) - Changed `NetworkTransform` authority handles delta checks on each new network tick and no longer consumes processing cycles checking for deltas for all frames in-between ticks. (#2388) - Changed the `NetworkTransformState` structure is now public and now has public methods that provide access to key properties of the `NetworkTransformState` structure. (#2388) - Changed `NetworkTransform` interpolation adjusts its interpolation "ticks ago" to be 2 ticks latent if it is owner authoritative and the instance is not the server or 1 tick latent if the instance is the server and/or is server authoritative. (#2388) - Updated `NetworkSceneManager` to migrate dynamically spawned `NetworkObject`s with `DestroyWithScene` set to false into the active scene if their current scene is unloaded. (#2383) - Updated the server to synchronize its local `NetworkSceneManager.ClientSynchronizationMode` during the initial client synchronization. (#2383) ### Fixed - Fixed issue where during client synchronization the synchronizing client could receive a ObjectSceneChanged message before the client-side NetworkObject instance had been instantiated and spawned. (#2502) - Fixed issue where `NetworkAnimator` was building client RPC parameters to exclude the host from sending itself messages but was not including it in the ClientRpc parameters. (#2492) - Fixed issue where `NetworkAnimator` was not properly detecting and synchronizing cross fade initiated transitions. (#2481) - Fixed issue where `NetworkAnimator` was not properly synchronizing animation state updates. (#2481) - Fixed float NetworkVariables not being rendered properly in the inspector of NetworkObjects. (#2441) - Fixed an issue where Named Message Handlers could remove themselves causing an exception when the metrics tried to access the name of the message.(#2426) - Fixed registry of public `NetworkVariable`s in derived `NetworkBehaviour`s (#2423) - Fixed issue where runtime association of `Animator` properties to `AnimationCurve`s would cause `NetworkAnimator` to attempt to update those changes. (#2416) - Fixed issue where `NetworkAnimator` would not check if its associated `Animator` was valid during serialization and would spam exceptions in the editor console. (#2416) - Fixed issue with a child's rotation rolling over when interpolation is enabled on a `NetworkTransform`. Now using half precision or full quaternion synchronization will always update all axis. (#2388) - Fixed issue where `NetworkTransform` was not setting the teleport flag when the `NetworkTransform.InLocalSpace` value changed. This issue only impacted `NetworkTransform` when interpolation was enabled. (#2388) - Fixed issue when the `NetworkSceneManager.ClientSynchronizationMode` is `LoadSceneMode.Additive` and the server changes the currently active scene prior to a client connecting then upon a client connecting and being synchronized the NetworkSceneManager would clear its internal ScenePlacedObjects list that could already be populated. (#2383) - Fixed issue where a client would load duplicate scenes of already preloaded scenes during the initial client synchronization and `NetworkSceneManager.ClientSynchronizationMode` was set to `LoadSceneMode.Additive`. (#2383)
2023-04-10 00:00:00 +00:00
parent 8060718e04
commit b5abc3ff7c
138 changed files with 7892 additions and 1852 deletions
--- a/Tests/Runtime/NetworkManagerEventsTests.cs
+++ b/Tests/Runtime/NetworkManagerEventsTests.cs
@@ -0,0 +1,258 @@
+using System;
+using System.Collections;
+using NUnit.Framework;
+using Unity.Netcode.TestHelpers.Runtime;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    public class NetworkManagerEventsTests
+    {
+        private NetworkManager m_ClientManager;
+        private NetworkManager m_ServerManager;
+
+        [UnityTest]
+        public IEnumerator OnServerStoppedCalledWhenServerStops()
+        {
+            bool callbackInvoked = false;
+            var gameObject = new GameObject(nameof(OnServerStoppedCalledWhenServerStops));
+            m_ServerManager = gameObject.AddComponent<NetworkManager>();
+
+            // Set dummy transport that does nothing
+            var transport = gameObject.AddComponent<DummyTransport>();
+            m_ServerManager.NetworkConfig = new NetworkConfig() { NetworkTransport = transport };
+
+            Action<bool> onServerStopped = (bool wasAlsoClient) =>
+            {
+                callbackInvoked = true;
+                Assert.IsFalse(wasAlsoClient);
+                if (m_ServerManager.IsServer)
+                {
+                    Assert.Fail("OnServerStopped called when the server is still active");
+                }
+            };
+
+            // Start server to cause initialization process
+            Assert.True(m_ServerManager.StartServer());
+            Assert.True(m_ServerManager.IsListening);
+
+            m_ServerManager.OnServerStopped += onServerStopped;
+            m_ServerManager.Shutdown();
+            UnityEngine.Object.DestroyImmediate(gameObject);
+
+            yield return WaitUntilManagerShutsdown();
+
+            Assert.False(m_ServerManager.IsListening);
+            Assert.True(callbackInvoked, "OnServerStopped wasn't invoked");
+        }
+
+        [UnityTest]
+        public IEnumerator OnClientStoppedCalledWhenClientStops()
+        {
+            yield return InitializeServerAndAClient();
+
+            bool callbackInvoked = false;
+            Action<bool> onClientStopped = (bool wasAlsoServer) =>
+            {
+                callbackInvoked = true;
+                Assert.IsFalse(wasAlsoServer);
+                if (m_ClientManager.IsClient)
+                {
+                    Assert.Fail("onClientStopped called when the client is still active");
+                }
+            };
+
+            m_ClientManager.OnClientStopped += onClientStopped;
+            m_ClientManager.Shutdown();
+            yield return WaitUntilManagerShutsdown();
+
+            Assert.True(callbackInvoked, "OnClientStopped wasn't invoked");
+        }
+
+        [UnityTest]
+        public IEnumerator OnClientAndServerStoppedCalledWhenHostStops()
+        {
+            var gameObject = new GameObject(nameof(OnClientAndServerStoppedCalledWhenHostStops));
+            m_ServerManager = gameObject.AddComponent<NetworkManager>();
+
+            // Set dummy transport that does nothing
+            var transport = gameObject.AddComponent<DummyTransport>();
+            m_ServerManager.NetworkConfig = new NetworkConfig() { NetworkTransport = transport };
+
+            int callbacksInvoked = 0;
+            Action<bool> onClientStopped = (bool wasAlsoServer) =>
+            {
+                callbacksInvoked++;
+                Assert.IsTrue(wasAlsoServer);
+                if (m_ServerManager.IsClient)
+                {
+                    Assert.Fail("onClientStopped called when the client is still active");
+                }
+            };
+
+            Action<bool> onServerStopped = (bool wasAlsoClient) =>
+            {
+                callbacksInvoked++;
+                Assert.IsTrue(wasAlsoClient);
+                if (m_ServerManager.IsServer)
+                {
+                    Assert.Fail("OnServerStopped called when the server is still active");
+                }
+            };
+
+            // Start server to cause initialization process
+            Assert.True(m_ServerManager.StartHost());
+            Assert.True(m_ServerManager.IsListening);
+
+            m_ServerManager.OnServerStopped += onServerStopped;
+            m_ServerManager.OnClientStopped += onClientStopped;
+            m_ServerManager.Shutdown();
+            UnityEngine.Object.DestroyImmediate(gameObject);
+
+            yield return WaitUntilManagerShutsdown();
+
+            Assert.False(m_ServerManager.IsListening);
+            Assert.AreEqual(2, callbacksInvoked, "either OnServerStopped or OnClientStopped wasn't invoked");
+        }
+
+        [UnityTest]
+        public IEnumerator OnServerStartedCalledWhenServerStarts()
+        {
+            var gameObject = new GameObject(nameof(OnServerStartedCalledWhenServerStarts));
+            m_ServerManager = gameObject.AddComponent<NetworkManager>();
+
+            // Set dummy transport that does nothing
+            var transport = gameObject.AddComponent<DummyTransport>();
+            m_ServerManager.NetworkConfig = new NetworkConfig() { NetworkTransport = transport };
+
+            bool callbackInvoked = false;
+            Action onServerStarted = () =>
+            {
+                callbackInvoked = true;
+                if (!m_ServerManager.IsServer)
+                {
+                    Assert.Fail("OnServerStarted called when the server is not active yet");
+                }
+            };
+
+            // Start server to cause initialization process
+            m_ServerManager.OnServerStarted += onServerStarted;
+
+            Assert.True(m_ServerManager.StartServer());
+            Assert.True(m_ServerManager.IsListening);
+
+            yield return WaitUntilServerBufferingIsReady();
+
+            Assert.True(callbackInvoked, "OnServerStarted wasn't invoked");
+        }
+
+        [UnityTest]
+        public IEnumerator OnClientStartedCalledWhenClientStarts()
+        {
+            bool callbackInvoked = false;
+            Action onClientStarted = () =>
+            {
+                callbackInvoked = true;
+                if (!m_ClientManager.IsClient)
+                {
+                    Assert.Fail("onClientStarted called when the client is not active yet");
+                }
+            };
+
+            yield return InitializeServerAndAClient(onClientStarted);
+
+            Assert.True(callbackInvoked, "OnClientStarted wasn't invoked");
+        }
+
+        [UnityTest]
+        public IEnumerator OnClientAndServerStartedCalledWhenHostStarts()
+        {
+            var gameObject = new GameObject(nameof(OnClientAndServerStartedCalledWhenHostStarts));
+            m_ServerManager = gameObject.AddComponent<NetworkManager>();
+
+            // Set dummy transport that does nothing
+            var transport = gameObject.AddComponent<DummyTransport>();
+            m_ServerManager.NetworkConfig = new NetworkConfig() { NetworkTransport = transport };
+
+            int callbacksInvoked = 0;
+            Action onClientStarted = () =>
+            {
+                callbacksInvoked++;
+                if (!m_ServerManager.IsClient)
+                {
+                    Assert.Fail("OnClientStarted called when the client is not active yet");
+                }
+            };
+
+            Action onServerStarted = () =>
+            {
+                callbacksInvoked++;
+                if (!m_ServerManager.IsServer)
+                {
+                    Assert.Fail("OnServerStarted called when the server is not active yet");
+                }
+            };
+
+            m_ServerManager.OnServerStarted += onServerStarted;
+            m_ServerManager.OnClientStarted += onClientStarted;
+
+            // Start server to cause initialization process
+            Assert.True(m_ServerManager.StartHost());
+            Assert.True(m_ServerManager.IsListening);
+
+            yield return WaitUntilServerBufferingIsReady();
+            Assert.AreEqual(2, callbacksInvoked, "either OnServerStarted or OnClientStarted wasn't invoked");
+        }
+
+        private IEnumerator WaitUntilManagerShutsdown()
+        {
+            /* Need two updates to actually shut down. First one to see the transport failing, which
+            marks the NetworkManager as shutting down. Second one where actual shutdown occurs. */
+            yield return null;
+            yield return null;
+        }
+
+        private IEnumerator InitializeServerAndAClient(Action onClientStarted = null)
+        {
+            // Create multiple NetworkManager instances
+            if (!NetcodeIntegrationTestHelpers.Create(1, out m_ServerManager, out NetworkManager[] clients, 30))
+            {
+                Debug.LogError("Failed to create instances");
+                Assert.Fail("Failed to create instances");
+            }
+
+            // passing no clients on purpose to start them manually later
+            NetcodeIntegrationTestHelpers.Start(false, m_ServerManager, new NetworkManager[] { });
+
+            yield return WaitUntilServerBufferingIsReady();
+            m_ClientManager = clients[0];
+
+            if (onClientStarted != null)
+            {
+                m_ClientManager.OnClientStarted += onClientStarted;
+            }
+
+            Assert.True(m_ClientManager.StartClient());
+            NetcodeIntegrationTestHelpers.RegisterHandlers(clients[0]);
+            // Wait for connection on client side
+            yield return NetcodeIntegrationTestHelpers.WaitForClientsConnected(clients);
+        }
+
+        private IEnumerator WaitUntilServerBufferingIsReady()
+        {
+            /* wait until at least more than 2 server ticks have passed
+            Note: Waiting for more than 2 ticks on the server is due
+            to the time system applying buffering to the received time
+            in NetworkTimeSystem.Sync */
+            yield return new WaitUntil(() => m_ServerManager.NetworkTickSystem.ServerTime.Tick > 2);
+        }
+
+        [UnityTearDown]
+        public virtual IEnumerator Teardown()
+        {
+            NetcodeIntegrationTestHelpers.Destroy();
+            yield return null;
+        }
+    }
+}