update

Minor code clean up with a handful of additional comments.

Author: NoelStephensUnity

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

@@ -194,6 +194,7 @@ private void DisplayNetworkTransformProperties()
             }
             else
             {
+                // Should only be visible when SwitchTransformSpaceWhenParented is disabled.
                 EditorGUILayout.PropertyField(m_InLocalSpaceProperty);
             }
             if (!networkTransform.HideInterpolateValue)

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

@@ -365,7 +365,7 @@ internal void __endSendRpc(ref FastBufferWriter bufferWriter, uint rpcMethodId,
                     {
                         throw new OverflowException("RPC parameters are too large for unreliable delivery.");
                     }
-                    networkDelivery = NetworkDelivery.UnreliableSequenced;
+                    networkDelivery = NetworkDelivery.Unreliable;
                     break;
             }
 

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

@@ -11,19 +11,43 @@ public class NetworkBehaviourUpdater
     {
         private NetworkManager m_NetworkManager;
         private NetworkConnectionManager m_ConnectionManager;
+
+        /// <summary>
+        /// Contains the current dirty <see cref="NetworkObject"/>s that are proccessed each new network tick.
+        /// Under most cases, dirty <see cref="NetworkObject"/>s are fully processed on the next network tick.
+        /// Under certain conditions, like user script invoking <see cref="NetworkVariableBase.SetUpdateTraits(NetworkVariableUpdateTraits)"/>
+        /// to define <see cref="NetworkVariableUpdateTraits"/>, a <see cref="NetworkObject"/> can remain in the
+        /// <see cref="m_DirtyNetworkObjects"/> list until the configured traits' conditions have been met.
+        /// </summary>
         private HashSet<NetworkObject> m_DirtyNetworkObjects = new HashSet<NetworkObject>();
+
+        /// <summary>
+        /// Contains any dirty <see cref="NetworkObject"/>s that will be added to the <see cref="m_DirtyNetworkObjects"/>
+        /// list on the next network tick (<see cref="OnNetworkTick"/>).
+        /// </summary>
         private HashSet<NetworkObject> m_PendingDirtyNetworkObjects = new HashSet<NetworkObject>();
 
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
         private ProfilerMarker m_NetworkBehaviourUpdate = new ProfilerMarker($"{nameof(NetworkBehaviour)}.{nameof(NetworkBehaviourUpdate)}");
 #endif
 
+        /// <summary>
+        /// Adds a <see cref="NetworkObject"/> to the prending dirty list.
+        /// The <see cref="m_PendingDirtyNetworkObjects"/> list is merged into the <see cref="m_DirtyNetworkObjects"/> list
+        /// when processed.
+        /// </summary>
         internal void AddForUpdate(NetworkObject networkObject)
         {
             // Since this is a HashSet, we don't need to worry about duplicate entries
             m_PendingDirtyNetworkObjects.Add(networkObject);
         }
 
+        /// <summary>
+        /// (Client-server network topology only)
+        /// The server handles processing network variables the same way as a client
+        /// with the primary difference being that the server sends updates to all
+        /// observers.
+        /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal void ProcessDirtyObjectServer(NetworkObject dirtyObj, bool forceSend)
         {
@@ -41,6 +65,12 @@ internal void ProcessDirtyObjectServer(NetworkObject dirtyObj, bool forceSend)
             }
         }
 
+        /// <summary>
+        /// Clients handle processing dirty objects relative to the client.
+        /// The <see cref="NetworkVariableDeltaMessage"/> is client to server.
+        /// With distributed authority live service sessions, this is sent to
+        /// the Rust server.
+        /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal void ProcessDirtyObjectClient(NetworkObject dirtyObj, bool forceSend)
         {
@@ -50,6 +80,10 @@ internal void ProcessDirtyObjectClient(NetworkObject dirtyObj, bool forceSend)
             }
         }
 
+        /// <summary>
+        /// Handle house cleaning on the child <see cref="NetworkBehaviour"/>s.
+        /// This includes some collections specific checks and updates.
+        /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal void PostProcessDirtyObject(NetworkObject dirtyObj)
         {
@@ -73,6 +107,11 @@ internal void PostProcessDirtyObject(NetworkObject dirtyObj)
             }
         }
 
+        /// <summary>
+        /// Invokes <see cref="NetworkBehaviour.PostNetworkVariableWrite(bool)"/> on all child <see cref="NetworkBehaviour"/>s.
+        /// </summary>
+        /// <param name="dirtyObj"></param>
+        /// <param name="forceSend">Refer to the <see cref="ProcessDirtyObject(NetworkObject, bool)"/> definition.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal void ResetDirtyObject(NetworkObject dirtyObj, bool forceSend)
         {
@@ -103,6 +142,18 @@ internal void ForceSendIfDirtyOnNetworkShow(NetworkObject networkObject)
             m_DirtyNetworkObjects.Remove(networkObject);
         }
 
+        /// <summary>
+        /// The primary "dirty" <see cref="NetworkObject"/> processor.
+        /// Invokes:
+        /// - <see cref="NetworkBehaviour.PreVariableUpdate"/> on all properties that derive from <see cref="NetworkVariableBase"/>.
+        /// - <see cref="ProcessDirtyObjectServer(NetworkObject, bool)"/> (if the server).
+        /// - <see cref="ProcessDirtyObjectClient(NetworkObject, bool)"/> (if the client).
+        /// - <see cref="PostProcessDirtyObject"/> to handle the post processing of network variables.
+        /// - <see cref="ResetDirtyObject"/> which cleans up and removes the <see cref="NetworkObject"/> from the dirty list.
+        /// </summary>
+        /// <param name="networkObject">The <see cref="NetworkObject"/> to process.</param>
+        /// <param name="forceSend">When enabled, any dirty network variables will be added to a
+        /// <see cref="NetworkVariableDeltaMessage"/> and added to the outbound queue.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal void ProcessDirtyObject(NetworkObject networkObject, bool forceSend)
         {
@@ -138,7 +189,7 @@ internal void ProcessDirtyObject(NetworkObject networkObject, bool forceSend)
         /// <summary>
         /// Sends NetworkVariable deltas
         /// </summary>
-        /// <param name="forceSend">internal only, when changing ownership we want to send this before the change in ownership message</param>
+        /// <param name="forceSend"> Refer to the <see cref="ProcessDirtyObject(NetworkObject, bool)"/> definition.</param>
         internal void NetworkBehaviourUpdate(bool forceSend = false)
         {
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
@@ -175,18 +226,20 @@ internal void Initialize(NetworkManager networkManager)
         {
             m_NetworkManager = networkManager;
             m_ConnectionManager = networkManager.ConnectionManager;
-            m_NetworkManager.NetworkTickSystem.Tick += NetworkBehaviourUpdater_Tick;
+            m_NetworkManager.NetworkTickSystem.Tick += OnNetworkTick;
         }
 
         internal void Shutdown()
         {
-            m_NetworkManager.NetworkTickSystem.Tick -= NetworkBehaviourUpdater_Tick;
+            m_NetworkManager.NetworkTickSystem.Tick -= OnNetworkTick;
         }
 
-        // Order of operations requires NetworkVariable updates first then showing NetworkObjects
-        private void NetworkBehaviourUpdater_Tick()
+        /// <summary>
+        /// Process any dirty <see cref="NetworkObject"/>s on each new
+        /// network tick.
+        /// </summary>
+        private void OnNetworkTick()
         {
-            // Handle showing NetworkObjects on the next network tick, and only if we sent
             NetworkBehaviourUpdate();
         }
     }

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

@@ -1550,6 +1550,15 @@ internal void ShutdownInternal()
             {
                 NetworkLog.LogInfo(nameof(ShutdownInternal));
             }
+
+            // Always wrap events that can invoke user script in a
+            // try-catch to assure any proceeding script is still
+            // executed.
+            // Example:
+            // In editor some script registered to OnPreShutdown
+            // throws and exception. The UnregisterAllNetworkUpdates
+            // will never be invoked which means it will continue to
+            // be invoked outside of play mode.
             try
             {
                 OnPreShutdown?.Invoke();
@@ -1647,6 +1656,8 @@ internal void ShutdownInternal()
         // Ensures that the NetworkManager is cleaned up before OnDestroy is run on NetworkObjects and NetworkBehaviours when quitting the application.
         private void OnApplicationQuit()
         {
+            // Abrupt shutdown (or immediate exit of play mode).
+            // Assure we unregister from network updates.
             this.UnregisterAllNetworkUpdates();
 
             // Make sure ShutdownInProgress returns true during this time
@@ -1679,6 +1690,8 @@ private void OnDestroy()
 
             UnityEngine.SceneManagement.SceneManager.sceneUnloaded -= OnSceneUnloaded;
 
+            // try-catch to assure we reset the Singleton and, if in the editor,
+            // unscubscribe from playModeStateChanged.
             try
             {
                 // Notify we are destroying NetworkManager

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

@@ -1738,6 +1738,8 @@ private void OnDestroy()
                 if (!NetworkManager.ShutdownInProgress)
                 {
                     // Since we still have a session connection, log locally and on the server to inform user of this issue.
+                    // If the NetworkObject's GaaeObject is not valid or the scene is no longer valid or loaded, then this was due to the
+                    // unloading of a scene which is done by the authority...
                     if (gameObject != null && gameObject.scene.IsValid() && gameObject.scene.isLoaded)
                     {
                         if (NetworkManager.LogLevel <= LogLevel.Error && gameObject != null && gameObject.scene.IsValid() && gameObject.scene.isLoaded)
@@ -1755,6 +1757,7 @@ private void OnDestroy()
                     }
                     else
                     {
+                        // If the destroy was authority scene event triggered, then mark this destroy as authority triggered.
                         isAuthorityDestroy = true;
                     }
                 }

com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs

@@ -1029,6 +1029,7 @@ internal NetworkObject CreateLocalNetworkObject(NetworkObject.SceneObject sceneO
         }
 
         /// <summary>
+        /// Only spawn authority <see cref="NetworkManager"/> instances should invoke this.
         /// Invoked from:
         /// - ConnectionManager after instantiating a player prefab when running in client-server.
         /// - NetworkObject when spawning a newly instantiated NetworkObject for the first time.
@@ -1114,8 +1115,9 @@ internal void AuthorityLocalSpawn(NetworkObject networkObject, ulong networkId,
         }
 
         /// <summary>
-        /// This is only invoked to instantiate a serialized NetworkObject via
-        /// <see cref="NetworkObject.AddSceneObject(in NetworkObject.SceneObject, FastBufferReader, NetworkManager, bool)"/>
+        /// Only spawn non-authority <see cref="NetworkManager"/> instances should invoke this.
+        /// This is invoked to instantiate an authority spawned <see cref="NetworkObject"/>, and
+        /// is only invoked by: <see cref="NetworkObject.AddSceneObject(in NetworkObject.SceneObject, FastBufferReader, NetworkManager, bool)"/>
         /// </summary>
         /// <remarks>
         /// IMPORTANT: Pre spawn methods need to be invoked from within <see cref="NetworkObject.AddSceneObject"/>.
@@ -1783,8 +1785,7 @@ internal void UpdateObservedNetworkObjects(ulong clientId)
         }
 
         /// <summary>
-        /// See <see cref="NetworkBehaviourUpdater.NetworkBehaviourUpdater_Tick"/>
-        /// See <see cref="NetworkManager.NetworkUpdate(NetworkUpdateStage)"/> during the <see cref="NetworkUpdateStage.PostLateUpdate"/> stage.
+        /// This is only invoked by <see cref="NetworkManager.NetworkUpdate(NetworkUpdateStage)"/> during the <see cref="NetworkUpdateStage.PostLateUpdate"/> stage.
         /// </summary>
         internal void HandleNetworkObjectShow(bool forceSend = false)
         {