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)

Runtime/Messaging/Messages/ChangeOwnershipMessage.cs

@@ -17,7 +17,7 @@ namespace Unity.Netcode
         /// <summary>
         /// When requesting, RequestClientId is the requestor.
         /// When approving, RequestClientId is the owner that approved.
-        /// When responding (only for denied), RequestClientId is the requestor 
+        /// When responding (only for denied), RequestClientId is the requestor
         /// </summary>
         internal ulong RequestClientId;
         internal int ClientIdCount;
@@ -272,7 +272,7 @@ namespace Unity.Netcode
                         networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.Reliable, clientId);
                     }
                 }
-                // If the NetworkObject is not visible to the DAHost client, then exit early 
+                // If the NetworkObject is not visible to the DAHost client, then exit early
                 if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
                 {
                     return;
@@ -294,7 +294,7 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Handle the 
+        /// Handle the extended distributed authority ownership updates
         /// </summary>
         /// <param name="context"></param>
         private void HandleExtendedOwnershipUpdate(ref NetworkContext context)
@@ -332,8 +332,8 @@ namespace Unity.Netcode
             // Sanity check that we are not sending duplicated change ownership messages
             if (networkObject.OwnerClientId == OwnerClientId)
             {
-                UnityEngine.Debug.LogError($"Unnecessary ownership changed message for {NetworkObjectId}.");
-                // Ignore the message
+                // Log error and then ignore the message
+                UnityEngine.Debug.LogError($"Client-{context.SenderId} ({RequestClientId}) sent unnecessary ownership changed message for {NetworkObjectId}.");
                 return;
             }
 
@@ -351,10 +351,10 @@ namespace Unity.Netcode
                 networkObject.InvokeBehaviourOnLostOwnership();
             }
 
-            // If in distributed authority mode 
+            // If in distributed authority mode
             if (networkManager.DistributedAuthorityMode)
             {
-                // Always update the network properties in distributed authority mode 
+                // Always update the network properties in distributed authority mode
                 for (int i = 0; i < networkObject.ChildNetworkBehaviours.Count; i++)
                 {
                     networkObject.ChildNetworkBehaviours[i].UpdateNetworkProperties();

Runtime/Messaging/Messages/ClientConnectedMessage.cs

@@ -55,19 +55,24 @@ namespace Unity.Netcode
                 // Don't redistribute for the local instance
                 if (ClientId != networkManager.LocalClientId)
                 {
+                    // Synchronize the client with spawned objects (relative to each client)
+                    networkManager.SpawnManager.SynchronizeObjectsToNewlyJoinedClient(ClientId);
+
+                    // Keeping for reference in case the above doesn't resolve for hidden objects (theoretically it should)
                     // Show any NetworkObjects that are:
                     // - Hidden from the session owner
                     // - Owned by this client
                     // - Has NetworkObject.SpawnWithObservers set to true (the default)
-                    if (!networkManager.LocalClient.IsSessionOwner)
-                    {
-                        networkManager.SpawnManager.ShowHiddenObjectsToNewlyJoinedClient(ClientId);
-                    }
+                    //if (!networkManager.LocalClient.IsSessionOwner)
+                    //{
+                    //    networkManager.SpawnManager.ShowHiddenObjectsToNewlyJoinedClient(ClientId);
+                    //}
 
-                    // We defer redistribution to the end of the NetworkUpdateStage.PostLateUpdate
-                    networkManager.RedistributeToClient = true;
-                    networkManager.ClientToRedistribute = ClientId;
-                    networkManager.TickToRedistribute = networkManager.ServerTime.Tick + 20;
+                    /// We defer redistribution to happen after NetworkShow has been invoked
+                    /// <see cref="NetworkBehaviourUpdater.NetworkBehaviourUpdater_Tick"/>
+                    /// DANGO-TODO: Determine if this needs to be removed once the service handles object distribution
+                    networkManager.RedistributeToClients = true;
+                    networkManager.ClientsToRedistribute.Add(ClientId);
                 }
             }
         }

Runtime/Messaging/Messages/ConnectionApprovedMessage.cs

@@ -5,23 +5,38 @@ namespace Unity.Netcode
 {
     internal struct ServiceConfig : INetworkSerializable
     {
-        public uint Version;
+        public uint SessionVersion;
         public bool IsRestoredSession;
         public ulong CurrentSessionOwner;
+        public bool ServerRedistribution;
 
         public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
         {
             if (serializer.IsWriter)
             {
-                BytePacker.WriteValueBitPacked(serializer.GetFastBufferWriter(), Version);
+                BytePacker.WriteValueBitPacked(serializer.GetFastBufferWriter(), SessionVersion);
                 serializer.SerializeValue(ref IsRestoredSession);
                 BytePacker.WriteValueBitPacked(serializer.GetFastBufferWriter(), CurrentSessionOwner);
+
+                if (SessionVersion >= SessionConfig.ServerDistributionCompatible)
+                {
+                    serializer.SerializeValue(ref ServerRedistribution);
+                }
             }
             else
             {
-                ByteUnpacker.ReadValueBitPacked(serializer.GetFastBufferReader(), out Version);
+                ByteUnpacker.ReadValueBitPacked(serializer.GetFastBufferReader(), out SessionVersion);
                 serializer.SerializeValue(ref IsRestoredSession);
                 ByteUnpacker.ReadValueBitPacked(serializer.GetFastBufferReader(), out CurrentSessionOwner);
+
+                if (SessionVersion >= SessionConfig.ServerDistributionCompatible)
+                {
+                    serializer.SerializeValue(ref ServerRedistribution);
+                }
+                else
+                {
+                    ServerRedistribution = false;
+                }
             }
         }
     }
@@ -190,11 +205,13 @@ namespace Unity.Netcode
                 if (receivedMessageVersion >= k_AddCMBServiceConfig)
                 {
                     reader.ReadNetworkSerializable(out ServiceConfig);
+                    networkManager.SessionConfig = new SessionConfig(ServiceConfig);
                 }
                 else
                 {
                     reader.ReadValueSafe(out IsRestoredSession);
                     ByteUnpacker.ReadValueBitPacked(reader, out CurrentSessionOwner);
+                    networkManager.SessionConfig = new SessionConfig(SessionConfig.NoFeatureCompatibility);
                 }
             }
 

Runtime/Messaging/Messages/ConnectionRequestMessage.cs

@@ -7,31 +7,28 @@ namespace Unity.Netcode
     /// </summary>
     internal struct ClientConfig : INetworkSerializable
     {
-        /// <summary>
-        /// We start at version 1, where anything less than version 1 on the service side
-        /// is not bypass feature compatible.
-        /// </summary>
-        private const int k_BypassFeatureCompatible = 1;
-        public int Version => k_BypassFeatureCompatible;
+        public SessionConfig SessionConfig;
+        public int SessionVersion => (int)SessionConfig.SessionVersion;
         public uint TickRate;
         public bool EnableSceneManagement;
 
         // Only gets deserialized but should never be used unless testing
-        public int RemoteClientVersion;
+        public int RemoteClientSessionVersion;
 
         public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
         {
+            // Clients always write
             if (serializer.IsWriter)
             {
                 var writer = serializer.GetFastBufferWriter();
-                BytePacker.WriteValueBitPacked(writer, Version);
+                BytePacker.WriteValueBitPacked(writer, SessionVersion);
                 BytePacker.WriteValueBitPacked(writer, TickRate);
                 writer.WriteValueSafe(EnableSceneManagement);
             }
             else
             {
                 var reader = serializer.GetFastBufferReader();
-                ByteUnpacker.ReadValueBitPacked(reader, out RemoteClientVersion);
+                ByteUnpacker.ReadValueBitPacked(reader, out RemoteClientSessionVersion);
                 ByteUnpacker.ReadValueBitPacked(reader, out TickRate);
                 reader.ReadValueSafe(out EnableSceneManagement);
             }
@@ -40,6 +37,8 @@ namespace Unity.Netcode
 
     internal struct ConnectionRequestMessage : INetworkMessage
     {
+        internal const string InvalidSessionVersionMessage = "The client version is not compatible with the session version.";
+
         // This version update is unidirectional (client to service) and version
         // handling occurs on the service side. This serialized data is never sent
         // to a host or server.
@@ -47,7 +46,7 @@ namespace Unity.Netcode
         public int Version => k_SendClientConfigToService;
 
         public ulong ConfigHash;
-        public bool CMBServiceConnection;
+        public bool DistributedAuthority;
         public ClientConfig ClientConfig;
 
         public byte[] ConnectionData;
@@ -72,7 +71,7 @@ namespace Unity.Netcode
             // END FORBIDDEN SEGMENT
             // ============================================================
 
-            if (CMBServiceConnection)
+            if (DistributedAuthority)
             {
                 writer.WriteNetworkSerializable(ClientConfig);
             }
@@ -120,6 +119,11 @@ namespace Unity.Netcode
             // END FORBIDDEN SEGMENT
             // ============================================================
 
+            if (networkManager.DAHost)
+            {
+                reader.ReadNetworkSerializable(out ClientConfig);
+            }
+
             if (networkManager.NetworkConfig.ConnectionApproval)
             {
                 if (!reader.TryBeginRead(FastBufferWriter.GetWriteSize(ConfigHash) + FastBufferWriter.GetWriteSize<int>()))
@@ -182,6 +186,17 @@ namespace Unity.Netcode
             var networkManager = (NetworkManager)context.SystemOwner;
             var senderId = context.SenderId;
 
+            // DAHost mocking the service logic to disconnect clients trying to connect with a lower session version
+            if (networkManager.DAHost)
+            {
+                if (ClientConfig.RemoteClientSessionVersion < networkManager.SessionConfig.SessionVersion)
+                {
+                    //Disconnect with reason
+                    networkManager.ConnectionManager.DisconnectClient(senderId, InvalidSessionVersionMessage);
+                    return;
+                }
+            }
+
             if (networkManager.ConnectionManager.PendingClients.TryGetValue(senderId, out PendingClient client))
             {
                 // Set to pending approval to prevent future connection requests from being approved

Runtime/Messaging/Messages/CreateObjectMessage.cs

@@ -257,7 +257,7 @@ namespace Unity.Netcode
                     {
                         // DA - NGO CMB SERVICE NOTES:
                         // (*** See above notes fist ***)
-                        // If it is a player object freshly spawning and one or more clients all connect at the exact same time (i.e. received on effectively 
+                        // If it is a player object freshly spawning and one or more clients all connect at the exact same time (i.e. received on effectively
                         // the same frame), then we need to check the observers list to make sure all players are visible upon first spawning. At a later date,
                         // for area of interest we will need to have some form of follow up "observer update" message to cull out players not within each
                         // player's AOI.

Runtime/Messaging/Messages/NetworkTransformMessage.cs

@@ -128,7 +128,7 @@ namespace Unity.Netcode
                     }
                     else if (networkManager.DAHost)
                     {
-                        // Specific to distributed authority mode, the only sender of state updates will be the owner 
+                        // Specific to distributed authority mode, the only sender of state updates will be the owner
                         ownerClientId = context.SenderId;
                     }
 

Runtime/Messaging/Messages/ParentSyncMessage.cs

@@ -70,10 +70,6 @@ namespace Unity.Netcode
         public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
-            if (!networkManager.IsClient)
-            {
-                return false;
-            }
 
             ByteUnpacker.ReadValueBitPacked(reader, out NetworkObjectId);
             reader.ReadValueSafe(out m_BitField);