com.unity.netcode.gameobjects@2.0.0-exp.2

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.0.0-exp.2] - 2024-04-02

### Added
- Added updates to all internal messages to account for a distributed authority network session connection.  (#2863)
- Added `NetworkRigidbodyBase` that provides users with a more customizable network rigidbody, handles both `Rigidbody` and `Rigidbody2D`, and provides an option to make `NetworkTransform` use the rigid body for motion.  (#2863)
  - For a customized `NetworkRigidbodyBase` class:
    - `NetworkRigidbodyBase.AutoUpdateKinematicState` provides control on whether the kinematic setting will be automatically set or not when ownership changes.
    - `NetworkRigidbodyBase.AutoSetKinematicOnDespawn` provides control on whether isKinematic will automatically be set to true when the associated `NetworkObject` is despawned.
    - `NetworkRigidbodyBase.Initialize` is a protected method that, when invoked, will initialize the instance. This includes options to:
      - Set whether using a `RigidbodyTypes.Rigidbody` or `RigidbodyTypes.Rigidbody2D`.
      - Includes additional optional parameters to set the `NetworkTransform`, `Rigidbody`, and `Rigidbody2d` to use.
  - Provides additional public methods:
    - `NetworkRigidbodyBase.GetPosition` to return the position of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
    - `NetworkRigidbodyBase.GetRotation` to return the rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
    - `NetworkRigidbodyBase.MovePosition` to move to the position of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
    - `NetworkRigidbodyBase.MoveRotation` to move to the rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
    - `NetworkRigidbodyBase.Move` to move to the position and rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
    - `NetworkRigidbodyBase.Move` to move to the position and rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
    - `NetworkRigidbodyBase.SetPosition` to set the position of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
    - `NetworkRigidbodyBase.SetRotation` to set the rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting).
    - `NetworkRigidbodyBase.ApplyCurrentTransform` to set the position and rotation of the `Rigidbody` or `Rigidbody2d` based on the associated `GameObject` transform (depending upon its initialized setting).
    - `NetworkRigidbodyBase.WakeIfSleeping` to wake up the rigid body if sleeping.
    - `NetworkRigidbodyBase.SleepRigidbody` to put the rigid body to sleep.
    - `NetworkRigidbodyBase.IsKinematic` to determine if the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting) is currently kinematic.
    - `NetworkRigidbodyBase.SetIsKinematic` to set the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting) current kinematic state.
    - `NetworkRigidbodyBase.ResetInterpolation` to reset the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting) back to its original interpolation value when initialized.
  - Now includes a `MonoBehaviour.FixedUpdate` implementation that will update the assigned `NetworkTransform` when `NetworkRigidbodyBase.UseRigidBodyForMotion` is true. (#2863)
- Added `RigidbodyContactEventManager` that provides a more optimized way to process collision enter and collision stay events as opposed to the `Monobehaviour` approach. (#2863)
  - Can be used in client-server and distributed authority modes, but is particularly useful in distributed authority.
- Added rigid body motion updates to `NetworkTransform` which allows users to set interolation on rigid bodies. (#2863)
  - Extrapolation is only allowed on authoritative instances, but custom class derived from `NetworkRigidbodyBase` or `NetworkRigidbody` or `NetworkRigidbody2D` automatically switches non-authoritative instances to interpolation if set to extrapolation.
- Added distributed authority mode support to `NetworkAnimator`. (#2863)
- Added session mode selection to `NetworkManager` inspector view. (#2863)
- Added distributed authority permissions feature. (#2863)
- Added distributed authority mode specific `NetworkObject` permissions flags (Distributable, Transferable, and RequestRequired). (#2863)
- Added distributed authority mode specific `NetworkObject.SetOwnershipStatus` method that applies one or more `NetworkObject` instance's ownership flags. If updated when spawned, the ownership permission changes are synchronized with the other connected clients. (#2863)
- Added distributed authority mode specific `NetworkObject.RemoveOwnershipStatus` method that removes one or more `NetworkObject` instance's ownership flags. If updated when spawned, the ownership permission changes are synchronized with the other connected clients. (#2863)
- Added distributed authority mode specific `NetworkObject.HasOwnershipStatus` method that will return (true or false) whether one or more ownership flags is set. (#2863)
- Added distributed authority mode specific `NetworkObject.SetOwnershipLock` method that locks ownership of a `NetworkObject` to prevent ownership from changing until the current owner releases the lock. (#2863)
- Added distributed authority mode specific `NetworkObject.RequestOwnership` method that sends an ownership request to the current owner of a spawned `NetworkObject` instance. (#2863)
- Added distributed authority mode specific `NetworkObject.OnOwnershipRequested` callback handler that is invoked on the owner/authoritative side when a non-owner requests ownership. Depending upon the boolean returned value depends upon whether the request is approved or denied. (#2863)
- Added distributed authority mode specific `NetworkObject.OnOwnershipRequestResponse` callback handler that is invoked when a non-owner's request has been processed. This callback includes a `NetworkObjet.OwnershipRequestResponseStatus` response parameter that describes whether the request was approved or the reason why it was not approved. (#2863)
- Added distributed authority mode specific `NetworkObject.DeferDespawn` method that defers the despawning of `NetworkObject` instances on non-authoritative clients based on the tick offset parameter. (#2863)
- Added distributed authority mode specific `NetworkObject.OnDeferredDespawnComplete` callback handler that can be used to further control when deferring the despawning of a `NetworkObject` on non-authoritative instances. (#2863)
- Added `NetworkClient.SessionModeType` as one way to determine the current session mode of the network session a client is connected to. (#2863)
- Added distributed authority mode specific `NetworkClient.IsSessionOwner` property to determine if the current local client is the current session owner of a distributed authority session. (#2863)
- Added distributed authority mode specific client side spawning capabilities. When running in distributed authority mode, clients can instantiate and spawn `NetworkObject` instances (the local client is authomatically the owner of the spawned object). (#2863)
  - This is useful to better visually synchronize owner authoritative motion models and newly spawned `NetworkObject` instances (i.e. projectiles for example).
- Added distributed authority mode specific client side player spawning capabilities. Clients will automatically spawn their associated player object locally. (#2863)
- Added distributed authority mode specific `NetworkConfig.AutoSpawnPlayerPrefabClientSide` property (default is true) to provide control over the automatic spawning of player prefabs on the local client side. (#2863)
- Added distributed authority mode specific `NetworkManager.OnFetchLocalPlayerPrefabToSpawn` callback that, when assigned, will allow the local client to provide the player prefab to be spawned for the local client. (#2863)
  - This is only invoked if the `NetworkConfig.AutoSpawnPlayerPrefabClientSide` property is set to true.
- Added distributed authority mode specific `NetworkBehaviour.HasAuthority` property that determines if the local client has authority over the associated `NetworkObject` instance (typical use case is within a `NetworkBehaviour` script much like that of `IsServer` or `IsClient`). (#2863)
- Added distributed authority mode specific `NetworkBehaviour.IsSessionOwner` property that determines if the local client is the session owner (typical use case would be to determine if the local client can has scene management authority within a `NetworkBehaviour` script). (#2863)
- Added support for distributed authority mode scene management where the currently assigned session owner can start scene events (i.e. scene loading and scene unloading). (#2863)

### Fixed

- Fixed issue where the host was not invoking `OnClientDisconnectCallback` for its own local client when internally shutting down. (#2822)
- Fixed issue where NetworkTransform could potentially attempt to "unregister" a named message prior to it being registered. (#2807)
- Fixed issue where in-scene placed `NetworkObject`s with complex nested children `NetworkObject`s (more than one child in depth) would not synchronize properly if WorldPositionStays was set to true. (#2796)

### Changed
- Changed client side awareness of other clients is now the same as a server or host. (#2863)
- Changed `NetworkManager.ConnectedClients` can now be accessed by both server and clients. (#2863)
- Changed `NetworkManager.ConnectedClientsList` can now be accessed by both server and clients. (#2863)
- Changed `NetworkTransform` defaults to owner authoritative when connected to a distributed authority session. (#2863)
- Changed `NetworkVariable` defaults to owner write and everyone read permissions when connected to a distributed authority session (even if declared with server read or write permissions).  (#2863)
- Changed `NetworkObject` no longer implements the `MonoBehaviour.Update` method in order to determine whether a `NetworkObject` instance has been migrated to a different scene. Instead, only `NetworkObjects` with the `SceneMigrationSynchronization` property set will be updated internally during the `NetworkUpdateStage.PostLateUpdate` by `NetworkManager`. (#2863)
- Changed `NetworkManager` inspector view layout where properties are now organized by category. (#2863)
- Changed `NetworkTransform` to now use `NetworkTransformMessage` as opposed to named messages for NetworkTransformState updates. (#2810)
- Changed `CustomMessageManager` so it no longer attempts to register or "unregister" a null or empty string and will log an error if this condition occurs. (#2807)

Runtime/Configuration/NetworkConfig.cs

@@ -129,9 +129,9 @@ namespace Unity.Netcode
         public int LoadSceneTimeOut = 120;
 
         /// <summary>
-        /// The amount of time a message should be buffered if the asset or object needed to process it doesn't exist yet. If the asset is not added/object is not spawned within this time, it will be dropped.
+        /// The amount of time a message will be held (deferred) if the destination NetworkObject needed to process the message doesn't exist yet. If the NetworkObject is not spawned within this time period, all deferred messages for that NetworkObject will be dropped.
         /// </summary>
-        [Tooltip("The amount of time a message should be buffered if the asset or object needed to process it doesn't exist yet. If the asset is not added/object is not spawned within this time, it will be dropped")]
+        [Tooltip("The amount of time a message will be held (deferred) if the destination NetworkObject needed to process the message doesn't exist yet. If the NetworkObject is not spawned within this time period, all deferred messages for that NetworkObject will be dropped.")]
         public float SpawnTimeout = 10f;
 
         /// <summary>
@@ -149,6 +149,15 @@ namespace Unity.Netcode
         /// </summary>
         public const int RttWindowSize = 64; // number of slots to use for RTT computations (max number of in-flight packets)
 
+        [Tooltip("Determines if the network session will run in client-server or distributed authority mode.")]
+        public SessionModeTypes SessionMode;
+
+        [HideInInspector]
+        public bool UseCMBService;
+
+        [Tooltip("When enabled (default), the player prefab will automatically be spawned (client-side) upon the client being approved and synchronized.")]
+        public bool AutoSpawnPlayerPrefabClientSide = true;
+
         /// <summary>
         /// Returns a base64 encoded version of the configuration
         /// </summary>

Runtime/Connection/NetworkClient.cs

@@ -1,7 +1,15 @@
 using System.Collections.Generic;
+using UnityEngine;
 
 namespace Unity.Netcode
 {
+
+    public enum SessionModeTypes
+    {
+        ClientServer,
+        DistributedAuthority
+    }
+
     /// <summary>
     /// A NetworkClient
     /// </summary>
@@ -33,6 +41,15 @@ namespace Unity.Netcode
         /// </summary>
         internal bool IsApproved { get; set; }
 
+        public SessionModeTypes SessionModeType { get; internal set; }
+
+        public bool DAHost { get; internal set; }
+
+        /// <summary>
+        /// Is true when the client has been assigned session ownership in distributed authority mode
+        /// </summary>
+        public bool IsSessionOwner { get; internal set; }
+
         /// <summary>
         /// The ClientId of the NetworkClient
         /// </summary>
@@ -50,21 +67,54 @@ namespace Unity.Netcode
 
         internal NetworkSpawnManager SpawnManager { get; private set; }
 
-        internal void SetRole(bool isServer, bool isClient, NetworkManager networkManager = null)
+        internal bool SetRole(bool isServer, bool isClient, NetworkManager networkManager = null)
         {
+            ResetClient(isServer, isClient);
+
             IsServer = isServer;
             IsClient = isClient;
-            if (!IsServer && !isClient)
+
+            if (networkManager != null)
+            {
+                SpawnManager = networkManager.SpawnManager;
+                SessionModeType = networkManager.NetworkConfig.SessionMode;
+
+                if (SessionModeType == SessionModeTypes.DistributedAuthority)
+                {
+                    DAHost = IsClient && IsServer;
+
+                    // DANGO-TODO: We might allow a dedicated mock CMB server, but for now do not allow this
+                    if (!IsClient && IsServer)
+                    {
+                        Debug.LogError("You cannot start NetworkManager as a server when operating in distributed authority mode!");
+                        return false;
+                    }
+
+                    if (DAHost && networkManager.CMBServiceConnection)
+                    {
+                        Debug.LogError("You cannot start a host when connecting to a distributed authority CMB Service!");
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Only to be invoked when setting the role.
+        /// This resets the current NetworkClient's properties.
+        /// </summary>
+        private void ResetClient(bool isServer, bool isClient)
+        {
+            // If we are niether client nor server, then reset properties (i.e. client has no role)
+            if (!IsServer && !IsClient)
             {
                 PlayerObject = null;
                 ClientId = 0;
                 IsConnected = false;
                 IsApproved = false;
-            }
-
-            if (networkManager != null)
-            {
-                SpawnManager = networkManager.SpawnManager;
+                SpawnManager = null;
+                DAHost = false;
             }
         }
 

Runtime/Connection/NetworkConnectionManager.cs

@@ -1,12 +1,12 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 using System.Runtime.CompilerServices;
 using Unity.Collections;
 using Unity.Collections.LowLevel.Unsafe;
 using Unity.Profiling;
 using UnityEngine;
-using Object = UnityEngine.Object;
 
 namespace Unity.Netcode
 {
@@ -366,6 +366,10 @@ namespace Unity.Netcode
             {
                 networkEvent = NetworkManager.NetworkConfig.NetworkTransport.PollEvent(out ulong transportClientId, out ArraySegment<byte> payload, out float receiveTime);
                 HandleNetworkEvent(networkEvent, transportClientId, payload, receiveTime);
+                if (networkEvent == NetworkEvent.Disconnect || networkEvent == NetworkEvent.TransportFailure)
+                {
+                    break;
+                }
                 // Only do another iteration if: there are no more messages AND (there is no limit to max events or we have processed less than the maximum)
             } while (NetworkManager.IsListening && networkEvent != NetworkEvent.Nothing);
 
@@ -430,16 +434,17 @@ namespace Unity.Netcode
             {
                 if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
                 {
-                    NetworkLog.LogInfo("Client Connected");
+                    var hostServer = NetworkManager.IsHost ? "Host" : "Server";
+                    NetworkLog.LogInfo($"[{hostServer}-Side] Transport connection established with pending Client-{clientId}.");
                 }
-
                 AddPendingClient(clientId);
             }
             else
             {
                 if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
                 {
-                    NetworkLog.LogInfo("Connected");
+                    var serverOrService = NetworkManager.DistributedAuthorityMode ? NetworkManager.CMBServiceConnection ? "service" : "DAHost" : "server";
+                    NetworkLog.LogInfo($"[Approval Pending][Client] Transport connection with {serverOrService} established! Awaiting connection approval...");
                 }
 
                 SendConnectionRequest();
@@ -546,6 +551,10 @@ namespace Unity.Netcode
         {
             var message = new ConnectionRequestMessage
             {
+                CMBServiceConnection = NetworkManager.CMBServiceConnection,
+                TickRate = NetworkManager.NetworkConfig.TickRate,
+                EnableSceneManagement = NetworkManager.NetworkConfig.EnableSceneManagement,
+
                 // Since only a remote client will send a connection request, we should always force the rebuilding of the NetworkConfig hash value
                 ConfigHash = NetworkManager.NetworkConfig.GetConfig(false),
                 ShouldSendConnectionData = NetworkManager.NetworkConfig.ConnectionApproval,
@@ -701,6 +710,12 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// Adding this because message hooks cannot happen fast enough under certain scenarios
+        /// where the message is sent and responded to before the hook is in place.
+        /// </summary>
+        internal bool MockSkippingApproval;
+
         /// <summary>
         /// Server Side: Handles the approval of a client
         /// </summary>
@@ -712,12 +727,15 @@ namespace Unity.Netcode
             LocalClient.IsApproved = response.Approved;
             if (response.Approved)
             {
+                if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
+                {
+                    NetworkLog.LogInfo($"[Server-Side] Pending Client-{ownerClientId} connection approved!");
+                }
                 // The client was approved, stop the server-side approval time out coroutine
                 RemovePendingClient(ownerClientId);
 
                 var client = AddClient(ownerClientId);
-
-                if (response.CreatePlayerObject)
+                if (!NetworkManager.DistributedAuthorityMode && response.CreatePlayerObject && NetworkManager.NetworkConfig.PlayerPrefab != null)
                 {
                     var prefabNetworkObject = NetworkManager.NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>();
                     var playerPrefabHash = response.PlayerPrefabHash ?? prefabNetworkObject.GlobalObjectIdHash;
@@ -732,6 +750,7 @@ namespace Unity.Netcode
                         HasTransform = prefabNetworkObject.SynchronizeTransform,
                         Hash = playerPrefabHash,
                         TargetClientId = ownerClientId,
+                        DontDestroyWithOwner = prefabNetworkObject.DontDestroyWithOwner,
                         Transform = new NetworkObject.SceneObject.TransformData
                         {
                             Position = response.Position.GetValueOrDefault(),
@@ -761,6 +780,7 @@ namespace Unity.Netcode
                     {
                         OwnerClientId = ownerClientId,
                         NetworkTick = NetworkManager.LocalTime.Tick,
+                        IsDistributedAuthority = NetworkManager.DistributedAuthorityMode,
                         ConnectedClientIds = new NativeArray<ulong>(ConnectedClientIds.Count, Allocator.Temp)
                     };
 
@@ -794,10 +814,20 @@ namespace Unity.Netcode
                             };
                         }
                     }
-
-                    SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ownerClientId);
+                    if (!MockSkippingApproval)
+                    {
+                        SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ownerClientId);
+                    }
+                    else
+                    {
+                        NetworkLog.LogInfo("Mocking server not responding with connection approved...");
+                    }
                     message.MessageVersions.Dispose();
                     message.ConnectedClientIds.Dispose();
+                    if (MockSkippingApproval)
+                    {
+                        return;
+                    }
 
                     // If scene management is disabled, then we are done and notify the local host-server the client is connected
                     if (!NetworkManager.NetworkConfig.EnableSceneManagement)
@@ -808,10 +838,19 @@ namespace Unity.Netcode
                         {
                             InvokeOnPeerConnectedCallback(ownerClientId);
                         }
+                        NetworkManager.SpawnManager.DistributeNetworkObjects(ownerClientId);
+
                     }
                     else // Otherwise, let NetworkSceneManager handle the initial scene and NetworkObject synchronization
                     {
-                        NetworkManager.SceneManager.SynchronizeNetworkObjects(ownerClientId);
+                        if (NetworkManager.DistributedAuthorityMode && NetworkManager.LocalClient.IsSessionOwner)
+                        {
+                            NetworkManager.SceneManager.SynchronizeNetworkObjects(ownerClientId);
+                        }
+                        else if (!NetworkManager.DistributedAuthorityMode)
+                        {
+                            NetworkManager.SceneManager.SynchronizeNetworkObjects(ownerClientId);
+                        }
                     }
                 }
                 else // Server just adds itself as an observer to all spawned NetworkObjects
@@ -819,6 +858,17 @@ namespace Unity.Netcode
                     LocalClient = client;
                     NetworkManager.SpawnManager.UpdateObservedNetworkObjects(ownerClientId);
                     LocalClient.IsConnected = true;
+                    // If running mock service, then set the instance as the default session owner
+                    if (NetworkManager.DistributedAuthorityMode && NetworkManager.DAHost)
+                    {
+                        NetworkManager.SetSessionOwner(NetworkManager.LocalClientId);
+                        NetworkManager.SceneManager.InitializeScenesLoaded();
+                    }
+
+                    if (NetworkManager.DistributedAuthorityMode && NetworkManager.AutoSpawnPlayerPrefabClientSide)
+                    {
+                        CreateAndSpawnPlayer(ownerClientId);
+                    }
                 }
 
                 if (!response.CreatePlayerObject || (response.PlayerPrefabHash == null && NetworkManager.NetworkConfig.PlayerPrefab == null))
@@ -826,6 +876,11 @@ namespace Unity.Netcode
                     return;
                 }
 
+                // Players are always spawned by their respective client, exit early. (DAHost mode anyway, CMB Service will never spawn player prefab)
+                if (NetworkManager.DistributedAuthorityMode)
+                {
+                    return;
+                }
                 // Separating this into a contained function call for potential further future separation of when this notification is sent.
                 ApprovedPlayerSpawn(ownerClientId, response.PlayerPrefabHash ?? NetworkManager.NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash);
             }
@@ -840,11 +895,28 @@ namespace Unity.Netcode
                     SendMessage(ref disconnectReason, NetworkDelivery.Reliable, ownerClientId);
                     MessageManager.ProcessSendQueues();
                 }
-
                 DisconnectRemoteClient(ownerClientId);
             }
         }
 
+        /// <summary>
+        /// Client-Side Spawning in distributed authority mode uses this to spawn the player.
+        /// </summary>
+        internal void CreateAndSpawnPlayer(ulong ownerId, Vector3 position = default, Quaternion rotation = default)
+        {
+            if (NetworkManager.DistributedAuthorityMode && NetworkManager.AutoSpawnPlayerPrefabClientSide)
+            {
+                var playerPrefab = NetworkManager.FetchLocalPlayerPrefabToSpawn();
+                if (playerPrefab != null)
+                {
+                    var globalObjectIdHash = playerPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash;
+                    var networkObject = NetworkManager.SpawnManager.GetNetworkObjectToSpawn(globalObjectIdHash, ownerId, position, rotation);
+                    networkObject.IsSceneObject = false;
+                    networkObject.SpawnAsPlayerObject(ownerId, networkObject.DestroyWithScene);
+                }
+            }
+        }
+
         /// <summary>
         /// Spawns the newly approved player
         /// </summary>
@@ -864,8 +936,10 @@ namespace Unity.Netcode
 
                 var message = new CreateObjectMessage
                 {
-                    ObjectInfo = ConnectedClients[clientId].PlayerObject.GetMessageSceneObject(clientPair.Key)
+                    ObjectInfo = ConnectedClients[clientId].PlayerObject.GetMessageSceneObject(clientPair.Key),
+                    IncludesSerializedObject = true,
                 };
+
                 message.ObjectInfo.Hash = playerPrefabHash;
                 message.ObjectInfo.IsSceneObject = false;
                 message.ObjectInfo.HasParent = false;
@@ -883,20 +957,92 @@ namespace Unity.Netcode
         /// </summary>
         internal NetworkClient AddClient(ulong clientId)
         {
+            if (ConnectedClients.ContainsKey(clientId) && ConnectedClientIds.Contains(clientId) && ConnectedClientsList.Contains(ConnectedClients[clientId]))
+            {
+                return ConnectedClients[clientId];
+            }
+
             var networkClient = LocalClient;
 
-            networkClient = new NetworkClient();
+            // If this is not the local client then create a new one
+            if (clientId != NetworkManager.LocalClientId)
+            {
+                networkClient = new NetworkClient();
+            }
             networkClient.SetRole(clientId == NetworkManager.ServerClientId, isClient: true, NetworkManager);
             networkClient.ClientId = clientId;
+            if (!ConnectedClients.ContainsKey(clientId))
+            {
+                ConnectedClients.Add(clientId, networkClient);
+            }
+            if (!ConnectedClientsList.Contains(networkClient))
+            {
+                ConnectedClientsList.Add(networkClient);
+            }
+
+            if (NetworkManager.LocalClientId != clientId)
+            {
+                if ((!NetworkManager.DistributedAuthorityMode && NetworkManager.IsServer) ||
+                    (NetworkManager.DistributedAuthorityMode && NetworkManager.NetworkConfig.EnableSceneManagement && NetworkManager.DAHost && NetworkManager.LocalClient.IsSessionOwner))
+                {
+                    var message = new ClientConnectedMessage { ClientId = clientId };
+                    NetworkManager.MessageManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, ConnectedClientIds.Where((c) => c != NetworkManager.LocalClientId).ToArray());
+                }
+                else if (NetworkManager.DistributedAuthorityMode && NetworkManager.NetworkConfig.EnableSceneManagement && NetworkManager.DAHost && !NetworkManager.LocalClient.IsSessionOwner)
+                {
+                    var message = new ClientConnectedMessage
+                    {
+                        ShouldSynchronize = true,
+                        ClientId = clientId
+                    };
+                    NetworkManager.MessageManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, NetworkManager.CurrentSessionOwner);
+                }
+            }
+            if (!ConnectedClientIds.Contains(clientId))
+            {
+                ConnectedClientIds.Add(clientId);
+            }
+
+            foreach (var networkObject in NetworkManager.SpawnManager.SpawnedObjectsList)
+            {
+                if (networkObject.SpawnWithObservers)
+                {
+                    networkObject.Observers.Add(clientId);
+                }
+            }
 
-            ConnectedClients.Add(clientId, networkClient);
-            ConnectedClientsList.Add(networkClient);
-            var message = new ClientConnectedMessage { ClientId = clientId };
-            NetworkManager.MessageManager.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ConnectedClientIds);
-            ConnectedClientIds.Add(clientId);
             return networkClient;
         }
 
+        /// <summary>
+        /// Invoked on clients when another client disconnects
+        /// </summary>
+        /// <param name="clientId">the client identifier to remove</param>
+        internal void RemoveClient(ulong clientId)
+        {
+            if (ConnectedClientIds.Contains(clientId))
+            {
+                ConnectedClientIds.Remove(clientId);
+            }
+            if (ConnectedClients.ContainsKey(clientId))
+            {
+                ConnectedClientsList.Remove(ConnectedClients[clientId]);
+            }
+
+            ConnectedClients.Remove(clientId);
+
+            foreach (var networkObject in NetworkManager.SpawnManager.SpawnedObjectsList)
+            {
+                networkObject.Observers.Remove(clientId);
+            }
+        }
+
+        /// <summary>
+        /// DANGO-TODO: Until we have the CMB Server end-to-end with all features verified working via integration tests,
+        /// I am keeping this debug toggle available. (NSS)
+        /// </summary>
+        internal bool EnableDistributeLogging;
+
         /// <summary>
         /// Server-Side:
         /// Invoked when a client is disconnected from a server-host
@@ -923,25 +1069,55 @@ namespace Unity.Netcode
                 {
                     if (!playerObject.DontDestroyWithOwner)
                     {
-                        if (NetworkManager.PrefabHandler.ContainsHandler(ConnectedClients[clientId].PlayerObject.GlobalObjectIdHash))
+                        // DANGO-TODO: This is something that would be best for CMB Service to handle as it is part of the disconnection process
+                        // If a player NetworkObject is being despawned, make sure to remove all children if they are marked to not be destroyed
+                        // with the owner.
+                        if (NetworkManager.DistributedAuthorityMode && NetworkManager.DAHost)
                         {
-                            NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(ConnectedClients[clientId].PlayerObject);
+                            // Remove any children from the player object if they are not going to be destroyed with the owner
+                            var childNetworkObjects = playerObject.GetComponentsInChildren<NetworkObject>();
+                            foreach (var child in childNetworkObjects)
+                            {
+                                // TODO: We have always just removed all children, but we might think about changing this to preserve the nested child
+                                // hierarchy.
+                                if (child.DontDestroyWithOwner && child.transform.transform.parent != null)
+                                {
+                                    // If we are here, then we are running in DAHost mode and have the authority to remove the child from its parent
+                                    child.AuthorityAppliedParenting = true;
+                                    child.TryRemoveParentCachedWorldPositionStays();
+                                }
+                            }
+                        }
+
+                        if (NetworkManager.PrefabHandler.ContainsHandler(playerObject.GlobalObjectIdHash))
+                        {
+                            if (NetworkManager.DAHost && NetworkManager.DistributedAuthorityMode)
+                            {
+                                NetworkManager.SpawnManager.DespawnObject(playerObject, true, NetworkManager.DistributedAuthorityMode);
+                            }
+                            else
+                            {
+                                NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(playerObject);
+                            }
                         }
                         else if (playerObject.IsSpawned)
                         {
                             // Call despawn to assure NetworkBehaviour.OnNetworkDespawn is invoked on the server-side (when the client side disconnected).
                             // This prevents the issue (when just destroying the GameObject) where any NetworkBehaviour component(s) destroyed before the NetworkObject would not have OnNetworkDespawn invoked.
-                            NetworkManager.SpawnManager.DespawnObject(playerObject, true);
+                            NetworkManager.SpawnManager.DespawnObject(playerObject, true, NetworkManager.DistributedAuthorityMode);
                         }
                     }
                     else if (!NetworkManager.ShutdownInProgress)
                     {
-                        playerObject.RemoveOwnership();
+                        if (!NetworkManager.ShutdownInProgress)
+                        {
+                            playerObject.RemoveOwnership();
+                        }
                     }
                 }
 
                 // Get the NetworkObjects owned by the disconnected client
-                var clientOwnedObjects = NetworkManager.SpawnManager.GetClientOwnedObjects(clientId);
+                var clientOwnedObjects = NetworkManager.SpawnManager.SpawnedObjectsList.Where((c) => c.OwnerClientId == clientId).ToList();
                 if (clientOwnedObjects == null)
                 {
                     // This could happen if a client is never assigned a player object and is disconnected
@@ -954,6 +1130,9 @@ namespace Unity.Netcode
                 else
                 {
                     // Handle changing ownership and prefab handlers
+                    var clientCounter = 0;
+                    var predictedClientCount = ConnectedClientsList.Count - 1;
+                    var remainingClients = NetworkManager.DistributedAuthorityMode ? ConnectedClientsList.Where((c) => c.ClientId != clientId).ToList() : null;
                     for (int i = clientOwnedObjects.Count - 1; i >= 0; i--)
                     {
                         var ownedObject = clientOwnedObjects[i];
@@ -963,16 +1142,72 @@ namespace Unity.Netcode
                             {
                                 if (NetworkManager.PrefabHandler.ContainsHandler(clientOwnedObjects[i].GlobalObjectIdHash))
                                 {
+                                    NetworkManager.SpawnManager.DespawnObject(ownedObject, true, true);
                                     NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(clientOwnedObjects[i]);
                                 }
                                 else
                                 {
-                                    Object.Destroy(ownedObject.gameObject);
+                                    NetworkManager.SpawnManager.DespawnObject(ownedObject, true, true);
                                 }
                             }
                             else if (!NetworkManager.ShutdownInProgress)
                             {
-                                ownedObject.RemoveOwnership();
+                                // NOTE: All of the below code only handles ownership transfer.
+                                // For client-server, we just remove the ownership.
+                                // For distributed authority, we need to change ownership based on parenting
+                                if (NetworkManager.DistributedAuthorityMode)
+                                {
+                                    // Only NetworkObjects that have the OwnershipStatus.Distributable flag set and no parent
+                                    // (ownership is transferred to all children) will have their ownership redistributed.
+                                    if (ownedObject.IsOwnershipDistributable && ownedObject.GetCachedParent() == null)
+                                    {
+                                        if (ownedObject.IsOwnershipLocked)
+                                        {
+                                            ownedObject.SetOwnershipLock(false);
+                                        }
+
+                                        // DANGO-TODO: We will want to match how the CMB service handles this. For now, we just try to evenly distribute
+                                        // ownership.
+                                        var targetOwner = NetworkManager.ServerClientId;
+                                        if (predictedClientCount > 1)
+                                        {
+                                            clientCounter++;
+                                            clientCounter = clientCounter % predictedClientCount;
+                                            targetOwner = remainingClients[clientCounter].ClientId;
+                                        }
+                                        if (EnableDistributeLogging)
+                                        {
+                                            Debug.Log($"[Disconnected][Client-{clientId}][NetworkObjectId-{ownedObject.NetworkObjectId} Distributed to Client-{targetOwner}");
+                                        }
+                                        NetworkManager.SpawnManager.ChangeOwnership(ownedObject, targetOwner, true);
+                                        // DANGO-TODO: Should we try handling inactive NetworkObjects?
+                                        // Ownership gets passed down to all children
+                                        var childNetworkObjects = ownedObject.GetComponentsInChildren<NetworkObject>();
+                                        foreach (var childObject in childNetworkObjects)
+                                        {
+                                            // We already changed ownership for this
+                                            if (childObject == ownedObject)
+                                            {
+                                                continue;
+                                            }
+                                            // If the client owner disconnected, it is ok to unlock this at this point in time.
+                                            if (childObject.IsOwnershipLocked)
+                                            {
+                                                childObject.SetOwnershipLock(false);
+                                            }
+
+                                            NetworkManager.SpawnManager.ChangeOwnership(childObject, targetOwner, true);
+                                            if (EnableDistributeLogging)
+                                            {
+                                                Debug.Log($"[Disconnected][Client-{clientId}][Child of {ownedObject.NetworkObjectId}][NetworkObjectId-{ownedObject.NetworkObjectId} Distributed to Client-{targetOwner}");
+                                            }
+                                        }
+                                    }
+                                }
+                                else
+                                {
+                                    ownedObject.RemoveOwnership();
+                                }
                             }
                         }
                     }
@@ -993,6 +1228,37 @@ namespace Unity.Netcode
                 ConnectedClientIds.Remove(clientId);
                 var message = new ClientDisconnectedMessage { ClientId = clientId };
                 MessageManager?.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ConnectedClientIds);
+
+                if (NetworkManager.DistributedAuthorityMode && !NetworkManager.ShutdownInProgress && NetworkManager.IsListening)
+                {
+                    var newSessionOwner = NetworkManager.LocalClientId;
+                    if (ConnectedClientIds.Count > 1)
+                    {
+                        var lowestRTT = ulong.MaxValue;
+                        var unityTransport = NetworkManager.NetworkConfig.NetworkTransport as Transports.UTP.UnityTransport;
+
+                        foreach (var identifier in ConnectedClientIds)
+                        {
+                            if (identifier == NetworkManager.LocalClientId)
+                            {
+                                continue;
+                            }
+                            var rtt = unityTransport.GetCurrentRtt(identifier);
+                            if (rtt < lowestRTT)
+                            {
+                                newSessionOwner = identifier;
+                                lowestRTT = rtt;
+                            }
+                        }
+                    }
+
+                    var sessionOwnerMessage = new SessionOwnerMessage()
+                    {
+                        SessionOwner = newSessionOwner,
+                    };
+                    MessageManager?.SendMessage(ref sessionOwnerMessage, NetworkDelivery.ReliableFragmentedSequenced, ConnectedClientIds);
+                    NetworkManager.SetSessionOwner(newSessionOwner);
+                }
             }
 
             // If the client ID transport map exists
@@ -1259,8 +1525,8 @@ namespace Unity.Netcode
         internal int SendMessage<T>(ref T message, NetworkDelivery delivery, ulong clientId)
             where T : INetworkMessage
         {
-            // Prevent server sending to itself
-            if (LocalClient.IsServer && clientId == NetworkManager.ServerClientId)
+            // Prevent server sending to itself or if there is no MessageManager yet then exit early
+            if ((LocalClient.IsServer && clientId == NetworkManager.ServerClientId) || MessageManager == null)
             {
                 return 0;
             }

Runtime/Core/NetworkBehaviour.cs

@@ -69,6 +69,7 @@ namespace Unity.Netcode
         internal void __endSendServerRpc(ref FastBufferWriter bufferWriter, uint rpcMethodId, ServerRpcParams serverRpcParams, RpcDelivery rpcDelivery)
 #pragma warning restore IDE1006 // restore naming rule violation check
         {
+            var networkManager = NetworkManager;
             var serverRpcMessage = new ServerRpcMessage
             {
                 Metadata = new RpcMetadata
@@ -88,7 +89,7 @@ namespace Unity.Netcode
                     networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
                     break;
                 case RpcDelivery.Unreliable:
-                    if (bufferWriter.Length > NetworkManager.MessageManager.NonFragmentedMessageMaxSize)
+                    if (bufferWriter.Length > networkManager.MessageManager.NonFragmentedMessageMaxSize)
                     {
                         throw new OverflowException("RPC parameters are too large for unreliable delivery.");
                     }
@@ -97,16 +98,16 @@ namespace Unity.Netcode
             }
 
             var rpcWriteSize = 0;
-
-            // If we are a server/host then we just no op and send to ourself
-            if (IsHost || IsServer)
+            // Authority just no ops and sends to itself
+            // Client-Server: Only the server-host sends to self
+            if (IsServer)
             {
                 using var tempBuffer = new FastBufferReader(bufferWriter, Allocator.Temp);
                 var context = new NetworkContext
                 {
                     SenderId = NetworkManager.ServerClientId,
-                    Timestamp = NetworkManager.RealTimeProvider.RealTimeSinceStartup,
-                    SystemOwner = NetworkManager,
+                    Timestamp = networkManager.RealTimeProvider.RealTimeSinceStartup,
+                    SystemOwner = networkManager,
                     // header information isn't valid since it's not a real message.
                     // RpcMessage doesn't access this stuff so it's just left empty.
                     Header = new NetworkMessageHeader(),
@@ -149,6 +150,7 @@ namespace Unity.Netcode
         internal void __endSendClientRpc(ref FastBufferWriter bufferWriter, uint rpcMethodId, ClientRpcParams clientRpcParams, RpcDelivery rpcDelivery)
 #pragma warning restore IDE1006 // restore naming rule violation check
         {
+            var networkManager = NetworkManager;
             var clientRpcMessage = new ClientRpcMessage
             {
                 Metadata = new RpcMetadata
@@ -168,7 +170,7 @@ namespace Unity.Netcode
                     networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
                     break;
                 case RpcDelivery.Unreliable:
-                    if (bufferWriter.Length > NetworkManager.MessageManager.NonFragmentedMessageMaxSize)
+                    if (bufferWriter.Length > networkManager.MessageManager.NonFragmentedMessageMaxSize)
                     {
                         throw new OverflowException("RPC parameters are too large for unreliable delivery.");
                     }
@@ -180,24 +182,22 @@ namespace Unity.Netcode
 
             // We check to see if we need to shortcut for the case where we are the host/server and we can send a clientRPC
             // to ourself. Sadly we have to figure that out from the list of clientIds :(
-            bool shouldSendToHost = false;
+            bool shouldInvokeLocally = false;
             if (clientRpcParams.Send.TargetClientIds != null)
             {
                 foreach (var targetClientId in clientRpcParams.Send.TargetClientIds)
                 {
                     if (targetClientId == NetworkManager.ServerClientId)
                     {
-                        shouldSendToHost = true;
-                        break;
+                        shouldInvokeLocally = true;
+                        continue;
                     }
-
                     // Check to make sure we are sending to only observers, if not log an error.
-                    if (NetworkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
+                    if (networkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
                     {
                         NetworkLog.LogError(GenerateObserverErrorMessage(clientRpcParams, targetClientId));
                     }
                 }
-
                 rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, in clientRpcParams.Send.TargetClientIds);
             }
             else if (clientRpcParams.Send.TargetClientIdsNativeArray != null)
@@ -206,17 +206,15 @@ namespace Unity.Netcode
                 {
                     if (targetClientId == NetworkManager.ServerClientId)
                     {
-                        shouldSendToHost = true;
-                        break;
+                        shouldInvokeLocally = true;
+                        continue;
                     }
-
                     // Check to make sure we are sending to only observers, if not log an error.
-                    if (NetworkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
+                    if (networkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
                     {
                         NetworkLog.LogError(GenerateObserverErrorMessage(clientRpcParams, targetClientId));
                     }
                 }
-
                 rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, clientRpcParams.Send.TargetClientIdsNativeArray.Value);
             }
             else
@@ -227,7 +225,7 @@ namespace Unity.Netcode
                     // Skip over the host
                     if (IsHost && observerEnumerator.Current == NetworkManager.LocalClientId)
                     {
-                        shouldSendToHost = true;
+                        shouldInvokeLocally = true;
                         continue;
                     }
                     rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, observerEnumerator.Current);
@@ -235,14 +233,14 @@ namespace Unity.Netcode
             }
 
             // If we are a server/host then we just no op and send to ourself
-            if (shouldSendToHost)
+            if (shouldInvokeLocally)
             {
                 using var tempBuffer = new FastBufferReader(bufferWriter, Allocator.Temp);
                 var context = new NetworkContext
                 {
                     SenderId = NetworkManager.ServerClientId,
-                    Timestamp = NetworkManager.RealTimeProvider.RealTimeSinceStartup,
-                    SystemOwner = NetworkManager,
+                    Timestamp = networkManager.RealTimeProvider.RealTimeSinceStartup,
+                    SystemOwner = networkManager,
                     // header information isn't valid since it's not a real message.
                     // RpcMessage doesn't access this stuff so it's just left empty.
                     Header = new NetworkMessageHeader(),
@@ -261,7 +259,7 @@ namespace Unity.Netcode
                 {
                     foreach (var targetClientId in clientRpcParams.Send.TargetClientIds)
                     {
-                        NetworkManager.NetworkMetrics.TrackRpcSent(
+                        networkManager.NetworkMetrics.TrackRpcSent(
                             targetClientId,
                             NetworkObject,
                             rpcMethodName,
@@ -273,7 +271,7 @@ namespace Unity.Netcode
                 {
                     foreach (var targetClientId in clientRpcParams.Send.TargetClientIdsNativeArray)
                     {
-                        NetworkManager.NetworkMetrics.TrackRpcSent(
+                        networkManager.NetworkMetrics.TrackRpcSent(
                             targetClientId,
                             NetworkObject,
                             rpcMethodName,
@@ -286,7 +284,7 @@ namespace Unity.Netcode
                     var observerEnumerator = NetworkObject.Observers.GetEnumerator();
                     while (observerEnumerator.MoveNext())
                     {
-                        NetworkManager.NetworkMetrics.TrackRpcSent(
+                        networkManager.NetworkMetrics.TrackRpcSent(
                             observerEnumerator.Current,
                             NetworkObject,
                             rpcMethodName,
@@ -372,6 +370,12 @@ namespace Unity.Netcode
                     case SendTo.ClientsAndHost:
                         rpcParams.Send.Target = RpcTarget.ClientsAndHost;
                         break;
+                    case SendTo.Authority:
+                        rpcParams.Send.Target = RpcTarget.Authority;
+                        break;
+                    case SendTo.NotAuthority:
+                        rpcParams.Send.Target = RpcTarget.NotAuthority;
+                        break;
                     case SendTo.SpecifiedInParams:
                         throw new RpcException("This method requires a runtime-specified send target.");
                 }
@@ -456,6 +460,31 @@ namespace Unity.Netcode
         /// </summary>
         public bool IsServer { get; private set; }
 
+        /// <summary>
+        /// Determines if the local client has authority over the associated NetworkObject
+        /// Client-Server: This will return true if IsServer or IsHost
+        /// Distributed Authority: This will return true if IsOwner
+        /// </summary>
+        public bool HasAuthority { get; internal set; }
+
+        internal NetworkClient LocalClient { get; private set; }
+
+        /// <summary>
+        /// Gets if the client is the distributed authority mode session owner
+        /// </summary>
+        public bool IsSessionOwner
+        {
+            get
+            {
+                if (LocalClient == null)
+                {
+                    return false;
+                }
+
+                return LocalClient.IsSessionOwner;
+            }
+        }
+
         /// <summary>
         /// Gets if the server (local or remote) is a host - i.e., also a client
         /// </summary>
@@ -505,12 +534,14 @@ namespace Unity.Netcode
         {
             get
             {
+                if (m_NetworkObject != null)
+                {
+                    return m_NetworkObject;
+                }
+
                 try
                 {
-                    if (m_NetworkObject == null)
-                    {
-                        m_NetworkObject = GetComponentInParent<NetworkObject>();
-                    }
+                    m_NetworkObject = GetComponentInParent<NetworkObject>();
                 }
                 catch (Exception)
                 {
@@ -579,30 +610,34 @@ namespace Unity.Netcode
         /// </summary>
         internal void UpdateNetworkProperties()
         {
+            var networkObject = NetworkObject;
             // Set NetworkObject dependent properties
-            if (NetworkObject != null)
+            if (networkObject != null)
             {
+                var networkManager = NetworkManager;
                 // Set identification related properties
-                NetworkObjectId = NetworkObject.NetworkObjectId;
-                IsLocalPlayer = NetworkObject.IsLocalPlayer;
+                NetworkObjectId = networkObject.NetworkObjectId;
+                IsLocalPlayer = networkObject.IsLocalPlayer;
 
                 // This is "OK" because GetNetworkBehaviourOrderIndex uses the order of
                 // NetworkObject.ChildNetworkBehaviours which is set once when first
                 // accessed.
-                NetworkBehaviourId = NetworkObject.GetNetworkBehaviourOrderIndex(this);
+                NetworkBehaviourId = networkObject.GetNetworkBehaviourOrderIndex(this);
 
                 // Set ownership related properties
-                IsOwnedByServer = NetworkObject.IsOwnedByServer;
-                IsOwner = NetworkObject.IsOwner;
-                OwnerClientId = NetworkObject.OwnerClientId;
+                IsOwnedByServer = networkObject.IsOwnedByServer;
+                IsOwner = networkObject.IsOwner;
+                OwnerClientId = networkObject.OwnerClientId;
 
                 // Set NetworkManager dependent properties
-                if (NetworkManager != null)
+                if (networkManager != null)
                 {
-                    IsHost = NetworkManager.IsListening && NetworkManager.IsHost;
-                    IsClient = NetworkManager.IsListening && NetworkManager.IsClient;
-                    IsServer = NetworkManager.IsListening && NetworkManager.IsServer;
-                    ServerIsHost = NetworkManager.IsListening && NetworkManager.ServerIsHost;
+                    IsHost = networkManager.IsListening && networkManager.IsHost;
+                    IsClient = networkManager.IsListening && networkManager.IsClient;
+                    IsServer = networkManager.IsListening && networkManager.IsServer;
+                    LocalClient = networkManager.LocalClient;
+                    HasAuthority = networkObject.HasAuthority;
+                    ServerIsHost = networkManager.IsListening && networkManager.ServerIsHost;
                 }
             }
             else // Shouldn't happen, but if so then set the properties to their default value;
@@ -610,9 +645,21 @@ namespace Unity.Netcode
                 OwnerClientId = NetworkObjectId = default;
                 IsOwnedByServer = IsOwner = IsHost = IsClient = IsServer = ServerIsHost = default;
                 NetworkBehaviourId = default;
+                LocalClient = default;
+                HasAuthority = default;
             }
         }
 
+        /// <summary>
+        /// Distributed Authority Mode Only
+        /// Invoked only on the authority instance when a <see cref="NetworkObject"/> is deferring its despawn on non-authoritative instances.
+        /// </summary>
+        /// <remarks>
+        /// See also: <see cref="NetworkObject.DeferDespawn(int, bool)"/>
+        /// </remarks>
+        /// <param name="despawnTick">the future network tick that the <see cref="NetworkObject"/> will be despawned on non-authoritative instances</param>
+        public virtual void OnDeferringDespawn(int despawnTick) { }
+
         /// <summary>
         /// Gets called when the <see cref="NetworkObject"/> gets spawned, message handlers are ready to be registered and the network is setup.
         /// </summary>
@@ -642,7 +689,8 @@ namespace Unity.Netcode
             }
 
             InitializeVariables();
-            if (IsServer)
+
+            if (NetworkObject.HasAuthority)
             {
                 // Since we just spawned the object and since user code might have modified their NetworkVariable, esp.
                 // NetworkList, we need to mark the object as free of updates.
@@ -679,7 +727,7 @@ namespace Unity.Netcode
         /// <summary>
         /// Invoked on all clients, override this method to be notified of any
         /// ownership changes (even if the instance was niether the previous or
-        /// newly assigned current owner). 
+        /// newly assigned current owner).
         /// </summary>
         /// <param name="previous">the previous owner</param>
         /// <param name="current">the current owner</param>
@@ -838,65 +886,83 @@ namespace Unity.Netcode
             PreNetworkVariableWrite();
         }
 
-        internal void VariableUpdate(ulong targetClientId)
-        {
-            NetworkVariableUpdate(targetClientId, NetworkBehaviourId);
-        }
-
         internal readonly List<int> NetworkVariableIndexesToReset = new List<int>();
         internal readonly HashSet<int> NetworkVariableIndexesToResetSet = new HashSet<int>();
 
-        private void NetworkVariableUpdate(ulong targetClientId, int behaviourIndex)
+        internal void NetworkVariableUpdate(ulong targetClientId)
         {
             if (!CouldHaveDirtyNetworkVariables())
             {
                 return;
             }
 
+            // Getting these ahead of time actually improves performance
+            var networkManager = NetworkManager;
+            var networkObject = NetworkObject;
+            var behaviourIndex = networkObject.GetNetworkBehaviourOrderIndex(this);
+            var messageManager = networkManager.MessageManager;
+            var connectionManager = networkManager.ConnectionManager;
+
             for (int j = 0; j < m_DeliveryMappedNetworkVariableIndices.Count; j++)
             {
+                var networkVariable = (NetworkVariableBase)null;
                 var shouldSend = false;
                 for (int k = 0; k < NetworkVariableFields.Count; k++)
                 {
-                    var networkVariable = NetworkVariableFields[k];
+                    networkVariable = NetworkVariableFields[k];
                     if (networkVariable.IsDirty() && networkVariable.CanClientRead(targetClientId))
                     {
                         shouldSend = true;
                         break;
                     }
                 }
-
-                if (shouldSend)
+                // All of this is just to prevent the DA Host from re-sending a NetworkVariable update it received from the client owner
+                // If this NetworkManager is running as a DAHost:
+                // - Only when the write permissions is owner (to pass existing integration tests running as DAHost)
+                // - If the target client ID is the owner and the owner is not the local NetworkManager instance
+                // - **Special** As long as ownership did not just change and we are sending the new owner any dirty/updated NetworkVariables
+                // Under these conditions we should not send to the client
+                if (shouldSend && networkManager.DAHost && networkVariable.WritePerm == NetworkVariableWritePermission.Owner &&
+                    networkObject.OwnerClientId == targetClientId && networkObject.OwnerClientId != networkManager.LocalClientId &&
+                    networkObject.PreviousOwnerId == networkObject.OwnerClientId)
                 {
-                    var message = new NetworkVariableDeltaMessage
+                    shouldSend = false;
+                }
+
+                if (!shouldSend)
+                {
+                    continue;
+                }
+                var message = new NetworkVariableDeltaMessage
+                {
+                    NetworkObjectId = NetworkObjectId,
+                    NetworkBehaviourIndex = behaviourIndex,
+                    NetworkBehaviour = this,
+                    TargetClientId = targetClientId,
+                    DeliveryMappedNetworkVariableIndex = m_DeliveryMappedNetworkVariableIndices[j]
+                };
+                // TODO: Serialization is where the IsDirty flag gets changed.
+                // Messages don't get sent from the server to itself, so if we're host and sending to ourselves,
+                // we still have to actually serialize the message even though we're not sending it, otherwise
+                // the dirty flag doesn't change properly. These two pieces should be decoupled at some point
+                // so we don't have to do this serialization work if we're not going to use the result.
+                if (IsServer && targetClientId == NetworkManager.ServerClientId)
+                {
+                    var tmpWriter = new FastBufferWriter(messageManager.NonFragmentedMessageMaxSize, Allocator.Temp, messageManager.FragmentedMessageMaxSize);
+                    using (tmpWriter)
                     {
-                        NetworkObjectId = NetworkObjectId,
-                        NetworkBehaviourIndex = NetworkObject.GetNetworkBehaviourOrderIndex(this),
-                        NetworkBehaviour = this,
-                        TargetClientId = targetClientId,
-                        DeliveryMappedNetworkVariableIndex = m_DeliveryMappedNetworkVariableIndices[j]
-                    };
-                    // TODO: Serialization is where the IsDirty flag gets changed.
-                    // Messages don't get sent from the server to itself, so if we're host and sending to ourselves,
-                    // we still have to actually serialize the message even though we're not sending it, otherwise
-                    // the dirty flag doesn't change properly. These two pieces should be decoupled at some point
-                    // so we don't have to do this serialization work if we're not going to use the result.
-                    if (IsServer && targetClientId == NetworkManager.ServerClientId)
-                    {
-                        var tmpWriter = new FastBufferWriter(NetworkManager.MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp, NetworkManager.MessageManager.FragmentedMessageMaxSize);
-                        using (tmpWriter)
-                        {
-                            message.Serialize(tmpWriter, message.Version);
-                        }
-                    }
-                    else
-                    {
-                        NetworkManager.ConnectionManager.SendMessage(ref message, m_DeliveryTypesForNetworkVariableGroups[j], targetClientId);
+                        message.Serialize(tmpWriter, message.Version);
                     }
                 }
+                else
+                {
+                    connectionManager.SendMessage(ref message, m_DeliveryTypesForNetworkVariableGroups[j], targetClientId);
+                }
             }
         }
 
+        internal static bool LogSentVariableUpdateMessage;
+
         private bool CouldHaveDirtyNetworkVariables()
         {
             // TODO: There should be a better way by reading one dirty variable vs. 'n'
@@ -929,17 +995,30 @@ namespace Unity.Netcode
         /// </remarks>
         internal void WriteNetworkVariableData(FastBufferWriter writer, ulong targetClientId)
         {
+            var networkManager = NetworkManager;
+            if (networkManager.DistributedAuthorityMode)
+            {
+                writer.WriteValueSafe((ushort)NetworkVariableFields.Count);
+            }
+
             if (NetworkVariableFields.Count == 0)
             {
                 return;
             }
 
+            // DANGO-TODO: Made some modifications here that overlap/won't play nice with EnsureNetworkVariableLenghtSafety.
+            // Worth either merging or more cleanly separating these codepaths.
             for (int j = 0; j < NetworkVariableFields.Count; j++)
             {
-
+                // Note: In distributed authority mode, all clients can read
                 if (NetworkVariableFields[j].CanClientRead(targetClientId))
                 {
-                    if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                    if (networkManager.DistributedAuthorityMode)
+                    {
+                        writer.WriteValueSafe(NetworkVariableFields[j].Type);
+                    }
+
+                    if (networkManager.DistributedAuthorityMode || networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                     {
                         var writePos = writer.Position;
                         // Note: This value can't be packed because we don't know how large it will be in advance
@@ -960,10 +1039,13 @@ namespace Unity.Netcode
                         NetworkVariableFields[j].WriteField(writer);
                     }
                 }
-                else // Only if EnsureNetworkVariableLengthSafety, otherwise just skip
-                if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                else
                 {
-                    writer.WriteValueSafe((ushort)0);
+                    // Only if EnsureNetworkVariableLengthSafety, otherwise just skip
+                    if (networkManager.DistributedAuthorityMode || networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                    {
+                        writer.WriteValueSafe((ushort)0);
+                    }
                 }
             }
         }
@@ -978,16 +1060,29 @@ namespace Unity.Netcode
         /// </remarks>
         internal void SetNetworkVariableData(FastBufferReader reader, ulong clientId)
         {
+            var networkManager = NetworkManager;
+            if (networkManager.DistributedAuthorityMode)
+            {
+                reader.ReadValueSafe(out ushort variableCount);
+                if (variableCount != NetworkVariableFields.Count)
+                {
+                    Debug.LogError("NetworkVariable count mismatch.");
+                    return;
+                }
+            }
+
             if (NetworkVariableFields.Count == 0)
             {
                 return;
             }
 
+            // DANGO-TODO: Made some modifications here that overlap/won't play nice with EnsureNetworkVariableLenghtSafety.
+            // Worth either merging or more cleanly separating these codepaths.
             for (int j = 0; j < NetworkVariableFields.Count; j++)
             {
                 var varSize = (ushort)0;
                 var readStartPos = 0;
-                if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                 {
                     reader.ReadValueSafe(out varSize);
                     if (varSize == 0)
@@ -999,12 +1094,35 @@ namespace Unity.Netcode
                 else // If the client cannot read this field, then skip it
                 if (!NetworkVariableFields[j].CanClientRead(clientId))
                 {
+                    if (networkManager.DistributedAuthorityMode)
+                    {
+                        reader.ReadValueSafe(out ushort size);
+                        if (size != 0)
+                        {
+                            Debug.LogError("Expected zero size");
+                        }
+                    }
                     continue;
                 }
 
-                NetworkVariableFields[j].ReadField(reader);
+                if (networkManager.DistributedAuthorityMode)
+                {
+                    // Explicit setting of the NetworkVariableType is only needed for CMB Runtime
+                    reader.ReadValueSafe(out NetworkVariableType _);
+                    reader.ReadValueSafe(out ushort size);
+                    var start_marker = reader.Position;
+                    NetworkVariableFields[j].ReadField(reader);
+                    if (reader.Position - start_marker != size)
+                    {
+                        Debug.LogError("Mismatched network variable size");
+                    }
+                }
+                else
+                {
+                    NetworkVariableFields[j].ReadField(reader);
+                }
 
-                if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                 {
                     if (reader.Position > (readStartPos + varSize))
                     {
@@ -1170,7 +1288,7 @@ namespace Unity.Netcode
                 {
                     if (NetworkManager.LogLevel <= LogLevel.Normal)
                     {
-                        NetworkLog.LogWarning($"{name} read {totalBytesRead} bytes but was expected to read {expectedBytesToRead} bytes during synchronization deserialization! This {nameof(NetworkBehaviour)} is being skipped and will not be synchronized!");
+                        NetworkLog.LogWarning($"{name} read {totalBytesRead} bytes but was expected to read {expectedBytesToRead} bytes during synchronization deserialization! This {nameof(NetworkBehaviour)}({GetType().Name})is being skipped and will not be synchronized!");
                     }
                     synchronizationError = true;
                 }

Runtime/Core/NetworkBehaviourUpdater.cs

@@ -44,13 +44,12 @@ namespace Unity.Netcode
                         for (int i = 0; i < m_ConnectionManager.ConnectedClientsList.Count; i++)
                         {
                             var client = m_ConnectionManager.ConnectedClientsList[i];
-
-                            if (dirtyObj.IsNetworkVisibleTo(client.ClientId))
+                            if (m_NetworkManager.DistributedAuthorityMode || dirtyObj.IsNetworkVisibleTo(client.ClientId))
                             {
                                 // Sync just the variables for just the objects this client sees
                                 for (int k = 0; k < dirtyObj.ChildNetworkBehaviours.Count; k++)
                                 {
-                                    dirtyObj.ChildNetworkBehaviours[k].VariableUpdate(client.ClientId);
+                                    dirtyObj.ChildNetworkBehaviours[k].NetworkVariableUpdate(client.ClientId);
                                 }
                             }
                         }
@@ -69,7 +68,7 @@ namespace Unity.Netcode
                             }
                             for (int k = 0; k < sobj.ChildNetworkBehaviours.Count; k++)
                             {
-                                sobj.ChildNetworkBehaviours[k].VariableUpdate(NetworkManager.ServerClientId);
+                                sobj.ChildNetworkBehaviours[k].NetworkVariableUpdate(NetworkManager.ServerClientId);
                             }
                         }
                     }
@@ -95,6 +94,8 @@ namespace Unity.Netcode
                 foreach (var dirtyobj in m_DirtyNetworkObjects)
                 {
                     dirtyobj.PostNetworkVariableWrite();
+                    // Once done processing, we set the previous owner id to the current owner id
+                    dirtyobj.PreviousOwnerId = dirtyobj.OwnerClientId;
                 }
                 m_DirtyNetworkObjects.Clear();
             }

Runtime/Core/NetworkManager.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using Unity.Collections;
+using System.Linq;
 using UnityEngine;
 #if UNITY_EDITOR
 using UnityEditor;
@@ -34,6 +35,148 @@ namespace Unity.Netcode
 
 #pragma warning restore IDE1006 // restore naming rule violation check
 
+        /// <summary>
+        /// Distributed Authority Mode
+        /// Returns true if the current session is running in distributed authority mode.
+        /// </summary>
+        public bool DistributedAuthorityMode
+        {
+            get
+            {
+                return NetworkConfig.SessionMode == SessionModeTypes.DistributedAuthority;
+            }
+        }
+
+        /// <summary>
+        /// Distributed Authority Mode
+        /// Gets whether the NetworkManager is connected to a distributed authority state service.
+        /// <see cref="NetworkClient.DAHost"/> to determine if the instance is mocking the state service.
+        /// </summary>
+        public bool CMBServiceConnection
+        {
+            get
+            {
+                return NetworkConfig.UseCMBService;
+            }
+        }
+
+        /// <summary>
+        /// Distributed Authority Mode
+        /// When enabled, the player prefab will be automatically spawned on the newly connected client-side.
+        /// </summary>
+        /// <remarks>
+        /// Refer to <see cref="NetworkConfig.AutoSpawnPlayerPrefabClientSide"/> to enable/disable automatic spawning of the player prefab.
+        /// Alternately, override the <see cref="FetchLocalPlayerPrefabToSpawn"/> to control what prefab the player should spawn.
+        /// </remarks>
+        public bool AutoSpawnPlayerPrefabClientSide
+        {
+            get
+            {
+                return NetworkConfig.AutoSpawnPlayerPrefabClientSide;
+            }
+        }
+
+        /// <summary>
+        /// Distributed Authority Mode
+        /// Delegate definition for <see cref="FetchLocalPlayerPrefabToSpawn"/>
+        /// </summary>
+        /// <returns>Player Prefab <see cref="GameObject"/></returns>
+        public delegate GameObject OnFetchLocalPlayerPrefabToSpawnDelegateHandler();
+
+        /// <summary>
+        /// Distributed Authority Mode
+        /// When a callback is assigned, this provides control over what player prefab a client will be using.
+        /// This is invoked only when <see cref="NetworkConfig.AutoSpawnPlayerPrefabClientSide"/> is enabled.
+        /// </summary>
+        public OnFetchLocalPlayerPrefabToSpawnDelegateHandler OnFetchLocalPlayerPrefabToSpawn;
+
+        internal GameObject FetchLocalPlayerPrefabToSpawn()
+        {
+            if (!AutoSpawnPlayerPrefabClientSide)
+            {
+                Debug.LogError($"[{nameof(FetchLocalPlayerPrefabToSpawn)}] Invoked when {nameof(NetworkConfig.AutoSpawnPlayerPrefabClientSide)} was not set! Check call paths!");
+                return null;
+            }
+            if (OnFetchLocalPlayerPrefabToSpawn == null && NetworkConfig.PlayerPrefab == null)
+            {
+                return null;
+            }
+
+            if (OnFetchLocalPlayerPrefabToSpawn != null)
+            {
+                return OnFetchLocalPlayerPrefabToSpawn();
+            }
+            return NetworkConfig.PlayerPrefab;
+        }
+
+        /// <summary>
+        /// Distributed Authority Mode
+        /// Gets whether the current NetworkManager is running as a mock distributed authority state service (DAHost)
+        /// </summary>
+        public bool DAHost
+        {
+            get
+            {
+                return LocalClient.DAHost;
+            }
+        }
+
+        // DANGO-TODO-MVP: Remove these properties once the service handles object distribution
+        internal ulong ClientToRedistribute;
+        internal bool RedistributeToClient;
+        internal int TickToRedistribute;
+
+        internal List<NetworkObject> DeferredDespawnObjects = new List<NetworkObject>();
+
+        public ulong CurrentSessionOwner { get; internal set; }
+
+        internal void SetSessionOwner(ulong sessionOwner)
+        {
+            var previousSessionOwner = CurrentSessionOwner;
+            CurrentSessionOwner = sessionOwner;
+            LocalClient.IsSessionOwner = LocalClientId == sessionOwner;
+            if (LocalClient.IsSessionOwner)
+            {
+                foreach (var networkObjectEntry in SpawnManager.SpawnedObjects)
+                {
+                    var networkObject = networkObjectEntry.Value;
+                    if (networkObject.IsSceneObject == null || !networkObject.IsSceneObject.Value)
+                    {
+                        continue;
+                    }
+                    if (networkObject.OwnerClientId != LocalClientId)
+                    {
+                        SpawnManager.ChangeOwnership(networkObject, LocalClientId, true);
+                    }
+                }
+            }
+        }
+
+        // TODO: Make this internal after testing
+        public void PromoteSessionOwner(ulong clientId)
+        {
+            if (!DistributedAuthorityMode)
+            {
+                NetworkLog.LogErrorServer($"[SceneManagement][NotDA] Invoking promote session owner while not in distributed authority mode!");
+                return;
+            }
+            if (!DAHost)
+            {
+                NetworkLog.LogErrorServer($"[SceneManagement][NotDAHost] Client is attempting to promote another client as the session owner!");
+                return;
+            }
+            SetSessionOwner(clientId);
+            var sessionOwnerMessage = new SessionOwnerMessage()
+            {
+                SessionOwner = clientId,
+            };
+            var clients = ConnectionManager.ConnectedClientIds.Where(c => c != LocalClientId).ToArray();
+            foreach (var targetClient in clients)
+            {
+                ConnectionManager.SendMessage(ref sessionOwnerMessage, NetworkDelivery.ReliableSequenced, targetClient);
+            }
+        }
+
         public void NetworkUpdate(NetworkUpdateStage updateStage)
         {
             switch (updateStage)
@@ -56,6 +199,15 @@ namespace Unity.Netcode
                     break;
                 case NetworkUpdateStage.PostLateUpdate:
                     {
+                        // Handle deferred despawning
+                        if (DistributedAuthorityMode)
+                        {
+                            SpawnManager.DeferredDespawnUpdate(ServerTime);
+                        }
+
+                        // Update any NetworkObject's registered to notify of scene migration changes.
+                        NetworkObject.UpdateNetworkObjectSceneChanges();
+
                         // This should be invoked just prior to the MessageManager processes its outbound queue.
                         SceneManager.CheckForAndSendNetworkObjectSceneChanged();
 
@@ -71,6 +223,16 @@ namespace Unity.Netcode
                         // This is "ok" to invoke when not processing messages since it is just cleaning up messages that never got handled within their timeout period.
                         DeferredMessageManager.CleanupStaleTriggers();
 
+                        // DANGO-TODO-MVP: Remove this once the service handles object distribution
+                        // NOTE: This needs to be the last thing done and should happen exactly at this point
+                        // in the update
+                        if (RedistributeToClient && ServerTime.Tick <= TickToRedistribute)
+                        {
+                            RedistributeToClient = false;
+                            SpawnManager.DistributeNetworkObjects(ClientToRedistribute);
+                            ClientToRedistribute = 0;
+                        }
+
                         if (m_ShuttingDown)
                         {
                             // Host-server will disconnect any connected clients prior to finalizing its shutdown
@@ -171,17 +333,17 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets a dictionary of connected clients and their clientId keys. This is only accessible on the server.
+        /// Gets a dictionary of connected clients and their clientId keys.
         /// </summary>
-        public IReadOnlyDictionary<ulong, NetworkClient> ConnectedClients => IsServer ? ConnectionManager.ConnectedClients : throw new NotServerException($"{nameof(ConnectionManager.ConnectedClients)} should only be accessed on server.");
+        public IReadOnlyDictionary<ulong, NetworkClient> ConnectedClients => ConnectionManager.ConnectedClients;
 
         /// <summary>
-        /// Gets a list of connected clients. This is only accessible on the server.
+        /// Gets a list of connected clients.
         /// </summary>
-        public IReadOnlyList<NetworkClient> ConnectedClientsList => IsServer ? ConnectionManager.ConnectedClientsList : throw new NotServerException($"{nameof(ConnectionManager.ConnectedClientsList)} should only be accessed on server.");
+        public IReadOnlyList<NetworkClient> ConnectedClientsList => ConnectionManager.ConnectedClientsList;
 
         /// <summary>
-        /// Gets a list of just the IDs of all connected clients. This is only accessible on the server.
+        /// Gets a list of just the IDs of all connected clients.
         /// </summary>
         public IReadOnlyList<ulong> ConnectedClientsIds => ConnectionManager.ConnectedClientIds;
 
@@ -780,6 +942,10 @@ namespace Unity.Netcode
 
         internal void Initialize(bool server)
         {
+
+            //DANGOEXP TODO: Remove this before finalizing the experimental release
+            NetworkConfig.AutoSpawnPlayerPrefabClientSide = DistributedAuthorityMode;
+
             // Make sure the ServerShutdownState is reset when initializing
             if (server)
             {
@@ -930,7 +1096,10 @@ namespace Unity.Netcode
                 return false;
             }
 
-            ConnectionManager.LocalClient.SetRole(true, false, this);
+            if (!ConnectionManager.LocalClient.SetRole(true, false, this))
+            {
+                return false;
+            }
             ConnectionManager.LocalClient.ClientId = ServerClientId;
 
             Initialize(true);
@@ -976,7 +1145,10 @@ namespace Unity.Netcode
                 return false;
             }
 
-            ConnectionManager.LocalClient.SetRole(false, true, this);
+            if (!ConnectionManager.LocalClient.SetRole(false, true, this))
+            {
+                return false;
+            }
 
             Initialize(false);
 
@@ -1019,7 +1191,11 @@ namespace Unity.Netcode
                 return false;
             }
 
-            ConnectionManager.LocalClient.SetRole(true, true, this);
+            if (!ConnectionManager.LocalClient.SetRole(true, true, this))
+            {
+                return false;
+            }
+
             Initialize(true);
             try
             {
@@ -1075,7 +1251,8 @@ namespace Unity.Netcode
                 var response = new ConnectionApprovalResponse
                 {
                     Approved = true,
-                    CreatePlayerObject = NetworkConfig.PlayerPrefab != null
+                    // Distributed authority always returns true since the client side handles spawning (whether automatically or manually)
+                    CreatePlayerObject = DistributedAuthorityMode || NetworkConfig.PlayerPrefab != null,
                 };
                 ConnectionManager.HandleConnectionApproval(ServerClientId, response);
             }
@@ -1185,6 +1362,12 @@ namespace Unity.Netcode
             IsListening = false;
             m_ShuttingDown = false;
 
+            // Generate a local notification that the host client is disconnected
+            if (IsHost)
+            {
+                ConnectionManager.InvokeOnClientDisconnectCallback(LocalClientId);
+            }
+
             if (ConnectionManager.LocalClient.IsClient)
             {
                 // If we were a client, we want to know if we were a host
@@ -1218,6 +1401,7 @@ namespace Unity.Netcode
             NetworkTickSystem = null;
         }
 
+
         // Ensures that the NetworkManager is cleaned up before OnDestroy is run on NetworkObjects and NetworkBehaviours when quitting the application.
         private void OnApplicationQuit()
         {

Runtime/Logging/NetworkLog.cs

@@ -39,6 +39,12 @@ namespace Unity.Netcode
         /// <param name="message">The message to log</param>
         public static void LogInfoServer(string message) => LogServer(message, LogType.Info);
 
+        /// <summary>
+        /// Logs an info log locally and on the session owner if possible.
+        /// </summary>
+        /// <param name="message">The message to log</param>
+        public static void LogInfoSessionOwner(string message) => LogServer(message, LogType.Info);
+
         /// <summary>
         /// Logs a warning log locally and on the server if possible.
         /// </summary>
@@ -58,7 +64,8 @@ namespace Unity.Netcode
             var networkManager = NetworkManagerOverride ??= NetworkManager.Singleton;
             // Get the sender of the local log
             ulong localId = networkManager?.LocalClientId ?? 0;
-            bool isServer = networkManager?.IsServer ?? true;
+            bool isServer = networkManager && networkManager.DistributedAuthorityMode ? networkManager.LocalClient.IsSessionOwner :
+                networkManager && !networkManager.DistributedAuthorityMode ? networkManager.IsServer : true;
             switch (logType)
             {
                 case LogType.Info:
@@ -98,7 +105,8 @@ namespace Unity.Netcode
                 var networkMessage = new ServerLogMessage
                 {
                     LogType = logType,
-                    Message = message
+                    Message = message,
+                    SenderId = localId
                 };
                 var size = networkManager.ConnectionManager.SendMessage(ref networkMessage, NetworkDelivery.ReliableFragmentedSequenced, NetworkManager.ServerClientId);
 
@@ -106,9 +114,19 @@ namespace Unity.Netcode
             }
         }
 
-        internal static void LogInfoServerLocal(string message, ulong sender) => Debug.Log($"[Netcode-Server Sender={sender}] {message}");
-        internal static void LogWarningServerLocal(string message, ulong sender) => Debug.LogWarning($"[Netcode-Server Sender={sender}] {message}");
-        internal static void LogErrorServerLocal(string message, ulong sender) => Debug.LogError($"[Netcode-Server Sender={sender}] {message}");
+        private static string Header()
+        {
+            var networkManager = NetworkManagerOverride ??= NetworkManager.Singleton;
+            if (networkManager.DistributedAuthorityMode)
+            {
+                return "Session-Owner";
+            }
+            return "Netcode-Server";
+        }
+
+        internal static void LogInfoServerLocal(string message, ulong sender) => Debug.Log($"[{Header()} Sender={sender}] {message}");
+        internal static void LogWarningServerLocal(string message, ulong sender) => Debug.LogWarning($"[{Header()} Sender={sender}] {message}");
+        internal static void LogErrorServerLocal(string message, ulong sender) => Debug.LogError($"[{Header()} Sender={sender}] {message}");
 
         internal enum LogType : byte
         {

Runtime/Messaging/CustomMessageManager.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using Unity.Collections;
+using UnityEngine;
 
 namespace Unity.Netcode
 {
@@ -151,18 +152,14 @@ namespace Unity.Netcode
                 // We dont know what size to use. Try every (more collision prone)
                 if (m_NamedMessageHandlers32.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler32))
                 {
-                    // handler can remove itself, cache the name for metrics
-                    string messageName = m_MessageHandlerNameLookup32[hash];
                     messageHandler32(sender, reader);
-                    m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount);
+                    m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup32[hash], bytesCount);
                 }
 
                 if (m_NamedMessageHandlers64.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler64))
                 {
-                    // handler can remove itself, cache the name for metrics
-                    string messageName = m_MessageHandlerNameLookup64[hash];
                     messageHandler64(sender, reader);
-                    m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount);
+                    m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup64[hash], bytesCount);
                 }
             }
             else
@@ -173,19 +170,15 @@ namespace Unity.Netcode
                     case HashSize.VarIntFourBytes:
                         if (m_NamedMessageHandlers32.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler32))
                         {
-                            // handler can remove itself, cache the name for metrics
-                            string messageName = m_MessageHandlerNameLookup32[hash];
                             messageHandler32(sender, reader);
-                            m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount);
+                            m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup32[hash], bytesCount);
                         }
                         break;
                     case HashSize.VarIntEightBytes:
                         if (m_NamedMessageHandlers64.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler64))
                         {
-                            // handler can remove itself, cache the name for metrics
-                            string messageName = m_MessageHandlerNameLookup64[hash];
                             messageHandler64(sender, reader);
-                            m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount);
+                            m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup64[hash], bytesCount);
                         }
                         break;
                 }
@@ -199,6 +192,14 @@ namespace Unity.Netcode
         /// <param name="callback">The callback to run when a named message is received.</param>
         public void RegisterNamedMessageHandler(string name, HandleNamedMessageDelegate callback)
         {
+            if (string.IsNullOrEmpty(name))
+            {
+                if (m_NetworkManager.LogLevel <= LogLevel.Error)
+                {
+                    Debug.LogError($"[{nameof(RegisterNamedMessageHandler)}] Cannot register a named message of type null or empty!");
+                }
+                return;
+            }
             var hash32 = XXHash.Hash32(name);
             var hash64 = XXHash.Hash64(name);
 
@@ -215,6 +216,15 @@ namespace Unity.Netcode
         /// <param name="name">The name of the message.</param>
         public void UnregisterNamedMessageHandler(string name)
         {
+            if (string.IsNullOrEmpty(name))
+            {
+                if (m_NetworkManager.LogLevel <= LogLevel.Error)
+                {
+                    Debug.LogError($"[{nameof(UnregisterNamedMessageHandler)}] Cannot unregister a named message of type null or empty!");
+                }
+                return;
+            }
+
             var hash32 = XXHash.Hash32(name);
             var hash64 = XXHash.Hash64(name);
 

Runtime/Messaging/DeferredMessageManager.cs

@@ -15,6 +15,7 @@ namespace Unity.Netcode
         }
         protected struct TriggerInfo
         {
+            public string MessageType;
             public float Expiry;
             public NativeList<TriggerData> TriggerData;
         }
@@ -36,7 +37,7 @@ namespace Unity.Netcode
         /// There is a one second maximum lifetime of triggers to avoid memory leaks. After one second has passed
         /// without the requested object ID being spawned, the triggers for it are automatically deleted.
         /// </summary>
-        public virtual unsafe void DeferMessage(IDeferredNetworkMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context)
+        public virtual unsafe void DeferMessage(IDeferredNetworkMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context, string messageType)
         {
             if (!m_Triggers.TryGetValue(trigger, out var triggers))
             {
@@ -48,6 +49,7 @@ namespace Unity.Netcode
             {
                 triggerInfo = new TriggerInfo
                 {
+                    MessageType = messageType,
                     Expiry = m_NetworkManager.RealTimeProvider.RealTimeSinceStartup + m_NetworkManager.NetworkConfig.SpawnTimeout,
                     TriggerData = new NativeList<TriggerData>(Allocator.Persistent)
                 };
@@ -90,11 +92,29 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// Used for testing purposes
+        /// </summary>
+        internal static bool IncludeMessageType = true;
+
+        private string GetWarningMessage(IDeferredNetworkMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo, float spawnTimeout)
+        {
+            if (IncludeMessageType)
+            {
+                return $"[Deferred {triggerType}] Messages were received for a trigger of type {triggerInfo.MessageType} associated with id ({key}), but the {nameof(NetworkObject)} was not received within the timeout period {spawnTimeout} second(s).";
+            }
+            else
+            {
+                return $"Deferred messages were received for a trigger of type {triggerType} associated with id ({key}), but the {nameof(NetworkObject)} was not received within the timeout period {spawnTimeout} second(s).";
+            }
+        }
+
         protected virtual void PurgeTrigger(IDeferredNetworkMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo)
         {
-            if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+            var logLevel = m_NetworkManager.DistributedAuthorityMode ? LogLevel.Developer : LogLevel.Normal;
+            if (NetworkLog.CurrentLogLevel <= logLevel)
             {
-                NetworkLog.LogWarning($"Deferred messages were received for a trigger of type {triggerType} with key {key}, but that trigger was not received within within {m_NetworkManager.NetworkConfig.SpawnTimeout} second(s).");
+                NetworkLog.LogWarning(GetWarningMessage(triggerType, key, triggerInfo, m_NetworkManager.NetworkConfig.SpawnTimeout));
             }
 
             foreach (var data in triggerInfo.TriggerData)

Runtime/Messaging/IDeferredNetworkMessageManager.cs

@@ -1,3 +1,4 @@
+
 namespace Unity.Netcode
 {
     internal interface IDeferredNetworkMessageManager
@@ -17,7 +18,7 @@ namespace Unity.Netcode
         /// There is a one second maximum lifetime of triggers to avoid memory leaks. After one second has passed
         /// without the requested object ID being spawned, the triggers for it are automatically deleted.
         /// </summary>
-        void DeferMessage(TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context);
+        void DeferMessage(TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context, string messageType = null);
 
         /// <summary>
         /// Cleans up any trigger that's existed for more than a second.

Runtime/Messaging/Messages/ChangeOwnershipMessage.cs

@@ -1,3 +1,4 @@
+
 namespace Unity.Netcode
 {
     internal struct ChangeOwnershipMessage : INetworkMessage, INetworkSerializeByMemcpy
@@ -6,11 +7,146 @@ namespace Unity.Netcode
 
         public ulong NetworkObjectId;
         public ulong OwnerClientId;
+        // DANGOEXP TODO: Remove these notes or change their format
+        // SERVICE NOTES:
+        // When forwarding the message to clients on the CMB Service side,
+        // you can set the ClientIdCount to 0 and skip writing the ClientIds.
+        // See the NetworkObjet.OwnershipRequest for more potential service side additions
+
+        /// <summary>
+        /// When requesting, RequestClientId is the requestor.
+        /// When approving, RequestClientId is the owner that approved.
+        /// When responding (only for denied), RequestClientId is the requestor 
+        /// </summary>
+        internal ulong RequestClientId;
+        internal int ClientIdCount;
+        internal ulong[] ClientIds;
+        internal bool DistributedAuthorityMode;
+        internal ushort OwnershipFlags;
+        internal byte OwnershipRequestResponseStatus;
+        private byte m_OwnershipMessageTypeFlags;
+
+        private const byte k_OwnershipChanging = 0x01;
+        private const byte k_OwnershipFlagsUpdate = 0x02;
+        private const byte k_RequestOwnership = 0x04;
+        private const byte k_RequestApproved = 0x08;
+        private const byte k_RequestDenied = 0x10;
+
+        // If no flags are set, then ownership is changing
+        internal bool OwnershipIsChanging
+        {
+            get
+            {
+                return GetFlag(k_OwnershipChanging);
+            }
+
+            set
+            {
+                SetFlag(value, k_OwnershipChanging);
+            }
+        }
+
+        internal bool OwnershipFlagsUpdate
+        {
+            get
+            {
+                return GetFlag(k_OwnershipFlagsUpdate);
+            }
+
+            set
+            {
+                SetFlag(value, k_OwnershipFlagsUpdate);
+            }
+        }
+
+        internal bool RequestOwnership
+        {
+            get
+            {
+                return GetFlag(k_RequestOwnership);
+            }
+
+            set
+            {
+                SetFlag(value, k_RequestOwnership);
+            }
+        }
+
+        internal bool RequestApproved
+        {
+            get
+            {
+                return GetFlag(k_RequestApproved);
+            }
+
+            set
+            {
+                SetFlag(value, k_RequestApproved);
+            }
+        }
+
+        internal bool RequestDenied
+        {
+            get
+            {
+                return GetFlag(k_RequestDenied);
+            }
+
+            set
+            {
+                SetFlag(value, k_RequestDenied);
+            }
+        }
+
+        private bool GetFlag(int flag)
+        {
+            return (m_OwnershipMessageTypeFlags & flag) != 0;
+        }
+
+        private void SetFlag(bool set, byte flag)
+        {
+            if (set) { m_OwnershipMessageTypeFlags = (byte)(m_OwnershipMessageTypeFlags | flag); }
+            else { m_OwnershipMessageTypeFlags = (byte)(m_OwnershipMessageTypeFlags & ~flag); }
+        }
 
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
             BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
             BytePacker.WriteValueBitPacked(writer, OwnerClientId);
+            if (DistributedAuthorityMode)
+            {
+                BytePacker.WriteValueBitPacked(writer, ClientIdCount);
+                if (ClientIdCount > 0)
+                {
+                    if (ClientIdCount != ClientIds.Length)
+                    {
+                        throw new System.Exception($"[{nameof(ChangeOwnershipMessage)}] ClientIdCount is {ClientIdCount} but the ClientIds length is {ClientIds.Length}!");
+                    }
+                    foreach (var clientId in ClientIds)
+                    {
+                        BytePacker.WriteValueBitPacked(writer, clientId);
+                    }
+                }
+
+                writer.WriteValueSafe(m_OwnershipMessageTypeFlags);
+                if (OwnershipFlagsUpdate || OwnershipIsChanging)
+                {
+                    writer.WriteValueSafe(OwnershipFlags);
+                }
+
+                // When requesting, it is the requestor
+                // When approving, it is the owner that approved
+                // When denied, it is the requestor
+                if (RequestOwnership || RequestApproved || RequestDenied)
+                {
+                    writer.WriteValueSafe(RequestClientId);
+
+                    if (RequestDenied)
+                    {
+                        writer.WriteValueSafe(OwnershipRequestResponseStatus);
+                    }
+                }
+            }
         }
 
         public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
@@ -22,46 +158,241 @@ namespace Unity.Netcode
             }
             ByteUnpacker.ReadValueBitPacked(reader, out NetworkObjectId);
             ByteUnpacker.ReadValueBitPacked(reader, out OwnerClientId);
-            if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
+
+            if (networkManager.DistributedAuthorityMode)
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
-                return false;
+                ByteUnpacker.ReadValueBitPacked(reader, out ClientIdCount);
+                if (ClientIdCount > 0)
+                {
+                    ClientIds = new ulong[ClientIdCount];
+                    var clientId = (ulong)0;
+                    for (int i = 0; i < ClientIdCount; i++)
+                    {
+                        ByteUnpacker.ReadValueBitPacked(reader, out clientId);
+                        ClientIds[i] = clientId;
+                    }
+                }
+
+                reader.ReadValueSafe(out m_OwnershipMessageTypeFlags);
+                if (OwnershipFlagsUpdate || OwnershipIsChanging)
+                {
+                    reader.ReadValueSafe(out OwnershipFlags);
+                }
+
+                // When requesting, it is the requestor
+                // When approving, it is the owner that approved
+                // When denied, it is the requestor
+                if (RequestOwnership || RequestApproved || RequestDenied)
+                {
+                    reader.ReadValueSafe(out RequestClientId);
+
+                    if (RequestDenied)
+                    {
+                        reader.ReadValueSafe(out OwnershipRequestResponseStatus);
+                    }
+                }
             }
 
+            // If we are not a DAHost instance and the NetworkObject does not exist then defer it as it very likely is not spawned yet.
+            // Otherwise if we are the DAHost and it does not exist then we want to forward this message because when the NetworkObject
+            // is made visible again, the ownership flags and owner information will be synchronized with the DAHost by the current
+            // authority of the NetworkObject in question.
+            if (!networkManager.DAHost && !networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
+            {
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, GetType().Name);
+                return false;
+            }
             return true;
         }
 
         public void Handle(ref NetworkContext context)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
-            var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
-            var originalOwner = networkObject.OwnerClientId;
 
+            // If we are the DAHost then forward this message
+            if (networkManager.DAHost)
+            {
+                var clientList = ClientIdCount > 0 ? ClientIds : networkManager.ConnectedClientsIds;
+
+                var message = new ChangeOwnershipMessage()
+                {
+                    NetworkObjectId = NetworkObjectId,
+                    OwnerClientId = OwnerClientId,
+                    DistributedAuthorityMode = true,
+                    OwnershipFlags = OwnershipFlags,
+                    RequestClientId = RequestClientId,
+                    ClientIdCount = 0,
+                    m_OwnershipMessageTypeFlags = m_OwnershipMessageTypeFlags,
+                };
+
+                if (RequestDenied)
+                {
+                    // If the local DAHost's client is not the target, then forward to the target
+                    if (RequestClientId != networkManager.LocalClientId)
+                    {
+                        message.OwnershipRequestResponseStatus = OwnershipRequestResponseStatus;
+                        networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.Reliable, RequestClientId);
+                        // We don't want the local DAHost's client to process this message, so exit early
+                        return;
+                    }
+                }
+                else if (RequestOwnership)
+                {
+                    // If the DAHost client is not authority, just forward the message to the authority
+                    if (OwnerClientId != networkManager.LocalClientId)
+                    {
+                        networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.Reliable, OwnerClientId);
+                        // We don't want the local DAHost's client to process this message, so exit early
+                        return;
+                    }
+                    // Otherwise, fall through and process the request.
+                }
+                else
+                {
+                    foreach (var clientId in clientList)
+                    {
+                        if (clientId == networkManager.LocalClientId)
+                        {
+                            continue;
+                        }
+
+                        // If ownership is changing and this is not an ownership request approval then ignore the OnwerClientId
+                        // If it is just updating flags then ignore sending to the owner
+                        // If it is a request or approving request, then ignore the RequestClientId
+                        if ((OwnershipIsChanging && !RequestApproved && OwnerClientId == clientId) || (OwnershipFlagsUpdate && clientId == OwnerClientId)
+                            || ((RequestOwnership || RequestApproved) && clientId == RequestClientId))
+                        {
+                            continue;
+                        }
+
+                        networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.Reliable, clientId);
+                    }
+                }
+                // If the NetworkObject is not visible to the DAHost client, then exit early 
+                if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
+                {
+                    return;
+                }
+            }
+
+            // If ownership is changing, then run through the ownershipd changed sequence
+            // Note: There is some extended ownership script at the bottom of HandleOwnershipChange
+            // If not in distributed authority mode, then always go straight to HandleOwnershipChange
+            if (OwnershipIsChanging || !networkManager.DistributedAuthorityMode)
+            {
+                HandleOwnershipChange(ref context);
+            }
+            else if (networkManager.DistributedAuthorityMode)
+            {
+                // Otherwise, we handle and extended ownership update
+                HandleExtendedOwnershipUpdate(ref context);
+            }
+        }
+
+        /// <summary>
+        /// Handle the 
+        /// </summary>
+        /// <param name="context"></param>
+        private void HandleExtendedOwnershipUpdate(ref NetworkContext context)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+
+            // Handle the extended ownership message types
+            var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
+
+            if (OwnershipFlagsUpdate)
+            {
+                // Just update the ownership flags
+                networkObject.Ownership = (NetworkObject.OwnershipStatus)OwnershipFlags;
+            }
+            else if (RequestOwnership)
+            {
+                // Requesting ownership, if allowed it will automatically send the ownership change message
+                networkObject.OwnershipRequest(RequestClientId);
+            }
+            else if (RequestDenied)
+            {
+                networkObject.OwnershipRequestResponse((NetworkObject.OwnershipRequestResponseStatus)OwnershipRequestResponseStatus);
+            }
+        }
+
+        /// <summary>
+        /// Handle the traditional change in ownership message type logic
+        /// </summary>
+        /// <param name="context"></param>
+        private void HandleOwnershipChange(ref NetworkContext context)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
+
+            // DANGO-TODO: This probably shouldn't be allowed to happen.
+            if (networkObject.OwnerClientId == OwnerClientId)
+            {
+                UnityEngine.Debug.LogWarning($"Unnecessary ownership changed message for {NetworkObjectId}");
+            }
+
+            var originalOwner = networkObject.OwnerClientId;
             networkObject.OwnerClientId = OwnerClientId;
 
-            // We are current owner.
-            if (originalOwner == networkManager.LocalClientId)
+            if (networkManager.DistributedAuthorityMode)
+            {
+                networkObject.Ownership = (NetworkObject.OwnershipStatus)OwnershipFlags;
+            }
+
+            // We are current owner (client-server) or running in distributed authority mode
+            if (originalOwner == networkManager.LocalClientId || networkManager.DistributedAuthorityMode)
             {
                 networkObject.InvokeBehaviourOnLostOwnership();
             }
 
-            // We are new owner.
-            if (OwnerClientId == networkManager.LocalClientId)
+            // We are new owner or (client-server) or running in distributed authority mode
+            if (OwnerClientId == networkManager.LocalClientId || networkManager.DistributedAuthorityMode)
             {
                 networkObject.InvokeBehaviourOnGainedOwnership();
             }
 
-            // For all other clients that are neither the former or current owner, update the behaviours' properties
-            if (OwnerClientId != networkManager.LocalClientId && originalOwner != networkManager.LocalClientId)
+            // If in distributed authority mode 
+            if (networkManager.DistributedAuthorityMode)
             {
+                // Always update the network properties in distributed authority mode 
                 for (int i = 0; i < networkObject.ChildNetworkBehaviours.Count; i++)
                 {
                     networkObject.ChildNetworkBehaviours[i].UpdateNetworkProperties();
                 }
             }
+            else // Otherwise update properties like we would in client-server
+            {
+                // For all other clients that are neither the former or current owner, update the behaviours' properties
+                if (OwnerClientId != networkManager.LocalClientId && originalOwner != networkManager.LocalClientId)
+                {
+                    for (int i = 0; i < networkObject.ChildNetworkBehaviours.Count; i++)
+                    {
+                        networkObject.ChildNetworkBehaviours[i].UpdateNetworkProperties();
+                    }
+                }
+            }
 
+            // Always invoke ownership change notifications
             networkObject.InvokeOwnershipChanged(originalOwner, OwnerClientId);
 
+            // If this change was requested, then notify that the request was approved (doing this last so all ownership
+            // changes have already been applied if the callback is invoked)
+            if (networkManager.DistributedAuthorityMode && networkManager.LocalClientId == OwnerClientId)
+            {
+                if (RequestApproved)
+                {
+                    networkObject.OwnershipRequestResponse(NetworkObject.OwnershipRequestResponseStatus.Approved);
+                }
+
+                // If the NetworkObject changed ownership and the Requested flag was set (i.e. it was an ownership request),
+                // then the new owner granted ownership removes the Requested flag and sends out an ownership status update.
+                if (networkObject.HasExtendedOwnershipStatus(NetworkObject.OwnershipStatusExtended.Requested))
+                {
+                    networkObject.RemoveOwnershipExtended(NetworkObject.OwnershipStatusExtended.Requested);
+                    networkObject.SendOwnershipStatusUpdate();
+                }
+            }
+
             networkManager.NetworkMetrics.TrackOwnershipChangeReceived(context.SenderId, networkObject, context.MessageSize);
         }
     }

Runtime/Messaging/Messages/ClientConnectedMessage.cs

@@ -6,9 +6,13 @@ namespace Unity.Netcode
 
         public ulong ClientId;
 
+        public bool ShouldSynchronize;
+
+
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
             BytePacker.WriteValueBitPacked(writer, ClientId);
+            writer.WriteValueSafe(ShouldSynchronize);
         }
 
         public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
@@ -19,17 +23,44 @@ namespace Unity.Netcode
                 return false;
             }
             ByteUnpacker.ReadValueBitPacked(reader, out ClientId);
+            reader.ReadValueSafe(out ShouldSynchronize);
+
             return true;
         }
 
         public void Handle(ref NetworkContext context)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
-            networkManager.ConnectionManager.ConnectedClientIds.Add(ClientId);
+            if ((ShouldSynchronize || networkManager.CMBServiceConnection) && networkManager.DistributedAuthorityMode && networkManager.LocalClient.IsSessionOwner)
+            {
+                networkManager.SceneManager.SynchronizeNetworkObjects(ClientId);
+            }
+            else
+            {
+                // All modes support adding NetworkClients
+                networkManager.ConnectionManager.AddClient(ClientId);
+            }
+            if (!networkManager.ConnectionManager.ConnectedClientIds.Contains(ClientId))
+            {
+                networkManager.ConnectionManager.ConnectedClientIds.Add(ClientId);
+            }
             if (networkManager.IsConnectedClient)
             {
                 networkManager.ConnectionManager.InvokeOnPeerConnectedCallback(ClientId);
             }
+
+            // DANGO-TODO: Remove the session owner object distribution check once the service handles object distribution
+            if (networkManager.DistributedAuthorityMode && networkManager.CMBServiceConnection && !networkManager.NetworkConfig.EnableSceneManagement)
+            {
+                // Don't redistribute for the local instance
+                if (ClientId != networkManager.LocalClientId)
+                {
+                    // We defer redistribution to the end of the NetworkUpdateStage.PostLateUpdate
+                    networkManager.RedistributeToClient = true;
+                    networkManager.ClientToRedistribute = ClientId;
+                    networkManager.TickToRedistribute = networkManager.ServerTime.Tick + 20;
+                }
+            }
         }
     }
 }

Runtime/Messaging/Messages/ClientDisconnectedMessage.cs

@@ -25,6 +25,8 @@ namespace Unity.Netcode
         public void Handle(ref NetworkContext context)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
+            // All modes support removing NetworkClients
+            networkManager.ConnectionManager.RemoveClient(ClientId);
             networkManager.ConnectionManager.ConnectedClientIds.Remove(ClientId);
             if (networkManager.IsConnectedClient)
             {

Runtime/Messaging/Messages/ConnectionApprovedMessage.cs

@@ -10,6 +10,11 @@ namespace Unity.Netcode
 
         public ulong OwnerClientId;
         public int NetworkTick;
+        // The cloud state service should set this if we are restoring a session
+        public bool IsRestoredSession;
+        public ulong CurrentSessionOwner;
+        // Not serialized
+        public bool IsDistributedAuthority;
 
         // Not serialized, held as references to serialize NetworkVariable data
         public HashSet<NetworkObject> SpawnedObjectsList;
@@ -38,6 +43,11 @@ namespace Unity.Netcode
 
             BytePacker.WriteValueBitPacked(writer, OwnerClientId);
             BytePacker.WriteValueBitPacked(writer, NetworkTick);
+            if (IsDistributedAuthority)
+            {
+                writer.WriteValueSafe(IsRestoredSession);
+                BytePacker.WriteValueBitPacked(writer, CurrentSessionOwner);
+            }
 
             if (targetVersion >= k_VersionAddClientIds)
             {
@@ -59,7 +69,8 @@ namespace Unity.Netcode
                     if (sobj.SpawnWithObservers && (sobj.CheckObjectVisibility == null || sobj.CheckObjectVisibility(OwnerClientId)))
                     {
                         sobj.Observers.Add(OwnerClientId);
-                        var sceneObject = sobj.GetMessageSceneObject(OwnerClientId);
+                        // In distributed authority mode, we send the currently known observers of each NetworkObject to the client being synchronized.
+                        var sceneObject = sobj.GetMessageSceneObject(OwnerClientId, IsDistributedAuthority);
                         sceneObject.Serialize(writer);
                         ++sceneObjectCount;
                     }
@@ -114,6 +125,11 @@ namespace Unity.Netcode
 
             ByteUnpacker.ReadValueBitPacked(reader, out OwnerClientId);
             ByteUnpacker.ReadValueBitPacked(reader, out NetworkTick);
+            if (networkManager.DistributedAuthorityMode)
+            {
+                reader.ReadValueSafe(out IsRestoredSession);
+                ByteUnpacker.ReadValueBitPacked(reader, out CurrentSessionOwner);
+            }
 
             if (receivedMessageVersion >= k_VersionAddClientIds)
             {
@@ -131,10 +147,23 @@ namespace Unity.Netcode
         public void Handle(ref NetworkContext context)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
+            if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
+            {
+                NetworkLog.LogInfo($"[Client-{OwnerClientId}] Connection approved! Synchronizing...");
+            }
             networkManager.LocalClientId = OwnerClientId;
             networkManager.MessageManager.SetLocalClientId(networkManager.LocalClientId);
             networkManager.NetworkMetrics.SetConnectionId(networkManager.LocalClientId);
 
+            if (networkManager.DistributedAuthorityMode)
+            {
+                networkManager.SetSessionOwner(CurrentSessionOwner);
+                if (networkManager.LocalClient.IsSessionOwner && networkManager.NetworkConfig.EnableSceneManagement)
+                {
+                    networkManager.SceneManager.InitializeScenesLoaded();
+                }
+            }
+
             var time = new NetworkTime(networkManager.NetworkTickSystem.TickRate, NetworkTick);
             networkManager.NetworkTimeSystem.Reset(time.Time, 0.15f); // Start with a constant RTT of 150 until we receive values from the transport.
             networkManager.NetworkTickSystem.Reset(networkManager.NetworkTimeSystem.LocalTime, networkManager.NetworkTimeSystem.ServerTime);
@@ -148,13 +177,26 @@ namespace Unity.Netcode
             networkManager.ConnectionManager.ConnectedClientIds.Clear();
             foreach (var clientId in ConnectedClientIds)
             {
-                networkManager.ConnectionManager.ConnectedClientIds.Add(clientId);
+                if (!networkManager.ConnectionManager.ConnectedClientIds.Contains(clientId))
+                {
+                    networkManager.ConnectionManager.AddClient(clientId);
+                }
             }
 
             // Only if scene management is disabled do we handle NetworkObject synchronization at this point
             if (!networkManager.NetworkConfig.EnableSceneManagement)
             {
-                networkManager.SpawnManager.DestroySceneObjects();
+                // DANGO-TODO: This is a temporary fix for no DA CMB scene event handling.
+                // We will either use this same concept or provide some way for the CMB state plugin to handle it.
+                if (networkManager.DistributedAuthorityMode && networkManager.LocalClient.IsSessionOwner)
+                {
+                    networkManager.SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
+                }
+                else
+                {
+                    networkManager.SpawnManager.DestroySceneObjects();
+                }
+
                 m_ReceivedSceneObjectData.ReadValueSafe(out uint sceneObjectCount);
 
                 // Deserializing NetworkVariable data is deferred from Receive() to Handle to avoid needing
@@ -168,10 +210,38 @@ namespace Unity.Netcode
 
                 // Mark the client being connected
                 networkManager.IsConnectedClient = true;
+
+                if (networkManager.AutoSpawnPlayerPrefabClientSide)
+                {
+                    networkManager.ConnectionManager.CreateAndSpawnPlayer(OwnerClientId);
+                }
+
+                if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
+                {
+                    NetworkLog.LogInfo($"[Client-{OwnerClientId}][Scene Management Disabled] Synchronization complete!");
+                }
                 // When scene management is disabled we notify after everything is synchronized
                 networkManager.ConnectionManager.InvokeOnClientConnectedCallback(context.SenderId);
             }
+            else
+            {
+                if (networkManager.DistributedAuthorityMode && networkManager.CMBServiceConnection && networkManager.LocalClient.IsSessionOwner && networkManager.NetworkConfig.EnableSceneManagement)
+                {
+                    // Mark the client being connected
+                    networkManager.IsConnectedClient = true;
 
+                    // Spawn any in-scene placed NetworkObjects
+                    networkManager.SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
+
+                    // Spawn the local player of the session owner
+                    if (networkManager.AutoSpawnPlayerPrefabClientSide)
+                    {
+                        networkManager.ConnectionManager.CreateAndSpawnPlayer(OwnerClientId);
+                    }
+                    // Synchronize the service with the initial session owner's loaded scenes and spawned objects
+                    networkManager.SceneManager.SynchronizeNetworkObjects(NetworkManager.ServerClientId);
+                }
+            }
             ConnectedClientIds.Dispose();
         }
     }

Runtime/Messaging/Messages/ConnectionRequestMessage.cs

@@ -8,6 +8,10 @@ namespace Unity.Netcode
 
         public ulong ConfigHash;
 
+        public bool CMBServiceConnection;
+        public uint TickRate;
+        public bool EnableSceneManagement;
+
         public byte[] ConnectionData;
 
         public bool ShouldSendConnectionData;
@@ -30,6 +34,12 @@ namespace Unity.Netcode
             // END FORBIDDEN SEGMENT
             // ============================================================
 
+            if (CMBServiceConnection)
+            {
+                writer.WriteValueSafe(TickRate);
+                writer.WriteValueSafe(EnableSceneManagement);
+            }
+
             if (ShouldSendConnectionData)
             {
                 writer.WriteValueSafe(ConfigHash);
@@ -151,7 +161,7 @@ namespace Unity.Netcode
                 var response = new NetworkManager.ConnectionApprovalResponse
                 {
                     Approved = true,
-                    CreatePlayerObject = networkManager.NetworkConfig.PlayerPrefab != null
+                    CreatePlayerObject = networkManager.DistributedAuthorityMode && networkManager.AutoSpawnPlayerPrefabClientSide ? false : networkManager.NetworkConfig.PlayerPrefab != null
                 };
                 networkManager.ConnectionManager.HandleConnectionApproval(senderId, response);
             }

Runtime/Messaging/Messages/CreateObjectMessage.cs

@@ -1,4 +1,6 @@
+using System.Linq;
 using System.Runtime.CompilerServices;
+
 namespace Unity.Netcode
 {
     internal struct CreateObjectMessage : INetworkMessage
@@ -8,9 +10,109 @@ namespace Unity.Netcode
         public NetworkObject.SceneObject ObjectInfo;
         private FastBufferReader m_ReceivedNetworkVariableData;
 
+        // DA - NGO CMB SERVICE NOTES:
+        // The ObserverIds and ExistingObserverIds will only be populated if k_UpdateObservers is set
+        // ObserverIds is the full list of observers (see below)
+        internal ulong[] ObserverIds;
+
+        // While this does consume a bit more bandwidth, this is only sent by the authority/owner
+        // and can be used to determine which clients should receive the ObjectInfo serialized data.
+        // All other already existing observers just need to receive the NewObserverIds and the
+        // NetworkObjectId
+        internal ulong[] NewObserverIds;
+
+        // If !IncludesSerializedObject then the NetworkObjectId will be serialized.
+        // This happens when we are just sending an update to the observers list
+        // to clients that already have the NetworkObject spawned
+        internal ulong NetworkObjectId;
+
+        private const byte k_IncludesSerializedObject = 0x01;
+        private const byte k_UpdateObservers = 0x02;
+        private const byte k_UpdateNewObservers = 0x04;
+
+
+        private byte m_CreateObjectMessageTypeFlags;
+
+        internal bool IncludesSerializedObject
+        {
+            get
+            {
+                return GetFlag(k_IncludesSerializedObject);
+            }
+
+            set
+            {
+                SetFlag(value, k_IncludesSerializedObject);
+            }
+        }
+
+        internal bool UpdateObservers
+        {
+            get
+            {
+                return GetFlag(k_UpdateObservers);
+            }
+
+            set
+            {
+                SetFlag(value, k_UpdateObservers);
+            }
+        }
+
+        internal bool UpdateNewObservers
+        {
+            get
+            {
+                return GetFlag(k_UpdateNewObservers);
+            }
+
+            set
+            {
+                SetFlag(value, k_UpdateNewObservers);
+            }
+        }
+
+        private bool GetFlag(int flag)
+        {
+            return (m_CreateObjectMessageTypeFlags & flag) != 0;
+        }
+
+        private void SetFlag(bool set, byte flag)
+        {
+            if (set) { m_CreateObjectMessageTypeFlags = (byte)(m_CreateObjectMessageTypeFlags | flag); }
+            else { m_CreateObjectMessageTypeFlags = (byte)(m_CreateObjectMessageTypeFlags & ~flag); }
+        }
+
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
-            ObjectInfo.Serialize(writer);
+            writer.WriteValueSafe(m_CreateObjectMessageTypeFlags);
+
+            if (UpdateObservers)
+            {
+                BytePacker.WriteValuePacked(writer, ObserverIds.Length);
+                foreach (var clientId in ObserverIds)
+                {
+                    BytePacker.WriteValuePacked(writer, clientId);
+                }
+            }
+
+            if (UpdateNewObservers)
+            {
+                BytePacker.WriteValuePacked(writer, NewObserverIds.Length);
+                foreach (var clientId in NewObserverIds)
+                {
+                    BytePacker.WriteValuePacked(writer, clientId);
+                }
+            }
+
+            if (IncludesSerializedObject)
+            {
+                ObjectInfo.Serialize(writer);
+            }
+            else
+            {
+                BytePacker.WriteValuePacked(writer, NetworkObjectId);
+            }
         }
 
         public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
@@ -21,10 +123,45 @@ namespace Unity.Netcode
                 return false;
             }
 
-            ObjectInfo.Deserialize(reader);
+            reader.ReadValueSafe(out m_CreateObjectMessageTypeFlags);
+            if (UpdateObservers)
+            {
+                var length = 0;
+                ByteUnpacker.ReadValuePacked(reader, out length);
+                ObserverIds = new ulong[length];
+                var clientId = (ulong)0;
+                for (int i = 0; i < length; i++)
+                {
+                    ByteUnpacker.ReadValuePacked(reader, out clientId);
+                    ObserverIds[i] = clientId;
+                }
+            }
+
+            if (UpdateNewObservers)
+            {
+                var length = 0;
+                ByteUnpacker.ReadValuePacked(reader, out length);
+                NewObserverIds = new ulong[length];
+                var clientId = (ulong)0;
+                for (int i = 0; i < length; i++)
+                {
+                    ByteUnpacker.ReadValuePacked(reader, out clientId);
+                    NewObserverIds[i] = clientId;
+                }
+            }
+
+            if (IncludesSerializedObject)
+            {
+                ObjectInfo.Deserialize(reader);
+            }
+            else
+            {
+                ByteUnpacker.ReadValuePacked(reader, out NetworkObjectId);
+            }
+
             if (!networkManager.NetworkConfig.ForceSamePrefabs && !networkManager.SpawnManager.HasPrefab(ObjectInfo))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context, GetType().Name);
                 return false;
             }
             m_ReceivedNetworkVariableData = reader;
@@ -38,21 +175,130 @@ namespace Unity.Netcode
             // If a client receives a create object message and it is still synchronizing, then defer the object creation until it has finished synchronizing
             if (networkManager.SceneManager.ShouldDeferCreateObject())
             {
-                networkManager.SceneManager.DeferCreateObject(context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData);
+                networkManager.SceneManager.DeferCreateObject(context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData, ObserverIds, NewObserverIds);
             }
             else
             {
-                CreateObject(ref networkManager, context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData);
+                if (networkManager.DistributedAuthorityMode && !IncludesSerializedObject && UpdateObservers)
+                {
+                    ObjectInfo = new NetworkObject.SceneObject()
+                    {
+                        NetworkObjectId = NetworkObjectId,
+                    };
+                }
+                CreateObject(ref networkManager, context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData, ObserverIds, NewObserverIds);
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static void CreateObject(ref NetworkManager networkManager, ulong senderId, uint messageSize, NetworkObject.SceneObject sceneObject, FastBufferReader networkVariableData)
+        internal static void CreateObject(ref NetworkManager networkManager, ref NetworkSceneManager.DeferredObjectCreation deferredObjectCreation)
         {
+            var senderId = deferredObjectCreation.SenderId;
+            var observerIds = deferredObjectCreation.ObserverIds;
+            var newObserverIds = deferredObjectCreation.NewObserverIds;
+            var messageSize = deferredObjectCreation.MessageSize;
+            var sceneObject = deferredObjectCreation.SceneObject;
+            var networkVariableData = deferredObjectCreation.FastBufferReader;
+            CreateObject(ref networkManager, senderId, messageSize, sceneObject, networkVariableData, observerIds, newObserverIds);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static void CreateObject(ref NetworkManager networkManager, ulong senderId, uint messageSize, NetworkObject.SceneObject sceneObject, FastBufferReader networkVariableData, ulong[] observerIds, ulong[] newObserverIds)
+        {
+            var networkObject = (NetworkObject)null;
             try
             {
-                var networkObject = NetworkObject.AddSceneObject(sceneObject, networkVariableData, networkManager);
-                networkManager.NetworkMetrics.TrackObjectSpawnReceived(senderId, networkObject, messageSize);
+                if (!networkManager.DistributedAuthorityMode)
+                {
+                    networkObject = NetworkObject.AddSceneObject(sceneObject, networkVariableData, networkManager);
+                }
+                else
+                {
+                    var hasObserverIdList = observerIds != null && observerIds.Length > 0;
+                    var hasNewObserverIdList = newObserverIds != null && newObserverIds.Length > 0;
+                    // Depending upon visibility of the NetworkObject and the client in question, it could be that
+                    // this client already has visibility of this NetworkObject
+                    if (networkManager.SpawnManager.SpawnedObjects.ContainsKey(sceneObject.NetworkObjectId))
+                    {
+                        // If so, then just get the local instance
+                        networkObject = networkManager.SpawnManager.SpawnedObjects[sceneObject.NetworkObjectId];
+
+                        // This should not happen, logging error just in case
+                        if (hasNewObserverIdList && newObserverIds.Contains(networkManager.LocalClientId))
+                        {
+                            NetworkLog.LogErrorServer($"[{nameof(CreateObjectMessage)}][Duplicate-Broadcast] Detected duplicated object creation for {sceneObject.NetworkObjectId}!");
+                        }
+                        else // Trap to make sure the owner is not receiving any messages it sent
+                        if (networkManager.CMBServiceConnection && networkManager.LocalClientId == networkObject.OwnerClientId)
+                        {
+                            NetworkLog.LogWarning($"[{nameof(CreateObjectMessage)}][Client-{networkManager.LocalClientId}][Duplicate-CreateObjectMessage][Client Is Owner] Detected duplicated object creation for {networkObject.name}-{sceneObject.NetworkObjectId}!");
+                        }
+                    }
+                    else
+                    {
+                        networkObject = NetworkObject.AddSceneObject(sceneObject, networkVariableData, networkManager, true);
+                    }
+
+                    // DA - NGO CMB SERVICE NOTES:
+                    // It is possible for two clients to connect at the exact same time which, due to client-side spawning, can cause each client
+                    // to miss their spawns. For now, all player NetworkObject spawns will always be visible to all known connected clients
+                    var clientList = hasObserverIdList && !networkObject.IsPlayerObject ? observerIds : networkManager.ConnectedClientsIds;
+
+                    // Update the observers for this instance
+                    foreach (var clientId in clientList)
+                    {
+                        networkObject.Observers.Add(clientId);
+                    }
+
+                    // Mock CMB Service and forward to all clients
+                    if (networkManager.DAHost)
+                    {
+                        // 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 
+                        // 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.
+                        if (networkObject.IsPlayerObject && hasNewObserverIdList && clientList.Count != observerIds.Length)
+                        {
+                            // For same-frame newly spawned players that might not be aware of all other players, update the player's observer
+                            // list.
+                            observerIds = clientList.ToArray();
+                        }
+
+                        var createObjectMessage = new CreateObjectMessage()
+                        {
+                            ObjectInfo = sceneObject,
+                            m_ReceivedNetworkVariableData = networkVariableData,
+                            ObserverIds = hasObserverIdList ? observerIds : null,
+                            NetworkObjectId = networkObject.NetworkObjectId,
+                            IncludesSerializedObject = true,
+                        };
+                        foreach (var clientId in clientList)
+                        {
+                            // DA - NGO CMB SERVICE NOTES:
+                            // If the authority did not specify the list of clients and the client is not an observer or we are the owner/originator
+                            // or we are the DAHost, then we skip sending the message.
+                            if ((!hasObserverIdList && (!networkObject.Observers.Contains(clientId)) ||
+                                clientId == networkObject.OwnerClientId || clientId == NetworkManager.ServerClientId))
+                            {
+                                continue;
+                            }
+
+                            // DA - NGO CMB SERVICE NOTES:
+                            // If this included a list of new observers and the targeted clientId is one of the observers, then send the serialized data.
+                            // Otherwise, the targeted clientId has already has visibility (i.e. it is already spawned) and so just send the updated
+                            // observers list to that client's instance.
+                            createObjectMessage.IncludesSerializedObject = hasNewObserverIdList && newObserverIds.Contains(clientId);
+
+                            networkManager.SpawnManager.SendSpawnCallForObject(clientId, networkObject);
+                        }
+                    }
+                }
+                if (networkObject != null)
+                {
+                    networkManager.NetworkMetrics.TrackObjectSpawnReceived(senderId, networkObject, messageSize);
+                }
             }
             catch (System.Exception ex)
             {

Runtime/Messaging/Messages/DestroyObjectMessage.cs

@@ -1,3 +1,5 @@
+using System.Linq;
+
 namespace Unity.Netcode
 {
     internal struct DestroyObjectMessage : INetworkMessage, INetworkSerializeByMemcpy
@@ -6,10 +8,53 @@ namespace Unity.Netcode
 
         public ulong NetworkObjectId;
         public bool DestroyGameObject;
+        private byte m_DestroyFlags;
+
+        internal int DeferredDespawnTick;
+        // Temporary until we make this a list
+        internal ulong TargetClientId;
+
+        internal bool IsDistributedAuthority;
+
+        internal const byte ClientTargetedDestroy = 0x01;
+
+        internal bool IsTargetedDestroy
+        {
+            get
+            {
+                return GetFlag(ClientTargetedDestroy);
+            }
+
+            set
+            {
+                SetFlag(value, ClientTargetedDestroy);
+            }
+        }
+
+        private bool GetFlag(int flag)
+        {
+            return (m_DestroyFlags & flag) != 0;
+        }
+
+        private void SetFlag(bool set, byte flag)
+        {
+            if (set) { m_DestroyFlags = (byte)(m_DestroyFlags | flag); }
+            else { m_DestroyFlags = (byte)(m_DestroyFlags & ~flag); }
+        }
 
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
             BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
+            if (IsDistributedAuthority)
+            {
+                writer.WriteByteSafe(m_DestroyFlags);
+
+                if (IsTargetedDestroy)
+                {
+                    BytePacker.WriteValueBitPacked(writer, TargetClientId);
+                }
+                BytePacker.WriteValueBitPacked(writer, DeferredDespawnTick);
+            }
             writer.WriteValueSafe(DestroyGameObject);
         }
 
@@ -22,12 +67,25 @@ namespace Unity.Netcode
             }
 
             ByteUnpacker.ReadValueBitPacked(reader, out NetworkObjectId);
+            if (networkManager.DistributedAuthorityMode)
+            {
+                reader.ReadByteSafe(out m_DestroyFlags);
+                if (IsTargetedDestroy)
+                {
+                    ByteUnpacker.ReadValueBitPacked(reader, out TargetClientId);
+                }
+                ByteUnpacker.ReadValueBitPacked(reader, out DeferredDespawnTick);
+            }
+
             reader.ReadValueSafe(out DestroyGameObject);
 
             if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
-                return false;
+                // Client-Server mode we always defer where in distributed authority mode we only defer if it is not a targeted destroy
+                if (!networkManager.DistributedAuthorityMode || (networkManager.DistributedAuthorityMode && !IsTargetedDestroy))
+                {
+                    networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, GetType().Name);
+                }
             }
             return true;
         }
@@ -35,14 +93,80 @@ namespace Unity.Netcode
         public void Handle(ref NetworkContext context)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
-            if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
+
+            var networkObject = (NetworkObject)null;
+            if (!networkManager.DistributedAuthorityMode)
             {
-                // This is the same check and log message that happens inside OnDespawnObject, but we have to do it here
-                return;
+                // If this NetworkObject does not exist on this instance then exit early
+                if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out networkObject))
+                {
+                    return;
+                }
+            }
+            else
+            {
+                networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out networkObject);
+                if (!networkManager.DAHost && networkObject == null)
+                {
+                    // If this NetworkObject does not exist on this instance then exit early
+                    return;
+                }
+            }
+            // DANGO-TODO: This is just a quick way to foward despawn messages to the remaining clients
+            if (networkManager.DistributedAuthorityMode && networkManager.DAHost)
+            {
+                var message = new DestroyObjectMessage
+                {
+                    NetworkObjectId = NetworkObjectId,
+                    DestroyGameObject = DestroyGameObject,
+                    IsDistributedAuthority = true,
+                    IsTargetedDestroy = IsTargetedDestroy,
+                    TargetClientId = TargetClientId, // Just always populate this value whether we write it or not
+                    DeferredDespawnTick = DeferredDespawnTick,
+                };
+                var ownerClientId = networkObject == null ? context.SenderId : networkObject.OwnerClientId;
+                var clientIds = networkObject == null ? networkManager.ConnectedClientsIds.ToList() : networkObject.Observers.ToList();
+
+                foreach (var clientId in clientIds)
+                {
+                    if (clientId == networkManager.LocalClientId || clientId == ownerClientId)
+                    {
+                        continue;
+                    }
+                    networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientId);
+                }
             }
 
-            networkManager.NetworkMetrics.TrackObjectDestroyReceived(context.SenderId, networkObject, context.MessageSize);
-            networkManager.SpawnManager.OnDespawnObject(networkObject, DestroyGameObject);
+            // If we are deferring the despawn, then add it to the deferred despawn queue
+            if (networkManager.DistributedAuthorityMode)
+            {
+                if (DeferredDespawnTick > 0)
+                {
+                    // Clients always add it to the queue while DAHost will only add it to the queue if it is not a targeted destroy or it is and the target is the
+                    // DAHost client.
+                    if (!networkManager.DAHost || (networkManager.DAHost && (!IsTargetedDestroy || (IsTargetedDestroy && TargetClientId == 0))))
+                    {
+                        networkObject.DeferredDespawnTick = DeferredDespawnTick;
+                        var hasCallback = networkObject.OnDeferredDespawnComplete != null;
+                        networkManager.SpawnManager.DeferDespawnNetworkObject(NetworkObjectId, DeferredDespawnTick, hasCallback);
+                        return;
+                    }
+                }
+
+                // If this is targeted and we are not the target, then just update our local observers for this object
+                if (IsTargetedDestroy && TargetClientId != networkManager.LocalClientId && networkObject != null)
+                {
+                    networkObject.Observers.Remove(TargetClientId);
+                    return;
+                }
+            }
+
+            if (networkObject != null)
+            {
+                // Otherwise just despawn the NetworkObject right now
+                networkManager.SpawnManager.OnDespawnObject(networkObject, DestroyGameObject);
+                networkManager.NetworkMetrics.TrackObjectDestroyReceived(context.SenderId, networkObject, context.MessageSize);
+            }
         }
     }
 }

Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs

@@ -23,6 +23,8 @@ namespace Unity.Netcode
 
         private FastBufferReader m_ReceivedNetworkVariableData;
 
+        // DANGO-TODO: Made some modifications here that overlap/won't play nice with EnsureNetworkVariableLenghtSafety.
+        // Worth either merging or more cleanly separating these codepaths.
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
             if (!writer.TryBeginWrite(FastBufferWriter.GetWriteSize(NetworkObjectId) + FastBufferWriter.GetWriteSize(NetworkBehaviourIndex)))
@@ -30,15 +32,26 @@ namespace Unity.Netcode
                 throw new OverflowException($"Not enough space in the buffer to write {nameof(NetworkVariableDeltaMessage)}");
             }
 
+            var obj = NetworkBehaviour.NetworkObject;
+            var networkManager = obj.NetworkManagerOwner;
+
             BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
             BytePacker.WriteValueBitPacked(writer, NetworkBehaviourIndex);
+            if (networkManager.DistributedAuthorityMode)
+            {
+                writer.WriteValueSafe((ushort)NetworkBehaviour.NetworkVariableFields.Count);
+            }
 
             for (int i = 0; i < NetworkBehaviour.NetworkVariableFields.Count; i++)
             {
                 if (!DeliveryMappedNetworkVariableIndex.Contains(i))
                 {
                     // This var does not belong to the currently iterating delivery group.
-                    if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                    if (networkManager.DistributedAuthorityMode)
+                    {
+                        writer.WriteValueSafe<ushort>(0);
+                    }
+                    else if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                     {
                         BytePacker.WriteValueBitPacked(writer, (ushort)0);
                     }
@@ -54,7 +67,7 @@ namespace Unity.Netcode
                 var networkVariable = NetworkBehaviour.NetworkVariableFields[i];
                 var shouldWrite = networkVariable.IsDirty() &&
                     networkVariable.CanClientRead(TargetClientId) &&
-                    (NetworkBehaviour.NetworkManager.IsServer || networkVariable.CanClientWrite(NetworkBehaviour.NetworkManager.LocalClientId));
+                    (networkManager.IsServer || networkVariable.CanClientWrite(networkManager.LocalClientId));
 
                 // Prevent the server from writing to the client that owns a given NetworkVariable
                 // Allowing the write would send an old value to the client and cause jitter
@@ -67,14 +80,21 @@ namespace Unity.Netcode
                 // The object containing the behaviour we're about to process is about to be shown to this client
                 // As a result, the client will get the fully serialized NetworkVariable and would be confused by
                 // an extraneous delta
-                if (NetworkBehaviour.NetworkManager.SpawnManager.ObjectsToShowToClient.ContainsKey(TargetClientId) &&
-                    NetworkBehaviour.NetworkManager.SpawnManager.ObjectsToShowToClient[TargetClientId]
-                    .Contains(NetworkBehaviour.NetworkObject))
+                if (networkManager.SpawnManager.ObjectsToShowToClient.ContainsKey(TargetClientId) &&
+                    networkManager.SpawnManager.ObjectsToShowToClient[TargetClientId]
+                    .Contains(obj))
                 {
                     shouldWrite = false;
                 }
 
-                if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                if (networkManager.DistributedAuthorityMode)
+                {
+                    if (!shouldWrite)
+                    {
+                        writer.WriteValueSafe<ushort>(0);
+                    }
+                }
+                else if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                 {
                     if (!shouldWrite)
                     {
@@ -88,9 +108,9 @@ namespace Unity.Netcode
 
                 if (shouldWrite)
                 {
-                    if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                    if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                     {
-                        var tempWriter = new FastBufferWriter(NetworkBehaviour.NetworkManager.MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp, NetworkBehaviour.NetworkManager.MessageManager.FragmentedMessageMaxSize);
+                        var tempWriter = new FastBufferWriter(networkManager.MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp, networkManager.MessageManager.FragmentedMessageMaxSize);
                         NetworkBehaviour.NetworkVariableFields[i].WriteDelta(tempWriter);
                         BytePacker.WriteValueBitPacked(writer, tempWriter.Length);
 
@@ -103,11 +123,30 @@ namespace Unity.Netcode
                     }
                     else
                     {
-                        networkVariable.WriteDelta(writer);
+                        // DANGO-TODO:
+                        // Complex types with custom type serialization (either registered custom types or INetworkSerializable implementations) will be problematic
+                        // Non-complex types always provide a full state update per delta
+                        // DANGO-TODO: Add NetworkListEvent<T>.EventType awareness to the cloud-state server
+                        if (networkManager.DistributedAuthorityMode)
+                        {
+                            var size_marker = writer.Position;
+                            writer.WriteValueSafe<ushort>(0);
+                            var start_marker = writer.Position;
+                            networkVariable.WriteDelta(writer);
+                            var end_marker = writer.Position;
+                            writer.Seek(size_marker);
+                            var size = end_marker - start_marker;
+                            writer.WriteValueSafe((ushort)size);
+                            writer.Seek(end_marker);
+                        }
+                        else
+                        {
+                            networkVariable.WriteDelta(writer);
+                        }
                     }
-                    NetworkBehaviour.NetworkManager.NetworkMetrics.TrackNetworkVariableDeltaSent(
+                    networkManager.NetworkMetrics.TrackNetworkVariableDeltaSent(
                         TargetClientId,
-                        NetworkBehaviour.NetworkObject,
+                        obj,
                         networkVariable.Name,
                         NetworkBehaviour.__getTypeName(),
                         writer.Length - startingSize);
@@ -125,6 +164,8 @@ namespace Unity.Netcode
             return true;
         }
 
+        // DANGO-TODO: Made some modifications here that overlap/won't play nice with EnsureNetworkVariableLenghtSafety.
+        // Worth either merging or more cleanly separating these codepaths.
         public void Handle(ref NetworkContext context)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
@@ -142,10 +183,29 @@ namespace Unity.Netcode
                 }
                 else
                 {
+                    if (networkManager.DistributedAuthorityMode)
+                    {
+                        m_ReceivedNetworkVariableData.ReadValueSafe(out ushort variableCount);
+                        if (variableCount != networkBehaviour.NetworkVariableFields.Count)
+                        {
+                            UnityEngine.Debug.LogError("Variable count mismatch");
+                        }
+                    }
+
                     for (int i = 0; i < networkBehaviour.NetworkVariableFields.Count; i++)
                     {
                         int varSize = 0;
-                        if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                        if (networkManager.DistributedAuthorityMode)
+                        {
+                            m_ReceivedNetworkVariableData.ReadValueSafe(out ushort variableSize);
+                            varSize = variableSize;
+
+                            if (varSize == 0)
+                            {
+                                continue;
+                            }
+                        }
+                        else if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                         {
                             ByteUnpacker.ReadValueBitPacked(m_ReceivedNetworkVariableData, out varSize);
 
@@ -197,6 +257,7 @@ namespace Unity.Netcode
                         }
                         int readStartPos = m_ReceivedNetworkVariableData.Position;
 
+                        // Read Delta so we also notify any subscribers to a change in the NetworkVariable
                         networkVariable.ReadDelta(m_ReceivedNetworkVariableData, networkManager.IsServer);
 
                         networkManager.NetworkMetrics.TrackNetworkVariableDeltaReceived(
@@ -206,7 +267,7 @@ namespace Unity.Netcode
                             networkBehaviour.__getTypeName(),
                             context.MessageSize);
 
-                        if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                        if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety || networkManager.DistributedAuthorityMode)
                         {
                             if (m_ReceivedNetworkVariableData.Position > (readStartPos + varSize))
                             {
@@ -232,7 +293,10 @@ namespace Unity.Netcode
             }
             else
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, m_ReceivedNetworkVariableData, ref context);
+                // DANGO-TODO: Fix me!
+                // When a client-spawned NetworkObject is despawned by the owner client, the owner client will still get messages for deltas and cause this to
+                // log a warning. The issue is primarily how NetworkVariables handle updating and will require some additional re-factoring.
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, m_ReceivedNetworkVariableData, ref context, GetType().Name);
             }
         }
     }

Runtime/Messaging/Messages/ParentSyncMessage.cs

@@ -33,6 +33,12 @@ namespace Unity.Netcode
             set => ByteUtility.SetBit(ref m_BitField, 2, value);
         }
 
+        public bool AuthorityApplied
+        {
+            get => ByteUtility.GetBit(m_BitField, 3);
+            set => ByteUtility.SetBit(ref m_BitField, 3, value);
+        }
+
         // These additional properties are used to synchronize clients with the current position,
         // rotation, and scale after parenting/de-parenting (world/local space relative). This
         // allows users to control the final child's transform values without having to have a
@@ -83,9 +89,10 @@ namespace Unity.Netcode
             reader.ReadValueSafe(out Rotation);
             reader.ReadValueSafe(out Scale);
 
-            if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
+            // If the target NetworkObject does not exist =or= the target latest parent does not exist then defer the message
+            if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId) || (LatestParent.HasValue && !networkManager.SpawnManager.SpawnedObjects.ContainsKey(LatestParent.Value)))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, GetType().Name);
                 return false;
             }
             return true;
@@ -95,6 +102,16 @@ namespace Unity.Netcode
         {
             var networkManager = (NetworkManager)context.SystemOwner;
             var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
+
+            // For either DA or Client-Server modes, parenting is only valid if the parent was owned by a different authority (i.e. AuthorityApplied) or the sender is from the owner (DA mode)
+            // or the server (client-server mode).
+            networkObject.AuthorityAppliedParenting = AuthorityApplied || context.SenderId == networkObject.OwnerClientId || context.SenderId == NetworkManager.ServerClientId;
+            if (!networkObject.AuthorityAppliedParenting && networkManager.LogLevel <= LogLevel.Normal)
+            {
+                NetworkLog.LogWarningServer($"Client-{context.SenderId} sent a ParentSyncMessage but is not the authority of {networkObject.gameObject.name}'s {nameof(NetworkObject)} component!");
+                // DANGO-TODO: Still determining if we should not apply this change (I am leaning towards not allowing it).
+            }
+
             networkObject.SetNetworkParenting(LatestParent, WorldPositionStays);
             networkObject.ApplyNetworkParenting(RemoveParent);
 
@@ -111,6 +128,30 @@ namespace Unity.Netcode
                 networkObject.transform.rotation = Rotation;
             }
             networkObject.transform.localScale = Scale;
+
+            // If in distributed authority mode and we are running a DAHost and this is the DAHost, then forward the parent changed message to any remaining clients
+            if (networkManager.DistributedAuthorityMode && !networkManager.CMBServiceConnection && networkManager.DAHost)
+            {
+                var size = 0;
+                var message = this;
+
+                foreach (var client in networkManager.ConnectedClients)
+                {
+                    if (client.Value.ClientId == networkObject.OwnerClientId || client.Value.ClientId == networkManager.LocalClientId)
+                    {
+                        continue;
+                    }
+                    if (networkObject.IsNetworkVisibleTo(client.Value.ClientId))
+                    {
+                        size = networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, client.Value.ClientId);
+                        networkManager.NetworkMetrics.TrackOwnershipChangeSent(client.Key, networkObject, size);
+                    }
+                    else
+                    {
+                        Debug.Log($"[DAHost][ParentingProxy] Client-{client.Value.ClientId} has no visibility to {networkObject.name}!");
+                    }
+                }
+            }
         }
     }
 }

Runtime/Messaging/Messages/ProxyMessage.cs

@@ -31,11 +31,24 @@ namespace Unity.Netcode
 
         public unsafe void Handle(ref NetworkContext context)
         {
-
             var networkManager = (NetworkManager)context.SystemOwner;
             if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(WrappedMessage.Metadata.NetworkObjectId, out var networkObject))
             {
-                throw new InvalidOperationException($"An RPC called on a {nameof(NetworkObject)} that is not in the spawned objects list. Please make sure the {nameof(NetworkObject)} is spawned before calling RPCs.");
+                // With distributed authority mode, we can send Rpcs before we have been notified the NetworkObject is despawned.
+                // DANGO-TODO: Should the CMB Service cull out any Rpcs targeting recently despawned NetworkObjects?
+                // DANGO-TODO: This would require the service to keep track of despawned NetworkObjects since we re-use NetworkObject identifiers.
+                if (networkManager.DistributedAuthorityMode)
+                {
+                    if (networkManager.LogLevel == LogLevel.Developer)
+                    {
+                        NetworkLog.LogWarning($"[{WrappedMessage.Metadata.NetworkObjectId}, {WrappedMessage.Metadata.NetworkBehaviourId}, {WrappedMessage.Metadata.NetworkRpcMethodId}]An RPC called on a {nameof(NetworkObject)} that is not in the spawned objects list. Please make sure the {nameof(NetworkObject)} is spawned before calling RPCs.");
+                    }
+                    return;
+                }
+                else
+                {
+                    throw new InvalidOperationException($"[{WrappedMessage.Metadata.NetworkObjectId}, {WrappedMessage.Metadata.NetworkBehaviourId}, {WrappedMessage.Metadata.NetworkRpcMethodId}]An RPC called on a {nameof(NetworkObject)} that is not in the spawned objects list. Please make sure the {nameof(NetworkObject)} is spawned before calling RPCs.");
+                }
             }
 
             var observers = networkObject.Observers;

Runtime/Messaging/Messages/RpcMessages.cs

@@ -14,7 +14,7 @@ namespace Unity.Netcode
             writer.WriteBytesSafe(payload.GetUnsafePtr(), payload.Length);
         }
 
-        public static unsafe bool Deserialize(ref FastBufferReader reader, ref NetworkContext context, ref RpcMetadata metadata, ref FastBufferReader payload)
+        public static unsafe bool Deserialize(ref FastBufferReader reader, ref NetworkContext context, ref RpcMetadata metadata, ref FastBufferReader payload, string messageType)
         {
             ByteUnpacker.ReadValueBitPacked(reader, out metadata.NetworkObjectId);
             ByteUnpacker.ReadValueBitPacked(reader, out metadata.NetworkBehaviourId);
@@ -23,7 +23,7 @@ namespace Unity.Netcode
             var networkManager = (NetworkManager)context.SystemOwner;
             if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(metadata.NetworkObjectId))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, metadata.NetworkObjectId, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, metadata.NetworkObjectId, reader, ref context, messageType);
                 return false;
             }
 
@@ -52,7 +52,6 @@ namespace Unity.Netcode
                     reader.Length);
             }
 #endif
-
             return true;
         }
 
@@ -107,7 +106,7 @@ namespace Unity.Netcode
 
         public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
         {
-            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer);
+            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, GetType().Name);
         }
 
         public void Handle(ref NetworkContext context)
@@ -142,7 +141,7 @@ namespace Unity.Netcode
 
         public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
         {
-            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer);
+            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, GetType().Name);
         }
 
         public void Handle(ref NetworkContext context)
@@ -179,7 +178,8 @@ namespace Unity.Netcode
         public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
         {
             ByteUnpacker.ReadValuePacked(reader, out SenderClientId);
-            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer);
+
+            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, GetType().Name);
         }
 
         public void Handle(ref NetworkContext context)
@@ -197,4 +197,138 @@ namespace Unity.Netcode
             RpcMessageHelpers.Handle(ref context, ref Metadata, ref ReadBuffer, ref rpcParams);
         }
     }
+
+    // DANGO-EXP TODO: REMOVE THIS
+    internal struct ForwardServerRpcMessage : INetworkMessage
+    {
+        public int Version => 0;
+        public ulong OwnerId;
+        public NetworkDelivery NetworkDelivery;
+        public ServerRpcMessage ServerRpcMessage;
+
+        public unsafe void Serialize(FastBufferWriter writer, int targetVersion)
+        {
+            writer.WriteValueSafe(OwnerId);
+            writer.WriteValueSafe(NetworkDelivery);
+            ServerRpcMessage.Serialize(writer, targetVersion);
+        }
+
+        public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+        {
+            reader.ReadValueSafe(out OwnerId);
+            reader.ReadValueSafe(out NetworkDelivery);
+            ServerRpcMessage.ReadBuffer = new FastBufferReader(reader, Allocator.Persistent, reader.Length - reader.Position, sizeof(RpcMetadata));
+
+            // If deserializing failed or this message was deferred.
+            if (!ServerRpcMessage.Deserialize(reader, ref context, receivedMessageVersion))
+            {
+                // release this reader as the handler will either be invoked later (deferred) or will not be invoked at all.
+                ServerRpcMessage.ReadBuffer.Dispose();
+                return false;
+            }
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            if (networkManager.DAHost)
+            {
+                try
+                {
+                    // Since this is temporary, we will not be collection metrics for this.
+                    // DAHost just forwards the message to the owner
+                    ServerRpcMessage.WriteBuffer = new FastBufferWriter(ServerRpcMessage.ReadBuffer.Length, Allocator.TempJob);
+                    ServerRpcMessage.WriteBuffer.WriteBytesSafe(ServerRpcMessage.ReadBuffer.ToArray());
+                    networkManager.ConnectionManager.SendMessage(ref ServerRpcMessage, NetworkDelivery, OwnerId);
+                }
+                catch (Exception ex)
+                {
+                    Debug.LogException(ex);
+                }
+            }
+            else
+            {
+                NetworkLog.LogErrorServer($"Received {nameof(ForwardServerRpcMessage)} on client-{networkManager.LocalClientId}! Only DAHost may forward RPC messages!");
+            }
+            ServerRpcMessage.ReadBuffer.Dispose();
+            ServerRpcMessage.WriteBuffer.Dispose();
+        }
+
+    }
+
+    // DANGO-EXP TODO: REMOVE THIS
+    internal struct ForwardClientRpcMessage : INetworkMessage
+    {
+        public int Version => 0;
+        public bool BroadCast;
+        public ulong[] TargetClientIds;
+        public NetworkDelivery NetworkDelivery;
+        public ClientRpcMessage ClientRpcMessage;
+
+        public unsafe void Serialize(FastBufferWriter writer, int targetVersion)
+        {
+            if (TargetClientIds == null)
+            {
+                BroadCast = true;
+                writer.WriteValueSafe(BroadCast);
+            }
+            else
+            {
+                BroadCast = false;
+                writer.WriteValueSafe(BroadCast);
+                writer.WriteValueSafe(TargetClientIds);
+            }
+            writer.WriteValueSafe(NetworkDelivery);
+            ClientRpcMessage.Serialize(writer, targetVersion);
+        }
+
+        public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+        {
+            reader.ReadValueSafe(out BroadCast);
+
+            if (!BroadCast)
+            {
+                reader.ReadValueSafe(out TargetClientIds);
+            }
+
+            reader.ReadValueSafe(out NetworkDelivery);
+
+            ClientRpcMessage.ReadBuffer = new FastBufferReader(reader, Allocator.Persistent, reader.Length - reader.Position, sizeof(RpcMetadata));
+            // If deserializing failed or this message was deferred.
+            if (!ClientRpcMessage.Deserialize(reader, ref context, receivedMessageVersion))
+            {
+                // release this reader as the handler will either be invoked later (deferred) or will not be invoked at all.
+                ClientRpcMessage.ReadBuffer.Dispose();
+                return false;
+            }
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            if (networkManager.DAHost)
+            {
+                ClientRpcMessage.WriteBuffer = new FastBufferWriter(ClientRpcMessage.ReadBuffer.Length, Allocator.TempJob);
+                ClientRpcMessage.WriteBuffer.WriteBytesSafe(ClientRpcMessage.ReadBuffer.ToArray());
+                // Since this is temporary, we will not be collection metrics for this.
+                // DAHost just forwards the message to the clients
+                if (BroadCast)
+                {
+                    networkManager.ConnectionManager.SendMessage(ref ClientRpcMessage, NetworkDelivery, networkManager.ConnectedClientsIds);
+                }
+                else
+                {
+                    networkManager.ConnectionManager.SendMessage(ref ClientRpcMessage, NetworkDelivery, TargetClientIds);
+                }
+            }
+            else
+            {
+                NetworkLog.LogErrorServer($"Received {nameof(ForwardClientRpcMessage)} on client-{networkManager.LocalClientId}! Only DAHost may forward RPC messages!");
+            }
+            ClientRpcMessage.WriteBuffer.Dispose();
+            ClientRpcMessage.ReadBuffer.Dispose();
+        }
+    }
 }

Runtime/Messaging/Messages/SceneEventMessage.cs

@@ -1,3 +1,4 @@
+
 namespace Unity.Netcode
 {
     // Todo: Would be lovely to get this one nicely formatted with all the data it sends in the struct
@@ -8,6 +9,7 @@ namespace Unity.Netcode
 
         public SceneEventData EventData;
 
+
         private FastBufferReader m_ReceivedData;
 
         public void Serialize(FastBufferWriter writer, int targetVersion)
@@ -23,7 +25,8 @@ namespace Unity.Netcode
 
         public void Handle(ref NetworkContext context)
         {
-            ((NetworkManager)context.SystemOwner).SceneManager.HandleSceneEvent(context.SenderId, m_ReceivedData);
+            var networkManager = (NetworkManager)context.SystemOwner;
+            networkManager.SceneManager.HandleSceneEvent(context.SenderId, m_ReceivedData);
         }
     }
 }

Runtime/Messaging/Messages/ServerLogMessage.cs

@@ -4,6 +4,8 @@ namespace Unity.Netcode
     {
         public int Version => 0;
 
+        public ulong SenderId;
+
         public NetworkLog.LogType LogType;
         // It'd be lovely to be able to replace this with FixedString or NativeArray...
         // But it's not really practical. On the sending side, the user is likely to want
@@ -12,30 +14,39 @@ namespace Unity.Netcode
         // So an allocation is unavoidable here on both sides.
         public string Message;
 
-
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
             writer.WriteValueSafe(LogType);
             BytePacker.WriteValuePacked(writer, Message);
+            BytePacker.WriteValueBitPacked(writer, SenderId);
         }
 
         public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
-            if (networkManager.IsServer && networkManager.NetworkConfig.EnableNetworkLogs)
+
+            if ((networkManager.IsServer || networkManager.LocalClient.IsSessionOwner) && networkManager.NetworkConfig.EnableNetworkLogs)
             {
                 reader.ReadValueSafe(out LogType);
                 ByteUnpacker.ReadValuePacked(reader, out Message);
+                ByteUnpacker.ReadValuePacked(reader, out SenderId);
+                // If in distributed authority mode and the DAHost is not the session owner, then the DAHost will just forward the message.
+                if (networkManager.DAHost && networkManager.CurrentSessionOwner != networkManager.LocalClientId)
+                {
+                    var message = this;
+                    var size = networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, networkManager.CurrentSessionOwner);
+                    networkManager.NetworkMetrics.TrackServerLogSent(networkManager.CurrentSessionOwner, (uint)LogType, size);
+                    return false;
+                }
                 return true;
             }
-
             return false;
         }
 
         public void Handle(ref NetworkContext context)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
-            var senderId = context.SenderId;
+            var senderId = networkManager.DistributedAuthorityMode ? SenderId : context.SenderId;
 
             networkManager.NetworkMetrics.TrackServerLogReceived(senderId, (uint)LogType, context.MessageSize);
 

Runtime/Messaging/Messages/SessionOwnerMessage.cs

@@ -0,0 +1,26 @@
+namespace Unity.Netcode
+{
+    internal struct SessionOwnerMessage : INetworkMessage
+    {
+        public int Version => 0;
+
+        public ulong SessionOwner;
+
+        public void Serialize(FastBufferWriter writer, int targetVersion)
+        {
+            BytePacker.WriteValuePacked(writer, SessionOwner);
+        }
+
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+        {
+            ByteUnpacker.ReadValuePacked(reader, out SessionOwner);
+            return true;
+        }
+
+        public unsafe void Handle(ref NetworkContext context)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            networkManager.SetSessionOwner(SessionOwner);
+        }
+    }
+}

Runtime/Messaging/Messages/SessionOwnerMessage.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8e02985965397ab44809c99406914311
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Messaging/NetworkMessageManager.cs

@@ -167,6 +167,28 @@ namespace Unity.Netcode
                 {
                     RegisterMessageType(type);
                 }
+
+#if UNITY_EDITOR
+                if (EnableMessageOrderConsoleLog)
+                {
+                    // DANGO-TODO: Remove this when we have some form of message type indices stability in place
+                    // For now, just log the messages and their assigned types for reference purposes.
+                    var networkManager = m_Owner as NetworkManager;
+                    if (networkManager != null)
+                    {
+                        if (networkManager.DistributedAuthorityMode)
+                        {
+                            var messageListing = new StringBuilder();
+                            messageListing.AppendLine("NGO Message Index to Type Listing:");
+                            foreach (var message in m_MessageTypes)
+                            {
+                                messageListing.AppendLine($"[{message.Value}][{message.Key.Name}]");
+                            }
+                            Debug.Log(messageListing);
+                        }
+                    }
+                }
+#endif
             }
             catch (Exception)
             {
@@ -175,6 +197,8 @@ namespace Unity.Netcode
             }
         }
 
+        internal static bool EnableMessageOrderConsoleLog = false;
+
         public void Dispose()
         {
             if (m_Disposed)
@@ -823,7 +847,11 @@ namespace Unity.Netcode
         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()

Runtime/Messaging/RpcTargets/AuthorityRpcTarget.cs

@@ -0,0 +1,75 @@
+namespace Unity.Netcode
+{
+    internal class AuthorityRpcTarget : ServerRpcTarget
+    {
+        private ProxyRpcTarget m_AuthorityTarget;
+        private DirectSendRpcTarget m_DirectSendTarget;
+
+        public override void Dispose()
+        {
+            if (m_AuthorityTarget != null)
+            {
+                m_AuthorityTarget.Dispose();
+                m_AuthorityTarget = null;
+            }
+
+            if (m_DirectSendTarget != null)
+            {
+                m_DirectSendTarget.Dispose();
+                m_DirectSendTarget = null;
+            }
+
+            base.Dispose();
+        }
+
+        internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
+        {
+            if (behaviour.NetworkManager.DistributedAuthorityMode)
+            {
+                // If invoked locally, then send locally
+                if (behaviour.HasAuthority)
+                {
+                    if (m_UnderlyingTarget == null)
+                    {
+                        m_UnderlyingTarget = new LocalSendRpcTarget(m_NetworkManager);
+                    }
+                    m_UnderlyingTarget.Send(behaviour, ref message, delivery, rpcParams);
+                }
+                else if (behaviour.NetworkManager.DAHost)
+                {
+                    if (m_DirectSendTarget == null)
+                    {
+                        m_DirectSendTarget = new DirectSendRpcTarget(behaviour.OwnerClientId, m_NetworkManager);
+                    }
+                    else
+                    {
+                        m_DirectSendTarget.ClientId = behaviour.OwnerClientId;
+                    }
+                    m_DirectSendTarget.Send(behaviour, ref message, delivery, rpcParams);
+                }
+                else // Otherwise (for now), we always proxy the RPC messages to the owner
+                {
+                    if (m_AuthorityTarget == null)
+                    {
+                        m_AuthorityTarget = new ProxyRpcTarget(behaviour.OwnerClientId, m_NetworkManager);
+                    }
+                    else
+                    {
+                        // Since the owner can change, for now we will just clear and set the owner each time
+                        m_AuthorityTarget.SetClientId(behaviour.OwnerClientId);
+                    }
+                    m_AuthorityTarget.Send(behaviour, ref message, delivery, rpcParams);
+                }
+            }
+            else
+            {
+                // If we are not in distributed authority mode, then we invoke the normal ServerRpc code.
+                base.Send(behaviour, ref message, delivery, rpcParams);
+            }
+        }
+
+        internal AuthorityRpcTarget(NetworkManager manager) : base(manager)
+        {
+        }
+    }
+}

Runtime/Messaging/RpcTargets/AuthorityRpcTarget.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6b8f28b7a617fd34faee91e5f88e89ac
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs

@@ -36,7 +36,7 @@ namespace Unity.Netcode
                     MessageType = m_NetworkManager.MessageManager.GetMessageType(typeof(RpcMessage))
                 };
 
-                behaviour.NetworkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnNextFrame, 0, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnNextFrame, 0, reader, ref context);
                 length = reader.Length;
             }
             else
@@ -49,8 +49,8 @@ namespace Unity.Netcode
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
             {
-                behaviour.NetworkManager.NetworkMetrics.TrackRpcSent(
-                    behaviour.NetworkManager.LocalClientId,
+                networkManager.NetworkMetrics.TrackRpcSent(
+                    networkManager.LocalClientId,
                     behaviour.NetworkObject,
                     rpcMethodName,
                     behaviour.__getTypeName(),

Runtime/Messaging/RpcTargets/NotAuthorityRpcTarget.cs

@@ -0,0 +1,65 @@
+namespace Unity.Netcode
+{
+    internal class NotAuthorityRpcTarget : NotServerRpcTarget
+    {
+        internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
+        {
+            var networkObject = behaviour.NetworkObject;
+            if (m_NetworkManager.DistributedAuthorityMode)
+            {
+                if (m_GroupSendTarget == null)
+                {
+                    // When mocking the CMB service, we are running a server so create a non-proxy target group
+                    if (m_NetworkManager.DAHost)
+                    {
+                        m_GroupSendTarget = new RpcTargetGroup(m_NetworkManager);
+                    }
+                    else // Otherwise (for now), we always proxy the RPC messages
+                    {
+                        m_GroupSendTarget = new ProxyRpcTargetGroup(m_NetworkManager);
+                    }
+                }
+                m_GroupSendTarget.Clear();
+
+                if (behaviour.HasAuthority)
+                {
+                    foreach (var clientId in networkObject.Observers)
+                    {
+                        if (clientId == behaviour.OwnerClientId)
+                        {
+                            continue;
+                        }
+                        m_GroupSendTarget.Add(clientId);
+                    }
+                }
+                else
+                {
+                    foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
+                    {
+                        if (clientId == behaviour.OwnerClientId || !networkObject.Observers.Contains(clientId))
+                        {
+                            continue;
+                        }
+
+                        if (clientId == m_NetworkManager.LocalClientId)
+                        {
+                            m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+                            continue;
+                        }
+                        m_GroupSendTarget.Add(clientId);
+                    }
+                }
+
+                m_GroupSendTarget.Target.Send(behaviour, ref message, delivery, rpcParams);
+            }
+            else
+            {
+                base.Send(behaviour, ref message, delivery, rpcParams);
+            }
+        }
+
+        internal NotAuthorityRpcTarget(NetworkManager manager) : base(manager)
+        {
+        }
+    }
+}

Runtime/Messaging/RpcTargets/NotAuthorityRpcTarget.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4968ce7e70c277d4a892c1ed209ce4d6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Messaging/RpcTargets/NotMeRpcTarget.cs

@@ -49,11 +49,18 @@ namespace Unity.Netcode
                     {
                         continue;
                     }
+                    // In distributed authority mode, we send to target id 0 (which would be a DAHost) via the group
+                    if (clientId == NetworkManager.ServerClientId && !m_NetworkManager.DistributedAuthorityMode)
+                    {
+                        continue;
+                    }
                     m_GroupSendTarget.Add(clientId);
                 }
             }
             m_GroupSendTarget.Target.Send(behaviour, ref message, delivery, rpcParams);
-            if (!behaviour.IsServer)
+
+            // In distributed authority mode, we don't use ServerRpc
+            if (!behaviour.IsServer && !m_NetworkManager.DistributedAuthorityMode)
             {
                 m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
             }

Runtime/Messaging/RpcTargets/NotOwnerRpcTarget.cs

@@ -40,6 +40,10 @@ namespace Unity.Netcode
                     {
                         continue;
                     }
+                    if (clientId == NetworkManager.ServerClientId)
+                    {
+                        continue;
+                    }
                     if (clientId == behaviour.NetworkManager.LocalClientId)
                     {
                         m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
@@ -57,6 +61,10 @@ namespace Unity.Netcode
                     {
                         continue;
                     }
+                    if (clientId == NetworkManager.ServerClientId)
+                    {
+                        continue;
+                    }
                     if (clientId == behaviour.NetworkManager.LocalClientId)
                     {
                         m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);

Runtime/Messaging/RpcTargets/NotServerRpcTarget.cs

@@ -2,8 +2,8 @@ namespace Unity.Netcode
 {
     internal class NotServerRpcTarget : BaseRpcTarget
     {
-        private IGroupRpcTarget m_GroupSendTarget;
-        private LocalSendRpcTarget m_LocalSendRpcTarget;
+        protected IGroupRpcTarget m_GroupSendTarget;
+        protected LocalSendRpcTarget m_LocalSendRpcTarget;
 
         public override void Dispose()
         {

Runtime/Messaging/RpcTargets/RpcTarget.cs

@@ -62,6 +62,18 @@ namespace Unity.Netcode
         /// </summary>
         ClientsAndHost,
         /// <summary>
+        /// Send this RPC to the authority.
+        /// In distributed authority mode, this will be the owner of the NetworkObject.
+        /// In normal client-server mode, this is basically the exact same thing as a server rpc.
+        /// </summary>
+        Authority,
+        /// <summary>
+        /// Send this RPC to all non-authority instances.
+        /// In distributed authority mode, this will be the non-owners of the NetworkObject.
+        /// In normal client-server mode, this is basically the exact same thing as a client rpc.
+        /// </summary>
+        NotAuthority,
+        /// <summary>
         /// This RPC cannot be sent without passing in a target in RpcSendParams.
         /// </summary>
         SpecifiedInParams
@@ -100,7 +112,8 @@ namespace Unity.Netcode
             NotMe = new NotMeRpcTarget(manager);
             Me = new LocalSendRpcTarget(manager);
             ClientsAndHost = new ClientsAndHostRpcTarget(manager);
-
+            Authority = new AuthorityRpcTarget(manager);
+            NotAuthority = new NotAuthorityRpcTarget(manager);
             m_CachedProxyRpcTargetGroup = new ProxyRpcTargetGroup(manager);
             m_CachedTargetGroup = new RpcTargetGroup(manager);
             m_CachedDirectSendTarget = new DirectSendRpcTarget(manager);
@@ -122,7 +135,8 @@ namespace Unity.Netcode
             NotMe.Dispose();
             Me.Dispose();
             ClientsAndHost.Dispose();
-
+            Authority.Dispose();
+            NotAuthority.Dispose();
             m_CachedProxyRpcTargetGroup.Unlock();
             m_CachedTargetGroup.Unlock();
             m_CachedDirectSendTarget.Unlock();
@@ -134,7 +148,6 @@ namespace Unity.Netcode
             m_CachedProxyRpcTarget.Dispose();
         }
 
-
         /// <summary>
         /// Send to the NetworkObject's current owner.
         /// Will execute locally if the local process is the owner.
@@ -196,6 +209,20 @@ namespace Unity.Netcode
         /// </summary>
         public BaseRpcTarget ClientsAndHost;
 
+        /// <summary>
+        /// Send this RPC to the authority.
+        /// In distributed authority mode, this will be the owner of the NetworkObject.
+        /// In normal client-server mode, this is basically the exact same thing as a server rpc.
+        /// </summary>
+        public BaseRpcTarget Authority;
+
+        /// <summary>
+        /// Send this RPC to all non-authority instances.
+        /// In distributed authority mode, this will be the non-owners of the NetworkObject.
+        /// In normal client-server mode, this is basically the exact same thing as a client rpc.
+        /// </summary>
+        public BaseRpcTarget NotAuthority;
+
         /// <summary>
         /// Send to a specific single client ID.
         /// </summary>

Runtime/Messaging/RpcTargets/ServerRpcTarget.cs

@@ -2,7 +2,7 @@ namespace Unity.Netcode
 {
     internal class ServerRpcTarget : BaseRpcTarget
     {
-        private BaseRpcTarget m_UnderlyingTarget;
+        protected BaseRpcTarget m_UnderlyingTarget;
 
         public override void Dispose()
         {
@@ -15,6 +15,12 @@ namespace Unity.Netcode
 
         internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
         {
+            if (behaviour.NetworkManager.DistributedAuthorityMode && behaviour.NetworkManager.CMBServiceConnection)
+            {
+                UnityEngine.Debug.LogWarning("[Invalid Target] There is no server to send to when in Distributed Authority mode!");
+                return;
+            }
+
             if (m_UnderlyingTarget == null)
             {
                 if (behaviour.NetworkManager.IsServer)

Runtime/NetworkVariable/CollectionSerializationUtility.cs

@@ -0,0 +1,769 @@
+using System;
+using System.Collections.Generic;
+using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
+using Unity.Mathematics;
+
+namespace Unity.Netcode
+{
+    internal static class CollectionSerializationUtility
+    {
+        public static void WriteNativeArrayDelta<T>(FastBufferWriter writer, ref NativeArray<T> value, ref NativeArray<T> previousValue) where T : unmanaged
+        {
+            // This bit vector serializes the list of which fields have changed using 1 bit per field.
+            // This will always be 1 bit per field of the whole array (rounded up to the nearest 8 bits)
+            // even if there is only one change, so as compared to serializing the index with each item,
+            // this will use more bandwidth when the overall bandwidth usage is small and the array is large,
+            // but less when the overall bandwidth usage is large. So it optimizes for the worst case while accepting
+            // some reduction in efficiency in the best case.
+            using var changes = new ResizableBitVector(Allocator.Temp);
+            int minLength = math.min(value.Length, previousValue.Length);
+            var numChanges = 0;
+            // Iterate the array, checking which values have changed and marking that in the bit vector
+            for (var i = 0; i < minLength; ++i)
+            {
+                var val = value[i];
+                var prevVal = previousValue[i];
+                if (!NetworkVariableSerialization<T>.AreEqual(ref val, ref prevVal))
+                {
+                    ++numChanges;
+                    changes.Set(i);
+                }
+            }
+
+            // Mark any newly added items as well
+            // We don't need to mark removed items because they are captured by serializing the length
+            for (var i = previousValue.Length; i < value.Length; ++i)
+            {
+                ++numChanges;
+                changes.Set(i);
+            }
+
+            // If the size of serializing the dela is greater than the size of serializing the whole array (i.e.,
+            // because almost the entire array has changed and the overhead of the change set increases bandwidth),
+            // then we just do a normal full serialization instead of a delta.
+            if (changes.GetSerializedSize() + FastBufferWriter.GetWriteSize<T>() * numChanges > FastBufferWriter.GetWriteSize<T>() * value.Length)
+            {
+                // 1 = full serialization
+                writer.WriteByteSafe(1);
+                writer.WriteValueSafe(value);
+                return;
+            }
+            // 0 = delta serialization
+            writer.WriteByte(0);
+            // Write the length, which will be used on the read side to resize the array
+            BytePacker.WriteValuePacked(writer, value.Length);
+            writer.WriteValueSafe(changes);
+            unsafe
+            {
+                var ptr = (T*)value.GetUnsafePtr();
+                var prevPtr = (T*)previousValue.GetUnsafePtr();
+                for (int i = 0; i < value.Length; ++i)
+                {
+                    if (changes.IsSet(i))
+                    {
+                        if (i < previousValue.Length)
+                        {
+                            // If we have an item in the previous array for this index, we can do nested deltas!
+                            NetworkVariableSerialization<T>.WriteDelta(writer, ref ptr[i], ref prevPtr[i]);
+                        }
+                        else
+                        {
+                            // If not, just write it normally
+                            NetworkVariableSerialization<T>.Write(writer, ref ptr[i]);
+                        }
+                    }
+                }
+            }
+        }
+        public static void ReadNativeArrayDelta<T>(FastBufferReader reader, ref NativeArray<T> value) where T : unmanaged
+        {
+            // 1 = full serialization, 0 = delta serialization
+            reader.ReadByteSafe(out byte full);
+            if (full == 1)
+            {
+                // If we're doing full serialization, we fall back on reading the whole array.
+                value.Dispose();
+                reader.ReadValueSafe(out value, Allocator.Persistent);
+                return;
+            }
+            // If not, first read the length and the change bits
+            ByteUnpacker.ReadValuePacked(reader, out int length);
+            var changes = new ResizableBitVector(Allocator.Temp);
+            using var toDispose = changes;
+            {
+                reader.ReadNetworkSerializableInPlace(ref changes);
+
+                // If the length has changed, we need to resize.
+                // NativeArray is not resizeable, so we have to dispose and allocate a new one.
+                var previousLength = value.Length;
+                if (length != value.Length)
+                {
+                    var newArray = new NativeArray<T>(length, Allocator.Persistent);
+                    unsafe
+                    {
+                        UnsafeUtility.MemCpy(newArray.GetUnsafePtr(), value.GetUnsafePtr(), math.min(newArray.Length * sizeof(T), value.Length * sizeof(T)));
+                    }
+                    value.Dispose();
+                    value = newArray;
+                }
+
+                unsafe
+                {
+                    var ptr = (T*)value.GetUnsafePtr();
+                    for (var i = 0; i < value.Length; ++i)
+                    {
+                        if (changes.IsSet(i))
+                        {
+                            if (i < previousLength)
+                            {
+                                // If we have an item to read a delta into, read it as a delta
+                                NetworkVariableSerialization<T>.ReadDelta(reader, ref ptr[i]);
+                            }
+                            else
+                            {
+                                // If not, read as a standard element
+                                NetworkVariableSerialization<T>.Read(reader, ref ptr[i]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        public static void WriteListDelta<T>(FastBufferWriter writer, ref List<T> value, ref List<T> previousValue)
+        {
+            // Lists can be null, so we have to handle that case.
+            // We do that by marking this as a full serialization and using the existing null handling logic
+            // in NetworkVariableSerialization<List<T>>
+            if (value == null || previousValue == null)
+            {
+                writer.WriteByteSafe(1);
+                NetworkVariableSerialization<List<T>>.Write(writer, ref value);
+                return;
+            }
+            // This bit vector serializes the list of which fields have changed using 1 bit per field.
+            // This will always be 1 bit per field of the whole array (rounded up to the nearest 8 bits)
+            // even if there is only one change, so as compared to serializing the index with each item,
+            // this will use more bandwidth when the overall bandwidth usage is small and the array is large,
+            // but less when the overall bandwidth usage is large. So it optimizes for the worst case while accepting
+            // some reduction in efficiency in the best case.
+            using var changes = new ResizableBitVector(Allocator.Temp);
+            int minLength = math.min(value.Count, previousValue.Count);
+            var numChanges = 0;
+            // Iterate the list, checking which values have changed and marking that in the bit vector
+            for (var i = 0; i < minLength; ++i)
+            {
+                var val = value[i];
+                var prevVal = previousValue[i];
+                if (!NetworkVariableSerialization<T>.AreEqual(ref val, ref prevVal))
+                {
+                    ++numChanges;
+                    changes.Set(i);
+                }
+            }
+
+            // Mark any newly added items as well
+            // We don't need to mark removed items because they are captured by serializing the length
+            for (var i = previousValue.Count; i < value.Count; ++i)
+            {
+                ++numChanges;
+                changes.Set(i);
+            }
+
+            // If the size of serializing the dela is greater than the size of serializing the whole array (i.e.,
+            // because almost the entire array has changed and the overhead of the change set increases bandwidth),
+            // then we just do a normal full serialization instead of a delta.
+            // In the case of List<T>, it's difficult to know exactly what the serialized size is going to be before
+            // we serialize it, so we fudge it.
+            if (numChanges >= value.Count * 0.9)
+            {
+                // 1 = full serialization
+                writer.WriteByteSafe(1);
+                NetworkVariableSerialization<List<T>>.Write(writer, ref value);
+                return;
+            }
+
+            // 0 = delta serialization
+            writer.WriteByteSafe(0);
+            // Write the length, which will be used on the read side to resize the list
+            BytePacker.WriteValuePacked(writer, value.Count);
+            writer.WriteValueSafe(changes);
+            for (int i = 0; i < value.Count; ++i)
+            {
+                if (changes.IsSet(i))
+                {
+                    var reffable = value[i];
+                    if (i < previousValue.Count)
+                    {
+                        // If we have an item in the previous array for this index, we can do nested deltas!
+                        var prevReffable = previousValue[i];
+                        NetworkVariableSerialization<T>.WriteDelta(writer, ref reffable, ref prevReffable);
+                    }
+                    else
+                    {
+                        // If not, just write it normally.
+                        NetworkVariableSerialization<T>.Write(writer, ref reffable);
+                    }
+                }
+            }
+        }
+        public static void ReadListDelta<T>(FastBufferReader reader, ref List<T> value)
+        {
+            // 1 = full serialization, 0 = delta serialization
+            reader.ReadByteSafe(out byte full);
+            if (full == 1)
+            {
+                // If we're doing full serialization, we fall back on reading the whole list.
+                NetworkVariableSerialization<List<T>>.Read(reader, ref value);
+                return;
+            }
+            // If not, first read the length and the change bits
+            ByteUnpacker.ReadValuePacked(reader, out int length);
+            var changes = new ResizableBitVector(Allocator.Temp);
+            using var toDispose = changes;
+            {
+                reader.ReadNetworkSerializableInPlace(ref changes);
+
+                // If the list shrank, we need to resize it down.
+                // List<T> has no method to reserve space for future elements,
+                // so if we have to grow it, we just do that using Add() below.
+                if (length < value.Count)
+                {
+                    value.RemoveRange(length, value.Count - length);
+                }
+
+                for (var i = 0; i < length; ++i)
+                {
+                    if (changes.IsSet(i))
+                    {
+                        if (i < value.Count)
+                        {
+                            // If we have an item to read a delta into, read it as a delta
+                            T item = value[i];
+                            NetworkVariableSerialization<T>.ReadDelta(reader, ref item);
+                            value[i] = item;
+                        }
+                        else
+                        {
+                            // If not, just read it as a standard item.
+                            T item = default;
+                            NetworkVariableSerialization<T>.Read(reader, ref item);
+                            value.Add(item);
+                        }
+                    }
+                }
+            }
+        }
+
+        // For HashSet and Dictionary, we need to have some local space to hold lists we need to serialize.
+        // We don't want to do allocations all the time and we know each one needs a maximum of three lists,
+        // so we're going to keep static lists that we can reuse in these methods.
+        private static class ListCache<T>
+        {
+            private static List<T> s_AddedList = new List<T>();
+            private static List<T> s_RemovedList = new List<T>();
+            private static List<T> s_ChangedList = new List<T>();
+
+            public static List<T> GetAddedList()
+            {
+                s_AddedList.Clear();
+                return s_AddedList;
+            }
+            public static List<T> GetRemovedList()
+            {
+                s_RemovedList.Clear();
+                return s_RemovedList;
+            }
+            public static List<T> GetChangedList()
+            {
+                s_ChangedList.Clear();
+                return s_ChangedList;
+            }
+        }
+
+        public static void WriteHashSetDelta<T>(FastBufferWriter writer, ref HashSet<T> value, ref HashSet<T> previousValue) where T : IEquatable<T>
+        {
+            // HashSets can be null, so we have to handle that case.
+            // We do that by marking this as a full serialization and using the existing null handling logic
+            // in NetworkVariableSerialization<HashSet<T>>
+            if (value == null || previousValue == null)
+            {
+                writer.WriteByteSafe(1);
+                NetworkVariableSerialization<HashSet<T>>.Write(writer, ref value);
+                return;
+            }
+            // No changed array because a set can't have a "changed" element, only added and removed.
+            var added = ListCache<T>.GetAddedList();
+            var removed = ListCache<T>.GetRemovedList();
+            // collect the new elements
+            foreach (var item in value)
+            {
+                if (!previousValue.Contains(item))
+                {
+                    added.Add(item);
+                }
+            }
+
+            // collect the removed elements
+            foreach (var item in previousValue)
+            {
+                if (!value.Contains(item))
+                {
+                    removed.Add(item);
+                }
+            }
+
+            // If we've got more changes than total items, we just do a full serialization
+            if (added.Count + removed.Count >= value.Count)
+            {
+                writer.WriteByteSafe(1);
+                NetworkVariableSerialization<HashSet<T>>.Write(writer, ref value);
+                return;
+            }
+
+            writer.WriteByteSafe(0);
+            // Write out the added and removed arrays.
+            writer.WriteValueSafe(added.Count);
+            for (var i = 0; i < added.Count; ++i)
+            {
+                var item = added[i];
+                NetworkVariableSerialization<T>.Write(writer, ref item);
+            }
+            writer.WriteValueSafe(removed.Count);
+            for (var i = 0; i < removed.Count; ++i)
+            {
+                var item = removed[i];
+                NetworkVariableSerialization<T>.Write(writer, ref item);
+            }
+        }
+
+        public static void ReadHashSetDelta<T>(FastBufferReader reader, ref HashSet<T> value) where T : IEquatable<T>
+        {
+            // 1 = full serialization, 0 = delta serialization
+            reader.ReadByteSafe(out byte full);
+            if (full != 0)
+            {
+                NetworkVariableSerialization<HashSet<T>>.Read(reader, ref value);
+                return;
+            }
+            // Read in the added and removed values
+            reader.ReadValueSafe(out int addedCount);
+            for (var i = 0; i < addedCount; ++i)
+            {
+                T item = default;
+                NetworkVariableSerialization<T>.Read(reader, ref item);
+                value.Add(item);
+            }
+            reader.ReadValueSafe(out int removedCount);
+            for (var i = 0; i < removedCount; ++i)
+            {
+                T item = default;
+                NetworkVariableSerialization<T>.Read(reader, ref item);
+                value.Remove(item);
+            }
+        }
+        public static void WriteDictionaryDelta<TKey, TVal>(FastBufferWriter writer, ref Dictionary<TKey, TVal> value, ref Dictionary<TKey, TVal> previousValue)
+            where TKey : IEquatable<TKey>
+        {
+            if (value == null || previousValue == null)
+            {
+                writer.WriteByteSafe(1);
+                NetworkVariableSerialization<Dictionary<TKey, TVal>>.Write(writer, ref value);
+                return;
+            }
+            var added = ListCache<KeyValuePair<TKey, TVal>>.GetAddedList();
+            var changed = ListCache<KeyValuePair<TKey, TVal>>.GetRemovedList();
+            var removed = ListCache<KeyValuePair<TKey, TVal>>.GetChangedList();
+            // Collect items that have been added or have changed
+            foreach (var item in value)
+            {
+                var val = item.Value;
+                var hasPrevVal = previousValue.TryGetValue(item.Key, out var prevVal);
+                if (!hasPrevVal)
+                {
+                    added.Add(item);
+                }
+                else if (!NetworkVariableSerialization<TVal>.AreEqual(ref val, ref prevVal))
+                {
+                    changed.Add(item);
+                }
+            }
+
+            // collect the items that have been removed
+            foreach (var item in previousValue)
+            {
+                if (!value.ContainsKey(item.Key))
+                {
+                    removed.Add(item);
+                }
+            }
+
+            // If there are more changes than total values, just do a full serialization
+            if (added.Count + removed.Count + changed.Count >= value.Count)
+            {
+                writer.WriteByteSafe(1);
+                NetworkVariableSerialization<Dictionary<TKey, TVal>>.Write(writer, ref value);
+                return;
+            }
+
+            writer.WriteByteSafe(0);
+            // Else, write out the added, removed, and changed arrays
+            writer.WriteValueSafe(added.Count);
+            for (var i = 0; i < added.Count; ++i)
+            {
+                (var key, var val) = (added[i].Key, added[i].Value);
+                NetworkVariableSerialization<TKey>.Write(writer, ref key);
+                NetworkVariableSerialization<TVal>.Write(writer, ref val);
+            }
+            writer.WriteValueSafe(removed.Count);
+            for (var i = 0; i < removed.Count; ++i)
+            {
+                var key = removed[i].Key;
+                NetworkVariableSerialization<TKey>.Write(writer, ref key);
+            }
+            writer.WriteValueSafe(changed.Count);
+            for (var i = 0; i < changed.Count; ++i)
+            {
+                (var key, var val) = (changed[i].Key, changed[i].Value);
+                NetworkVariableSerialization<TKey>.Write(writer, ref key);
+                NetworkVariableSerialization<TVal>.Write(writer, ref val);
+            }
+        }
+
+        public static void ReadDictionaryDelta<TKey, TVal>(FastBufferReader reader, ref Dictionary<TKey, TVal> value)
+            where TKey : IEquatable<TKey>
+        {
+            // 1 = full serialization, 0 = delta serialization
+            reader.ReadByteSafe(out byte full);
+            if (full != 0)
+            {
+                NetworkVariableSerialization<Dictionary<TKey, TVal>>.Read(reader, ref value);
+                return;
+            }
+            // Added
+            reader.ReadValueSafe(out int length);
+            for (var i = 0; i < length; ++i)
+            {
+                (TKey key, TVal val) = (default, default);
+                NetworkVariableSerialization<TKey>.Read(reader, ref key);
+                NetworkVariableSerialization<TVal>.Read(reader, ref val);
+                value.Add(key, val);
+            }
+            // Removed
+            reader.ReadValueSafe(out length);
+            for (var i = 0; i < length; ++i)
+            {
+                TKey key = default;
+                NetworkVariableSerialization<TKey>.Read(reader, ref key);
+                value.Remove(key);
+            }
+            // Changed
+            reader.ReadValueSafe(out length);
+            for (var i = 0; i < length; ++i)
+            {
+                (TKey key, TVal val) = (default, default);
+                NetworkVariableSerialization<TKey>.Read(reader, ref key);
+                NetworkVariableSerialization<TVal>.Read(reader, ref val);
+                value[key] = val;
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        public static void WriteNativeListDelta<T>(FastBufferWriter writer, ref NativeList<T> value, ref NativeList<T> previousValue) where T : unmanaged
+        {
+            // See WriteListDelta and WriteNativeArrayDelta to understand most of this. It's basically the same,
+            // just adjusted for the NativeList API
+            using var changes = new ResizableBitVector(Allocator.Temp);
+            int minLength = math.min(value.Length, previousValue.Length);
+            var numChanges = 0;
+            for (var i = 0; i < minLength; ++i)
+            {
+                var val = value[i];
+                var prevVal = previousValue[i];
+                if (!NetworkVariableSerialization<T>.AreEqual(ref val, ref prevVal))
+                {
+                    ++numChanges;
+                    changes.Set(i);
+                }
+            }
+
+            for (var i = previousValue.Length; i < value.Length; ++i)
+            {
+                ++numChanges;
+                changes.Set(i);
+            }
+
+            if (changes.GetSerializedSize() + FastBufferWriter.GetWriteSize<T>() * numChanges > FastBufferWriter.GetWriteSize<T>() * value.Length)
+            {
+                writer.WriteByteSafe(1);
+                writer.WriteValueSafe(value);
+                return;
+            }
+
+            writer.WriteByte(0);
+            BytePacker.WriteValuePacked(writer, value.Length);
+            writer.WriteValueSafe(changes);
+            unsafe
+            {
+#if UTP_TRANSPORT_2_0_ABOVE
+                var ptr = value.GetUnsafePtr();
+                var prevPtr = previousValue.GetUnsafePtr();
+#else
+                var ptr = (T*)value.GetUnsafePtr();
+                var prevPtr = (T*)previousValue.GetUnsafePtr();
+#endif
+                for (int i = 0; i < value.Length; ++i)
+                {
+                    if (changes.IsSet(i))
+                    {
+                        if (i < previousValue.Length)
+                        {
+                            NetworkVariableSerialization<T>.WriteDelta(writer, ref ptr[i], ref prevPtr[i]);
+                        }
+                        else
+                        {
+                            NetworkVariableSerialization<T>.Write(writer, ref ptr[i]);
+                        }
+                    }
+                }
+            }
+        }
+        public static void ReadNativeListDelta<T>(FastBufferReader reader, ref NativeList<T> value) where T : unmanaged
+        {
+            // See ReadListDelta and ReadNativeArrayDelta to understand most of this. It's basically the same,
+            // just adjusted for the NativeList API
+            reader.ReadByteSafe(out byte full);
+            if (full == 1)
+            {
+                reader.ReadValueSafeInPlace(ref value);
+                return;
+            }
+            ByteUnpacker.ReadValuePacked(reader, out int length);
+            var changes = new ResizableBitVector(Allocator.Temp);
+            using var toDispose = changes;
+            {
+                reader.ReadNetworkSerializableInPlace(ref changes);
+
+                var previousLength = value.Length;
+                // The one big difference between this and NativeArray/List is that NativeList supports
+                // easy and fast resizing and reserving space.
+                if (length != value.Length)
+                {
+                    value.Resize(length, NativeArrayOptions.UninitializedMemory);
+                }
+
+                unsafe
+                {
+#if UTP_TRANSPORT_2_0_ABOVE
+                    var ptr = value.GetUnsafePtr();
+#else
+                    var ptr = (T*)value.GetUnsafePtr();
+#endif
+                    for (var i = 0; i < value.Length; ++i)
+                    {
+                        if (changes.IsSet(i))
+                        {
+                            if (i < previousLength)
+                            {
+                                NetworkVariableSerialization<T>.ReadDelta(reader, ref ptr[i]);
+                            }
+                            else
+                            {
+                                NetworkVariableSerialization<T>.Read(reader, ref ptr[i]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        public static unsafe void WriteNativeHashSetDelta<T>(FastBufferWriter writer, ref NativeHashSet<T> value, ref NativeHashSet<T> previousValue) where T : unmanaged, IEquatable<T>
+        {
+            // See WriteHashSet; this is the same algorithm, adjusted for the NativeHashSet API
+            var added = stackalloc T[value.Count];
+            var removed = stackalloc T[previousValue.Count];
+            var addedCount = 0;
+            var removedCount = 0;
+            foreach (var item in value)
+            {
+                if (!previousValue.Contains(item))
+                {
+                    added[addedCount] = item;
+                    ++addedCount;
+                }
+            }
+
+            foreach (var item in previousValue)
+            {
+                if (!value.Contains(item))
+                {
+                    removed[removedCount] = item;
+                    ++removedCount;
+                }
+            }
+#if UTP_TRANSPORT_2_0_ABOVE
+            if (addedCount + removedCount >= value.Count)
+#else
+            if (addedCount + removedCount >= value.Count())
+#endif
+            {
+                writer.WriteByteSafe(1);
+                writer.WriteValueSafe(value);
+                return;
+            }
+
+            writer.WriteByteSafe(0);
+            writer.WriteValueSafe(addedCount);
+            for (var i = 0; i < addedCount; ++i)
+            {
+                NetworkVariableSerialization<T>.Write(writer, ref added[i]);
+            }
+            writer.WriteValueSafe(removedCount);
+            for (var i = 0; i < removedCount; ++i)
+            {
+                NetworkVariableSerialization<T>.Write(writer, ref removed[i]);
+            }
+        }
+
+        public static void ReadNativeHashSetDelta<T>(FastBufferReader reader, ref NativeHashSet<T> value) where T : unmanaged, IEquatable<T>
+        {
+            // See ReadHashSet; this is the same algorithm, adjusted for the NativeHashSet API
+            reader.ReadByteSafe(out byte full);
+            if (full != 0)
+            {
+                reader.ReadValueSafeInPlace(ref value);
+                return;
+            }
+            reader.ReadValueSafe(out int addedCount);
+            for (var i = 0; i < addedCount; ++i)
+            {
+                T item = default;
+                NetworkVariableSerialization<T>.Read(reader, ref item);
+                value.Add(item);
+            }
+            reader.ReadValueSafe(out int removedCount);
+            for (var i = 0; i < removedCount; ++i)
+            {
+                T item = default;
+                NetworkVariableSerialization<T>.Read(reader, ref item);
+                value.Remove(item);
+            }
+        }
+
+        public static unsafe void WriteNativeHashMapDelta<TKey, TVal>(FastBufferWriter writer, ref NativeHashMap<TKey, TVal> value, ref NativeHashMap<TKey, TVal> previousValue)
+            where TKey : unmanaged, IEquatable<TKey>
+            where TVal : unmanaged
+        {
+            // See WriteDictionary; this is the same algorithm, adjusted for the NativeHashMap API
+#if UTP_TRANSPORT_2_0_ABOVE
+            var added = stackalloc KVPair<TKey, TVal>[value.Count];
+            var changed = stackalloc KVPair<TKey, TVal>[value.Count];
+            var removed = stackalloc KVPair<TKey, TVal>[previousValue.Count];
+#else
+            var added = stackalloc KeyValue<TKey, TVal>[value.Count()];
+            var changed = stackalloc KeyValue<TKey, TVal>[value.Count()];
+            var removed = stackalloc KeyValue<TKey, TVal>[previousValue.Count()];
+#endif
+            var addedCount = 0;
+            var changedCount = 0;
+            var removedCount = 0;
+            foreach (var item in value)
+            {
+
+                var hasPrevVal = previousValue.TryGetValue(item.Key, out var prevVal);
+                if (!hasPrevVal)
+                {
+                    added[addedCount] = item;
+                    ++addedCount;
+                }
+                else if (!NetworkVariableSerialization<TVal>.AreEqual(ref item.Value, ref prevVal))
+                {
+                    changed[changedCount] = item;
+                    ++changedCount;
+                }
+            }
+
+            foreach (var item in previousValue)
+            {
+                if (!value.ContainsKey(item.Key))
+                {
+                    removed[removedCount] = item;
+                    ++removedCount;
+                }
+            }
+
+#if UTP_TRANSPORT_2_0_ABOVE
+            if (addedCount + removedCount + changedCount >= value.Count)
+#else
+            if (addedCount + removedCount + changedCount >= value.Count())
+#endif
+            {
+                writer.WriteByteSafe(1);
+                writer.WriteValueSafe(value);
+                return;
+            }
+
+            writer.WriteByteSafe(0);
+            writer.WriteValueSafe(addedCount);
+            for (var i = 0; i < addedCount; ++i)
+            {
+                (var key, var val) = (added[i].Key, added[i].Value);
+                NetworkVariableSerialization<TKey>.Write(writer, ref key);
+                NetworkVariableSerialization<TVal>.Write(writer, ref val);
+            }
+            writer.WriteValueSafe(removedCount);
+            for (var i = 0; i < removedCount; ++i)
+            {
+                var key = removed[i].Key;
+                NetworkVariableSerialization<TKey>.Write(writer, ref key);
+            }
+            writer.WriteValueSafe(changedCount);
+            for (var i = 0; i < changedCount; ++i)
+            {
+                (var key, var val) = (changed[i].Key, changed[i].Value);
+                NetworkVariableSerialization<TKey>.Write(writer, ref key);
+                NetworkVariableSerialization<TVal>.Write(writer, ref val);
+            }
+        }
+
+        public static void ReadNativeHashMapDelta<TKey, TVal>(FastBufferReader reader, ref NativeHashMap<TKey, TVal> value)
+            where TKey : unmanaged, IEquatable<TKey>
+            where TVal : unmanaged
+        {
+            // See ReadDictionary; this is the same algorithm, adjusted for the NativeHashMap API
+            reader.ReadByteSafe(out byte full);
+            if (full != 0)
+            {
+                reader.ReadValueSafeInPlace(ref value);
+                return;
+            }
+            // Added
+            reader.ReadValueSafe(out int length);
+            for (var i = 0; i < length; ++i)
+            {
+                (TKey key, TVal val) = (default, default);
+                NetworkVariableSerialization<TKey>.Read(reader, ref key);
+                NetworkVariableSerialization<TVal>.Read(reader, ref val);
+                value.Add(key, val);
+            }
+            // Removed
+            reader.ReadValueSafe(out length);
+            for (var i = 0; i < length; ++i)
+            {
+                TKey key = default;
+                NetworkVariableSerialization<TKey>.Read(reader, ref key);
+                value.Remove(key);
+            }
+            // Changed
+            reader.ReadValueSafe(out length);
+            for (var i = 0; i < length; ++i)
+            {
+                (TKey key, TVal val) = (default, default);
+                NetworkVariableSerialization<TKey>.Read(reader, ref key);
+                NetworkVariableSerialization<TVal>.Read(reader, ref val);
+                value[key] = val;
+            }
+        }
+#endif
+    }
+}

Runtime/NetworkVariable/CollectionSerializationUtility.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c822ece4e24f4676861e07288a7f8526
+timeCreated: 1705437250

Runtime/NetworkVariable/Collections/NetworkList.cs

@@ -24,6 +24,7 @@ namespace Unity.Netcode
         /// The callback to be invoked when the list gets changed
         /// </summary>
         public event OnListChangedDelegate OnListChanged;
+        internal override NetworkVariableType Type => NetworkVariableType.NetworkList;
 
         /// <summary>
         /// Constructor method for <see cref="NetworkList"/>
@@ -98,7 +99,7 @@ namespace Unity.Netcode
                         break;
                     case NetworkListEvent<T>.EventType.Insert:
                         {
-                            writer.WriteValueSafe(element.Index);
+                            BytePacker.WriteValueBitPacked(writer, element.Index);
                             NetworkVariableSerialization<T>.Write(writer, ref element.Value);
                         }
                         break;
@@ -109,12 +110,12 @@ namespace Unity.Netcode
                         break;
                     case NetworkListEvent<T>.EventType.RemoveAt:
                         {
-                            writer.WriteValueSafe(element.Index);
+                            BytePacker.WriteValueBitPacked(writer, element.Index);
                         }
                         break;
                     case NetworkListEvent<T>.EventType.Value:
                         {
-                            writer.WriteValueSafe(element.Index);
+                            BytePacker.WriteValueBitPacked(writer, element.Index);
                             NetworkVariableSerialization<T>.Write(writer, ref element.Value);
                         }
                         break;
@@ -130,6 +131,20 @@ namespace Unity.Netcode
         /// <inheritdoc />
         public override void WriteField(FastBufferWriter writer)
         {
+            if (m_NetworkManager.DistributedAuthorityMode)
+            {
+                writer.WriteValueSafe(NetworkVariableSerialization<T>.Type);
+                if (NetworkVariableSerialization<T>.Type == CollectionItemType.Unmanaged)
+                {
+                    // Write the size of the unmanaged serialized type as it has a fixed size. This allows the CMB runtime to correctly read the unmanged type.
+                    var placeholder = new T();
+                    var startPos = writer.Position;
+                    NetworkVariableSerialization<T>.Write(writer, ref placeholder);
+                    var size = writer.Position - startPos;
+                    writer.Seek(startPos);
+                    BytePacker.WriteValueBitPacked(writer, size);
+                }
+            }
             writer.WriteValueSafe((ushort)m_List.Length);
             for (int i = 0; i < m_List.Length; i++)
             {
@@ -141,6 +156,15 @@ namespace Unity.Netcode
         public override void ReadField(FastBufferReader reader)
         {
             m_List.Clear();
+            if (m_NetworkManager.DistributedAuthorityMode)
+            {
+                // Collection item type is used by the CMB rust service, drop value here.
+                reader.ReadValueSafe(out CollectionItemType type);
+                if (type == CollectionItemType.Unmanaged)
+                {
+                    ByteUnpacker.ReadValueBitPacked(reader, out int _);
+                }
+            }
             reader.ReadValueSafe(out ushort count);
             for (int i = 0; i < count; i++)
             {
@@ -189,7 +213,7 @@ namespace Unity.Netcode
                         break;
                     case NetworkListEvent<T>.EventType.Insert:
                         {
-                            reader.ReadValueSafe(out int index);
+                            ByteUnpacker.ReadValueBitPacked(reader, out int index);
                             var value = new T();
                             NetworkVariableSerialization<T>.Read(reader, ref value);
 
@@ -261,7 +285,7 @@ namespace Unity.Netcode
                         break;
                     case NetworkListEvent<T>.EventType.RemoveAt:
                         {
-                            reader.ReadValueSafe(out int index);
+                            ByteUnpacker.ReadValueBitPacked(reader, out int index);
                             T value = m_List[index];
                             m_List.RemoveAt(index);
 
@@ -289,7 +313,7 @@ namespace Unity.Netcode
                         break;
                     case NetworkListEvent<T>.EventType.Value:
                         {
-                            reader.ReadValueSafe(out int index);
+                            ByteUnpacker.ReadValueBitPacked(reader, out int index);
                             var value = new T();
                             NetworkVariableSerialization<T>.Read(reader, ref value);
                             if (index >= m_List.Length)
@@ -367,7 +391,7 @@ namespace Unity.Netcode
         public void Add(T item)
         {
             // check write permissions
-            if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
+            if (!CanClientWrite(m_NetworkManager.LocalClientId))
             {
                 throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
             }
@@ -388,7 +412,7 @@ namespace Unity.Netcode
         public void Clear()
         {
             // check write permissions
-            if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
+            if (!CanClientWrite(m_NetworkManager.LocalClientId))
             {
                 throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
             }
@@ -414,7 +438,7 @@ namespace Unity.Netcode
         public bool Remove(T item)
         {
             // check write permissions
-            if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
+            if (!CanClientWrite(m_NetworkManager.LocalClientId))
             {
                 throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
             }
@@ -449,7 +473,7 @@ namespace Unity.Netcode
         public void Insert(int index, T item)
         {
             // check write permissions
-            if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
+            if (!CanClientWrite(m_NetworkManager.LocalClientId))
             {
                 throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
             }
@@ -478,7 +502,7 @@ namespace Unity.Netcode
         public void RemoveAt(int index)
         {
             // check write permissions
-            if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
+            if (!CanClientWrite(m_NetworkManager.LocalClientId))
             {
                 throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
             }
@@ -503,7 +527,7 @@ namespace Unity.Netcode
             set
             {
                 // check write permissions
-                if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
+                if (!CanClientWrite(m_NetworkManager.LocalClientId))
                 {
                     throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
                 }
@@ -551,6 +575,7 @@ namespace Unity.Netcode
         {
             m_List.Dispose();
             m_DirtyEvents.Dispose();
+            base.Dispose();
         }
     }
 

Runtime/NetworkVariable/NetworkVariable.cs

@@ -21,6 +21,7 @@ namespace Unity.Netcode
         /// The callback to be invoked when the value gets changed
         /// </summary>
         public OnValueChangedDelegate OnValueChanged;
+        internal override NetworkVariableType Type => NetworkVariableType.Value;
 
         /// <summary>
         /// Constructor for <see cref="NetworkVariable{T}"/>
@@ -43,6 +44,19 @@ namespace Unity.Netcode
             m_PreviousValue = default;
         }
 
+        /// <summary>
+        /// Resets the NetworkVariable when the associated NetworkObject is not spawned
+        /// </summary>
+        /// <param name="value">the value to reset the NetworkVariable to (if none specified it resets to the default)</param>
+        public void Reset(T value = default)
+        {
+            if (m_NetworkBehaviour == null || m_NetworkBehaviour != null && !m_NetworkBehaviour.NetworkObject.IsSpawned)
+            {
+                m_InternalValue = value;
+                m_PreviousValue = default;
+            }
+        }
+
         /// <summary>
         /// The internal value of the NetworkVariable
         /// </summary>
@@ -68,9 +82,9 @@ namespace Unity.Netcode
                     return;
                 }
 
-                if (m_NetworkBehaviour && !CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
+                if (m_NetworkManager && !CanClientWrite(m_NetworkManager.LocalClientId))
                 {
-                    throw new InvalidOperationException("Client is not allowed to write to this NetworkVariable");
+                    throw new InvalidOperationException($"[Client-{m_NetworkManager.LocalClientId}][{m_NetworkBehaviour.name}][{Name}] Write permissions ({WritePerm}) for this client instance is not allowed!");
                 }
 
                 Set(value);
@@ -104,6 +118,8 @@ namespace Unity.Netcode
             }
 
             m_PreviousValue = default;
+
+            base.Dispose();
         }
 
         ~NetworkVariable()
@@ -142,16 +158,16 @@ namespace Unity.Netcode
         /// </summary>
         public override void ResetDirty()
         {
-            base.ResetDirty();
             // Resetting the dirty value declares that the current value is not dirty
             // Therefore, we set the m_PreviousValue field to a duplicate of the current
             // field, so that our next dirty check is made against the current "not dirty"
             // value.
-            if (!m_HasPreviousValue || !NetworkVariableSerialization<T>.AreEqual(ref m_InternalValue, ref m_PreviousValue))
+            if (IsDirty())
             {
                 m_HasPreviousValue = true;
                 NetworkVariableSerialization<T>.Duplicate(m_InternalValue, ref m_PreviousValue);
             }
+            base.ResetDirty();
         }
 
         /// <summary>
@@ -173,7 +189,7 @@ namespace Unity.Netcode
         /// <param name="writer">The stream to write the value to</param>
         public override void WriteDelta(FastBufferWriter writer)
         {
-            WriteField(writer);
+            NetworkVariableSerialization<T>.WriteDelta(writer, ref m_InternalValue, ref m_PreviousValue);
         }
 
         /// <summary>
@@ -189,7 +205,7 @@ namespace Unity.Netcode
             // would be stored in different fields
 
             T previousValue = m_InternalValue;
-            NetworkVariableSerialization<T>.Read(reader, ref m_InternalValue);
+            NetworkVariableSerialization<T>.ReadDelta(reader, ref m_InternalValue);
 
             if (keepDirtyDelta)
             {

Runtime/NetworkVariable/NetworkVariableBase.cs

@@ -18,6 +18,22 @@ namespace Unity.Netcode
         /// </summary>
         private protected NetworkBehaviour m_NetworkBehaviour;
 
+        private NetworkManager m_InternalNetworkManager;
+
+        internal virtual NetworkVariableType Type => NetworkVariableType.Custom;
+
+        private protected NetworkManager m_NetworkManager
+        {
+            get
+            {
+                if (m_InternalNetworkManager == null && m_NetworkBehaviour && m_NetworkBehaviour.NetworkObject?.NetworkManager)
+                {
+                    m_InternalNetworkManager = m_NetworkBehaviour.NetworkObject?.NetworkManager;
+                }
+                return m_InternalNetworkManager;
+            }
+        }
+
         public NetworkBehaviour GetBehaviour()
         {
             return m_NetworkBehaviour;
@@ -29,7 +45,14 @@ namespace Unity.Netcode
         /// <param name="networkBehaviour">The NetworkBehaviour the NetworkVariable belongs to</param>
         public void Initialize(NetworkBehaviour networkBehaviour)
         {
+            m_InternalNetworkManager = null;
             m_NetworkBehaviour = networkBehaviour;
+            if (m_NetworkBehaviour && m_NetworkBehaviour.NetworkObject?.NetworkManager)
+            {
+                m_InternalNetworkManager = m_NetworkBehaviour.NetworkObject?.NetworkManager;
+                // When in distributed authority mode, there is no such thing as server write permissions
+                InternalWritePerm = m_InternalNetworkManager.DistributedAuthorityMode ? NetworkVariableWritePermission.Owner : InternalWritePerm;
+            }
         }
 
         /// <summary>
@@ -53,7 +76,7 @@ namespace Unity.Netcode
             NetworkVariableWritePermission writePerm = DefaultWritePerm)
         {
             ReadPerm = readPerm;
-            WritePerm = writePerm;
+            InternalWritePerm = writePerm;
         }
 
         /// <summary>
@@ -76,7 +99,17 @@ namespace Unity.Netcode
         /// <summary>
         /// The write permission for this var
         /// </summary>
-        public readonly NetworkVariableWritePermission WritePerm;
+        public NetworkVariableWritePermission WritePerm
+        {
+            get
+            {
+                return InternalWritePerm;
+            }
+        }
+
+        // We had to change the Write Permission in distributed authority.
+        // (It is too bad we initially declared it as readonly)
+        internal NetworkVariableWritePermission InternalWritePerm;
 
         /// <summary>
         /// Sets whether or not the variable needs to be delta synced
@@ -92,12 +125,17 @@ namespace Unity.Netcode
             }
         }
 
+        internal static bool IgnoreInitializeWarning;
+
         protected void MarkNetworkBehaviourDirty()
         {
             if (m_NetworkBehaviour == null)
             {
-                Debug.LogWarning($"NetworkVariable is written to, but doesn't know its NetworkBehaviour yet. " +
-                                 "Are you modifying a NetworkVariable before the NetworkObject is spawned?");
+                if (!IgnoreInitializeWarning)
+                {
+                    Debug.LogWarning($"NetworkVariable is written to, but doesn't know its NetworkBehaviour yet. " +
+                                     "Are you modifying a NetworkVariable before the NetworkObject is spawned?");
+                }
                 return;
             }
             if (m_NetworkBehaviour.NetworkManager.ShutdownInProgress)
@@ -109,7 +147,7 @@ namespace Unity.Netcode
                 }
                 return;
             }
-            m_NetworkBehaviour.NetworkManager.BehaviourUpdater.AddForUpdate(m_NetworkBehaviour.NetworkObject);
+            m_NetworkBehaviour.NetworkManager.BehaviourUpdater?.AddForUpdate(m_NetworkBehaviour.NetworkObject);
         }
 
         /// <summary>
@@ -136,6 +174,11 @@ namespace Unity.Netcode
         /// <returns>Whether or not the client has permission to read</returns>
         public bool CanClientRead(ulong clientId)
         {
+            // When in distributed authority mode, everyone can read (but only the owner can write)
+            if (m_NetworkManager != null && m_NetworkManager.DistributedAuthorityMode)
+            {
+                return true;
+            }
             switch (ReadPerm)
             {
                 default:
@@ -201,6 +244,50 @@ namespace Unity.Netcode
         /// </summary>
         public virtual void Dispose()
         {
+            m_InternalNetworkManager = null;
         }
     }
+
+    /// <summary>
+    /// Enum representing the different types of Network Variables.
+    /// </summary>
+    public enum NetworkVariableType : byte
+    {
+        /// <summary>
+        /// Value
+        /// Used for all of the basic NetworkVariables that contain a single value
+        /// </summary>
+        Value = 0,
+
+        /// <summary>
+        /// Custom
+        /// For any custom implemented extension of the NetworkVariableBase
+        /// </summary>
+        Custom = 1,
+
+        /// <summary>
+        /// NetworkList
+        /// </summary>
+        NetworkList = 2
+    }
+
+    public enum CollectionItemType : byte
+    {
+        /// <summary>
+        /// For any type that is not valid inside a NetworkVariable collection
+        /// </summary>
+        Unknown = 0,
+
+        /// <summary>
+        /// The following types are valid types inside of NetworkVariable collections
+        /// </summary>
+        Short = 1,
+        UShort = 2,
+        Int = 3,
+        UInt = 4,
+        Long = 5,
+        ULong = 6,
+        Unmanaged = 7,
+    }
+
 }

Runtime/NetworkVariable/ResizableBitVector.cs

@@ -0,0 +1,115 @@
+using System;
+using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// This is a simple resizable bit vector - i.e., a list of flags that use 1 bit each and can
+    /// grow to an indefinite size. This is backed by a NativeList&lt;byte&gt; instead of a single
+    /// integer value, allowing it to contain any size of memory. Contains built-in serialization support.
+    /// </summary>
+    internal struct ResizableBitVector : INetworkSerializable, IDisposable
+    {
+        private NativeList<byte> m_Bits;
+        private const int k_Divisor = sizeof(byte) * 8;
+
+        public ResizableBitVector(Allocator allocator)
+        {
+            m_Bits = new NativeList<byte>(allocator);
+        }
+
+        public void Dispose()
+        {
+            m_Bits.Dispose();
+        }
+
+        public int GetSerializedSize()
+        {
+            return sizeof(int) + m_Bits.Length;
+        }
+
+        private (int, int) GetBitData(int i)
+        {
+            var index = i / k_Divisor;
+            var bitWithinIndex = i % k_Divisor;
+            return (index, bitWithinIndex);
+        }
+
+        /// <summary>
+        /// Set bit 'i' - i.e., bit 0 is 00000001, bit 1 is 00000010, and so on.
+        /// There is no upper bound on i except for the memory available in the system.
+        /// </summary>
+        /// <param name="i"></param>
+        public void Set(int i)
+        {
+            var (index, bitWithinIndex) = GetBitData(i);
+            if (index >= m_Bits.Length)
+            {
+                m_Bits.Resize(index + 1, NativeArrayOptions.ClearMemory);
+            }
+
+            m_Bits[index] |= (byte)(1 << bitWithinIndex);
+        }
+
+        /// <summary>
+        /// Unset bit 'i' - i.e., bit 0 is 00000001, bit 1 is 00000010, and so on.
+        /// There is no upper bound on i except for the memory available in the system.
+        /// Note that once a BitVector has grown to a certain size, it will not shrink back down,
+        /// so if you set and unset every bit, it will still serialize at its high watermark size.
+        /// </summary>
+        /// <param name="i"></param>
+        public void Unset(int i)
+        {
+            var (index, bitWithinIndex) = GetBitData(i);
+            if (index >= m_Bits.Length)
+            {
+                return;
+            }
+
+            m_Bits[index] &= (byte)~(1 << bitWithinIndex);
+        }
+
+        /// <summary>
+        /// Check if bit 'i' is set - i.e., bit 0 is 00000001, bit 1 is 00000010, and so on.
+        /// There is no upper bound on i except for the memory available in the system.
+        /// </summary>
+        /// <param name="i"></param>
+        public bool IsSet(int i)
+        {
+            var (index, bitWithinIndex) = GetBitData(i);
+            if (index >= m_Bits.Length)
+            {
+                return false;
+            }
+
+            return (m_Bits[index] & (byte)(1 << bitWithinIndex)) != 0;
+        }
+
+        public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
+        {
+            var length = m_Bits.Length;
+            serializer.SerializeValue(ref length);
+            m_Bits.ResizeUninitialized(length);
+            var ptr = m_Bits.GetUnsafePtr();
+            {
+                if (serializer.IsReader)
+                {
+#if UTP_TRANSPORT_2_0_ABOVE
+                    serializer.GetFastBufferReader().ReadBytesSafe(ptr, length);
+#else
+                    serializer.GetFastBufferReader().ReadBytesSafe((byte*)ptr, length);
+#endif
+                }
+                else
+                {
+#if UTP_TRANSPORT_2_0_ABOVE
+                    serializer.GetFastBufferWriter().WriteBytesSafe(ptr, length);
+#else
+                    serializer.GetFastBufferWriter().WriteBytesSafe((byte*)ptr, length);
+#endif
+                }
+            }
+        }
+    }
+}

Runtime/NetworkVariable/ResizableBitVector.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 664696a622e244dfa43b26628c05e4a6
+timeCreated: 1705437231

Runtime/SceneManagement/DefaultSceneManagerHandler.cs

@@ -18,6 +18,7 @@ namespace Unity.Netcode
             public bool IsAssigned;
             public Scene Scene;
         }
+        public bool IsIntegrationTest() { return false; }
 
         internal Dictionary<string, Dictionary<int, SceneEntry>> SceneNameToSceneHandles = new Dictionary<string, Dictionary<int, SceneEntry>>();
 
@@ -327,8 +328,8 @@ namespace Unity.Netcode
         public void SetClientSynchronizationMode(ref NetworkManager networkManager, LoadSceneMode mode)
         {
             var sceneManager = networkManager.SceneManager;
-            // Don't let client's set this value
-            if (!networkManager.IsServer)
+            // Don't let non-authority set this value
+            if ((!networkManager.DistributedAuthorityMode && !networkManager.IsServer) || (networkManager.DistributedAuthorityMode && !networkManager.LocalClient.IsSessionOwner))
             {
                 if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                 {

Runtime/SceneManagement/ISceneManagerHandler.cs

@@ -32,5 +32,7 @@ namespace Unity.Netcode
         void SetClientSynchronizationMode(ref NetworkManager networkManager, LoadSceneMode mode);
 
         bool ClientShouldPassThrough(string sceneName, bool isPrimaryScene, LoadSceneMode clientSynchronizationMode, NetworkManager networkManager);
+
+        bool IsIntegrationTest();
     }
 }

Runtime/SceneManagement/SceneEventData.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text;
 using Unity.Collections;
 using UnityEngine.SceneManagement;
 
@@ -114,7 +115,10 @@ namespace Unity.Netcode
 
         /// Only used for <see cref="SceneEventType.Synchronize"/> scene events, this assures permissions when writing
         /// NetworkVariable information.  If that process changes, then we need to update this
+        /// In distributed authority mode this is used to route messages to the appropriate destination client
         internal ulong TargetClientId;
+        /// Only used with a DAHost
+        internal ulong SenderClientId;
 
         private Dictionary<uint, List<NetworkObject>> m_SceneNetworkObjects;
         private Dictionary<uint, long> m_SceneNetworkObjectDataOffsets;
@@ -243,8 +247,76 @@ namespace Unity.Netcode
             {
                 SceneHandlesToSynchronize.Clear();
             }
+            ForwardSynchronization = false;
         }
 
+        /// <summary>
+        /// Used with SortParentedNetworkObjects to sort the children of the root parent NetworkObject
+        /// </summary>
+        /// <param name="first">object to be sorted</param>
+        /// <param name="second">object to be compared to for sorting the first object</param>
+        /// <returns></returns>
+        private int SortChildrenNetworkObjects(NetworkObject first, NetworkObject second)
+        {
+            var firstParent = first.GetCachedParent()?.GetComponent<NetworkObject>();
+            // If the second is the first's parent then move the first down
+            if (firstParent != null && firstParent == second)
+            {
+                return 1;
+            }
+
+            var secondParent = second.GetCachedParent()?.GetComponent<NetworkObject>();
+            // If the first is the second's parent then move the first up
+            if (secondParent != null && secondParent == first)
+            {
+                return -1;
+            }
+
+            // Otherwise, don't move the first at all
+            return 0;
+        }
+
+        /// <summary>
+        /// Sorts the synchronization order of the NetworkObjects to be serialized
+        /// by parents before children order
+        /// </summary>
+        private void SortParentedNetworkObjects()
+        {
+            var networkObjectList = m_NetworkObjectsSync.ToList();
+            foreach (var networkObject in networkObjectList)
+            {
+                // Find only the root parent NetworkObjects
+                if (networkObject.transform.childCount > 0 && networkObject.transform.parent == null)
+                {
+                    // Get all child NetworkObjects of the root
+                    var childNetworkObjects = networkObject.GetComponentsInChildren<NetworkObject>().ToList();
+
+                    childNetworkObjects.Sort(SortChildrenNetworkObjects);
+
+                    // Remove the root from the children list
+                    childNetworkObjects.Remove(networkObject);
+
+                    // Remove the root's children from the primary list
+                    foreach (var childObject in childNetworkObjects)
+                    {
+                        m_NetworkObjectsSync.Remove(childObject);
+                    }
+                    // Insert or Add the sorted children list
+                    var nextIndex = m_NetworkObjectsSync.IndexOf(networkObject) + 1;
+                    if (nextIndex == m_NetworkObjectsSync.Count)
+                    {
+                        m_NetworkObjectsSync.AddRange(childNetworkObjects);
+                    }
+                    else
+                    {
+                        m_NetworkObjectsSync.InsertRange(nextIndex, childNetworkObjects);
+                    }
+                }
+            }
+        }
+
+        internal static bool LogSerializationOrder = false;
+
         internal void AddSpawnedNetworkObjects()
         {
             m_NetworkObjectsSync.Clear();
@@ -256,22 +328,22 @@ namespace Unity.Netcode
                 }
             }
 
-            // Sort by parents before children
-            m_NetworkObjectsSync.Sort(SortParentedNetworkObjects);
-
             // Sort by INetworkPrefabInstanceHandler implementation before the
             // NetworkObjects spawned by the implementation
             m_NetworkObjectsSync.Sort(SortNetworkObjects);
 
+            // The last thing we sort is parents before children
+            SortParentedNetworkObjects();
+
             // This is useful to know what NetworkObjects a client is going to be synchronized with
             // as well as the order in which they will be deserialized
-            if (m_NetworkManager.LogLevel == LogLevel.Developer)
+            if (LogSerializationOrder && m_NetworkManager.LogLevel == LogLevel.Developer)
             {
-                var messageBuilder = new System.Text.StringBuilder(0xFFFF);
-                messageBuilder.Append("[Server-Side Client-Synchronization] NetworkObject serialization order:");
+                var messageBuilder = new StringBuilder(0xFFFF);
+                messageBuilder.AppendLine("[Server-Side Client-Synchronization] NetworkObject serialization order:");
                 foreach (var networkObject in m_NetworkObjectsSync)
                 {
-                    messageBuilder.Append($"{networkObject.name}");
+                    messageBuilder.AppendLine($"{networkObject.name}");
                 }
                 NetworkLog.LogInfo(messageBuilder.ToString());
             }
@@ -362,31 +434,35 @@ namespace Unity.Netcode
             return 0;
         }
 
-        /// <summary>
-        /// Sorts the synchronization order of the NetworkObjects to be serialized
-        /// by parents before children.
-        /// </summary>
-        /// <remarks>
-        /// This only handles late joining players. Spawning and nesting several children
-        /// dynamically is still handled by the orphaned child list when deserialized out of
-        /// hierarchical order (i.e. Spawn parent and child dynamically, parent message is
-        /// dropped and re-sent but child object is received and processed)
-        /// </remarks>
-        private int SortParentedNetworkObjects(NetworkObject first, NetworkObject second)
+        internal bool EnableSerializationLogs = false;
+
+        private void LogArray(byte[] data, int start = 0, int stop = 0, StringBuilder builder = null)
         {
-            // If the first has a parent, move the first down
-            if (first.transform.parent != null)
+            var usingExternalBuilder = builder != null;
+            if (!usingExternalBuilder)
             {
-                return 1;
+                builder = new StringBuilder();
             }
-            else // If the second has a parent and the first does not, then move the first up
-            if (second.transform.parent != null)
+
+            if (stop == 0)
             {
-                return -1;
+                stop = data.Length;
+            }
+
+            builder.AppendLine($"[Start Data Dump][Start = {start}][Stop = {stop}] Size ({stop - start})");
+            for (int i = start; i < stop; i++)
+            {
+                builder.Append($"{data[i]:X2} ");
+            }
+            builder.Append("\n");
+
+            if (!usingExternalBuilder)
+            {
+                UnityEngine.Debug.Log(builder.ToString());
             }
-            return 0;
         }
 
+        internal bool ForwardSynchronization;
 
         /// <summary>
         /// Client and Server Side:
@@ -398,6 +474,12 @@ namespace Unity.Netcode
             // Write the scene event type
             writer.WriteValueSafe(SceneEventType);
 
+            if (m_NetworkManager.DistributedAuthorityMode)
+            {
+                BytePacker.WriteValueBitPacked(writer, TargetClientId);
+                BytePacker.WriteValueBitPacked(writer, SenderClientId);
+            }
+
             if (SceneEventType == SceneEventType.ActiveSceneChanged)
             {
                 writer.WriteValueSafe(ActiveSceneHash);
@@ -432,12 +514,25 @@ namespace Unity.Netcode
                 case SceneEventType.Synchronize:
                     {
                         writer.WriteValueSafe(ActiveSceneHash);
+
                         WriteSceneSynchronizationData(writer);
+
+                        if (EnableSerializationLogs)
+                        {
+                            LogArray(writer.ToArray(), 0, writer.Length);
+                        }
                         break;
                     }
                 case SceneEventType.Load:
                     {
-                        SerializeScenePlacedObjects(writer);
+                        if (m_NetworkManager.DistributedAuthorityMode && IsForwarding && m_NetworkManager.DAHost)
+                        {
+                            CopyInternalBuffer(ref writer);
+                        }
+                        else
+                        {
+                            SerializeScenePlacedObjects(writer);
+                        }
                         break;
                     }
                 case SceneEventType.SynchronizeComplete:
@@ -459,6 +554,11 @@ namespace Unity.Netcode
             }
         }
 
+        private unsafe void CopyInternalBuffer(ref FastBufferWriter writer)
+        {
+            writer.WriteBytesSafe(InternalBuffer.GetUnsafePtrAtCurrentPosition(), InternalBuffer.Length);
+        }
+
         /// <summary>
         /// Server Side:
         /// Called at the end of a <see cref="SceneEventType.Load"/> event once the scene is loaded and scene placed NetworkObjects
@@ -466,13 +566,29 @@ namespace Unity.Netcode
         /// </summary>
         internal void WriteSceneSynchronizationData(FastBufferWriter writer)
         {
+            var builder = (StringBuilder)null;
+            if (EnableSerializationLogs)
+            {
+                builder = new StringBuilder();
+                builder.AppendLine($"[Write][Synchronize-Start][WPos: {writer.Position}] Begin:");
+            }
             // Write the scenes we want to load, in the order we want to load them
             writer.WriteValueSafe(ScenesToSynchronize.ToArray());
             writer.WriteValueSafe(SceneHandlesToSynchronize.ToArray());
-
             // Store our current position in the stream to come back and say how much data we have written
             var positionStart = writer.Position;
 
+            if (m_NetworkManager.DistributedAuthorityMode && ForwardSynchronization && m_NetworkManager.DAHost)
+            {
+                writer.WriteValueSafe(m_InternalBufferSize);
+                CopyInternalBuffer(ref writer);
+                if (EnableSerializationLogs)
+                {
+                    LogArray(writer.ToArray(), positionStart);
+                }
+                return;
+            }
+
             // Size Place Holder -- Start
             // !!NOTE!!: Since this is a placeholder to be set after we know how much we have written,
             // for stream offset purposes this MUST not be a packed value!
@@ -481,15 +597,34 @@ namespace Unity.Netcode
 
             // Write the number of NetworkObjects we are serializing
             writer.WriteValueSafe(m_NetworkObjectsSync.Count);
+            if (EnableSerializationLogs)
+            {
+                builder.AppendLine($"[Synchronize Objects][positionStart: {positionStart}][WPos: {writer.Position}][NO-Count: {m_NetworkObjectsSync.Count}] Begin:");
+            }
+            var distributedAuthority = m_NetworkManager.DistributedAuthorityMode;
 
             // Serialize all NetworkObjects that are spawned
             for (var i = 0; i < m_NetworkObjectsSync.Count; ++i)
             {
+                var networkObject = m_NetworkObjectsSync[i];
                 var noStart = writer.Position;
-                var sceneObject = m_NetworkObjectsSync[i].GetMessageSceneObject(TargetClientId);
+                // In distributed authority mode, we send the currently known observers of each NetworkObject to the client being synchronized.
+                var sceneObject = m_NetworkObjectsSync[i].GetMessageSceneObject(TargetClientId, distributedAuthority);
+
                 sceneObject.Serialize(writer);
                 var noStop = writer.Position;
                 totalBytes += noStop - noStart;
+                if (EnableSerializationLogs)
+                {
+                    var offStart = noStart - (positionStart + sizeof(int));
+                    var offStop = noStop - (positionStart + sizeof(int));
+                    builder.AppendLine($"[Head: {offStart}][Tail: {offStop}][Size: {offStop - offStart}][{networkObject.name}][NID-{networkObject.NetworkObjectId}][Children: {networkObject.ChildNetworkBehaviours.Count}]");
+                    LogArray(writer.ToArray(), noStart, noStop, builder);
+                }
+            }
+            if (EnableSerializationLogs)
+            {
+                UnityEngine.Debug.Log(builder.ToString());
             }
 
             // Write the number of despawned in-scene placed NetworkObjects
@@ -511,6 +646,10 @@ namespace Unity.Netcode
             // Write the total size written to the stream by NetworkObjects being serialized
             writer.WriteValueSafe(bytesWritten);
             writer.Seek(positionEnd);
+            if (EnableSerializationLogs)
+            {
+                LogArray(writer.ToArray(), positionStart);
+            }
         }
 
         /// <summary>
@@ -526,6 +665,7 @@ namespace Unity.Netcode
 
             // Write our count place holder (must not be packed!)
             writer.WriteValueSafe((ushort)0);
+            var distributedAuthority = m_NetworkManager.DistributedAuthorityMode;
 
             foreach (var keyValuePairByGlobalObjectIdHash in m_NetworkManager.SceneManager.ScenePlacedObjects)
             {
@@ -534,7 +674,7 @@ namespace Unity.Netcode
                     if (keyValuePairBySceneHandle.Value.Observers.Contains(TargetClientId))
                     {
                         // Serialize the NetworkObject
-                        var sceneObject = keyValuePairBySceneHandle.Value.GetMessageSceneObject(TargetClientId);
+                        var sceneObject = keyValuePairBySceneHandle.Value.GetMessageSceneObject(TargetClientId, distributedAuthority);
                         sceneObject.Serialize(writer);
                         numberOfObjects++;
                     }
@@ -567,6 +707,12 @@ namespace Unity.Netcode
         internal void Deserialize(FastBufferReader reader)
         {
             reader.ReadValueSafe(out SceneEventType);
+            if (m_NetworkManager.DistributedAuthorityMode)
+            {
+                ByteUnpacker.ReadValueBitPacked(reader, out TargetClientId);
+                ByteUnpacker.ReadValueBitPacked(reader, out SenderClientId);
+            }
+
             if (SceneEventType == SceneEventType.ActiveSceneChanged)
             {
                 reader.ReadValueSafe(out ActiveSceneHash);
@@ -607,6 +753,10 @@ namespace Unity.Netcode
                 case SceneEventType.Synchronize:
                     {
                         reader.ReadValueSafe(out ActiveSceneHash);
+                        if (EnableSerializationLogs)
+                        {
+                            LogArray(reader.ToArray(), 0, reader.Length);
+                        }
                         CopySceneSynchronizationData(reader);
                         break;
                     }
@@ -641,6 +791,8 @@ namespace Unity.Netcode
             }
         }
 
+        private int m_InternalBufferSize;
+
         /// <summary>
         /// Client Side:
         /// Prepares for a scene synchronization event and copies the scene synchronization data
@@ -657,6 +809,8 @@ namespace Unity.Netcode
 
             // is not packed!
             reader.ReadValueSafe(out int sizeToCopy);
+            m_InternalBufferSize = sizeToCopy;
+
             unsafe
             {
                 if (!reader.TryBeginRead(sizeToCopy))
@@ -667,6 +821,10 @@ namespace Unity.Netcode
                 m_HasInternalBuffer = true;
                 // We use Allocator.Persistent since scene synchronization will most likely take longer than 4 frames
                 InternalBuffer = new FastBufferReader(reader.GetUnsafePtrAtCurrentPosition(), Allocator.Persistent, sizeToCopy);
+                if (EnableSerializationLogs)
+                {
+                    LogArray(InternalBuffer.ToArray());
+                }
             }
         }
 
@@ -916,12 +1074,24 @@ namespace Unity.Netcode
         /// <param name="networkManager"></param>
         internal void SynchronizeSceneNetworkObjects(NetworkManager networkManager)
         {
+            var builder = (StringBuilder)null;
+            if (EnableSerializationLogs)
+            {
+                builder = new StringBuilder();
+            }
+
             try
             {
                 // Process all spawned NetworkObjects for this network session
                 InternalBuffer.ReadValueSafe(out int newObjectsCount);
+                if (EnableSerializationLogs)
+                {
+                    builder.AppendLine($"[Read][Synchronize Objects][WPos: {InternalBuffer.Position}][NO-Count: {newObjectsCount}] Begin:");
+                }
+
                 for (int i = 0; i < newObjectsCount; i++)
                 {
+                    var noStart = InternalBuffer.Position;
                     var sceneObject = new NetworkObject.SceneObject();
                     sceneObject.Deserialize(InternalBuffer);
 
@@ -932,6 +1102,12 @@ namespace Unity.Netcode
                     }
                     var spawnedNetworkObject = NetworkObject.AddSceneObject(sceneObject, InternalBuffer, networkManager);
 
+                    var noStop = InternalBuffer.Position;
+                    if (EnableSerializationLogs)
+                    {
+                        builder.AppendLine($"[Head: {noStart}][Tail: {noStop}][Size: {noStop - noStart}][{spawnedNetworkObject.name}][NID-{spawnedNetworkObject.NetworkObjectId}][Children: {spawnedNetworkObject.ChildNetworkBehaviours.Count}]");
+                        LogArray(InternalBuffer.ToArray(), noStart, noStop, builder);
+                    }
                     // If we failed to deserialize the NetowrkObject then don't add null to the list
                     if (spawnedNetworkObject != null)
                     {
@@ -941,11 +1117,20 @@ namespace Unity.Netcode
                         }
                     }
                 }
+                if (EnableSerializationLogs)
+                {
+                    UnityEngine.Debug.Log(builder.ToString());
+                }
 
                 // Now deserialize the despawned in-scene placed NetworkObjects list (if any)
                 DeserializeDespawnedInScenePlacedNetworkObjects();
 
             }
+            catch (Exception ex)
+            {
+                UnityEngine.Debug.LogException(ex);
+                UnityEngine.Debug.Log(builder.ToString());
+            }
             finally
             {
                 InternalBuffer.Dispose();
@@ -999,24 +1184,38 @@ namespace Unity.Netcode
         /// Serialize scene handles and associated NetworkObjects that were migrated
         /// into a new scene.
         /// </summary>
+        internal bool IsForwarding;
+        private ulong m_OwnerId;
+
         private void SerializeObjectsMovedIntoNewScene(FastBufferWriter writer)
         {
             var sceneManager = m_NetworkManager.SceneManager;
+            var ownerId = m_NetworkManager.LocalClientId;
+            if (IsForwarding)
+            {
+                ownerId = m_OwnerId;
+            }
+
+            // Write the owner identifier
+            writer.WriteValueSafe(ownerId);
+
             // Write the number of scene handles
             writer.WriteValueSafe(sceneManager.ObjectsMigratedIntoNewScene.Count);
             foreach (var sceneHandleObjects in sceneManager.ObjectsMigratedIntoNewScene)
             {
+                if (!sceneManager.ObjectsMigratedIntoNewScene[sceneHandleObjects.Key].ContainsKey(ownerId))
+                {
+                    throw new Exception($"Trying to send object scene migration for Client-{ownerId} but the client has no entries to send!");
+                }
                 // Write the scene handle
                 writer.WriteValueSafe(sceneHandleObjects.Key);
                 // Write the number of NetworkObjectIds to expect
-                writer.WriteValueSafe(sceneHandleObjects.Value.Count);
-                foreach (var networkObject in sceneHandleObjects.Value)
+                writer.WriteValueSafe(sceneHandleObjects.Value[ownerId].Count);
+                foreach (var networkObject in sceneHandleObjects.Value[ownerId])
                 {
                     writer.WriteValueSafe(networkObject.NetworkObjectId);
                 }
             }
-            // Once we are done, clear the table
-            sceneManager.ObjectsMigratedIntoNewScene.Clear();
         }
 
         /// <summary>
@@ -1027,17 +1226,30 @@ namespace Unity.Netcode
         {
             var sceneManager = m_NetworkManager.SceneManager;
             var spawnManager = m_NetworkManager.SpawnManager;
-            // Just always assure this has no entries
-            sceneManager.ObjectsMigratedIntoNewScene.Clear();
+
             var numberOfScenes = 0;
             var sceneHandle = 0;
             var objectCount = 0;
             var networkObjectId = (ulong)0;
+
+            var ownerID = (ulong)0;
+            reader.ReadValueSafe(out ownerID);
+            m_OwnerId = ownerID;
             reader.ReadValueSafe(out numberOfScenes);
+
             for (int i = 0; i < numberOfScenes; i++)
             {
                 reader.ReadValueSafe(out sceneHandle);
-                sceneManager.ObjectsMigratedIntoNewScene.Add(sceneHandle, new List<NetworkObject>());
+                if (!sceneManager.ObjectsMigratedIntoNewScene.ContainsKey(sceneHandle))
+                {
+                    sceneManager.ObjectsMigratedIntoNewScene.Add(sceneHandle, new Dictionary<ulong, List<NetworkObject>>());
+                }
+
+                if (!sceneManager.ObjectsMigratedIntoNewScene[sceneHandle].ContainsKey(ownerID))
+                {
+                    sceneManager.ObjectsMigratedIntoNewScene[sceneHandle].Add(ownerID, new List<NetworkObject>());
+                }
+
                 reader.ReadValueSafe(out objectCount);
                 for (int j = 0; j < objectCount; j++)
                 {
@@ -1047,9 +1259,9 @@ namespace Unity.Netcode
                         NetworkLog.LogError($"[Object Scene Migration] Trying to synchronize NetworkObjectId ({networkObjectId}) but it was not spawned or no longer exists!!");
                         continue;
                     }
+                    var networkObject = spawnManager.SpawnedObjects[networkObjectId];
                     // Add NetworkObject scene migration to ObjectsMigratedIntoNewScene dictionary that is processed
-                    //
-                    sceneManager.ObjectsMigratedIntoNewScene[sceneHandle].Add(spawnManager.SpawnedObjects[networkObjectId]);
+                    sceneManager.ObjectsMigratedIntoNewScene[sceneHandle][ownerID].Add(networkObject);
                 }
             }
         }
@@ -1065,16 +1277,22 @@ namespace Unity.Netcode
         {
             var sceneManager = m_NetworkManager.SceneManager;
             var spawnManager = m_NetworkManager.SpawnManager;
+            var ownerId = (ulong)0;
             var numberOfScenes = 0;
             var sceneHandle = 0;
             var objectCount = 0;
             var networkObjectId = (ulong)0;
 
+            reader.ReadValueSafe(out ownerId);
+
+
             var deferredObjectsMovedEvent = new NetworkSceneManager.DeferredObjectsMovedEvent()
             {
-                ObjectsMigratedTable = new Dictionary<int, List<ulong>>()
+                OwnerId = ownerId,
+                ObjectsMigratedTable = new Dictionary<int, List<ulong>>(),
             };
 
+
             reader.ReadValueSafe(out numberOfScenes);
             for (int i = 0; i < numberOfScenes; i++)
             {
@@ -1104,8 +1322,13 @@ namespace Unity.Netcode
                 {
                     if (!sceneManager.ObjectsMigratedIntoNewScene.ContainsKey(keyEntry.Key))
                     {
-                        sceneManager.ObjectsMigratedIntoNewScene.Add(keyEntry.Key, new List<NetworkObject>());
+                        sceneManager.ObjectsMigratedIntoNewScene.Add(keyEntry.Key, new Dictionary<ulong, List<NetworkObject>>());
                     }
+                    if (!sceneManager.ObjectsMigratedIntoNewScene[keyEntry.Key].ContainsKey(objectsMovedEvent.OwnerId))
+                    {
+                        sceneManager.ObjectsMigratedIntoNewScene[keyEntry.Key].Add(objectsMovedEvent.OwnerId, new List<NetworkObject>());
+                    }
+
                     foreach (var objectId in keyEntry.Value)
                     {
                         if (!spawnManager.SpawnedObjects.ContainsKey(objectId))
@@ -1114,22 +1337,15 @@ namespace Unity.Netcode
                             continue;
                         }
                         var networkObject = spawnManager.SpawnedObjects[objectId];
-                        if (!sceneManager.ObjectsMigratedIntoNewScene[keyEntry.Key].Contains(networkObject))
+                        if (!sceneManager.ObjectsMigratedIntoNewScene[keyEntry.Key][objectsMovedEvent.OwnerId].Contains(networkObject))
                         {
-                            sceneManager.ObjectsMigratedIntoNewScene[keyEntry.Key].Add(networkObject);
+                            sceneManager.ObjectsMigratedIntoNewScene[keyEntry.Key][objectsMovedEvent.OwnerId].Add(networkObject);
                         }
                     }
                 }
                 objectsMovedEvent.ObjectsMigratedTable.Clear();
             }
-
             sceneManager.DeferredObjectsMovedEvents.Clear();
-
-            // If there are any pending objects to migrate, then migrate them
-            if (sceneManager.ObjectsMigratedIntoNewScene.Count > 0)
-            {
-                sceneManager.MigrateNetworkObjectsIntoScenes();
-            }
         }
 
         /// <summary>

Runtime/SceneManagement/SceneEventProgress.cs

@@ -55,6 +55,10 @@ namespace Unity.Netcode
         /// This is returned when a client attempts to perform a server only action
         /// </summary>
         ServerOnlyAction,
+        /// <summary>
+        /// This is returned when a client that is not the session owner attempts to perform a session owner only action
+        /// </summary>
+        SessionOwnerOnlyAction,
     }
 
     /// <summary>
@@ -157,22 +161,20 @@ namespace Unity.Netcode
             if (status == SceneEventProgressStatus.Started)
             {
                 m_NetworkManager = networkManager;
-
-                if (networkManager.IsServer)
+                WhenSceneEventHasTimedOut = networkManager.RealTimeProvider.RealTimeSinceStartup + networkManager.NetworkConfig.LoadSceneTimeOut;
+                if ((networkManager.IsServer && !networkManager.DistributedAuthorityMode) || (networkManager.DistributedAuthorityMode && networkManager.LocalClient.IsSessionOwner))
                 {
                     m_NetworkManager.OnClientDisconnectCallback += OnClientDisconnectCallback;
                     // Track the clients that were connected when we started this event
                     foreach (var connectedClientId in networkManager.ConnectedClientsIds)
                     {
-                        // Ignore the host client
-                        if (NetworkManager.ServerClientId == connectedClientId)
+                        // Ignore the host or session owner
+                        if ((!networkManager.DistributedAuthorityMode && NetworkManager.ServerClientId == connectedClientId) || (networkManager.DistributedAuthorityMode && networkManager.CurrentSessionOwner == connectedClientId))
                         {
                             continue;
                         }
                         ClientsProcessingSceneEvent.Add(connectedClientId, false);
                     }
-
-                    WhenSceneEventHasTimedOut = networkManager.RealTimeProvider.RealTimeSinceStartup + networkManager.NetworkConfig.LoadSceneTimeOut;
                     m_TimeOutCoroutine = m_NetworkManager.StartCoroutine(TimeOutSceneEventProgress());
                 }
             }
@@ -298,7 +300,7 @@ namespace Unity.Netcode
                     m_NetworkManager.OnClientDisconnectCallback -= OnClientDisconnectCallback;
                 }
 
-                if (m_TimeOutCoroutine != null)
+                if (m_TimeOutCoroutine != null && m_NetworkManager != null)
                 {
                     m_NetworkManager.StopCoroutine(m_TimeOutCoroutine);
                 }

Runtime/Serialization/FastBufferReader.cs

@@ -245,6 +245,11 @@ namespace Unity.Netcode
         /// </summary>
         public unsafe void Dispose()
         {
+            if (Handle == null)
+            {
+                return;
+            }
+
             UnsafeUtility.Free(Handle, Handle->Allocator);
             Handle = null;
         }
@@ -1069,6 +1074,36 @@ namespace Unity.Netcode
                 ReadUnmanagedSafeInPlace(ref value);
             }
         }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void ReadValueSafeInPlace<T>(ref NativeHashSet<T> value) where T : unmanaged, IEquatable<T>
+        {
+            ReadUnmanagedSafe(out int length);
+            value.Clear();
+            for (var i = 0; i < length; ++i)
+            {
+                T val = default;
+                NetworkVariableSerialization<T>.Read(this, ref val);
+                value.Add(val);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void ReadValueSafeInPlace<TKey, TVal>(ref NativeHashMap<TKey, TVal> value)
+            where TKey : unmanaged, IEquatable<TKey>
+            where TVal : unmanaged
+        {
+            ReadUnmanagedSafe(out int length);
+            value.Clear();
+            for (var i = 0; i < length; ++i)
+            {
+                TKey key = default;
+                TVal val = default;
+                NetworkVariableSerialization<TKey>.Read(this, ref key);
+                NetworkVariableSerialization<TVal>.Read(this, ref val);
+                value[key] = val;
+            }
+        }
 #endif
 
         /// <summary>

Runtime/Serialization/FastBufferWriter.cs

@@ -772,7 +772,11 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public unsafe void WriteBytes(NativeList<byte> value, int size = -1, int offset = 0)
         {
+#if UTP_TRANSPORT_2_0_ABOVE
+            byte* ptr = value.GetUnsafePtr();
+#else
             byte* ptr = (byte*)value.GetUnsafePtr();
+#endif
             WriteBytes(ptr, size == -1 ? value.Length : size, offset);
         }
 
@@ -816,7 +820,11 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public unsafe void WriteBytesSafe(NativeList<byte> value, int size = -1, int offset = 0)
         {
+#if UTP_TRANSPORT_2_0_ABOVE
+            byte* ptr = value.GetUnsafePtr();
+#else
             byte* ptr = (byte*)value.GetUnsafePtr();
+#endif
             WriteBytesSafe(ptr, size == -1 ? value.Length : size, offset);
         }
 
@@ -985,7 +993,11 @@ namespace Unity.Netcode
         internal unsafe void WriteUnmanaged<T>(NativeList<T> value) where T : unmanaged
         {
             WriteUnmanaged(value.Length);
+#if UTP_TRANSPORT_2_0_ABOVE
+            var ptr = value.GetUnsafePtr();
+#else
             var ptr = (T*)value.GetUnsafePtr();
+#endif
             {
                 byte* bytes = (byte*)ptr;
                 WriteBytes(bytes, sizeof(T) * value.Length);
@@ -995,7 +1007,11 @@ namespace Unity.Netcode
         internal unsafe void WriteUnmanagedSafe<T>(NativeList<T> value) where T : unmanaged
         {
             WriteUnmanagedSafe(value.Length);
+#if UTP_TRANSPORT_2_0_ABOVE
+            var ptr = value.GetUnsafePtr();
+#else
             var ptr = (T*)value.GetUnsafePtr();
+#endif
             {
                 byte* bytes = (byte*)ptr;
                 WriteBytesSafe(bytes, sizeof(T) * value.Length);
@@ -1189,6 +1205,39 @@ namespace Unity.Netcode
                 WriteUnmanaged(value);
             }
         }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void WriteValueSafe<T>(NativeHashSet<T> value) where T : unmanaged, IEquatable<T>
+        {
+#if UTP_TRANSPORT_2_0_ABOVE
+            WriteUnmanagedSafe(value.Count);
+#else
+            WriteUnmanagedSafe(value.Count());
+#endif
+            foreach (var item in value)
+            {
+                var iReffable = item;
+                NetworkVariableSerialization<T>.Write(this, ref iReffable);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void WriteValueSafe<TKey, TVal>(NativeHashMap<TKey, TVal> value)
+            where TKey : unmanaged, IEquatable<TKey>
+            where TVal : unmanaged
+        {
+#if UTP_TRANSPORT_2_0_ABOVE
+            WriteUnmanagedSafe(value.Count);
+#else
+            WriteUnmanagedSafe(value.Count());
+#endif
+            foreach (var item in value)
+            {
+                (var key, var val) = (item.Key, item.Value);
+                NetworkVariableSerialization<TKey>.Write(this, ref key);
+                NetworkVariableSerialization<TVal>.Write(this, ref val);
+            }
+        }
 #endif
 
         /// <summary>

Runtime/Serialization/NetworkBehaviourReference.cs

@@ -40,7 +40,7 @@ namespace Unity.Netcode
         /// <returns>True if the <see cref="NetworkBehaviour"/> was found; False if the <see cref="NetworkBehaviour"/> was not found. This can happen if the corresponding <see cref="NetworkObject"/> has not been spawned yet. you can try getting the reference at a later point in time.</returns>
         public bool TryGet(out NetworkBehaviour networkBehaviour, NetworkManager networkManager = null)
         {
-            networkBehaviour = GetInternal(this, null);
+            networkBehaviour = GetInternal(this, networkManager);
             return networkBehaviour != null;
         }
 
@@ -53,7 +53,7 @@ namespace Unity.Netcode
         /// <returns>True if the <see cref="NetworkBehaviour"/> was found; False if the <see cref="NetworkBehaviour"/> was not found. This can happen if the corresponding <see cref="NetworkObject"/> has not been spawned yet. you can try getting the reference at a later point in time.</returns>
         public bool TryGet<T>(out T networkBehaviour, NetworkManager networkManager = null) where T : NetworkBehaviour
         {
-            networkBehaviour = GetInternal(this, null) as T;
+            networkBehaviour = GetInternal(this, networkManager) as T;
             return networkBehaviour != null;
         }
 

Runtime/Timing/IRealTimeProvider.cs

@@ -6,5 +6,6 @@ namespace Unity.Netcode
         float UnscaledTime { get; }
         float UnscaledDeltaTime { get; }
         float DeltaTime { get; }
+        float FixedDeltaTime { get; }
     }
 }

Runtime/Timing/NetworkTime.cs

@@ -113,9 +113,9 @@ namespace Unity.Netcode
         /// </summary>
         /// <param name="ticks">The number of ticks ago we're querying the time</param>
         /// <returns></returns>
-        public NetworkTime TimeTicksAgo(int ticks)
+        public NetworkTime TimeTicksAgo(int ticks, float offset = 0.0f)
         {
-            return this - new NetworkTime(TickRate, ticks);
+            return this - new NetworkTime(TickRate, ticks, offset);
         }
 
         private void UpdateCache()

Runtime/Timing/RealTimeProvider.cs

@@ -8,5 +8,6 @@ namespace Unity.Netcode
         public float UnscaledTime => Time.unscaledTime;
         public float UnscaledDeltaTime => Time.unscaledDeltaTime;
         public float DeltaTime => Time.deltaTime;
+        public float FixedDeltaTime => Time.fixedDeltaTime;
     }
 }

Runtime/Transports/UTP/BatchedSendQueue.cs

@@ -106,7 +106,11 @@ namespace Unity.Netcode.Transports.UTP
         {
             unsafe
             {
+#if UTP_TRANSPORT_2_0_ABOVE
+                var writer = new DataStreamWriter(m_Data.GetUnsafePtr() + TailIndex, Capacity - TailIndex);
+#else
                 var writer = new DataStreamWriter((byte*)m_Data.GetUnsafePtr() + TailIndex, Capacity - TailIndex);
+#endif
 
                 writer.WriteInt(data.Count);
 
@@ -145,7 +149,11 @@ namespace Unity.Netcode.Transports.UTP
             {
                 unsafe
                 {
+#if UTP_TRANSPORT_2_0_ABOVE
+                    UnsafeUtility.MemMove(m_Data.GetUnsafePtr(), m_Data.GetUnsafePtr() + HeadIndex, Length);
+#else
                     UnsafeUtility.MemMove(m_Data.GetUnsafePtr(), (byte*)m_Data.GetUnsafePtr() + HeadIndex, Length);
+#endif
                 }
 
                 TailIndex = Length;
@@ -231,7 +239,11 @@ namespace Unity.Netcode.Transports.UTP
                 if (bytesToWrite > softMaxBytes && bytesToWrite <= writer.Capacity)
                 {
                     writer.WriteInt(messageLength);
+#if UTP_TRANSPORT_2_0_ABOVE
+                    WriteBytes(ref writer, m_Data.GetUnsafePtr() + reader.GetBytesRead(), messageLength);
+#else
                     WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + reader.GetBytesRead(), messageLength);
+#endif
 
                     return bytesToWrite;
                 }
@@ -248,7 +260,11 @@ namespace Unity.Netcode.Transports.UTP
                         if (bytesWritten + bytesToWrite <= softMaxBytes)
                         {
                             writer.WriteInt(messageLength);
+#if UTP_TRANSPORT_2_0_ABOVE
+                            WriteBytes(ref writer, m_Data.GetUnsafePtr() + reader.GetBytesRead(), messageLength);
+#else
                             WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + reader.GetBytesRead(), messageLength);
+#endif
 
                             readerOffset += bytesToWrite;
                             bytesWritten += bytesToWrite;
@@ -292,7 +308,11 @@ namespace Unity.Netcode.Transports.UTP
 
             unsafe
             {
+#if UTP_TRANSPORT_2_0_ABOVE
+                WriteBytes(ref writer, m_Data.GetUnsafePtr() + HeadIndex, copyLength);
+#else
                 WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + HeadIndex, copyLength);
+#endif
             }
 
             return copyLength;