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)

Tests/Runtime/Transports/UnityTransportTestHelpers.cs

@@ -36,6 +36,24 @@ namespace Unity.Netcode.RuntimeTests
             Assert.Fail("Timed out while waiting for network event.");
         }
 
+        // Wait to ensure no event is sent.
+        public static IEnumerator EnsureNoNetworkEvent(List<TransportEvent> events, float timeout = MaxNetworkEventWaitTime)
+        {
+            int initialCount = events.Count;
+            float startTime = Time.realtimeSinceStartup;
+
+            while (Time.realtimeSinceStartup - startTime < timeout)
+            {
+                if (events.Count > initialCount)
+                {
+                    Assert.Fail("Received unexpected network event.");
+                }
+
+                yield return new WaitForSeconds(0.01f);
+            }
+        }
+
+
         // Common code to initialize a UnityTransport that logs its events.
         public static void InitializeTransport(out UnityTransport transport, out List<TransportEvent> events,
             int maxPayloadSize = UnityTransport.InitialMaxPayloadSize, int maxSendQueueSize = 0, NetworkFamily family = NetworkFamily.Ipv4)
@@ -43,7 +61,7 @@ namespace Unity.Netcode.RuntimeTests
             var logger = new TransportEventLogger();
             events = logger.Events;
 
-            transport = new GameObject().AddComponent<UnityTransport>();
+            transport = new GameObject().AddComponent<UnityTransportTestComponent>();
 
             transport.OnTransportEvent += logger.HandleEvent;
             transport.MaxPayloadSize = maxPayloadSize;
@@ -91,5 +109,58 @@ namespace Unity.Netcode.RuntimeTests
                 });
             }
         }
+
+        internal class UnityTransportTestComponent : UnityTransport, INetworkUpdateSystem
+        {
+            private static List<UnityTransportTestComponent> s_Instances = new List<UnityTransportTestComponent>();
+
+            public static void CleanUp()
+            {
+                for (int i = s_Instances.Count - 1; i >= 0; i--)
+                {
+                    var instance = s_Instances[i];
+                    instance.Shutdown();
+                    DestroyImmediate(instance.gameObject);
+                }
+                s_Instances.Clear();
+            }
+
+            /// <summary>
+            /// Simulate the <see cref="NetworkManager.NetworkUpdate"/> being invoked so <see cref="UnityTransport.EarlyUpdate"/>
+            /// and <see cref="UnityTransport.PostLateUpdate"/> are invoked.
+            /// </summary>
+            public void NetworkUpdate(NetworkUpdateStage updateStage)
+            {
+                switch (updateStage)
+                {
+                    case NetworkUpdateStage.EarlyUpdate:
+                        {
+                            EarlyUpdate();
+                            break;
+                        }
+                    case NetworkUpdateStage.PostLateUpdate:
+                        {
+                            PostLateUpdate();
+                            break;
+                        }
+                }
+            }
+
+            public override void Shutdown()
+            {
+                s_Instances.Remove(this);
+                base.Shutdown();
+                this.UnregisterAllNetworkUpdates();
+            }
+
+            public override void Initialize(NetworkManager networkManager = null)
+            {
+                base.Initialize(networkManager);
+                this.RegisterNetworkUpdate(NetworkUpdateStage.EarlyUpdate);
+                this.RegisterNetworkUpdate(NetworkUpdateStage.PreUpdate);
+                this.RegisterNetworkUpdate(NetworkUpdateStage.PostLateUpdate);
+                s_Instances.Add(this);
+            }
+        }
     }
 }