Merge branch 'develop-2.0.0' into renovate/develop-2.0.0-recipeengine.modules.wrench-0.x

Author: michalChrobot

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -10,6 +10,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Added
 
+- Added `NetworkManager.OnPreShutdown` which is called before the NetworkManager cleans up and shuts down. (#3366)
 - Added interpolator types as an inspector view selection for position, rotation, and scale. (#3337)
 - Added a new smooth dampening interpolator type that provides a nice balance between precision and smoothing results. (#3337)
 - Added `NetworkTimeSystem.TickLatency` property that provides the average latency of a client. (#3337)
@@ -20,6 +21,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 - Fixed issue when using a distributed authority network topology and many clients attempt to connect simultaneously the session owner could max-out the maximum in-flight reliable messages allowed, start dropping packets, and some of the connecting clients would fail to fully synchronize. (#3350)
 - Fixed issue when using a distributed authority network topology and scene management was disabled clients would not be able to spawn any new network prefab instances until synchronization was complete. (#3350)
+- Fixed issue where an owner that changes ownership, when using a distributed authority network topology, could yield identical previous and current owner identifiers. This could also cause `NetworkTransform` to fail to change ownership which would leave the previous owner still subscribed to network tick events. (#3347)
 - Fixed issue where the `MaximumInterpolationTime` could not be modified from within the inspector view or runtime. (#3337)
 - Fixed `ChangeOwnership` changing ownership to clients that are not observers. This also happened with automated object distribution. (#3323)
 - Fixed issue where `AnticipatedNetworkVariable` previous value returned by `AnticipatedNetworkVariable.OnAuthoritativeValueChanged` is updated correctly on the non-authoritative side. (#3306)

com.unity.netcode.gameobjects/Editor/NetworkManagerRelayIntegration.cs

@@ -1,4 +1,4 @@
-#if UNITY_2022_3_OR_NEWER && (RELAY_SDK_INSTALLED && !UNITY_WEBGL ) || (RELAY_SDK_INSTALLED && UNITY_WEBGL && UTP_TRANSPORT_2_0_ABOVE)
+#if UNITY_2022_3_OR_NEWER && (RELAY_SDK_INSTALLED && !UNITY_WEBGL ) || (RELAY_SDK_INSTALLED && UNITY_WEBGL)
 using System;
 using System.Threading.Tasks;
 using Unity.Netcode.Transports.UTP;
@@ -109,9 +109,7 @@ private static UnityTransport GetUnityTransport(NetworkManager networkManager, s
             {
                 transport = networkManager.gameObject.AddComponent<UnityTransport>();
             }
-#if UTP_TRANSPORT_2_0_ABOVE
             transport.UseWebSockets = connectionType.StartsWith("ws"); // Probably should be part of SetRelayServerData, but not possible at this point
-#endif
             networkManager.NetworkConfig.NetworkTransport = transport; // Force using UnityTransport
             return transport;
         }

com.unity.netcode.gameobjects/Editor/com.unity.netcode.editor.asmdef

@@ -49,11 +49,6 @@
             "expression": "1.0",
             "define": "RELAY_SDK_INSTALLED"
         },
-        {
-            "name": "com.unity.transport",
-            "expression": "2.0",
-            "define": "UTP_TRANSPORT_2_0_ABOVE"
-        },
         {
             "name": "com.unity.services.multiplayer",
             "expression": "0.2.0",

com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviour.cs

@@ -826,7 +826,7 @@ internal void InternalOnNetworkDespawn()
 
         /// <summary>
         /// In client-server contexts, this method is invoked on both the server and the local client of the owner when <see cref="Netcode.NetworkObject"/> ownership is assigned.
-        /// In distributed authority contexts, this method is only invoked on the local client that has been assigned ownership of the associated <see cref="Netcode.NetworkObject"/>.
+        /// In distributed authority contexts, this method is invoked on all clients connected to the session.
         /// </summary>
         public virtual void OnGainedOwnership() { }
 
@@ -863,7 +863,7 @@ internal void InternalOnOwnershipChanged(ulong previous, ulong current)
         /// <summary>
         /// In client-server contexts, this method is invoked on the local client when it loses ownership of the associated <see cref="Netcode.NetworkObject"/>
         /// and on the server when any client loses ownership.
-        /// In distributed authority contexts, this method is only invoked on the local client that has lost ownership of the associated <see cref="Netcode.NetworkObject"/>.
+        /// In distributed authority contexts, this method is invoked on all clients connected to the session.
         /// </summary>
         public virtual void OnLostOwnership() { }
 
@@ -1185,14 +1185,23 @@ internal void MarkVariablesDirty(bool dirty)
             }
         }
 
-        internal void MarkOwnerReadVariablesDirty()
+        /// <summary>
+        /// For owner read permissions, when changing ownership we need to do a full synchronization
+        /// of all NetworkVariables that are owner read permission based since the owner is the only
+        /// instance that knows what the most current values are.
+        /// </summary>
+        internal void MarkOwnerReadDirtyAndCheckOwnerWriteIsDirty()
         {
             for (int j = 0; j < NetworkVariableFields.Count; j++)
             {
                 if (NetworkVariableFields[j].ReadPerm == NetworkVariableReadPermission.Owner)
                 {
                     NetworkVariableFields[j].SetDirty(true);
                 }
+                if (NetworkVariableFields[j].WritePerm == NetworkVariableWritePermission.Owner)
+                {
+                    NetworkVariableFields[j].OnCheckIsDirtyState();
+                }
             }
         }
 

com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviourUpdater.cs

@@ -108,8 +108,6 @@ internal void NetworkBehaviourUpdate(bool forceSend = false)
                 foreach (var dirtyobj in m_DirtyNetworkObjects)
                 {
                     dirtyobj.PostNetworkVariableWrite(forceSend);
-                    // Once done processing, we set the previous owner id to the current owner id
-                    dirtyobj.PreviousOwnerId = dirtyobj.OwnerClientId;
                 }
                 m_DirtyNetworkObjects.Clear();
             }

com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs

@@ -807,6 +807,12 @@ public struct ConnectionApprovalRequest
         /// </summary>
         public event Action OnClientStarted = null;
 
+        /// <summary>
+        /// Subscribe to this event to get notifications before a <see cref="NetworkManager"/> instance is being destroyed.
+        /// This is useful if you want to use the state of anything the NetworkManager cleans up during its shutdown.
+        /// </summary>
+        public event Action OnPreShutdown = null;
+
         /// <summary>
         /// This callback is invoked once the local server is stopped.
         /// </summary>
@@ -1481,6 +1487,8 @@ internal void ShutdownInternal()
                 NetworkLog.LogInfo(nameof(ShutdownInternal));
             }
 
+            OnPreShutdown?.Invoke();
+
             this.UnregisterAllNetworkUpdates();
 
             // Everything is shutdown in the order of their dependencies

com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs

@@ -2567,12 +2567,39 @@ internal void MarkVariablesDirty(bool dirty)
             }
         }
 
-        internal void MarkOwnerReadVariablesDirty()
+        /// <summary>
+        /// Used when changing ownership, this will mark any owner read permission base NetworkVariables as dirty
+        /// and will check if any owner write permission NetworkVariables are dirty (primarily for collections) so
+        /// the new owner will get a full state update prior to changing ownership.
+        /// </summary>
+        /// <remarks>
+        /// We have to pass in the original owner and previous owner to "reset" back to the current state of this
+        /// NetworkObject in order to preserve the same ownership change flow. By the time this is invoked, the
+        /// new and previous owner ids have already been set.
+        /// </remarks>
+        /// <param name="originalOwnerId">the owner prior to beginning the change in ownership change.</param>
+        /// <param name="originalPreviousOwnerId">the previous owner prior to beginning the change in ownership change.</param>
+        internal void SynchronizeOwnerNetworkVariables(ulong originalOwnerId, ulong originalPreviousOwnerId)
         {
+            var currentOwnerId = OwnerClientId;
+            OwnerClientId = originalOwnerId;
+            PreviousOwnerId = originalPreviousOwnerId;
             for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
             {
-                ChildNetworkBehaviours[i].MarkOwnerReadVariablesDirty();
+                ChildNetworkBehaviours[i].MarkOwnerReadDirtyAndCheckOwnerWriteIsDirty();
             }
+
+            // Now set the new owner and previous owner identifiers back to their original new values
+            // before we run the NetworkBehaviourUpdate. For owner read only permissions this order of
+            // operations is **particularly important** as we need to first (above) mark things as dirty
+            // from the context of the original owner and then second (below) we need to send the messages
+            // which requires the new owner to be set for owner read permission NetworkVariables.
+            OwnerClientId = currentOwnerId;
+            PreviousOwnerId = originalOwnerId;
+
+            // Force send a state update for all owner read NetworkVariables  and any currently dirty
+            // owner write NetworkVariables.
+            NetworkManager.BehaviourUpdater.NetworkBehaviourUpdate(true);
         }
 
         // NGO currently guarantees that the client will receive spawn data for all objects in one network tick.

com.unity.netcode.gameobjects/Runtime/Messaging/Messages/ChangeOwnershipMessage.cs

@@ -381,11 +381,8 @@ private void HandleOwnershipChange(ref NetworkContext context)
 
             if (originalOwner == networkManager.LocalClientId && !networkManager.DistributedAuthorityMode)
             {
-                // Mark any owner read variables as dirty
-                networkObject.MarkOwnerReadVariablesDirty();
-                // Immediately queue any pending deltas and order the message before the
-                // change in ownership message.
-                networkManager.BehaviourUpdater.NetworkBehaviourUpdate(true);
+                // Fully synchronize NetworkVariables with either read or write ownership permissions. 
+                networkObject.SynchronizeOwnerNetworkVariables(originalOwner, networkObject.PreviousOwnerId);
             }
 
             // Always invoke ownership change notifications

com.unity.netcode.gameobjects/Runtime/Messaging/NetworkMessageManager.cs

@@ -808,11 +808,7 @@ internal unsafe int SendMessage<T>(ref T message, NetworkDelivery delivery, in N
         internal unsafe int SendMessage<T>(ref T message, NetworkDelivery delivery, in NativeList<ulong> clientIds)
             where T : INetworkMessage
         {
-#if UTP_TRANSPORT_2_0_ABOVE
             return SendMessage(ref message, delivery, new PointerListWrapper<ulong>(clientIds.GetUnsafePtr(), clientIds.Length));
-#else
-            return SendMessage(ref message, delivery, new PointerListWrapper<ulong>((ulong*)clientIds.GetUnsafePtr(), clientIds.Length));
-#endif
         }
 
         internal unsafe void ProcessSendQueues()

com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariable.cs

@@ -166,6 +166,13 @@ public bool CheckDirtyState(bool forceCheck = false)
             return isDirty;
         }
 
+        /// <inheritdoc/>
+        internal override void OnCheckIsDirtyState()
+        {
+            CheckDirtyState();
+            base.OnCheckIsDirtyState();
+        }
+
         internal ref T RefValue()
         {
             return ref m_InternalValue;