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)

CHANGELOG.md

@@ -6,77 +6,76 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 
 Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).
 
-## [1.11.0] - 2024-08-20
+## [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 `NetworkVariable.CheckDirtyState` that is to be used in tandem with collections in order to detect whether the collection or an item within the collection has changed. (#3005)
+- 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 by adding null checks in `NetworkVariableBase.CanClientRead` and `NetworkVariableBase.CanClientWrite` methods to ensure safe access to `NetworkBehaviour`. (#3011)
-- Fixed issue using collections within `NetworkVariable` where the collection would not detect changes to items or nested items. (#3005)
-- Fixed issue where `List`, `Dictionary`, and `HashSet` collections would not uniquely duplicate nested collections. (#3005)
-- Fixed Issue where a state with dual triggers, inbound and outbound, could cause a false layer to layer state transition message to be sent to non-authority `NetworkAnimator` instances and cause a warning message to be logged. (#2999)
-- Fixed issue where `FixedStringSerializer<T>` was using `NetworkVariableSerialization<byte>.AreEqual` to determine if two bytes were equal causes an exception to be thrown due to no byte serializer having been defined. (#2992)
-
-### Changed
-
-- Changed permissions exception thrown in `NetworkList` to exiting early with a logged error that is now a unified permissions message within `NetworkVariableBase`. (#3005)
-- Changed permissions exception thrown in `NetworkVariable.Value` to exiting early with a logged error that is now a unified permissions message within `NetworkVariableBase`. (#3005)
-
-
-## [1.10.0] - 2024-07-22
-
-### Added
-
-- Added `NetworkBehaviour.OnNetworkPreSpawn` and `NetworkBehaviour.OnNetworkPostSpawn` methods that provide the ability to handle pre and post spawning actions during the `NetworkObject` spawn sequence. (#2906)
-- Added a client-side only `NetworkBehaviour.OnNetworkSessionSynchronized` convenience method that is invoked on all `NetworkBehaviour`s after a newly joined client has finished synchronizing with the network session in progress. (#2906)
-- Added `NetworkBehaviour.OnInSceneObjectsSpawned` convenience method that is invoked when all in-scene `NetworkObject`s have been spawned after a scene has been loaded or upon a host or server starting. (#2906)
-
-### Fixed
-
-- Fixed issue where the realtime network stats monitor was not able to display RPC traffic in release builds due to those stats being only available in development builds or the editor. (#2980)
-- Fixed issue where `NetworkManager.ScenesLoaded` was not being updated if `PostSynchronizationSceneUnloading` was set and any loaded scenes not used during synchronization were unloaded.(#2977)
-- Fixed issue where internal delta serialization could not have a byte serializer defined when serializing deltas for other types. Added `[GenerateSerializationForType(typeof(byte))]` to both the `NetworkVariable` and `AnticipatedNetworkVariable` classes to assure a byte serializer is defined. (#2953)
-- Fixed issue with the client count not being correct on the host or server side when a client disconnects itself from a session. (#2941)
-- Fixed issue with the host trying to send itself a message that it has connected when first starting up. (#2941)
-- Fixed issue where in-scene placed NetworkObjects could be destroyed if a client disconnects early and/or before approval. (#2923)
-- Fixed issue where `NetworkDeltaPosition` would "jitter" periodically if both unreliable delta state updates and half-floats were used together. (#2922)
-- Fixed issue where `NetworkRigidbody2D` would not properly change body type based on the instance's authority when spawned. (#2916)
-- Fixed issue where a `NetworkObject` component's associated `NetworkBehaviour` components would not be detected if scene loading is disabled in the editor and the currently loaded scene has in-scene placed `NetworkObject`s. (#2906)
-- Fixed issue where an in-scene placed `NetworkObject` with `NetworkTransform` that is also parented under a `GameObject` would not properly synchronize when the parent `GameObject` had a world space position other than 0,0,0. (#2895)
-
-### Changed
-
-
-## [1.9.1] - 2024-04-18
-
-### Added
-- Added AnticipatedNetworkVariable<T>, which adds support for client anticipation of NetworkVariable values, allowing for more responsive gameplay (#2820)
-- Added AnticipatedNetworkTransform, which adds support for client anticipation of NetworkTransforms (#2820)
-- Added NetworkVariableBase.ExceedsDirtinessThreshold to allow network variables to throttle updates by only sending updates when the difference between the current and previous values exceeds a threshold. (This is exposed in NetworkVariable<T> with the callback NetworkVariable<T>.CheckExceedsDirtinessThreshold) (#2820)
-- Added NetworkVariableUpdateTraits, which add additional throttling support: MinSecondsBetweenUpdates will prevent the NetworkVariable from sending updates more often than the specified time period (even if it exceeds the dirtiness threshold), while MaxSecondsBetweenUpdates will force a dirty NetworkVariable to send an update after the specified time period even if it has not yet exceeded the dirtiness threshold. (#2820)
-- Added virtual method NetworkVariableBase.OnInitialize() which can be used by NetworkVariable subclasses to add initialization code (#2820)
-- Added virtual method NetworkVariableBase.Update(), which is called once per frame to support behaviors such as interpolation between an anticipated value and an authoritative one. (#2820)
-- Added NetworkTime.TickWithPartial, which represents the current tick as a double that includes the fractional/partial tick value. (#2820)
-- `NetworkVariable` now includes built-in support for `NativeHashSet`, `NativeHashMap`, `List`, `HashSet`, and `Dictionary` (#2813)
-- `NetworkVariable` now includes delta compression for collection values (`NativeList`, `NativeArray`, `NativeHashSet`, `NativeHashMap`, `List`, `HashSet`, `Dictionary`, and `FixedString` types) to save bandwidth by only sending the values that changed. (Note: For `NativeList`, `NativeArray`, and `List`, this algorithm works differently than that used in `NetworkList`. This algorithm will use less bandwidth for "set" and "add" operations, but `NetworkList` is more bandwidth-efficient if you are performing frequent "insert" operations.) (#2813)
-- `UserNetworkVariableSerialization` now has optional callbacks for `WriteDelta` and `ReadDelta`. If both are provided, they will be used for all serialization operations on NetworkVariables of that type except for the first one for each client. If either is missing, the existing `Write` and `Read` will always be used. (#2813)
-- Network variables wrapping `INetworkSerializable` types can perform delta serialization by setting `UserNetworkVariableSerialization<T>.WriteDelta` and `UserNetworkVariableSerialization<T>.ReadDelta` for those types. The built-in `INetworkSerializable` serializer will continue to be used for all other serialization operations, but if those callbacks are set, it will call into them on all but the initial serialization to perform delta serialization. (This could be useful if you have a large struct where most values do not change regularly and you want to send only the fields that did change.) (#2813)
-
-### Fixed
-
-- Fixed issue where NetworkTransformEditor would throw and exception if you excluded the physics package. (#2871)
-- Fixed issue where `NetworkTransform` could not properly synchronize its base position when using half float precision. (#2845)
 - 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 `NetworkObjectReference` and `NetworkBehaviourReference` to allow null references when constructing and serializing. (#2874)
+- Changed `NetworkManager.ConnectedClients` can now be accessed by both server and clients. (#2863)
-- Changed `NetworkAnimator` no longer requires the `Animator` component to exist on the same `GameObject`. (#2872)
+- 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)
 

Components/AnticipatedNetworkTransform.cs

@@ -1,500 +0,0 @@
-using Unity.Mathematics;
-using UnityEngine;
-
-namespace Unity.Netcode.Components
-{
-
-#pragma warning disable IDE0001
-    /// <summary>
-    /// A subclass of <see cref="NetworkTransform"/> that supports basic client anticipation - the client
-    /// can set a value on the belief that the server will update it to reflect the same value in a future update
-    /// (i.e., as the result of an RPC call). This value can then be adjusted as new updates from the server come in,
-    /// in three basic modes:
-    ///
-    /// <list type="bullet">
-    ///
-    /// <item><b>Snap:</b> In this mode (with <see cref="StaleDataHandling"/> set to
-    /// <see cref="StaleDataHandling.Ignore"/> and no <see cref="NetworkBehaviour.OnReanticipate"/> callback),
-    /// the moment a more up-to-date value is received from the authority, it will simply replace the anticipated value,
-    /// resulting in a "snap" to the new value if it is different from the anticipated value.</item>
-    ///
-    /// <item><b>Smooth:</b> In this mode (with <see cref="StaleDataHandling"/> set to
-    /// <see cref="Netcode.StaleDataHandling.Ignore"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> callback that calls
-    /// <see cref="Smooth"/> from the anticipated value to the authority value with an appropriate
-    /// <see cref="Mathf.Lerp"/>-style smooth function), when a more up-to-date value is received from the authority,
-    /// it will interpolate over time from an incorrect anticipated value to the correct authoritative value.</item>
-    ///
-    /// <item><b>Constant Reanticipation:</b> In this mode (with <see cref="StaleDataHandling"/> set to
-    /// <see cref="Netcode.StaleDataHandling.Reanticipate"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> that calculates a
-    /// new anticipated value based on the current authoritative value), when a more up-to-date value is received from
-    /// the authority, user code calculates a new anticipated value, possibly calling <see cref="Smooth"/> to interpolate
-    /// between the previous anticipation and the new anticipation. This is useful for values that change frequently and
-    /// need to constantly be re-evaluated, as opposed to values that change only in response to user action and simply
-    /// need a one-time anticipation when the user performs that action.</item>
-    ///
-    /// </list>
-    ///
-    /// Note that these three modes may be combined. For example, if an <see cref="NetworkBehaviour.OnReanticipate"/> callback
-    /// does not call either <see cref="Smooth"/> or one of the Anticipate methods, the result will be a snap to the
-    /// authoritative value, enabling for a callback that may conditionally call <see cref="Smooth"/> when the
-    /// difference between the anticipated and authoritative values is within some threshold, but fall back to
-    /// snap behavior if the difference is too large.
-    /// </summary>
-#pragma warning restore IDE0001
-    [DisallowMultipleComponent]
-    [AddComponentMenu("Netcode/Anticipated Network Transform")]
-    [DefaultExecutionOrder(100000)] // this is needed to catch the update time after the transform was updated by user scripts
-    public class AnticipatedNetworkTransform : NetworkTransform
-    {
-        public struct TransformState
-        {
-            public Vector3 Position;
-            public Quaternion Rotation;
-            public Vector3 Scale;
-        }
-
-        private TransformState m_AuthoritativeTransform = new TransformState();
-        private TransformState m_AnticipatedTransform = new TransformState();
-        private TransformState m_PreviousAnticipatedTransform = new TransformState();
-        private ulong m_LastAnticipaionCounter;
-        private double m_LastAnticipationTime;
-        private ulong m_LastAuthorityUpdateCounter;
-
-        private TransformState m_SmoothFrom;
-        private TransformState m_SmoothTo;
-        private float m_SmoothDuration;
-        private float m_CurrentSmoothTime;
-
-        private bool m_OutstandingAuthorityChange = false;
-
-#if UNITY_EDITOR
-        private void Reset()
-        {
-            // Anticipation + smoothing is a form of interpolation, and adding NetworkTransform's buffered interpolation
-            // makes the anticipation get weird, so we default it to false.
-            Interpolate = false;
-        }
-#endif
-
-#pragma warning disable IDE0001
-        /// <summary>
-        /// Defines what the behavior should be if we receive a value from the server with an earlier associated
-        /// time value than the anticipation time value.
-        /// <br/><br/>
-        /// If this is <see cref="Netcode.StaleDataHandling.Ignore"/>, the stale data will be ignored and the authoritative
-        /// value will not replace the anticipated value until the anticipation time is reached. <see cref="OnAuthoritativeValueChanged"/>
-        /// and <see cref="OnReanticipate"/> will also not be invoked for this stale data.
-        /// <br/><br/>
-        /// If this is <see cref="Netcode.StaleDataHandling.Reanticipate"/>, the stale data will replace the anticipated data and
-        /// <see cref="OnAuthoritativeValueChanged"/> and <see cref="OnReanticipate"/> will be invoked.
-        /// In this case, the authoritativeTime value passed to <see cref="OnReanticipate"/> will be lower than
-        /// the anticipationTime value, and that callback can be used to calculate a new anticipated value.
-        /// </summary>
-#pragma warning restore IDE0001
-        public StaleDataHandling StaleDataHandling = StaleDataHandling.Reanticipate;
-
-        /// <summary>
-        /// Contains the current state of this transform on the server side.
-        /// Note that, on the server side, this gets updated at the end of the frame, and will not immediately reflect
-        /// changes to the transform.
-        /// </summary>
-        public TransformState AuthoritativeState => m_AuthoritativeTransform;
-
-        /// <summary>
-        /// Contains the current anticipated state, which will match the values of this object's
-        /// actual <see cref="MonoBehaviour.transform"/>. When a server
-        /// update arrives, this value will be overwritten by the new
-        /// server value (unless stale data handling is set to "Ignore"
-        /// and the update is determined to be stale). This value will
-        /// be duplicated in <see cref="PreviousAnticipatedState"/>, which
-        /// will NOT be overwritten in server updates.
-        /// </summary>
-        public TransformState AnticipatedState => m_AnticipatedTransform;
-
-        /// <summary>
-        /// Indicates whether this transform currently needs
-        /// reanticipation. If this is true, the anticipated value
-        /// has been overwritten by the authoritative value from the
-        /// server; the previous anticipated value is stored in <see cref="PreviousAnticipatedState"/>
-        /// </summary>
-        public bool ShouldReanticipate
-        {
-            get;
-            private set;
-        }
-
-        /// <summary>
-        /// Holds the most recent anticipated state, whatever was
-        /// most recently set using the Anticipate methods. Unlike
-        /// <see cref="AnticipatedState"/>, this does not get overwritten
-        /// when a server update arrives.
-        /// </summary>
-        public TransformState PreviousAnticipatedState => m_PreviousAnticipatedTransform;
-
-        /// <summary>
-        /// Anticipate that, at the end of one round trip to the server, this transform will be in the given
-        /// <see cref="newPosition"/>
-        /// </summary>
-        /// <param name="newPosition"></param>
-        public void AnticipateMove(Vector3 newPosition)
-        {
-            if (NetworkManager.ShutdownInProgress || !NetworkManager.IsListening)
-            {
-                return;
-            }
-            transform.position = newPosition;
-            m_AnticipatedTransform.Position = newPosition;
-            if (CanCommitToTransform)
-            {
-                m_AuthoritativeTransform.Position = newPosition;
-            }
-
-            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
-
-            m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
-            m_LastAnticipationTime = NetworkManager.LocalTime.Time;
-
-            m_SmoothDuration = 0;
-            m_CurrentSmoothTime = 0;
-        }
-
-        /// <summary>
-        /// Anticipate that, at the end of one round trip to the server, this transform will have the given
-        /// <see cref="newRotation"/>
-        /// </summary>
-        /// <param name="newRotation"></param>
-        public void AnticipateRotate(Quaternion newRotation)
-        {
-            if (NetworkManager.ShutdownInProgress || !NetworkManager.IsListening)
-            {
-                return;
-            }
-            transform.rotation = newRotation;
-            m_AnticipatedTransform.Rotation = newRotation;
-            if (CanCommitToTransform)
-            {
-                m_AuthoritativeTransform.Rotation = newRotation;
-            }
-
-            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
-
-            m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
-            m_LastAnticipationTime = NetworkManager.LocalTime.Time;
-
-            m_SmoothDuration = 0;
-            m_CurrentSmoothTime = 0;
-        }
-
-        /// <summary>
-        /// Anticipate that, at the end of one round trip to the server, this transform will have the given
-        /// <see cref="newScale"/>
-        /// </summary>
-        /// <param name="newScale"></param>
-        public void AnticipateScale(Vector3 newScale)
-        {
-            if (NetworkManager.ShutdownInProgress || !NetworkManager.IsListening)
-            {
-                return;
-            }
-            transform.localScale = newScale;
-            m_AnticipatedTransform.Scale = newScale;
-            if (CanCommitToTransform)
-            {
-                m_AuthoritativeTransform.Scale = newScale;
-            }
-
-            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
-
-            m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
-            m_LastAnticipationTime = NetworkManager.LocalTime.Time;
-
-            m_SmoothDuration = 0;
-            m_CurrentSmoothTime = 0;
-        }
-
-        /// <summary>
-        /// Anticipate that, at the end of one round trip to the server, the transform will have the given
-        /// <see cref="newState"/>
-        /// </summary>
-        /// <param name="newState"></param>
-        public void AnticipateState(TransformState newState)
-        {
-            if (NetworkManager.ShutdownInProgress || !NetworkManager.IsListening)
-            {
-                return;
-            }
-            var transform_ = transform;
-            transform_.position = newState.Position;
-            transform_.rotation = newState.Rotation;
-            transform_.localScale = newState.Scale;
-            m_AnticipatedTransform = newState;
-            if (CanCommitToTransform)
-            {
-                m_AuthoritativeTransform = newState;
-            }
-
-            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
-
-            m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
-            m_LastAnticipationTime = NetworkManager.LocalTime.Time;
-
-            m_SmoothDuration = 0;
-            m_CurrentSmoothTime = 0;
-        }
-
-        protected override void Update()
-        {
-            // If not spawned or this instance has authority, exit early
-            if (!IsSpawned)
-            {
-                return;
-            }
-            // Do not call the base class implementation...
-            // AnticipatedNetworkTransform applies its authoritative state immediately rather than waiting for update
-            // This is because AnticipatedNetworkTransforms may need to reference each other in reanticipating
-            // and we will want all reanticipation done before anything else wants to reference the transform in
-            // Update()
-            //base.Update();
-
-            if (m_CurrentSmoothTime < m_SmoothDuration)
-            {
-                m_CurrentSmoothTime += NetworkManager.RealTimeProvider.DeltaTime;
-                var transform_ = transform;
-                var pct = math.min(m_CurrentSmoothTime / m_SmoothDuration, 1f);
-
-                m_AnticipatedTransform = new TransformState
-                {
-                    Position = Vector3.Lerp(m_SmoothFrom.Position, m_SmoothTo.Position, pct),
-                    Rotation = Quaternion.Slerp(m_SmoothFrom.Rotation, m_SmoothTo.Rotation, pct),
-                    Scale = Vector3.Lerp(m_SmoothFrom.Scale, m_SmoothTo.Scale, pct)
-                };
-                m_PreviousAnticipatedTransform = m_AnticipatedTransform;
-                if (!CanCommitToTransform)
-                {
-                    transform_.position = m_AnticipatedTransform.Position;
-                    transform_.localScale = m_AnticipatedTransform.Scale;
-                    transform_.rotation = m_AnticipatedTransform.Rotation;
-                }
-            }
-        }
-
-        internal class AnticipatedObject : IAnticipationEventReceiver, IAnticipatedObject
-        {
-            public AnticipatedNetworkTransform Transform;
-
-
-            public void SetupForRender()
-            {
-                if (Transform.CanCommitToTransform)
-                {
-                    var transform_ = Transform.transform;
-                    Transform.m_AuthoritativeTransform = new TransformState
-                    {
-                        Position = transform_.position,
-                        Rotation = transform_.rotation,
-                        Scale = transform_.localScale
-                    };
-                    if (Transform.m_CurrentSmoothTime >= Transform.m_SmoothDuration)
-                    {
-                        // If we've had a call to Smooth() we'll continue interpolating.
-                        // Otherwise we'll go ahead and make the visual and actual locations
-                        // match.
-                        Transform.m_AnticipatedTransform = Transform.m_AuthoritativeTransform;
-                    }
-
-                    transform_.position = Transform.m_AnticipatedTransform.Position;
-                    transform_.rotation = Transform.m_AnticipatedTransform.Rotation;
-                    transform_.localScale = Transform.m_AnticipatedTransform.Scale;
-                }
-            }
-
-            public void SetupForUpdate()
-            {
-                if (Transform.CanCommitToTransform)
-                {
-                    var transform_ = Transform.transform;
-                    transform_.position = Transform.m_AuthoritativeTransform.Position;
-                    transform_.rotation = Transform.m_AuthoritativeTransform.Rotation;
-                    transform_.localScale = Transform.m_AuthoritativeTransform.Scale;
-                }
-            }
-
-            public void Update()
-            {
-                // No need to do this, it's handled by NetworkBehaviour.Update
-            }
-
-            public void ResetAnticipation()
-            {
-                Transform.ShouldReanticipate = false;
-            }
-
-            public NetworkObject OwnerObject => Transform.NetworkObject;
-        }
-
-        private AnticipatedObject m_AnticipatedObject = null;
-
-        private void ResetAnticipatedState()
-        {
-            var transform_ = transform;
-            m_AuthoritativeTransform = new TransformState
-            {
-                Position = transform_.position,
-                Rotation = transform_.rotation,
-                Scale = transform_.localScale
-            };
-            m_AnticipatedTransform = m_AuthoritativeTransform;
-            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
-
-            m_SmoothDuration = 0;
-            m_CurrentSmoothTime = 0;
-        }
-
-        protected override void OnSynchronize<T>(ref BufferSerializer<T> serializer)
-        {
-            base.OnSynchronize(ref serializer);
-            if (!CanCommitToTransform)
-            {
-                m_OutstandingAuthorityChange = true;
-                ApplyAuthoritativeState();
-                ResetAnticipatedState();
-            }
-        }
-
-        public override void OnNetworkSpawn()
-        {
-            base.OnNetworkSpawn();
-            m_OutstandingAuthorityChange = true;
-            ApplyAuthoritativeState();
-            ResetAnticipatedState();
-
-            m_AnticipatedObject = new AnticipatedObject { Transform = this };
-            NetworkManager.AnticipationSystem.RegisterForAnticipationEvents(m_AnticipatedObject);
-            NetworkManager.AnticipationSystem.AllAnticipatedObjects.Add(m_AnticipatedObject);
-        }
-
-        public override void OnNetworkDespawn()
-        {
-            if (m_AnticipatedObject != null)
-            {
-                NetworkManager.AnticipationSystem.DeregisterForAnticipationEvents(m_AnticipatedObject);
-                NetworkManager.AnticipationSystem.AllAnticipatedObjects.Remove(m_AnticipatedObject);
-                NetworkManager.AnticipationSystem.ObjectsToReanticipate.Remove(m_AnticipatedObject);
-                m_AnticipatedObject = null;
-            }
-            ResetAnticipatedState();
-
-            base.OnNetworkDespawn();
-        }
-
-        public override void OnDestroy()
-        {
-            if (m_AnticipatedObject != null)
-            {
-                NetworkManager.AnticipationSystem.DeregisterForAnticipationEvents(m_AnticipatedObject);
-                NetworkManager.AnticipationSystem.AllAnticipatedObjects.Remove(m_AnticipatedObject);
-                NetworkManager.AnticipationSystem.ObjectsToReanticipate.Remove(m_AnticipatedObject);
-                m_AnticipatedObject = null;
-            }
-
-            base.OnDestroy();
-        }
-
-        /// <summary>
-        /// Interpolate between the transform represented by <see cref="from"/> to the transform represented by
-        /// <see cref="to"/> over <see cref="durationSeconds"/> of real time. The duration uses
-        /// <see cref="Time.deltaTime"/>, so it is affected by <see cref="Time.timeScale"/>.
-        /// </summary>
-        /// <param name="from"></param>
-        /// <param name="to"></param>
-        /// <param name="durationSeconds"></param>
-        public void Smooth(TransformState from, TransformState to, float durationSeconds)
-        {
-            var transform_ = transform;
-            if (durationSeconds <= 0)
-            {
-                m_AnticipatedTransform = to;
-                m_PreviousAnticipatedTransform = m_AnticipatedTransform;
-                transform_.position = to.Position;
-                transform_.rotation = to.Rotation;
-                transform_.localScale = to.Scale;
-                m_SmoothDuration = 0;
-                m_CurrentSmoothTime = 0;
-                return;
-            }
-            m_AnticipatedTransform = from;
-            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
-
-            if (!CanCommitToTransform)
-            {
-                transform_.position = from.Position;
-                transform_.rotation = from.Rotation;
-                transform_.localScale = from.Scale;
-            }
-
-            m_SmoothFrom = from;
-            m_SmoothTo = to;
-            m_SmoothDuration = durationSeconds;
-            m_CurrentSmoothTime = 0;
-        }
-
-        protected override void OnBeforeUpdateTransformState()
-        {
-            // this is called when new data comes from the server
-            m_LastAuthorityUpdateCounter = NetworkManager.AnticipationSystem.LastAnticipationAck;
-            m_OutstandingAuthorityChange = true;
-        }
-
-        protected override void OnNetworkTransformStateUpdated(ref NetworkTransformState oldState, ref NetworkTransformState newState)
-        {
-            base.OnNetworkTransformStateUpdated(ref oldState, ref newState);
-            ApplyAuthoritativeState();
-        }
-
-        protected override void OnTransformUpdated()
-        {
-            if (CanCommitToTransform || m_AnticipatedObject == null)
-            {
-                return;
-            }
-            // this is called pretty much every frame and will change the transform
-            // If we've overridden the transform with an anticipated state, we need to be able to change it back
-            // to the anticipated state (while updating the authority state accordingly) or else
-            // mark this transform for reanticipation
-            var transform_ = transform;
-
-            var previousAnticipatedTransform = m_AnticipatedTransform;
-
-            // Update authority state to catch any possible interpolation data
-            m_AuthoritativeTransform.Position = transform_.position;
-            m_AuthoritativeTransform.Rotation = transform_.rotation;
-            m_AuthoritativeTransform.Scale = transform_.localScale;
-
-            if (!m_OutstandingAuthorityChange)
-            {
-                // Keep the anticipated value unchanged, we have no updates from the server at all.
-                transform_.position = previousAnticipatedTransform.Position;
-                transform_.localScale = previousAnticipatedTransform.Scale;
-                transform_.rotation = previousAnticipatedTransform.Rotation;
-                return;
-            }
-
-            if (StaleDataHandling == StaleDataHandling.Ignore && m_LastAnticipaionCounter > m_LastAuthorityUpdateCounter)
-            {
-                // Keep the anticipated value unchanged because it is more recent than the authoritative one.
-                transform_.position = previousAnticipatedTransform.Position;
-                transform_.localScale = previousAnticipatedTransform.Scale;
-                transform_.rotation = previousAnticipatedTransform.Rotation;
-                return;
-            }
-
-            m_SmoothDuration = 0;
-            m_CurrentSmoothTime = 0;
-            m_OutstandingAuthorityChange = false;
-            m_AnticipatedTransform = m_AuthoritativeTransform;
-
-            ShouldReanticipate = true;
-            NetworkManager.AnticipationSystem.ObjectsToReanticipate.Add(m_AnticipatedObject);
-        }
-    }
-}

Components/AnticipatedNetworkTransform.cs.meta

@@ -1,3 +0,0 @@
-fileFormatVersion: 2
-guid: 97616b67982a4be48d957d421e422433
-timeCreated: 1705597211

Components/Messages/NetworkTransformMessage.cs

@@ -11,6 +11,20 @@ namespace Unity.Netcode
         public int Version => 0;
         public ulong NetworkObjectId;
         public int NetworkBehaviourId;
+        // This is only used when serializing but not serialized
+        public bool DistributedAuthorityMode;
+        // Might get removed
+        public ulong[] TargetIds;
+
+        private int GetTargetIdLength()
+        {
+            if (TargetIds != null)
+            {
+                return TargetIds.Length;
+            }
+            return 0;
+        }
+
         public NetworkTransform.NetworkTransformState State;
 
         private NetworkTransform m_ReceiverNetworkTransform;
@@ -32,6 +46,20 @@ namespace Unity.Netcode
                 BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
                 BytePacker.WriteValueBitPacked(writer, NetworkBehaviourId);
                 writer.WriteNetworkSerializable(State);
+                if (DistributedAuthorityMode)
+                {
+                    var length = GetTargetIdLength();
+                    BytePacker.WriteValuePacked(writer, length);
+                    // If no target ids, then just exit early (DAHost specific)
+                    if (length == 0)
+                    {
+                        return;
+                    }
+                    foreach (var target in TargetIds)
+                    {
+                        BytePacker.WriteValuePacked(writer, target);
+                    }
+                }
             }
         }
 
@@ -45,32 +73,76 @@ namespace Unity.Netcode
             }
             var currentPosition = reader.Position;
             ByteUnpacker.ReadValueBitPacked(reader, out NetworkObjectId);
-            if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
+            var isSpawnedLocally = networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId);
+
+            // Only defer if the NetworkObject is not spawned yet and the local NetworkManager is not running as a DAHost.
+            if (!isSpawnedLocally && !networkManager.DAHost)
             {
                 networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
                 return false;
             }
+
+            // While the below check and assignment might seem out of place, this is specific to running in DAHost mode when a NetworkObject is
+            // hidden from the DAHost but is visible to other clients. Since the DAHost needs to forward updates to the clients, we ignore processing
+            // this message locally
+            var networkObject = (NetworkObject)null;
+            var isServerAuthoritative = false;
+            var ownerAuthoritativeServerSide = false;
+
             // Get the behaviour index
             ByteUnpacker.ReadValueBitPacked(reader, out NetworkBehaviourId);
 
             // Deserialize the state
-            reader.ReadNetworkSerializable(out State);
+            reader.ReadNetworkSerializableInPlace(ref State);
 
-            var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
+            if (networkManager.DistributedAuthorityMode)
+            {
+                var targetCount = 0;
+                ByteUnpacker.ReadValueBitPacked(reader, out targetCount);
+                if (targetCount > 0)
+                {
+                    TargetIds = new ulong[targetCount];
+                }
+                var targetId = (ulong)0;
+                for (int i = 0; i < targetCount; i++)
+                {
+                    ByteUnpacker.ReadValueBitPacked(reader, out targetId);
+                    TargetIds[i] = targetId;
+                }
+            }
 
-            // Get the target NetworkTransform
+            if (isSpawnedLocally)
-            m_ReceiverNetworkTransform = networkObject.ChildNetworkBehaviours[NetworkBehaviourId] as NetworkTransform;
+            {
+                networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
+                // Get the target NetworkTransform
+                m_ReceiverNetworkTransform = networkObject.ChildNetworkBehaviours[NetworkBehaviourId] as NetworkTransform;
+                isServerAuthoritative = m_ReceiverNetworkTransform.IsServerAuthoritative();
+                ownerAuthoritativeServerSide = !isServerAuthoritative && networkManager.IsServer;
+            }
+            else
+            {
+                // If we are the DAHost and the NetworkObject is hidden from the host we still need to forward this message
+                ownerAuthoritativeServerSide = networkManager.DAHost && !isSpawnedLocally;
+            }
 
-            var isServerAuthoritative = m_ReceiverNetworkTransform.IsServerAuthoritative();
-            var ownerAuthoritativeServerSide = !isServerAuthoritative && networkManager.IsServer;
             if (ownerAuthoritativeServerSide)
             {
-                var ownerClientId = networkObject.OwnerClientId;
+                var ownerClientId = (ulong)0;
-                if (ownerClientId == NetworkManager.ServerClientId)
+
+                if (networkObject != null)
                 {
-                    // Ownership must have changed, ignore any additional pending messages that might have
+                    ownerClientId = networkObject.OwnerClientId;
-                    // come from a previous owner client.
+                    if (ownerClientId == NetworkManager.ServerClientId)
-                    return true;
+                    {
+                        // Ownership must have changed, ignore any additional pending messages that might have
+                        // come from a previous owner client.
+                        return true;
+                    }
+                }
+                else if (networkManager.DAHost)
+                {
+                    // Specific to distributed authority mode, the only sender of state updates will be the owner 
+                    ownerClientId = context.SenderId;
                 }
 
                 var networkDelivery = State.IsReliableStateUpdate() ? NetworkDelivery.ReliableSequenced : NetworkDelivery.UnreliableSequenced;
@@ -78,6 +150,12 @@ namespace Unity.Netcode
                 // Forward the state update if there are any remote clients to foward it to
                 if (networkManager.ConnectionManager.ConnectedClientsList.Count > (networkManager.IsHost ? 2 : 1))
                 {
+                    var clientCount = networkManager.DistributedAuthorityMode ? GetTargetIdLength() : networkManager.ConnectionManager.ConnectedClientsList.Count;
+                    if (clientCount == 0)
+                    {
+                        return true;
+                    }
+
                     // This is only to copy the existing and already serialized struct for forwarding purposes only.
                     // This will not include any changes made to this struct at this particular stage of processing the message.
                     var currentMessage = this;
@@ -86,14 +164,16 @@ namespace Unity.Netcode
                     // Rewind the new reader to the beginning of the message's payload
                     currentMessage.m_CurrentReader.Seek(currentPosition);
                     // Forward the message to all connected clients that are observers of the associated NetworkObject
-                    var clientCount = networkManager.ConnectionManager.ConnectedClientsList.Count;
+
                     for (int i = 0; i < clientCount; i++)
                     {
-                        var clientId = networkManager.ConnectionManager.ConnectedClientsList[i].ClientId;
+                        var clientId = networkManager.DistributedAuthorityMode ? TargetIds[i] : networkManager.ConnectionManager.ConnectedClientsList[i].ClientId;
-                        if (NetworkManager.ServerClientId == clientId || (!isServerAuthoritative && clientId == ownerClientId) || !networkObject.Observers.Contains(clientId))
+                        if (NetworkManager.ServerClientId == clientId || (!isServerAuthoritative && clientId == ownerClientId) ||
+                            (!networkManager.DistributedAuthorityMode && !networkObject.Observers.Contains(clientId)))
                         {
                             continue;
                         }
+
                         networkManager.MessageManager.SendMessage(ref currentMessage, networkDelivery, clientId);
                     }
                     // Dispose of the reader used for forwarding
@@ -105,12 +185,21 @@ namespace Unity.Netcode
 
         public void Handle(ref NetworkContext context)
         {
+            var networkManager = context.SystemOwner as NetworkManager;
+            // Only if the local NetworkManager instance is running as the DAHost we just exit if there is no local
+            // NetworkTransform component to apply the state update to (i.e. it is hidden from the DAHost and it
+            // just forwarded the state update to any other connected client)
+            if (networkManager.DAHost && m_ReceiverNetworkTransform == null)
+            {
+                return;
+            }
+
             if (m_ReceiverNetworkTransform == null)
             {
                 Debug.LogError($"[{nameof(NetworkTransformMessage)}][Dropped] Reciever {nameof(NetworkTransform)} was not set!");
                 return;
             }
-            m_ReceiverNetworkTransform.TransformStateUpdate(ref State);
+            m_ReceiverNetworkTransform.TransformStateUpdate(ref State, context.SenderId);
         }
     }
 }

Components/NetworkAnimator.cs

@@ -25,26 +25,48 @@ namespace Unity.Netcode.Components
         {
             foreach (var animationUpdate in m_SendAnimationUpdates)
             {
-                m_NetworkAnimator.SendAnimStateClientRpc(animationUpdate.AnimationMessage, animationUpdate.ClientRpcParams);
+
+                if (m_NetworkAnimator.NetworkManager.DistributedAuthorityMode)
+                {
+                    m_NetworkAnimator.SendAnimStateRpc(animationUpdate.AnimationMessage);
+                }
+                else
+                {
+                    m_NetworkAnimator.SendAnimStateClientRpc(animationUpdate.AnimationMessage, animationUpdate.ClientRpcParams);
+                }
             }
 
             m_SendAnimationUpdates.Clear();
 
             foreach (var sendEntry in m_SendParameterUpdates)
             {
-                m_NetworkAnimator.SendParametersUpdateClientRpc(sendEntry.ParametersUpdateMessage, sendEntry.ClientRpcParams);
+                if (m_NetworkAnimator.NetworkManager.DistributedAuthorityMode)
+                {
+                    m_NetworkAnimator.SendParametersUpdateRpc(sendEntry.ParametersUpdateMessage);
+                }
+                else
+                {
+                    m_NetworkAnimator.SendParametersUpdateClientRpc(sendEntry.ParametersUpdateMessage, sendEntry.ClientRpcParams);
+                }
             }
             m_SendParameterUpdates.Clear();
 
             foreach (var sendEntry in m_SendTriggerUpdates)
             {
-                if (!sendEntry.SendToServer)
+                if (m_NetworkAnimator.NetworkManager.DistributedAuthorityMode)
                 {
-                    m_NetworkAnimator.SendAnimTriggerClientRpc(sendEntry.AnimationTriggerMessage, sendEntry.ClientRpcParams);
+                    m_NetworkAnimator.SendAnimTriggerRpc(sendEntry.AnimationTriggerMessage);
                 }
                 else
                 {
-                    m_NetworkAnimator.SendAnimTriggerServerRpc(sendEntry.AnimationTriggerMessage);
+                    if (!sendEntry.SendToServer)
+                    {
+                        m_NetworkAnimator.SendAnimTriggerClientRpc(sendEntry.AnimationTriggerMessage, sendEntry.ClientRpcParams);
+                    }
+                    else
+                    {
+                        m_NetworkAnimator.SendAnimTriggerServerRpc(sendEntry.AnimationTriggerMessage);
+                    }
                 }
             }
             m_SendTriggerUpdates.Clear();
@@ -164,6 +186,7 @@ namespace Unity.Netcode.Components
     /// NetworkAnimator enables remote synchronization of <see cref="UnityEngine.Animator"/> state for on network objects.
     /// </summary>
     [AddComponentMenu("Netcode/Network Animator")]
+    [RequireComponent(typeof(Animator))]
     public class NetworkAnimator : NetworkBehaviour, ISerializationCallbackReceiver
     {
         [Serializable]
@@ -651,17 +674,14 @@ namespace Unity.Netcode.Components
                 NetworkLog.LogWarningServer($"[{gameObject.name}][{nameof(NetworkAnimator)}] {nameof(Animator)} is not assigned! Animation synchronization will not work for this instance!");
             }
 
-            if (IsServer)
+            m_ClientSendList = new List<ulong>(128);
+            m_ClientRpcParams = new ClientRpcParams
             {
-                m_ClientSendList = new List<ulong>(128);
+                Send = new ClientRpcSendParams
-                m_ClientRpcParams = new ClientRpcParams
                 {
-                    Send = new ClientRpcSendParams
+                    TargetClientIds = m_ClientSendList
-                    {
+                }
-                        TargetClientIds = m_ClientSendList
+            };
-                    }
-                };
-            }
 
             // Create a handler for state changes
             m_NetworkAnimatorStateChangeHandler = new NetworkAnimatorStateChangeHandler(this);
@@ -832,12 +852,7 @@ namespace Unity.Netcode.Components
                     stateChangeDetected = true;
                     //Debug.Log($"[Cross-Fade] To-Hash: {nt.fullPathHash} | TI-Duration: ({tt.duration}) | TI-Norm: ({tt.normalizedTime}) | From-Hash: ({m_AnimationHash[layer]}) | SI-FPHash: ({st.fullPathHash}) | SI-Norm: ({st.normalizedTime})");
                 }
-                // If we are not transitioned into the "any state" and the animator transition isn't a full path hash (layer to layer) and our pre-built destination state to transition does not contain the
+                else if (!tt.anyState && tt.fullPathHash != m_TransitionHash[layer])
-                // current layer (i.e. transitioning into a state from another layer) =or= we do contain the layer and the layer contains state to transition to is contained within our pre-built destination
-                // state then we can handle this transition as a non-cross fade state transition between layers.
-                // Otherwise, if we don't enter into this then this is a "trigger transition to some state that is now being transitioned back to the Idle state via trigger" or "Dual Triggers" IDLE<-->State.
-                else if (!tt.anyState && tt.fullPathHash != m_TransitionHash[layer] && (!m_DestinationStateToTransitioninfo.ContainsKey(layer) ||
-                    (m_DestinationStateToTransitioninfo.ContainsKey(layer) && m_DestinationStateToTransitioninfo[layer].ContainsKey(nt.fullPathHash))))
                 {
                     // first time in this transition for this layer
                     m_TransitionHash[layer] = tt.fullPathHash;
@@ -846,10 +861,6 @@ namespace Unity.Netcode.Components
                     animState.CrossFade = false;
                     animState.Transition = true;
                     animState.NormalizedTime = tt.normalizedTime;
-                    if (m_DestinationStateToTransitioninfo.ContainsKey(layer) && m_DestinationStateToTransitioninfo[layer].ContainsKey(nt.fullPathHash))
-                    {
-                        animState.DestinationStateHash = nt.fullPathHash;
-                    }
                     stateChangeDetected = true;
                     //Debug.Log($"[Transition] TI-Duration: ({tt.duration}) | TI-Norm: ({tt.normalizedTime}) | From-Hash: ({m_AnimationHash[layer]}) |SI-FPHash: ({st.fullPathHash}) | SI-Norm: ({st.normalizedTime})");
                 }
@@ -916,6 +927,11 @@ namespace Unity.Netcode.Components
             // Send an AnimationMessage only if there are dirty AnimationStates to send
             if (m_AnimationMessage.IsDirtyCount > 0)
             {
+                if (NetworkManager.DistributedAuthorityMode)
+                {
+                    SendAnimStateRpc(m_AnimationMessage);
+                }
+                else
                 if (!IsServer && IsOwner)
                 {
                     SendAnimStateServerRpc(m_AnimationMessage);
@@ -940,20 +956,33 @@ namespace Unity.Netcode.Components
             {
                 Parameters = m_ParameterWriter.ToArray()
             };
-
+            if (NetworkManager.DistributedAuthorityMode)
-            if (!IsServer)
             {
-                SendParametersUpdateServerRpc(parametersMessage);
+                if (IsOwner)
-            }
-            else
-            {
-                if (sendDirect)
                 {
-                    SendParametersUpdateClientRpc(parametersMessage, clientRpcParams);
+                    SendParametersUpdateRpc(parametersMessage);
                 }
                 else
                 {
-                    m_NetworkAnimatorStateChangeHandler.SendParameterUpdate(parametersMessage, clientRpcParams);
+                    Debug.LogError($"[{name}][Client-{NetworkManager.LocalClientId}] Attempting to send parameter updates but not the owner!");
+                }
+            }
+            else
+            {
+                if (!IsServer)
+                {
+                    SendParametersUpdateServerRpc(parametersMessage);
+                }
+                else
+                {
+                    if (sendDirect)
+                    {
+                        SendParametersUpdateClientRpc(parametersMessage, clientRpcParams);
+                    }
+                    else
+                    {
+                        m_NetworkAnimatorStateChangeHandler.SendParameterUpdate(parametersMessage, clientRpcParams);
+                    }
                 }
             }
         }
@@ -1233,10 +1262,19 @@ namespace Unity.Netcode.Components
         }
 
         /// <summary>
-        /// Updates the client's animator's parameters
+        /// Distributed Authority: Updates the client's animator's parameters
+        /// </summary>
+        [Rpc(SendTo.NotAuthority)]
+        internal void SendParametersUpdateRpc(ParametersUpdateMessage parametersUpdate)
+        {
+            m_NetworkAnimatorStateChangeHandler.ProcessParameterUpdate(parametersUpdate);
+        }
+
+        /// <summary>
+        /// Client-Server: Updates the client's animator's parameters
         /// </summary>
         [ClientRpc]
-        internal unsafe void SendParametersUpdateClientRpc(ParametersUpdateMessage parametersUpdate, ClientRpcParams clientRpcParams = default)
+        internal void SendParametersUpdateClientRpc(ParametersUpdateMessage parametersUpdate, ClientRpcParams clientRpcParams = default)
         {
             var isServerAuthoritative = IsServerAuthoritative();
             if (!isServerAuthoritative && !IsOwner || isServerAuthoritative)
@@ -1250,7 +1288,7 @@ namespace Unity.Netcode.Components
         /// The server sets its local state and then forwards the message to the remaining clients
         /// </summary>
         [ServerRpc]
-        private unsafe void SendAnimStateServerRpc(AnimationMessage animationMessage, ServerRpcParams serverRpcParams = default)
+        private void SendAnimStateServerRpc(AnimationMessage animationMessage, ServerRpcParams serverRpcParams = default)
         {
             if (IsServerAuthoritative())
             {
@@ -1281,26 +1319,44 @@ namespace Unity.Netcode.Components
         }
 
         /// <summary>
-        /// Internally-called RPC client receiving function to update some animation state on a client
+        /// Client-Server: Internally-called RPC client-side receiving function to update animation states
         /// </summary>
         [ClientRpc]
-        internal unsafe void SendAnimStateClientRpc(AnimationMessage animationMessage, ClientRpcParams clientRpcParams = default)
+        internal void SendAnimStateClientRpc(AnimationMessage animationMessage, ClientRpcParams clientRpcParams = default)
         {
-            // This should never happen
+            ProcessAnimStates(animationMessage);
-            if (IsHost)
+        }
+
+        /// <summary>
+        /// Distributed Authority: Internally-called RPC non-authority receiving function to update animation states
+        /// </summary>
+        [Rpc(SendTo.NotAuthority)]
+        internal void SendAnimStateRpc(AnimationMessage animationMessage)
+        {
+            ProcessAnimStates(animationMessage);
+        }
+
+        private void ProcessAnimStates(AnimationMessage animationMessage)
+        {
+            if (HasAuthority)
             {
                 if (NetworkManager.LogLevel == LogLevel.Developer)
                 {
-                    NetworkLog.LogWarning("Detected the Host is sending itself animation updates! Please report this issue.");
+                    var hostOrOwner = NetworkManager.DistributedAuthorityMode ? "Owner" : "Host";
+                    var clientServerOrDAMode = NetworkManager.DistributedAuthorityMode ? "distributed authority" : "client-server";
+                    NetworkLog.LogWarning($"Detected the {hostOrOwner} is sending itself animation updates in {clientServerOrDAMode} mode! Please report this issue.");
                 }
                 return;
             }
+
             foreach (var animationState in animationMessage.AnimationStates)
             {
                 UpdateAnimationState(animationState);
             }
         }
 
+
+
         /// <summary>
         /// Server-side trigger state update request
         /// The server sets its local state and then forwards the message to the remaining clients
@@ -1345,7 +1401,18 @@ namespace Unity.Netcode.Components
         }
 
         /// <summary>
-        /// Internally-called RPC client receiving function to update a trigger when the server wants to forward
+        /// Distributed Authority: Internally-called RPC client receiving function to update a trigger when the server wants to forward
+        ///   a trigger for a client to play / reset
+        /// </summary>
+        /// <param name="animationTriggerMessage">the payload containing the trigger data to apply</param>
+        [Rpc(SendTo.NotAuthority)]
+        internal void SendAnimTriggerRpc(AnimationTriggerMessage animationTriggerMessage)
+        {
+            InternalSetTrigger(animationTriggerMessage.Hash, animationTriggerMessage.IsTriggerSet);
+        }
+
+        /// <summary>
+        /// Client Server: Internally-called RPC client receiving function to update a trigger when the server wants to forward
         ///   a trigger for a client to play / reset
         /// </summary>
         /// <param name="animationTriggerMessage">the payload containing the trigger data to apply</param>
@@ -1370,15 +1437,26 @@ namespace Unity.Netcode.Components
         /// <param name="setTrigger">sets (true) or resets (false) the trigger. The default is to set it (true).</param>
         public void SetTrigger(int hash, bool setTrigger = true)
         {
+            if (!IsSpawned)
+            {
+                NetworkLog.LogError($"[{gameObject.name}] Cannot set a synchronized trigger when the {nameof(NetworkObject)} is not spawned!");
+                return;
+            }
+
             // MTT-3564:
             // After fixing the issue with trigger controlled Transitions being synchronized twice,
             // it exposed additional issues with this logic.  Now, either the owner or the server can
             // update triggers. Since server-side RPCs are immediately invoked, for a host a trigger
             // will happen when SendAnimTriggerClientRpc is called.  For a client owner, we call the
             // SendAnimTriggerServerRpc and then trigger locally when running in owner authority mode.
-            if (IsOwner || IsServer)
+            var animTriggerMessage = new AnimationTriggerMessage() { Hash = hash, IsTriggerSet = setTrigger };
+            if (NetworkManager.DistributedAuthorityMode && HasAuthority)
+            {
+                m_NetworkAnimatorStateChangeHandler.QueueTriggerUpdateToClient(animTriggerMessage);
+                InternalSetTrigger(hash, setTrigger);
+            }
+            else if (!NetworkManager.DistributedAuthorityMode && (IsOwner || IsServer))
             {
-                var animTriggerMessage = new AnimationTriggerMessage() { Hash = hash, IsTriggerSet = setTrigger };
                 if (IsServer)
                 {
                     /// <see cref="UpdatePendingTriggerStates"/> as to why we queue

Components/NetworkDeltaPosition.cs

@@ -32,13 +32,9 @@ namespace Unity.Netcode.Components
         /// </summary>
         public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
         {
-            if (!SynchronizeBase)
+            HalfVector3.NetworkSerialize(serializer);
+            if (SynchronizeBase)
             {
-                HalfVector3.NetworkSerialize(serializer);
-            }
-            else
-            {
-                serializer.SerializeValue(ref DeltaPosition);
                 serializer.SerializeValue(ref CurrentBasePosition);
             }
         }

Components/NetworkRigidBodyBase.cs

@@ -0,0 +1,535 @@
+#if COM_UNITY_MODULES_PHYSICS
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+    /// <summary>
+    /// NetworkRigidbodyBase is a unified <see cref="Rigidbody"/> and <see cref="Rigidbody2D"/> integration that helps to synchronize physics motion, collision, and interpolation
+    /// when used with a <see cref="NetworkTransform"/>.
+    /// </summary>
+    /// <remarks>
+    /// For a customizable netcode Rigidbody, create your own component from this class and use <see cref="Initialize(RigidbodyTypes, NetworkTransform, Rigidbody2D, Rigidbody)"/>
+    /// during instantiation (i.e. invoked from within the Awake method). You can re-initialize after having initialized but only when the <see cref="NetworkObject"/> is not spawned.
+    /// </remarks>
+    public abstract class NetworkRigidbodyBase : NetworkBehaviour
+    {
+        /// <summary>
+        /// When enabled, the associated <see cref="NetworkTransform"/> will use the Rigidbody/Rigidbody2D to apply and synchronize changes in position, rotation, and
+        /// allows for the use of Rigidbody interpolation/extrapolation.
+        /// </summary>
+        /// <remarks>
+        /// If <see cref="NetworkTransform.Interpolate"/> is enabled, non-authoritative instances can only use Rigidbody interpolation. If a network prefab is set to
+        /// extrapolation and <see cref="NetworkTransform.Interpolate"/> is enabled, then non-authoritative instances will automatically be adjusted to use Rigidbody
+        /// interpolation while the authoritative instance will still use extrapolation.
+        /// </remarks>
+        public bool UseRigidBodyForMotion;
+
+        /// <summary>
+        /// When enabled (default), automatically set the Kinematic state of the Rigidbody based on ownership.
+        /// When disabled, Kinematic state needs to be set by external script(s).
+        /// </summary>
+        public bool AutoUpdateKinematicState = true;
+
+        /// <summary>
+        /// Primarily applies to the <see cref="AutoUpdateKinematicState"/> property when disabled but you still want
+        /// the Rigidbody to be automatically set to Kinematic when despawned.
+        /// </summary>
+        public bool AutoSetKinematicOnDespawn = true;
+
+        // Determines if this is a Rigidbody or Rigidbody2D implementation
+        private bool m_IsRigidbody2D => RigidbodyType == RigidbodyTypes.Rigidbody2D;
+        // Used to cache the authority state of this Rigidbody during the last frame
+        private bool m_IsAuthority;
+        private Rigidbody m_Rigidbody;
+        private Rigidbody2D m_Rigidbody2D;
+        private NetworkTransform m_NetworkTransform;
+        private enum InterpolationTypes
+        {
+            None,
+            Interpolate,
+            Extrapolate
+        }
+        private InterpolationTypes m_OriginalInterpolation;
+
+        /// <summary>
+        /// Used to define the type of Rigidbody implemented.
+        /// <see cref=""/>
+        /// </summary>
+        public enum RigidbodyTypes
+        {
+            Rigidbody,
+            Rigidbody2D,
+        }
+
+        public RigidbodyTypes RigidbodyType { get; private set; }
+
+        /// <summary>
+        /// Initializes the networked Rigidbody based on the <see cref="RigidbodyTypes"/>
+        /// passed in as a parameter.
+        /// </summary>
+        /// <remarks>
+        /// Cannot be initialized while the associated <see cref="NetworkObject"/> is spawned.
+        /// </remarks>
+        /// <param name="rigidbodyType">type of rigid body being initialized</param>
+        /// <param name="rigidbody2D">(optional) The <see cref="Rigidbody2D"/> to be used</param>
+        /// <param name="rigidbody">(optional) The <see cref="Rigidbody"/> to be used</param>
+        protected void Initialize(RigidbodyTypes rigidbodyType, NetworkTransform networkTransform = null, Rigidbody2D rigidbody2D = null, Rigidbody rigidbody = null)
+        {
+            // Don't initialize if already spawned
+            if (IsSpawned)
+            {
+                Debug.LogError($"[{name}] Attempting to initialize while spawned is not allowed.");
+                return;
+            }
+            RigidbodyType = rigidbodyType;
+            m_Rigidbody2D = rigidbody2D;
+            m_Rigidbody = rigidbody;
+            m_NetworkTransform = networkTransform;
+
+            if (m_IsRigidbody2D && m_Rigidbody2D == null)
+            {
+                m_Rigidbody2D = GetComponent<Rigidbody2D>();
+
+            }
+            else if (m_Rigidbody == null)
+            {
+                m_Rigidbody = GetComponent<Rigidbody>();
+            }
+
+            SetOriginalInterpolation();
+
+            if (m_NetworkTransform == null)
+            {
+                m_NetworkTransform = GetComponent<NetworkTransform>();
+            }
+
+            if (m_NetworkTransform != null)
+            {
+                m_NetworkTransform.RegisterRigidbody(this);
+            }
+            else
+            {
+                throw new System.Exception($"[Missing {nameof(NetworkTransform)}] No {nameof(NetworkTransform)} is assigned or can be found during initialization!");
+            }
+
+            if (AutoUpdateKinematicState)
+            {
+                SetIsKinematic(true);
+            }
+        }
+
+        /// <summary>
+        /// Gets the position of the Rigidbody
+        /// </summary>
+        /// <returns><see cref="Vector3"/></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 GetPosition()
+        {
+            if (m_IsRigidbody2D)
+            {
+                return m_Rigidbody2D.position;
+            }
+            else
+            {
+                return m_Rigidbody.position;
+            }
+        }
+
+        /// <summary>
+        /// Gets the rotation of the Rigidbody
+        /// </summary>
+        /// <returns><see cref="Quaternion"/></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Quaternion GetRotation()
+        {
+            if (m_IsRigidbody2D)
+            {
+                var quaternion = Quaternion.identity;
+                var angles = quaternion.eulerAngles;
+                angles.z = m_Rigidbody2D.rotation;
+                quaternion.eulerAngles = angles;
+                return quaternion;
+            }
+            else
+            {
+                return m_Rigidbody.rotation;
+            }
+        }
+
+        /// <summary>
+        /// Moves the rigid body
+        /// </summary>
+        /// <param name="position">The <see cref="Vector3"/> position to move towards</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void MovePosition(Vector3 position)
+        {
+            if (m_IsRigidbody2D)
+            {
+                m_Rigidbody2D.MovePosition(position);
+            }
+            else
+            {
+                m_Rigidbody.MovePosition(position);
+            }
+        }
+
+        /// <summary>
+        /// Directly applies a position (like teleporting)
+        /// </summary>
+        /// <param name="position"><see cref="Vector3"/> position to apply to the Rigidbody</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetPosition(Vector3 position)
+        {
+            if (m_IsRigidbody2D)
+            {
+                m_Rigidbody2D.position = position;
+            }
+            else
+            {
+                m_Rigidbody.position = position;
+            }
+        }
+
+        /// <summary>
+        /// Applies the rotation and position of the <see cref="GameObject"/>'s <see cref="Transform"/>
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ApplyCurrentTransform()
+        {
+            if (m_IsRigidbody2D)
+            {
+                m_Rigidbody2D.position = transform.position;
+                m_Rigidbody2D.rotation = transform.eulerAngles.z;
+            }
+            else
+            {
+                m_Rigidbody.position = transform.position;
+                m_Rigidbody.rotation = transform.rotation;
+            }
+        }
+
+        /// <summary>
+        /// Rotatates the Rigidbody towards a specified rotation
+        /// </summary>
+        /// <param name="rotation">The rotation expressed as a <see cref="Quaternion"/></param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void MoveRotation(Quaternion rotation)
+        {
+            if (m_IsRigidbody2D)
+            {
+                m_Rigidbody2D.MoveRotation(rotation);
+            }
+            else
+            {
+                m_Rigidbody.MoveRotation(rotation);
+            }
+        }
+
+        /// <summary>
+        /// Applies a rotation to the Rigidbody
+        /// </summary>
+        /// <param name="rotation">The rotation to apply expressed as a <see cref="Quaternion"/></param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetRotation(Quaternion rotation)
+        {
+            if (m_IsRigidbody2D)
+            {
+                m_Rigidbody2D.rotation = rotation.eulerAngles.z;
+            }
+            else
+            {
+                m_Rigidbody.rotation = rotation;
+            }
+        }
+
+        /// <summary>
+        /// Sets the original interpolation of the Rigidbody while taking the Rigidbody type into consideration
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void SetOriginalInterpolation()
+        {
+            if (m_IsRigidbody2D)
+            {
+                switch (m_Rigidbody2D.interpolation)
+                {
+                    case RigidbodyInterpolation2D.None:
+                        {
+                            m_OriginalInterpolation = InterpolationTypes.None;
+                            break;
+                        }
+                    case RigidbodyInterpolation2D.Interpolate:
+                        {
+                            m_OriginalInterpolation = InterpolationTypes.Interpolate;
+                            break;
+                        }
+                    case RigidbodyInterpolation2D.Extrapolate:
+                        {
+                            m_OriginalInterpolation = InterpolationTypes.Extrapolate;
+                            break;
+                        }
+                }
+            }
+            else
+            {
+                switch (m_Rigidbody.interpolation)
+                {
+                    case RigidbodyInterpolation.None:
+                        {
+                            m_OriginalInterpolation = InterpolationTypes.None;
+                            break;
+                        }
+                    case RigidbodyInterpolation.Interpolate:
+                        {
+                            m_OriginalInterpolation = InterpolationTypes.Interpolate;
+                            break;
+                        }
+                    case RigidbodyInterpolation.Extrapolate:
+                        {
+                            m_OriginalInterpolation = InterpolationTypes.Extrapolate;
+                            break;
+                        }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Wakes the Rigidbody if it is sleeping
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WakeIfSleeping()
+        {
+            if (m_IsRigidbody2D)
+            {
+                if (m_Rigidbody2D.IsSleeping())
+                {
+                    m_Rigidbody2D.WakeUp();
+                }
+            }
+            else
+            {
+                if (m_Rigidbody.IsSleeping())
+                {
+                    m_Rigidbody.WakeUp();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Puts the Rigidbody to sleep
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SleepRigidbody()
+        {
+            if (m_IsRigidbody2D)
+            {
+                m_Rigidbody2D.Sleep();
+            }
+            else
+            {
+                m_Rigidbody.Sleep();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool IsKinematic()
+        {
+            if (m_IsRigidbody2D)
+            {
+                return m_Rigidbody2D.isKinematic;
+            }
+            else
+            {
+                return m_Rigidbody.isKinematic;
+            }
+        }
+
+        /// <summary>
+        /// Sets the kinematic state of the Rigidbody and handles updating the Rigidbody's
+        /// interpolation setting based on the Kinematic state.
+        /// </summary>
+        /// <remarks>
+        /// When using the Rigidbody for <see cref="NetworkTransform"/> motion, this automatically
+        /// adjusts from extrapolation to interpolation if:
+        /// - The Rigidbody was originally set to extrapolation
+        /// - The NetworkTransform is set to interpolate
+        /// When the two above conditions are true:
+        /// - When switching from non-kinematic to kinematic this will automatically
+        /// switch the Rigidbody from extrapolation to interpolate.
+        /// - When switching from kinematic to non-kinematic this will automatically
+        /// switch the Rigidbody from interpolation back to extrapolation.
+        /// </remarks>
+        /// <param name="isKinematic"></param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetIsKinematic(bool isKinematic)
+        {
+            if (m_IsRigidbody2D)
+            {
+                m_Rigidbody2D.isKinematic = isKinematic;
+            }
+            else
+            {
+                m_Rigidbody.isKinematic = isKinematic;
+            }
+
+            // If we are not spawned, then exit early
+            if (!IsSpawned)
+            {
+                return;
+            }
+
+            if (UseRigidBodyForMotion)
+            {
+                // Only if the NetworkTransform is set to interpolate do we need to check for extrapolation
+                if (m_NetworkTransform.Interpolate && m_OriginalInterpolation == InterpolationTypes.Extrapolate)
+                {
+                    if (IsKinematic())
+                    {
+                        // If not already set to interpolate then set the Rigidbody to interpolate 
+                        if (m_Rigidbody.interpolation == RigidbodyInterpolation.Extrapolate)
+                        {
+                            // Sleep until the next fixed update when switching from extrapolation to interpolation
+                            SleepRigidbody();
+                            SetInterpolation(InterpolationTypes.Interpolate);
+                        }
+                    }
+                    else
+                    {
+                        // Switch it back to the original interpolation if non-kinematic (doesn't require sleep).
+                        SetInterpolation(m_OriginalInterpolation);
+                    }
+                }
+            }
+            else
+            {
+                SetInterpolation(m_IsAuthority ? m_OriginalInterpolation : (m_NetworkTransform.Interpolate ? InterpolationTypes.None : m_OriginalInterpolation));
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void SetInterpolation(InterpolationTypes interpolationType)
+        {
+            switch (interpolationType)
+            {
+                case InterpolationTypes.None:
+                    {
+                        if (m_IsRigidbody2D)
+                        {
+                            m_Rigidbody2D.interpolation = RigidbodyInterpolation2D.None;
+                        }
+                        else
+                        {
+                            m_Rigidbody.interpolation = RigidbodyInterpolation.None;
+                        }
+                        break;
+                    }
+                case InterpolationTypes.Interpolate:
+                    {
+                        if (m_IsRigidbody2D)
+                        {
+                            m_Rigidbody2D.interpolation = RigidbodyInterpolation2D.Interpolate;
+                        }
+                        else
+                        {
+                            m_Rigidbody.interpolation = RigidbodyInterpolation.Interpolate;
+                        }
+                        break;
+                    }
+                case InterpolationTypes.Extrapolate:
+                    {
+                        if (m_IsRigidbody2D)
+                        {
+                            m_Rigidbody2D.interpolation = RigidbodyInterpolation2D.Extrapolate;
+                        }
+                        else
+                        {
+                            m_Rigidbody.interpolation = RigidbodyInterpolation.Extrapolate;
+                        }
+                        break;
+                    }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ResetInterpolation()
+        {
+            SetInterpolation(m_OriginalInterpolation);
+        }
+
+        protected override void OnOwnershipChanged(ulong previous, ulong current)
+        {
+            UpdateOwnershipAuthority();
+            base.OnOwnershipChanged(previous, current);
+        }
+
+        /// <summary>
+        /// Sets the authority based on whether it is server or owner authoritative
+        /// </summary>
+        /// <remarks>
+        /// Distributed authority sessions will always be owner authoritative.
+        /// </remarks>
+        internal void UpdateOwnershipAuthority()
+        {
+            if (NetworkManager.DistributedAuthorityMode)
+            {
+                // When in distributed authority mode, always use HasAuthority
+                m_IsAuthority = HasAuthority;
+            }
+            else
+            {
+                if (m_NetworkTransform.IsServerAuthoritative())
+                {
+                    m_IsAuthority = NetworkManager.IsServer;
+                }
+                else
+                {
+                    m_IsAuthority = IsOwner;
+                }
+            }
+
+            if (AutoUpdateKinematicState)
+            {
+                SetIsKinematic(!m_IsAuthority);
+            }
+        }
+
+        /// <inheritdoc />
+        public override void OnNetworkSpawn()
+        {
+            UpdateOwnershipAuthority();
+        }
+
+        /// <inheritdoc />
+        public override void OnNetworkDespawn()
+        {
+            // If we are automatically handling the kinematic state...
+            if (AutoUpdateKinematicState || AutoSetKinematicOnDespawn)
+            {
+                // Turn off physics for the rigid body until spawned, otherwise
+                // non-owners can run fixed updates before the first full
+                // NetworkTransform update and physics will be applied (i.e. gravity, etc)
+                SetIsKinematic(true);
+            }
+            SetInterpolation(m_OriginalInterpolation);
+        }
+
+        /// <summary>
+        /// When <see cref="UseRigidBodyForMotion"/> is enabled, the <see cref="NetworkTransform"/> will update Kinematic instances using
+        /// the Rigidbody's move methods allowing Rigidbody interpolation settings to be taken into consideration by the physics simulation.
+        /// </summary>
+        /// <remarks>
+        /// This will update the associated <see cref="NetworkTransform"/> during FixedUpdate which also avoids the added expense of adding
+        /// a FixedUpdate to all <see cref="NetworkTransform"/> instances where some might not be using a Rigidbody.
+        /// </remarks>
+        private void FixedUpdate()
+        {
+            if (!IsSpawned || m_NetworkTransform == null || !UseRigidBodyForMotion)
+            {
+                return;
+            }
+            m_NetworkTransform.OnFixedUpdate();
+        }
+    }
+}
+#endif // COM_UNITY_MODULES_PHYSICS
+

Components/NetworkRigidBodyBase.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 2263d66f6df15a7428d279dbdaba1519
+guid: 8c4434f0563fb7f42b3b2993c97ae81a
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Components/NetworkRigidbody.cs

@@ -7,106 +7,14 @@ namespace Unity.Netcode.Components
     /// NetworkRigidbody allows for the use of <see cref="Rigidbody"/> on network objects. By controlling the kinematic
     /// mode of the <see cref="Rigidbody"/> and disabling it on all peers but the authoritative one.
     /// </summary>
-    [RequireComponent(typeof(Rigidbody))]
     [RequireComponent(typeof(NetworkTransform))]
+    [RequireComponent(typeof(Rigidbody))]
     [AddComponentMenu("Netcode/Network Rigidbody")]
-    public class NetworkRigidbody : NetworkBehaviour
+    public class NetworkRigidbody : NetworkRigidbodyBase
     {
-        /// <summary>
+        protected virtual void Awake()
-        /// Determines if we are server (true) or owner (false) authoritative
-        /// </summary>
-        private bool m_IsServerAuthoritative;
-
-        private Rigidbody m_Rigidbody;
-        private NetworkTransform m_NetworkTransform;
-        private RigidbodyInterpolation m_OriginalInterpolation;
-
-        // Used to cache the authority state of this Rigidbody during the last frame
-        private bool m_IsAuthority;
-
-        private void Awake()
         {
-            m_NetworkTransform = GetComponent<NetworkTransform>();
+            Initialize(RigidbodyTypes.Rigidbody);
-            m_IsServerAuthoritative = m_NetworkTransform.IsServerAuthoritative();
-
-            SetupRigidBody();
-        }
-
-        /// <summary>
-        /// If the current <see cref="NetworkTransform"/> has authority,
-        /// then use the <see cref="RigidBody"/> interpolation strategy,
-        /// if the <see cref="NetworkTransform"/> is handling interpolation,
-        /// set interpolation to none on the <see cref="RigidBody"/>
-        /// <br/>
-        /// Turn off physics for the rigid body until spawned, otherwise
-        /// clients can run fixed update before the first
-        /// full <see cref="NetworkTransform"/> update
-        /// </summary>
-        private void SetupRigidBody()
-        {
-            m_Rigidbody = GetComponent<Rigidbody>();
-            m_OriginalInterpolation = m_Rigidbody.interpolation;
-
-            m_Rigidbody.interpolation = m_IsAuthority ? m_OriginalInterpolation : (m_NetworkTransform.Interpolate ? RigidbodyInterpolation.None : m_OriginalInterpolation);
-            m_Rigidbody.isKinematic = true;
-        }
-
-        /// <summary>
-        /// For owner authoritative (i.e. ClientNetworkTransform)
-        /// we adjust our authority when we gain ownership
-        /// </summary>
-        public override void OnGainedOwnership()
-        {
-            UpdateOwnershipAuthority();
-        }
-
-        /// <summary>
-        /// For owner authoritative(i.e. ClientNetworkTransform)
-        /// we adjust our authority when we have lost ownership
-        /// </summary>
-        public override void OnLostOwnership()
-        {
-            UpdateOwnershipAuthority();
-        }
-
-        /// <summary>
-        /// Sets the authority differently depending upon
-        /// whether it is server or owner authoritative
-        /// </summary>
-        private void UpdateOwnershipAuthority()
-        {
-            if (m_IsServerAuthoritative)
-            {
-                m_IsAuthority = NetworkManager.IsServer;
-            }
-            else
-            {
-                m_IsAuthority = IsOwner;
-            }
-
-            // If you have authority then you are not kinematic
-            m_Rigidbody.isKinematic = !m_IsAuthority;
-
-            // Set interpolation of the Rigidbody based on authority
-            // With authority: let local transform handle interpolation
-            // Without authority: let the NetworkTransform handle interpolation
-            m_Rigidbody.interpolation = m_IsAuthority ? m_OriginalInterpolation : RigidbodyInterpolation.None;
-        }
-
-        /// <inheritdoc />
-        public override void OnNetworkSpawn()
-        {
-            UpdateOwnershipAuthority();
-        }
-
-        /// <inheritdoc />
-        public override void OnNetworkDespawn()
-        {
-            m_Rigidbody.interpolation = m_OriginalInterpolation;
-            // Turn off physics for the rigid body until spawned, otherwise
-            // non-owners can run fixed updates before the first full
-            // NetworkTransform update and physics will be applied (i.e. gravity, etc)
-            m_Rigidbody.isKinematic = true;
         }
     }
 }

Components/NetworkRigidbody2D.cs

@@ -7,106 +7,14 @@ namespace Unity.Netcode.Components
     /// NetworkRigidbody allows for the use of <see cref="Rigidbody2D"/> on network objects. By controlling the kinematic
     /// mode of the rigidbody and disabling it on all peers but the authoritative one.
     /// </summary>
-    [RequireComponent(typeof(Rigidbody2D))]
     [RequireComponent(typeof(NetworkTransform))]
+    [RequireComponent(typeof(Rigidbody2D))]
     [AddComponentMenu("Netcode/Network Rigidbody 2D")]
-    public class NetworkRigidbody2D : NetworkBehaviour
+    public class NetworkRigidbody2D : NetworkRigidbodyBase
     {
-        /// <summary>
+        protected virtual void Awake()
-        /// Determines if we are server (true) or owner (false) authoritative
-        /// </summary>
-        private bool m_IsServerAuthoritative;
-
-        private Rigidbody2D m_Rigidbody;
-        private NetworkTransform m_NetworkTransform;
-
-        private RigidbodyInterpolation2D m_OriginalInterpolation;
-
-        // Used to cache the authority state of this rigidbody during the last frame
-        private bool m_IsAuthority;
-
-        private void Awake()
         {
-            m_NetworkTransform = GetComponent<NetworkTransform>();
+            Initialize(RigidbodyTypes.Rigidbody2D);
-            m_IsServerAuthoritative = m_NetworkTransform.IsServerAuthoritative();
-
-            SetupRigidBody();
-        }
-
-        /// <summary>
-        /// If the current <see cref="NetworkTransform"/> has authority,
-        /// then use the <see cref="Rigidbody2D"/> interpolation strategy,
-        /// if the <see cref="NetworkTransform"/> is handling interpolation,
-        /// set interpolation to none on the <see cref="Rigidbody2D"/>
-        /// <br/>
-        /// Turn off physics for the rigid body until spawned, otherwise
-        /// clients can run fixed update before the first
-        /// full <see cref="NetworkTransform"/> update
-        /// </summary>
-        private void SetupRigidBody()
-        {
-            m_Rigidbody = GetComponent<Rigidbody2D>();
-            m_OriginalInterpolation = m_Rigidbody.interpolation;
-
-            m_Rigidbody.interpolation = m_IsAuthority ? m_OriginalInterpolation : (m_NetworkTransform.Interpolate ? RigidbodyInterpolation2D.None : m_OriginalInterpolation);
-            // Turn off physics for the rigid body until spawned, otherwise
-            // clients can run fixed update before the first full
-            // NetworkTransform update
-            m_Rigidbody.isKinematic = true;
-        }
-
-        /// <summary>
-        /// For owner authoritative (i.e. ClientNetworkTransform)
-        /// we adjust our authority when we gain ownership
-        /// </summary>
-        public override void OnGainedOwnership()
-        {
-            UpdateOwnershipAuthority();
-        }
-
-        /// <summary>
-        /// For owner authoritative(i.e. ClientNetworkTransform)
-        /// we adjust our authority when we have lost ownership
-        /// </summary>
-        public override void OnLostOwnership()
-        {
-            UpdateOwnershipAuthority();
-        }
-
-        /// <summary>
-        /// Sets the authority differently depending upon
-        /// whether it is server or owner authoritative
-        /// </summary>
-        private void UpdateOwnershipAuthority()
-        {
-            if (m_IsServerAuthoritative)
-            {
-                m_IsAuthority = NetworkManager.IsServer;
-            }
-            else
-            {
-                m_IsAuthority = IsOwner;
-            }
-
-            // If you have authority then you are not kinematic
-            m_Rigidbody.isKinematic = !m_IsAuthority;
-
-            // Set interpolation of the Rigidbody2D based on authority
-            // With authority: let local transform handle interpolation
-            // Without authority: let the NetworkTransform handle interpolation
-            m_Rigidbody.interpolation = m_IsAuthority ? m_OriginalInterpolation : RigidbodyInterpolation2D.None;
-        }
-
-        /// <inheritdoc />
-        public override void OnNetworkSpawn()
-        {
-            UpdateOwnershipAuthority();
-        }
-
-        /// <inheritdoc />
-        public override void OnNetworkDespawn()
-        {
-            UpdateOwnershipAuthority();
         }
     }
 }

Components/RigidbodyContactEventManager.cs

@@ -0,0 +1,230 @@
+#if COM_UNITY_MODULES_PHYSICS
+using System.Collections.Generic;
+using Unity.Collections;
+using Unity.Jobs;
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+    public interface IContactEventHandler
+    {
+        Rigidbody GetRigidbody();
+
+        void ContactEvent(ulong eventId, Vector3 averagedCollisionNormal, Rigidbody collidingBody, Vector3 contactPoint, bool hasCollisionStay = false, Vector3 averagedCollisionStayNormal = default);
+    }
+
+    [AddComponentMenu("Netcode/Rigidbody Contact Event Manager")]
+    public class RigidbodyContactEventManager : MonoBehaviour
+    {
+        public static RigidbodyContactEventManager Instance { get; private set; }
+
+        private struct JobResultStruct
+        {
+            public bool HasCollisionStay;
+            public int ThisInstanceID;
+            public int OtherInstanceID;
+            public Vector3 AverageNormal;
+            public Vector3 AverageCollisionStayNormal;
+            public Vector3 ContactPoint;
+        }
+
+        private NativeArray<JobResultStruct> m_ResultsArray;
+        private int m_Count = 0;
+        private JobHandle m_JobHandle;
+
+        private readonly Dictionary<int, Rigidbody> m_RigidbodyMapping = new Dictionary<int, Rigidbody>();
+        private readonly Dictionary<int, IContactEventHandler> m_HandlerMapping = new Dictionary<int, IContactEventHandler>();
+
+        private void OnEnable()
+        {
+            m_ResultsArray = new NativeArray<JobResultStruct>(16, Allocator.Persistent);
+            Physics.ContactEvent += Physics_ContactEvent;
+            if (Instance != null)
+            {
+                NetworkLog.LogError($"[Invalid][Multiple Instances] Found more than one instance of {nameof(RigidbodyContactEventManager)}: {name} and {Instance.name}");
+                NetworkLog.LogError($"[Disable][Additional Instance] Disabling {name} instance!");
+                gameObject.SetActive(false);
+                return;
+            }
+            Instance = this;
+        }
+
+        public void RegisterHandler(IContactEventHandler contactEventHandler, bool register = true)
+        {
+            var rigidbody = contactEventHandler.GetRigidbody();
+            var instanceId = rigidbody.GetInstanceID();
+            if (register)
+            {
+                if (!m_RigidbodyMapping.ContainsKey(instanceId))
+                {
+                    m_RigidbodyMapping.Add(instanceId, rigidbody);
+                }
+
+                if (!m_HandlerMapping.ContainsKey(instanceId))
+                {
+                    m_HandlerMapping.Add(instanceId, contactEventHandler);
+                }
+            }
+            else
+            {
+                m_RigidbodyMapping.Remove(instanceId);
+                m_HandlerMapping.Remove(instanceId);
+            }
+        }
+
+        private void OnDisable()
+        {
+            m_JobHandle.Complete();
+            m_ResultsArray.Dispose();
+
+            Physics.ContactEvent -= Physics_ContactEvent;
+
+            m_RigidbodyMapping.Clear();
+            Instance = null;
+        }
+
+        private bool m_HasCollisions;
+        private int m_CurrentCount = 0;
+
+        private void ProcessCollisions()
+        {
+            // Process all collisions
+            for (int i = 0; i < m_Count; i++)
+            {
+                var thisInstanceID = m_ResultsArray[i].ThisInstanceID;
+                var otherInstanceID = m_ResultsArray[i].OtherInstanceID;
+                var rb0Valid = thisInstanceID != 0 && m_RigidbodyMapping.ContainsKey(thisInstanceID);
+                var rb1Valid = otherInstanceID != 0 && m_RigidbodyMapping.ContainsKey(otherInstanceID);
+                // Only notify registered rigid bodies.
+                if (!rb0Valid || !rb1Valid || !m_HandlerMapping.ContainsKey(thisInstanceID))
+                {
+                    continue;
+                }
+                if (m_ResultsArray[i].HasCollisionStay)
+                {
+                    m_HandlerMapping[thisInstanceID].ContactEvent(m_EventId, m_ResultsArray[i].AverageNormal, m_RigidbodyMapping[otherInstanceID], m_ResultsArray[i].ContactPoint, m_ResultsArray[i].HasCollisionStay, m_ResultsArray[i].AverageCollisionStayNormal);
+                }
+                else
+                {
+                    m_HandlerMapping[thisInstanceID].ContactEvent(m_EventId, m_ResultsArray[i].AverageNormal, m_RigidbodyMapping[otherInstanceID], m_ResultsArray[i].ContactPoint);
+                }
+            }
+        }
+
+        private void FixedUpdate()
+        {
+            // Only process new collisions
+            if (!m_HasCollisions && m_CurrentCount == 0)
+            {
+                return;
+            }
+
+            // This assures we won't process the same collision
+            // set after it has been processed.
+            if (m_HasCollisions)
+            {
+                m_CurrentCount = m_Count;
+                m_HasCollisions = false;
+                m_JobHandle.Complete();
+            }
+            ProcessCollisions();
+        }
+
+        private void LateUpdate()
+        {
+            m_CurrentCount = 0;
+        }
+
+        private ulong m_EventId;
+        private void Physics_ContactEvent(PhysicsScene scene, NativeArray<ContactPairHeader>.ReadOnly pairHeaders)
+        {
+            m_EventId++;
+            m_HasCollisions = true;
+            int n = pairHeaders.Length;
+            if (m_ResultsArray.Length < n)
+            {
+                m_ResultsArray.Dispose();
+                m_ResultsArray = new NativeArray<JobResultStruct>(Mathf.NextPowerOfTwo(n), Allocator.Persistent);
+            }
+            m_Count = n;
+            var job = new GetCollisionsJob()
+            {
+                PairedHeaders = pairHeaders,
+                ResultsArray = m_ResultsArray
+            };
+            m_JobHandle = job.Schedule(n, 256);
+        }
+
+        private struct GetCollisionsJob : IJobParallelFor
+        {
+            [ReadOnly]
+            public NativeArray<ContactPairHeader>.ReadOnly PairedHeaders;
+
+            public NativeArray<JobResultStruct> ResultsArray;
+
+            public void Execute(int index)
+            {
+                Vector3 averageNormal = Vector3.zero;
+                Vector3 averagePoint = Vector3.zero;
+                Vector3 averageCollisionStay = Vector3.zero;
+                int count = 0;
+                int collisionStaycount = 0;
+                int positionCount = 0;
+                for (int j = 0; j < PairedHeaders[index].pairCount; j++)
+                {
+                    ref readonly var pair = ref PairedHeaders[index].GetContactPair(j);
+
+                    if (pair.isCollisionExit)
+                    {
+                        continue;
+                    }
+
+                    for (int k = 0; k < pair.contactCount; k++)
+                    {
+                        ref readonly var contact = ref pair.GetContactPoint(k);
+                        averagePoint += contact.position;
+                        positionCount++;
+                        if (!pair.isCollisionStay)
+                        {
+                            averageNormal += contact.normal;
+                            count++;
+                        }
+                        else
+                        {
+                            averageCollisionStay += contact.normal;
+                            collisionStaycount++;
+                        }
+                    }
+                }
+
+                if (count != 0)
+                {
+                    averageNormal /= count;
+                }
+
+                if (collisionStaycount != 0)
+                {
+                    averageCollisionStay /= collisionStaycount;
+                }
+
+                if (positionCount != 0)
+                {
+                    averagePoint /= positionCount;
+                }
+
+                var result = new JobResultStruct()
+                {
+                    ThisInstanceID = PairedHeaders[index].bodyInstanceID,
+                    OtherInstanceID = PairedHeaders[index].otherBodyInstanceID,
+                    AverageNormal = averageNormal,
+                    HasCollisionStay = collisionStaycount != 0,
+                    AverageCollisionStayNormal = averageCollisionStay,
+                    ContactPoint = averagePoint
+                };
+
+                ResultsArray[index] = result;
+            }
+        }
+    }
+}
+#endif

Components/RigidbodyContactEventManager.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 939ac41f36685f84e94a4b66ebbb6d8c
+guid: 739e5cee846b6384988f9a47e4691836
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Editor/AnticipatedNetworkTransformEditor.cs

@@ -1,14 +0,0 @@
-using Unity.Netcode.Components;
-using UnityEditor;
-
-namespace Unity.Netcode.Editor
-{
-    /// <summary>
-    /// The <see cref="CustomEditor"/> for <see cref="AnticipatedNetworkTransform"/>
-    /// </summary>
-    [CustomEditor(typeof(AnticipatedNetworkTransform), true)]
-    public class AnticipatedNetworkTransformEditor : NetworkTransformEditor
-    {
-        public override bool HideInterpolateValue => true;
-    }
-}

Editor/AnticipatedNetworkTransformEditor.cs.meta

@@ -1,3 +0,0 @@
-fileFormatVersion: 2
-guid: 34bc168605014eeeadf97b12080e11fa
-timeCreated: 1707514321

Editor/CodeGen/NetworkBehaviourILPP.cs

@@ -408,7 +408,6 @@ namespace Unity.Netcode.Editor.CodeGen
                     }
                     else
                     {
-                        m_Diagnostics.AddError($"{type}: Managed type in NetworkVariable must implement IEquatable<{type}>");
                         equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedClassEquals_MethodRef);
                     }
 

Editor/Configuration/NetcodeSettingsProvider.cs

@@ -19,7 +19,7 @@ namespace Unity.Netcode.Editor.Configuration
         {
             // First parameter is the path in the Settings window.
             // Second parameter is the scope of this setting: it only appears in the Settings window for the Project scope.
-            var provider = new SettingsProvider("Project/NetcodeForGameObjects", SettingsScope.Project)
+            var provider = new SettingsProvider("Project/Multiplayer/NetcodeForGameObjects", SettingsScope.Project)
             {
                 label = "Netcode for GameObjects",
                 keywords = new[] { "netcode", "editor" },

Editor/NetworkManagerEditor.cs

@@ -1,6 +1,3 @@
-#if UNITY_2022_3_OR_NEWER && (RELAY_SDK_INSTALLED && !UNITY_WEBGL ) || (RELAY_SDK_INSTALLED && UNITY_WEBGL && UTP_TRANSPORT_2_0_ABOVE)
-#define RELAY_INTEGRATION_AVAILABLE
-#endif
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -33,7 +30,7 @@ namespace Unity.Netcode.Editor
         private SerializedProperty m_ProtocolVersionProperty;
         private SerializedProperty m_NetworkTransportProperty;
         private SerializedProperty m_TickRateProperty;
-        private SerializedProperty m_MaxObjectUpdatesPerTickProperty;
+        private SerializedProperty m_SessionModeProperty;
         private SerializedProperty m_ClientConnectionBufferTimeoutProperty;
         private SerializedProperty m_ConnectionApprovalProperty;
         private SerializedProperty m_EnsureNetworkVariableLengthSafetyProperty;
@@ -41,6 +38,7 @@ namespace Unity.Netcode.Editor
         private SerializedProperty m_EnableSceneManagementProperty;
         private SerializedProperty m_RecycleNetworkIdsProperty;
         private SerializedProperty m_NetworkIdRecycleDelayProperty;
+        private SerializedProperty m_SpawnTimeOutProperty;
         private SerializedProperty m_RpcHashSizeProperty;
         private SerializedProperty m_LoadSceneTimeOutProperty;
         private SerializedProperty m_PrefabsList;
@@ -51,27 +49,6 @@ namespace Unity.Netcode.Editor
         private readonly List<Type> m_TransportTypes = new List<Type>();
         private string[] m_TransportNames = { "Select transport..." };
 
-        /// <inheritdoc/>
-        public override void OnInspectorGUI()
-        {
-            Initialize();
-            CheckNullProperties();
-
-#if !MULTIPLAYER_TOOLS
-            DrawInstallMultiplayerToolsTip();
-#endif
-
-            if (m_NetworkManager.IsServer || m_NetworkManager.IsClient)
-            {
-                DrawDisconnectButton();
-            }
-            else
-            {
-                DrawAllPropertyFields();
-                ShowStartConnectionButtons();
-            }
-        }
-
         private void ReloadTransports()
         {
             m_TransportTypes.Clear();
@@ -120,15 +97,20 @@ namespace Unity.Netcode.Editor
             m_ProtocolVersionProperty = m_NetworkConfigProperty.FindPropertyRelative("ProtocolVersion");
             m_NetworkTransportProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkTransport");
             m_TickRateProperty = m_NetworkConfigProperty.FindPropertyRelative("TickRate");
+            m_SessionModeProperty = m_NetworkConfigProperty.FindPropertyRelative("SessionMode");
             m_ClientConnectionBufferTimeoutProperty = m_NetworkConfigProperty.FindPropertyRelative("ClientConnectionBufferTimeout");
             m_ConnectionApprovalProperty = m_NetworkConfigProperty.FindPropertyRelative("ConnectionApproval");
             m_EnsureNetworkVariableLengthSafetyProperty = m_NetworkConfigProperty.FindPropertyRelative("EnsureNetworkVariableLengthSafety");
             m_ForceSamePrefabsProperty = m_NetworkConfigProperty.FindPropertyRelative("ForceSamePrefabs");
-            m_EnableSceneManagementProperty = m_NetworkConfigProperty.FindPropertyRelative("EnableSceneManagement");
             m_RecycleNetworkIdsProperty = m_NetworkConfigProperty.FindPropertyRelative("RecycleNetworkIds");
             m_NetworkIdRecycleDelayProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkIdRecycleDelay");
-            m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize");
+
+            m_EnableSceneManagementProperty = m_NetworkConfigProperty.FindPropertyRelative("EnableSceneManagement");
+            m_SpawnTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("SpawnTimeout");
             m_LoadSceneTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("LoadSceneTimeOut");
+
+
+            m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize");
             m_PrefabsList = m_NetworkConfigProperty
                 .FindPropertyRelative(nameof(NetworkConfig.Prefabs))
                 .FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists));
@@ -148,325 +130,213 @@ namespace Unity.Netcode.Editor
             m_ProtocolVersionProperty = m_NetworkConfigProperty.FindPropertyRelative("ProtocolVersion");
             m_NetworkTransportProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkTransport");
             m_TickRateProperty = m_NetworkConfigProperty.FindPropertyRelative("TickRate");
+            m_SessionModeProperty = m_NetworkConfigProperty.FindPropertyRelative("SessionMode");
             m_ClientConnectionBufferTimeoutProperty = m_NetworkConfigProperty.FindPropertyRelative("ClientConnectionBufferTimeout");
             m_ConnectionApprovalProperty = m_NetworkConfigProperty.FindPropertyRelative("ConnectionApproval");
             m_EnsureNetworkVariableLengthSafetyProperty = m_NetworkConfigProperty.FindPropertyRelative("EnsureNetworkVariableLengthSafety");
             m_ForceSamePrefabsProperty = m_NetworkConfigProperty.FindPropertyRelative("ForceSamePrefabs");
-            m_EnableSceneManagementProperty = m_NetworkConfigProperty.FindPropertyRelative("EnableSceneManagement");
             m_RecycleNetworkIdsProperty = m_NetworkConfigProperty.FindPropertyRelative("RecycleNetworkIds");
             m_NetworkIdRecycleDelayProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkIdRecycleDelay");
-            m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize");
+
+
+            m_EnableSceneManagementProperty = m_NetworkConfigProperty.FindPropertyRelative("EnableSceneManagement");
+            m_SpawnTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("SpawnTimeout");
             m_LoadSceneTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("LoadSceneTimeOut");
+
+            m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize");
             m_PrefabsList = m_NetworkConfigProperty
                 .FindPropertyRelative(nameof(NetworkConfig.Prefabs))
                 .FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists));
         }
 
-        private void DrawAllPropertyFields()
+        /// <inheritdoc/>
+        public override void OnInspectorGUI()
         {
-            serializedObject.Update();
+            Initialize();
-            EditorGUILayout.PropertyField(m_RunInBackgroundProperty);
+            CheckNullProperties();
-            EditorGUILayout.PropertyField(m_LogLevelProperty);
-            EditorGUILayout.Space();
 
-            EditorGUILayout.PropertyField(m_PlayerPrefabProperty);
+#if !MULTIPLAYER_TOOLS
-            EditorGUILayout.Space();
+            DrawInstallMultiplayerToolsTip();
-
-            DrawPrefabListField();
-
-            EditorGUILayout.Space();
-
-            EditorGUILayout.LabelField("General", EditorStyles.boldLabel);
-            EditorGUILayout.PropertyField(m_ProtocolVersionProperty);
-
-            DrawTransportField();
-
-            EditorGUILayout.PropertyField(m_TickRateProperty);
-
-            EditorGUILayout.LabelField("Performance", EditorStyles.boldLabel);
-
-            EditorGUILayout.PropertyField(m_EnsureNetworkVariableLengthSafetyProperty);
-
-            EditorGUILayout.LabelField("Connection", EditorStyles.boldLabel);
-            EditorGUILayout.PropertyField(m_ConnectionApprovalProperty);
-
-            using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.ConnectionApproval))
-            {
-                EditorGUILayout.PropertyField(m_ClientConnectionBufferTimeoutProperty);
-            }
-
-            EditorGUILayout.LabelField("Spawning", EditorStyles.boldLabel);
-            EditorGUILayout.PropertyField(m_ForceSamePrefabsProperty);
-
-            EditorGUILayout.PropertyField(m_RecycleNetworkIdsProperty);
-
-            using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.RecycleNetworkIds))
-            {
-                EditorGUILayout.PropertyField(m_NetworkIdRecycleDelayProperty);
-            }
-
-            EditorGUILayout.LabelField("Bandwidth", EditorStyles.boldLabel);
-            EditorGUILayout.PropertyField(m_RpcHashSizeProperty);
-
-            EditorGUILayout.LabelField("Scene Management", EditorStyles.boldLabel);
-            EditorGUILayout.PropertyField(m_EnableSceneManagementProperty);
-
-            using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.EnableSceneManagement))
-            {
-                EditorGUILayout.PropertyField(m_LoadSceneTimeOutProperty);
-            }
-
-            serializedObject.ApplyModifiedProperties();
-        }
-
-        private void DrawTransportField()
-        {
-#if RELAY_INTEGRATION_AVAILABLE
-            var useRelay = EditorPrefs.GetBool(m_UseEasyRelayIntegrationKey, false);
-#else
-            var useRelay = false;
 #endif
 
-            if (useRelay)
+            if (!m_NetworkManager.IsServer && !m_NetworkManager.IsClient)
             {
-                EditorGUILayout.HelpBox("Test connection with relay is enabled, so the default Unity Transport will be used", MessageType.Info);
+                serializedObject.Update();
-                GUI.enabled = false;
+                EditorGUILayout.PropertyField(m_RunInBackgroundProperty);
+                EditorGUILayout.PropertyField(m_LogLevelProperty);
+                EditorGUILayout.PropertyField(m_SessionModeProperty);
+                EditorGUILayout.Space();
+                EditorGUILayout.LabelField("Network Settings", EditorStyles.boldLabel);
+                EditorGUILayout.PropertyField(m_ProtocolVersionProperty);
                 EditorGUILayout.PropertyField(m_NetworkTransportProperty);
-                GUI.enabled = true;
+                if (m_NetworkTransportProperty.objectReferenceValue == null)
-                return;
-            }
-
-            EditorGUILayout.PropertyField(m_NetworkTransportProperty);
-
-            if (m_NetworkTransportProperty.objectReferenceValue == null)
-            {
-                EditorGUILayout.HelpBox("You have no transport selected. A transport is required for netcode to work. Which one do you want?", MessageType.Warning);
-
-                int selection = EditorGUILayout.Popup(0, m_TransportNames);
-
-                if (selection > 0)
                 {
-                    ReloadTransports();
+                    EditorGUILayout.HelpBox("You have no transport selected. A transport is required for netcode to work. Which one do you want?", MessageType.Warning);
 
-                    var transportComponent = m_NetworkManager.gameObject.GetComponent(m_TransportTypes[selection - 1]) ?? m_NetworkManager.gameObject.AddComponent(m_TransportTypes[selection - 1]);
+                    int selection = EditorGUILayout.Popup(0, m_TransportNames);
-                    m_NetworkTransportProperty.objectReferenceValue = transportComponent;
 
-                    Repaint();
+                    if (selection > 0)
+                    {
+                        ReloadTransports();
+
+                        var transportComponent = m_NetworkManager.gameObject.GetComponent(m_TransportTypes[selection - 1]) ?? m_NetworkManager.gameObject.AddComponent(m_TransportTypes[selection - 1]);
+                        m_NetworkTransportProperty.objectReferenceValue = transportComponent;
+
+                        Repaint();
+                    }
                 }
-            }
+                EditorGUILayout.PropertyField(m_TickRateProperty);
-        }
+                EditorGUILayout.PropertyField(m_SpawnTimeOutProperty);
-
+                EditorGUILayout.PropertyField(m_ConnectionApprovalProperty);
-#if RELAY_INTEGRATION_AVAILABLE
+                if (m_NetworkManager.NetworkConfig.ConnectionApproval)
-        private readonly string m_UseEasyRelayIntegrationKey = "NetworkManagerUI_UseRelay_" + Application.dataPath.GetHashCode();
-        private string m_JoinCode = "";
-        private string m_StartConnectionError = null;
-        private string m_Region = "";
-
-        // wait for next frame so that ImGui finishes the current frame
-        private static void RunNextFrame(Action action) => EditorApplication.delayCall += () => action();
-#endif
-
-        private void ShowStartConnectionButtons()
-        {
-            EditorGUILayout.LabelField("Start Connection", EditorStyles.boldLabel);
-
-#if RELAY_INTEGRATION_AVAILABLE
-            // use editor prefs to persist the setting when entering / leaving play mode / exiting Unity
-            var useRelay = EditorPrefs.GetBool(m_UseEasyRelayIntegrationKey, false);
-            GUILayout.BeginHorizontal();
-            useRelay = GUILayout.Toggle(useRelay, "Try Relay in the Editor");
-
-            var icon = EditorGUIUtility.IconContent("_Help");
-            icon.tooltip = "This will help you test relay in the Editor. Click here to know how to integrate Relay in your build";
-            if (GUILayout.Button(icon, GUIStyle.none, GUILayout.Width(20)))
-            {
-                Application.OpenURL("https://docs-multiplayer.unity3d.com/netcode/current/relay/");
-            }
-            GUILayout.EndHorizontal();
-
-            EditorPrefs.SetBool(m_UseEasyRelayIntegrationKey, useRelay);
-            if (useRelay && !Application.isPlaying && !CloudProjectSettings.projectBound)
-            {
-                EditorGUILayout.HelpBox("To use relay, you need to setup your project in the Project Settings in the Services section.", MessageType.Warning);
-                if (GUILayout.Button("Open Project settings"))
                 {
-                    SettingsService.OpenProjectSettings("Project/Services");
+                    EditorGUILayout.PropertyField(m_ClientConnectionBufferTimeoutProperty);
                 }
-            }
+                EditorGUILayout.PropertyField(m_EnsureNetworkVariableLengthSafetyProperty, new GUIContent("NetworkVariable Length Safety"));
+                EditorGUILayout.PropertyField(m_RecycleNetworkIdsProperty);
+                if (m_NetworkManager.NetworkConfig.RecycleNetworkIds)
+                {
+                    EditorGUILayout.PropertyField(m_NetworkIdRecycleDelayProperty);
+                }
+                EditorGUILayout.PropertyField(m_RpcHashSizeProperty);
+
+                EditorGUILayout.Space();
+                EditorGUILayout.LabelField("Prefab Settings", EditorStyles.boldLabel);
+                EditorGUILayout.PropertyField(m_ForceSamePrefabsProperty);
+                EditorGUILayout.PropertyField(m_PlayerPrefabProperty, new GUIContent("Default Player Prefab"));
+
+                if (m_NetworkManager.NetworkConfig.HasOldPrefabList())
+                {
+                    EditorGUILayout.HelpBox("Network Prefabs serialized in old format. Migrate to new format to edit the list.", MessageType.Info);
+                    if (GUILayout.Button(new GUIContent("Migrate Prefab List", "Converts the old format Network Prefab list to a new Scriptable Object")))
+                    {
+                        // Default directory
+                        var directory = "Assets/";
+                        var assetPath = AssetDatabase.GetAssetPath(m_NetworkManager);
+                        if (assetPath == "")
+                        {
+                            assetPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(m_NetworkManager);
+                        }
+
+                        if (assetPath != "")
+                        {
+                            directory = Path.GetDirectoryName(assetPath);
+                        }
+                        else
+                        {
+#if UNITY_2021_1_OR_NEWER
+                            var prefabStage = UnityEditor.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
 #else
-            var useRelay = false;
+                            var prefabStage = UnityEditor.Experimental.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
 #endif
+                            if (prefabStage != null)
+                            {
+                                var prefabPath = prefabStage.assetPath;
+                                if (!string.IsNullOrEmpty(prefabPath))
+                                {
+                                    directory = Path.GetDirectoryName(prefabPath);
+                                }
+                            }
+                            if (m_NetworkManager.gameObject.scene != null)
+                            {
+                                var scenePath = m_NetworkManager.gameObject.scene.path;
+                                if (!string.IsNullOrEmpty(scenePath))
+                                {
+                                    directory = Path.GetDirectoryName(scenePath);
+                                }
+                            }
+                        }
+                        var networkPrefabs = m_NetworkManager.NetworkConfig.MigrateOldNetworkPrefabsToNetworkPrefabsList();
+                        string path = Path.Combine(directory, $"NetworkPrefabs-{m_NetworkManager.GetInstanceID()}.asset");
+                        Debug.Log("Saving migrated Network Prefabs List to " + path);
+                        AssetDatabase.CreateAsset(networkPrefabs, path);
+                        EditorUtility.SetDirty(m_NetworkManager);
+                    }
+                }
+                else
+                {
+                    if (m_NetworkManager.NetworkConfig.Prefabs.NetworkPrefabsLists.Count == 0)
+                    {
+                        EditorGUILayout.HelpBox("You have no prefab list selected. You will have to add your prefabs manually at runtime for netcode to work.", MessageType.Warning);
+                    }
+                    EditorGUILayout.PropertyField(m_PrefabsList);
+                }
 
-            string buttonDisabledReasonSuffix = "";
+                EditorGUILayout.Space();
+                EditorGUILayout.LabelField("Scene Management Settings", EditorStyles.boldLabel);
+                EditorGUILayout.PropertyField(m_EnableSceneManagementProperty);
+                if (m_NetworkManager.NetworkConfig.EnableSceneManagement)
+                {
+                    EditorGUILayout.PropertyField(m_LoadSceneTimeOutProperty);
+                }
 
-            if (!EditorApplication.isPlaying)
+                serializedObject.ApplyModifiedProperties();
-            {
-                buttonDisabledReasonSuffix = ". This can only be done in play mode";
-                GUI.enabled = false;
-            }
 
-            if (useRelay)
+
-            {
+                // Start buttons below
-                ShowStartConnectionButtons_Relay(buttonDisabledReasonSuffix);
+                {
+                    string buttonDisabledReasonSuffix = "";
+
+                    if (!EditorApplication.isPlaying)
+                    {
+                        buttonDisabledReasonSuffix = ". This can only be done in play mode";
+                        GUI.enabled = false;
+                    }
+
+                    if (GUILayout.Button(new GUIContent("Start Host", "Starts a host instance" + buttonDisabledReasonSuffix)))
+                    {
+                        m_NetworkManager.StartHost();
+                    }
+
+                    if (GUILayout.Button(new GUIContent("Start Server", "Starts a server instance" + buttonDisabledReasonSuffix)))
+                    {
+                        m_NetworkManager.StartServer();
+                    }
+
+                    if (GUILayout.Button(new GUIContent("Start Client", "Starts a client instance" + buttonDisabledReasonSuffix)))
+                    {
+                        m_NetworkManager.StartClient();
+                    }
+
+                    if (!EditorApplication.isPlaying)
+                    {
+                        GUI.enabled = true;
+                    }
+                }
             }
             else
             {
-                ShowStartConnectionButtons_Standard(buttonDisabledReasonSuffix);
+                string instanceType = string.Empty;
-            }
 
-            if (!EditorApplication.isPlaying)
+                if (m_NetworkManager.IsHost)
-            {
-                GUI.enabled = true;
-            }
-        }
-
-        private void ShowStartConnectionButtons_Relay(string buttonDisabledReasonSuffix)
-        {
-#if RELAY_INTEGRATION_AVAILABLE
-
-            void AddStartServerOrHostButton(bool isServer)
-            {
-                var type = isServer ? "Server" : "Host";
-                if (GUILayout.Button(new GUIContent($"Start {type}", $"Starts a {type} instance with Relay{buttonDisabledReasonSuffix}")))
                 {
-                    m_StartConnectionError = null;
+                    instanceType = "Host";
-                    RunNextFrame(async () =>
-                    {
-                        try
-                        {
-                            var (joinCode, allocation) = isServer ? await m_NetworkManager.StartServerWithRelay() : await m_NetworkManager.StartHostWithRelay();
-                            m_JoinCode = joinCode;
-                            m_Region = allocation.Region;
-                            Repaint();
-                        }
-                        catch (Exception e)
-                        {
-                            m_StartConnectionError = e.Message;
-                            throw;
-                        }
-                    });
                 }
-            }
+                else if (m_NetworkManager.IsServer)
-
-            AddStartServerOrHostButton(isServer: true);
-            AddStartServerOrHostButton(isServer: false);
-
-            GUILayout.Space(8f);
-            m_JoinCode = EditorGUILayout.TextField("Relay Join Code", m_JoinCode);
-            if (GUILayout.Button(new GUIContent("Start Client", "Starts a client instance with Relay" + buttonDisabledReasonSuffix)))
-            {
-                m_StartConnectionError = null;
-                RunNextFrame(async () =>
                 {
-                    if (string.IsNullOrEmpty(m_JoinCode))
+                    instanceType = "Server";
-                    {
+                }
-                        m_StartConnectionError = "Please provide a join code!";
+                else if (m_NetworkManager.IsClient)
-                        return;
-                    }
-
-                    try
-                    {
-                        var allocation = await m_NetworkManager.StartClientWithRelay(m_JoinCode);
-                        m_Region = allocation.Region;
-                        Repaint();
-                    }
-                    catch (Exception e)
-                    {
-                        m_StartConnectionError = e.Message;
-                        throw;
-                    }
-                });
-            }
-
-            if (Application.isPlaying && !string.IsNullOrEmpty(m_StartConnectionError))
-            {
-                EditorGUILayout.HelpBox(m_StartConnectionError, MessageType.Error);
-            }
-#endif
-        }
-
-        private void ShowStartConnectionButtons_Standard(string buttonDisabledReasonSuffix)
-        {
-            if (GUILayout.Button(new GUIContent("Start Host", "Starts a host instance" + buttonDisabledReasonSuffix)))
-            {
-                m_NetworkManager.StartHost();
-            }
-
-            if (GUILayout.Button(new GUIContent("Start Server", "Starts a server instance" + buttonDisabledReasonSuffix)))
-            {
-                m_NetworkManager.StartServer();
-            }
-
-            if (GUILayout.Button(new GUIContent("Start Client", "Starts a client instance" + buttonDisabledReasonSuffix)))
-            {
-                m_NetworkManager.StartClient();
-            }
-        }
-
-        private void DrawDisconnectButton()
-        {
-            string instanceType = string.Empty;
-
-            if (m_NetworkManager.IsHost)
-            {
-                instanceType = "Host";
-            }
-            else if (m_NetworkManager.IsServer)
-            {
-                instanceType = "Server";
-            }
-            else if (m_NetworkManager.IsClient)
-            {
-                instanceType = "Client";
-            }
-
-            EditorGUILayout.HelpBox($"You cannot edit the NetworkConfig when a {instanceType} is running.", MessageType.Info);
-
-#if RELAY_INTEGRATION_AVAILABLE
-            if (!string.IsNullOrEmpty(m_JoinCode) && !string.IsNullOrEmpty(m_Region))
-            {
-                var style = new GUIStyle(EditorStyles.helpBox)
                 {
-                    fontSize = 10,
+                    instanceType = "Client";
-                    alignment = TextAnchor.MiddleCenter,
-                };
-
-                GUILayout.BeginHorizontal(style, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false), GUILayout.MaxWidth(800));
-                GUILayout.Label(new GUIContent(EditorGUIUtility.IconContent(k_InfoIconName)), GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true));
-                GUILayout.Space(25f);
-                GUILayout.BeginVertical();
-                GUILayout.Space(4f);
-                GUILayout.Label($"Connected via relay ({m_Region}).\nJoin code: {m_JoinCode}", EditorStyles.miniLabel, GUILayout.ExpandHeight(true));
-
-                if (GUILayout.Button("Copy code", GUILayout.ExpandHeight(true)))
-                {
-                    GUIUtility.systemCopyBuffer = m_JoinCode;
                 }
 
-                GUILayout.Space(4f);
+                EditorGUILayout.HelpBox("You cannot edit the NetworkConfig when a " + instanceType + " is running.", MessageType.Info);
-                GUILayout.EndVertical();
-                GUILayout.Space(2f);
-                GUILayout.EndHorizontal();
-            }
-#endif
 
-            if (GUILayout.Button(new GUIContent($"Stop {instanceType}", $"Stops the {instanceType} instance.")))
+                if (GUILayout.Button(new GUIContent("Stop " + instanceType, "Stops the " + instanceType + " instance.")))
-            {
+                {
-#if RELAY_INTEGRATION_AVAILABLE
+                    m_NetworkManager.Shutdown();
-                m_JoinCode = "";
+                }
-#endif
-                m_NetworkManager.Shutdown();
             }
         }
 
-        private const string k_InfoIconName = "console.infoicon";
         private static void DrawInstallMultiplayerToolsTip()
         {
             const string getToolsText = "Access additional tools for multiplayer development by installing the Multiplayer Tools package in the Package Manager.";
             const string openDocsButtonText = "Open Docs";
             const string dismissButtonText = "Dismiss";
             const string targetUrl = "https://docs-multiplayer.unity3d.com/tools/current/install-tools";
-
+            const string infoIconName = "console.infoicon";
 
             if (NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() != 0)
             {
@@ -497,7 +367,7 @@ namespace Unity.Netcode.Editor
             GUILayout.FlexibleSpace();
             GUILayout.BeginHorizontal(s_HelpBoxStyle, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false), GUILayout.MaxWidth(800));
             {
-                GUILayout.Label(new GUIContent(EditorGUIUtility.IconContent(k_InfoIconName)), GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true));
+                GUILayout.Label(new GUIContent(EditorGUIUtility.IconContent(infoIconName)), GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true));
                 GUILayout.Space(4);
                 GUILayout.Label(getToolsText, s_CenteredWordWrappedLabelStyle, GUILayout.ExpandHeight(true));
 
@@ -530,69 +400,5 @@ namespace Unity.Netcode.Editor
 
             GUILayout.Space(10);
         }
-
-        private void DrawPrefabListField()
-        {
-            if (!m_NetworkManager.NetworkConfig.HasOldPrefabList())
-            {
-                if (m_NetworkManager.NetworkConfig.Prefabs.NetworkPrefabsLists.Count == 0)
-                {
-                    EditorGUILayout.HelpBox("You have no prefab list selected. You will have to add your prefabs manually at runtime for netcode to work.", MessageType.Warning);
-                }
-
-                EditorGUILayout.PropertyField(m_PrefabsList);
-                return;
-            }
-
-            // Old format of prefab list
-            EditorGUILayout.HelpBox("Network Prefabs serialized in old format. Migrate to new format to edit the list.", MessageType.Info);
-            if (GUILayout.Button(new GUIContent("Migrate Prefab List", "Converts the old format Network Prefab list to a new Scriptable Object")))
-            {
-                // Default directory
-                var directory = "Assets/";
-                var assetPath = AssetDatabase.GetAssetPath(m_NetworkManager);
-                if (assetPath == "")
-                {
-                    assetPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(m_NetworkManager);
-                }
-
-                if (assetPath != "")
-                {
-                    directory = Path.GetDirectoryName(assetPath);
-                }
-                else
-                {
-
-#if UNITY_2021_1_OR_NEWER
-                    var prefabStage = UnityEditor.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
-#else
-                    var prefabStage = UnityEditor.Experimental.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
-#endif
-                    if (prefabStage != null)
-                    {
-                        var prefabPath = prefabStage.assetPath;
-                        if (!string.IsNullOrEmpty(prefabPath))
-                        {
-                            directory = Path.GetDirectoryName(prefabPath);
-                        }
-                    }
-
-                    if (m_NetworkManager.gameObject.scene != null)
-                    {
-                        var scenePath = m_NetworkManager.gameObject.scene.path;
-                        if (!string.IsNullOrEmpty(scenePath))
-                        {
-                            directory = Path.GetDirectoryName(scenePath);
-                        }
-                    }
-                }
-
-                var networkPrefabs = m_NetworkManager.NetworkConfig.MigrateOldNetworkPrefabsToNetworkPrefabsList();
-                string path = Path.Combine(directory, $"NetworkPrefabs-{m_NetworkManager.GetInstanceID()}.asset");
-                Debug.Log("Saving migrated Network Prefabs List to " + path);
-                AssetDatabase.CreateAsset(networkPrefabs, path);
-                EditorUtility.SetDirty(m_NetworkManager);
-            }
-        }
     }
 }

Editor/NetworkObjectEditor.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Linq;
 using UnityEditor;
 using UnityEngine;
 
@@ -49,6 +50,10 @@ namespace Unity.Netcode.Editor
             {
                 var guiEnabled = GUI.enabled;
                 GUI.enabled = false;
+                if (m_NetworkObject.NetworkManager.DistributedAuthorityMode)
+                {
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty(nameof(NetworkObject.Ownership)));
+                }
                 EditorGUILayout.TextField(nameof(NetworkObject.GlobalObjectIdHash), m_NetworkObject.GlobalObjectIdHash.ToString());
                 EditorGUILayout.TextField(nameof(NetworkObject.NetworkObjectId), m_NetworkObject.NetworkObjectId.ToString());
                 EditorGUILayout.TextField(nameof(NetworkObject.OwnerClientId), m_NetworkObject.OwnerClientId.ToString());
@@ -138,4 +143,49 @@ namespace Unity.Netcode.Editor
             NetworkBehaviourEditor.CheckForNetworkObject(m_GameObject, true);
         }
     }
+
+
+    [CustomPropertyDrawer(typeof(NetworkObject.OwnershipStatus))]
+    public class NetworkObjectOwnership : PropertyDrawer
+    {
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            label = EditorGUI.BeginProperty(position, label, property);
+            // Don't allow modification while in play mode
+            EditorGUI.BeginDisabledGroup(EditorApplication.isPlaying);
+
+            // This is a temporary work around due to EditorGUI.EnumFlagsField having a bug in how it displays mask values.
+            // For now, we will just display the flags as a toggle and handle the masking of the value ourselves.
+            EditorGUILayout.BeginHorizontal();
+            var names = System.Enum.GetNames(typeof(NetworkObject.OwnershipStatus)).ToList();
+            names.RemoveAt(0);
+            var value = property.enumValueFlag;
+            var compareValue = 0x01;
+            GUILayout.Label(label);
+            foreach (var name in names)
+            {
+                var isSet = (value & compareValue) > 0;
+                isSet = GUILayout.Toggle(isSet, name);
+                if (isSet)
+                {
+                    value |= compareValue;
+                }
+                else
+                {
+                    value &= ~compareValue;
+                }
+                compareValue = compareValue << 1;
+            }
+            property.enumValueFlag = value;
+            EditorGUILayout.EndHorizontal();
+
+            // The below can cause visual anomalies and/or throws an exception within the EditorGUI itself (index out of bounds of the array). and has
+            // The visual anomaly is when you select one field it is set in the drop down but then the flags selection in the popup menu selects more items
+            // even though if you exit the popup menu the flag setting is correct. 
+            //var ownership = (NetworkObject.OwnershipStatus)EditorGUI.EnumFlagsField(position, label, (NetworkObject.OwnershipStatus)property.enumValueFlag);
+            //property.enumValueFlag = (int)ownership;
+            EditorGUI.EndDisabledGroup();
+            EditorGUI.EndProperty();
+        }
+    }
 }

Editor/NetworkTransformEditor.cs

@@ -37,8 +37,6 @@ namespace Unity.Netcode.Editor
         private static GUIContent s_RotationLabel = EditorGUIUtility.TrTextContent("Rotation");
         private static GUIContent s_ScaleLabel = EditorGUIUtility.TrTextContent("Scale");
 
-        public virtual bool HideInterpolateValue => false;
-
         /// <inheritdoc/>
         public void OnEnable()
         {
@@ -139,11 +137,7 @@ namespace Unity.Netcode.Editor
             EditorGUILayout.Space();
             EditorGUILayout.LabelField("Configurations", EditorStyles.boldLabel);
             EditorGUILayout.PropertyField(m_InLocalSpaceProperty);
-            if (!HideInterpolateValue)
+            EditorGUILayout.PropertyField(m_InterpolateProperty);
-            {
-                EditorGUILayout.PropertyField(m_InterpolateProperty);
-            }
-
             EditorGUILayout.PropertyField(m_SlerpPosition);
             EditorGUILayout.PropertyField(m_UseQuaternionSynchronization);
             if (m_UseQuaternionSynchronization.boolValue)
@@ -156,10 +150,9 @@ namespace Unity.Netcode.Editor
             }
             EditorGUILayout.PropertyField(m_UseHalfFloatPrecision);
 
+#if COM_UNITY_MODULES_PHYSICS
             // if rigidbody is present but network rigidbody is not present
             var go = ((NetworkTransform)target).gameObject;
-
-#if COM_UNITY_MODULES_PHYSICS
             if (go.TryGetComponent<Rigidbody>(out _) && go.TryGetComponent<NetworkRigidbody>(out _) == false)
             {
                 EditorGUILayout.HelpBox("This GameObject contains a Rigidbody but no NetworkRigidbody.\n" +

LICENSE.md

@@ -1,9 +1,7 @@
-MIT License
+Unity Companion License (UCL License)
 
-Copyright (c) 2021 Unity Technologies
+com.unity.netcode.gameobjects copyright ©  2021-2024 Unity Technologies
+Licensed under the Unity Companion License for Unity-dependent projects (see https://unity3d.com/legal/licenses/unity_companion_license).
+Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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;
-            }
+                SpawnManager = null;
-
+                DAHost = false;
-            if (networkManager != null)
-            {
-                SpawnManager = networkManager.SpawnManager;
             }
         }
 

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
 {
@@ -104,11 +104,9 @@ namespace Unity.Netcode
                     {
                         continue;
                     }
-                    if (peerClientIds.Length > idx)
+
-                    {
+                    peerClientIds[idx] = peerId;
-                        peerClientIds[idx] = peerId;
+                    ++idx;
-                        ++idx;
-                    }
                 }
 
                 try
@@ -368,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);
 
@@ -432,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();
@@ -493,41 +496,24 @@ namespace Unity.Netcode
             // Process the incoming message queue so that we get everything from the server disconnecting us or, if we are the server, so we got everything from that client.
             MessageManager.ProcessIncomingMessageQueue();
 
+            InvokeOnClientDisconnectCallback(clientId);
+
+            if (LocalClient.IsHost)
+            {
+                InvokeOnPeerDisconnectedCallback(clientId);
+            }
+
             if (LocalClient.IsServer)
             {
-                // We need to process the disconnection before notifying
                 OnClientDisconnectFromServer(clientId);
-
-                // Now notify the client has disconnected
-                InvokeOnClientDisconnectCallback(clientId);
-
-                if (LocalClient.IsHost)
-                {
-                    InvokeOnPeerDisconnectedCallback(clientId);
-                }
             }
-            else
+            else // As long as we are not in the middle of a shutdown
+            if (!NetworkManager.ShutdownInProgress)
             {
-                // Notify local client of disconnection
+                // We must pass true here and not process any sends messages as we are no longer connected.
-                InvokeOnClientDisconnectCallback(clientId);
+                // Otherwise, attempting to process messages here can cause an exception within UnityTransport
-
+                // as the client ID is no longer valid.
-                // As long as we are not in the middle of a shutdown
+                NetworkManager.Shutdown(true);
-                if (!NetworkManager.ShutdownInProgress)
-                {
-                    // We must pass true here and not process any sends messages as we are no longer connected.
-                    // Otherwise, attempting to process messages here can cause an exception within UnityTransport
-                    // as the client ID is no longer valid.
-                    NetworkManager.Shutdown(true);
-                }
-            }
-
-            if (NetworkManager.IsServer)
-            {
-                MessageManager.ClientDisconnected(clientId);
-            }
-            else
-            {
-                MessageManager.ClientDisconnected(NetworkManager.ServerClientId);
             }
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             s_TransportDisconnect.End();
@@ -565,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,
@@ -720,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>
@@ -731,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 (!NetworkManager.DistributedAuthorityMode && response.CreatePlayerObject && NetworkManager.NetworkConfig.PlayerPrefab != null)
-                if (response.CreatePlayerObject)
                 {
                     var prefabNetworkObject = NetworkManager.NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>();
                     var playerPrefabHash = response.PlayerPrefabHash ?? prefabNetworkObject.GlobalObjectIdHash;
@@ -751,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(),
@@ -780,6 +780,7 @@ namespace Unity.Netcode
                     {
                         OwnerClientId = ownerClientId,
                         NetworkTick = NetworkManager.LocalTime.Tick,
+                        IsDistributedAuthority = NetworkManager.DistributedAuthorityMode,
                         ConnectedClientIds = new NativeArray<ulong>(ConnectedClientIds.Count, Allocator.Temp)
                     };
 
@@ -813,10 +814,20 @@ namespace Unity.Netcode
                             };
                         }
                     }
-
+                    if (!MockSkippingApproval)
-                    SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ownerClientId);
+                    {
+                        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)
@@ -827,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
@@ -838,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))
@@ -845,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);
             }
@@ -859,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>
@@ -883,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;
@@ -902,25 +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);
-            ConnectedClientsList.Add(networkClient);
-            ConnectedClientIds.Add(clientId);
-            // Host should not send this message to itself
-            if (clientId != NetworkManager.ServerClientId)
             {
-                var message = new ClientConnectedMessage { ClientId = clientId };
+                ConnectedClients.Add(clientId, networkClient);
-                NetworkManager.MessageManager.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ConnectedClientIds);
+            }
+            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);
+                }
             }
 
             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
@@ -947,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
@@ -978,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];
@@ -987,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();
+                                }
                             }
                         }
                     }
@@ -1017,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
@@ -1283,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
+            // Prevent server sending to itself or if there is no MessageManager yet then exit early
-            if (LocalClient.IsServer && clientId == NetworkManager.ServerClientId)
+            if ((LocalClient.IsServer && clientId == NetworkManager.ServerClientId) || MessageManager == null)
             {
                 return 0;
             }

Runtime/Core/NetworkBehaviour.cs

@@ -27,7 +27,7 @@ namespace Unity.Netcode
         // RuntimeAccessModifiersILPP will make this `public`
         internal static readonly Dictionary<Type, Dictionary<uint, RpcReceiveHandler>> __rpc_func_table = new Dictionary<Type, Dictionary<uint, RpcReceiveHandler>>();
 
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
         // RuntimeAccessModifiersILPP will make this `public`
         internal static readonly Dictionary<Type, Dictionary<uint, string>> __rpc_name_table = new Dictionary<Type, Dictionary<uint, string>>();
 #endif
@@ -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;
-
+            // Authority just no ops and sends to itself
-            // If we are a server/host then we just no op and send to ourself
+            // Client-Server: Only the server-host sends to self
-            if (IsHost || IsServer)
+            if (IsServer)
             {
                 using var tempBuffer = new FastBufferReader(bufferWriter, Allocator.Temp);
                 var context = new NetworkContext
                 {
                     SenderId = NetworkManager.ServerClientId,
-                    Timestamp = NetworkManager.RealTimeProvider.RealTimeSinceStartup,
+                    Timestamp = networkManager.RealTimeProvider.RealTimeSinceStartup,
-                    SystemOwner = NetworkManager,
+                    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(),
@@ -123,7 +124,7 @@ namespace Unity.Netcode
             }
 
             bufferWriter.Dispose();
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
             if (__rpc_name_table[GetType()].TryGetValue(rpcMethodId, out var rpcMethodName))
             {
                 NetworkManager.NetworkMetrics.TrackRpcSent(
@@ -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;
+                        shouldInvokeLocally = true;
-                        break;
+                        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;
+                        shouldInvokeLocally = true;
-                        break;
+                        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,
+                    Timestamp = networkManager.RealTimeProvider.RealTimeSinceStartup,
-                    SystemOwner = NetworkManager,
+                    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(),
@@ -254,14 +252,14 @@ namespace Unity.Netcode
             }
 
             bufferWriter.Dispose();
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
             if (__rpc_name_table[GetType()].TryGetValue(rpcMethodId, out var rpcMethodName))
             {
                 if (clientRpcParams.Send.TargetClientIds != null)
                 {
                     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>
@@ -581,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;
+                NetworkObjectId = networkObject.NetworkObjectId;
-                IsLocalPlayer = NetworkObject.IsLocalPlayer;
+                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;
+                IsOwnedByServer = networkObject.IsOwnedByServer;
-                IsOwner = NetworkObject.IsOwner;
+                IsOwner = networkObject.IsOwner;
-                OwnerClientId = NetworkObject.OwnerClientId;
+                OwnerClientId = networkObject.OwnerClientId;
 
                 // Set NetworkManager dependent properties
-                if (NetworkManager != null)
+                if (networkManager != null)
                 {
-                    IsHost = NetworkManager.IsListening && NetworkManager.IsHost;
+                    IsHost = networkManager.IsListening && networkManager.IsHost;
-                    IsClient = NetworkManager.IsListening && NetworkManager.IsClient;
+                    IsClient = networkManager.IsListening && networkManager.IsClient;
-                    IsServer = NetworkManager.IsListening && NetworkManager.IsServer;
+                    IsServer = networkManager.IsListening && networkManager.IsServer;
-                    ServerIsHost = NetworkManager.IsListening && NetworkManager.ServerIsHost;
+                    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;
@@ -612,73 +645,31 @@ namespace Unity.Netcode
                 OwnerClientId = NetworkObjectId = default;
                 IsOwnedByServer = IsOwner = IsHost = IsClient = IsServer = ServerIsHost = default;
                 NetworkBehaviourId = default;
+                LocalClient = default;
+                HasAuthority = default;
             }
         }
 
         /// <summary>
-        /// Gets called after the <see cref="NetworkObject"/> is spawned. No NetworkBehaviours associated with the NetworkObject will have had <see cref="OnNetworkSpawn"/> invoked yet.
+        /// Distributed Authority Mode Only
-        /// A reference to <see cref="NetworkManager"/> is passed in as a parameter to determine the context of execution (IsServer/IsClient)
+        /// Invoked only on the authority instance when a <see cref="NetworkObject"/> is deferring its despawn on non-authoritative instances.
         /// </summary>
         /// <remarks>
-        /// <param name="networkManager">a ref to the <see cref="NetworkManager"/> since this is not yet set on the <see cref="NetworkBehaviour"/></param>
+        /// See also: <see cref="NetworkObject.DeferDespawn(int, bool)"/>
-        /// The <see cref="NetworkBehaviour"/> will not have anything assigned to it at this point in time.
-        /// Settings like ownership, NetworkBehaviourId, NetworkManager, and most other spawn related properties will not be set.
-        /// This can be used to handle things like initializing/instantiating a NetworkVariable or the like.
         /// </remarks>
-        protected virtual void OnNetworkPreSpawn(ref NetworkManager networkManager) { }
+        /// <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>
         public virtual void OnNetworkSpawn() { }
 
-        /// <summary>
-        /// Gets called after the <see cref="NetworkObject"/> is spawned. All NetworkBehaviours associated with the NetworkObject will have had <see cref="OnNetworkSpawn"/> invoked.
-        /// </summary>
-        /// <remarks>
-        /// Will be invoked on each <see cref="NetworkBehaviour"/> associated with the <see cref="NetworkObject"/> being spawned.
-        /// All associated <see cref="NetworkBehaviour"/> components will have had <see cref="OnNetworkSpawn"/> invoked on the spawned <see cref="NetworkObject"/>.
-        /// </remarks>
-        protected virtual void OnNetworkPostSpawn() { }
-
-        /// <summary>
-        /// [Client-Side Only]
-        /// When a new client joins it is synchronized with all spawned NetworkObjects and scenes loaded for the session joined. At the end of the synchronization process, when all
-        /// <see cref="NetworkObject"/>s and scenes (if scene management is enabled) have finished synchronizing, all NetworkBehaviour components associated with spawned <see cref="NetworkObject"/>s
-        /// will have this method invoked.
-        /// </summary>
-        /// <remarks>
-        /// This can be used to handle post synchronization actions where you might need to access a different NetworkObject and/or NetworkBehaviour not local to the current NetworkObject context.
-        /// This is only invoked on clients during a client-server network topology session.
-        /// </remarks>
-        protected virtual void OnNetworkSessionSynchronized() { }
-
-        /// <summary>
-        /// [Client & Server Side]
-        /// When a scene is loaded an in-scene placed NetworkObjects are all spawned, this method is invoked on all of the newly spawned in-scene placed NetworkObjects.
-        /// </summary>
-        /// <remarks>
-        /// This can be used to handle post scene loaded actions for in-scene placed NetworkObjcts where you might need to access a different NetworkObject and/or NetworkBehaviour not local to the current NetworkObject context.
-        /// </remarks>
-        protected virtual void OnInSceneObjectsSpawned() { }
-
         /// <summary>
         /// Gets called when the <see cref="NetworkObject"/> gets despawned. Is called both on the server and clients.
         /// </summary>
         public virtual void OnNetworkDespawn() { }
 
-        internal void NetworkPreSpawn(ref NetworkManager networkManager)
-        {
-            try
-            {
-                OnNetworkPreSpawn(ref networkManager);
-            }
-            catch (Exception e)
-            {
-                Debug.LogException(e);
-            }
-        }
-
         internal void InternalOnNetworkSpawn()
         {
             IsSpawned = true;
@@ -698,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.
@@ -707,42 +699,6 @@ namespace Unity.Netcode
             }
         }
 
-        internal void NetworkPostSpawn()
-        {
-            try
-            {
-                OnNetworkPostSpawn();
-            }
-            catch (Exception e)
-            {
-                Debug.LogException(e);
-            }
-        }
-
-        internal void NetworkSessionSynchronized()
-        {
-            try
-            {
-                OnNetworkSessionSynchronized();
-            }
-            catch (Exception e)
-            {
-                Debug.LogException(e);
-            }
-        }
-
-        internal void InSceneNetworkObjectsSpawned()
-        {
-            try
-            {
-                OnInSceneObjectsSpawned();
-            }
-            catch (Exception e)
-            {
-                Debug.LogException(e);
-            }
-        }
-
         internal void InternalOnNetworkDespawn()
         {
             IsSpawned = false;
@@ -758,7 +714,7 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Invoked on both the server and the local client of the owner when <see cref="Netcode.NetworkObject"/> ownership is assigned.
+        /// Gets called when the local client gains ownership of this object
         /// </summary>
         public virtual void OnGainedOwnership() { }
 
@@ -786,8 +742,7 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Invoked on the local client when it loses ownership of the associated <see cref="Netcode.NetworkObject"/>.
+        /// Gets called when we loose ownership of this object
-        /// This method is also invoked on the server when any client loses ownership.
         /// </summary>
         public virtual void OnLostOwnership() { }
 
@@ -833,7 +788,7 @@ namespace Unity.Netcode
 #pragma warning restore IDE1006 // restore naming rule violation check
         {
             __rpc_func_table[GetType()][hash] = handler;
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
             __rpc_name_table[GetType()][hash] = rpcMethodName;
 #endif
         }
@@ -859,7 +814,7 @@ namespace Unity.Netcode
             if (!__rpc_func_table.ContainsKey(GetType()))
             {
                 __rpc_func_table[GetType()] = new Dictionary<uint, RpcReceiveHandler>();
-#if UNITY_EDITOR || DEVELOPMENT_BUILD || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
                 __rpc_name_table[GetType()] = new Dictionary<uint, string>();
 #endif
                 __initializeRpcs();
@@ -906,16 +861,7 @@ namespace Unity.Netcode
                 // during OnNetworkSpawn has been sent and needs to be cleared
                 for (int i = 0; i < NetworkVariableFields.Count; i++)
                 {
-                    var networkVariable = NetworkVariableFields[i];
+                    NetworkVariableFields[i].ResetDirty();
-                    if (networkVariable.IsDirty())
-                    {
-                        if (networkVariable.CanSend())
-                        {
-                            networkVariable.UpdateLastSentTime();
-                            networkVariable.ResetDirty();
-                            networkVariable.SetDirty(false);
-                        }
-                    }
                 }
             }
             else
@@ -923,18 +869,11 @@ namespace Unity.Netcode
                 // mark any variables we wrote as no longer dirty
                 for (int i = 0; i < NetworkVariableIndexesToReset.Count; i++)
                 {
-                    var networkVariable = NetworkVariableFields[NetworkVariableIndexesToReset[i]];
+                    NetworkVariableFields[NetworkVariableIndexesToReset[i]].ResetDirty();
-                    if (networkVariable.IsDirty())
-                    {
-                        if (networkVariable.CanSend())
-                        {
-                            networkVariable.UpdateLastSentTime();
-                            networkVariable.ResetDirty();
-                            networkVariable.SetDirty(false);
-                        }
-                    }
                 }
             }
+
+            MarkVariablesDirty(false);
         }
 
         internal void PreVariableUpdate()
@@ -943,86 +882,95 @@ namespace Unity.Netcode
             {
                 InitializeVariables();
             }
-            PreNetworkVariableWrite();
-        }
 
-        internal void VariableUpdate(ulong targetClientId)
+            PreNetworkVariableWrite();
-        {
-            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))
                     {
-                        if (networkVariable.CanSend())
+                        shouldSend = true;
-                        {
-                            shouldSend = true;
-                        }
                         break;
                     }
                 }
-
+                // All of this is just to prevent the DA Host from re-sending a NetworkVariable update it received from the client owner
-                if (shouldSend)
+                // 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,
+                        message.Serialize(tmpWriter, message.Version);
-                        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);
                     }
                 }
+                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'
             for (int i = 0; i < NetworkVariableFields.Count; i++)
             {
-                var networkVariable = NetworkVariableFields[i];
+                if (NetworkVariableFields[i].IsDirty())
-                if (networkVariable.IsDirty())
                 {
-                    if (networkVariable.CanSend())
+                    return true;
-                    {
-                        return true;
-                    }
-                    // If it's dirty but can't be sent yet, we have to keep monitoring it until one of the
-                    // conditions blocking its send changes.
-                    NetworkManager.BehaviourUpdater.AddForUpdate(NetworkObject);
                 }
             }
 
@@ -1047,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
@@ -1078,10 +1039,13 @@ namespace Unity.Netcode
                         NetworkVariableFields[j].WriteField(writer);
                     }
                 }
-                else // Only if EnsureNetworkVariableLengthSafety, otherwise just skip
+                else
-                if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                 {
-                    writer.WriteValueSafe((ushort)0);
+                    // Only if EnsureNetworkVariableLengthSafety, otherwise just skip
+                    if (networkManager.DistributedAuthorityMode || networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                    {
+                        writer.WriteValueSafe((ushort)0);
+                    }
                 }
             }
         }
@@ -1096,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)
@@ -1117,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))
                     {
@@ -1179,11 +1179,6 @@ namespace Unity.Netcode
 
         }
 
-        public virtual void OnReanticipate(double lastRoundTripTime)
-        {
-
-        }
-
         /// <summary>
         /// The relative client identifier targeted for the serialization of this <see cref="NetworkBehaviour"/> instance.
         /// </summary>
@@ -1293,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;
                 }
@@ -1314,9 +1309,9 @@ namespace Unity.Netcode
 
 
         /// <summary>
-        /// Invoked when the <see cref="GameObject"/> the <see cref="NetworkBehaviour"/> is attached to is destroyed.
+        /// Invoked when the <see cref="GameObject"/> the <see cref="NetworkBehaviour"/> is attached to.
-        /// NOTE:  If you override this, you should invoke this base class version of this
+        /// NOTE:  If you override this, you will want to always invoke this base class version of this
-        /// <see cref="OnDestroy"/> method.
+        /// <see cref="OnDestroy"/> method!!
         /// </summary>
         public virtual void OnDestroy()
         {

Runtime/Core/NetworkBehaviourUpdater.cs

@@ -11,7 +11,6 @@ namespace Unity.Netcode
         private NetworkManager m_NetworkManager;
         private NetworkConnectionManager m_ConnectionManager;
         private HashSet<NetworkObject> m_DirtyNetworkObjects = new HashSet<NetworkObject>();
-        private HashSet<NetworkObject> m_PendingDirtyNetworkObjects = new HashSet<NetworkObject>();
 
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
         private ProfilerMarker m_NetworkBehaviourUpdate = new ProfilerMarker($"{nameof(NetworkBehaviour)}.{nameof(NetworkBehaviourUpdate)}");
@@ -19,7 +18,7 @@ namespace Unity.Netcode
 
         internal void AddForUpdate(NetworkObject networkObject)
         {
-            m_PendingDirtyNetworkObjects.Add(networkObject);
+            m_DirtyNetworkObjects.Add(networkObject);
         }
 
         internal void NetworkBehaviourUpdate()
@@ -29,9 +28,6 @@ namespace Unity.Netcode
 #endif
             try
             {
-                m_DirtyNetworkObjects.UnionWith(m_PendingDirtyNetworkObjects);
-                m_PendingDirtyNetworkObjects.Clear();
-
                 // NetworkObject references can become null, when hidden or despawned. Once NUll, there is no point
                 // trying to process them, even if they were previously marked as dirty.
                 m_DirtyNetworkObjects.RemoveWhere((sobj) => sobj == null);
@@ -48,13 +44,12 @@ namespace Unity.Netcode
                         for (int i = 0; i < m_ConnectionManager.ConnectedClientsList.Count; i++)
                         {
                             var client = m_ConnectionManager.ConnectedClientsList[i];
-
+                            if (m_NetworkManager.DistributedAuthorityMode || dirtyObj.IsNetworkVisibleTo(client.ClientId))
-                            if (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);
                                 }
                             }
                         }
@@ -73,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);
                             }
                         }
                     }
@@ -99,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;
@@ -27,13 +28,155 @@ namespace Unity.Netcode
         // RuntimeAccessModifiersILPP will make this `public`
         internal static readonly Dictionary<uint, RpcReceiveHandler> __rpc_func_table = new Dictionary<uint, RpcReceiveHandler>();
 
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
         // RuntimeAccessModifiersILPP will make this `public`
         internal static readonly Dictionary<uint, string> __rpc_name_table = new Dictionary<uint, string>();
 #endif
 
 #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)
@@ -45,27 +188,26 @@ namespace Unity.Netcode
 
                         DeferredMessageManager.ProcessTriggers(IDeferredNetworkMessageManager.TriggerType.OnNextFrame, 0);
 
-                        AnticipationSystem.SetupForUpdate();
                         MessageManager.ProcessIncomingMessageQueue();
                         MessageManager.CleanupDisconnectedClients();
-
-                        AnticipationSystem.ProcessReanticipation();
                     }
                     break;
                 case NetworkUpdateStage.PreUpdate:
                     {
                         NetworkTimeSystem.UpdateTime();
-                        AnticipationSystem.Update();
                     }
                     break;
-                case NetworkUpdateStage.PostScriptLateUpdate:
-
-                    AnticipationSystem.Sync();
-                    AnticipationSystem.SetupForRender();
-                    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();
 
@@ -81,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
@@ -181,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;
 
@@ -284,25 +436,6 @@ namespace Unity.Netcode
             remove => ConnectionManager.OnTransportFailure -= value;
         }
 
-        public delegate void ReanticipateDelegate(double lastRoundTripTime);
-
-        /// <summary>
-        /// This callback is called after all individual OnReanticipate calls on AnticipatedNetworkVariable
-        /// and AnticipatedNetworkTransform values have been invoked. The first parameter is a hash set of
-        /// all the variables that have been changed on this frame (you can detect a particular variable by
-        /// checking if the set contains it), while the second parameter is a set of all anticipated network
-        /// transforms that have been changed. Both are passed as their base class type.
-        ///
-        /// The third parameter is the local time corresponding to the current authoritative server state
-        /// (i.e., to determine the amount of time that needs to be re-simulated, you will use
-        /// NetworkManager.LocalTime.Time - authorityTime).
-        /// </summary>
-        public event ReanticipateDelegate OnReanticipate
-        {
-            add => AnticipationSystem.OnReanticipate += value;
-            remove => AnticipationSystem.OnReanticipate -= value;
-        }
-
         /// <summary>
         /// The callback to invoke during connection approval. Allows client code to decide whether or not to allow incoming client connection
         /// </summary>
@@ -463,21 +596,20 @@ namespace Unity.Netcode
         public event Action OnServerStarted = null;
 
         /// <summary>
-        /// The callback to invoke once the local client is ready.
+        /// The callback to invoke once the local client is ready
         /// </summary>
         public event Action OnClientStarted = null;
 
         /// <summary>
         /// This callback is invoked once the local server is stopped.
         /// </summary>
-        /// <remarks>The bool parameter will be set to true when stopping a host instance and false when stopping a server instance.</remarks>
         /// <param name="arg1">The first parameter of this event will be set to <see cref="true"/> when stopping a host instance and <see cref="false"/> when stopping a server instance.</param>
         public event Action<bool> OnServerStopped = null;
 
         /// <summary>
-        /// The callback to invoke once the local client stops.
+        /// The callback to invoke once the local client stops
         /// </summary>
-        /// <remarks>The bool parameter will be set to true when stopping a host client and false when stopping a standard client instance.</remarks>
+        /// <remarks>The parameter states whether the client was running in host mode</remarks>
         /// <param name="arg1">The first parameter of this event will be set to <see cref="true"/> when stopping the host client and <see cref="false"/> when stopping a standard client instance.</param>
         public event Action<bool> OnClientStopped = null;
 
@@ -548,8 +680,6 @@ namespace Unity.Netcode
         /// </summary>
         public NetworkTickSystem NetworkTickSystem { get; private set; }
 
-        internal AnticipationSystem AnticipationSystem { get; private set; }
-
         /// <summary>
         /// Used for time mocking in tests
         /// </summary>
@@ -812,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)
             {
@@ -845,7 +979,6 @@ namespace Unity.Netcode
 
             this.RegisterNetworkUpdate(NetworkUpdateStage.EarlyUpdate);
             this.RegisterNetworkUpdate(NetworkUpdateStage.PreUpdate);
-            this.RegisterNetworkUpdate(NetworkUpdateStage.PostScriptLateUpdate);
             this.RegisterNetworkUpdate(NetworkUpdateStage.PostLateUpdate);
 
             // ComponentFactory needs to set its defaults next
@@ -878,7 +1011,6 @@ namespace Unity.Netcode
             // The remaining systems can then be initialized
             NetworkTimeSystem = server ? NetworkTimeSystem.ServerTimeSystem() : new NetworkTimeSystem(1.0 / NetworkConfig.TickRate);
             NetworkTickSystem = NetworkTimeSystem.Initialize(this);
-            AnticipationSystem = new AnticipationSystem(this);
 
             // Create spawn manager instance
             SpawnManager = new NetworkSpawnManager(this);
@@ -964,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);
@@ -1010,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);
 
@@ -1053,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
             {
@@ -1109,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);
             }
@@ -1188,6 +1331,7 @@ namespace Unity.Netcode
 
             // Everything is shutdown in the order of their dependencies
             DeferredMessageManager?.CleanupAllTriggers();
+            CustomMessagingManager = null;
 
             RpcTarget?.Dispose();
             RpcTarget = null;
@@ -1198,8 +1342,6 @@ namespace Unity.Netcode
             // Shutdown connection manager last which shuts down transport
             ConnectionManager.Shutdown();
 
-            CustomMessagingManager = null;
-
             if (MessageManager != null)
             {
                 MessageManager.Dispose();
@@ -1259,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/Core/NetworkUpdateLoop.cs

@@ -54,14 +54,7 @@ namespace Unity.Netcode
         /// </summary>
         PreLateUpdate = 6,
         /// <summary>
-        /// Updated after Monobehaviour.LateUpdate, but BEFORE rendering
-        /// </summary>
-        // Yes, these numbers are out of order due to backward compatibility requirements.
-        // The enum values are listed in the order they will be called.
-        PostScriptLateUpdate = 8,
-        /// <summary>
         /// Updated after the Monobehaviour.LateUpdate for all components is invoked
-        /// and all rendering is complete
         /// </summary>
         PostLateUpdate = 7
     }
@@ -265,18 +258,6 @@ namespace Unity.Netcode
             }
         }
 
-        internal struct NetworkPostScriptLateUpdate
-        {
-            public static PlayerLoopSystem CreateLoopSystem()
-            {
-                return new PlayerLoopSystem
-                {
-                    type = typeof(NetworkPostScriptLateUpdate),
-                    updateDelegate = () => RunNetworkUpdateStage(NetworkUpdateStage.PostScriptLateUpdate)
-                };
-            }
-        }
-
         internal struct NetworkPostLateUpdate
         {
             public static PlayerLoopSystem CreateLoopSystem()
@@ -418,7 +399,6 @@ namespace Unity.Netcode
                 else if (currentSystem.type == typeof(PreLateUpdate))
                 {
                     TryAddLoopSystem(ref currentSystem, NetworkPreLateUpdate.CreateLoopSystem(), typeof(PreLateUpdate.ScriptRunBehaviourLateUpdate), LoopSystemPosition.Before);
-                    TryAddLoopSystem(ref currentSystem, NetworkPostScriptLateUpdate.CreateLoopSystem(), typeof(PreLateUpdate.ScriptRunBehaviourLateUpdate), LoopSystemPosition.After);
                 }
                 else if (currentSystem.type == typeof(PostLateUpdate))
                 {
@@ -460,7 +440,6 @@ namespace Unity.Netcode
                 else if (currentSystem.type == typeof(PreLateUpdate))
                 {
                     TryRemoveLoopSystem(ref currentSystem, typeof(NetworkPreLateUpdate));
-                    TryRemoveLoopSystem(ref currentSystem, typeof(NetworkPostScriptLateUpdate));
                 }
                 else if (currentSystem.type == typeof(PostLateUpdate))
                 {

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}");
+        private static string Header()
-        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}");
+            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

@@ -152,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
@@ -174,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;
                 }

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/AnticipationCounterSync.cs

@@ -1,70 +0,0 @@
-namespace Unity.Netcode
-{
-    internal struct AnticipationCounterSyncPingMessage : INetworkMessage
-    {
-        public int Version => 0;
-
-        public ulong Counter;
-        public double Time;
-
-        public void Serialize(FastBufferWriter writer, int targetVersion)
-        {
-            BytePacker.WriteValuePacked(writer, Counter);
-            writer.WriteValueSafe(Time);
-        }
-
-        public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
-        {
-            var networkManager = (NetworkManager)context.SystemOwner;
-            if (!networkManager.IsServer)
-            {
-                return false;
-            }
-            ByteUnpacker.ReadValuePacked(reader, out Counter);
-            reader.ReadValueSafe(out Time);
-            return true;
-        }
-
-        public void Handle(ref NetworkContext context)
-        {
-            var networkManager = (NetworkManager)context.SystemOwner;
-            if (networkManager.IsListening && !networkManager.ShutdownInProgress && networkManager.ConnectedClients.ContainsKey(context.SenderId))
-            {
-                var message = new AnticipationCounterSyncPongMessage { Counter = Counter, Time = Time };
-                networkManager.MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, context.SenderId);
-            }
-        }
-    }
-    internal struct AnticipationCounterSyncPongMessage : INetworkMessage
-    {
-        public int Version => 0;
-
-        public ulong Counter;
-        public double Time;
-
-        public void Serialize(FastBufferWriter writer, int targetVersion)
-        {
-            BytePacker.WriteValuePacked(writer, Counter);
-            writer.WriteValueSafe(Time);
-        }
-
-        public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
-        {
-            var networkManager = (NetworkManager)context.SystemOwner;
-            if (!networkManager.IsClient)
-            {
-                return false;
-            }
-            ByteUnpacker.ReadValuePacked(reader, out Counter);
-            reader.ReadValueSafe(out Time);
-            return true;
-        }
-
-        public void Handle(ref NetworkContext context)
-        {
-            var networkManager = (NetworkManager)context.SystemOwner;
-            networkManager.AnticipationSystem.LastAnticipationAck = Counter;
-            networkManager.AnticipationSystem.LastAnticipationAckTime = Time;
-        }
-    }
-}

Runtime/Messaging/Messages/AnticipationCounterSync.cs.meta

@@ -1,3 +0,0 @@
-fileFormatVersion: 2
-guid: db5034828a9741ce9bc8ec9a64d5a5b6
-timeCreated: 1706042908

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);
+                ByteUnpacker.ReadValueBitPacked(reader, out ClientIdCount);
-                return false;
+                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 (networkManager.DistributedAuthorityMode)
-            if (originalOwner == networkManager.LocalClientId)
+            {
+                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.
+            // We are new owner or (client-server) or running in distributed authority mode
-            if (OwnerClientId == networkManager.LocalClientId)
+            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 in distributed authority mode 
-            if (OwnerClientId != networkManager.LocalClientId && originalOwner != networkManager.LocalClientId)
+            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,16 +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);
-
+            }
-                // For convenience, notify all NetworkBehaviours that synchronization is complete.
+            else
-                foreach (var networkObject in networkManager.SpawnManager.SpawnedObjectsList)
+            {
+                if (networkManager.DistributedAuthorityMode && networkManager.CMBServiceConnection && networkManager.LocalClient.IsSessionOwner && networkManager.NetworkConfig.EnableSceneManagement)
                 {
-                    networkObject.InternalNetworkSessionSynchronized();
+                    // 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);
+                if (!networkManager.DistributedAuthorityMode)
-                networkManager.NetworkMetrics.TrackObjectSpawnReceived(senderId, networkObject, messageSize);
+                {
+                    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);
+                // Client-Server mode we always defer where in distributed authority mode we only defer if it is not a targeted destroy
-                return false;
+                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
+                // If this NetworkObject does not exist on this instance then exit early
-                return;
+                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);
+            // If we are deferring the despawn, then add it to the deferred despawn queue
-            networkManager.SpawnManager.OnDespawnObject(networkObject, DestroyGameObject);
+            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)))
@@ -35,13 +37,21 @@ namespace Unity.Netcode
 
             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 (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                    if (networkManager.DistributedAuthorityMode)
+                    {
+                        writer.WriteValueSafe<ushort>(0);
+                    }
+                    else if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                     {
                         BytePacker.WriteValueBitPacked(writer, (ushort)0);
                     }
@@ -55,11 +65,9 @@ namespace Unity.Netcode
 
                 var startingSize = writer.Length;
                 var networkVariable = NetworkBehaviour.NetworkVariableFields[i];
-
                 var shouldWrite = networkVariable.IsDirty() &&
                     networkVariable.CanClientRead(TargetClientId) &&
-                    (networkManager.IsServer || networkVariable.CanClientWrite(networkManager.LocalClientId)) &&
+                    (networkManager.IsServer || networkVariable.CanClientWrite(networkManager.LocalClientId));
-                    networkVariable.CanSend();
 
                 // 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
@@ -79,7 +87,14 @@ namespace Unity.Netcode
                     shouldWrite = false;
                 }
 
-                if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                if (networkManager.DistributedAuthorityMode)
+                {
+                    if (!shouldWrite)
+                    {
+                        writer.WriteValueSafe<ushort>(0);
+                    }
+                }
+                else if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                 {
                     if (!shouldWrite)
                     {
@@ -108,7 +123,26 @@ 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);
+                        }
                     }
                     networkManager.NetworkMetrics.TrackNetworkVariableDeltaSent(
                         TargetClientId,
@@ -130,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;
@@ -147,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);
 
@@ -202,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(
@@ -211,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))
                             {
@@ -237,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;
             }
 
@@ -41,7 +41,7 @@ namespace Unity.Netcode
 
             payload = new FastBufferReader(reader.GetUnsafePtrAtCurrentPosition(), Allocator.None, reader.Length - reader.Position);
 
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
             if (NetworkBehaviour.__rpc_name_table[networkBehaviour.GetType()].TryGetValue(metadata.NetworkRpcMethodId, out var rpcMethodName))
             {
                 networkManager.NetworkMetrics.TrackRpcReceived(
@@ -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/BaseRpcTarget.cs

@@ -36,12 +36,12 @@ namespace Unity.Netcode
 
         private protected void SendMessageToClient(NetworkBehaviour behaviour, ulong clientId, ref RpcMessage message, NetworkDelivery delivery)
         {
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
             var size =
 #endif
                 behaviour.NetworkManager.MessageManager.SendMessage(ref message, delivery, clientId);
 
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
             if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
             {
                 behaviour.NetworkManager.NetworkMetrics.TrackRpcSent(

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
@@ -46,11 +46,11 @@ namespace Unity.Netcode
                 message.Handle(ref context);
                 length = tempBuffer.Length;
             }
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
             if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
             {
-                behaviour.NetworkManager.NetworkMetrics.TrackRpcSent(
+                networkManager.NetworkMetrics.TrackRpcSent(
-                    behaviour.NetworkManager.LocalClientId,
+                    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,7 +49,8 @@ namespace Unity.Netcode
                     {
                         continue;
                     }
-                    if (clientId == NetworkManager.ServerClientId)
+                    // 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;
                     }
@@ -57,7 +58,9 @@ namespace Unity.Netcode
                 }
             }
             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/NotServerRpcTarget.cs

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

Runtime/Messaging/RpcTargets/ProxyRpcTargetGroup.cs

@@ -18,12 +18,12 @@ namespace Unity.Netcode
         internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
         {
             var proxyMessage = new ProxyMessage { Delivery = delivery, TargetClientIds = TargetClientIds.AsArray(), WrappedMessage = message };
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
             var size =
 #endif
                 behaviour.NetworkManager.MessageManager.SendMessage(ref proxyMessage, delivery, NetworkManager.ServerClientId);
 
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
             if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
             {
                 foreach (var clientId in TargetClientIds)

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/AnticipatedNetworkVariable.cs

@@ -1,392 +0,0 @@
-using System;
-using Unity.Mathematics;
-using UnityEngine;
-
-namespace Unity.Netcode
-{
-
-    public enum StaleDataHandling
-    {
-        Ignore,
-        Reanticipate
-    }
-
-#pragma warning disable IDE0001
-    /// <summary>
-    /// A variable that can be synchronized over the network.
-    /// This version supports basic client anticipation - the client can set a value on the belief that the server
-    /// will update it to reflect the same value in a future update (i.e., as the result of an RPC call).
-    /// This value can then be adjusted as new updates from the server come in, in three basic modes:
-    ///
-    /// <list type="bullet">
-    ///
-    /// <item><b>Snap:</b> In this mode (with <see cref="StaleDataHandling"/> set to
-    /// <see cref="Netcode.StaleDataHandling.Ignore"/> and no <see cref="NetworkBehaviour.OnReanticipate"/> callback),
-    /// the moment a more up-to-date value is received from the authority, it will simply replace the anticipated value,
-    /// resulting in a "snap" to the new value if it is different from the anticipated value.</item>
-    ///
-    /// <item><b>Smooth:</b> In this mode (with <see cref="StaleDataHandling"/> set to
-    /// <see cref="Netcode.StaleDataHandling.Ignore"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> callback that calls
-    /// <see cref="Smooth"/> from the anticipated value to the authority value with an appropriate
-    /// <see cref="Mathf.Lerp"/>-style smooth function), when a more up-to-date value is received from the authority,
-    /// it will interpolate over time from an incorrect anticipated value to the correct authoritative value.</item>
-    ///
-    /// <item><b>Constant Reanticipation:</b> In this mode (with <see cref="StaleDataHandling"/> set to
-    /// <see cref="Netcode.StaleDataHandling.Reanticipate"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> that calculates a
-    /// new anticipated value based on the current authoritative value), when a more up-to-date value is received from
-    /// the authority, user code calculates a new anticipated value, possibly calling <see cref="Smooth"/> to interpolate
-    /// between the previous anticipation and the new anticipation. This is useful for values that change frequently and
-    /// need to constantly be re-evaluated, as opposed to values that change only in response to user action and simply
-    /// need a one-time anticipation when the user performs that action.</item>
-    ///
-    /// </list>
-    ///
-    /// Note that these three modes may be combined. For example, if an <see cref="NetworkBehaviour.OnReanticipate"/> callback
-    /// does not call either <see cref="Smooth"/> or <see cref="Anticipate"/>, the result will be a snap to the
-    /// authoritative value, enabling for a callback that may conditionally call <see cref="Smooth"/> when the
-    /// difference between the anticipated and authoritative values is within some threshold, but fall back to
-    /// snap behavior if the difference is too large.
-    /// </summary>
-    /// <typeparam name="T">the unmanaged type for <see cref="NetworkVariable{T}"/> </typeparam>
-#pragma warning restore IDE0001
-    [Serializable]
-    [GenerateSerializationForGenericParameter(0)]
-    public class AnticipatedNetworkVariable<T> : NetworkVariableBase
-    {
-        [SerializeField]
-        private NetworkVariable<T> m_AuthoritativeValue;
-        private T m_AnticipatedValue;
-        private T m_PreviousAnticipatedValue;
-        private ulong m_LastAuthorityUpdateCounter = 0;
-        private ulong m_LastAnticipationCounter = 0;
-        private bool m_IsDisposed = false;
-        private bool m_SettingAuthoritativeValue = false;
-
-        private T m_SmoothFrom;
-        private T m_SmoothTo;
-        private float m_SmoothDuration;
-        private float m_CurrentSmoothTime;
-        private bool m_HasSmoothValues;
-
-#pragma warning disable IDE0001
-        /// <summary>
-        /// Defines what the behavior should be if we receive a value from the server with an earlier associated
-        /// time value than the anticipation time value.
-        /// <br/><br/>
-        /// If this is <see cref="Netcode.StaleDataHandling.Ignore"/>, the stale data will be ignored and the authoritative
-        /// value will not replace the anticipated value until the anticipation time is reached. <see cref="OnAuthoritativeValueChanged"/>
-        /// and <see cref="NetworkBehaviour.OnReanticipate"/> will also not be invoked for this stale data.
-        /// <br/><br/>
-        /// If this is <see cref="Netcode.StaleDataHandling.Reanticipate"/>, the stale data will replace the anticipated data and
-        /// <see cref="OnAuthoritativeValueChanged"/> and <see cref="NetworkBehaviour.OnReanticipate"/> will be invoked.
-        /// In this case, the authoritativeTime value passed to <see cref="NetworkBehaviour.OnReanticipate"/> will be lower than
-        /// the anticipationTime value, and that callback can be used to calculate a new anticipated value.
-        /// </summary>
-#pragma warning restore IDE0001
-        public StaleDataHandling StaleDataHandling;
-
-        public delegate void OnAuthoritativeValueChangedDelegate(AnticipatedNetworkVariable<T> variable, in T previousValue, in T newValue);
-
-        /// <summary>
-        /// Invoked any time the authoritative value changes, even when the data is stale or has been changed locally.
-        /// </summary>
-        public OnAuthoritativeValueChangedDelegate OnAuthoritativeValueChanged = null;
-
-        /// <summary>
-        /// Determines if the difference between the last serialized value and the current value is large enough
-        /// to serialize it again.
-        /// </summary>
-        public event NetworkVariable<T>.CheckExceedsDirtinessThresholdDelegate CheckExceedsDirtinessThreshold
-        {
-            add => m_AuthoritativeValue.CheckExceedsDirtinessThreshold += value;
-            remove => m_AuthoritativeValue.CheckExceedsDirtinessThreshold -= value;
-        }
-
-        private class AnticipatedObject : IAnticipatedObject
-        {
-            public AnticipatedNetworkVariable<T> Variable;
-
-            public void Update()
-            {
-                Variable.Update();
-            }
-
-            public void ResetAnticipation()
-            {
-                Variable.ShouldReanticipate = false;
-            }
-
-            public NetworkObject OwnerObject => Variable.m_NetworkBehaviour.NetworkObject;
-        }
-
-        private AnticipatedObject m_AnticipatedObject;
-
-        public override void OnInitialize()
-        {
-            m_AuthoritativeValue.Initialize(m_NetworkBehaviour);
-            NetworkVariableSerialization<T>.Duplicate(m_AuthoritativeValue.Value, ref m_AnticipatedValue);
-            NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
-            if (m_NetworkBehaviour != null && m_NetworkBehaviour.NetworkManager != null && m_NetworkBehaviour.NetworkManager.AnticipationSystem != null)
-            {
-                m_AnticipatedObject = new AnticipatedObject { Variable = this };
-                m_NetworkBehaviour.NetworkManager.AnticipationSystem.AllAnticipatedObjects.Add(m_AnticipatedObject);
-            }
-        }
-
-        public override bool ExceedsDirtinessThreshold()
-        {
-            return m_AuthoritativeValue.ExceedsDirtinessThreshold();
-        }
-
-        /// <summary>
-        /// Retrieves the current value for the variable.
-        /// This is the "display value" for this variable, and is affected by <see cref="Anticipate"/> and
-        /// <see cref="Smooth"/>, as well as by updates from the authority, depending on <see cref="StaleDataHandling"/>
-        /// and the behavior of any <see cref="NetworkBehaviour.OnReanticipate"/> callbacks.
-        /// <br /><br />
-        /// When a server update arrives, this value will be overwritten
-        /// by the new server value (unless stale data handling is set
-        /// to "Ignore" and the update is determined to be stale).
-        /// This value will be duplicated in
-        /// <see cref="PreviousAnticipatedValue"/>, which
-        /// will NOT be overwritten in server updates.
-        /// </summary>
-        public T Value => m_AnticipatedValue;
-
-        /// <summary>
-        /// Indicates whether this variable currently needs
-        /// reanticipation. If this is true, the anticipated value
-        /// has been overwritten by the authoritative value from the
-        /// server; the previous anticipated value is stored in <see cref="PreviousAnticipatedState"/>
-        /// </summary>
-        public bool ShouldReanticipate
-        {
-            get;
-            private set;
-        }
-
-        /// <summary>
-        /// Holds the most recent anticipated value, whatever was
-        /// most recently set using <see cref="Anticipate"/>. Unlike
-        /// <see cref="Value"/>, this does not get overwritten
-        /// when a server update arrives.
-        /// </summary>
-        public T PreviousAnticipatedValue => m_PreviousAnticipatedValue;
-
-        /// <summary>
-        /// Sets the current value of the variable on the expectation that the authority will set the variable
-        /// to the same value within one network round trip (i.e., in response to an RPC).
-        /// </summary>
-        /// <param name="value"></param>
-        public void Anticipate(T value)
-        {
-            if (m_NetworkBehaviour.NetworkManager.ShutdownInProgress || !m_NetworkBehaviour.NetworkManager.IsListening)
-            {
-                return;
-            }
-            m_SmoothDuration = 0;
-            m_CurrentSmoothTime = 0;
-            m_LastAnticipationCounter = m_NetworkBehaviour.NetworkManager.AnticipationSystem.AnticipationCounter;
-            m_AnticipatedValue = value;
-            NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
-            if (CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
-            {
-                AuthoritativeValue = value;
-            }
-        }
-
-#pragma warning disable IDE0001
-        /// <summary>
-        /// Retrieves or sets the underlying authoritative value.
-        /// Note that only a client or server with write permissions to this variable may set this value.
-        /// When this variable has been anticipated, this value will alawys return the most recent authoritative
-        /// state, which is updated even if <see cref="StaleDataHandling"/> is <see cref="Netcode.StaleDataHandling.Ignore"/>.
-        /// </summary>
-#pragma warning restore IDE0001
-        public T AuthoritativeValue
-        {
-            get => m_AuthoritativeValue.Value;
-            set
-            {
-                m_SettingAuthoritativeValue = true;
-                try
-                {
-                    m_AuthoritativeValue.Value = value;
-                    m_AnticipatedValue = value;
-                    NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
-                }
-                finally
-                {
-                    m_SettingAuthoritativeValue = false;
-                }
-            }
-        }
-
-        /// <summary>
-        /// A function to interpolate between two values based on a percentage.
-        /// See <see cref="Mathf.Lerp"/>, <see cref="Vector3.Lerp"/>, <see cref="Vector3.Slerp"/>, and so on
-        /// for examples.
-        /// </summary>
-        public delegate T SmoothDelegate(T authoritativeValue, T anticipatedValue, float amount);
-
-        private SmoothDelegate m_SmoothDelegate = null;
-
-        public AnticipatedNetworkVariable(T value = default,
-            StaleDataHandling staleDataHandling = StaleDataHandling.Ignore)
-            : base()
-        {
-            StaleDataHandling = staleDataHandling;
-            m_AuthoritativeValue = new NetworkVariable<T>(value)
-            {
-                OnValueChanged = OnValueChangedInternal
-            };
-        }
-
-        public void Update()
-        {
-            if (m_CurrentSmoothTime < m_SmoothDuration)
-            {
-                m_CurrentSmoothTime += m_NetworkBehaviour.NetworkManager.RealTimeProvider.DeltaTime;
-                var pct = math.min(m_CurrentSmoothTime / m_SmoothDuration, 1f);
-                m_AnticipatedValue = m_SmoothDelegate(m_SmoothFrom, m_SmoothTo, pct);
-                NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
-            }
-        }
-
-        public override void Dispose()
-        {
-            if (m_IsDisposed)
-            {
-                return;
-            }
-
-            if (m_NetworkBehaviour != null && m_NetworkBehaviour.NetworkManager != null && m_NetworkBehaviour.NetworkManager.AnticipationSystem != null)
-            {
-                if (m_AnticipatedObject != null)
-                {
-                    m_NetworkBehaviour.NetworkManager.AnticipationSystem.AllAnticipatedObjects.Remove(m_AnticipatedObject);
-                    m_NetworkBehaviour.NetworkManager.AnticipationSystem.ObjectsToReanticipate.Remove(m_AnticipatedObject);
-                    m_AnticipatedObject = null;
-                }
-            }
-
-            m_IsDisposed = true;
-
-            m_AuthoritativeValue.Dispose();
-            if (m_AnticipatedValue is IDisposable anticipatedValueDisposable)
-            {
-                anticipatedValueDisposable.Dispose();
-            }
-
-            m_AnticipatedValue = default;
-            if (m_PreviousAnticipatedValue is IDisposable previousValueDisposable)
-            {
-                previousValueDisposable.Dispose();
-                m_PreviousAnticipatedValue = default;
-            }
-
-            if (m_HasSmoothValues)
-            {
-                if (m_SmoothFrom is IDisposable smoothFromDisposable)
-                {
-                    smoothFromDisposable.Dispose();
-                    m_SmoothFrom = default;
-                }
-                if (m_SmoothTo is IDisposable smoothToDisposable)
-                {
-                    smoothToDisposable.Dispose();
-                    m_SmoothTo = default;
-                }
-
-                m_HasSmoothValues = false;
-            }
-        }
-
-        ~AnticipatedNetworkVariable()
-        {
-            Dispose();
-        }
-
-        private void OnValueChangedInternal(T previousValue, T newValue)
-        {
-            if (!m_SettingAuthoritativeValue)
-            {
-                m_LastAuthorityUpdateCounter = m_NetworkBehaviour.NetworkManager.AnticipationSystem.LastAnticipationAck;
-                if (StaleDataHandling == StaleDataHandling.Ignore && m_LastAnticipationCounter > m_LastAuthorityUpdateCounter)
-                {
-                    // Keep the anticipated value unchanged because it is more recent than the authoritative one.
-                    return;
-                }
-
-
-                ShouldReanticipate = true;
-                m_NetworkBehaviour.NetworkManager.AnticipationSystem.ObjectsToReanticipate.Add(m_AnticipatedObject);
-            }
-
-            NetworkVariableSerialization<T>.Duplicate(AuthoritativeValue, ref m_AnticipatedValue);
-
-            m_SmoothDuration = 0;
-            m_CurrentSmoothTime = 0;
-            OnAuthoritativeValueChanged?.Invoke(this, previousValue, newValue);
-        }
-
-        /// <summary>
-        /// Interpolate this variable from <see cref="from"/> to <see cref="to"/> over <see cref="durationSeconds"/> of
-        /// real time. The duration uses <see cref="Time.deltaTime"/>, so it is affected by <see cref="Time.timeScale"/>.
-        /// </summary>
-        /// <param name="from"></param>
-        /// <param name="to"></param>
-        /// <param name="durationSeconds"></param>
-        /// <param name="how"></param>
-        public void Smooth(in T from, in T to, float durationSeconds, SmoothDelegate how)
-        {
-            if (durationSeconds <= 0)
-            {
-                NetworkVariableSerialization<T>.Duplicate(to, ref m_AnticipatedValue);
-                m_SmoothDuration = 0;
-                m_CurrentSmoothTime = 0;
-                m_SmoothDelegate = null;
-                return;
-            }
-            NetworkVariableSerialization<T>.Duplicate(from, ref m_AnticipatedValue);
-            NetworkVariableSerialization<T>.Duplicate(from, ref m_SmoothFrom);
-            NetworkVariableSerialization<T>.Duplicate(to, ref m_SmoothTo);
-            m_SmoothDuration = durationSeconds;
-            m_CurrentSmoothTime = 0;
-            m_SmoothDelegate = how;
-            m_HasSmoothValues = true;
-        }
-
-        public override bool IsDirty()
-        {
-            return m_AuthoritativeValue.IsDirty();
-        }
-
-        public override void ResetDirty()
-        {
-            m_AuthoritativeValue.ResetDirty();
-        }
-
-        public override void WriteDelta(FastBufferWriter writer)
-        {
-            m_AuthoritativeValue.WriteDelta(writer);
-        }
-
-        public override void WriteField(FastBufferWriter writer)
-        {
-            m_AuthoritativeValue.WriteField(writer);
-        }
-
-        public override void ReadField(FastBufferReader reader)
-        {
-            m_AuthoritativeValue.ReadField(reader);
-            NetworkVariableSerialization<T>.Duplicate(m_AuthoritativeValue.Value, ref m_AnticipatedValue);
-            NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
-        }
-
-        public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
-        {
-            m_AuthoritativeValue.ReadDelta(reader, keepDirtyDelta);
-        }
-    }
-}

Runtime/NetworkVariable/AnticipatedNetworkVariable.cs.meta

@@ -1,3 +0,0 @@
-fileFormatVersion: 2
-guid: 10f5188736b742d1993a2aad46a03e78
-timeCreated: 1705595868

Runtime/NetworkVariable/CollectionSerializationUtility.cs

@@ -505,8 +505,13 @@ namespace Unity.Netcode
             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))
@@ -549,7 +554,11 @@ namespace Unity.Netcode
 
                 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))
@@ -571,8 +580,8 @@ namespace Unity.Netcode
         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 added = stackalloc T[value.Count];
-            var removed = stackalloc T[previousValue.Count()];
+            var removed = stackalloc T[previousValue.Count];
             var addedCount = 0;
             var removedCount = 0;
             foreach (var item in value)
@@ -592,8 +601,11 @@ namespace Unity.Netcode
                     ++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);
@@ -643,14 +655,21 @@ namespace Unity.Netcode
             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)
                 {
@@ -673,7 +692,11 @@ namespace Unity.Netcode
                 }
             }
 
+#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);

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,10 +391,9 @@ namespace Unity.Netcode
         public void Add(T item)
         {
             // check write permissions
-            if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
+            if (!CanClientWrite(m_NetworkManager.LocalClientId))
             {
-                LogWritePermissionError();
+                throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
-                return;
             }
 
             m_List.Add(item);
@@ -389,10 +412,9 @@ namespace Unity.Netcode
         public void Clear()
         {
             // check write permissions
-            if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
+            if (!CanClientWrite(m_NetworkManager.LocalClientId))
             {
-                LogWritePermissionError();
+                throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
-                return;
             }
 
             m_List.Clear();
@@ -416,10 +438,9 @@ namespace Unity.Netcode
         public bool Remove(T item)
         {
             // check write permissions
-            if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
+            if (!CanClientWrite(m_NetworkManager.LocalClientId))
             {
-                LogWritePermissionError();
+                throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
-                return false;
             }
 
             int index = m_List.IndexOf(item);
@@ -452,10 +473,9 @@ namespace Unity.Netcode
         public void Insert(int index, T item)
         {
             // check write permissions
-            if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
+            if (!CanClientWrite(m_NetworkManager.LocalClientId))
             {
-                LogWritePermissionError();
+                throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
-                return;
             }
 
             if (index < m_List.Length)
@@ -482,10 +502,9 @@ namespace Unity.Netcode
         public void RemoveAt(int index)
         {
             // check write permissions
-            if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
+            if (!CanClientWrite(m_NetworkManager.LocalClientId))
             {
-                LogWritePermissionError();
+                throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
-                return;
             }
 
             var value = m_List[index];
@@ -508,10 +527,9 @@ namespace Unity.Netcode
             set
             {
                 // check write permissions
-                if (!CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
+                if (!CanClientWrite(m_NetworkManager.LocalClientId))
                 {
-                    LogWritePermissionError();
+                    throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
-                    return;
                 }
 
                 var previousValue = m_List[index];
@@ -557,6 +575,7 @@ namespace Unity.Netcode
         {
             m_List.Dispose();
             m_DirtyEvents.Dispose();
+            base.Dispose();
         }
     }
 

Runtime/NetworkVariable/NetworkVariable.cs

@@ -21,28 +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;
-        public delegate bool CheckExceedsDirtinessThresholdDelegate(in T previousValue, in T newValue);
-
-        public CheckExceedsDirtinessThresholdDelegate CheckExceedsDirtinessThreshold;
-
-        public override bool ExceedsDirtinessThreshold()
-        {
-            if (CheckExceedsDirtinessThreshold != null && m_HasPreviousValue)
-            {
-                return CheckExceedsDirtinessThreshold(m_PreviousValue, m_InternalValue);
-            }
-
-            return true;
-        }
-
-        public override void OnInitialize()
-        {
-            base.OnInitialize();
-
-            m_HasPreviousValue = true;
-            NetworkVariableSerialization<T>.Duplicate(m_InternalValue, ref m_PreviousValue);
-        }
 
         /// <summary>
         /// Constructor for <see cref="NetworkVariable{T}"/>
@@ -65,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>
@@ -79,57 +71,25 @@ namespace Unity.Netcode
         /// <summary>
         /// The value of the NetworkVariable container
         /// </summary>
-        /// <remarks>
-        /// When assigning collections to <see cref="Value"/>, unless it is a completely new collection this will not
-        /// detect any deltas with most managed collection classes since assignment of one collection value to another
-        /// is actually just a reference to the collection itself. <br />
-        /// To detect deltas in a collection, you should invoke <see cref="CheckDirtyState"/> after making modifications to the collection.
-        /// </remarks>
         public virtual T Value
         {
             get => m_InternalValue;
             set
             {
-                if (m_NetworkManager && !CanClientWrite(m_NetworkManager.LocalClientId))
+                // Compare bitwise
+                if (NetworkVariableSerialization<T>.AreEqual(ref m_InternalValue, ref value))
                 {
-                    LogWritePermissionError();
                     return;
                 }
 
-                // Compare the Value being applied to the current value
+                if (m_NetworkManager && !CanClientWrite(m_NetworkManager.LocalClientId))
-                if (!NetworkVariableSerialization<T>.AreEqual(ref m_InternalValue, ref value))
                 {
-                    T previousValue = m_InternalValue;
+                    throw new InvalidOperationException($"[Client-{m_NetworkManager.LocalClientId}][{m_NetworkBehaviour.name}][{Name}] Write permissions ({WritePerm}) for this client instance is not allowed!");
-                    m_InternalValue = value;
-                    SetDirty(true);
-                    m_IsDisposed = false;
-                    OnValueChanged?.Invoke(previousValue, m_InternalValue);
                 }
-            }
-        }
 
-        /// <summary>
+                Set(value);
-        /// Invoke this method to check if a collection's items are dirty.
-        /// The default behavior is to exit early if the <see cref="NetworkVariable{T}"/> is already dirty.
-        /// </summary>
-        /// <param name="forceCheck"> when true, this check will force a full item collection check even if the NetworkVariable is already dirty</param>
-        /// <remarks>
-        /// This is to be used as a way to check if a <see cref="NetworkVariable{T}"/> containing a managed collection has any changees to the collection items.<br />
-        /// If you invoked this when a collection is dirty, it will not trigger the <see cref="OnValueChanged"/> unless you set <param name="forceCheck"/> to true. <br />
-        /// </remarks>
-        public bool CheckDirtyState(bool forceCheck = false)
-        {
-            var isDirty = base.IsDirty();
-
-            // Compare the previous with the current if not dirty or forcing a check.
-            if ((!isDirty || forceCheck) && !NetworkVariableSerialization<T>.AreEqual(ref m_PreviousValue, ref m_InternalValue))
-            {
-                SetDirty(true);
-                OnValueChanged?.Invoke(m_PreviousValue, m_InternalValue);
                 m_IsDisposed = false;
-                isDirty = true;
             }
-            return isDirty;
         }
 
         internal ref T RefValue()
@@ -158,6 +118,8 @@ namespace Unity.Netcode
             }
 
             m_PreviousValue = default;
+
+            base.Dispose();
         }
 
         ~NetworkVariable()
@@ -216,8 +178,9 @@ namespace Unity.Netcode
         private protected void Set(T value)
         {
             SetDirty(true);
+            T previousValue = m_InternalValue;
             m_InternalValue = value;
-            OnValueChanged?.Invoke(m_PreviousValue, m_InternalValue);
+            OnValueChanged?.Invoke(previousValue, m_InternalValue);
         }
 
         /// <summary>
@@ -236,22 +199,20 @@ namespace Unity.Netcode
         /// <param name="keepDirtyDelta">Whether or not the container should keep the dirty delta, or mark the delta as consumed</param>
         public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
         {
-            // In order to get managed collections to properly have a previous and current value, we have to
-            // duplicate the collection at this point before making any modifications to the current.
-            m_HasPreviousValue = true;
-            NetworkVariableSerialization<T>.Duplicate(m_InternalValue, ref m_PreviousValue);
-            NetworkVariableSerialization<T>.ReadDelta(reader, ref m_InternalValue);
-
             // todo:
             // keepDirtyDelta marks a variable received as dirty and causes the server to send the value to clients
             // In a prefect world, whether a variable was A) modified locally or B) received and needs retransmit
             // would be stored in different fields
+
+            T previousValue = m_InternalValue;
+            NetworkVariableSerialization<T>.ReadDelta(reader, ref m_InternalValue);
+
             if (keepDirtyDelta)
             {
                 SetDirty(true);
             }
 
-            OnValueChanged?.Invoke(m_PreviousValue, m_InternalValue);
+            OnValueChanged?.Invoke(previousValue, m_InternalValue);
         }
 
         /// <inheritdoc />

Runtime/NetworkVariable/NetworkVariableBase.cs

@@ -3,26 +3,11 @@ using UnityEngine;
 
 namespace Unity.Netcode
 {
-    public struct NetworkVariableUpdateTraits
-    {
-        [Tooltip("The minimum amount of time that must pass between sending updates. If this amount of time has not passed since the last update, dirtiness will be ignored.")]
-        public float MinSecondsBetweenUpdates;
-
-        [Tooltip("The maximum amount of time that a variable can be dirty without sending an update. If this amount of time has passed since the last update, an update will be sent even if the dirtiness threshold has not been met.")]
-        public float MaxSecondsBetweenUpdates;
-    }
-
     /// <summary>
     /// Interface for network value containers
     /// </summary>
     public abstract class NetworkVariableBase : IDisposable
     {
-        [SerializeField]
-        internal NetworkVariableUpdateTraits UpdateTraits = default;
-
-        [NonSerialized]
-        internal double LastUpdateSent;
-
         /// <summary>
         /// The delivery type (QoS) to send data with
         /// </summary>
@@ -32,22 +17,10 @@ namespace Unity.Netcode
         /// Maintains a link to the associated NetworkBehaviour
         /// </summary>
         private protected NetworkBehaviour m_NetworkBehaviour;
+
         private NetworkManager m_InternalNetworkManager;
 
-        public NetworkBehaviour GetBehaviour()
+        internal virtual NetworkVariableType Type => NetworkVariableType.Custom;
-        {
-            return m_NetworkBehaviour;
-        }
-
-        internal string GetWritePermissionError()
-        {
-            return $"|Client-{m_NetworkManager.LocalClientId}|{m_NetworkBehaviour.name}|{Name}| Write permissions ({WritePerm}) for this client instance is not allowed!";
-        }
-
-        internal void LogWritePermissionError()
-        {
-            Debug.LogError(GetWritePermissionError());
-        }
 
         private protected NetworkManager m_NetworkManager
         {
@@ -61,6 +34,11 @@ namespace Unity.Netcode
             }
         }
 
+        public NetworkBehaviour GetBehaviour()
+        {
+            return m_NetworkBehaviour;
+        }
+
         /// <summary>
         /// Initializes the NetworkVariable
         /// </summary>
@@ -72,42 +50,9 @@ namespace Unity.Netcode
             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
-                if (m_NetworkBehaviour.NetworkManager.NetworkTimeSystem != null)
+                InternalWritePerm = m_InternalNetworkManager.DistributedAuthorityMode ? NetworkVariableWritePermission.Owner : InternalWritePerm;
-                {
-                    UpdateLastSentTime();
-                }
             }
-
-            OnInitialize();
-        }
-
-        /// <summary>
-        /// Called on initialization
-        /// </summary>
-        public virtual void OnInitialize()
-        {
-
-        }
-
-        /// <summary>
-        /// Sets the update traits for this network variable to determine how frequently it will send updates.
-        /// </summary>
-        /// <param name="traits"></param>
-        public void SetUpdateTraits(NetworkVariableUpdateTraits traits)
-        {
-            UpdateTraits = traits;
-        }
-
-        /// <summary>
-        /// Check whether or not this variable has changed significantly enough to send an update.
-        /// If not, no update will be sent even if the variable is dirty, unless the time since last update exceeds
-        /// the <see cref="UpdateTraits"/>' <see cref="NetworkVariableUpdateTraits.MaxSecondsBetweenUpdates"/>.
-        /// </summary>
-        /// <returns></returns>
-        public virtual bool ExceedsDirtinessThreshold()
-        {
-            return true;
         }
 
         /// <summary>
@@ -131,7 +76,7 @@ namespace Unity.Netcode
             NetworkVariableWritePermission writePerm = DefaultWritePerm)
         {
             ReadPerm = readPerm;
-            WritePerm = writePerm;
+            InternalWritePerm = writePerm;
         }
 
         /// <summary>
@@ -154,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
@@ -170,31 +125,17 @@ namespace Unity.Netcode
             }
         }
 
-        internal bool CanSend()
+        internal static bool IgnoreInitializeWarning;
-        {
-            var timeSinceLastUpdate = m_NetworkBehaviour.NetworkManager.NetworkTimeSystem.LocalTime - LastUpdateSent;
-            return
-                (
-                    UpdateTraits.MaxSecondsBetweenUpdates > 0 &&
-                    timeSinceLastUpdate >= UpdateTraits.MaxSecondsBetweenUpdates
-                ) ||
-                (
-                    timeSinceLastUpdate >= UpdateTraits.MinSecondsBetweenUpdates &&
-                    ExceedsDirtinessThreshold()
-                );
-        }
-
-        internal void UpdateLastSentTime()
-        {
-            LastUpdateSent = m_NetworkBehaviour.NetworkManager.NetworkTimeSystem.LocalTime;
-        }
 
         protected void MarkNetworkBehaviourDirty()
         {
             if (m_NetworkBehaviour == null)
             {
-                Debug.LogWarning($"NetworkVariable is written to, but doesn't know its NetworkBehaviour yet. " +
+                if (!IgnoreInitializeWarning)
-                                 "Are you modifying a NetworkVariable before the NetworkObject is spawned?");
+                {
+                    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)
@@ -206,17 +147,7 @@ namespace Unity.Netcode
                 }
                 return;
             }
-
+            m_NetworkBehaviour.NetworkManager.BehaviourUpdater?.AddForUpdate(m_NetworkBehaviour.NetworkObject);
-            if (!m_NetworkBehaviour.NetworkManager.IsListening)
-            {
-                if (m_NetworkBehaviour.NetworkManager.LogLevel <= LogLevel.Developer)
-                {
-                    Debug.LogWarning($"NetworkVariable is written to after the NetworkManager has already shutdown! " +
-                     "Are you modifying a NetworkVariable within a NetworkBehaviour.OnDestroy or NetworkBehaviour.OnDespawn method?");
-                }
-                return;
-            }
-            m_NetworkBehaviour.NetworkManager.BehaviourUpdater.AddForUpdate(m_NetworkBehaviour.NetworkObject);
         }
 
         /// <summary>
@@ -243,11 +174,11 @@ namespace Unity.Netcode
         /// <returns>Whether or not the client has permission to read</returns>
         public bool CanClientRead(ulong clientId)
         {
-            if (!m_NetworkBehaviour)
+            // When in distributed authority mode, everyone can read (but only the owner can write)
+            if (m_NetworkManager != null && m_NetworkManager.DistributedAuthorityMode)
             {
-                return false;
+                return true;
             }
-
             switch (ReadPerm)
             {
                 default:
@@ -265,11 +196,6 @@ namespace Unity.Netcode
         /// <returns>Whether or not the client has permission to write</returns>
         public bool CanClientWrite(ulong clientId)
         {
-            if (!m_NetworkBehaviour)
-            {
-                return false;
-            }
-
             switch (WritePerm)
             {
                 default:
@@ -318,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/NetworkVariableSerialization.cs

@@ -349,10 +349,7 @@ namespace Unity.Netcode
             duplicatedValue.Clear();
             foreach (var item in value)
             {
-                // This handles the nested list scenario List<List<T>>
+                duplicatedValue.Add(item);
-                T subValue = default;
-                NetworkVariableSerialization<T>.Duplicate(item, ref subValue);
-                duplicatedValue.Add(subValue);
             }
         }
     }
@@ -424,9 +421,6 @@ namespace Unity.Netcode
             duplicatedValue.Clear();
             foreach (var item in value)
             {
-                // Handles nested HashSets
-                T subValue = default;
-                NetworkVariableSerialization<T>.Duplicate(item, ref subValue);
                 duplicatedValue.Add(item);
             }
         }
@@ -503,12 +497,7 @@ namespace Unity.Netcode
             duplicatedValue.Clear();
             foreach (var item in value)
             {
-                // Handles nested dictionaries
+                duplicatedValue.Add(item.Key, item.Value);
-                TKey subKey = default;
-                TVal subValue = default;
-                NetworkVariableSerialization<TKey>.Duplicate(item.Key, ref subKey);
-                NetworkVariableSerialization<TVal>.Duplicate(item.Value, ref subValue);
-                duplicatedValue.Add(subKey, subValue);
             }
         }
     }
@@ -709,7 +698,7 @@ namespace Unity.Netcode
             {
                 var val = value[i];
                 var prevVal = previousValue[i];
-                if (val != prevVal)
+                if (!NetworkVariableSerialization<byte>.AreEqual(ref val, ref prevVal))
                 {
                     ++numChanges;
                     changes.Set(i);
@@ -728,17 +717,25 @@ namespace Unity.Netcode
                 writer.WriteValueSafe(value);
                 return;
             }
-            writer.WriteByteSafe(0);
+            writer.WriteByte(0);
             BytePacker.WriteValuePacked(writer, value.Length);
             writer.WriteValueSafe(changes);
             unsafe
             {
                 byte* ptr = value.GetUnsafePtr();
+                byte* prevPtr = previousValue.GetUnsafePtr();
                 for (int i = 0; i < value.Length; ++i)
                 {
                     if (changes.IsSet(i))
                     {
-                        writer.WriteByteSafe(ptr[i]);
+                        if (i < previousValue.Length)
+                        {
+                            NetworkVariableSerialization<byte>.WriteDelta(writer, ref ptr[i], ref prevPtr[i]);
+                        }
+                        else
+                        {
+                            NetworkVariableSerialization<byte>.Write(writer, ref ptr[i]);
+                        }
                     }
                 }
             }
@@ -769,7 +766,7 @@ namespace Unity.Netcode
                 {
                     if (changes.IsSet(i))
                     {
-                        reader.ReadByteSafe(out ptr[i]);
+                        reader.ReadByte(out ptr[i]);
                     }
                 }
             }
@@ -1270,6 +1267,14 @@ namespace Unity.Netcode
             NetworkVariableSerialization<long>.AreEqual = NetworkVariableSerialization<long>.ValueEquals;
             NetworkVariableSerialization<ulong>.Serializer = new UlongSerializer();
             NetworkVariableSerialization<ulong>.AreEqual = NetworkVariableSerialization<ulong>.ValueEquals;
+
+            // DANGO-EXP TODO: Determine if this is distributed authority only and impacts of this in client-server
+            NetworkVariableSerialization<short>.Type = CollectionItemType.Short;
+            NetworkVariableSerialization<ushort>.Type = CollectionItemType.UShort;
+            NetworkVariableSerialization<int>.Type = CollectionItemType.Int;
+            NetworkVariableSerialization<uint>.Type = CollectionItemType.UInt;
+            NetworkVariableSerialization<long>.Type = CollectionItemType.Long;
+            NetworkVariableSerialization<ulong>.Type = CollectionItemType.ULong;
         }
 
         /// <summary>
@@ -1279,6 +1284,8 @@ namespace Unity.Netcode
         public static void InitializeSerializer_UnmanagedByMemcpy<T>() where T : unmanaged
         {
             NetworkVariableSerialization<T>.Serializer = new UnmanagedTypeSerializer<T>();
+            // DANGO-EXP TODO: Determine if this is distributed authority only and impacts of this in client-server
+            NetworkVariableSerialization<T>.Type = CollectionItemType.Unmanaged;
         }
 
         /// <summary>
@@ -1557,6 +1564,12 @@ namespace Unity.Netcode
     {
         internal static INetworkVariableSerializer<T> Serializer = new FallbackSerializer<T>();
 
+        /// <summary>
+        /// The collection item type tells the CMB server how to read the bytes of each item in the collection
+        /// </summary>
+        /// DANGO-EXP TODO: Determine if this is distributed authority only and impacts of this in client-server
+        internal static CollectionItemType Type = CollectionItemType.Unknown;
+
         /// <summary>
         /// A callback to check if two values are equal.
         /// </summary>
@@ -1728,8 +1741,14 @@ namespace Unity.Netcode
                 return false;
             }
 
+#if UTP_TRANSPORT_2_0_ABOVE
+            var aptr = a.GetUnsafePtr();
+            var bptr = b.GetUnsafePtr();
+#else
             var aptr = (TValueType*)a.GetUnsafePtr();
             var bptr = (TValueType*)b.GetUnsafePtr();
+#endif
+
             return UnsafeUtility.MemCmp(aptr, bptr, sizeof(TValueType) * a.Length) == 0;
         }
 #endif
@@ -1858,8 +1877,13 @@ namespace Unity.Netcode
                 return false;
             }
 
+#if UTP_TRANSPORT_2_0_ABOVE
+            var aptr = a.GetUnsafePtr();
+            var bptr = b.GetUnsafePtr();
+#else
             var aptr = (TValueType*)a.GetUnsafePtr();
             var bptr = (TValueType*)b.GetUnsafePtr();
+#endif
             for (var i = 0; i < a.Length; ++i)
             {
                 if (!EqualityEquals(ref aptr[i], ref bptr[i]))
@@ -1883,7 +1907,11 @@ namespace Unity.Netcode
                 return true;
             }
 
+#if UTP_TRANSPORT_2_0_ABOVE
+            if (a.Count != b.Count)
+#else
             if (a.Count() != b.Count())
+#endif
             {
                 return false;
             }
@@ -1996,7 +2024,11 @@ namespace Unity.Netcode
                 return true;
             }
 
+#if UTP_TRANSPORT_2_0_ABOVE
+            if (a.Count != b.Count)
+#else
             if (a.Count() != b.Count())
+#endif
             {
                 return false;
             }

Runtime/NetworkVariable/ResizableBitVector.cs

@@ -95,11 +95,19 @@ namespace Unity.Netcode
             {
                 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/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>>();
 
@@ -226,11 +227,6 @@ namespace Unity.Netcode
             foreach (var sceneToUnload in m_ScenesToUnload)
             {
                 SceneManager.UnloadSceneAsync(sceneToUnload);
-                // Update the ScenesLoaded when we unload scenes
-                if (sceneManager.ScenesLoaded.ContainsKey(sceneToUnload.handle))
-                {
-                    sceneManager.ScenesLoaded.Remove(sceneToUnload.handle);
-                }
             }
         }
 
@@ -332,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
+            // Don't let non-authority set this value
-            if (!networkManager.IsServer)
+            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,6 +247,7 @@ namespace Unity.Netcode
             {
                 SceneHandlesToSynchronize.Clear();
             }
+            ForwardSynchronization = false;
         }
 
         /// <summary>
@@ -334,7 +339,7 @@ namespace Unity.Netcode
             // as well as the order in which they will be deserialized
             if (LogSerializationOrder && m_NetworkManager.LogLevel == LogLevel.Developer)
             {
-                var messageBuilder = new System.Text.StringBuilder(0xFFFF);
+                var messageBuilder = new StringBuilder(0xFFFF);
                 messageBuilder.AppendLine("[Server-Side Client-Synchronization] NetworkObject serialization order:");
                 foreach (var networkObject in m_NetworkObjectsSync)
                 {
@@ -429,6 +434,36 @@ namespace Unity.Netcode
             return 0;
         }
 
+        internal bool EnableSerializationLogs = false;
+
+        private void LogArray(byte[] data, int start = 0, int stop = 0, StringBuilder builder = null)
+        {
+            var usingExternalBuilder = builder != null;
+            if (!usingExternalBuilder)
+            {
+                builder = new StringBuilder();
+            }
+
+            if (stop == 0)
+            {
+                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());
+            }
+        }
+
+        internal bool ForwardSynchronization;
+
         /// <summary>
         /// Client and Server Side:
         /// Serializes data based on the SceneEvent type (<see cref="SceneEventType"/>)
@@ -439,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);
@@ -473,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:
@@ -500,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
@@ -507,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!
@@ -522,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
@@ -552,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>
@@ -567,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)
             {
@@ -575,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++;
                     }
@@ -608,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);
@@ -648,6 +753,10 @@ namespace Unity.Netcode
                 case SceneEventType.Synchronize:
                     {
                         reader.ReadValueSafe(out ActiveSceneHash);
+                        if (EnableSerializationLogs)
+                        {
+                            LogArray(reader.ToArray(), 0, reader.Length);
+                        }
                         CopySceneSynchronizationData(reader);
                         break;
                     }
@@ -682,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
@@ -698,6 +809,8 @@ namespace Unity.Netcode
 
             // is not packed!
             reader.ReadValueSafe(out int sizeToCopy);
+            m_InternalBufferSize = sizeToCopy;
+
             unsafe
             {
                 if (!reader.TryBeginRead(sizeToCopy))
@@ -708,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());
+                }
             }
         }
 
@@ -722,7 +839,7 @@ namespace Unity.Netcode
             {
                 // is not packed!
                 InternalBuffer.ReadValueSafe(out ushort newObjectsCount);
-                var sceneObjects = new List<NetworkObject>();
+
                 for (ushort i = 0; i < newObjectsCount; i++)
                 {
                     var sceneObject = new NetworkObject.SceneObject();
@@ -734,22 +851,10 @@ namespace Unity.Netcode
                         m_NetworkManager.SceneManager.SetTheSceneBeingSynchronized(sceneObject.NetworkSceneHandle);
                     }
 
-                    var networkObject = NetworkObject.AddSceneObject(sceneObject, InternalBuffer, m_NetworkManager);
+                    NetworkObject.AddSceneObject(sceneObject, InternalBuffer, m_NetworkManager);
-
-                    if (sceneObject.IsSceneObject)
-                    {
-                        sceneObjects.Add(networkObject);
-                    }
                 }
                 // Now deserialize the despawned in-scene placed NetworkObjects list (if any)
                 DeserializeDespawnedInScenePlacedNetworkObjects();
-
-                // Notify all newly spawned in-scene placed NetworkObjects that all in-scene placed
-                // NetworkObjects have been spawned.
-                foreach (var networkObject in sceneObjects)
-                {
-                    networkObject.InternalInSceneNetworkObjectsSpawned();
-                }
             }
             finally
             {
@@ -969,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);
 
@@ -985,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)
                     {
@@ -994,20 +1117,20 @@ namespace Unity.Netcode
                         }
                     }
                 }
-
+                if (EnableSerializationLogs)
-                // Notify that all in-scene placed NetworkObjects have been spawned
-                foreach (var networkObject in m_NetworkObjectsSync)
                 {
-                    if (networkObject.IsSceneObject.HasValue && networkObject.IsSceneObject.Value)
+                    UnityEngine.Debug.Log(builder.ToString());
-                    {
-                        networkObject.InternalInSceneNetworkObjectsSpawned();
-                    }
                 }
 
                 // 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();
@@ -1061,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);
+                writer.WriteValueSafe(sceneHandleObjects.Value[ownerId].Count);
-                foreach (var networkObject in sceneHandleObjects.Value)
+                foreach (var networkObject in sceneHandleObjects.Value[ownerId])
                 {
                     writer.WriteValueSafe(networkObject.NetworkObjectId);
                 }
             }
-            // Once we are done, clear the table
-            sceneManager.ObjectsMigratedIntoNewScene.Clear();
         }
 
         /// <summary>
@@ -1089,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++)
                 {
@@ -1109,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][ownerID].Add(networkObject);
-                    sceneManager.ObjectsMigratedIntoNewScene[sceneHandle].Add(spawnManager.SpawnedObjects[networkObjectId]);
                 }
             }
         }
@@ -1127,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++)
             {
@@ -1166,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))
@@ -1176,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;
-
+                WhenSceneEventHasTimedOut = networkManager.RealTimeProvider.RealTimeSinceStartup + networkManager.NetworkConfig.LoadSceneTimeOut;
-                if (networkManager.IsServer)
+                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
+                        // Ignore the host or session owner
-                        if (NetworkManager.ServerClientId == connectedClientId)
+                        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;
         }

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);
@@ -1193,7 +1209,11 @@ namespace Unity.Netcode
         [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;
@@ -1206,7 +1226,11 @@ namespace Unity.Netcode
             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);

Runtime/Serialization/NetworkBehaviourReference.cs

@@ -5,15 +5,12 @@ namespace Unity.Netcode
 {
     /// <summary>
     /// A helper struct for serializing <see cref="NetworkBehaviour"/>s over the network. Can be used in RPCs and <see cref="NetworkVariable{T}"/>.
-    /// Network IDs get recycled by the NetworkManager after a while, so using a NetworkBehaviourReference for too long may result in a
+    /// Note: network ids get recycled by the NetworkManager after a while. So a reference pointing to
-    /// different NetworkBehaviour being returned for the assigned NetworkBehaviourId. NetworkBehaviourReferences are best for short-term
-    /// use when receieved via RPC or custom message, rather than for long-term references to NetworkBehaviours.
     /// </summary>
     public struct NetworkBehaviourReference : INetworkSerializable, IEquatable<NetworkBehaviourReference>
     {
         private NetworkObjectReference m_NetworkObjectReference;
         private ushort m_NetworkBehaviourId;
-        private static ushort s_NullId = ushort.MaxValue;
 
         /// <summary>
         /// Creates a new instance of the <see cref="NetworkBehaviourReference{T}"/> struct.
@@ -24,9 +21,7 @@ namespace Unity.Netcode
         {
             if (networkBehaviour == null)
             {
-                m_NetworkObjectReference = new NetworkObjectReference((NetworkObject)null);
+                throw new ArgumentNullException(nameof(networkBehaviour));
-                m_NetworkBehaviourId = s_NullId;
-                return;
             }
             if (networkBehaviour.NetworkObject == null)
             {
@@ -65,10 +60,6 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static NetworkBehaviour GetInternal(NetworkBehaviourReference networkBehaviourRef, NetworkManager networkManager = null)
         {
-            if (networkBehaviourRef.m_NetworkBehaviourId == s_NullId)
-            {
-                return null;
-            }
             if (networkBehaviourRef.m_NetworkObjectReference.TryGet(out NetworkObject networkObject, networkManager))
             {
                 return networkObject.GetNetworkBehaviourAtOrderIndex(networkBehaviourRef.m_NetworkBehaviourId);

Runtime/Serialization/NetworkObjectReference.cs

@@ -10,7 +10,6 @@ namespace Unity.Netcode
     public struct NetworkObjectReference : INetworkSerializable, IEquatable<NetworkObjectReference>
     {
         private ulong m_NetworkObjectId;
-        private static ulong s_NullId = ulong.MaxValue;
 
         /// <summary>
         /// The <see cref="NetworkObject.NetworkObjectId"/> of the referenced <see cref="NetworkObject"/>.
@@ -25,13 +24,13 @@ namespace Unity.Netcode
         /// Creates a new instance of the <see cref="NetworkObjectReference"/> struct.
         /// </summary>
         /// <param name="networkObject">The <see cref="NetworkObject"/> to reference.</param>
+        /// <exception cref="ArgumentNullException"></exception>
         /// <exception cref="ArgumentException"></exception>
         public NetworkObjectReference(NetworkObject networkObject)
         {
             if (networkObject == null)
             {
-                m_NetworkObjectId = s_NullId;
+                throw new ArgumentNullException(nameof(networkObject));
-                return;
             }
 
             if (networkObject.IsSpawned == false)
@@ -46,20 +45,16 @@ namespace Unity.Netcode
         /// Creates a new instance of the <see cref="NetworkObjectReference"/> struct.
         /// </summary>
         /// <param name="gameObject">The GameObject from which the <see cref="NetworkObject"/> component will be referenced.</param>
+        /// <exception cref="ArgumentNullException"></exception>
         /// <exception cref="ArgumentException"></exception>
         public NetworkObjectReference(GameObject gameObject)
         {
             if (gameObject == null)
             {
-                m_NetworkObjectId = s_NullId;
+                throw new ArgumentNullException(nameof(gameObject));
-                return;
             }
 
-            var networkObject = gameObject.GetComponent<NetworkObject>();
+            var networkObject = gameObject.GetComponent<NetworkObject>() ?? throw new ArgumentException($"Cannot create {nameof(NetworkObjectReference)} from {nameof(GameObject)} without a {nameof(NetworkObject)} component.");
-            if (!networkObject)
-            {
-                throw new ArgumentException($"Cannot create {nameof(NetworkObjectReference)} from {nameof(GameObject)} without a {nameof(NetworkObject)} component.");
-            }
             if (networkObject.IsSpawned == false)
             {
                 throw new ArgumentException($"{nameof(NetworkObjectReference)} can only be created from spawned {nameof(NetworkObject)}s.");
@@ -85,14 +80,10 @@ namespace Unity.Netcode
         /// </summary>
         /// <param name="networkObjectRef">The reference.</param>
         /// <param name="networkManager">The networkmanager. Uses <see cref="NetworkManager.Singleton"/> to resolve if null.</param>
-        /// <returns>The resolved <see cref="NetworkObject"/>. Returns null if the networkobject was not found</returns>
+        /// <returns>The resolves <see cref="NetworkObject"/>. Returns null if the networkobject was not found</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static NetworkObject Resolve(NetworkObjectReference networkObjectRef, NetworkManager networkManager = null)
         {
-            if (networkObjectRef.m_NetworkObjectId == s_NullId)
-            {
-                return null;
-            }
             networkManager = networkManager ?? NetworkManager.Singleton;
             networkManager.SpawnManager.SpawnedObjects.TryGetValue(networkObjectRef.m_NetworkObjectId, out NetworkObject networkObject);
 

Runtime/Timing/AnticipationSystem.cs

@@ -1,100 +0,0 @@
-using System.Collections.Generic;
-
-namespace Unity.Netcode
-{
-    internal interface IAnticipationEventReceiver
-    {
-        public void SetupForUpdate();
-        public void SetupForRender();
-    }
-
-    internal interface IAnticipatedObject
-    {
-        public void Update();
-        public void ResetAnticipation();
-        public NetworkObject OwnerObject { get; }
-    }
-
-    internal class AnticipationSystem
-    {
-        internal ulong LastAnticipationAck;
-        internal double LastAnticipationAckTime;
-
-        internal HashSet<IAnticipatedObject> AllAnticipatedObjects = new HashSet<IAnticipatedObject>();
-
-        internal ulong AnticipationCounter;
-
-        private NetworkManager m_NetworkManager;
-
-        public HashSet<IAnticipatedObject> ObjectsToReanticipate = new HashSet<IAnticipatedObject>();
-
-        public AnticipationSystem(NetworkManager manager)
-        {
-            m_NetworkManager = manager;
-        }
-
-        public event NetworkManager.ReanticipateDelegate OnReanticipate;
-
-        private HashSet<IAnticipationEventReceiver> m_AnticipationEventReceivers = new HashSet<IAnticipationEventReceiver>();
-
-        public void RegisterForAnticipationEvents(IAnticipationEventReceiver receiver)
-        {
-            m_AnticipationEventReceivers.Add(receiver);
-        }
-        public void DeregisterForAnticipationEvents(IAnticipationEventReceiver receiver)
-        {
-            m_AnticipationEventReceivers.Remove(receiver);
-        }
-
-        public void SetupForUpdate()
-        {
-            foreach (var receiver in m_AnticipationEventReceivers)
-            {
-                receiver.SetupForUpdate();
-            }
-        }
-
-        public void SetupForRender()
-        {
-            foreach (var receiver in m_AnticipationEventReceivers)
-            {
-                receiver.SetupForRender();
-            }
-        }
-
-        public void ProcessReanticipation()
-        {
-            var lastRoundTripTime = m_NetworkManager.LocalTime.Time - LastAnticipationAckTime;
-            foreach (var item in ObjectsToReanticipate)
-            {
-                foreach (var behaviour in item.OwnerObject.ChildNetworkBehaviours)
-                {
-                    behaviour.OnReanticipate(lastRoundTripTime);
-                }
-                item.ResetAnticipation();
-            }
-
-            ObjectsToReanticipate.Clear();
-            OnReanticipate?.Invoke(lastRoundTripTime);
-        }
-
-        public void Update()
-        {
-            foreach (var item in AllAnticipatedObjects)
-            {
-                item.Update();
-            }
-        }
-
-        public void Sync()
-        {
-            if (AllAnticipatedObjects.Count != 0 && !m_NetworkManager.ShutdownInProgress && !m_NetworkManager.ConnectionManager.LocalClient.IsServer && m_NetworkManager.ConnectionManager.LocalClient.IsConnected)
-            {
-                var message = new AnticipationCounterSyncPingMessage { Counter = AnticipationCounter, Time = m_NetworkManager.LocalTime.Time };
-                m_NetworkManager.MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, NetworkManager.ServerClientId);
-            }
-
-            ++AnticipationCounter;
-        }
-    }
-}

Runtime/Timing/AnticipationSystem.cs.meta

@@ -1,3 +0,0 @@
-fileFormatVersion: 2
-guid: 21e6ae0a82f945458519aee4ee119cab
-timeCreated: 1707845625

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

@@ -24,11 +24,6 @@ namespace Unity.Netcode
         /// </summary>
         public double TickOffset => m_CachedTickOffset;
 
-        /// <summary>
-        /// Gets the tick, including partial tick value passed since it started.
-        /// </summary>
-        public double TickWithPartial => Tick + (TickOffset / m_TickInterval);
-
         /// <summary>
         /// Gets the current time. This is a non fixed time value and similar to <see cref="Time.time"/>.
         /// </summary>
@@ -118,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/NetworkTimeSystem.cs

@@ -5,9 +5,7 @@ namespace Unity.Netcode
 {
     /// <summary>
     /// <see cref="NetworkTimeSystem"/> is a standalone system which can be used to run a network time simulation.
-    /// The network time system maintains both a local and a server time. The local time is based on the server time
+    /// The network time system maintains both a local and a server time. The local time is based on
-    /// as last received from the server plus an offset based on the current RTT - in other words, it is a best-guess
-    /// effort at predicting what the server tick will be when a given network action is processed on the server.
     /// </summary>
     public class NetworkTimeSystem
     {

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;

Runtime/Transports/UTP/UnityTransport.cs

@@ -202,12 +202,11 @@ namespace Unity.Netcode.Transports.UTP
             set => m_MaxPacketQueueSize = value;
         }
 
-        [Tooltip("The maximum size of an unreliable payload that can be handled by the transport. The memory for MaxPayloadSize is allocated once per connection and is released when the connection is closed.")]
+        [Tooltip("The maximum size of an unreliable payload that can be handled by the transport.")]
         [SerializeField]
         private int m_MaxPayloadSize = InitialMaxPayloadSize;
 
         /// <summary>The maximum size of an unreliable payload that can be handled by the transport.</summary>
-        /// <remarks>The memory for MaxPayloadSize is allocated once per connection and is released when the connection is closed.</remarks>
         public int MaxPayloadSize
         {
             get => m_MaxPayloadSize;

TestHelpers/Runtime/IntegrationTestSceneHandler.cs

@@ -23,6 +23,8 @@ namespace Unity.Netcode.TestHelpers.Runtime
             public Scene Scene;
         }
 
+        public bool IsIntegrationTest() { return true; }
+
         internal static Dictionary<NetworkManager, Dictionary<string, Dictionary<int, SceneEntry>>> SceneNameToSceneHandles = new Dictionary<NetworkManager, Dictionary<string, Dictionary<int, SceneEntry>>>();
 
         // All IntegrationTestSceneHandler instances register their associated NetworkManager
@@ -675,11 +677,6 @@ namespace Unity.Netcode.TestHelpers.Runtime
             foreach (var sceneToUnload in m_ScenesToUnload)
             {
                 SceneManager.UnloadSceneAsync(sceneToUnload.Key);
-                // Update the ScenesLoaded when we unload scenes
-                if (sceneManager.ScenesLoaded.ContainsKey(sceneToUnload.Key.handle))
-                {
-                    sceneManager.ScenesLoaded.Remove(sceneToUnload.Key.handle);
-                }
             }
         }
 

TestHelpers/Runtime/IntegrationTestWithApproximation.cs

@@ -1,12 +1,24 @@
+using System;
 using System.Runtime.CompilerServices;
 using UnityEngine;
+using Random = UnityEngine.Random;
 
 
 namespace Unity.Netcode.TestHelpers.Runtime
 {
     public abstract class IntegrationTestWithApproximation : NetcodeIntegrationTest
     {
-        private const float k_AproximateDeltaVariance = 0.01f;
+        private const float k_AproximateDeltaVariance = 0.016f;
+
+        protected string GetVector3Values(ref Vector3 vector3)
+        {
+            return $"({vector3.x:F6},{vector3.y:F6},{vector3.z:F6})";
+        }
+
+        protected string GetVector3Values(Vector3 vector3)
+        {
+            return GetVector3Values(ref vector3);
+        }
 
         protected virtual float GetDeltaVarianceThreshold()
         {
@@ -40,17 +52,17 @@ namespace Unity.Netcode.TestHelpers.Runtime
         protected bool Approximately(Vector2 a, Vector2 b)
         {
             var deltaVariance = GetDeltaVarianceThreshold();
-            return Mathf.Abs(a.x - b.x) <= deltaVariance &&
+            return Math.Round(Mathf.Abs(a.x - b.x), 2) <= deltaVariance &&
-                Mathf.Abs(a.y - b.y) <= deltaVariance;
+                Math.Round(Mathf.Abs(a.y - b.y), 2) <= deltaVariance;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         protected bool Approximately(Vector3 a, Vector3 b)
         {
             var deltaVariance = GetDeltaVarianceThreshold();
-            return Mathf.Abs(a.x - b.x) <= deltaVariance &&
+            return Math.Round(Mathf.Abs(a.x - b.x), 2) <= deltaVariance &&
-                Mathf.Abs(a.y - b.y) <= deltaVariance &&
+                Math.Round(Mathf.Abs(a.y - b.y), 2) <= deltaVariance &&
-                Mathf.Abs(a.z - b.z) <= deltaVariance;
+                Math.Round(Mathf.Abs(a.z - b.z), 2) <= deltaVariance;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -75,5 +87,10 @@ namespace Unity.Netcode.TestHelpers.Runtime
             return new Vector3(Random.Range(min, max), Random.Range(min, max), Random.Range(min, max));
         }
 
+        public IntegrationTestWithApproximation(SessionModeTypes sessionModeType) : base(sessionModeType) { }
+
+        public IntegrationTestWithApproximation(HostOrServer hostOrServer) : base(hostOrServer) { }
+
+        public IntegrationTestWithApproximation() : base() { }
     }
 }

TestHelpers/Runtime/MockTimeProvider.cs

@@ -7,6 +7,9 @@ namespace Unity.Netcode.TestHelpers.Runtime
         public float UnscaledDeltaTime => (float)s_DoubleDelta;
         public float DeltaTime => (float)s_DoubleDelta;
 
+        // DANGO-EXP TODO: Figure out how we want to handle time travel with fixed delta time.
+        public float FixedDeltaTime => (float)s_DoubleDelta;
+
         public static float StaticRealTimeSinceStartup => (float)s_DoubleRealTime;
         public static float StaticUnscaledTime => (float)s_DoubleRealTime;
         public static float StaticUnscaledDeltaTime => (float)s_DoubleDelta;

TestHelpers/Runtime/MockTransport.cs

@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using Unity.Collections;
-using Random = UnityEngine.Random;
 
 namespace Unity.Netcode.TestHelpers.Runtime
 {
@@ -10,107 +8,37 @@ namespace Unity.Netcode.TestHelpers.Runtime
         private struct MessageData
         {
             public ulong FromClientId;
-            public FastBufferReader Payload;
+            public ArraySegment<byte> Payload;
             public NetworkEvent Event;
-            public float AvailableTime;
-            public int Sequence;
-            public NetworkDelivery Delivery;
         }
 
-        private static Dictionary<ulong, List<MessageData>> s_MessageQueue = new Dictionary<ulong, List<MessageData>>();
+        private static Dictionary<ulong, Queue<MessageData>> s_MessageQueue = new Dictionary<ulong, Queue<MessageData>>();
 
         public override ulong ServerClientId { get; } = 0;
 
         public static ulong HighTransportId = 0;
         public ulong TransportId = 0;
 
-        public float SimulatedLatencySeconds;
-        public float PacketDropRate;
-        public float LatencyJitter;
-
-        public Dictionary<ulong, int> LastSentSequence = new Dictionary<ulong, int>();
-        public Dictionary<ulong, int> LastReceivedSequence = new Dictionary<ulong, int>();
-
         public NetworkManager NetworkManager;
 
         public override void Send(ulong clientId, ArraySegment<byte> payload, NetworkDelivery networkDelivery)
         {
-            if ((networkDelivery == NetworkDelivery.Unreliable || networkDelivery == NetworkDelivery.UnreliableSequenced) && Random.Range(0, 1) < PacketDropRate)
+            var copy = new byte[payload.Array.Length];
-            {
+            Array.Copy(payload.Array, copy, payload.Array.Length);
-                return;
+            s_MessageQueue[clientId].Enqueue(new MessageData { FromClientId = TransportId, Payload = new ArraySegment<byte>(copy, payload.Offset, payload.Count), Event = NetworkEvent.Data });
-            }
-
-            if (!LastSentSequence.ContainsKey(clientId))
-            {
-                LastSentSequence[clientId] = 1;
-            }
-
-            var reader = new FastBufferReader(payload, Allocator.TempJob);
-            s_MessageQueue[clientId].Add(new MessageData
-            {
-                FromClientId = TransportId,
-                Payload = reader,
-                Event = NetworkEvent.Data,
-                AvailableTime = NetworkManager.RealTimeProvider.UnscaledTime + SimulatedLatencySeconds + Random.Range(-LatencyJitter, LatencyJitter),
-                Sequence = ++LastSentSequence[clientId],
-                Delivery = networkDelivery
-            });
-            s_MessageQueue[clientId].Sort(((a, b) => a.AvailableTime.CompareTo(b.AvailableTime)));
         }
 
         public override NetworkEvent PollEvent(out ulong clientId, out ArraySegment<byte> payload, out float receiveTime)
         {
             if (s_MessageQueue[TransportId].Count > 0)
             {
-                MessageData data;
+                var data = s_MessageQueue[TransportId].Dequeue();
-                for (; ; )
+                clientId = data.FromClientId;
-                {
+                payload = data.Payload;
-                    data = s_MessageQueue[TransportId][0];
-                    if (data.AvailableTime > NetworkManager.RealTimeProvider.UnscaledTime)
-                    {
-                        clientId = 0;
-                        payload = new ArraySegment<byte>();
-                        receiveTime = 0;
-                        return NetworkEvent.Nothing;
-                    }
-
-                    s_MessageQueue[TransportId].RemoveAt(0);
-                    clientId = data.FromClientId;
-                    if (data.Event == NetworkEvent.Data && data.Delivery == NetworkDelivery.UnreliableSequenced && LastReceivedSequence.ContainsKey(clientId) && data.Sequence <= LastReceivedSequence[clientId])
-                    {
-                        continue;
-                    }
-
-                    break;
-                }
-
-                if (data.Delivery == NetworkDelivery.UnreliableSequenced)
-                {
-                    LastReceivedSequence[clientId] = data.Sequence;
-                }
-
-                payload = new ArraySegment<byte>();
-                if (data.Event == NetworkEvent.Data)
-                {
-                    payload = data.Payload.ToArray();
-                    data.Payload.Dispose();
-                }
-
                 receiveTime = NetworkManager.RealTimeProvider.RealTimeSinceStartup;
                 if (NetworkManager.IsServer && data.Event == NetworkEvent.Connect)
                 {
-                    if (!LastSentSequence.ContainsKey(data.FromClientId))
+                    s_MessageQueue[data.FromClientId].Enqueue(new MessageData { Event = NetworkEvent.Connect, FromClientId = ServerClientId, Payload = new ArraySegment<byte>() });
-                    {
-                        LastSentSequence[data.FromClientId] = 1;
-                    }
-                    s_MessageQueue[data.FromClientId].Add(
-                        new MessageData
-                        {
-                            Event = NetworkEvent.Connect,
-                            FromClientId = ServerClientId,
-                            AvailableTime = NetworkManager.RealTimeProvider.UnscaledTime + SimulatedLatencySeconds + Random.Range(-LatencyJitter, LatencyJitter),
-                            Sequence = ++LastSentSequence[data.FromClientId]
-                        });
                 }
                 return data.Event;
             }
@@ -123,45 +51,30 @@ namespace Unity.Netcode.TestHelpers.Runtime
         public override bool StartClient()
         {
             TransportId = ++HighTransportId;
-            s_MessageQueue[TransportId] = new List<MessageData>();
+            s_MessageQueue[TransportId] = new Queue<MessageData>();
-            s_MessageQueue[ServerClientId].Add(
+            s_MessageQueue[ServerClientId].Enqueue(new MessageData { Event = NetworkEvent.Connect, FromClientId = TransportId, Payload = new ArraySegment<byte>() });
-                new MessageData
-                {
-                    Event = NetworkEvent.Connect,
-                    FromClientId = TransportId,
-                });
             return true;
         }
 
         public override bool StartServer()
         {
-            s_MessageQueue[ServerClientId] = new List<MessageData>();
+            s_MessageQueue[ServerClientId] = new Queue<MessageData>();
             return true;
         }
 
         public override void DisconnectRemoteClient(ulong clientId)
         {
-            s_MessageQueue[clientId].Add(
+            s_MessageQueue[clientId].Enqueue(new MessageData { Event = NetworkEvent.Disconnect, FromClientId = TransportId, Payload = new ArraySegment<byte>() });
-                new MessageData
-                {
-                    Event = NetworkEvent.Disconnect,
-                    FromClientId = TransportId,
-                });
         }
 
         public override void DisconnectLocalClient()
         {
-            s_MessageQueue[ServerClientId].Add(
+            s_MessageQueue[ServerClientId].Enqueue(new MessageData { Event = NetworkEvent.Disconnect, FromClientId = TransportId, Payload = new ArraySegment<byte>() });
-                new MessageData
-                {
-                    Event = NetworkEvent.Disconnect,
-                    FromClientId = TransportId,
-                });
         }
 
         public override ulong GetCurrentRtt(ulong clientId)
         {
-            return (ulong)(SimulatedLatencySeconds * 1000);
+            return 0;
         }
 
         public override void Shutdown()
@@ -172,35 +85,5 @@ namespace Unity.Netcode.TestHelpers.Runtime
         {
             NetworkManager = networkManager;
         }
-
-        protected static void DisposeQueueItems()
-        {
-            foreach (var kvp in s_MessageQueue)
-            {
-                foreach (var value in kvp.Value)
-                {
-                    if (value.Event == NetworkEvent.Data)
-                    {
-                        value.Payload.Dispose();
-                    }
-                }
-            }
-        }
-
-        public static void Reset()
-        {
-            DisposeQueueItems();
-            s_MessageQueue.Clear();
-            HighTransportId = 0;
-        }
-
-        public static void ClearQueues()
-        {
-            DisposeQueueItems();
-            foreach (var kvp in s_MessageQueue)
-            {
-                kvp.Value.Clear();
-            }
-        }
     }
 }

TestHelpers/Runtime/NetcodeIntegrationTest.cs

@@ -4,6 +4,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
+using System.Text;
 using NUnit.Framework;
 using Unity.Netcode.RuntimeTests;
 using Unity.Netcode.Transports.UTP;
@@ -29,6 +30,13 @@ namespace Unity.Netcode.TestHelpers.Runtime
         protected static WaitForSecondsRealtime s_DefaultWaitForTick = new WaitForSecondsRealtime(1.0f / k_DefaultTickRate);
 
         public NetcodeLogAssert NetcodeLogAssert;
+        public enum SceneManagementState
+        {
+            SceneManagementEnabled,
+            SceneManagementDisabled
+        }
+
+        private StringBuilder m_InternalErrorLog = new StringBuilder();
 
         /// <summary>
         /// Registered list of all NetworkObjects spawned.
@@ -112,7 +120,8 @@ namespace Unity.Netcode.TestHelpers.Runtime
         public enum HostOrServer
         {
             Host,
-            Server
+            Server,
+            DAHost
         }
 
         protected GameObject m_PlayerPrefab;
@@ -129,6 +138,26 @@ namespace Unity.Netcode.TestHelpers.Runtime
         protected Dictionary<ulong, Dictionary<ulong, NetworkObject>> m_PlayerNetworkObjects = new Dictionary<ulong, Dictionary<ulong, NetworkObject>>();
 
         protected bool m_UseHost = true;
+        protected bool m_DistributedAuthority;
+        protected SessionModeTypes m_SessionModeType = SessionModeTypes.ClientServer;
+
+        protected virtual bool UseCMBService()
+        {
+            return false;
+        }
+
+        protected virtual SessionModeTypes OnGetSessionmode()
+        {
+            return m_SessionModeType;
+        }
+
+        protected void SetDistributedAuthorityProperties(NetworkManager networkManager)
+        {
+            networkManager.NetworkConfig.SessionMode = m_SessionModeType;
+            networkManager.NetworkConfig.AutoSpawnPlayerPrefabClientSide = m_DistributedAuthority;
+            networkManager.NetworkConfig.UseCMBService = UseCMBService() && m_DistributedAuthority;
+        }
+
         protected int m_TargetFrameRate = 60;
 
         private NetworkManagerInstatiationMode m_NetworkManagerInstatiationMode;
@@ -308,14 +337,6 @@ namespace Unity.Netcode.TestHelpers.Runtime
             NetcodeLogAssert = new NetcodeLogAssert();
             if (m_EnableTimeTravel)
             {
-                if (m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.AllTests)
-                {
-                    MockTransport.ClearQueues();
-                }
-                else
-                {
-                    MockTransport.Reset();
-                }
                 // Setup the frames per tick for time travel advance to next tick
                 ConfigureFramesPerTick();
             }
@@ -346,6 +367,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
                 else
                 {
                     yield return StartServerAndClients();
+
                 }
             }
 
@@ -375,6 +397,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
             m_PlayerPrefab = new GameObject("Player");
             OnPlayerPrefabGameObjectCreated();
             NetworkObject networkObject = m_PlayerPrefab.AddComponent<NetworkObject>();
+            networkObject.IsSceneObject = false;
 
             // Make it a prefab
             NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObject);
@@ -463,6 +486,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
         {
             var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_EnableTimeTravel);
             networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
+            SetDistributedAuthorityProperties(networkManager);
 
             // Notification that the new client (NetworkManager) has been created
             // in the event any modifications need to be made before starting the client
@@ -491,12 +515,64 @@ namespace Unity.Netcode.TestHelpers.Runtime
                     Object.DestroyImmediate(networkManager.gameObject);
                 }
 
-                AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for the new client to be connected!");
+                AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for the new client to be connected!\n {m_InternalErrorLog}");
                 ClientNetworkManagerPostStart(networkManager);
+                if (networkManager.DistributedAuthorityMode)
+                {
+                    yield return WaitForConditionOrTimeOut(() => AllPlayerObjectClonesSpawned(networkManager));
+                    AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for all sessions to spawn Client-{networkManager.LocalClientId}'s player object!");
+                }
+
                 VerboseDebug($"[{networkManager.name}] Created and connected!");
             }
         }
 
+        private bool AllPlayerObjectClonesSpawned(NetworkManager joinedClient)
+        {
+            m_InternalErrorLog.Clear();
+            // Continue to populate the PlayerObjects list until all player object (local and clone) are found
+            ClientNetworkManagerPostStart(joinedClient);
+
+            var playerObjectRelative = m_ServerNetworkManager.SpawnManager.PlayerObjects.Where((c) => c.OwnerClientId == joinedClient.LocalClientId).FirstOrDefault();
+            if (playerObjectRelative == null)
+            {
+                m_InternalErrorLog.Append($"[AllPlayerObjectClonesSpawned][Server-Side] Joining Client-{joinedClient.LocalClientId} was not populated in the {nameof(NetworkSpawnManager.PlayerObjects)} list!");
+                return false;
+            }
+            else
+            {
+                // Go ahead and create an entry for this new client
+                if (!m_PlayerNetworkObjects[m_ServerNetworkManager.LocalClientId].ContainsKey(joinedClient.LocalClientId))
+                {
+                    m_PlayerNetworkObjects[m_ServerNetworkManager.LocalClientId].Add(joinedClient.LocalClientId, playerObjectRelative);
+                }
+            }
+
+            foreach (var clientNetworkManager in m_ClientNetworkManagers)
+            {
+                if (clientNetworkManager.LocalClientId == joinedClient.LocalClientId)
+                {
+                    continue;
+                }
+
+                playerObjectRelative = clientNetworkManager.SpawnManager.PlayerObjects.Where((c) => c.OwnerClientId == joinedClient.LocalClientId).FirstOrDefault();
+                if (playerObjectRelative == null)
+                {
+                    m_InternalErrorLog.Append($"[AllPlayerObjectClonesSpawned][Client-{clientNetworkManager.LocalClientId}] Client-{joinedClient.LocalClientId} was not populated in the {nameof(NetworkSpawnManager.PlayerObjects)} list!");
+                    return false;
+                }
+                else
+                {
+                    // Go ahead and create an entry for this new client
+                    if (!m_PlayerNetworkObjects[clientNetworkManager.LocalClientId].ContainsKey(joinedClient.LocalClientId))
+                    {
+                        m_PlayerNetworkObjects[clientNetworkManager.LocalClientId].Add(joinedClient.LocalClientId, playerObjectRelative);
+                    }
+                }
+            }
+            return true;
+        }
+
         /// <summary>
         /// This will create, start, and connect a new client while in the middle of an
         /// integration test.
@@ -505,6 +581,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
         {
             var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_EnableTimeTravel);
             networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
+            SetDistributedAuthorityProperties(networkManager);
 
             // Notification that the new client (NetworkManager) has been created
             // in the event any modifications need to be made before starting the client
@@ -542,7 +619,10 @@ namespace Unity.Netcode.TestHelpers.Runtime
         protected IEnumerator StopOneClient(NetworkManager networkManager, bool destroy = false)
         {
             NetcodeIntegrationTestHelpers.StopOneClient(networkManager, destroy);
-            AddRemoveNetworkManager(networkManager, false);
+            if (destroy)
+            {
+                AddRemoveNetworkManager(networkManager, false);
+            }
             yield return WaitForConditionOrTimeOut(() => !networkManager.IsConnectedClient);
         }
 
@@ -556,33 +636,6 @@ namespace Unity.Netcode.TestHelpers.Runtime
             Assert.True(WaitForConditionOrTimeOutWithTimeTravel(() => !networkManager.IsConnectedClient));
         }
 
-        protected void SetTimeTravelSimulatedLatency(float latencySeconds)
-        {
-            ((MockTransport)m_ServerNetworkManager.NetworkConfig.NetworkTransport).SimulatedLatencySeconds = latencySeconds;
-            foreach (var client in m_ClientNetworkManagers)
-            {
-                ((MockTransport)client.NetworkConfig.NetworkTransport).SimulatedLatencySeconds = latencySeconds;
-            }
-        }
-
-        protected void SetTimeTravelSimulatedDropRate(float dropRatePercent)
-        {
-            ((MockTransport)m_ServerNetworkManager.NetworkConfig.NetworkTransport).PacketDropRate = dropRatePercent;
-            foreach (var client in m_ClientNetworkManagers)
-            {
-                ((MockTransport)client.NetworkConfig.NetworkTransport).PacketDropRate = dropRatePercent;
-            }
-        }
-
-        protected void SetTimeTravelSimulatedLatencyJitter(float jitterSeconds)
-        {
-            ((MockTransport)m_ServerNetworkManager.NetworkConfig.NetworkTransport).LatencyJitter = jitterSeconds;
-            foreach (var client in m_ClientNetworkManagers)
-            {
-                ((MockTransport)client.NetworkConfig.NetworkTransport).LatencyJitter = jitterSeconds;
-            }
-        }
-
         /// <summary>
         /// Creates the server and clients
         /// </summary>
@@ -616,9 +669,12 @@ namespace Unity.Netcode.TestHelpers.Runtime
             // Set the player prefab for the server and clients
             m_ServerNetworkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
 
+            SetDistributedAuthorityProperties(m_ServerNetworkManager);
+
             foreach (var client in m_ClientNetworkManagers)
             {
                 client.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
+                SetDistributedAuthorityProperties(client);
             }
 
             // Provides opportunity to allow child derived classes to
@@ -765,7 +821,10 @@ namespace Unity.Netcode.TestHelpers.Runtime
 
                 // Start the instances and pass in our SceneManagerInitialization action that is invoked immediately after host-server
                 // is started and after each client is started.
-                if (!NetcodeIntegrationTestHelpers.Start(m_UseHost, m_ServerNetworkManager, m_ClientNetworkManagers))
+
+                // When using the CMBService, don't start the server.
+                bool startServer = !(UseCMBService() && m_DistributedAuthority);
+                if (!NetcodeIntegrationTestHelpers.Start(m_UseHost, startServer, m_ServerNetworkManager, m_ClientNetworkManagers))
                 {
                     Debug.LogError("Failed to start instances");
                     Assert.Fail("Failed to start instances");
@@ -776,11 +835,13 @@ namespace Unity.Netcode.TestHelpers.Runtime
                 // to load their own scenes.
                 if (m_ServerNetworkManager.NetworkConfig.EnableSceneManagement)
                 {
-                    var scenesLoaded = m_ServerNetworkManager.SceneManager.ScenesLoaded;
+                    if (startServer)
-                    m_ServerNetworkManager.SceneManager.SceneManagerHandler.PopulateLoadedScenes(ref scenesLoaded, m_ServerNetworkManager);
+                    {
+                        var scenesLoaded = m_ServerNetworkManager.SceneManager.ScenesLoaded;
+                        m_ServerNetworkManager.SceneManager.SceneManagerHandler.PopulateLoadedScenes(ref scenesLoaded, m_ServerNetworkManager);
+                    }
                 }
 
-
                 if (LogAllMessages)
                 {
                     EnableMessageLogging();
@@ -797,7 +858,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
                     // Wait for all clients to connect
                     yield return WaitForClientsConnectedOrTimeOut();
 
-                    AssertOnTimeout($"{nameof(StartServerAndClients)} timed out waiting for all clients to be connected!");
+                    AssertOnTimeout($"{nameof(StartServerAndClients)} timed out waiting for all clients to be connected!\n {m_InternalErrorLog}");
 
                     if (m_UseHost || m_ServerNetworkManager.IsHost)
                     {
@@ -818,9 +879,25 @@ namespace Unity.Netcode.TestHelpers.Runtime
                             m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(m_ServerNetworkManager.LocalClientId, playerNetworkObject);
                         }
                     }
-
+                    if (m_DistributedAuthority)
+                    {
+                        //yield return WaitForConditionOrTimeOut(AllClientPlayersSpawned);
+                        //AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for all sessions to spawn all player objects!");
+                        foreach (var networkManager in m_ClientNetworkManagers)
+                        {
+                            if (networkManager.DistributedAuthorityMode)
+                            {
+                                yield return WaitForConditionOrTimeOut(() => AllPlayerObjectClonesSpawned(networkManager));
+                                AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for all sessions to spawn Client-{networkManager.LocalClientId}'s player object!\n {m_InternalErrorLog}");
+                            }
+                        }
+                        if (m_ServerNetworkManager != null)
+                        {
+                            yield return WaitForConditionOrTimeOut(() => AllPlayerObjectClonesSpawned(m_ServerNetworkManager));
+                            AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for all sessions to spawn Client-{m_ServerNetworkManager.LocalClientId}'s player object!\n {m_InternalErrorLog}");
+                        }
+                    }
                     ClientNetworkManagerPostStartInit();
-
                     // Notification that at this time the server and client(s) are instantiated,
                     // started, and connected on both sides.
                     yield return OnServerAndClientsConnected();
@@ -842,7 +919,9 @@ namespace Unity.Netcode.TestHelpers.Runtime
 
                 // Start the instances and pass in our SceneManagerInitialization action that is invoked immediately after host-server
                 // is started and after each client is started.
-                if (!NetcodeIntegrationTestHelpers.Start(m_UseHost, m_ServerNetworkManager, m_ClientNetworkManagers))
+                // When using the CMBService, don't start the server.
+                var usingCMBService = UseCMBService() && m_DistributedAuthority;
+                if (!NetcodeIntegrationTestHelpers.Start(m_UseHost, !usingCMBService, m_ServerNetworkManager, m_ClientNetworkManagers))
                 {
                     Debug.LogError("Failed to start instances");
                     Assert.Fail("Failed to start instances");
@@ -892,6 +971,24 @@ namespace Unity.Netcode.TestHelpers.Runtime
                         }
                     }
 
+                    if (m_DistributedAuthority)
+                    {
+
+                        foreach (var networkManager in m_ClientNetworkManagers)
+                        {
+                            if (networkManager.DistributedAuthorityMode)
+                            {
+                                WaitForConditionOrTimeOutWithTimeTravel(() => AllPlayerObjectClonesSpawned(m_ServerNetworkManager));
+                                AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for all sessions to spawn Client-{networkManager.LocalClientId}'s player object!");
+                            }
+                        }
+                        if (m_ServerNetworkManager != null)
+                        {
+                            WaitForConditionOrTimeOutWithTimeTravel(() => AllPlayerObjectClonesSpawned(m_ServerNetworkManager));
+                            AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for all sessions to spawn Client-{m_ServerNetworkManager.LocalClientId}'s player object!");
+                        }
+                    }
+
                     ClientNetworkManagerPostStartInit();
 
                     // Notification that at this time the server and client(s) are instantiated,
@@ -1000,6 +1097,45 @@ namespace Unity.Netcode.TestHelpers.Runtime
             VerboseDebug($"Exiting {nameof(ShutdownAndCleanUp)}");
         }
 
+        protected IEnumerator CoroutineShutdownAndCleanUp()
+        {
+            VerboseDebug($"Entering {nameof(ShutdownAndCleanUp)}");
+            // Shutdown and clean up both of our NetworkManager instances
+            try
+            {
+                DeRegisterSceneManagerHandler();
+
+                NetcodeIntegrationTestHelpers.Destroy();
+
+                m_PlayerNetworkObjects.Clear();
+                s_GlobalNetworkObjects.Clear();
+            }
+            catch (Exception e)
+            {
+                throw e;
+            }
+            finally
+            {
+                if (m_PlayerPrefab != null)
+                {
+                    Object.DestroyImmediate(m_PlayerPrefab);
+                    m_PlayerPrefab = null;
+                }
+            }
+
+            // Allow time for NetworkManagers to fully shutdown
+            yield return s_DefaultWaitForTick;
+
+            // Cleanup any remaining NetworkObjects
+            DestroySceneNetworkObjects();
+
+            UnloadRemainingScenes();
+
+            // reset the m_ServerWaitForTick for the next test to initialize
+            s_DefaultWaitForTick = new WaitForSecondsRealtime(1.0f / k_DefaultTickRate);
+            VerboseDebug($"Exiting {nameof(ShutdownAndCleanUp)}");
+        }
+
         /// <summary>
         /// Note: For <see cref="NetworkManagerInstatiationMode.PerTest"/> mode
         /// this is called before ShutdownAndCleanUp.
@@ -1029,7 +1165,14 @@ namespace Unity.Netcode.TestHelpers.Runtime
 
             if (m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.PerTest)
             {
-                ShutdownAndCleanUp();
+                if (m_TearDownIsACoroutine)
+                {
+                    yield return CoroutineShutdownAndCleanUp();
+                }
+                else
+                {
+                    ShutdownAndCleanUp();
+                }
             }
 
             if (m_EnableTimeTravel)
@@ -1040,17 +1183,6 @@ namespace Unity.Netcode.TestHelpers.Runtime
             VerboseDebug($"Exiting {nameof(TearDown)}");
             LogWaitForMessages();
             NetcodeLogAssert.Dispose();
-            if (m_EnableTimeTravel)
-            {
-                if (m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.AllTests)
-                {
-                    MockTransport.ClearQueues();
-                }
-                else
-                {
-                    MockTransport.Reset();
-                }
-            }
         }
 
         /// <summary>
@@ -1276,11 +1408,35 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// <param name="clientsToCheck">An array of clients to be checked</param>
         protected IEnumerator WaitForClientsConnectedOrTimeOut(NetworkManager[] clientsToCheck)
         {
-            var remoteClientCount = clientsToCheck.Length;
+            yield return WaitForConditionOrTimeOut(() => CheckClientsConnected(clientsToCheck));
-            var serverClientCount = m_ServerNetworkManager.IsHost ? remoteClientCount + 1 : remoteClientCount;
+        }
 
-            yield return WaitForConditionOrTimeOut(() => clientsToCheck.Where((c) => c.IsConnectedClient).Count() == remoteClientCount &&
+        /// <summary>
-                                                         m_ServerNetworkManager.ConnectedClients.Count == serverClientCount);
+        /// Validation for clients connected that includes additional information for easier troubleshooting purposes.
+        /// </summary>
+        private bool CheckClientsConnected(NetworkManager[] clientsToCheck)
+        {
+            m_InternalErrorLog.Clear();
+            var allClientsConnected = true;
+
+            for (int i = 0; i < clientsToCheck.Length; i++)
+            {
+                if (!clientsToCheck[i].IsConnectedClient)
+                {
+                    allClientsConnected = false;
+                    m_InternalErrorLog.AppendLine($"[Client-{i + 1}] Client is not connected!");
+                }
+            }
+            var expectedCount = m_ServerNetworkManager.IsHost ? clientsToCheck.Length + 1 : clientsToCheck.Length;
+            var currentCount = m_ServerNetworkManager.ConnectedClients.Count;
+
+            if (currentCount != expectedCount)
+            {
+                allClientsConnected = false;
+                m_InternalErrorLog.AppendLine($"[Server-Side] Expected {expectedCount} clients to connect but only {currentCount} connected!");
+            }
+
+            return allClientsConnected;
         }
 
         /// <summary>
@@ -1332,7 +1488,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
             // Used to determine if all clients received the CreateObjectMessage
             var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
             yield return WaitForConditionOrTimeOut(hooks);
-            Assert.False(s_GlobalTimeoutHelper.TimedOut);
+            AssertOnTimeout($"Timed out waiting for message type {typeof(T).Name}!");
         }
 
         internal IEnumerator WaitForMessagesReceived(List<Type> messagesInOrder, List<NetworkManager> waitForReceivedBy, ReceiptType type = ReceiptType.Handled)
@@ -1352,7 +1508,12 @@ namespace Unity.Netcode.TestHelpers.Runtime
             // Used to determine if all clients received the CreateObjectMessage
             var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
             yield return WaitForConditionOrTimeOut(hooks);
-            Assert.False(s_GlobalTimeoutHelper.TimedOut);
+            var stringBuilder = new StringBuilder();
+            foreach (var messageType in messagesInOrder)
+            {
+                stringBuilder.Append($"{messageType.Name},");
+            }
+            AssertOnTimeout($"Timed out waiting for message types: {stringBuilder}!");
         }
 
 
@@ -1369,7 +1530,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
 
             // Used to determine if all clients received the CreateObjectMessage
             var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
-            Assert.True(WaitForConditionOrTimeOutWithTimeTravel(hooks));
+            Assert.True(WaitForConditionOrTimeOutWithTimeTravel(hooks), $"[Message Not Recieved] {hooks.GetHooksStillWaiting()}");
         }
 
         internal void WaitForMessagesReceivedWithTimeTravel(List<Type> messagesInOrder, List<NetworkManager> waitForReceivedBy, ReceiptType type = ReceiptType.Handled)
@@ -1388,7 +1549,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
 
             // Used to determine if all clients received the CreateObjectMessage
             var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
-            Assert.True(WaitForConditionOrTimeOutWithTimeTravel(hooks));
+            Assert.True(WaitForConditionOrTimeOutWithTimeTravel(hooks), $"[Messages Not Recieved] {hooks.GetHooksStillWaiting()}");
         }
 
         /// <summary>
@@ -1404,8 +1565,11 @@ namespace Unity.Netcode.TestHelpers.Runtime
                                           $"but before {nameof(OnStartedServerAndClients)}!";
             Assert.IsNotNull(m_ServerNetworkManager, prefabCreateAssertError);
             Assert.IsFalse(m_ServerNetworkManager.IsListening, prefabCreateAssertError);
-
+            var prefabObject = NetcodeIntegrationTestHelpers.CreateNetworkObjectPrefab(baseName, m_ServerNetworkManager, m_ClientNetworkManagers);
-            return NetcodeIntegrationTestHelpers.CreateNetworkObjectPrefab(baseName, m_ServerNetworkManager, m_ClientNetworkManagers);
+            // DANGO-TODO: Ownership flags could require us to change this
+            // For testing purposes, we default to true for the distribute ownership property when in distirbuted authority session mode.
+            prefabObject.GetComponent<NetworkObject>().Ownership |= NetworkObject.OwnershipStatus.Distributable;
+            return prefabObject;
         }
 
         /// <summary>
@@ -1418,6 +1582,16 @@ namespace Unity.Netcode.TestHelpers.Runtime
             return SpawnObject(prefabNetworkObject, owner, destroyWithScene);
         }
 
+        /// <summary>
+        /// Overloaded method <see cref="SpawnObject(NetworkObject, NetworkManager, bool)"/>
+        /// </summary>
+        protected GameObject SpawnPlayerObject(GameObject prefabGameObject, NetworkManager owner, bool destroyWithScene = false)
+        {
+            var prefabNetworkObject = prefabGameObject.GetComponent<NetworkObject>();
+            Assert.IsNotNull(prefabNetworkObject, $"{nameof(GameObject)} {prefabGameObject.name} does not have a {nameof(NetworkObject)} component!");
+            return SpawnObject(prefabNetworkObject, owner, destroyWithScene, true);
+        }
+
         /// <summary>
         /// Spawn a NetworkObject prefab instance
         /// </summary>
@@ -1425,28 +1599,57 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// <param name="owner">the owner of the instance</param>
         /// <param name="destroyWithScene">default is false</param>
         /// <returns>GameObject instance spawned</returns>
-        private GameObject SpawnObject(NetworkObject prefabNetworkObject, NetworkManager owner, bool destroyWithScene = false)
+        private GameObject SpawnObject(NetworkObject prefabNetworkObject, NetworkManager owner, bool destroyWithScene = false, bool isPlayerObject = false)
         {
             Assert.IsTrue(prefabNetworkObject.GlobalObjectIdHash > 0, $"{nameof(GameObject)} {prefabNetworkObject.name} has a {nameof(NetworkObject.GlobalObjectIdHash)} value of 0! Make sure to make it a valid prefab before trying to spawn!");
             var newInstance = Object.Instantiate(prefabNetworkObject.gameObject);
             var networkObjectToSpawn = newInstance.GetComponent<NetworkObject>();
-            networkObjectToSpawn.NetworkManagerOwner = m_ServerNetworkManager; // Required to assure the server does the spawning
+
-            if (owner == m_ServerNetworkManager)
+            if (owner.NetworkConfig.SessionMode == SessionModeTypes.DistributedAuthority)
             {
-                if (m_UseHost)
+                networkObjectToSpawn.NetworkManagerOwner = owner; // Required to assure the client does the spawning
+                if (isPlayerObject)
                 {
-                    networkObjectToSpawn.SpawnWithOwnership(owner.LocalClientId, destroyWithScene);
+                    networkObjectToSpawn.SpawnAsPlayerObject(owner.LocalClientId, destroyWithScene);
                 }
                 else
                 {
-                    networkObjectToSpawn.Spawn(destroyWithScene);
+                    networkObjectToSpawn.SpawnWithOwnership(owner.LocalClientId, destroyWithScene);
                 }
             }
             else
             {
-                networkObjectToSpawn.SpawnWithOwnership(owner.LocalClientId, destroyWithScene);
+                networkObjectToSpawn.NetworkManagerOwner = m_ServerNetworkManager; // Required to assure the server does the spawning
+                if (owner == m_ServerNetworkManager)
+                {
+                    if (m_UseHost)
+                    {
+                        if (isPlayerObject)
+                        {
+                            networkObjectToSpawn.SpawnAsPlayerObject(owner.LocalClientId, destroyWithScene);
+                        }
+                        else
+                        {
+                            networkObjectToSpawn.SpawnWithOwnership(owner.LocalClientId, destroyWithScene);
+                        }
+                    }
+                    else
+                    {
+                        networkObjectToSpawn.Spawn(destroyWithScene);
+                    }
+                }
+                else
+                {
+                    if (isPlayerObject)
+                    {
+                        networkObjectToSpawn.SpawnAsPlayerObject(owner.LocalClientId, destroyWithScene);
+                    }
+                    else
+                    {
+                        networkObjectToSpawn.SpawnWithOwnership(owner.LocalClientId, destroyWithScene);
+                    }
+                }
             }
-
             return newInstance;
         }
 
@@ -1484,6 +1687,15 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// </summary>
         public NetcodeIntegrationTest()
         {
+            m_SessionModeType = OnGetSessionmode();
+            m_DistributedAuthority = OnGetSessionmode() == SessionModeTypes.DistributedAuthority;
+            NetworkMessageManager.EnableMessageOrderConsoleLog = false;
+        }
+
+        public NetcodeIntegrationTest(SessionModeTypes sessionMode)
+        {
+            m_SessionModeType = sessionMode;
+            m_DistributedAuthority = OnGetSessionmode() == SessionModeTypes.DistributedAuthority;
         }
 
         /// <summary>
@@ -1504,7 +1716,9 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// <param name="hostOrServer"></param>
         public NetcodeIntegrationTest(HostOrServer hostOrServer)
         {
-            m_UseHost = hostOrServer == HostOrServer.Host ? true : false;
+            m_UseHost = hostOrServer == HostOrServer.Host || hostOrServer == HostOrServer.DAHost;
+            m_SessionModeType = hostOrServer == HostOrServer.DAHost ? SessionModeTypes.DistributedAuthority : SessionModeTypes.ClientServer;
+            m_DistributedAuthority = OnGetSessionmode() == SessionModeTypes.DistributedAuthority;
         }
 
         /// <summary>
@@ -1535,7 +1749,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
             }
         }
 
-        private System.Text.StringBuilder m_WaitForLog = new System.Text.StringBuilder();
+        private StringBuilder m_WaitForLog = new StringBuilder();
 
         private void LogWaitForMessages()
         {
@@ -1600,17 +1814,8 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// </summary>
         /// <param name="amountOfTimeInSeconds"></param>
         /// <param name="numFramesToSimulate"></param>
-        protected static void TimeTravel(double amountOfTimeInSeconds, int numFramesToSimulate = -1)
+        protected static void TimeTravel(double amountOfTimeInSeconds, int numFramesToSimulate)
         {
-            if (numFramesToSimulate < 0)
-            {
-                var frameRate = Application.targetFrameRate;
-                if (frameRate <= 0)
-                {
-                    frameRate = 60;
-                }
-                numFramesToSimulate = Math.Max((int)(amountOfTimeInSeconds / frameRate), 1);
-            }
             var interval = amountOfTimeInSeconds / numFramesToSimulate;
             for (var i = 0; i < numFramesToSimulate; ++i)
             {
@@ -1668,16 +1873,6 @@ namespace Unity.Netcode.TestHelpers.Runtime
             TimeTravel(timePassed, frames);
         }
 
-        private struct UpdateData
-        {
-            public MethodInfo Update;
-            public MethodInfo FixedUpdate;
-            public MethodInfo LateUpdate;
-        }
-
-        private static object[] s_EmptyObjectArray = { };
-        private static Dictionary<Type, UpdateData> s_UpdateFunctionCache = new Dictionary<Type, UpdateData>();
-
         /// <summary>
         /// Simulates one SDK frame. This can be used even without TimeTravel, though it's of somewhat less use
         /// without TimeTravel, as, without the mock transport, it will likely not provide enough time for any
@@ -1685,50 +1880,33 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// </summary>
         public static void SimulateOneFrame()
         {
-            foreach (NetworkUpdateStage updateStage in Enum.GetValues(typeof(NetworkUpdateStage)))
+            foreach (NetworkUpdateStage stage in Enum.GetValues(typeof(NetworkUpdateStage)))
             {
-                var stage = updateStage;
-                // These two are out of order numerically due to backward compatibility
-                // requirements. We have to swap them to maintain correct execution
-                // order.
-                if (stage == NetworkUpdateStage.PostScriptLateUpdate)
-                {
-                    stage = NetworkUpdateStage.PostLateUpdate;
-                }
-                else if (stage == NetworkUpdateStage.PostLateUpdate)
-                {
-                    stage = NetworkUpdateStage.PostScriptLateUpdate;
-                }
                 NetworkUpdateLoop.RunNetworkUpdateStage(stage);
-
+                string methodName = string.Empty;
-                if (stage == NetworkUpdateStage.Update || stage == NetworkUpdateStage.FixedUpdate || stage == NetworkUpdateStage.PreLateUpdate)
+                switch (stage)
                 {
-                    foreach (var behaviour in Object.FindObjectsByType<NetworkBehaviour>(FindObjectsSortMode.None))
+                    case NetworkUpdateStage.FixedUpdate:
-                    {
+                        methodName = "FixedUpdate"; // mapping NetworkUpdateStage.FixedUpdate to MonoBehaviour.FixedUpdate
-                        var type = behaviour.GetType();
+                        break;
-                        if (!s_UpdateFunctionCache.TryGetValue(type, out var updateData))
+                    case NetworkUpdateStage.Update:
-                        {
+                        methodName = "Update"; // mapping NetworkUpdateStage.Update to MonoBehaviour.Update
-                            updateData = new UpdateData
+                        break;
-                            {
+                    case NetworkUpdateStage.PreLateUpdate:
-                                Update = type.GetMethod("Update", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance),
+                        methodName = "LateUpdate"; // mapping NetworkUpdateStage.PreLateUpdate to MonoBehaviour.LateUpdate
-                                FixedUpdate = type.GetMethod("FixedUpdate", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance),
+                        break;
-                                LateUpdate = type.GetMethod("LateUpdate", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance),
+                }
-                            };
-                            s_UpdateFunctionCache[type] = updateData;
-                        }
 
-                        switch (stage)
+                if (!string.IsNullOrEmpty(methodName))
-                        {
+                {
-                            case NetworkUpdateStage.FixedUpdate:
+#if UNITY_2023_1_OR_NEWER
-                                updateData.FixedUpdate?.Invoke(behaviour, new object[] { });
+                    foreach (var behaviour in Object.FindObjectsByType<NetworkBehaviour>(FindObjectsSortMode.InstanceID))
-                                break;
+#else
-                            case NetworkUpdateStage.Update:
+                    foreach (var behaviour in Object.FindObjectsOfType<NetworkBehaviour>())
-                                updateData.Update?.Invoke(behaviour, new object[] { });
+#endif
-                                break;
+                    {
-                            case NetworkUpdateStage.PreLateUpdate:
+                        var method = behaviour.GetType().GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
-                                updateData.LateUpdate?.Invoke(behaviour, new object[] { });
+                        method?.Invoke(behaviour, new object[] { });
-                                break;
-                        }
                     }
                 }
             }

TestHelpers/Runtime/NetcodeIntegrationTestHelpers.cs

@@ -410,12 +410,31 @@ namespace Unity.Netcode.TestHelpers.Runtime
                 {
                     networkManager.SceneManager.ScenesLoaded.Add(scene.handle, scene);
                 }
+                // In distributed authority we need to check if this scene is already added
+                if (networkManager.DistributedAuthorityMode)
+                {
+                    if (!networkManager.SceneManager.ServerSceneHandleToClientSceneHandle.ContainsKey(scene.handle))
+                    {
+                        networkManager.SceneManager.ServerSceneHandleToClientSceneHandle.Add(scene.handle, scene.handle);
+                    }
+
+                    if (!networkManager.SceneManager.ClientSceneHandleToServerSceneHandle.ContainsKey(scene.handle))
+                    {
+                        networkManager.SceneManager.ClientSceneHandleToServerSceneHandle.Add(scene.handle, scene.handle);
+                    }
+                    return;
+                }
                 networkManager.SceneManager.ServerSceneHandleToClientSceneHandle.Add(scene.handle, scene.handle);
             }
         }
 
         public delegate void BeforeClientStartCallback();
 
+        internal static bool Start(bool host, bool startServer, NetworkManager server, NetworkManager[] clients)
+        {
+            return Start(host, server, clients, null, startServer);
+        }
+
         /// <summary>
         /// Starts NetworkManager instances created by the Create method.
         /// </summary>
@@ -424,7 +443,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// <param name="clients">The Clients NetworkManager</param>
         /// <param name="callback">called immediately after server is started and before client(s) are started</param>
         /// <returns></returns>
-        public static bool Start(bool host, NetworkManager server, NetworkManager[] clients, BeforeClientStartCallback callback = null)
+        public static bool Start(bool host, NetworkManager server, NetworkManager[] clients, BeforeClientStartCallback callback = null, bool startServer = true)
         {
             if (s_IsStarted)
             {
@@ -433,24 +452,26 @@ namespace Unity.Netcode.TestHelpers.Runtime
 
             s_IsStarted = true;
             s_ClientCount = clients.Length;
-
+            var hooks = (MultiInstanceHooks)null;
-            if (host)
+            if (startServer)
             {
-                server.StartHost();
+                if (host)
+                {
+                    server.StartHost();
+                }
+                else
+                {
+                    server.StartServer();
+                }
+
+                hooks = new MultiInstanceHooks();
+                server.ConnectionManager.MessageManager.Hook(hooks);
+                s_Hooks[server] = hooks;
+
+                // Register the server side handler (always pass true for server)
+                RegisterHandlers(server, true);
+                callback?.Invoke();
             }
-            else
-            {
-                server.StartServer();
-            }
-
-            var hooks = new MultiInstanceHooks();
-            server.ConnectionManager.MessageManager.Hook(hooks);
-            s_Hooks[server] = hooks;
-
-            // Register the server side handler (always pass true for server)
-            RegisterHandlers(server, true);
-
-            callback?.Invoke();
 
             for (int i = 0; i < clients.Length; i++)
             {

Tests/Editor/Build/BuildTests.cs

@@ -1,3 +1,4 @@
+#if !MULTIPLAYER_TOOLS
 using System.IO;
 using System.Reflection;
 using NUnit.Framework;
@@ -38,3 +39,4 @@ namespace Unity.Netcode.EditorTests
         }
     }
 }
+#endif

Tests/Editor/Messaging/MessageCorruptionTests.cs

@@ -90,16 +90,11 @@ namespace Unity.Netcode.EditorTests
                             break;
                         }
                     case TypeOfCorruption.CorruptBytes:
-                        {
+                        batchData.Seek(batchData.Length - 2);
-                            batchData.Seek(batchData.Length - 4);
+                        var currentByte = batchData.GetUnsafePtr()[0];
-                            for (int i = 0; i < 4; i++)
+                        batchData.WriteByteSafe((byte)(currentByte == 0 ? 1 : 0));
-                            {
+                        MessageQueue.Add(batchData.ToArray());
-                                var currentByte = batchData.GetUnsafePtr()[i];
+                        break;
-                                batchData.WriteByteSafe((byte)(currentByte == 0 ? 1 : 0));
-                                MessageQueue.Add(batchData.ToArray());
-                            }
-                            break;
-                        }
                     case TypeOfCorruption.Truncated:
                         batchData.Truncate(batchData.Length - 1);
                         MessageQueue.Add(batchData.ToArray());

Tests/Editor/Serialization/FastBufferWriterTests.cs

@@ -311,8 +311,11 @@ namespace Unity.Netcode.EditorTests
         {
             int* sizeValue = (int*)(unsafePtr + offset);
             Assert.AreEqual(value.Length, *sizeValue);
-
+#if UTP_TRANSPORT_2_0_ABOVE
+            var asTPointer = value.GetUnsafePtr();
+#else
             var asTPointer = (T*)value.GetUnsafePtr();
+#endif
             var underlyingTArray = (T*)(unsafePtr + sizeof(int) + offset);
             for (var i = 0; i < value.Length; ++i)
             {

Tests/Editor/Transports/BatchedReceiveQueueTests.cs

@@ -2,7 +2,9 @@ using System;
 using NUnit.Framework;
 using Unity.Collections;
 using Unity.Netcode.Transports.UTP;
+#if !UTP_TRANSPORT_2_0_ABOVE
 using Unity.Networking.Transport;
+#endif
 
 namespace Unity.Netcode.EditorTests
 {

Tests/Editor/Transports/BatchedSendQueueTests.cs

@@ -2,7 +2,9 @@ using System;
 using NUnit.Framework;
 using Unity.Collections;
 using Unity.Netcode.Transports.UTP;
+#if !UTP_TRANSPORT_2_0_ABOVE
 using Unity.Networking.Transport;
+#endif
 
 namespace Unity.Netcode.EditorTests
 {

Tests/Runtime/ConnectionApprovalTimeoutTests.cs

@@ -26,9 +26,9 @@ namespace Unity.Netcode.RuntimeTests
             m_ApprovalFailureType = approvalFailureType;
         }
 
-        // Must be >= 2 since this is an int value and the test waits for timeout - 1 to try to verify it doesn't
+        // Must be >= 5 since this is an int value and the test waits for timeout - 1 to try to verify it doesn't
         // time out early
-        private const int k_TestTimeoutPeriod = 1;
+        private const int k_TestTimeoutPeriod = 5;
 
         private Regex m_ExpectedLogMessage;
         private LogType m_LogType;
@@ -59,6 +59,7 @@ namespace Unity.Netcode.RuntimeTests
         {
             if (m_ApprovalFailureType == ApprovalTimedOutTypes.ServerDoesNotRespond)
             {
+                m_ServerNetworkManager.ConnectionManager.MockSkippingApproval = true;
                 // We catch (don't process) the incoming approval message to simulate the server not sending the approved message in time
                 m_ClientNetworkManagers[0].ConnectionManager.MessageManager.Hook(new MessageCatcher<ConnectionApprovedMessage>(m_ClientNetworkManagers[0]));
                 m_ExpectedLogMessage = new Regex("Timed out waiting for the server to approve the connection request.");
@@ -80,18 +81,18 @@ namespace Unity.Netcode.RuntimeTests
         [UnityTest]
         public IEnumerator ValidateApprovalTimeout()
         {
-            // Delay for half of the wait period
+            // Just delay for a second
-            yield return new WaitForSeconds(k_TestTimeoutPeriod * 0.25f);
+            yield return new WaitForSeconds(1);
 
             // Verify we haven't received the time out message yet
             NetcodeLogAssert.LogWasNotReceived(LogType.Log, m_ExpectedLogMessage);
 
-            yield return new WaitForSeconds(k_TestTimeoutPeriod * 1.5f);
+            yield return new WaitForSeconds(k_TestTimeoutPeriod * 1.25f);
 
             // We should have the test relative log message by this time.
             NetcodeLogAssert.LogWasReceived(m_LogType, m_ExpectedLogMessage);
 
-            Debug.Log("Checking connected client count");
+            VerboseDebug("Checking connected client count");
             // It should only have the host client connected
             Assert.AreEqual(1, m_ServerNetworkManager.ConnectedClients.Count, $"Expected only one client when there were {m_ServerNetworkManager.ConnectedClients.Count} clients connected!");