com.unity.netcode.gameobjects@2.2.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). ## [2.2.0] - 2024-12-12 ### Added - Added `NetworkObject.OwnershipStatus.SessionOwner` to allow Network Objects to be distributable and only owned by the Session Owner. This flag will override all other `OwnershipStatus` flags. (#3175) - Added `UnityTransport.GetEndpoint` method to provide a way to obtain `NetworkEndpoint` information of a connection via client identifier. (#3130) - Added `NetworkTransport.OnEarlyUpdate` and `NetworkTransport.OnPostLateUpdate` methods to provide more control over handling transport related events at the start and end of each frame. (#3113) ### Fixed - Fixed issue where the server, host, or session owner would not populate the in-scene place `NetworkObject` table if the scene was loaded prior to starting the `NetworkManager`. (#3177) - Fixed issue where the `NetworkObjectIdHash` value could be incorrect when entering play mode while still in prefab edit mode with pending changes and using MPPM. (#3162) - Fixed issue where a sever only `NetworkManager` instance would spawn the actual `NetworkPrefab`'s `GameObject` as opposed to creating an instance of it. (#3160) - Fixed issue where only the session owner (as opposed to all clients) would handle spawning prefab overrides properly when using a distributed authority network topology. (#3160) - Fixed issue where an exception was thrown when calling `NetworkManager.Shutdown` after calling `UnityTransport.Shutdown`. (#3118) - Fixed issue where `NetworkList` properties on in-scene placed `NetworkObject`s could cause small memory leaks when entering playmode. (#3147) - Fixed in-scene `NertworkObject` synchronization issue when loading a scene with currently connected clients connected to a session created by a `NetworkManager` started as a server (i.e. not as a host). (#3133) - Fixed issue where a `NetworkManager` started as a server would not add itself as an observer to in-scene placed `NetworkObject`s instantiated and spawned by a scene loading event. (#3133) - Fixed issue where spawning a player using `NetworkObject.InstantiateAndSpawn` or `NetworkSpawnManager.InstantiateAndSpawn` would not update the `NetworkSpawnManager.PlayerObjects` or assign the newly spawned player to the `NetworkClient.PlayerObject`. (#3122) - Fixed issue where queued UnitTransport (NetworkTransport) message batches were being sent on the next frame. They are now sent at the end of the frame during `PostLateUpdate`. (#3113) - Fixed issue where `NotOwnerRpcTarget` or `OwnerRpcTarget` were not using their replacements `NotAuthorityRpcTarget` and `AuthorityRpcTarget` which would invoke a warning. (#3111) - Fixed issue where client is removed as an observer from spawned objects when their player instance is despawned. (#3110) - Fixed issue where `NetworkAnimator` would statically allocate write buffer space for `Animator` parameters that could cause a write error if the number of parameters exceeded the space allocated. (#3108) ### Changed - In-scene placed `NetworkObject`s have been made distributable when balancing object distribution after a connection event. (#3175) - Optimised `NetworkVariable` and `NetworkTransform` related packets when in Distributed Authority mode. - The Debug Simulator section of the Unity Transport component was removed. This section was not functional anymore and users are now recommended to use the more featureful [Network Simulator](https://docs-multiplayer.unity3d.com/tools/current/tools-network-simulator/) tool from the Multiplayer Tools package instead. (#3121)
2024-12-12 00:00:00 +00:00
parent 016788c21e
commit 8fe07bbad2
78 changed files with 2243 additions and 1187 deletions
--- a/Tests/Runtime/Prefabs/NetworkPrefabHandlerTests.cs
+++ b/Tests/Runtime/Prefabs/NetworkPrefabHandlerTests.cs
@@ -0,0 +1,245 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Unity.Netcode.TestHelpers.Runtime;
+using UnityEngine;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    /// <summary>
+    /// The NetworkPrefabHandler unit tests validates:
+    /// Registering with GameObject, NetworkObject, or GlobalObjectIdHash
+    /// Newly assigned rotation or position values for newly spawned NetworkObject instances are valid
+    /// Destroying a newly spawned NetworkObject instance works
+    /// Removing a INetworkPrefabInstanceHandler is removed and can be verified (very last check)
+    /// </summary>
+    internal class NetworkPrefabHandlerTests
+    {
+
+        private const string k_TestPrefabObjectName = "NetworkPrefabTestObject";
+        private uint m_ObjectId = 1;
+        private GameObject MakeValidNetworkPrefab()
+        {
+            Guid baseObjectID = NetworkManagerHelper.AddGameNetworkObject(k_TestPrefabObjectName + m_ObjectId.ToString());
+            NetworkObject validPrefab = NetworkManagerHelper.InstantiatedNetworkObjects[baseObjectID];
+            NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(validPrefab);
+            m_ObjectId++;
+            return validPrefab.gameObject;
+        }
+
+        /// <summary>
+        /// Tests the NetwokConfig NetworkPrefabsList initialization during NetworkManager's Init method to make sure that
+        /// it will still initialize but remove the invalid prefabs
+        /// </summary>
+        [Test]
+        public void NetworkConfigInvalidNetworkPrefabTest()
+        {
+
+            // Add null entry
+            NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(null);
+
+            // Add a NetworkPrefab with no prefab
+            NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab());
+
+            // Add a NetworkPrefab override with an invalid hash
+            NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Hash, SourceHashToOverride = 0 });
+
+            // Add a NetworkPrefab override with a valid hash but an invalid target prefab
+            NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Hash, SourceHashToOverride = 654321, OverridingTargetPrefab = null });
+
+            // Add a NetworkPrefab override with a valid hash to override but an invalid target prefab
+            NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourceHashToOverride = 654321, OverridingTargetPrefab = null });
+
+            // Add a NetworkPrefab override with an invalid source prefab to override
+            NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourcePrefabToOverride = null });
+
+            // Add a NetworkPrefab override with a valid source prefab to override but an invalid target prefab
+            NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourcePrefabToOverride = MakeValidNetworkPrefab(), OverridingTargetPrefab = null });
+
+            // Add a valid prefab
+            NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Prefab = MakeValidNetworkPrefab() });
+
+            // Add a NetworkPrefab override with a valid hash and valid target prefab
+            NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Hash, SourceHashToOverride = 11111111, OverridingTargetPrefab = MakeValidNetworkPrefab() });
+
+            // Add a NetworkPrefab override with a valid prefab and valid target prefab
+            NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.Add(new NetworkPrefab() { Override = NetworkPrefabOverride.Prefab, SourcePrefabToOverride = MakeValidNetworkPrefab(), OverridingTargetPrefab = MakeValidNetworkPrefab() });
+
+            var exceptionOccurred = false;
+            try
+            {
+                NetworkManagerHelper.NetworkManagerObject.StartHost();
+            }
+            catch
+            {
+                exceptionOccurred = true;
+            }
+
+            Assert.False(exceptionOccurred);
+
+            // In the end we should only have 3 valid registered network prefabs
+            Assert.True(NetworkManagerHelper.NetworkManagerObject.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.Count == 3);
+        }
+
+        private const string k_PrefabObjectName = "NetworkPrefabHandlerTestObject";
+
+        [Test]
+        public void NetworkPrefabHandlerClass([Values] bool distributedAuthority)
+        {
+            var networkConfig = new NetworkConfig()
+            {
+                NetworkTopology = distributedAuthority ? NetworkTopologyTypes.DistributedAuthority : NetworkTopologyTypes.ClientServer,
+            };
+
+            Assert.IsTrue(NetworkManagerHelper.StartNetworkManager(out _, networkConfig: networkConfig));
+            var testPrefabObjectName = k_PrefabObjectName;
+
+            Guid baseObjectID = NetworkManagerHelper.AddGameNetworkObject(testPrefabObjectName);
+            NetworkObject baseObject = NetworkManagerHelper.InstantiatedNetworkObjects[baseObjectID];
+
+            var networkPrefabHandler = new NetworkPrefabHandler();
+            var networkPrefaInstanceHandler = new NetworkPrefaInstanceHandler(baseObject);
+
+            var prefabPosition = new Vector3(1.0f, 5.0f, 3.0f);
+            var prefabRotation = new Quaternion(1.0f, 0.5f, 0.4f, 0.1f);
+
+            //Register via GameObject
+            var gameObjectRegistered = networkPrefabHandler.AddHandler(baseObject.gameObject, networkPrefaInstanceHandler);
+
+            //Test result of registering via GameObject reference
+            Assert.True(gameObjectRegistered);
+
+            var spawnedObject = networkPrefabHandler.HandleNetworkPrefabSpawn(baseObject.GlobalObjectIdHash, 0, prefabPosition, prefabRotation);
+
+            //Test that something was instantiated
+            Assert.NotNull(spawnedObject);
+
+            //Test that this is indeed an instance of our original object
+            Assert.True(spawnedObject.name.Contains(testPrefabObjectName));
+
+            //Test for position and rotation
+            Assert.True(prefabPosition == spawnedObject.transform.position);
+            Assert.True(prefabRotation == spawnedObject.transform.rotation);
+
+            networkPrefabHandler.HandleNetworkPrefabDestroy(spawnedObject);     //Destroy our prefab instance
+            networkPrefabHandler.RemoveHandler(baseObject);                     //Remove our handler
+
+            //Register via NetworkObject
+            gameObjectRegistered = networkPrefabHandler.AddHandler(baseObject, networkPrefaInstanceHandler);
+
+            //Test result of registering via NetworkObject reference
+            Assert.True(gameObjectRegistered);
+
+            //Change it up
+            prefabPosition = new Vector3(2.0f, 1.0f, 5.0f);
+            prefabRotation = new Quaternion(4.0f, 1.5f, 5.4f, 5.1f);
+
+            spawnedObject = networkPrefabHandler.HandleNetworkPrefabSpawn(baseObject.GlobalObjectIdHash, 0, prefabPosition, prefabRotation);
+
+            //Test that something was instantiated
+            Assert.NotNull(spawnedObject);
+
+            //Test that this is indeed an instance of our original object
+            Assert.True(spawnedObject.name.Contains(testPrefabObjectName));
+
+            //Test for position and rotation
+            Assert.True(prefabPosition == spawnedObject.transform.position);
+            Assert.True(prefabRotation == spawnedObject.transform.rotation);
+
+            networkPrefabHandler.HandleNetworkPrefabDestroy(spawnedObject);     //Destroy our prefab instance
+            networkPrefabHandler.RemoveHandler(baseObject);                     //Remove our handler
+
+            //Register via GlobalObjectIdHash
+            gameObjectRegistered = networkPrefabHandler.AddHandler(baseObject.GlobalObjectIdHash, networkPrefaInstanceHandler);
+
+            //Test result of registering via GlobalObjectIdHash reference
+            Assert.True(gameObjectRegistered);
+
+            //Change it up
+            prefabPosition = new Vector3(6.0f, 4.0f, 1.0f);
+            prefabRotation = new Quaternion(3f, 2f, 4f, 1f);
+
+            spawnedObject = networkPrefabHandler.HandleNetworkPrefabSpawn(baseObject.GlobalObjectIdHash, 0, prefabPosition, prefabRotation);
+
+            //Test that something was instantiated
+            Assert.NotNull(spawnedObject);
+
+            //Test that this is indeed an instance of our original object
+            Assert.True(spawnedObject.name.Contains(testPrefabObjectName));
+
+            //Test for position and rotation
+            Assert.True(prefabPosition == spawnedObject.transform.position);
+            Assert.True(prefabRotation == spawnedObject.transform.rotation);
+
+            networkPrefabHandler.HandleNetworkPrefabDestroy(spawnedObject);     //Destroy our prefab instance
+            networkPrefabHandler.RemoveHandler(baseObject);                     //Remove our handler
+
+            Assert.False(networkPrefaInstanceHandler.StillHasInstances());
+        }
+
+        [SetUp]
+        public void Setup()
+        {
+            //Create, instantiate, and host
+            NetworkManagerHelper.StartNetworkManager(out _, NetworkManagerHelper.NetworkManagerOperatingMode.None);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            //Stop, shutdown, and destroy
+            NetworkManagerHelper.ShutdownNetworkManager();
+
+#if UNITY_2023_1_OR_NEWER
+            var networkObjects = UnityEngine.Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID).ToList();
+#else
+            var networkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>().ToList();
+#endif
+
+            var networkObjectsList = networkObjects.Where(c => c.name.Contains(k_PrefabObjectName));
+            foreach (var networkObject in networkObjectsList)
+            {
+                UnityEngine.Object.DestroyImmediate(networkObject);
+            }
+        }
+    }
+
+    /// <summary>
+    /// The Prefab instance handler to use for this test
+    /// </summary>
+    internal class NetworkPrefaInstanceHandler : INetworkPrefabInstanceHandler
+    {
+        private NetworkObject m_NetworkObject;
+
+        private List<NetworkObject> m_Instances;
+
+        public NetworkObject Instantiate(ulong ownerClientId, Vector3 position, Quaternion rotation)
+        {
+            var networkObjectInstance = UnityEngine.Object.Instantiate(m_NetworkObject.gameObject).GetComponent<NetworkObject>();
+            networkObjectInstance.transform.position = position;
+            networkObjectInstance.transform.rotation = rotation;
+            m_Instances.Add(networkObjectInstance);
+            return networkObjectInstance;
+        }
+
+        public void Destroy(NetworkObject networkObject)
+        {
+            var instancesContainsNetworkObject = m_Instances.Contains(networkObject);
+            Assert.True(instancesContainsNetworkObject);
+            m_Instances.Remove(networkObject);
+            UnityEngine.Object.Destroy(networkObject.gameObject);
+        }
+
+        public bool StillHasInstances()
+        {
+            return (m_Instances.Count > 0);
+        }
+
+        public NetworkPrefaInstanceHandler(NetworkObject networkObject)
+        {
+            m_NetworkObject = networkObject;
+            m_Instances = new List<NetworkObject>();
+        }
+    }
+}