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,6 +6,291 @@ 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).
 
+## [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)
+
+## [1.8.1] - 2024-02-05
+
+### Fixed
+
+- Fixed a compile error when compiling for IL2CPP targets when using the new `[Rpc]` attribute. (#2824)
+
+## [1.8.0] - 2023-12-12
+
+### Added
+
+- Added a new RPC attribute, which is simply `Rpc`. (#2762)
+  - This is a generic attribute that can perform the functions of both Server and Client RPCs, as well as enabling client-to-client RPCs. Includes several default targets: `Server`, `NotServer`, `Owner`, `NotOwner`, `Me`, `NotMe`, `ClientsAndHost`, and `Everyone`. Runtime overrides are available for any of these targets, as well as for sending to a specific ID or groups of IDs.
+  - This attribute also includes the ability to defer RPCs that are sent to the local process to the start of the next frame instead of executing them immediately, treating them as if they had gone across the network. The default behavior is to execute immediately.
+  - This attribute effectively replaces `ServerRpc` and `ClientRpc`. `ServerRpc` and `ClientRpc` remain in their existing forms for backward compatibility, but `Rpc` will be the recommended and most supported option.
+- Added `NetworkManager.OnConnectionEvent` as a unified connection event callback to notify clients and servers of all client connections and disconnections within the session (#2762)
+- Added `NetworkManager.ServerIsHost` and `NetworkBehaviour.ServerIsHost` to allow a client to tell if it is connected to a host or to a dedicated server (#2762)
+- Added `SceneEventProgress.SceneManagementNotEnabled` return status to be returned when a `NetworkSceneManager` method is invoked and scene management is not enabled. (#2735)
+- Added `SceneEventProgress.ServerOnlyAction` return status to be returned when a `NetworkSceneManager` method is invoked by a client. (#2735)
+- Added `NetworkObject.InstantiateAndSpawn` and `NetworkSpawnManager.InstantiateAndSpawn` methods to simplify prefab spawning by assuring that the prefab is valid and applies any override prior to instantiating the `GameObject` and spawning the `NetworkObject` instance. (#2710)
+
+### Fixed
+
+- Fixed issue where a client disconnected by a server-host would not receive a local notification. (#2789)
+- Fixed issue where a server-host could shutdown during a relay connection but periodically the transport disconnect message sent to any connected clients could be dropped. (#2789)
+- Fixed issue where a host could disconnect its local client but remain running as a server. (#2789)
+- Fixed issue where `OnClientDisconnectedCallback` was not being invoked under certain conditions. (#2789)
+- Fixed issue where `OnClientDisconnectedCallback` was always returning 0 as the client identifier. (#2789)
+- Fixed issue where if a host or server shutdown while a client owned NetworkObjects (other than the player) it would throw an exception. (#2789)
+- Fixed issue where setting values on a `NetworkVariable` or `NetworkList` within `OnNetworkDespawn` during a shutdown sequence would throw an exception. (#2789)
+- Fixed issue where a teleport state could potentially be overridden by a previous unreliable delta state. (#2777)
+- Fixed issue where `NetworkTransform` was using the `NetworkManager.ServerTime.Tick` as opposed to `NetworkManager.NetworkTickSystem.ServerTime.Tick` during the authoritative side's tick update where it performed a delta state check. (#2777)
+- Fixed issue where a parented in-scene placed NetworkObject would be destroyed upon a client or server exiting a network session but not unloading the original scene in which the NetworkObject was placed. (#2737)
+- Fixed issue where during client synchronization and scene loading, when client synchronization or the scene loading mode are set to `LoadSceneMode.Single`, a `CreateObjectMessage` could be received, processed, and the resultant spawned `NetworkObject` could be instantiated in the client's currently active scene that could, towards the end of the client synchronization or loading process, be unloaded and cause the newly created `NetworkObject` to be destroyed (and throw and exception). (#2735)
+- Fixed issue where a `NetworkTransform` instance with interpolation enabled would result in wide visual motion gaps (stuttering) under above normal latency conditions and a 1-5% or higher packet are drop rate. (#2713)
+- Fixed issue where  you could not have multiple source network prefab overrides targeting the same network prefab as their override. (#2710)
+
+### Changed
+- Changed the server or host shutdown so it will now perform a "soft shutdown" when `NetworkManager.Shutdown` is invoked. This will send a disconnect notification to all connected clients and the server-host will wait for all connected clients to disconnect or timeout after a 5 second period before completing the shutdown process. (#2789)
+- Changed `OnClientDisconnectedCallback` will now return the assigned client identifier on the local client side if the client was approved and assigned one prior to being disconnected. (#2789)
+- Changed `NetworkTransform.SetState` (and related methods) now are cumulative during a fractional tick period and sent on the next pending tick. (#2777)
+- `NetworkManager.ConnectedClientsIds` is now accessible on the client side and will contain the list of all clients in the session, including the host client if the server is operating in host mode (#2762)
+- Changed `NetworkSceneManager` to return a `SceneEventProgress` status and not throw exceptions for methods invoked when scene management is disabled and when a client attempts to access a `NetworkSceneManager` method by a client. (#2735)
+- Changed `NetworkTransform` authoritative instance tick registration so a single `NetworkTransform` specific tick event update will update all authoritative instances to improve perofmance. (#2713)
+- Changed `NetworkPrefabs.OverrideToNetworkPrefab` dictionary is no longer used/populated due to it ending up being related to a regression bug and not allowing more than one override to be assigned to a network prefab asset. (#2710)
+- Changed in-scene placed `NetworkObject`s now store their source network prefab asset's `GlobalObjectIdHash` internally that is used, when scene management is disabled, by clients to spawn the correct prefab even if the `NetworkPrefab` entry has an override. This does not impact dynamically spawning the same prefab which will yield the override on both host and client. (#2710)
+- Changed in-scene placed `NetworkObject`s no longer require a `NetworkPrefab` entry with `GlobalObjectIdHash` override in order for clients to properly synchronize. (#2710)
+- Changed in-scene placed `NetworkObject`s now set their `IsSceneObject` value when generating their `GlobalObjectIdHash` value. (#2710)
+- Changed the default `NetworkConfig.SpawnTimeout` value from 1.0s to 10.0s. (#2710)
+
+## [1.7.1] - 2023-11-15
+
+### Added
+
+### Fixed
+
+- Fixed a bug where having a class with Rpcs that inherits from a class without Rpcs that inherits from NetworkVariable would cause a compile error. (#2751)
+- Fixed issue where `NetworkBehaviour.Synchronize` was not truncating the write buffer if nothing was serialized during `NetworkBehaviour.OnSynchronize` causing an additional 6 bytes to be written per `NetworkBehaviour` component instance. (#2749)
+
+## [1.7.0] - 2023-10-11
+
+### Added
+
+- exposed NetworkObject.GetNetworkBehaviourAtOrderIndex as a public API (#2724)
+- Added context menu tool that provides users with the ability to quickly update the GlobalObjectIdHash value for all in-scene placed prefab instances that were created prior to adding a NetworkObject component to it. (#2707)
+- Added methods NetworkManager.SetPeerMTU and NetworkManager.GetPeerMTU to be able to set MTU sizes per-peer (#2676)
+- Added `GenerateSerializationForGenericParameterAttribute`, which can be applied to user-created Network Variable types to ensure the codegen generates serialization for the generic types they wrap. (#2694)
+- Added `GenerateSerializationForTypeAttribute`, which can be applied to any class or method to ensure the codegen generates serialization for the specific provided type. (#2694)
+- Exposed `NetworkVariableSerialization<T>.Read`, `NetworkVariableSerialization<T>.Write`, `NetworkVariableSerialization<T>.AreEqual`, and `NetworkVariableSerialization<T>.Duplicate` to further support the creation of user-created network variables by allowing users to access the generated serialization methods and serialize generic types efficiently without boxing. (#2694)
+- Added `NetworkVariableBase.MarkNetworkBehaviourDirty` so that user-created network variable types can mark their containing `NetworkBehaviour` to be processed by the update loop. (#2694)
+
+### Fixed
+
+- Fixed issue where the server side `NetworkSceneManager` instance was not adding the currently active scene to its list of scenes loaded. (#2723)
+- Generic NetworkBehaviour types no longer result in compile errors or runtime errors (#2720)
+- Rpcs within Generic NetworkBehaviour types can now serialize parameters of the class's generic types (but may not have generic types of their own) (#2720)
+- Errors are no longer thrown when entering play mode with domain reload disabled (#2720)
+- NetworkSpawn is now correctly called each time when entering play mode with scene reload disabled (#2720)
+- NetworkVariables of non-integer types will no longer break the inspector (#2714)
+- NetworkVariables with NonSerializedAttribute will not appear in the inspector (#2714)
+- Fixed issue where `UnityTransport` would attempt to establish WebSocket connections even if using UDP/DTLS Relay allocations when the build target was WebGL. This only applied to working in the editor since UDP/DTLS can't work in the browser. (#2695)
+- Fixed issue where a `NetworkBehaviour` component's `OnNetworkDespawn` was not being invoked on the host-server side for an in-scene placed `NetworkObject` when a scene was unloaded (during a scene transition) and the `NetworkBehaviour` component was positioned/ordered before the `NetworkObject` component. (#2685)
+- Fixed issue where `SpawnWithObservers` was not being honored when `NetworkConfig.EnableSceneManagement` was disabled. (#2682)
+- Fixed issue where `NetworkAnimator` was not internally tracking changes to layer weights which prevented proper layer weight synchronization back to the original layer weight value. (#2674)
+- Fixed "writing past the end of the buffer" error when calling ResetDirty() on managed network variables that are larger than 256 bytes when serialized. (#2670)
+- Fixed issue where generation of the `DefaultNetworkPrefabs` asset was not enabled by default. (#2662)
+- Fixed issue where the `GlobalObjectIdHash` value could be updated but the asset not marked as dirty. (#2662)
+- Fixed issue where the `GlobalObjectIdHash` value of a (network) prefab asset could be assigned an incorrect value when editing the prefab in a temporary scene. (#2662)
+- Fixed issue where the `GlobalObjectIdHash` value generated after creating a (network) prefab from an object constructed within the scene would not be the correct final value in a stand alone build. (#2662)
+
+### Changed
+
+- Updated dependency on `com.unity.transport` to version 1.4.0. (#2716)
+
+## [1.6.0] - 2023-08-09
+
+### Added
+
+- Added a protected virtual method `NetworkTransform.OnInitialize(ref NetworkTransformState replicatedState)` that just returns the replicated state reference.
+  
+### Fixed
+
+- Fixed issue where invoking `NetworkManager.Shutdown` within `NetworkManager.OnClientStopped` or `NetworkManager.OnServerStopped` would force `NetworkManager.ShutdownInProgress` to remain true after completing the shutdown process. (#2661)
+- Fixed issue where ARMv7 Android builds would crash when trying to validate the batch header. (#2654)
+- Fixed issue with client synchronization of position when using half precision and the delta position reaches the maximum value and is collapsed on the host prior to being forwarded to the non-owner clients. (#2636)
+- Fixed issue with scale not synchronizing properly depending upon the spawn order of NetworkObjects. (#2636)
+- Fixed issue position was not properly transitioning between ownership changes with an owner authoritative NetworkTransform. (#2636)
+- Fixed issue where a late joining non-owner client could update an owner authoritative NetworkTransform if ownership changed without any updates to position prior to the non-owner client joining. (#2636)
+
+### Changed
+
+## [1.5.2] - 2023-07-24
+
+### Added
+
+### Fixed
+- Bumped minimum Unity version supported to 2021.3 LTS
+- Fixed issue where `NetworkClient.OwnedObjects` was not returning any owned objects due to the `NetworkClient.IsConnected` not being properly set. (#2631)
+- Fixed a crash when calling TrySetParent with a null Transform (#2625)
+- Fixed issue where a `NetworkTransform` using full precision state updates was losing transform state updates when interpolation was enabled. (#2624)
+- Fixed issue where `NetworkObject.SpawnWithObservers` was not being honored for late joining clients. (#2623)
+- Fixed issue where invoking `NetworkManager.Shutdown` multiple times, depending upon the timing, could cause an exception. (#2622)
+- Fixed issue where removing ownership would not notify the server that it gained ownership. This also resolves the issue where an owner authoritative NetworkTransform would not properly initialize upon removing ownership from a remote client. (#2618)
+- Fixed ILPP issues when using CoreCLR and for certain dedicated server builds. (#2614)
+- Fixed an ILPP compile error when creating a generic NetworkBehaviour singleton with a static T instance. (#2603)
+
+### Changed
+
+## [1.5.1] - 2023-06-07
+
+### Added
+
+- Added support for serializing `NativeArray<>` and `NativeList<>` in `FastBufferReader`/`FastBufferWriter`, `BufferSerializer`, `NetworkVariable`, and RPCs. (To use `NativeList<>`, add `UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT` to your Scripting Define Symbols in `Project Settings > Player`) (#2375)
+- The location of the automatically-created default network prefab list can now be configured (#2544)
+- Added: Message size limits (max single message and max fragmented message) can now be set using NetworkManager.MaximumTransmissionUnitSize and NetworkManager.MaximumFragmentedMessageSize for transports that don't work with the default values (#2530)
+- Added `NetworkObject.SpawnWithObservers` property (default is true) that when set to false will spawn a `NetworkObject` with no observers and will not be spawned on any client until `NetworkObject.NetworkShow` is invoked. (#2568)
+
+### Fixed
+
+- Fixed: Fixed a null reference in codegen in some projects (#2581)
+- Fixed issue where the `OnClientDisconnected` client identifier was incorrect after a pending client connection was denied. (#2569)
+- Fixed warning "Runtime Network Prefabs was not empty at initialization time." being erroneously logged when no runtime network prefabs had been added (#2565)
+- Fixed issue where some temporary debug console logging was left in a merged PR. (#2562)
+- Fixed the "Generate Default Network Prefabs List" setting not loading correctly and always reverting to being checked. (#2545)
+- Fixed issue where users could not use NetworkSceneManager.VerifySceneBeforeLoading to exclude runtime generated scenes from client synchronization. (#2550)
+- Fixed missing value on `NetworkListEvent` for `EventType.RemoveAt` events.  (#2542,#2543)
+- Fixed issue where parenting a NetworkTransform under a transform with a scale other than Vector3.one would result in incorrect values on non-authoritative instances. (#2538)
+- Fixed issue where a server would include scene migrated and then despawned NetworkObjects to a client that was being synchronized. (#2532)
+- Fixed the inspector throwing exceptions when attempting to render `NetworkVariable`s of enum types. (#2529)
+- Making a `NetworkVariable` with an `INetworkSerializable` type that doesn't meet the `new()` constraint will now create a compile-time error instead of an editor crash (#2528)
+- Fixed Multiplayer Tools package installation docs page link on the NetworkManager popup. (#2526)
+- Fixed an exception and error logging when two different objects are shown and hidden on the same frame (#2524)
+- Fixed a memory leak in `UnityTransport` that occurred if `StartClient` failed. (#2518)
+- Fixed issue where a client could throw an exception if abruptly disconnected from a network session with one or more spawned `NetworkObject`(s). (#2510)
+- Fixed issue where invalid endpoint addresses were not being detected and returning false from NGO UnityTransport. (#2496)
+- Fixed some errors that could occur if a connection is lost and the loss is detected when attempting to write to the socket. (#2495)
+
+## Changed
+
+- Adding network prefabs before NetworkManager initialization is now supported. (#2565)
+- Connecting clients being synchronized now switch to the server's active scene before spawning and synchronizing NetworkObjects. (#2532)
+- Updated `UnityTransport` dependency on `com.unity.transport` to 1.3.4. (#2533)
+- Improved performance of NetworkBehaviour initialization by replacing reflection when initializing NetworkVariables with compile-time code generation, which should help reduce hitching during additive scene loads. (#2522)
+
+## [1.4.0] - 2023-04-10
+
+### Added
+
+- Added a way to access the GlobalObjectIdHash via PrefabIdHash for use in the Connection Approval Callback. (#2437)
+- Added `OnServerStarted` and `OnServerStopped` events that will trigger only on the server (or host player) to notify that the server just started or is no longer active (#2420)
+- Added `OnClientStarted` and `OnClientStopped` events that will trigger only on the client (or host player) to notify that the client just started or is no longer active (#2420)
+- Added `NetworkTransform.UseHalfFloatPrecision` property that, when enabled, will use half float values for position, rotation, and scale. This yields a 50% bandwidth savings a the cost of precision. (#2388)
+- Added `NetworkTransform.UseQuaternionSynchronization` property that, when enabled, will synchronize the entire quaternion. (#2388)
+- Added `NetworkTransform.UseQuaternionCompression` property that, when enabled, will use a smallest three implementation reducing a full quaternion synchronization update to the size of an unsigned integer. (#2388)
+- Added `NetworkTransform.SlerpPosition` property that, when enabled along with interpolation being enabled, will interpolate using `Vector3.Slerp`. (#2388)
+- Added `BufferedLinearInterpolatorVector3` that replaces the float version, is now used by `NetworkTransform`, and provides the ability to enable or disable `Slerp`. (#2388)
+- Added `HalfVector3` used for scale when half float precision is enabled. (#2388)
+- Added `HalfVector4` used for rotation when half float precision and quaternion synchronization is enabled. (#2388)
+- Added `HalfVector3DeltaPosition` used for position when half float precision is enabled. This handles loss in position precision by updating only the delta position as opposed to the full position. (#2388)
+- Added `NetworkTransform.GetSpaceRelativePosition` and `NetworkTransform.GetSpaceRelativeRotation` helper methods to return the proper values depending upon whether local or world space. (#2388)
+- Added `NetworkTransform.OnAuthorityPushTransformState` virtual method that is invoked just prior to sending the `NetworkTransformState` to non-authoritative instances. This provides users with the ability to obtain more precise delta values for prediction related calculations. (#2388)
+- Added `NetworkTransform.OnNetworkTransformStateUpdated` virtual method that is invoked just after the authoritative `NetworkTransformState` is applied. This provides users with the ability to obtain more precise delta values for prediction related calculations. (#2388)
+- Added `NetworkTransform.OnInitialize`virtual method that is invoked after the `NetworkTransform` has been initialized or re-initialized when ownership changes. This provides for a way to make adjustments when `NetworkTransform` is initialized (i.e. resetting client prediction etc) (#2388)
+- Added `NetworkObject.SynchronizeTransform` property (default is true) that provides users with another way to help with bandwidth optimizations where, when set to false, the `NetworkObject`'s associated transform will not be included when spawning and/or synchronizing late joining players. (#2388)
+- Added `NetworkSceneManager.ActiveSceneSynchronizationEnabled` property, disabled by default, that enables client synchronization of server-side active scene changes. (#2383)
+- Added `NetworkObject.ActiveSceneSynchronization`, disabled by default, that will automatically migrate a `NetworkObject` to a newly assigned active scene. (#2383)
+- Added `NetworkObject.SceneMigrationSynchronization`, enabled by default, that will synchronize client(s) when a `NetworkObject` is migrated into a new scene on the server side via `SceneManager.MoveGameObjectToScene`. (#2383)
+
+### Changed
+
+- Made sure the `CheckObjectVisibility` delegate is checked and applied, upon `NetworkShow` attempt. Found while supporting (#2454), although this is not a fix for this (already fixed) issue. (#2463)
+- Changed `NetworkTransform` authority handles delta checks on each new network tick and no longer consumes processing cycles checking for deltas for all frames in-between ticks. (#2388)
+- Changed the `NetworkTransformState` structure is now public and now has public methods that provide access to key properties of the `NetworkTransformState` structure. (#2388)
+- Changed `NetworkTransform` interpolation adjusts its interpolation "ticks ago" to be 2 ticks latent if it is owner authoritative and the instance is not the server or 1 tick latent if the instance is the server and/or is server authoritative. (#2388)
+- Updated `NetworkSceneManager` to migrate dynamically spawned `NetworkObject`s with `DestroyWithScene` set to false into the active scene if their current scene is unloaded. (#2383)
+- Updated the server to synchronize its local `NetworkSceneManager.ClientSynchronizationMode` during the initial client synchronization. (#2383)
+
+### Fixed
+
+- Fixed issue where during client synchronization the synchronizing client could receive a ObjectSceneChanged message before the client-side NetworkObject instance had been instantiated and spawned. (#2502)
+- Fixed issue where `NetworkAnimator` was building client RPC parameters to exclude the host from sending itself messages but was not including it in the ClientRpc parameters. (#2492)
+- Fixed issue where `NetworkAnimator` was not properly detecting and synchronizing cross fade initiated transitions. (#2481)
+- Fixed issue where `NetworkAnimator` was not properly synchronizing animation state updates. (#2481)
+- Fixed float NetworkVariables not being rendered properly in the inspector of NetworkObjects. (#2441)
+- Fixed an issue where Named Message Handlers could remove themselves causing an exception when the metrics tried to access the name of the message.(#2426)
+- Fixed registry of public `NetworkVariable`s in derived `NetworkBehaviour`s (#2423)
+- Fixed issue where runtime association of `Animator` properties to `AnimationCurve`s would cause `NetworkAnimator` to attempt to update those changes. (#2416)
+- Fixed issue where `NetworkAnimator` would not check if its associated `Animator` was valid during serialization and would spam exceptions in the editor console. (#2416)
+- Fixed issue with a child's rotation rolling over when interpolation is enabled on a `NetworkTransform`. Now using half precision or full quaternion synchronization will always update all axis. (#2388)
+- Fixed issue where `NetworkTransform` was not setting the teleport flag when the `NetworkTransform.InLocalSpace` value changed. This issue only impacted `NetworkTransform` when interpolation was enabled. (#2388)
+- Fixed issue when the `NetworkSceneManager.ClientSynchronizationMode` is `LoadSceneMode.Additive` and the server changes the currently active scene prior to a client connecting then upon a client connecting and being synchronized the NetworkSceneManager would clear its internal ScenePlacedObjects list that could already be populated. (#2383)
+- Fixed issue where a client would load duplicate scenes of already preloaded scenes during the initial client synchronization and `NetworkSceneManager.ClientSynchronizationMode` was set to `LoadSceneMode.Additive`. (#2383)
+
 ## [1.3.1] - 2023-03-27
 
 ### Added

Components/HalfVector3.cs

@@ -0,0 +1,170 @@
+using System.Runtime.CompilerServices;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+    /// <summary>
+    /// Half float precision <see cref="Vector3"/>.
+    /// </summary>
+    /// <remarks>
+    /// The Vector3T<ushort> values are half float values returned by <see cref="Mathf.FloatToHalf(float)"/> for each
+    /// individual axis and the 16 bits of the half float are stored as <see cref="ushort"/> values since C# does not have
+    /// a half float type.
+    /// </remarks>
+    public struct HalfVector3 : INetworkSerializable
+    {
+        internal const int Length = 3;
+
+        /// <summary>
+        /// The half float precision value of the x-axis as a <see cref="half"/>.
+        /// </summary>
+        public half X => Axis.x;
+        /// <summary>
+        /// The half float precision value of the y-axis as a <see cref="half"/>.
+        /// </summary>
+        public half Y => Axis.y;
+        /// <summary>
+        /// The half float precision value of the z-axis as a <see cref="half"/>.
+        /// </summary>
+        public half Z => Axis.z;
+
+        /// <summary>
+        /// Used to store the half float precision values as a <see cref="half3"/>
+        /// </summary>
+        public half3 Axis;
+
+        /// <summary>
+        /// Determine which axis will be synchronized during serialization
+        /// </summary>
+        public bool3 AxisToSynchronize;
+
+        /// <summary>
+        /// Directly sets each axial value to the passed in full precision values
+        /// that are converted to half precision
+        /// </summary>
+        internal void Set(float x, float y, float z)
+        {
+            Axis.x = math.half(x);
+            Axis.y = math.half(y);
+            Axis.z = math.half(z);
+        }
+
+        private void SerializeWrite(FastBufferWriter writer)
+        {
+            for (int i = 0; i < Length; i++)
+            {
+                if (AxisToSynchronize[i])
+                {
+                    writer.WriteUnmanagedSafe(Axis[i]);
+                }
+            }
+        }
+
+        private void SerializeRead(FastBufferReader reader)
+        {
+            for (int i = 0; i < Length; i++)
+            {
+                if (AxisToSynchronize[i])
+                {
+                    var axisValue = Axis[i];
+                    reader.ReadUnmanagedSafe(out axisValue);
+                    Axis[i] = axisValue;
+                }
+            }
+        }
+
+        /// <summary>
+        /// The serialization implementation of <see cref="INetworkSerializable"/>.
+        /// </summary>
+        public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
+        {
+            if (serializer.IsReader)
+            {
+                SerializeRead(serializer.GetFastBufferReader());
+            }
+            else
+            {
+                SerializeWrite(serializer.GetFastBufferWriter());
+            }
+        }
+
+        /// <summary>
+        /// Gets the full precision value as a <see cref="Vector3"/>.
+        /// </summary>
+        /// <returns>a <see cref="Vector3"/> as the full precision value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 ToVector3()
+        {
+            Vector3 fullPrecision = Vector3.zero;
+            Vector3 fullConversion = math.float3(Axis);
+            for (int i = 0; i < Length; i++)
+            {
+                if (AxisToSynchronize[i])
+                {
+                    fullPrecision[i] = fullConversion[i];
+                }
+            }
+            return fullPrecision;
+        }
+
+        /// <summary>
+        /// Converts a full precision <see cref="Vector3"/> to half precision and updates the current instance.
+        /// </summary>
+        /// <param name="vector3">The <see cref="Vector3"/> to convert.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UpdateFrom(ref Vector3 vector3)
+        {
+            var half3Full = math.half3(vector3);
+            for (int i = 0; i < Length; i++)
+            {
+                if (AxisToSynchronize[i])
+                {
+                    Axis[i] = half3Full[i];
+                }
+            }
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="vector3">The initial axial values (converted to half floats) when instantiated.</param>
+        /// <param name="vector3AxisToSynchronize">The axis to synchronize.</param>
+        public HalfVector3(Vector3 vector3, bool3 axisToSynchronize)
+        {
+            Axis = half3.zero;
+            AxisToSynchronize = axisToSynchronize;
+            UpdateFrom(ref vector3);
+        }
+
+        /// <summary>
+        /// Constructor that defaults to all axis being synchronized.
+        /// </summary>
+        /// <param name="vector3">The initial axial values (converted to half floats) when instantiated.</param>
+        public HalfVector3(Vector3 vector3) : this(vector3, math.bool3(true))
+        {
+
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="x">The initial x axis (converted to half float) value when instantiated.</param>
+        /// <param name="y">The initial y axis (converted to half float) value when instantiated.</param>
+        /// <param name="z">The initial z axis (converted to half float) value when instantiated.</param>
+        /// <param name="axisToSynchronize">The axis to synchronize.</param>
+        public HalfVector3(float x, float y, float z, bool3 axisToSynchronize) : this(new Vector3(x, y, z), axisToSynchronize)
+        {
+        }
+
+        /// <summary>
+        /// Constructor that defaults to all axis being synchronized.
+        /// </summary>
+        /// <param name="x">The initial x axis (converted to half float) value when instantiated.</param>
+        /// <param name="y">The initial y axis (converted to half float) value when instantiated.</param>
+        /// <param name="z">The initial z axis (converted to half float) value when instantiated.</param>
+        public HalfVector3(float x, float y, float z) : this(new Vector3(x, y, z), math.bool3(true))
+        {
+        }
+    }
+}

Components/HalfVector3.cs.meta

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

Components/HalfVector4.cs

@@ -0,0 +1,137 @@
+using System.Runtime.CompilerServices;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+    /// <summary>
+    /// Half Precision <see cref="Vector4"/> that can also be used to convert a <see cref="Quaternion"/> to half precision.
+    /// </summary>
+    /// <remarks>
+    /// The Vector4T<ushort> values are half float values returned by <see cref="Mathf.FloatToHalf(float)"/> for each
+    /// individual axis and the 16 bits of the half float are stored as <see cref="ushort"/> values since C# does not have
+    /// a half float type.
+    /// </remarks>
+    public struct HalfVector4 : INetworkSerializable
+    {
+        internal const int Length = 4;
+        /// <summary>
+        /// The half float precision value of the x-axis as a <see cref="half"/>.
+        /// </summary>
+        public half X => Axis.x;
+
+        /// <summary>
+        /// The half float precision value of the y-axis as a <see cref="half"/>.
+        /// </summary>
+        public half Y => Axis.y;
+
+        /// <summary>
+        /// The half float precision value of the z-axis as a <see cref="half"/>.
+        /// </summary>
+        public half Z => Axis.z;
+
+        /// <summary>
+        /// The half float precision value of the w-axis as a <see cref="half"/>.
+        /// </summary>
+        public half W => Axis.w;
+
+        /// <summary>
+        /// Used to store the half float precision values as a <see cref="half4"/>
+        /// </summary>
+        public half4 Axis;
+
+        private void SerializeWrite(FastBufferWriter writer)
+        {
+            for (int i = 0; i < Length; i++)
+            {
+                writer.WriteUnmanagedSafe(Axis[i]);
+            }
+        }
+
+        private void SerializeRead(FastBufferReader reader)
+        {
+            for (int i = 0; i < Length; i++)
+            {
+                var axisValue = Axis[i];
+                reader.ReadUnmanagedSafe(out axisValue);
+                Axis[i] = axisValue;
+            }
+        }
+
+        /// <summary>
+        /// The serialization implementation of <see cref="INetworkSerializable"/>.
+        /// </summary>
+        public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
+        {
+            if (serializer.IsReader)
+            {
+                SerializeRead(serializer.GetFastBufferReader());
+            }
+            else
+            {
+                SerializeWrite(serializer.GetFastBufferWriter());
+            }
+        }
+
+        /// <summary>
+        /// Converts this instance to a full precision <see cref="Vector4"/>.
+        /// </summary>
+        /// <returns>A <see cref="Vector4"/> as the full precision value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector4 ToVector4()
+        {
+            return math.float4(Axis);
+        }
+
+        /// <summary>
+        /// Converts this instance to a full precision <see cref="Quaternion"/>.
+        /// </summary>
+        /// <returns>A <see cref="Quaternion"/> as the full precision value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Quaternion ToQuaternion()
+        {
+            return math.quaternion(Axis);
+        }
+
+        /// <summary>
+        /// Converts a full precision <see cref="Vector4"/> to half precision and updates the current instance.
+        /// </summary>
+        /// <param name="vector4">The <see cref="Vector4"/> to convert and update this instance with.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UpdateFrom(ref Vector4 vector4)
+        {
+            Axis = math.half4(vector4);
+        }
+
+        /// <summary>
+        /// Converts a full precision <see cref="Vector4"/> to half precision and updates the current instance.
+        /// </summary>
+        /// <param name="quaternion">The <see cref="Quaternion"/> to convert and update this instance with.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UpdateFrom(ref Quaternion quaternion)
+        {
+            Axis = math.half4(math.half(quaternion.x), math.half(quaternion.y), math.half(quaternion.z), math.half(quaternion.w));
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="vector4">The initial axial values (converted to half floats) when instantiated.</param>
+        public HalfVector4(Vector4 vector4)
+        {
+            Axis = default;
+            UpdateFrom(ref vector4);
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="x">The initial x axis (converted to half float) value when instantiated.</param>
+        /// <param name="y">The initial y axis (converted to half float) value when instantiated.</param>
+        /// <param name="z">The initial z axis (converted to half float) value when instantiated.</param>
+        /// <param name="w">The initial w axis (converted to half float) value when instantiated.</param>
+        public HalfVector4(float x, float y, float z, float w) : this(new Vector4(x, y, z, w))
+        {
+        }
+    }
+}

Components/HalfVector4.cs.meta

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

Components/Interpolator/BufferedLinearInterpolator.cs

@@ -312,20 +312,79 @@ namespace Unity.Netcode
     /// </remarks>
     public class BufferedLinearInterpolatorQuaternion : BufferedLinearInterpolator<Quaternion>
     {
+        /// <summary>
+        /// Use <see cref="Quaternion.Slerp"/> when <see cref="true"/>.
+        /// Use <see cref="Quaternion.Lerp"/> when <see cref="false"/>
+        /// </summary>
+        /// <remarks>
+        /// When using half precision (due to the imprecision) using <see cref="Quaternion.Lerp"/> is
+        /// less processor intensive (i.e. precision is already "imprecise").
+        /// When using full precision (to maintain precision) using <see cref="Quaternion.Slerp"/> is
+        /// more processor intensive yet yields more precise results.
+        /// </remarks>
+        public bool IsSlerp;
+
         /// <inheritdoc />
         protected override Quaternion InterpolateUnclamped(Quaternion start, Quaternion end, float time)
         {
-            // Disabling Extrapolation:
-            // TODO: Add Jira Ticket
-            return Quaternion.Slerp(start, end, time);
+            if (IsSlerp)
+            {
+                return Quaternion.Slerp(start, end, time);
+            }
+            else
+            {
+                return Quaternion.Lerp(start, end, time);
+            }
         }
 
         /// <inheritdoc />
         protected override Quaternion Interpolate(Quaternion start, Quaternion end, float time)
         {
-            // Disabling Extrapolation:
-            // TODO: Add Jira Ticket
-            return Quaternion.Slerp(start, end, time);
+            if (IsSlerp)
+            {
+                return Quaternion.Slerp(start, end, time);
+            }
+            else
+            {
+                return Quaternion.Lerp(start, end, time);
+            }
+        }
+    }
+
+    /// <summary>
+    /// A <see cref="BufferedLinearInterpolator<T>"/> <see cref="Vector3"/> implementation.
+    /// </summary>
+    public class BufferedLinearInterpolatorVector3 : BufferedLinearInterpolator<Vector3>
+    {
+        /// <summary>
+        /// Use <see cref="Vector3.Slerp"/> when <see cref="true"/>.
+        /// Use <see cref="Vector3.Lerp"/> when <see cref="false"/>
+        /// </summary>
+        public bool IsSlerp;
+        /// <inheritdoc />
+        protected override Vector3 InterpolateUnclamped(Vector3 start, Vector3 end, float time)
+        {
+            if (IsSlerp)
+            {
+                return Vector3.Slerp(start, end, time);
+            }
+            else
+            {
+                return Vector3.Lerp(start, end, time);
+            }
+        }
+
+        /// <inheritdoc />
+        protected override Vector3 Interpolate(Vector3 start, Vector3 end, float time)
+        {
+            if (IsSlerp)
+            {
+                return Vector3.Slerp(start, end, time);
+            }
+            else
+            {
+                return Vector3.Lerp(start, end, time);
+            }
         }
     }
 }

Components/Messages.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a9db1d18fa0117f4da5e8e65386b894a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Components/Messages/NetworkTransformMessage.cs

@@ -0,0 +1,205 @@
+using Unity.Netcode.Components;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// NetworkTransform State Update Message
+    /// </summary>
+    internal struct NetworkTransformMessage : INetworkMessage
+    {
+        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;
+        private FastBufferReader m_CurrentReader;
+
+        private unsafe void CopyPayload(ref FastBufferWriter writer)
+        {
+            writer.WriteBytesSafe(m_CurrentReader.GetUnsafePtrAtCurrentPosition(), m_CurrentReader.Length - m_CurrentReader.Position);
+        }
+
+        public void Serialize(FastBufferWriter writer, int targetVersion)
+        {
+            if (m_CurrentReader.IsInitialized)
+            {
+                CopyPayload(ref writer);
+            }
+            else
+            {
+                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);
+                    }
+                }
+            }
+        }
+
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+        {
+            var networkManager = context.SystemOwner as NetworkManager;
+            if (networkManager == null)
+            {
+                Debug.LogError($"[{nameof(NetworkTransformMessage)}] System owner context was not of type {nameof(NetworkManager)}!");
+                return false;
+            }
+            var currentPosition = reader.Position;
+            ByteUnpacker.ReadValueBitPacked(reader, out 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.ReadNetworkSerializableInPlace(ref State);
+
+            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;
+                }
+            }
+
+            if (isSpawnedLocally)
+            {
+                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;
+            }
+
+            if (ownerAuthoritativeServerSide)
+            {
+                var ownerClientId = (ulong)0;
+
+                if (networkObject != null)
+                {
+                    ownerClientId = networkObject.OwnerClientId;
+                    if (ownerClientId == NetworkManager.ServerClientId)
+                    {
+                        // 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;
+
+                // 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;
+                    // Create a new reader that replicates this message
+                    currentMessage.m_CurrentReader = new FastBufferReader(reader, Collections.Allocator.None);
+                    // 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
+
+                    for (int i = 0; i < clientCount; i++)
+                    {
+                        var clientId = networkManager.DistributedAuthorityMode ? TargetIds[i] : networkManager.ConnectionManager.ConnectedClientsList[i].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
+                    currentMessage.m_CurrentReader.Dispose();
+                }
+            }
+            return true;
+        }
+
+        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, context.SenderId);
+        }
+    }
+}

Components/Messages/NetworkTransformMessage.cs.meta

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

Components/NetworkAnimator.cs

@@ -23,21 +23,50 @@ namespace Unity.Netcode.Components
         /// </summary>
         private void FlushMessages()
         {
+            foreach (var animationUpdate in m_SendAnimationUpdates)
+            {
+
+                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();
@@ -64,9 +93,11 @@ namespace Unity.Netcode.Components
                             m_NetworkAnimator.UpdateParameters(ref parameterUpdate);
                         }
                         m_ProcessParameterUpdates.Clear();
+                        var isServerAuthority = m_NetworkAnimator.IsServerAuthoritative();
 
-                        // Only owners check for Animator changes
-                        if (m_NetworkAnimator.IsOwner && !m_NetworkAnimator.IsServerAuthoritative() || m_NetworkAnimator.IsServerAuthoritative() && m_NetworkAnimator.NetworkManager.IsServer)
+                        // owners when owner authoritative or the server when server authoritative are the only instances that
+                        // checks for Animator changes
+                        if ((!isServerAuthority && m_NetworkAnimator.IsOwner) || (isServerAuthority && m_NetworkAnimator.IsServer))
                         {
                             m_NetworkAnimator.CheckForAnimatorChanges();
                         }
@@ -157,11 +188,11 @@ namespace Unity.Netcode.Components
     [AddComponentMenu("Netcode/Network Animator")]
     [RequireComponent(typeof(Animator))]
     public class NetworkAnimator : NetworkBehaviour, ISerializationCallbackReceiver
-
     {
         [Serializable]
         internal class TransitionStateinfo
         {
+            public bool IsCrossFadeExit;
             public int Layer;
             public int OriginatingState;
             public int DestinationState;
@@ -279,6 +310,11 @@ namespace Unity.Netcode.Components
             {
                 return;
             }
+            if (m_Animator == null)
+            {
+                return;
+            }
+
             TransitionStateInfoList = new List<TransitionStateinfo>();
             var animatorController = m_Animator.runtimeAnimatorController as AnimatorController;
             if (animatorController == null)
@@ -312,9 +348,19 @@ namespace Unity.Netcode.Components
             internal float NormalizedTime;
             internal int Layer;
             internal float Weight;
+            internal float Duration;
 
             // For synchronizing transitions
             internal bool Transition;
+            internal bool CrossFade;
+
+            // Flags for bool states
+            private const byte k_IsTransition = 0x01;
+            private const byte k_IsCrossFade = 0x02;
+
+            // Used to serialize the bool states
+            private byte m_StateFlags;
+
             // The StateHash is where the transition starts
             // and the DestinationStateHash is the destination state
             internal int DestinationStateHash;
@@ -324,65 +370,46 @@ namespace Unity.Netcode.Components
                 if (serializer.IsWriter)
                 {
                     var writer = serializer.GetFastBufferWriter();
-                    var writeSize = FastBufferWriter.GetWriteSize(Transition);
-                    writeSize += FastBufferWriter.GetWriteSize(StateHash);
-                    writeSize += FastBufferWriter.GetWriteSize(NormalizedTime);
-                    writeSize += FastBufferWriter.GetWriteSize(Layer);
-                    writeSize += FastBufferWriter.GetWriteSize(Weight);
+                    m_StateFlags = 0x00;
                     if (Transition)
                     {
-                        writeSize += FastBufferWriter.GetWriteSize(DestinationStateHash);
+                        m_StateFlags |= k_IsTransition;
                     }
-
-                    if (!writer.TryBeginWrite(writeSize))
+                    if (CrossFade)
                     {
-                        throw new OverflowException($"[{GetType().Name}] Could not serialize: Out of buffer space.");
+                        m_StateFlags |= k_IsCrossFade;
                     }
+                    serializer.SerializeValue(ref m_StateFlags);
 
-                    writer.WriteValue(Transition);
-                    writer.WriteValue(StateHash);
-                    writer.WriteValue(NormalizedTime);
-                    writer.WriteValue(Layer);
-                    writer.WriteValue(Weight);
+                    BytePacker.WriteValuePacked(writer, StateHash);
+                    BytePacker.WriteValuePacked(writer, Layer);
                     if (Transition)
                     {
-                        writer.WriteValue(DestinationStateHash);
+                        BytePacker.WriteValuePacked(writer, DestinationStateHash);
                     }
                 }
                 else
                 {
                     var reader = serializer.GetFastBufferReader();
-                    // Begin reading the Transition flag
-                    if (!reader.TryBeginRead(FastBufferWriter.GetWriteSize(Transition)))
-                    {
-                        throw new OverflowException($"[{GetType().Name}] Could not deserialize: Out of buffer space.");
-                    }
-                    reader.ReadValue(out Transition);
+                    serializer.SerializeValue(ref m_StateFlags);
+                    Transition = (m_StateFlags & k_IsTransition) == k_IsTransition;
+                    CrossFade = (m_StateFlags & k_IsCrossFade) == k_IsCrossFade;
 
-                    // Now determine what remains to be read
-                    var readSize = FastBufferWriter.GetWriteSize(StateHash);
-                    readSize += FastBufferWriter.GetWriteSize(NormalizedTime);
-                    readSize += FastBufferWriter.GetWriteSize(Layer);
-                    readSize += FastBufferWriter.GetWriteSize(Weight);
+                    ByteUnpacker.ReadValuePacked(reader, out StateHash);
+                    ByteUnpacker.ReadValuePacked(reader, out Layer);
                     if (Transition)
                     {
-                        readSize += FastBufferWriter.GetWriteSize(DestinationStateHash);
+                        ByteUnpacker.ReadValuePacked(reader, out DestinationStateHash);
                     }
+                }
 
-                    // Now read the remaining information about this AnimationState
-                    if (!reader.TryBeginRead(readSize))
-                    {
-                        throw new OverflowException($"[{GetType().Name}] Could not deserialize: Out of buffer space.");
-                    }
+                serializer.SerializeValue(ref NormalizedTime);
+                serializer.SerializeValue(ref Weight);
 
-                    reader.ReadValue(out StateHash);
-                    reader.ReadValue(out NormalizedTime);
-                    reader.ReadValue(out Layer);
-                    reader.ReadValue(out Weight);
-                    if (Transition)
-                    {
-                        reader.ReadValue(out DestinationStateHash);
-                    }
+                // Cross fading includes the duration of the cross fade.
+                if (CrossFade)
+                {
+                    serializer.SerializeValue(ref Duration);
                 }
             }
         }
@@ -565,8 +592,10 @@ namespace Unity.Netcode.Components
 
             // We initialize the m_AnimationMessage for all instances in the event that
             // ownership or authority changes during runtime.
-            m_AnimationMessage = new AnimationMessage();
-            m_AnimationMessage.AnimationStates = new List<AnimationState>();
+            m_AnimationMessage = new AnimationMessage
+            {
+                AnimationStates = new List<AnimationState>()
+            };
 
             // Store off our current layer weights and create our animation
             // state entries per layer.
@@ -588,17 +617,13 @@ namespace Unity.Netcode.Components
             m_CachedAnimatorParameters = new NativeArray<AnimatorParamCache>(parameters.Length, Allocator.Persistent);
             m_ParametersToUpdate = new List<int>(parameters.Length);
 
+            // Include all parameters including any controlled by an AnimationCurve as this could change during runtime.
+            // We ignore changes to any parameter controlled by an AnimationCurve when we are checking for changes in
+            // the Animator's parameters.
             for (var i = 0; i < parameters.Length; i++)
             {
                 var parameter = parameters[i];
 
-                if (m_Animator.IsParameterControlledByCurve(parameter.nameHash))
-                {
-                    // we are ignoring parameters that are controlled by animation curves - syncing the layer
-                    //  states indirectly syncs the values that are driven by the animation curves
-                    continue;
-                }
-
                 var cacheParam = new AnimatorParamCache
                 {
                     Type = UnsafeUtility.EnumToInt(parameter.type),
@@ -643,14 +668,21 @@ namespace Unity.Netcode.Components
         /// <inheritdoc/>
         public override void OnNetworkSpawn()
         {
-            if (IsServer)
+            // If there is no assigned Animator then generate a server network warning (logged locally and if applicable on the server-host side as well).
+            if (m_Animator == null)
             {
-                m_ClientSendList = new List<ulong>(128);
-                m_ClientRpcParams = new ClientRpcParams();
-                m_ClientRpcParams.Send = new ClientRpcSendParams();
-                m_ClientRpcParams.Send.TargetClientIds = m_ClientSendList;
+                NetworkLog.LogWarningServer($"[{gameObject.name}][{nameof(NetworkAnimator)}] {nameof(Animator)} is not assigned! Animation synchronization will not work for this instance!");
             }
 
+            m_ClientSendList = new List<ulong>(128);
+            m_ClientRpcParams = new ClientRpcParams
+            {
+                Send = new ClientRpcSendParams
+                {
+                    TargetClientIds = m_ClientSendList
+                }
+            };
+
             // Create a handler for state changes
             m_NetworkAnimatorStateChangeHandler = new NetworkAnimatorStateChangeHandler(this);
         }
@@ -691,10 +723,7 @@ namespace Unity.Netcode.Components
                 for (int layer = 0; layer < m_Animator.layerCount; layer++)
                 {
                     var synchronizationStateInfo = m_Animator.GetCurrentAnimatorStateInfo(layer);
-                    if (SynchronizationStateInfo != null)
-                    {
-                        SynchronizationStateInfo.Add(synchronizationStateInfo);
-                    }
+                    SynchronizationStateInfo?.Add(synchronizationStateInfo);
                     var stateHash = synchronizationStateInfo.fullPathHash;
                     var normalizedTime = synchronizationStateInfo.normalizedTime;
                     var isInTransition = m_Animator.IsInTransition(layer);
@@ -767,11 +796,96 @@ namespace Unity.Netcode.Components
             else
             {
                 var parameters = new ParametersUpdateMessage();
-                var animationStates = new AnimationMessage();
+                var animationMessage = new AnimationMessage();
                 serializer.SerializeValue(ref parameters);
                 UpdateParameters(ref parameters);
-                serializer.SerializeValue(ref animationStates);
-                HandleAnimStateUpdate(ref animationStates);
+                serializer.SerializeValue(ref animationMessage);
+                foreach (var animationState in animationMessage.AnimationStates)
+                {
+                    UpdateAnimationState(animationState);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Checks for animation state changes in:
+        /// -Layer weights
+        /// -Cross fades
+        /// -Transitions
+        /// -Layer AnimationStates
+        /// </summary>
+        private void CheckForStateChange(int layer)
+        {
+            var stateChangeDetected = false;
+            var animState = m_AnimationMessage.AnimationStates[m_AnimationMessage.IsDirtyCount];
+            float layerWeightNow = m_Animator.GetLayerWeight(layer);
+            animState.CrossFade = false;
+            animState.Transition = false;
+            animState.NormalizedTime = 0.0f;
+            animState.Layer = layer;
+            animState.Duration = 0.0f;
+            animState.Weight = m_LayerWeights[layer];
+            animState.DestinationStateHash = 0;
+
+            if (layerWeightNow != m_LayerWeights[layer])
+            {
+                m_LayerWeights[layer] = layerWeightNow;
+                stateChangeDetected = true;
+                animState.Weight = layerWeightNow;
+            }
+
+            AnimatorStateInfo st = m_Animator.GetCurrentAnimatorStateInfo(layer);
+
+            if (m_Animator.IsInTransition(layer))
+            {
+                AnimatorTransitionInfo tt = m_Animator.GetAnimatorTransitionInfo(layer);
+                AnimatorStateInfo nt = m_Animator.GetNextAnimatorStateInfo(layer);
+                if (tt.anyState && tt.fullPathHash == 0 && m_TransitionHash[layer] != nt.fullPathHash)
+                {
+                    m_TransitionHash[layer] = nt.fullPathHash;
+                    m_AnimationHash[layer] = 0;
+                    animState.DestinationStateHash = nt.fullPathHash; // Next state is the destination state for cross fade
+                    animState.CrossFade = true;
+                    animState.Transition = true;
+                    animState.Duration = tt.duration;
+                    animState.NormalizedTime = tt.normalizedTime;
+                    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})");
+                }
+                else if (!tt.anyState && tt.fullPathHash != m_TransitionHash[layer])
+                {
+                    // first time in this transition for this layer
+                    m_TransitionHash[layer] = tt.fullPathHash;
+                    m_AnimationHash[layer] = 0;
+                    animState.StateHash = tt.fullPathHash; // Transitioning from state
+                    animState.CrossFade = false;
+                    animState.Transition = true;
+                    animState.NormalizedTime = tt.normalizedTime;
+                    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})");
+                }
+            }
+            else
+            {
+                if (st.fullPathHash != m_AnimationHash[layer])
+                {
+                    m_TransitionHash[layer] = 0;
+                    m_AnimationHash[layer] = st.fullPathHash;
+                    // first time in this animation state
+                    if (m_AnimationHash[layer] != 0)
+                    {
+                        // came from another animation directly - from Play()
+                        animState.StateHash = st.fullPathHash;
+                        animState.NormalizedTime = st.normalizedTime;
+                    }
+                    stateChangeDetected = true;
+                    //Debug.Log($"[State] From-Hash: ({m_AnimationHash[layer]}) |SI-FPHash: ({st.fullPathHash}) | SI-Norm: ({st.normalizedTime})");
+                }
+            }
+            if (stateChangeDetected)
+            {
+                m_AnimationMessage.AnimationStates[m_AnimationMessage.IsDirtyCount] = animState;
+                m_AnimationMessage.IsDirtyCount++;
             }
         }
 
@@ -784,11 +898,6 @@ namespace Unity.Netcode.Components
         /// </remarks>
         internal void CheckForAnimatorChanges()
         {
-            if (!IsSpawned || (!IsOwner && !IsServerAuthoritative()) || (IsServerAuthoritative() && !IsServer))
-            {
-                return;
-            }
-
             if (CheckParametersChanged())
             {
                 SendParametersUpdate();
@@ -803,9 +912,6 @@ namespace Unity.Netcode.Components
                 return;
             }
 
-            int stateHash;
-            float normalizedTime;
-
             // Reset the dirty count before checking for AnimationState updates
             m_AnimationMessage.IsDirtyCount = 0;
 
@@ -815,31 +921,17 @@ namespace Unity.Netcode.Components
                 AnimatorStateInfo st = m_Animator.GetCurrentAnimatorStateInfo(layer);
                 var totalSpeed = st.speed * st.speedMultiplier;
                 var adjustedNormalizedMaxTime = totalSpeed > 0.0f ? 1.0f / totalSpeed : 0.0f;
-
-                if (!CheckAnimStateChanged(out stateHash, out normalizedTime, layer))
-                {
-                    continue;
-                }
-
-                // If we made it here, then we need to synchronize this layer's animation state.
-                // Get one of the preallocated AnimationState entries and populate it with the
-                // current layer's state.
-                var animationState = m_AnimationMessage.AnimationStates[m_AnimationMessage.IsDirtyCount];
-
-                animationState.Transition = false; // Only used during synchronization
-                animationState.StateHash = stateHash;
-                animationState.NormalizedTime = normalizedTime;
-                animationState.Layer = layer;
-                animationState.Weight = m_LayerWeights[layer];
-
-                // Apply the changes
-                m_AnimationMessage.AnimationStates[m_AnimationMessage.IsDirtyCount] = animationState;
-                m_AnimationMessage.IsDirtyCount++;
+                CheckForStateChange(layer);
             }
 
             // 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);
@@ -851,7 +943,7 @@ namespace Unity.Netcode.Components
                     m_ClientSendList.AddRange(NetworkManager.ConnectedClientsIds);
                     m_ClientSendList.Remove(NetworkManager.LocalClientId);
                     m_ClientRpcParams.Send.TargetClientIds = m_ClientSendList;
-                    SendAnimStateClientRpc(m_AnimationMessage);
+                    SendAnimStateClientRpc(m_AnimationMessage, m_ClientRpcParams);
                 }
             }
         }
@@ -864,20 +956,33 @@ namespace Unity.Netcode.Components
             {
                 Parameters = m_ParameterWriter.ToArray()
             };
-
-            if (!IsServer)
+            if (NetworkManager.DistributedAuthorityMode)
             {
-                SendParametersUpdateServerRpc(parametersMessage);
-            }
-            else
-            {
-                if (sendDirect)
+                if (IsOwner)
                 {
-                    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);
+                    }
                 }
             }
         }
@@ -885,7 +990,7 @@ namespace Unity.Netcode.Components
         /// <summary>
         /// Helper function to get the cached value
         /// </summary>
-        unsafe private T GetValue<T>(ref AnimatorParamCache animatorParamCache)
+        private unsafe T GetValue<T>(ref AnimatorParamCache animatorParamCache)
         {
             T currentValue;
             fixed (void* value = animatorParamCache.Value)
@@ -900,12 +1005,20 @@ namespace Unity.Netcode.Components
         /// If so, it fills out m_ParametersToUpdate with the indices of the parameters
         /// that have changed.  Returns true if any parameters changed.
         /// </summary>
-        unsafe private bool CheckParametersChanged()
+        private unsafe bool CheckParametersChanged()
         {
             m_ParametersToUpdate.Clear();
             for (int i = 0; i < m_CachedAnimatorParameters.Length; i++)
             {
                 ref var cacheValue = ref UnsafeUtility.ArrayElementAsRef<AnimatorParamCache>(m_CachedAnimatorParameters.GetUnsafePtr(), i);
+
+                // If a parameter gets controlled by a curve during runtime after initialization of NetworkAnimator
+                // then ignore changes to this parameter. We are not removing the parameter in the event that
+                // it no longer is controlled by a curve.
+                if (m_Animator.IsParameterControlledByCurve(cacheValue.Hash))
+                {
+                    continue;
+                }
                 var hash = cacheValue.Hash;
                 if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterInt)
                 {
@@ -941,52 +1054,6 @@ namespace Unity.Netcode.Components
             return m_ParametersToUpdate.Count > 0;
         }
 
-        /// <summary>
-        /// Checks if any of the Animator's states have changed
-        /// </summary>
-        private bool CheckAnimStateChanged(out int stateHash, out float normalizedTime, int layer)
-        {
-            stateHash = 0;
-            normalizedTime = 0;
-
-            float layerWeightNow = m_Animator.GetLayerWeight(layer);
-            if (layerWeightNow != m_LayerWeights[layer])
-            {
-                m_LayerWeights[layer] = layerWeightNow;
-                return true;
-            }
-
-            if (m_Animator.IsInTransition(layer))
-            {
-                AnimatorTransitionInfo tt = m_Animator.GetAnimatorTransitionInfo(layer);
-                if (tt.fullPathHash != m_TransitionHash[layer])
-                {
-                    // first time in this transition for this layer
-                    m_TransitionHash[layer] = tt.fullPathHash;
-                    m_AnimationHash[layer] = 0;
-                    return true;
-                }
-            }
-            else
-            {
-                AnimatorStateInfo st = m_Animator.GetCurrentAnimatorStateInfo(layer);
-                if (st.fullPathHash != m_AnimationHash[layer])
-                {
-                    // first time in this animation state
-                    if (m_AnimationHash[layer] != 0)
-                    {
-                        // came from another animation directly - from Play()
-                        stateHash = st.fullPathHash;
-                        normalizedTime = st.normalizedTime;
-                    }
-                    m_TransitionHash[layer] = 0;
-                    m_AnimationHash[layer] = st.fullPathHash;
-                    return true;
-                }
-            }
-            return false;
-        }
-
         /// <summary>
         /// Writes all of the Animator's parameters
         /// This uses the m_ParametersToUpdate list to write out only
@@ -1022,8 +1089,7 @@ namespace Unity.Netcode.Components
                         BytePacker.WriteValuePacked(writer, valueBool);
                     }
                 }
-                else
-                if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterFloat)
+                else if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterFloat)
                 {
                     var valueFloat = m_Animator.GetFloat(hash);
                     fixed (void* value = cacheValue.Value)
@@ -1106,18 +1172,19 @@ namespace Unity.Netcode.Components
                 if (m_LayerWeights[animationState.Layer] != animationState.Weight)
                 {
                     m_Animator.SetLayerWeight(animationState.Layer, animationState.Weight);
+                    m_LayerWeights[animationState.Layer] = animationState.Weight;
                 }
             }
 
             // If there is no state transition then return
-            if (animationState.StateHash == 0)
+            if (animationState.StateHash == 0 && !animationState.Transition)
             {
                 return;
             }
 
             var currentState = m_Animator.GetCurrentAnimatorStateInfo(animationState.Layer);
             // If it is a transition, then we are synchronizing transitions in progress when a client late joins
-            if (animationState.Transition)
+            if (animationState.Transition && !animationState.CrossFade)
             {
                 // We should have all valid entries for any animation state transition update
                 // Verify the AnimationState's assigned Layer exists
@@ -1150,9 +1217,14 @@ namespace Unity.Netcode.Components
                     NetworkLog.LogError($"[DestinationState To Transition Info] Layer ({animationState.Layer}) does not exist!");
                 }
             }
+            else if (animationState.Transition && animationState.CrossFade)
+            {
+                m_Animator.CrossFade(animationState.DestinationStateHash, animationState.Duration, animationState.Layer, animationState.NormalizedTime);
+            }
             else
             {
-                if (currentState.fullPathHash != animationState.StateHash)
+                // Make sure we are not just updating the weight of a layer.
+                if (currentState.fullPathHash != animationState.StateHash && m_Animator.HasState(animationState.Layer, animationState.StateHash))
                 {
                     m_Animator.Play(animationState.StateHash, animationState.Layer, animationState.NormalizedTime);
                 }
@@ -1190,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)
@@ -1207,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())
             {
@@ -1237,36 +1318,45 @@ namespace Unity.Netcode.Components
             }
         }
 
-        internal void HandleAnimStateUpdate(ref AnimationMessage animationMessage)
+        /// <summary>
+        /// Client-Server: Internally-called RPC client-side receiving function to update animation states
+        /// </summary>
+        [ClientRpc]
+        internal void SendAnimStateClientRpc(AnimationMessage animationMessage, ClientRpcParams clientRpcParams = default)
         {
-            var isServerAuthoritative = IsServerAuthoritative();
-            if (!isServerAuthoritative && !IsOwner || isServerAuthoritative)
-            {
-                foreach (var animationState in animationMessage.AnimationStates)
-                {
-                    UpdateAnimationState(animationState);
-                }
-            }
+            ProcessAnimStates(animationMessage);
         }
 
         /// <summary>
-        /// Internally-called RPC client receiving function to update some animation state on a client
+        /// Distributed Authority: Internally-called RPC non-authority receiving function to update animation states
         /// </summary>
-        [ClientRpc]
-        private unsafe void SendAnimStateClientRpc(AnimationMessage animationMessage, ClientRpcParams clientRpcParams = default)
+        [Rpc(SendTo.NotAuthority)]
+        internal void SendAnimStateRpc(AnimationMessage animationMessage)
         {
-            // This should never happen
-            if (IsHost)
+            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;
             }
-            HandleAnimStateUpdate(ref animationMessage);
+
+            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
@@ -1274,44 +1364,31 @@ namespace Unity.Netcode.Components
         [ServerRpc]
         internal void SendAnimTriggerServerRpc(AnimationTriggerMessage animationTriggerMessage, ServerRpcParams serverRpcParams = default)
         {
-            // If it is server authoritative
+            // Ignore if a non-owner sent this.
+            if (serverRpcParams.Receive.SenderClientId != OwnerClientId)
+            {
+                if (NetworkManager.LogLevel == LogLevel.Developer)
+                {
+                    NetworkLog.LogWarning($"[Owner Authoritative] Detected the a non-authoritative client is sending the server animation trigger updates. If you recently changed ownership of the {name} object, then this could be the reason.");
+                }
+                return;
+            }
+
+            // set the trigger locally on the server
+            InternalSetTrigger(animationTriggerMessage.Hash, animationTriggerMessage.IsTriggerSet);
+
+            m_ClientSendList.Clear();
+            m_ClientSendList.AddRange(NetworkManager.ConnectedClientsIds);
+            m_ClientSendList.Remove(NetworkManager.ServerClientId);
+
             if (IsServerAuthoritative())
             {
-                // The only condition where this should (be allowed to) happen is when the owner sends the server a trigger message
-                if (OwnerClientId == serverRpcParams.Receive.SenderClientId)
-                {
-                    m_NetworkAnimatorStateChangeHandler.QueueTriggerUpdateToClient(animationTriggerMessage);
-                }
-                else if (NetworkManager.LogLevel == LogLevel.Developer)
-                {
-                    NetworkLog.LogWarning($"[Server Authoritative] Detected the a non-authoritative client is sending the server animation trigger updates. If you recently changed ownership of the {name} object, then this could be the reason.");
-                }
+                m_NetworkAnimatorStateChangeHandler.QueueTriggerUpdateToClient(animationTriggerMessage, m_ClientRpcParams);
             }
-            else
+            else if (NetworkManager.ConnectedClientsIds.Count > (IsHost ? 2 : 1))
             {
-                // Ignore if a non-owner sent this.
-                if (serverRpcParams.Receive.SenderClientId != OwnerClientId)
-                {
-                    if (NetworkManager.LogLevel == LogLevel.Developer)
-                    {
-                        NetworkLog.LogWarning($"[Owner Authoritative] Detected the a non-authoritative client is sending the server animation trigger updates. If you recently changed ownership of the {name} object, then this could be the reason.");
-                    }
-                    return;
-                }
-
-                // set the trigger locally on the server
-                InternalSetTrigger(animationTriggerMessage.Hash, animationTriggerMessage.IsTriggerSet);
-
-                // send the message to all non-authority clients excluding the server and the owner
-                if (NetworkManager.ConnectedClientsIds.Count > (IsHost ? 2 : 1))
-                {
-                    m_ClientSendList.Clear();
-                    m_ClientSendList.AddRange(NetworkManager.ConnectedClientsIds);
-                    m_ClientSendList.Remove(serverRpcParams.Receive.SenderClientId);
-                    m_ClientSendList.Remove(NetworkManager.ServerClientId);
-                    m_ClientRpcParams.Send.TargetClientIds = m_ClientSendList;
-                    m_NetworkAnimatorStateChangeHandler.QueueTriggerUpdateToClient(animationTriggerMessage, m_ClientRpcParams);
-                }
+                m_ClientSendList.Remove(serverRpcParams.Receive.SenderClientId);
+                m_NetworkAnimatorStateChangeHandler.QueueTriggerUpdateToClient(animationTriggerMessage, m_ClientRpcParams);
             }
         }
 
@@ -1324,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>
@@ -1349,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

@@ -0,0 +1,217 @@
+using System.Runtime.CompilerServices;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+    /// <summary>
+    /// Used to synchromnize delta position when half float precision is enabled
+    /// </summary>
+    public struct NetworkDeltaPosition : INetworkSerializable
+    {
+        internal const float MaxDeltaBeforeAdjustment = 64f;
+
+        /// <summary>
+        /// The HalfVector3 used to synchronize the delta in position
+        /// </summary>
+        public HalfVector3 HalfVector3;
+
+        internal Vector3 CurrentBasePosition;
+        internal Vector3 PrecisionLossDelta;
+        internal Vector3 HalfDeltaConvertedBack;
+        internal Vector3 PreviousPosition;
+        internal Vector3 DeltaPosition;
+        internal int NetworkTick;
+
+        internal bool SynchronizeBase;
+
+        internal bool CollapsedDeltaIntoBase;
+
+        /// <summary>
+        /// The serialization implementation of <see cref="INetworkSerializable"/>
+        /// </summary>
+        public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
+        {
+            HalfVector3.NetworkSerialize(serializer);
+            if (SynchronizeBase)
+            {
+                serializer.SerializeValue(ref CurrentBasePosition);
+            }
+        }
+
+        /// <summary>
+        /// Gets the full precision value of Vector3 position while also potentially updating the current base position.
+        /// </summary>
+        /// <param name="networkTick">Use the current network tick value.</param>
+        /// <returns>The full position as a <see cref="Vector3"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 ToVector3(int networkTick)
+        {
+            // When synchronizing, it is possible to have a state update arrive
+            // for the same synchronization network tick.  Under this scenario,
+            // we only want to return the existing CurrentBasePosition + DeltaPosition
+            // values and not process the X, Y, or Z values.
+            // (See the constructors below)
+            if (networkTick == NetworkTick)
+            {
+                return CurrentBasePosition + DeltaPosition;
+            }
+            for (int i = 0; i < HalfVector3.Length; i++)
+            {
+                if (HalfVector3.AxisToSynchronize[i])
+                {
+                    DeltaPosition[i] = Mathf.HalfToFloat(HalfVector3.Axis[i].value);
+                    // If we exceed or are equal to the maximum delta value then we need to
+                    // apply the delta to the CurrentBasePosition value and reset the delta
+                    // position for the axis.
+                    if (Mathf.Abs(DeltaPosition[i]) >= MaxDeltaBeforeAdjustment)
+                    {
+                        CurrentBasePosition[i] += DeltaPosition[i];
+                        DeltaPosition[i] = 0.0f;
+                        HalfVector3.Axis[i] = half.zero;
+                    }
+                }
+            }
+            return CurrentBasePosition + DeltaPosition;
+        }
+
+        /// <summary>
+        /// Returns the current base position (excluding the delta position offset).
+        /// </summary>
+        /// <returns>The current base position as a <see cref="Vector3"/></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 GetCurrentBasePosition()
+        {
+            return CurrentBasePosition;
+        }
+
+        /// <summary>
+        /// Returns the full position which includes the delta offset position.
+        /// </summary>
+        /// <returns>The full position as a <see cref="Vector3"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 GetFullPosition()
+        {
+            return CurrentBasePosition + DeltaPosition;
+        }
+
+        /// <summary>
+        /// The half float vector3 version of the current delta position.
+        /// </summary>
+        /// <remarks>
+        /// Only applies to the authoritative side for <see cref="NetworkTransform"/> instances.
+        /// </remarks>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 GetConvertedDelta()
+        {
+            return HalfDeltaConvertedBack;
+        }
+
+        /// <summary>
+        /// The full precision current delta position.
+        /// </summary>
+        /// <remarks>
+        /// Authoritative: Will have no precision loss
+        /// Non-Authoritative: Has the current network tick's loss of precision.
+        /// Precision loss adjustments are one network tick behind on the
+        /// non-authoritative side.
+        /// </remarks>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 GetDeltaPosition()
+        {
+            return DeltaPosition;
+        }
+
+        /// <summary>
+        /// Updates the position delta based off of the current base position.
+        /// </summary>
+        /// <param name="vector3">The full precision <see cref="Vector3"/> value to (converted to half floats) used to determine the delta offset positon.</param>
+        /// <param name="networkTick">Set the current network tick value when updating.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UpdateFrom(ref Vector3 vector3, int networkTick)
+        {
+            CollapsedDeltaIntoBase = false;
+            NetworkTick = networkTick;
+            DeltaPosition = (vector3 + PrecisionLossDelta) - CurrentBasePosition;
+            for (int i = 0; i < HalfVector3.Length; i++)
+            {
+                if (HalfVector3.AxisToSynchronize[i])
+                {
+                    HalfVector3.Axis[i] = math.half(DeltaPosition[i]);
+                    HalfDeltaConvertedBack[i] = Mathf.HalfToFloat(HalfVector3.Axis[i].value);
+                    PrecisionLossDelta[i] = DeltaPosition[i] - HalfDeltaConvertedBack[i];
+                    if (Mathf.Abs(HalfDeltaConvertedBack[i]) >= MaxDeltaBeforeAdjustment)
+                    {
+                        CurrentBasePosition[i] += HalfDeltaConvertedBack[i];
+                        HalfDeltaConvertedBack[i] = 0.0f;
+                        DeltaPosition[i] = 0.0f;
+                        CollapsedDeltaIntoBase = true;
+                    }
+                }
+            }
+
+            for (int i = 0; i < HalfVector3.Length; i++)
+            {
+                if (HalfVector3.AxisToSynchronize[i])
+                {
+                    PreviousPosition[i] = vector3[i];
+                }
+            }
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="vector3">The initial axial values (converted to half floats) when instantiated.</param>
+        /// <param name="networkTick">Set the network tick value to the current network tick when instantiating.</param>
+        /// <param name="axisToSynchronize">The axis to be synchronized.</param>
+        public NetworkDeltaPosition(Vector3 vector3, int networkTick, bool3 axisToSynchronize)
+        {
+            NetworkTick = networkTick;
+            CurrentBasePosition = vector3;
+            PreviousPosition = vector3;
+            PrecisionLossDelta = Vector3.zero;
+            DeltaPosition = Vector3.zero;
+            HalfDeltaConvertedBack = Vector3.zero;
+            HalfVector3 = new HalfVector3(vector3, axisToSynchronize);
+            SynchronizeBase = false;
+            CollapsedDeltaIntoBase = false;
+            UpdateFrom(ref vector3, networkTick);
+        }
+
+        /// <summary>
+        /// Constructor that defaults to all axis being synchronized.
+        /// </summary>
+        /// <param name="vector3">The initial axial values (converted to half floats) when instantiated.</param>
+        /// <param name="networkTick">Set the network tick value to the current network tick when instantiating.</param>
+        public NetworkDeltaPosition(Vector3 vector3, int networkTick) : this(vector3, networkTick, math.bool3(true))
+        {
+
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="x">The initial x axis (converted to half float) value when instantiated.</param>
+        /// <param name="y">The initial y axis (converted to half float) value when instantiated.</param>
+        /// <param name="z">The initial z axis (converted to half float) value when instantiated.</param>
+        /// <param name="networkTick">Set the network tick value to the current network tick when instantiating.</param>
+        /// <param name="axisToSynchronize">The axis to be synchronized.</param>
+        public NetworkDeltaPosition(float x, float y, float z, int networkTick, bool3 axisToSynchronize) :
+            this(new Vector3(x, y, z), networkTick, axisToSynchronize)
+        {
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="x">The initial x axis (converted to half float) value when instantiated.</param>
+        /// <param name="y">The initial y axis (converted to half float) value when instantiated.</param>
+        /// <param name="z">The initial z axis (converted to half float) value when instantiated.</param>
+        /// <param name="networkTick">Set the network tick value to the current network tick when instantiating.</param>
+        public NetworkDeltaPosition(float x, float y, float z, int networkTick) :
+            this(new Vector3(x, y, z), networkTick, math.bool3(true))
+        {
+        }
+    }
+}

Components/NetworkDeltaPosition.cs.meta

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

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

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

Components/NetworkRigidbody.cs

@@ -7,96 +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>
-        /// 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()
+        protected virtual void Awake()
         {
-            m_NetworkTransform = GetComponent<NetworkTransform>();
-            m_IsServerAuthoritative = m_NetworkTransform.IsServerAuthoritative();
-
-            m_Rigidbody = GetComponent<Rigidbody>();
-            m_OriginalInterpolation = m_Rigidbody.interpolation;
-
-            // Set interpolation to none if NetworkTransform is handling interpolation, otherwise it sets it to the original value
-            m_Rigidbody.interpolation = m_NetworkTransform.Interpolate ? RigidbodyInterpolation.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 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;
+            Initialize(RigidbodyTypes.Rigidbody);
         }
     }
 }

Components/NetworkRigidbody2D.cs

@@ -7,76 +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
     {
-        private Rigidbody2D m_Rigidbody;
-        private NetworkTransform m_NetworkTransform;
-
-        private bool m_OriginalKinematic;
-        private RigidbodyInterpolation2D m_OriginalInterpolation;
-
-        // Used to cache the authority state of this rigidbody during the last frame
-        private bool m_IsAuthority;
-
-        /// <summary>
-        /// Gets a bool value indicating whether this <see cref="NetworkRigidbody2D"/> on this peer currently holds authority.
-        /// </summary>
-        private bool HasAuthority => m_NetworkTransform.CanCommitToTransform;
-
-        private void Awake()
+        protected virtual void Awake()
         {
-            m_Rigidbody = GetComponent<Rigidbody2D>();
-            m_NetworkTransform = GetComponent<NetworkTransform>();
-        }
-
-        private void FixedUpdate()
-        {
-            if (IsSpawned)
-            {
-                if (HasAuthority != m_IsAuthority)
-                {
-                    m_IsAuthority = HasAuthority;
-                    UpdateRigidbodyKinematicMode();
-                }
-            }
-        }
-
-        // Puts the rigidbody in a kinematic non-interpolated mode on everyone but the server.
-        private void UpdateRigidbodyKinematicMode()
-        {
-            if (m_IsAuthority == false)
-            {
-                m_OriginalKinematic = m_Rigidbody.isKinematic;
-                m_Rigidbody.isKinematic = true;
-
-                m_OriginalInterpolation = m_Rigidbody.interpolation;
-                // Set interpolation to none, the NetworkTransform component interpolates the position of the object.
-                m_Rigidbody.interpolation = RigidbodyInterpolation2D.None;
-            }
-            else
-            {
-                // Resets the rigidbody back to it's non replication only state. Happens on shutdown and when authority is lost
-                m_Rigidbody.isKinematic = m_OriginalKinematic;
-                m_Rigidbody.interpolation = m_OriginalInterpolation;
-            }
-        }
-
-        /// <inheritdoc />
-        public override void OnNetworkSpawn()
-        {
-            m_IsAuthority = HasAuthority;
-            m_OriginalKinematic = m_Rigidbody.isKinematic;
-            m_OriginalInterpolation = m_Rigidbody.interpolation;
-            UpdateRigidbodyKinematicMode();
-        }
-
-        /// <inheritdoc />
-        public override void OnNetworkDespawn()
-        {
-            UpdateRigidbodyKinematicMode();
+            Initialize(RigidbodyTypes.Rigidbody2D);
         }
     }
 }

Components/QuaternionCompressor.cs

@@ -0,0 +1,123 @@
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// A Smallest Three Quaternion Compressor Implementation
+    /// </summary>
+    /// <remarks>
+    /// Explanation of why "The smallest three":
+    /// Since a normalized Quaternion's unit value is 1.0f:
+    /// x*x + y*y + z*z + w*w = M*M (where M is the magnitude of the vector)
+    /// If w was the largest value and the quaternion is normalized:
+    /// M = 1.0f (which M * M would still yield 1.0f)
+    /// w*w = M*M - (x*x + y*y + z*z) or Mathf.Sqrt(1.0f - (x*x + y*y + z*z))
+    /// w = Math.Sqrt(1.0f - (x*x + y*y + z*z))
+    /// Using the largest the number avoids potential loss of precision in the smallest three values.
+    /// </remarks>
+    public static class QuaternionCompressor
+    {
+        private const ushort k_PrecisionMask = (1 << 9) - 1;
+
+        // Square root of 2 over 2 (Mathf.Sqrt(2.0f) / 2.0f == 1.0f / Mathf.Sqrt(2.0f))
+        // This provides encoding the smallest three components into a (+/-) Mathf.Sqrt(2.0f) / 2.0f range
+        private const float k_SqrtTwoOverTwoEncoding = 0.70710678118654752440084436210485f;
+
+        // We can further improve the encoding compression by dividing k_SqrtTwoOverTwo into 1.0f and multiplying that
+        // by the precision mask (minor reduction of runtime calculations)
+        private const float k_CompressionEcodingMask = (1.0f / k_SqrtTwoOverTwoEncoding) * k_PrecisionMask;
+
+        // Used to shift the negative bit to the 10th bit position when compressing and encoding
+        private const ushort k_ShiftNegativeBit = 9;
+
+        // We can do the same for our decoding and decompression by dividing k_PrecisionMask into 1.0 and multiplying
+        // that by k_SqrtTwoOverTwo (minor reduction of runtime calculations)
+        private const float k_DcompressionDecodingMask = (1.0f / k_PrecisionMask) * k_SqrtTwoOverTwoEncoding;
+
+        // The sign bit position (10th bit) used when decompressing and decoding
+        private const ushort k_NegShortBit = 0x200;
+
+        // Negative bit set values
+        private const ushort k_True = 1;
+        private const ushort k_False = 0;
+
+        // Used to store the absolute value of the 4 quaternion elements
+        private static Quaternion s_QuatAbsValues = Quaternion.identity;
+
+        /// <summary>
+        /// Compresses a Quaternion into an unsigned integer
+        /// </summary>
+        /// <param name="quaternion">the <see cref="Quaternion"/> to be compressed</param>
+        /// <returns>the <see cref="Quaternion"/> compressed as an unsigned integer</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint CompressQuaternion(ref Quaternion quaternion)
+        {
+            // Store off the absolute value for each Quaternion element
+            s_QuatAbsValues[0] = Mathf.Abs(quaternion[0]);
+            s_QuatAbsValues[1] = Mathf.Abs(quaternion[1]);
+            s_QuatAbsValues[2] = Mathf.Abs(quaternion[2]);
+            s_QuatAbsValues[3] = Mathf.Abs(quaternion[3]);
+
+            // Get the largest element value of the quaternion to know what the remaining "Smallest Three" values are
+            var quatMax = Mathf.Max(s_QuatAbsValues[0], s_QuatAbsValues[1], s_QuatAbsValues[2], s_QuatAbsValues[3]);
+
+            // Find the index of the largest element so we can skip that element while compressing and decompressing
+            var indexToSkip = (ushort)(s_QuatAbsValues[0] == quatMax ? 0 : s_QuatAbsValues[1] == quatMax ? 1 : s_QuatAbsValues[2] == quatMax ? 2 : 3);
+
+            // Get the sign of the largest element which is all that is needed when calculating the sum of squares of a normalized quaternion.
+
+            var quatMaxSign = (quaternion[indexToSkip] < 0 ? k_True : k_False);
+
+            // Start with the index to skip which will be shifted to the highest two bits
+            var compressed = (uint)indexToSkip;
+
+            // Step 1: Start with the first element
+            var currentIndex = 0;
+
+            // Step 2: If we are on the index to skip preserve the current compressed value, otherwise proceed to step 3 and 4
+            // Step 3: Get the sign of the element we are processing. If it is the not the same as the largest value's sign bit then we set the bit
+            // Step 4: Get the compressed and encoded value by multiplying the absolute value of the current element by k_CompressionEcodingMask and round that result up
+            compressed = currentIndex != indexToSkip ? (compressed << 10) | (uint)((quaternion[currentIndex] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * s_QuatAbsValues[currentIndex]) : compressed;
+            currentIndex++;
+            // Repeat the last 3 steps for the remaining elements
+            compressed = currentIndex != indexToSkip ? (compressed << 10) | (uint)((quaternion[currentIndex] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * s_QuatAbsValues[currentIndex]) : compressed;
+            currentIndex++;
+            compressed = currentIndex != indexToSkip ? (compressed << 10) | (uint)((quaternion[currentIndex] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * s_QuatAbsValues[currentIndex]) : compressed;
+            currentIndex++;
+            compressed = currentIndex != indexToSkip ? (compressed << 10) | (uint)((quaternion[currentIndex] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * s_QuatAbsValues[currentIndex]) : compressed;
+
+            // Return the compress quaternion
+            return compressed;
+        }
+
+        /// <summary>
+        /// Decompress a compressed quaternion
+        /// </summary>
+        /// <param name="quaternion">quaternion to store the decompressed values within</param>
+        /// <param name="compressed">the compressed quaternion</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void DecompressQuaternion(ref Quaternion quaternion, uint compressed)
+        {
+            // Get the last two bits for the index to skip (0-3)
+            var indexToSkip = (int)(compressed >> 30);
+
+            // Reverse out the values while skipping over the largest value index
+            var sumOfSquaredMagnitudes = 0.0f;
+            for (int i = 3; i >= 0; --i)
+            {
+                if (i == indexToSkip)
+                {
+                    continue;
+                }
+                // Check the negative bit and multiply that result with the decompressed and decoded value
+                quaternion[i] = ((compressed & k_NegShortBit) > 0 ? -1.0f : 1.0f) * ((compressed & k_PrecisionMask) * k_DcompressionDecodingMask);
+                sumOfSquaredMagnitudes += quaternion[i] * quaternion[i];
+                compressed = compressed >> 10;
+            }
+            // Since a normalized quaternion's magnitude is 1.0f, we subtract the sum of the squared smallest three from the unit value and take
+            // the square root of the difference to find the final largest value
+            quaternion[indexToSkip] = Mathf.Sqrt(1.0f - sumOfSquaredMagnitudes);
+        }
+    }
+}

Components/QuaternionCompressor.cs.meta

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

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

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

Components/com.unity.netcode.components.asmdef

@@ -3,7 +3,8 @@
     "rootNamespace": "Unity.Netcode.Components",
     "references": [
         "Unity.Netcode.Runtime",
-        "Unity.Collections"
+        "Unity.Collections",
+        "Unity.Mathematics"
     ],
     "allowUnsafeCode": true,
     "versionDefines": [

Documentation~/index.md

@@ -7,16 +7,16 @@ Netcode for GameObjects is a Unity package that provides networking capabilities
 See guides below to install Unity Netcode for GameObjects, set up your project, and get started with your first networked game:
 
 - [Documentation](https://docs-multiplayer.unity3d.com/netcode/current/about)
-- [Installation](https://docs-multiplayer.unity3d.com/netcode/current/migration/install)
-- [First Steps](https://docs-multiplayer.unity3d.com/netcode/current/tutorials/helloworld/helloworldintro)
-- [API Reference](https://docs-multiplayer.unity3d.com/netcode/current/api/introduction)
+- [Installation](https://docs-multiplayer.unity3d.com/netcode/current/installation)
+- [First Steps](https://docs-multiplayer.unity3d.com/netcode/current/tutorials/get-started-ngo)
+- [API Reference](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@1.6/api/index.html)
 
 # Technical details
 
 ## Requirements
 
 Netcode for GameObjects targets the following Unity versions:
-- Unity 2020.3, 2021.1, 2021.2 and 2021.3
+- Unity 2021.3 (LTS), 2022.3 (LTS) and 2023.2
 
 On the following runtime platforms:
 - Windows, MacOS, and Linux
@@ -32,4 +32,4 @@ On the following runtime platforms:
 |June 3, 2021|Update document to acknowledge Unity min version change. Matches package version 0.2.0|
 |August 5, 2021|Update product/package name|
 |September 9,2021|Updated the links and name of the file.|
-|April 20, 2022|Updated links|
+|April 20, 2022|Updated links|

Editor/CodeGen/CodeGenHelpers.cs

@@ -10,6 +10,7 @@ using Unity.Collections;
 using Unity.CompilationPipeline.Common.Diagnostics;
 using Unity.CompilationPipeline.Common.ILPostProcessing;
 using UnityEngine;
+using Object = System.Object;
 
 namespace Unity.Netcode.Editor.CodeGen
 {
@@ -20,13 +21,16 @@ namespace Unity.Netcode.Editor.CodeGen
         public const string NetcodeModuleName = "Unity.Netcode.Runtime.dll";
 
         public const string RuntimeAssemblyName = "Unity.Netcode.Runtime";
+        public const string ComponentsAssemblyName = "Unity.Netcode.Components";
 
         public static readonly string NetworkBehaviour_FullName = typeof(NetworkBehaviour).FullName;
         public static readonly string INetworkMessage_FullName = typeof(INetworkMessage).FullName;
         public static readonly string ServerRpcAttribute_FullName = typeof(ServerRpcAttribute).FullName;
         public static readonly string ClientRpcAttribute_FullName = typeof(ClientRpcAttribute).FullName;
+        public static readonly string RpcAttribute_FullName = typeof(RpcAttribute).FullName;
         public static readonly string ServerRpcParams_FullName = typeof(ServerRpcParams).FullName;
         public static readonly string ClientRpcParams_FullName = typeof(ClientRpcParams).FullName;
+        public static readonly string RpcParams_FullName = typeof(RpcParams).FullName;
         public static readonly string ClientRpcSendParams_FullName = typeof(ClientRpcSendParams).FullName;
         public static readonly string ClientRpcReceiveParams_FullName = typeof(ClientRpcReceiveParams).FullName;
         public static readonly string ServerRpcSendParams_FullName = typeof(ServerRpcSendParams).FullName;
@@ -58,7 +62,7 @@ namespace Unity.Netcode.Editor.CodeGen
 
         public static bool IsSubclassOf(this TypeDefinition typeDefinition, string classTypeFullName)
         {
-            if (!typeDefinition.IsClass)
+            if (typeDefinition == null || !typeDefinition.IsClass)
             {
                 return false;
             }
@@ -112,6 +116,64 @@ namespace Unity.Netcode.Editor.CodeGen
 
             return name;
         }
+        public static TypeReference MakeGenericType(this TypeReference self, params TypeReference[] arguments)
+        {
+            if (self.GenericParameters.Count != arguments.Length)
+            {
+                throw new ArgumentException();
+            }
+
+            var instance = new GenericInstanceType(self);
+            foreach (var argument in arguments)
+            {
+                instance.GenericArguments.Add(argument);
+            }
+
+            return instance;
+        }
+
+        public static MethodReference MakeGeneric(this MethodReference self, params TypeReference[] arguments)
+        {
+            var reference = new MethodReference(self.Name, self.ReturnType)
+            {
+                DeclaringType = self.DeclaringType.MakeGenericType(arguments),
+                HasThis = self.HasThis,
+                ExplicitThis = self.ExplicitThis,
+                CallingConvention = self.CallingConvention,
+            };
+
+            foreach (var parameter in self.Parameters)
+            {
+                reference.Parameters.Add(new ParameterDefinition(parameter.ParameterType));
+            }
+
+            foreach (var generic_parameter in self.GenericParameters)
+            {
+                reference.GenericParameters.Add(new GenericParameter(generic_parameter.Name, reference));
+            }
+
+            return reference;
+        }
+
+        public static bool IsSubclassOf(this TypeReference typeReference, TypeReference baseClass)
+        {
+            if (typeReference == null)
+            {
+                return false;
+            }
+            var type = typeReference.Resolve();
+            if (type?.BaseType == null || type.BaseType.Name == nameof(Object))
+            {
+                return false;
+            }
+
+            if (type.BaseType.Resolve() == baseClass.Resolve())
+            {
+                return true;
+            }
+
+            return type.BaseType.IsSubclassOf(baseClass);
+        }
 
         public static bool HasInterface(this TypeReference typeReference, string interfaceTypeFullName)
         {

Editor/CodeGen/INetworkMessageILPP.cs

@@ -1,12 +1,13 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Collections.Generic;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using Mono.Cecil.Rocks;
 using Unity.CompilationPipeline.Common.Diagnostics;
 using Unity.CompilationPipeline.Common.ILPostProcessing;
+using UnityEngine;
 using ILPPInterface = Unity.CompilationPipeline.Common.ILPostProcessing.ILPostProcessor;
 using MethodAttributes = Mono.Cecil.MethodAttributes;
 
@@ -16,7 +17,7 @@ namespace Unity.Netcode.Editor.CodeGen
     {
         public override ILPPInterface GetInstance() => this;
 
-        public override bool WillProcess(ICompiledAssembly compiledAssembly) => compiledAssembly.Name == CodeGenHelpers.RuntimeAssemblyName;
+        public override bool WillProcess(ICompiledAssembly compiledAssembly) => compiledAssembly.Name == CodeGenHelpers.RuntimeAssemblyName || compiledAssembly.Name == CodeGenHelpers.ComponentsAssemblyName;
 
         private readonly List<DiagnosticMessage> m_Diagnostics = new List<DiagnosticMessage>();
 
@@ -101,54 +102,54 @@ namespace Unity.Netcode.Editor.CodeGen
         private ModuleDefinition m_NetcodeModule;
         private PostProcessorAssemblyResolver m_AssemblyResolver;
 
-        private MethodReference m_MessagingSystem_ReceiveMessage_MethodRef;
-        private MethodReference m_MessagingSystem_CreateMessageAndGetVersion_MethodRef;
-        private TypeReference m_MessagingSystem_MessageWithHandler_TypeRef;
-        private MethodReference m_MessagingSystem_MessageHandler_Constructor_TypeRef;
-        private MethodReference m_MessagingSystem_VersionGetter_Constructor_TypeRef;
+        private MethodReference m_RuntimeInitializeOnLoadAttribute_Ctor;
+
+        private MethodReference m_MessageManager_ReceiveMessage_MethodRef;
+        private MethodReference m_MessageManager_CreateMessageAndGetVersion_MethodRef;
+        private TypeReference m_MessageManager_MessageWithHandler_TypeRef;
+        private MethodReference m_MessageManager_MessageHandler_Constructor_TypeRef;
+        private MethodReference m_MessageManager_VersionGetter_Constructor_TypeRef;
         private FieldReference m_ILPPMessageProvider___network_message_types_FieldRef;
-        private FieldReference m_MessagingSystem_MessageWithHandler_MessageType_FieldRef;
-        private FieldReference m_MessagingSystem_MessageWithHandler_Handler_FieldRef;
-        private FieldReference m_MessagingSystem_MessageWithHandler_GetVersion_FieldRef;
+        private FieldReference m_MessageManager_MessageWithHandler_MessageType_FieldRef;
+        private FieldReference m_MessageManager_MessageWithHandler_Handler_FieldRef;
+        private FieldReference m_MessageManager_MessageWithHandler_GetVersion_FieldRef;
         private MethodReference m_Type_GetTypeFromHandle_MethodRef;
         private MethodReference m_List_Add_MethodRef;
 
-        private const string k_ReceiveMessageName = nameof(MessagingSystem.ReceiveMessage);
-        private const string k_CreateMessageAndGetVersionName = nameof(MessagingSystem.CreateMessageAndGetVersion);
+        private const string k_ReceiveMessageName = nameof(NetworkMessageManager.ReceiveMessage);
+        private const string k_CreateMessageAndGetVersionName = nameof(NetworkMessageManager.CreateMessageAndGetVersion);
 
         private bool ImportReferences(ModuleDefinition moduleDefinition)
         {
             // Different environments seem to have different situations...
-            // Some have these definitions in netstandard.dll...
-            // some seem to have them elsewhere...
-            // Since they're standard .net classes they're not going to cause
-            // the same issues as referencing other assemblies, in theory, since
-            // the definitions should be standard and consistent across platforms
-            // (i.e., there's no #if UNITY_EDITOR in them that could create
-            // invalid IL code)
+            // Some have these definitions in netstandard.dll, some seem to have them elsewhere...
+            // Since they're standard .net classes they're not going to cause the same issues as referencing other assemblies,
+            // in theory, since the definitions should be standard and consistent across platforms
+            // (i.e., there's no #if UNITY_EDITOR in them that could create invalid IL code)
             TypeDefinition typeTypeDef = moduleDefinition.ImportReference(typeof(Type)).Resolve();
             TypeDefinition listTypeDef = moduleDefinition.ImportReference(typeof(List<>)).Resolve();
+            m_RuntimeInitializeOnLoadAttribute_Ctor = moduleDefinition.ImportReference(typeof(RuntimeInitializeOnLoadMethodAttribute).GetConstructor(new Type[] { }));
 
             TypeDefinition messageHandlerTypeDef = null;
             TypeDefinition versionGetterTypeDef = null;
             TypeDefinition messageWithHandlerTypeDef = null;
             TypeDefinition ilppMessageProviderTypeDef = null;
-            TypeDefinition messagingSystemTypeDef = null;
+            TypeDefinition messageManagerSystemTypeDef = null;
             foreach (var netcodeTypeDef in m_NetcodeModule.GetAllTypes())
             {
-                if (messageHandlerTypeDef == null && netcodeTypeDef.Name == nameof(MessagingSystem.MessageHandler))
+                if (messageHandlerTypeDef == null && netcodeTypeDef.Name == nameof(NetworkMessageManager.MessageHandler))
                 {
                     messageHandlerTypeDef = netcodeTypeDef;
                     continue;
                 }
 
-                if (versionGetterTypeDef == null && netcodeTypeDef.Name == nameof(MessagingSystem.VersionGetter))
+                if (versionGetterTypeDef == null && netcodeTypeDef.Name == nameof(NetworkMessageManager.VersionGetter))
                 {
                     versionGetterTypeDef = netcodeTypeDef;
                     continue;
                 }
 
-                if (messageWithHandlerTypeDef == null && netcodeTypeDef.Name == nameof(MessagingSystem.MessageWithHandler))
+                if (messageWithHandlerTypeDef == null && netcodeTypeDef.Name == nameof(NetworkMessageManager.MessageWithHandler))
                 {
                     messageWithHandlerTypeDef = netcodeTypeDef;
                     continue;
@@ -160,29 +161,29 @@ namespace Unity.Netcode.Editor.CodeGen
                     continue;
                 }
 
-                if (messagingSystemTypeDef == null && netcodeTypeDef.Name == nameof(MessagingSystem))
+                if (messageManagerSystemTypeDef == null && netcodeTypeDef.Name == nameof(NetworkMessageManager))
                 {
-                    messagingSystemTypeDef = netcodeTypeDef;
+                    messageManagerSystemTypeDef = netcodeTypeDef;
                     continue;
                 }
             }
 
-            m_MessagingSystem_MessageHandler_Constructor_TypeRef = moduleDefinition.ImportReference(messageHandlerTypeDef.GetConstructors().First());
-            m_MessagingSystem_VersionGetter_Constructor_TypeRef = moduleDefinition.ImportReference(versionGetterTypeDef.GetConstructors().First());
+            m_MessageManager_MessageHandler_Constructor_TypeRef = moduleDefinition.ImportReference(messageHandlerTypeDef.GetConstructors().First());
+            m_MessageManager_VersionGetter_Constructor_TypeRef = moduleDefinition.ImportReference(versionGetterTypeDef.GetConstructors().First());
 
-            m_MessagingSystem_MessageWithHandler_TypeRef = moduleDefinition.ImportReference(messageWithHandlerTypeDef);
+            m_MessageManager_MessageWithHandler_TypeRef = moduleDefinition.ImportReference(messageWithHandlerTypeDef);
             foreach (var fieldDef in messageWithHandlerTypeDef.Fields)
             {
                 switch (fieldDef.Name)
                 {
-                    case nameof(MessagingSystem.MessageWithHandler.MessageType):
-                        m_MessagingSystem_MessageWithHandler_MessageType_FieldRef = moduleDefinition.ImportReference(fieldDef);
+                    case nameof(NetworkMessageManager.MessageWithHandler.MessageType):
+                        m_MessageManager_MessageWithHandler_MessageType_FieldRef = moduleDefinition.ImportReference(fieldDef);
                         break;
-                    case nameof(MessagingSystem.MessageWithHandler.Handler):
-                        m_MessagingSystem_MessageWithHandler_Handler_FieldRef = moduleDefinition.ImportReference(fieldDef);
+                    case nameof(NetworkMessageManager.MessageWithHandler.Handler):
+                        m_MessageManager_MessageWithHandler_Handler_FieldRef = moduleDefinition.ImportReference(fieldDef);
                         break;
-                    case nameof(MessagingSystem.MessageWithHandler.GetVersion):
-                        m_MessagingSystem_MessageWithHandler_GetVersion_FieldRef = moduleDefinition.ImportReference(fieldDef);
+                    case nameof(NetworkMessageManager.MessageWithHandler.GetVersion):
+                        m_MessageManager_MessageWithHandler_GetVersion_FieldRef = moduleDefinition.ImportReference(fieldDef);
                         break;
                 }
             }
@@ -219,15 +220,15 @@ namespace Unity.Netcode.Editor.CodeGen
                 }
             }
 
-            foreach (var methodDef in messagingSystemTypeDef.Methods)
+            foreach (var methodDef in messageManagerSystemTypeDef.Methods)
             {
                 switch (methodDef.Name)
                 {
                     case k_ReceiveMessageName:
-                        m_MessagingSystem_ReceiveMessage_MethodRef = moduleDefinition.ImportReference(methodDef);
+                        m_MessageManager_ReceiveMessage_MethodRef = moduleDefinition.ImportReference(methodDef);
                         break;
                     case k_CreateMessageAndGetVersionName:
-                        m_MessagingSystem_CreateMessageAndGetVersion_MethodRef = moduleDefinition.ImportReference(methodDef);
+                        m_MessageManager_CreateMessageAndGetVersion_MethodRef = moduleDefinition.ImportReference(methodDef);
                         break;
                 }
             }
@@ -235,48 +236,29 @@ namespace Unity.Netcode.Editor.CodeGen
             return true;
         }
 
-        private MethodDefinition GetOrCreateStaticConstructor(TypeDefinition typeDefinition)
-        {
-            var staticCtorMethodDef = typeDefinition.GetStaticConstructor();
-            if (staticCtorMethodDef == null)
-            {
-                staticCtorMethodDef = new MethodDefinition(
-                    ".cctor", // Static Constructor (constant-constructor)
-                    MethodAttributes.HideBySig |
-                    MethodAttributes.SpecialName |
-                    MethodAttributes.RTSpecialName |
-                    MethodAttributes.Static,
-                    typeDefinition.Module.TypeSystem.Void);
-                staticCtorMethodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
-                typeDefinition.Methods.Add(staticCtorMethodDef);
-            }
-
-            return staticCtorMethodDef;
-        }
-
         private void CreateInstructionsToRegisterType(ILProcessor processor, List<Instruction> instructions, TypeReference type, MethodReference receiveMethod, MethodReference versionMethod)
         {
-            // MessagingSystem.__network_message_types.Add(new MessagingSystem.MessageWithHandler{MessageType=typeof(type), Handler=type.Receive});
-            processor.Body.Variables.Add(new VariableDefinition(m_MessagingSystem_MessageWithHandler_TypeRef));
+            // NetworkMessageManager.__network_message_types.Add(new NetworkMessageManager.MessageWithHandler{MessageType=typeof(type), Handler=type.Receive});
+            processor.Body.Variables.Add(new VariableDefinition(m_MessageManager_MessageWithHandler_TypeRef));
             int messageWithHandlerLocIdx = processor.Body.Variables.Count - 1;
 
             instructions.Add(processor.Create(OpCodes.Ldsfld, m_ILPPMessageProvider___network_message_types_FieldRef));
             instructions.Add(processor.Create(OpCodes.Ldloca, messageWithHandlerLocIdx));
-            instructions.Add(processor.Create(OpCodes.Initobj, m_MessagingSystem_MessageWithHandler_TypeRef));
+            instructions.Add(processor.Create(OpCodes.Initobj, m_MessageManager_MessageWithHandler_TypeRef));
 
             // tmp.MessageType = typeof(type);
             instructions.Add(processor.Create(OpCodes.Ldloca, messageWithHandlerLocIdx));
             instructions.Add(processor.Create(OpCodes.Ldtoken, type));
             instructions.Add(processor.Create(OpCodes.Call, m_Type_GetTypeFromHandle_MethodRef));
-            instructions.Add(processor.Create(OpCodes.Stfld, m_MessagingSystem_MessageWithHandler_MessageType_FieldRef));
+            instructions.Add(processor.Create(OpCodes.Stfld, m_MessageManager_MessageWithHandler_MessageType_FieldRef));
 
             // tmp.Handler = MessageHandler.ReceveMessage<type>
             instructions.Add(processor.Create(OpCodes.Ldloca, messageWithHandlerLocIdx));
             instructions.Add(processor.Create(OpCodes.Ldnull));
 
             instructions.Add(processor.Create(OpCodes.Ldftn, receiveMethod));
-            instructions.Add(processor.Create(OpCodes.Newobj, m_MessagingSystem_MessageHandler_Constructor_TypeRef));
-            instructions.Add(processor.Create(OpCodes.Stfld, m_MessagingSystem_MessageWithHandler_Handler_FieldRef));
+            instructions.Add(processor.Create(OpCodes.Newobj, m_MessageManager_MessageHandler_Constructor_TypeRef));
+            instructions.Add(processor.Create(OpCodes.Stfld, m_MessageManager_MessageWithHandler_Handler_FieldRef));
 
 
             // tmp.GetVersion = MessageHandler.CreateMessageAndGetVersion<type>
@@ -284,43 +266,46 @@ namespace Unity.Netcode.Editor.CodeGen
             instructions.Add(processor.Create(OpCodes.Ldnull));
 
             instructions.Add(processor.Create(OpCodes.Ldftn, versionMethod));
-            instructions.Add(processor.Create(OpCodes.Newobj, m_MessagingSystem_VersionGetter_Constructor_TypeRef));
-            instructions.Add(processor.Create(OpCodes.Stfld, m_MessagingSystem_MessageWithHandler_GetVersion_FieldRef));
+            instructions.Add(processor.Create(OpCodes.Newobj, m_MessageManager_VersionGetter_Constructor_TypeRef));
+            instructions.Add(processor.Create(OpCodes.Stfld, m_MessageManager_MessageWithHandler_GetVersion_FieldRef));
 
             // ILPPMessageProvider.__network_message_types.Add(tmp);
             instructions.Add(processor.Create(OpCodes.Ldloc, messageWithHandlerLocIdx));
             instructions.Add(processor.Create(OpCodes.Callvirt, m_List_Add_MethodRef));
         }
 
-        // Creates a static module constructor (which is executed when the module is loaded) that registers all the message types in the assembly with MessagingSystem.
+        // Creates a static module constructor (which is executed when the module is loaded) that registers all the message types in the assembly with NetworkMessageManager.
         // This is the same behavior as annotating a static method with [ModuleInitializer] in standardized C# (that attribute doesn't exist in Unity, but the static module constructor still works).
         // https://docs.microsoft.com/en-us/dotnet/api/system.runtime.compilerservices.moduleinitializerattribute?view=net-5.0
         // https://web.archive.org/web/20100212140402/http://blogs.msdn.com/junfeng/archive/2005/11/19/494914.aspx
         private void CreateModuleInitializer(AssemblyDefinition assembly, List<TypeDefinition> networkMessageTypes)
         {
-            foreach (var typeDefinition in assembly.MainModule.Types)
+            var typeDefinition = new TypeDefinition("__GEN", "INetworkMessageHelper", TypeAttributes.NotPublic | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit, assembly.MainModule.TypeSystem.Object);
+
+            var staticCtorMethodDef = new MethodDefinition(
+                $"InitializeMessages",
+                MethodAttributes.Assembly |
+                MethodAttributes.Static,
+                assembly.MainModule.TypeSystem.Void);
+            staticCtorMethodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
+            staticCtorMethodDef.CustomAttributes.Add(new CustomAttribute(m_RuntimeInitializeOnLoadAttribute_Ctor));
+            typeDefinition.Methods.Add(staticCtorMethodDef);
+
+            var instructions = new List<Instruction>();
+            var processor = staticCtorMethodDef.Body.GetILProcessor();
+
+            foreach (var type in networkMessageTypes)
             {
-                if (typeDefinition.FullName == "<Module>")
-                {
-                    var staticCtorMethodDef = GetOrCreateStaticConstructor(typeDefinition);
-
-                    var processor = staticCtorMethodDef.Body.GetILProcessor();
-
-                    var instructions = new List<Instruction>();
-
-                    foreach (var type in networkMessageTypes)
-                    {
-                        var receiveMethod = new GenericInstanceMethod(m_MessagingSystem_ReceiveMessage_MethodRef);
-                        receiveMethod.GenericArguments.Add(type);
-                        var versionMethod = new GenericInstanceMethod(m_MessagingSystem_CreateMessageAndGetVersion_MethodRef);
-                        versionMethod.GenericArguments.Add(type);
-                        CreateInstructionsToRegisterType(processor, instructions, type, receiveMethod, versionMethod);
-                    }
-
-                    instructions.ForEach(instruction => processor.Body.Instructions.Insert(processor.Body.Instructions.Count - 1, instruction));
-                    break;
-                }
+                var receiveMethod = new GenericInstanceMethod(m_MessageManager_ReceiveMessage_MethodRef);
+                receiveMethod.GenericArguments.Add(type);
+                var versionMethod = new GenericInstanceMethod(m_MessageManager_CreateMessageAndGetVersion_MethodRef);
+                versionMethod.GenericArguments.Add(type);
+                CreateInstructionsToRegisterType(processor, instructions, type, receiveMethod, versionMethod);
             }
+
+            instructions.ForEach(instruction => processor.Body.Instructions.Insert(processor.Body.Instructions.Count - 1, instruction));
+
+            assembly.MainModule.Types.Add(typeDefinition);
         }
     }
 }

Editor/CodeGen/INetworkSerializableILPP.cs

@@ -1,7 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Collections.Generic;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using Unity.CompilationPipeline.Common.Diagnostics;

Editor/CodeGen/RuntimeAccessModifiersILPP.cs

@@ -2,6 +2,7 @@ using System.Collections.Generic;
 using System.IO;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
+using Mono.Cecil.Rocks;
 using Unity.CompilationPipeline.Common.Diagnostics;
 using Unity.CompilationPipeline.Common.ILPostProcessing;
 using ILPPInterface = Unity.CompilationPipeline.Common.ILPostProcessing.ILPostProcessor;
@@ -52,7 +53,17 @@ namespace Unity.Netcode.Editor.CodeGen
                         case nameof(NetworkBehaviour):
                             ProcessNetworkBehaviour(typeDefinition);
                             break;
+                        case nameof(RpcAttribute):
+                            foreach (var methodDefinition in typeDefinition.GetConstructors())
+                            {
+                                if (methodDefinition.Parameters.Count == 0)
+                                {
+                                    methodDefinition.IsPublic = true;
+                                }
+                            }
+                            break;
                         case nameof(__RpcParams):
+                        case nameof(RpcFallbackSerialization):
                             typeDefinition.IsPublic = true;
                             break;
                     }
@@ -79,6 +90,9 @@ namespace Unity.Netcode.Editor.CodeGen
             return new ILPostProcessResult(new InMemoryAssembly(pe.ToArray(), pdb.ToArray()), m_Diagnostics);
         }
 
+        // TODO: Deprecate...
+        // This is changing accessibility for values that are no longer used, but since our validator runs
+        // after ILPP and sees those values as public, they cannot be removed until a major version change.
         private void ProcessNetworkManager(TypeDefinition typeDefinition, string[] assemblyDefines)
         {
             foreach (var fieldDefinition in typeDefinition.Fields)
@@ -98,6 +112,14 @@ namespace Unity.Netcode.Editor.CodeGen
                     fieldDefinition.IsPublic = true;
                 }
             }
+
+            foreach (var nestedTypeDefinition in typeDefinition.NestedTypes)
+            {
+                if (nestedTypeDefinition.Name == nameof(NetworkManager.RpcReceiveHandler))
+                {
+                    nestedTypeDefinition.IsNestedPublic = true;
+                }
+            }
         }
 
         private void ProcessNetworkBehaviour(TypeDefinition typeDefinition)
@@ -108,13 +130,31 @@ namespace Unity.Netcode.Editor.CodeGen
                 {
                     nestedType.IsNestedFamily = true;
                 }
+                if (nestedType.Name == nameof(NetworkBehaviour.RpcReceiveHandler))
+                {
+                    nestedType.IsNestedPublic = true;
+                }
             }
 
             foreach (var fieldDefinition in typeDefinition.Fields)
             {
-                if (fieldDefinition.Name == nameof(NetworkBehaviour.__rpc_exec_stage))
+                if (fieldDefinition.Name == nameof(NetworkBehaviour.__rpc_exec_stage) || fieldDefinition.Name == nameof(NetworkBehaviour.NetworkVariableFields))
                 {
-                    fieldDefinition.IsFamily = true;
+                    fieldDefinition.IsFamilyOrAssembly = true;
+                }
+                if (fieldDefinition.Name == nameof(NetworkBehaviour.__rpc_func_table))
+                {
+                    fieldDefinition.IsFamilyOrAssembly = true;
+                }
+
+                if (fieldDefinition.Name == nameof(NetworkBehaviour.RpcReceiveHandler))
+                {
+                    fieldDefinition.IsFamilyOrAssembly = true;
+                }
+
+                if (fieldDefinition.Name == nameof(NetworkBehaviour.__rpc_name_table))
+                {
+                    fieldDefinition.IsFamilyOrAssembly = true;
                 }
             }
 
@@ -123,10 +163,22 @@ namespace Unity.Netcode.Editor.CodeGen
                 if (methodDefinition.Name == nameof(NetworkBehaviour.__beginSendServerRpc) ||
                     methodDefinition.Name == nameof(NetworkBehaviour.__endSendServerRpc) ||
                     methodDefinition.Name == nameof(NetworkBehaviour.__beginSendClientRpc) ||
-                    methodDefinition.Name == nameof(NetworkBehaviour.__endSendClientRpc))
+                    methodDefinition.Name == nameof(NetworkBehaviour.__endSendClientRpc) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__beginSendRpc) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__endSendRpc) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__initializeVariables) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__initializeRpcs) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__registerRpc) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__nameNetworkVariable) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__createNativeList))
                 {
                     methodDefinition.IsFamily = true;
                 }
+
+                if (methodDefinition.Name == nameof(NetworkBehaviour.__getTypeName))
+                {
+                    methodDefinition.IsFamilyOrAssembly = true;
+                }
             }
         }
     }

Editor/Configuration/NetcodeForGameObjectsProjectSettings.cs

@@ -0,0 +1,30 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Netcode.Editor.Configuration
+{
+    [FilePath("ProjectSettings/NetcodeForGameObjects.asset", FilePathAttribute.Location.ProjectFolder)]
+    public class NetcodeForGameObjectsProjectSettings : ScriptableSingleton<NetcodeForGameObjectsProjectSettings>
+    {
+        internal static readonly string DefaultNetworkPrefabsPath = "Assets/DefaultNetworkPrefabs.asset";
+        [SerializeField] public string NetworkPrefabsPath = DefaultNetworkPrefabsPath;
+        public string TempNetworkPrefabsPath;
+
+        private void OnEnable()
+        {
+            if (NetworkPrefabsPath == "")
+            {
+                NetworkPrefabsPath = DefaultNetworkPrefabsPath;
+            }
+            TempNetworkPrefabsPath = NetworkPrefabsPath;
+        }
+
+        [SerializeField]
+        public bool GenerateDefaultNetworkPrefabs = true;
+
+        internal void SaveSettings()
+        {
+            Save(true);
+        }
+    }
+}

Editor/Configuration/NetcodeForGameObjectsProjectSettings.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2727d53a542a4c1aa312905c3a02d807
+timeCreated: 1685564945

Editor/Configuration/NetcodeForGameObjectsSettings.cs

@@ -1,6 +1,4 @@
 using UnityEditor;
-using UnityEngine;
-
 
 namespace Unity.Netcode.Editor.Configuration
 {
@@ -39,15 +37,4 @@ namespace Unity.Netcode.Editor.Configuration
             EditorPrefs.SetBool(AutoAddNetworkObjectIfNoneExists, autoAddSetting);
         }
     }
-
-    [FilePath("ProjectSettings/NetcodeForGameObjects.settings", FilePathAttribute.Location.ProjectFolder)]
-    internal class NetcodeForGameObjectsProjectSettings : ScriptableSingleton<NetcodeForGameObjectsProjectSettings>
-    {
-        [SerializeField] public bool GenerateDefaultNetworkPrefabs = true;
-
-        internal void SaveSettings()
-        {
-            Save(true);
-        }
-    }
 }

Editor/Configuration/NetcodeSettingsProvider.cs

@@ -1,5 +1,9 @@
+using System.Collections.Generic;
+using System.IO;
 using UnityEditor;
 using UnityEngine;
+using Directory = UnityEngine.Windows.Directory;
+using File = UnityEngine.Windows.File;
 
 namespace Unity.Netcode.Editor.Configuration
 {
@@ -15,16 +19,65 @@ 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" },
                 guiHandler = OnGuiHandler,
+                deactivateHandler = OnDeactivate
             };
 
             return provider;
         }
 
+        private static void OnDeactivate()
+        {
+            var settings = NetcodeForGameObjectsProjectSettings.instance;
+            if (settings.TempNetworkPrefabsPath != settings.NetworkPrefabsPath)
+            {
+                var newPath = settings.TempNetworkPrefabsPath;
+                if (newPath == "")
+                {
+                    newPath = NetcodeForGameObjectsProjectSettings.DefaultNetworkPrefabsPath;
+                    settings.TempNetworkPrefabsPath = newPath;
+                }
+                var oldPath = settings.NetworkPrefabsPath;
+                settings.NetworkPrefabsPath = settings.TempNetworkPrefabsPath;
+                var dirName = Path.GetDirectoryName(newPath);
+                if (!Directory.Exists(dirName))
+                {
+                    var dirs = dirName.Split(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar });
+                    var dirsQueue = new Queue<string>(dirs);
+                    var parent = dirsQueue.Dequeue();
+                    while (dirsQueue.Count != 0)
+                    {
+                        var child = dirsQueue.Dequeue();
+                        var together = Path.Combine(parent, child);
+                        if (!Directory.Exists(together))
+                        {
+                            AssetDatabase.CreateFolder(parent, child);
+                        }
+
+                        parent = together;
+                    }
+                }
+
+                if (Directory.Exists(dirName))
+                {
+                    if (File.Exists(oldPath))
+                    {
+                        AssetDatabase.MoveAsset(oldPath, newPath);
+                        if (File.Exists(oldPath))
+                        {
+                            File.Delete(oldPath);
+                        }
+                        AssetDatabase.Refresh();
+                    }
+                }
+                settings.SaveSettings();
+            }
+        }
+
 
         internal static NetcodeSettingsLabel NetworkObjectsSectionLabel;
         internal static NetcodeSettingsToggle AutoAddNetworkObjectToggle;
@@ -70,6 +123,7 @@ namespace Unity.Netcode.Editor.Configuration
             var multiplayerToolsTipStatus = NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() == 0;
             var settings = NetcodeForGameObjectsProjectSettings.instance;
             var generateDefaultPrefabs = settings.GenerateDefaultNetworkPrefabs;
+            var networkPrefabsPath = settings.TempNetworkPrefabsPath;
 
             EditorGUI.BeginChangeCheck();
 
@@ -97,6 +151,7 @@ namespace Unity.Netcode.Editor.Configuration
             {
                 GUILayout.BeginVertical("Box");
                 const string generateNetworkPrefabsString = "Generate Default Network Prefabs List";
+                const string networkPrefabsLocationString = "Default Network Prefabs List path";
 
                 if (s_MaxLabelWidth == 0)
                 {
@@ -114,6 +169,14 @@ namespace Unity.Netcode.Editor.Configuration
                         "to date with all NetworkObject prefabs."),
                     generateDefaultPrefabs,
                     GUILayout.Width(s_MaxLabelWidth + 20));
+
+                GUI.SetNextControlName("Location");
+                networkPrefabsPath = EditorGUILayout.TextField(
+                    new GUIContent(
+                        networkPrefabsLocationString,
+                        "The path to the asset the default NetworkPrefabList object should be stored in."),
+                    networkPrefabsPath,
+                    GUILayout.Width(s_MaxLabelWidth + 270));
                 GUILayout.EndVertical();
             }
             EditorGUILayout.EndFoldoutHeaderGroup();
@@ -123,6 +186,7 @@ namespace Unity.Netcode.Editor.Configuration
                 NetcodeForGameObjectsEditorSettings.SetAutoAddNetworkObjectSetting(autoAddNetworkObjectSetting);
                 NetcodeForGameObjectsEditorSettings.SetNetcodeInstallMultiplayerToolTips(multiplayerToolsTipStatus ? 0 : 1);
                 settings.GenerateDefaultNetworkPrefabs = generateDefaultPrefabs;
+                settings.TempNetworkPrefabsPath = networkPrefabsPath;
                 settings.SaveSettings();
             }
         }

Editor/Configuration/NetworkPrefabProcessor.cs

@@ -9,16 +9,15 @@ namespace Unity.Netcode.Editor.Configuration
     /// </summary>
     public class NetworkPrefabProcessor : AssetPostprocessor
     {
-        private static string s_DefaultNetworkPrefabsPath = "Assets/DefaultNetworkPrefabs.asset";
         public static string DefaultNetworkPrefabsPath
         {
             get
             {
-                return s_DefaultNetworkPrefabsPath;
+                return NetcodeForGameObjectsProjectSettings.instance.NetworkPrefabsPath;
             }
             internal set
             {
-                s_DefaultNetworkPrefabsPath = value;
+                NetcodeForGameObjectsProjectSettings.instance.NetworkPrefabsPath = value;
                 // Force a recache of the prefab list
                 s_PrefabsList = null;
             }

Editor/NetworkBehaviourEditor.cs

@@ -1,9 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
-using UnityEngine;
-using UnityEditor;
 using Unity.Netcode.Editor.Configuration;
+using UnityEditor;
+using UnityEngine;
 
 namespace Unity.Netcode.Editor
 {
@@ -37,17 +37,15 @@ namespace Unity.Netcode.Editor
             for (int i = 0; i < fields.Length; i++)
             {
                 var ft = fields[i].FieldType;
-                if (ft.IsGenericType && ft.GetGenericTypeDefinition() == typeof(NetworkVariable<>) && !fields[i].IsDefined(typeof(HideInInspector), true))
+                if (ft.IsGenericType && ft.GetGenericTypeDefinition() == typeof(NetworkVariable<>) && !fields[i].IsDefined(typeof(HideInInspector), true) && !fields[i].IsDefined(typeof(NonSerializedAttribute), true))
                 {
                     m_NetworkVariableNames.Add(ObjectNames.NicifyVariableName(fields[i].Name));
                     m_NetworkVariableFields.Add(ObjectNames.NicifyVariableName(fields[i].Name), fields[i]);
-                    Debug.Log($"Adding NetworkVariable {fields[i].Name}");
                 }
-                if (ft.IsGenericType && ft.GetGenericTypeDefinition() == typeof(NetworkList<>) && !fields[i].IsDefined(typeof(HideInInspector), true))
+                if (ft.IsGenericType && ft.GetGenericTypeDefinition() == typeof(NetworkList<>) && !fields[i].IsDefined(typeof(HideInInspector), true) && !fields[i].IsDefined(typeof(NonSerializedAttribute), true))
                 {
                     m_NetworkVariableNames.Add(ObjectNames.NicifyVariableName(fields[i].Name));
                     m_NetworkVariableFields.Add(ObjectNames.NicifyVariableName(fields[i].Name), fields[i]);
-                    Debug.Log($"Adding NetworkList {fields[i].Name}");
                 }
             }
         }
@@ -81,7 +79,25 @@ namespace Unity.Netcode.Editor
             EditorGUILayout.BeginHorizontal();
             if (genericType.IsValueType)
             {
-                var method = typeof(NetworkBehaviourEditor).GetMethod("RenderNetworkContainerValueType", BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic);
+                var isEquatable = false;
+                foreach (var iface in genericType.GetInterfaces())
+                {
+                    if (iface.IsGenericType && iface.GetGenericTypeDefinition() == typeof(IEquatable<>))
+                    {
+                        isEquatable = true;
+                    }
+                }
+
+                MethodInfo method;
+                if (isEquatable)
+                {
+                    method = typeof(NetworkBehaviourEditor).GetMethod(nameof(RenderNetworkContainerValueTypeIEquatable), BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic);
+                }
+                else
+                {
+                    method = typeof(NetworkBehaviourEditor).GetMethod(nameof(RenderNetworkContainerValueType), BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic);
+                }
+
                 var genericMethod = method.MakeGenericMethod(genericType);
                 genericMethod.Invoke(this, new[] { (object)index });
             }
@@ -94,7 +110,23 @@ namespace Unity.Netcode.Editor
             }
         }
 
-        private void RenderNetworkContainerValueType<T>(int index) where T : unmanaged, IEquatable<T>
+        private void RenderNetworkContainerValueType<T>(int index) where T : unmanaged
+        {
+            try
+            {
+                var networkVariable = (NetworkVariable<T>)m_NetworkVariableFields[m_NetworkVariableNames[index]].GetValue(target);
+                RenderNetworkVariableValueType(index, networkVariable);
+            }
+            catch (Exception e)
+            {
+                Debug.Log(e);
+                throw;
+            }
+
+            EditorGUILayout.EndHorizontal();
+        }
+
+        private void RenderNetworkContainerValueTypeIEquatable<T>(int index) where T : unmanaged, IEquatable<T>
         {
             try
             {
@@ -135,23 +167,23 @@ namespace Unity.Netcode.Editor
                 }
                 else if (type == typeof(uint))
                 {
-                    val = (uint)EditorGUILayout.LongField(variableName, (long)((uint)val));
+                    val = (uint)EditorGUILayout.LongField(variableName, (uint)val);
                 }
                 else if (type == typeof(short))
                 {
-                    val = (short)EditorGUILayout.IntField(variableName, (int)((short)val));
+                    val = (short)EditorGUILayout.IntField(variableName, (short)val);
                 }
                 else if (type == typeof(ushort))
                 {
-                    val = (ushort)EditorGUILayout.IntField(variableName, (int)((ushort)val));
+                    val = (ushort)EditorGUILayout.IntField(variableName, (ushort)val);
                 }
                 else if (type == typeof(sbyte))
                 {
-                    val = (sbyte)EditorGUILayout.IntField(variableName, (int)((sbyte)val));
+                    val = (sbyte)EditorGUILayout.IntField(variableName, (sbyte)val);
                 }
                 else if (type == typeof(byte))
                 {
-                    val = (byte)EditorGUILayout.IntField(variableName, (int)((byte)val));
+                    val = (byte)EditorGUILayout.IntField(variableName, (byte)val);
                 }
                 else if (type == typeof(long))
                 {
@@ -161,6 +193,10 @@ namespace Unity.Netcode.Editor
                 {
                     val = (ulong)EditorGUILayout.LongField(variableName, (long)((ulong)val));
                 }
+                else if (type == typeof(float))
+                {
+                    val = EditorGUILayout.FloatField(variableName, (float)((float)val));
+                }
                 else if (type == typeof(bool))
                 {
                     val = EditorGUILayout.Toggle(variableName, (bool)val);
@@ -236,7 +272,7 @@ namespace Unity.Netcode.Editor
             bool expanded = true;
             while (property.NextVisible(expanded))
             {
-                if (m_NetworkVariableNames.Contains(property.name))
+                if (m_NetworkVariableNames.Contains(ObjectNames.NicifyVariableName(property.name)))
                 {
                     // Skip rendering of NetworkVars, they have special rendering
                     continue;
@@ -309,8 +345,9 @@ namespace Unity.Netcode.Editor
         /// <param name="networkObjectRemoved">used internally</param>
         public static void CheckForNetworkObject(GameObject gameObject, bool networkObjectRemoved = false)
         {
-            // If there are no NetworkBehaviours or no gameObject, then exit early
-            if (gameObject == null || (gameObject.GetComponent<NetworkBehaviour>() == null && gameObject.GetComponentInChildren<NetworkBehaviour>() == null))
+            // If there are no NetworkBehaviours or gameObjects then exit early
+            // If we are in play mode and a user is inspecting something then exit early (we don't add NetworkObjects to something when in play mode)
+            if (EditorApplication.isPlaying || gameObject == null || (gameObject.GetComponent<NetworkBehaviour>() == null && gameObject.GetComponentInChildren<NetworkBehaviour>() == null))
             {
                 return;
             }
@@ -380,6 +417,48 @@ namespace Unity.Netcode.Editor
                     }
                 }
             }
+
+            if (networkObject != null)
+            {
+                OrderNetworkObject(networkObject);
+            }
+        }
+
+        // Assures the NetworkObject precedes any NetworkBehaviour on the same GameObject as the NetworkObject
+        private static void OrderNetworkObject(NetworkObject networkObject)
+        {
+            var monoBehaviours = networkObject.gameObject.GetComponents<MonoBehaviour>();
+            var networkObjectIndex = 0;
+            var firstNetworkBehaviourIndex = -1;
+            for (int i = 0; i < monoBehaviours.Length; i++)
+            {
+                if (monoBehaviours[i] == networkObject)
+                {
+                    networkObjectIndex = i;
+                    break;
+                }
+
+                var networkBehaviour = monoBehaviours[i] as NetworkBehaviour;
+                if (networkBehaviour != null)
+                {
+                    // Get the index of the first NetworkBehaviour Component
+                    if (firstNetworkBehaviourIndex == -1)
+                    {
+                        firstNetworkBehaviourIndex = i;
+                    }
+                }
+            }
+
+            if (firstNetworkBehaviourIndex != -1 && networkObjectIndex > firstNetworkBehaviourIndex)
+            {
+                var positionsToMove = networkObjectIndex - firstNetworkBehaviourIndex;
+                for (int i = 0; i < positionsToMove; i++)
+                {
+                    UnityEditorInternal.ComponentUtility.MoveComponentUp(networkObject);
+                }
+
+                EditorUtility.SetDirty(networkObject.gameObject);
+            }
         }
     }
 }

Editor/NetworkManagerEditor.cs

@@ -1,9 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using Unity.Netcode.Editor.Configuration;
 using UnityEditor;
 using UnityEngine;
-using Unity.Netcode.Editor.Configuration;
 
 namespace Unity.Netcode.Editor
 {
@@ -30,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;
@@ -38,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;
@@ -96,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));
@@ -124,15 +130,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));
@@ -153,10 +164,46 @@ namespace Unity.Netcode.Editor
                 serializedObject.Update();
                 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);
+                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();
+
+                        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 (m_NetworkManager.NetworkConfig.ConnectionApproval)
+                {
+                    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.PropertyField(m_PlayerPrefabProperty);
                 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())
                 {
@@ -214,68 +261,11 @@ namespace Unity.Netcode.Editor
                     }
                     EditorGUILayout.PropertyField(m_PrefabsList);
                 }
+
                 EditorGUILayout.Space();
-
-                EditorGUILayout.LabelField("General", EditorStyles.boldLabel);
-                EditorGUILayout.PropertyField(m_ProtocolVersionProperty);
-
-                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();
-
-                        var transportComponent = m_NetworkManager.gameObject.GetComponent(m_TransportTypes[selection - 1]);
-
-                        if (transportComponent == null)
-                        {
-                            transportComponent = m_NetworkManager.gameObject.AddComponent(m_TransportTypes[selection - 1]);
-                        }
-
-                        m_NetworkTransportProperty.objectReferenceValue = transportComponent;
-
-                        Repaint();
-                    }
-                }
-
-                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.LabelField("Scene Management Settings", EditorStyles.boldLabel);
                 EditorGUILayout.PropertyField(m_EnableSceneManagementProperty);
-
-                using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.EnableSceneManagement))
+                if (m_NetworkManager.NetworkConfig.EnableSceneManagement)
                 {
                     EditorGUILayout.PropertyField(m_LoadSceneTimeOutProperty);
                 }
@@ -345,7 +335,7 @@ namespace Unity.Netcode.Editor
             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/netcode/current/tools/install-tools";
+            const string targetUrl = "https://docs-multiplayer.unity3d.com/tools/current/install-tools";
             const string infoIconName = "console.infoicon";
 
             if (NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() != 0)
@@ -355,15 +345,19 @@ namespace Unity.Netcode.Editor
 
             if (s_CenteredWordWrappedLabelStyle == null)
             {
-                s_CenteredWordWrappedLabelStyle = new GUIStyle(GUI.skin.label);
-                s_CenteredWordWrappedLabelStyle.wordWrap = true;
-                s_CenteredWordWrappedLabelStyle.alignment = TextAnchor.MiddleLeft;
+                s_CenteredWordWrappedLabelStyle = new GUIStyle(GUI.skin.label)
+                {
+                    wordWrap = true,
+                    alignment = TextAnchor.MiddleLeft
+                };
             }
 
             if (s_HelpBoxStyle == null)
             {
-                s_HelpBoxStyle = new GUIStyle(EditorStyles.helpBox);
-                s_HelpBoxStyle.padding = new RectOffset(10, 10, 10, 10);
+                s_HelpBoxStyle = new GUIStyle(EditorStyles.helpBox)
+                {
+                    padding = new RectOffset(10, 10, 10, 10)
+                };
             }
 
             var openDocsButtonStyle = GUI.skin.button;

Editor/NetworkManagerHelper.cs

@@ -1,9 +1,9 @@
 using System.Collections.Generic;
 using System.Linq;
 using Unity.Netcode.Editor.Configuration;
+using UnityEditor;
 using UnityEngine;
 using UnityEngine.SceneManagement;
-using UnityEditor;
 
 namespace Unity.Netcode.Editor
 {

Editor/NetworkManagerRelayIntegration.cs

@@ -0,0 +1,120 @@
+#if UNITY_2022_3_OR_NEWER && (RELAY_SDK_INSTALLED && !UNITY_WEBGL ) || (RELAY_SDK_INSTALLED && UNITY_WEBGL && UTP_TRANSPORT_2_0_ABOVE)
+using System;
+using System.Threading.Tasks;
+using Unity.Netcode.Transports.UTP;
+using Unity.Networking.Transport.Relay;
+using Unity.Services.Authentication;
+using Unity.Services.Core;
+using Unity.Services.Relay;
+using Unity.Services.Relay.Models;
+
+namespace Unity.Netcode.Editor
+{
+    /// <summary>
+    /// Integration with Unity Relay SDK and Unity Transport that support the additional buttons in the NetworkManager inspector.
+    /// This code could theoretically be used at runtime, but we would like to avoid the additional dependencies in the runtime assembly of netcode for gameobjects.
+    /// </summary>
+    public static class NetworkManagerRelayIntegration
+    {
+
+#if UNITY_WEBGL
+        private const string k_DefaultConnectionType = "wss";
+#else
+        private const string k_DefaultConnectionType = "dtls";
+#endif
+
+        /// <summary>
+        /// Easy relay integration (host): it will initialize the unity services, sign in anonymously and start the host with a new relay allocation.
+        /// Note that this will force the use of Unity Transport.
+        /// </summary>
+        /// <param name="networkManager">The network manager that will start the connection</param>
+        /// <param name="maxConnections">Maximum number of connections to the created relay.</param>
+        /// <param name="connectionType">The connection type of the <see cref="RelayServerData"/> (wss, ws, dtls or udp) </param>
+        /// <returns>The join code that a potential client can use and the allocation</returns>
+        /// <exception cref="ServicesInitializationException"> Exception when there's an error during services initialization </exception>
+        /// <exception cref="UnityProjectNotLinkedException"> Exception when the project is not linked to a cloud project id </exception>
+        /// <exception cref="CircularDependencyException"> Exception when two registered <see cref="IInitializablePackage"/> depend on the other </exception>
+        /// <exception cref="AuthenticationException"> The task fails with the exception when the task cannot complete successfully due to Authentication specific errors. </exception>
+        /// <exception cref="RequestFailedException"> See <see cref="IAuthenticationService.SignInAnonymouslyAsync"/></exception>
+        /// <exception cref="ArgumentException">Thrown when the maxConnections argument fails validation in Relay Service SDK.</exception>
+        /// <exception cref="RelayServiceException">Thrown when the request successfully reach the Relay Allocation Service but results in an error.</exception>
+        internal static async Task<(string, Allocation)> StartHostWithRelay(this NetworkManager networkManager, int maxConnections = 5)
+        {
+            var codeAndAllocation = await InitializeAndCreateAllocAsync(networkManager, maxConnections, k_DefaultConnectionType);
+            return networkManager.StartHost() ? codeAndAllocation : (null, null);
+        }
+
+        /// <summary>
+        /// Easy relay integration (server): it will initialize the unity services, sign in anonymously and start the server with a new relay allocation.
+        /// Note that this will force the use of Unity Transport.
+        /// </summary>
+        /// <param name="networkManager">The network manager that will start the connection</param>
+        /// <param name="maxConnections">Maximum number of connections to the created relay.</param>
+        /// <returns>The join code that a potential client can use and the allocation.</returns>
+        /// <exception cref="ServicesInitializationException"> Exception when there's an error during services initialization </exception>
+        /// <exception cref="UnityProjectNotLinkedException"> Exception when the project is not linked to a cloud project id </exception>
+        /// <exception cref="CircularDependencyException"> Exception when two registered <see cref="IInitializablePackage"/> depend on the other </exception>
+        /// <exception cref="AuthenticationException"> The task fails with the exception when the task cannot complete successfully due to Authentication specific errors. </exception>
+        /// <exception cref="RequestFailedException"> See <see cref="IAuthenticationService.SignInAnonymouslyAsync"/></exception>
+        /// <exception cref="ArgumentException">Thrown when the maxConnections argument fails validation in Relay Service SDK.</exception>
+        /// <exception cref="RelayServiceException">Thrown when the request successfully reach the Relay Allocation Service but results in an error.</exception>
+        internal static async Task<(string, Allocation)> StartServerWithRelay(this NetworkManager networkManager, int maxConnections = 5)
+        {
+            var codeAndAllocation = await InitializeAndCreateAllocAsync(networkManager, maxConnections, k_DefaultConnectionType);
+            return networkManager.StartServer() ? codeAndAllocation : (null, null);
+        }
+
+        /// <summary>
+        /// Easy relay integration (client): it will initialize the unity services, sign in anonymously, join the relay with the given join code and start the client.
+        /// Note that this will force the use of Unity Transport.
+        /// </summary>
+        /// <param name="networkManager">The network manager that will start the connection</param>
+        /// <param name="joinCode">The join code of the allocation</param>
+        /// <exception cref="ServicesInitializationException"> Exception when there's an error during services initialization </exception>
+        /// <exception cref="UnityProjectNotLinkedException"> Exception when the project is not linked to a cloud project id </exception>
+        /// <exception cref="CircularDependencyException"> Exception when two registered <see cref="IInitializablePackage"/> depend on the other </exception>
+        /// <exception cref="AuthenticationException"> The task fails with the exception when the task cannot complete successfully due to Authentication specific errors. </exception>
+        /// <exception cref="RequestFailedException">Thrown when the request does not reach the Relay Allocation Service.</exception>
+        /// <exception cref="ArgumentException">Thrown if the joinCode has the wrong format.</exception>
+        /// <exception cref="RelayServiceException">Thrown when the request successfully reach the Relay Allocation Service but results in an error.</exception>
+        /// <returns>True if starting the client was successful</returns>
+        internal static async Task<JoinAllocation> StartClientWithRelay(this NetworkManager networkManager, string joinCode)
+        {
+            await UnityServices.InitializeAsync();
+            if (!AuthenticationService.Instance.IsSignedIn)
+            {
+                await AuthenticationService.Instance.SignInAnonymouslyAsync();
+            }
+            var joinAllocation = await RelayService.Instance.JoinAllocationAsync(joinCode: joinCode);
+            GetUnityTransport(networkManager, k_DefaultConnectionType).SetRelayServerData(new RelayServerData(joinAllocation, k_DefaultConnectionType));
+            return networkManager.StartClient() ? joinAllocation : null;
+        }
+
+        private static async Task<(string, Allocation)> InitializeAndCreateAllocAsync(NetworkManager networkManager, int maxConnections, string connectionType)
+        {
+            await UnityServices.InitializeAsync();
+            if (!AuthenticationService.Instance.IsSignedIn)
+            {
+                await AuthenticationService.Instance.SignInAnonymouslyAsync();
+            }
+            Allocation allocation = await RelayService.Instance.CreateAllocationAsync(maxConnections);
+            GetUnityTransport(networkManager, connectionType).SetRelayServerData(new RelayServerData(allocation, connectionType));
+            var joinCode = await RelayService.Instance.GetJoinCodeAsync(allocation.AllocationId);
+            return (joinCode, allocation);
+        }
+
+        private static UnityTransport GetUnityTransport(NetworkManager networkManager, string connectionType)
+        {
+            if (!networkManager.TryGetComponent<UnityTransport>(out var transport))
+            {
+                transport = networkManager.gameObject.AddComponent<UnityTransport>();
+            }
+#if UTP_TRANSPORT_2_0_ABOVE
+            transport.UseWebSockets = connectionType.StartsWith("ws"); // Probably should be part of SetRelayServerData, but not possible at this point
+#endif
+            networkManager.NetworkConfig.NetworkTransport = transport; // Force using UnityTransport
+            return transport;
+        }
+    }
+}
+#endif

Editor/NetworkManagerRelayIntegration.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 23b658b1c2e443109a8a131ef3632c9b
+timeCreated: 1698673251

Editor/NetworkObjectEditor.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
-using UnityEngine;
+using System.Linq;
 using UnityEditor;
+using UnityEngine;
 
 namespace Unity.Netcode.Editor
 {
@@ -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

@@ -1,6 +1,6 @@
+using Unity.Netcode.Components;
 using UnityEditor;
 using UnityEngine;
-using Unity.Netcode.Components;
 
 namespace Unity.Netcode.Editor
 {
@@ -10,6 +10,7 @@ namespace Unity.Netcode.Editor
     [CustomEditor(typeof(NetworkTransform), true)]
     public class NetworkTransformEditor : UnityEditor.Editor
     {
+        private SerializedProperty m_UseUnreliableDeltas;
         private SerializedProperty m_SyncPositionXProperty;
         private SerializedProperty m_SyncPositionYProperty;
         private SerializedProperty m_SyncPositionZProperty;
@@ -25,6 +26,11 @@ namespace Unity.Netcode.Editor
         private SerializedProperty m_InLocalSpaceProperty;
         private SerializedProperty m_InterpolateProperty;
 
+        private SerializedProperty m_UseQuaternionSynchronization;
+        private SerializedProperty m_UseQuaternionCompression;
+        private SerializedProperty m_UseHalfFloatPrecision;
+        private SerializedProperty m_SlerpPosition;
+
         private static int s_ToggleOffset = 45;
         private static float s_MaxRowWidth = EditorGUIUtility.labelWidth + EditorGUIUtility.fieldWidth + 5;
         private static GUIContent s_PositionLabel = EditorGUIUtility.TrTextContent("Position");
@@ -34,6 +40,7 @@ namespace Unity.Netcode.Editor
         /// <inheritdoc/>
         public void OnEnable()
         {
+            m_UseUnreliableDeltas = serializedObject.FindProperty(nameof(NetworkTransform.UseUnreliableDeltas));
             m_SyncPositionXProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionX));
             m_SyncPositionYProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionY));
             m_SyncPositionZProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionZ));
@@ -48,6 +55,10 @@ namespace Unity.Netcode.Editor
             m_ScaleThresholdProperty = serializedObject.FindProperty(nameof(NetworkTransform.ScaleThreshold));
             m_InLocalSpaceProperty = serializedObject.FindProperty(nameof(NetworkTransform.InLocalSpace));
             m_InterpolateProperty = serializedObject.FindProperty(nameof(NetworkTransform.Interpolate));
+            m_UseQuaternionSynchronization = serializedObject.FindProperty(nameof(NetworkTransform.UseQuaternionSynchronization));
+            m_UseQuaternionCompression = serializedObject.FindProperty(nameof(NetworkTransform.UseQuaternionCompression));
+            m_UseHalfFloatPrecision = serializedObject.FindProperty(nameof(NetworkTransform.UseHalfFloatPrecision));
+            m_SlerpPosition = serializedObject.FindProperty(nameof(NetworkTransform.SlerpPosition));
         }
 
         /// <inheritdoc/>
@@ -71,6 +82,8 @@ namespace Unity.Netcode.Editor
 
                 GUILayout.EndHorizontal();
             }
+
+            if (!m_UseQuaternionSynchronization.boolValue)
             {
                 GUILayout.BeginHorizontal();
 
@@ -88,6 +101,13 @@ namespace Unity.Netcode.Editor
 
                 GUILayout.EndHorizontal();
             }
+            else
+            {
+                m_SyncRotationXProperty.boolValue = true;
+                m_SyncRotationYProperty.boolValue = true;
+                m_SyncRotationZProperty.boolValue = true;
+            }
+
             {
                 GUILayout.BeginHorizontal();
 
@@ -111,11 +131,24 @@ namespace Unity.Netcode.Editor
             EditorGUILayout.PropertyField(m_PositionThresholdProperty);
             EditorGUILayout.PropertyField(m_RotAngleThresholdProperty);
             EditorGUILayout.PropertyField(m_ScaleThresholdProperty);
-
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Delivery", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(m_UseUnreliableDeltas);
             EditorGUILayout.Space();
             EditorGUILayout.LabelField("Configurations", EditorStyles.boldLabel);
             EditorGUILayout.PropertyField(m_InLocalSpaceProperty);
             EditorGUILayout.PropertyField(m_InterpolateProperty);
+            EditorGUILayout.PropertyField(m_SlerpPosition);
+            EditorGUILayout.PropertyField(m_UseQuaternionSynchronization);
+            if (m_UseQuaternionSynchronization.boolValue)
+            {
+                EditorGUILayout.PropertyField(m_UseQuaternionCompression);
+            }
+            else
+            {
+                m_UseQuaternionCompression.boolValue = false;
+            }
+            EditorGUILayout.PropertyField(m_UseHalfFloatPrecision);
 
 #if COM_UNITY_MODULES_PHYSICS
             // if rigidbody is present but network rigidbody is not present

Editor/com.unity.netcode.editor.asmdef

@@ -3,11 +3,21 @@
     "rootNamespace": "Unity.Netcode.Editor",
     "references": [
         "Unity.Netcode.Runtime",
-        "Unity.Netcode.Components"
+        "Unity.Netcode.Components",
+        "Unity.Services.Relay",
+        "Unity.Networking.Transport",
+        "Unity.Services.Core",
+        "Unity.Services.Authentication"
     ],
     "includePlatforms": [
         "Editor"
     ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
     "versionDefines": [
         {
             "name": "com.unity.multiplayer.tools",
@@ -33,6 +43,17 @@
             "name": "com.unity.modules.physics2d",
             "expression": "",
             "define": "COM_UNITY_MODULES_PHYSICS2D"
+        },
+        {
+            "name": "com.unity.services.relay",
+            "expression": "1.0",
+            "define": "RELAY_SDK_INSTALLED"
+        },
+        {
+            "name": "com.unity.transport",
+            "expression": "2.0",
+            "define": "UTP_TRANSPORT_2_0_ABOVE"
         }
-    ]
-}
+    ],
+    "noEngineReferences": false
+}

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

@@ -1,5 +1,5 @@
 using System.Runtime.CompilerServices;
-
+[assembly: InternalsVisibleTo("Unity.Netcode.Components")]
 #if UNITY_EDITOR
 [assembly: InternalsVisibleTo("Unity.Netcode.Editor")]
 [assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")]

Runtime/Configuration/NetworkConfig.cs

@@ -1,8 +1,8 @@
 using System;
 using System.Collections.Generic;
-using UnityEngine;
 using System.Linq;
 using Unity.Collections;
+using UnityEngine;
 using UnityEngine.Serialization;
 
 namespace Unity.Netcode
@@ -129,10 +129,10 @@ 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")]
-        public float SpawnTimeout = 1f;
+        [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>
         /// Whether or not to enable network logs.
@@ -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>
@@ -156,7 +165,7 @@ namespace Unity.Netcode
         public string ToBase64()
         {
             NetworkConfig config = this;
-            var writer = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp);
+            var writer = new FastBufferWriter(1024, Allocator.Temp);
             using (writer)
             {
                 writer.WriteValueSafe(config.ProtocolVersion);
@@ -208,6 +217,14 @@ namespace Unity.Netcode
 
         private ulong? m_ConfigHash = null;
 
+        /// <summary>
+        /// Clears out the configuration hash value generated for a specific network session
+        /// </summary>
+        internal void ClearConfigHash()
+        {
+            m_ConfigHash = null;
+        }
+
         /// <summary>
         /// Gets a SHA256 hash of parts of the NetworkConfig instance
         /// </summary>
@@ -220,7 +237,7 @@ namespace Unity.Netcode
                 return m_ConfigHash.Value;
             }
 
-            var writer = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, int.MaxValue);
+            var writer = new FastBufferWriter(1024, Allocator.Temp, int.MaxValue);
             using (writer)
             {
                 writer.WriteValueSafe(ProtocolVersion);
@@ -273,8 +290,6 @@ namespace Unity.Netcode
             Prefabs.Initialize();
         }
 
-        #region Legacy Network Prefab List
-
         [NonSerialized]
         private bool m_DidWarnOldPrefabList = false;
 
@@ -334,7 +349,5 @@ namespace Unity.Netcode
         [FormerlySerializedAs("NetworkPrefabs")]
         [SerializeField]
         internal List<NetworkPrefab> OldPrefabList;
-
-        #endregion
     }
 }

Runtime/Configuration/NetworkPrefab.cs

@@ -12,10 +12,12 @@ namespace Unity.Netcode
         /// No oeverride is present
         /// </summary>
         None,
+
         /// <summary>
         /// Override the prefab when the given SourcePrefabToOverride is requested
         /// </summary>
         Prefab,
+
         /// <summary>
         /// Override the prefab when the given SourceHashToOverride is requested
         /// Used in situations where the server assets do not exist in client builds
@@ -71,19 +73,23 @@ namespace Unity.Netcode
                 switch (Override)
                 {
                     case NetworkPrefabOverride.None:
-                        if (Prefab != null && Prefab.TryGetComponent(out NetworkObject no))
                         {
-                            return no.GlobalObjectIdHash;
-                        }
+                            if (Prefab != null && Prefab.TryGetComponent(out NetworkObject networkObject))
+                            {
+                                return networkObject.GlobalObjectIdHash;
+                            }
 
-                        throw new InvalidOperationException("Prefab field isn't set or isn't a Network Object");
+                            throw new InvalidOperationException($"Prefab field is not set or is not a {nameof(NetworkObject)}");
+                        }
                     case NetworkPrefabOverride.Prefab:
-                        if (SourcePrefabToOverride != null && SourcePrefabToOverride.TryGetComponent(out no))
                         {
-                            return no.GlobalObjectIdHash;
-                        }
+                            if (SourcePrefabToOverride != null && SourcePrefabToOverride.TryGetComponent(out NetworkObject networkObject))
+                            {
+                                return networkObject.GlobalObjectIdHash;
+                            }
 
-                        throw new InvalidOperationException("Source Prefab field isn't set or isn't a Network Object");
+                            throw new InvalidOperationException($"Source Prefab field is not set or is not a {nameof(NetworkObject)}");
+                        }
                     case NetworkPrefabOverride.Hash:
                         return SourceHashToOverride;
                     default:
@@ -102,12 +108,14 @@ namespace Unity.Netcode
                         return 0;
                     case NetworkPrefabOverride.Prefab:
                     case NetworkPrefabOverride.Hash:
-                        if (OverridingTargetPrefab != null && OverridingTargetPrefab.TryGetComponent(out NetworkObject no))
                         {
-                            return no.GlobalObjectIdHash;
-                        }
+                            if (OverridingTargetPrefab != null && OverridingTargetPrefab.TryGetComponent(out NetworkObject networkObject))
+                            {
+                                return networkObject.GlobalObjectIdHash;
+                            }
 
-                        throw new InvalidOperationException("Target Prefab field isn't set or isn't a Network Object");
+                            throw new InvalidOperationException($"Target Prefab field is not set or is not a {nameof(NetworkObject)}");
+                        }
                     default:
                         throw new ArgumentOutOfRangeException();
                 }
@@ -130,9 +138,9 @@ namespace Unity.Netcode
                 {
                     if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
                     {
-                        NetworkLog.LogWarning($"{NetworkManager.PrefabDebugHelper(this)} is missing " +
-                                              $"a {nameof(NetworkObject)} component (entry will be ignored).");
+                        NetworkLog.LogWarning($"{NetworkPrefabHandler.PrefabDebugHelper(this)} is missing a {nameof(NetworkObject)} component (entry will be ignored).");
                     }
+
                     return false;
                 }
 
@@ -148,9 +156,9 @@ namespace Unity.Netcode
                         {
                             if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
                             {
-                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(SourceHashToOverride)} is zero " +
-                                    "(entry will be ignored).");
+                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(SourceHashToOverride)} is zero (entry will be ignored).");
                             }
+
                             return false;
                         }
 
@@ -178,9 +186,9 @@ namespace Unity.Netcode
                         {
                             if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
                             {
-                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} ({SourcePrefabToOverride.name}) " +
-                                    $"is missing a {nameof(NetworkObject)} component (entry will be ignored).");
+                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} ({SourcePrefabToOverride.name}) is missing a {nameof(NetworkObject)} component (entry will be ignored).");
                             }
+
                             return false;
                         }
 
@@ -195,6 +203,7 @@ namespace Unity.Netcode
                 {
                     NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(OverridingTargetPrefab)} is null!");
                 }
+
                 switch (Override)
                 {
                     case NetworkPrefabOverride.Hash:
@@ -208,8 +217,10 @@ namespace Unity.Netcode
                             break;
                         }
                 }
+
                 return false;
             }
+
             return true;
         }
 

Runtime/Configuration/NetworkPrefabs.cs

@@ -30,6 +30,12 @@ namespace Unity.Netcode
         [NonSerialized]
         public Dictionary<uint, NetworkPrefab> NetworkPrefabOverrideLinks = new Dictionary<uint, NetworkPrefab>();
 
+        /// <summary>
+        /// This is used for the legacy way of spawning NetworkPrefabs with an override when manually instantiating and spawning.
+        /// To handle multiple source NetworkPrefab overrides that all point to the same target NetworkPrefab use
+        /// <see cref="NetworkSpawnManager.InstantiateAndSpawn(NetworkObject, ulong, bool, bool, bool, Vector3, Quaternion)"/>
+        /// or <see cref="NetworkObject.InstantiateAndSpawn(NetworkManager, ulong, bool, bool, bool, Vector3, Quaternion)"/>
+        /// </summary>
         [NonSerialized]
         public Dictionary<uint, uint> OverrideToNetworkPrefab = new Dictionary<uint, uint>();
 
@@ -38,10 +44,15 @@ namespace Unity.Netcode
         [NonSerialized]
         private List<NetworkPrefab> m_Prefabs = new List<NetworkPrefab>();
 
+        [NonSerialized]
+        private List<NetworkPrefab> m_RuntimeAddedPrefabs = new List<NetworkPrefab>();
+
         private void AddTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
         {
             if (AddPrefabRegistration(networkPrefab))
             {
+                // Don't add this to m_RuntimeAddedPrefabs
+                // This prefab is now in the PrefabList, so if we shutdown and initialize again, we'll pick it up from there.
                 m_Prefabs.Add(networkPrefab);
             }
         }
@@ -52,6 +63,15 @@ namespace Unity.Netcode
         }
 
         ~NetworkPrefabs()
+        {
+            Shutdown();
+        }
+
+        /// <summary>
+        /// Deregister from add and remove events
+        /// Clear the list
+        /// </summary>
+        internal void Shutdown()
         {
             foreach (var list in NetworkPrefabsLists)
             {
@@ -66,13 +86,7 @@ namespace Unity.Netcode
         /// </summary>
         public void Initialize(bool warnInvalid = true)
         {
-            if (NetworkPrefabsLists.Count != 0 && m_Prefabs.Count > 0)
-            {
-                NetworkLog.LogWarning("Runtime Network Prefabs was not empty at initialization time. Network " +
-                    "Prefab registrations made before initialization will be replaced by NetworkPrefabsList.");
-                m_Prefabs.Clear();
-            }
-
+            m_Prefabs.Clear();
             foreach (var list in NetworkPrefabsLists)
             {
                 list.OnAdd += AddTriggeredByNetworkPrefabList;
@@ -82,7 +96,7 @@ namespace Unity.Netcode
             NetworkPrefabOverrideLinks.Clear();
             OverrideToNetworkPrefab.Clear();
 
-            var prefabs = NetworkPrefabsLists.Count != 0 ? new List<NetworkPrefab>() : m_Prefabs;
+            var prefabs = new List<NetworkPrefab>();
 
             if (NetworkPrefabsLists.Count != 0)
             {
@@ -115,6 +129,18 @@ namespace Unity.Netcode
                 }
             }
 
+            foreach (var networkPrefab in m_RuntimeAddedPrefabs)
+            {
+                if (AddPrefabRegistration(networkPrefab))
+                {
+                    m_Prefabs.Add(networkPrefab);
+                }
+                else
+                {
+                    removeList?.Add(networkPrefab);
+                }
+            }
+
             // Clear out anything that is invalid or not used
             if (removeList?.Count > 0)
             {
@@ -141,6 +167,7 @@ namespace Unity.Netcode
             if (AddPrefabRegistration(networkPrefab))
             {
                 m_Prefabs.Add(networkPrefab);
+                m_RuntimeAddedPrefabs.Add(networkPrefab);
                 return true;
             }
 
@@ -164,6 +191,7 @@ namespace Unity.Netcode
             }
 
             m_Prefabs.Remove(prefab);
+            m_RuntimeAddedPrefabs.Remove(prefab);
             OverrideToNetworkPrefab.Remove(prefab.TargetPrefabGlobalObjectIdHash);
             NetworkPrefabOverrideLinks.Remove(prefab.SourcePrefabGlobalObjectIdHash);
         }
@@ -192,6 +220,15 @@ namespace Unity.Netcode
                     return;
                 }
             }
+
+            for (int i = 0; i < m_RuntimeAddedPrefabs.Count; i++)
+            {
+                if (m_RuntimeAddedPrefabs[i].Prefab == prefab)
+                {
+                    Remove(m_RuntimeAddedPrefabs[i]);
+                    return;
+                }
+            }
         }
 
         /// <summary>
@@ -203,7 +240,8 @@ namespace Unity.Netcode
         {
             for (int i = 0; i < m_Prefabs.Count; i++)
             {
-                if (m_Prefabs[i].Prefab == prefab)
+                // Check both values as Prefab and be different than SourcePrefabToOverride
+                if (m_Prefabs[i].Prefab == prefab || m_Prefabs[i].SourcePrefabToOverride == prefab)
                 {
                     return true;
                 }
@@ -231,7 +269,7 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Configures <see cref="NetworkPrefabOverrideLinks"/> and <see cref="OverrideToNetworkPrefab"/> for the given <see cref="NetworkPrefab"/>
+        /// Configures <see cref="NetworkPrefabOverrideLinks"/> for the given <see cref="NetworkPrefab"/>
         /// </summary>
         private bool AddPrefabRegistration(NetworkPrefab networkPrefab)
         {
@@ -265,28 +303,16 @@ namespace Unity.Netcode
                 return true;
             }
 
-            // Make sure we don't have several overrides targeting the same prefab. Apparently we don't support that... shame.
-            if (OverrideToNetworkPrefab.ContainsKey(target))
-            {
-                var networkObject = networkPrefab.Prefab.GetComponent<NetworkObject>();
-
-                // This can happen if a user tries to make several GlobalObjectIdHash values point to the same target
-                Debug.LogError($"{nameof(NetworkPrefab)} (\"{networkObject.name}\") has a duplicate {nameof(NetworkObject.GlobalObjectIdHash)} target entry value of: {target}!");
-                return false;
-            }
-
             switch (networkPrefab.Override)
             {
                 case NetworkPrefabOverride.Prefab:
-                    {
-                        NetworkPrefabOverrideLinks.Add(source, networkPrefab);
-                        OverrideToNetworkPrefab.Add(target, source);
-                    }
-                    break;
                 case NetworkPrefabOverride.Hash:
                     {
                         NetworkPrefabOverrideLinks.Add(source, networkPrefab);
-                        OverrideToNetworkPrefab.Add(target, source);
+                        if (!OverrideToNetworkPrefab.ContainsKey(target))
+                        {
+                            OverrideToNetworkPrefab.Add(target, source);
+                        }
                     }
                     break;
             }

Runtime/Connection/NetworkClient.cs

@@ -1,12 +1,55 @@
 using System.Collections.Generic;
+using UnityEngine;
 
 namespace Unity.Netcode
 {
+
+    public enum SessionModeTypes
+    {
+        ClientServer,
+        DistributedAuthority
+    }
+
     /// <summary>
     /// A NetworkClient
     /// </summary>
     public class NetworkClient
     {
+        /// <summary>
+        /// Returns true if the session instance is considered a server
+        /// </summary>
+        internal bool IsServer { get; set; }
+
+        /// <summary>
+        /// Returns true if the session instance is considered a client
+        /// </summary>
+        internal bool IsClient { get; set; }
+
+        /// <summary>
+        /// Returns true if the session instance is considered a host
+        /// </summary>
+        internal bool IsHost => IsClient && IsServer;
+
+        /// <summary>
+        /// When true, the client is connected, approved, and synchronized with
+        /// the server.
+        /// </summary>
+        internal bool IsConnected { get; set; }
+
+        /// <summary>
+        /// Is true when the client has been approved.
+        /// </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>
@@ -18,19 +61,66 @@ namespace Unity.Netcode
         public NetworkObject PlayerObject;
 
         /// <summary>
-        /// The NetworkObject's owned by this Client
+        /// The list of NetworkObject's owned by this client instance
         /// </summary>
-        public List<NetworkObject> OwnedObjects
-        {
-            get
-            {
-                if (PlayerObject != null && PlayerObject.NetworkManager != null && PlayerObject.NetworkManager.IsListening)
-                {
-                    return PlayerObject.NetworkManager.SpawnManager.GetClientOwnedObjects(ClientId);
-                }
+        public List<NetworkObject> OwnedObjects => IsConnected ? SpawnManager.GetClientOwnedObjects(ClientId) : new List<NetworkObject>();
 
-                return new List<NetworkObject>();
+        internal NetworkSpawnManager SpawnManager { get; private set; }
+
+        internal bool SetRole(bool isServer, bool isClient, NetworkManager networkManager = null)
+        {
+            ResetClient(isServer, isClient);
+
+            IsServer = isServer;
+            IsClient = 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;
+            }
+        }
+
+        internal void AssignPlayerObject(ref NetworkObject networkObject)
+        {
+            PlayerObject = networkObject;
         }
     }
 }

Runtime/Connection/NetworkConnectionManager.cs.meta

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

Runtime/Connection/PendingClient.cs

@@ -1,10 +1,15 @@
+using UnityEngine;
+
 namespace Unity.Netcode
 {
     /// <summary>
+    /// Server-Side Only:
     /// A class representing a client that is currently in the process of connecting
     /// </summary>
     public class PendingClient
     {
+        internal Coroutine ApprovalCoroutine = null;
+
         /// <summary>
         /// The ClientId of the client
         /// </summary>

Runtime/Core/ComponentFactory.cs

@@ -51,7 +51,9 @@ namespace Unity.Netcode
         /// </summary>
         public static void SetDefaults()
         {
-            SetDefault<IDeferredMessageManager>(networkManager => new DeferredMessageManager(networkManager));
+            SetDefault<IDeferredNetworkMessageManager>(networkManager => new DeferredMessageManager(networkManager));
+
+            SetDefault<IRealTimeProvider>(networkManager => new RealTimeProvider());
         }
 
         private static void SetDefault<T>(CreateObjectDelegate creator)

Runtime/Core/NetworkBehaviour.cs

@@ -1,33 +1,56 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using UnityEngine;
-using System.Reflection;
 using Unity.Collections;
+using UnityEngine;
+
 
 namespace Unity.Netcode
 {
+    public class RpcException : Exception
+    {
+        public RpcException(string message) : base(message)
+        {
+
+        }
+    }
+
     /// <summary>
     /// The base class to override to write network code. Inherits MonoBehaviour
     /// </summary>
     public abstract class NetworkBehaviour : MonoBehaviour
     {
 #pragma warning disable IDE1006 // disable naming rule violation check
+
+        // RuntimeAccessModifiersILPP will make this `public`
+        internal delegate void RpcReceiveHandler(NetworkBehaviour behaviour, FastBufferReader reader, __RpcParams parameters);
+
+        // 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
+        // RuntimeAccessModifiersILPP will make this `public`
+        internal static readonly Dictionary<Type, Dictionary<uint, string>> __rpc_name_table = new Dictionary<Type, Dictionary<uint, string>>();
+#endif
+
         // RuntimeAccessModifiersILPP will make this `protected`
         internal enum __RpcExecStage
         {
+            // Technically will overlap with None and Server
+            // but it doesn't matter since we don't use None and Server
+            Send = 0,
+            Execute = 1,
+
+            // Backward compatibility, not used...
             None = 0,
             Server = 1,
-            Client = 2
+            Client = 2,
         }
-
-
         // NetworkBehaviourILPP will override this in derived classes to return the name of the concrete type
         internal virtual string __getTypeName() => nameof(NetworkBehaviour);
 
         [NonSerialized]
         // RuntimeAccessModifiersILPP will make this `protected`
-        internal __RpcExecStage __rpc_exec_stage = __RpcExecStage.None;
+        internal __RpcExecStage __rpc_exec_stage = __RpcExecStage.Send;
 #pragma warning restore IDE1006 // restore naming rule violation check
 
         private const int k_RpcMessageDefaultSize = 1024; // 1k
@@ -46,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
@@ -65,7 +89,7 @@ namespace Unity.Netcode
                     networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
                     break;
                 case RpcDelivery.Unreliable:
-                    if (bufferWriter.Length > MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE)
+                    if (bufferWriter.Length > networkManager.MessageManager.NonFragmentedMessageMaxSize)
                     {
                         throw new OverflowException("RPC parameters are too large for unreliable delivery.");
                     }
@@ -74,19 +98,19 @@ namespace Unity.Netcode
             }
 
             var rpcWriteSize = 0;
-
-            // If we are a server/host then we just no op and send to ourself
-            if (IsHost || IsServer)
+            // Authority just no ops and sends to itself
+            // Client-Server: Only the server-host sends to self
+            if (IsServer)
             {
                 using var tempBuffer = new FastBufferReader(bufferWriter, Allocator.Temp);
                 var context = new NetworkContext
                 {
                     SenderId = NetworkManager.ServerClientId,
-                    Timestamp = Time.realtimeSinceStartup,
-                    SystemOwner = NetworkManager,
+                    Timestamp = networkManager.RealTimeProvider.RealTimeSinceStartup,
+                    SystemOwner = networkManager,
                     // header information isn't valid since it's not a real message.
                     // RpcMessage doesn't access this stuff so it's just left empty.
-                    Header = new MessageHeader(),
+                    Header = new NetworkMessageHeader(),
                     SerializedHeaderSize = 0,
                     MessageSize = 0
                 };
@@ -96,13 +120,12 @@ namespace Unity.Netcode
             }
             else
             {
-                rpcWriteSize = NetworkManager.SendMessage(ref serverRpcMessage, networkDelivery, NetworkManager.ServerClientId);
+                rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref serverRpcMessage, networkDelivery, NetworkManager.ServerClientId);
             }
 
             bufferWriter.Dispose();
-
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (NetworkManager.__rpc_name_table.TryGetValue(rpcMethodId, out var rpcMethodName))
+            if (__rpc_name_table[GetType()].TryGetValue(rpcMethodId, out var rpcMethodName))
             {
                 NetworkManager.NetworkMetrics.TrackRpcSent(
                     NetworkManager.ServerClientId,
@@ -127,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
@@ -146,7 +170,7 @@ namespace Unity.Netcode
                     networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
                     break;
                 case RpcDelivery.Unreliable:
-                    if (bufferWriter.Length > MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE)
+                    if (bufferWriter.Length > networkManager.MessageManager.NonFragmentedMessageMaxSize)
                     {
                         throw new OverflowException("RPC parameters are too large for unreliable delivery.");
                     }
@@ -158,25 +182,23 @@ namespace Unity.Netcode
 
             // We check to see if we need to shortcut for the case where we are the host/server and we can send a clientRPC
             // to ourself. Sadly we have to figure that out from the list of clientIds :(
-            bool shouldSendToHost = false;
+            bool shouldInvokeLocally = false;
             if (clientRpcParams.Send.TargetClientIds != null)
             {
                 foreach (var targetClientId in clientRpcParams.Send.TargetClientIds)
                 {
                     if (targetClientId == NetworkManager.ServerClientId)
                     {
-                        shouldSendToHost = true;
-                        break;
+                        shouldInvokeLocally = true;
+                        continue;
                     }
-
                     // Check to make sure we are sending to only observers, if not log an error.
-                    if (NetworkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
+                    if (networkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
                     {
                         NetworkLog.LogError(GenerateObserverErrorMessage(clientRpcParams, targetClientId));
                     }
                 }
-
-                rpcWriteSize = NetworkManager.SendMessage(ref clientRpcMessage, networkDelivery, in clientRpcParams.Send.TargetClientIds);
+                rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, in clientRpcParams.Send.TargetClientIds);
             }
             else if (clientRpcParams.Send.TargetClientIdsNativeArray != null)
             {
@@ -184,18 +206,16 @@ namespace Unity.Netcode
                 {
                     if (targetClientId == NetworkManager.ServerClientId)
                     {
-                        shouldSendToHost = true;
-                        break;
+                        shouldInvokeLocally = true;
+                        continue;
                     }
-
                     // Check to make sure we are sending to only observers, if not log an error.
-                    if (NetworkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
+                    if (networkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
                     {
                         NetworkLog.LogError(GenerateObserverErrorMessage(clientRpcParams, targetClientId));
                     }
                 }
-
-                rpcWriteSize = NetworkManager.SendMessage(ref clientRpcMessage, networkDelivery, clientRpcParams.Send.TargetClientIdsNativeArray.Value);
+                rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, clientRpcParams.Send.TargetClientIdsNativeArray.Value);
             }
             else
             {
@@ -205,25 +225,25 @@ namespace Unity.Netcode
                     // Skip over the host
                     if (IsHost && observerEnumerator.Current == NetworkManager.LocalClientId)
                     {
-                        shouldSendToHost = true;
+                        shouldInvokeLocally = true;
                         continue;
                     }
-                    rpcWriteSize = NetworkManager.MessagingSystem.SendMessage(ref clientRpcMessage, networkDelivery, observerEnumerator.Current);
+                    rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, observerEnumerator.Current);
                 }
             }
 
             // 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 = Time.realtimeSinceStartup,
-                    SystemOwner = NetworkManager,
+                    Timestamp = networkManager.RealTimeProvider.RealTimeSinceStartup,
+                    SystemOwner = networkManager,
                     // header information isn't valid since it's not a real message.
                     // RpcMessage doesn't access this stuff so it's just left empty.
-                    Header = new MessageHeader(),
+                    Header = new NetworkMessageHeader(),
                     SerializedHeaderSize = 0,
                     MessageSize = 0
                 };
@@ -232,15 +252,14 @@ namespace Unity.Netcode
             }
 
             bufferWriter.Dispose();
-
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (NetworkManager.__rpc_name_table.TryGetValue(rpcMethodId, out var rpcMethodName))
+            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,
@@ -252,7 +271,7 @@ namespace Unity.Netcode
                 {
                     foreach (var targetClientId in clientRpcParams.Send.TargetClientIdsNativeArray)
                     {
-                        NetworkManager.NetworkMetrics.TrackRpcSent(
+                        networkManager.NetworkMetrics.TrackRpcSent(
                             targetClientId,
                             NetworkObject,
                             rpcMethodName,
@@ -265,7 +284,7 @@ namespace Unity.Netcode
                     var observerEnumerator = NetworkObject.Observers.GetEnumerator();
                     while (observerEnumerator.MoveNext())
                     {
-                        NetworkManager.NetworkMetrics.TrackRpcSent(
+                        networkManager.NetworkMetrics.TrackRpcSent(
                             observerEnumerator.Current,
                             NetworkObject,
                             rpcMethodName,
@@ -277,6 +296,113 @@ namespace Unity.Netcode
 #endif
         }
 
+
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal FastBufferWriter __beginSendRpc(uint rpcMethodId, RpcParams rpcParams, RpcAttribute.RpcAttributeParams attributeParams, SendTo defaultTarget, RpcDelivery rpcDelivery)
+#pragma warning restore IDE1006 // restore naming rule violation check
+        {
+            if (attributeParams.RequireOwnership && !IsOwner)
+            {
+                throw new RpcException("This RPC can only be sent by its owner.");
+            }
+            return new FastBufferWriter(k_RpcMessageDefaultSize, Allocator.Temp, k_RpcMessageMaximumSize);
+        }
+
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal void __endSendRpc(ref FastBufferWriter bufferWriter, uint rpcMethodId, RpcParams rpcParams, RpcAttribute.RpcAttributeParams attributeParams, SendTo defaultTarget, RpcDelivery rpcDelivery)
+#pragma warning restore IDE1006 // restore naming rule violation check
+        {
+            var rpcMessage = new RpcMessage
+            {
+                Metadata = new RpcMetadata
+                {
+                    NetworkObjectId = NetworkObjectId,
+                    NetworkBehaviourId = NetworkBehaviourId,
+                    NetworkRpcMethodId = rpcMethodId,
+                },
+                SenderClientId = NetworkManager.LocalClientId,
+                WriteBuffer = bufferWriter
+            };
+
+            NetworkDelivery networkDelivery;
+            switch (rpcDelivery)
+            {
+                default:
+                case RpcDelivery.Reliable:
+                    networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
+                    break;
+                case RpcDelivery.Unreliable:
+                    if (bufferWriter.Length > NetworkManager.MessageManager.NonFragmentedMessageMaxSize)
+                    {
+                        throw new OverflowException("RPC parameters are too large for unreliable delivery.");
+                    }
+                    networkDelivery = NetworkDelivery.Unreliable;
+                    break;
+            }
+
+            if (rpcParams.Send.Target == null)
+            {
+                switch (defaultTarget)
+                {
+                    case SendTo.Everyone:
+                        rpcParams.Send.Target = RpcTarget.Everyone;
+                        break;
+                    case SendTo.Owner:
+                        rpcParams.Send.Target = RpcTarget.Owner;
+                        break;
+                    case SendTo.Server:
+                        rpcParams.Send.Target = RpcTarget.Server;
+                        break;
+                    case SendTo.NotServer:
+                        rpcParams.Send.Target = RpcTarget.NotServer;
+                        break;
+                    case SendTo.NotMe:
+                        rpcParams.Send.Target = RpcTarget.NotMe;
+                        break;
+                    case SendTo.NotOwner:
+                        rpcParams.Send.Target = RpcTarget.NotOwner;
+                        break;
+                    case SendTo.Me:
+                        rpcParams.Send.Target = RpcTarget.Me;
+                        break;
+                    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.");
+                }
+            }
+            else if (defaultTarget != SendTo.SpecifiedInParams && !attributeParams.AllowTargetOverride)
+            {
+                throw new RpcException("Target override is not allowed for this method.");
+            }
+
+            if (rpcParams.Send.LocalDeferMode == LocalDeferMode.Default)
+            {
+                rpcParams.Send.LocalDeferMode = attributeParams.DeferLocal ? LocalDeferMode.Defer : LocalDeferMode.SendImmediate;
+            }
+
+            rpcParams.Send.Target.Send(this, ref rpcMessage, networkDelivery, rpcParams);
+
+            bufferWriter.Dispose();
+        }
+
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal static NativeList<T> __createNativeList<T>() where T : unmanaged
+#pragma warning restore IDE1006 // restore naming rule violation check
+        {
+            return new NativeList<T>(Allocator.Temp);
+        }
+
         internal string GenerateObserverErrorMessage(ClientRpcParams clientRpcParams, ulong targetClientId)
         {
             var containerNameHoldingId = clientRpcParams.Send.TargetClientIds != null ? nameof(ClientRpcParams.Send.TargetClientIds) : nameof(ClientRpcParams.Send.TargetClientIdsNativeArray);
@@ -300,6 +426,24 @@ namespace Unity.Netcode
             }
         }
 
+        // This erroneously tries to simplify these method references but the docs do not pick it up correctly
+        // because they try to resolve it on the field rather than the class of the same name.
+#pragma warning disable IDE0001
+        /// <summary>
+        /// Provides access to the various <see cref="SendTo"/> targets at runtime, as well as
+        /// runtime-bound targets like <see cref="Unity.Netcode.RpcTarget.Single"/>,
+        /// <see cref="Unity.Netcode.RpcTarget.Group(NativeArray{ulong})"/>,
+        /// <see cref="Unity.Netcode.RpcTarget.Group(NativeList{ulong})"/>,
+        /// <see cref="Unity.Netcode.RpcTarget.Group(ulong[])"/>,
+        /// <see cref="Unity.Netcode.RpcTarget.Group{T}(T)"/>, <see cref="Unity.Netcode.RpcTarget.Not(ulong)"/>,
+        /// <see cref="Unity.Netcode.RpcTarget.Not(NativeArray{ulong})"/>,
+        /// <see cref="Unity.Netcode.RpcTarget.Not(NativeList{ulong})"/>,
+        /// <see cref="Unity.Netcode.RpcTarget.Not(ulong[])"/>, and
+        /// <see cref="Unity.Netcode.RpcTarget.Not{T}(T)"/>
+        /// </summary>
+#pragma warning restore IDE0001
+        public RpcTarget RpcTarget => NetworkManager.RpcTarget;
+
         /// <summary>
         /// If a NetworkObject is assigned, it will return whether or not this NetworkObject
         /// is the local player object.  If no NetworkObject is assigned it will always return false.
@@ -316,6 +460,36 @@ 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>
+        public bool ServerIsHost { get; private set; }
+
         /// <summary>
         /// Gets if we are executing as client
         /// </summary>
@@ -360,12 +534,14 @@ namespace Unity.Netcode
         {
             get
             {
+                if (m_NetworkObject != null)
+                {
+                    return m_NetworkObject;
+                }
+
                 try
                 {
-                    if (m_NetworkObject == null)
-                    {
-                        m_NetworkObject = GetComponentInParent<NetworkObject>();
-                    }
+                    m_NetworkObject = GetComponentInParent<NetworkObject>();
                 }
                 catch (Exception)
                 {
@@ -434,39 +610,56 @@ namespace Unity.Netcode
         /// </summary>
         internal void UpdateNetworkProperties()
         {
+            var networkObject = NetworkObject;
             // Set NetworkObject dependent properties
-            if (NetworkObject != null)
+            if (networkObject != null)
             {
+                var networkManager = NetworkManager;
                 // Set identification related properties
-                NetworkObjectId = NetworkObject.NetworkObjectId;
-                IsLocalPlayer = NetworkObject.IsLocalPlayer;
+                NetworkObjectId = networkObject.NetworkObjectId;
+                IsLocalPlayer = networkObject.IsLocalPlayer;
 
                 // This is "OK" because GetNetworkBehaviourOrderIndex uses the order of
                 // NetworkObject.ChildNetworkBehaviours which is set once when first
                 // accessed.
-                NetworkBehaviourId = NetworkObject.GetNetworkBehaviourOrderIndex(this);
+                NetworkBehaviourId = networkObject.GetNetworkBehaviourOrderIndex(this);
 
                 // Set ownership related properties
-                IsOwnedByServer = NetworkObject.IsOwnedByServer;
-                IsOwner = NetworkObject.IsOwner;
-                OwnerClientId = NetworkObject.OwnerClientId;
+                IsOwnedByServer = networkObject.IsOwnedByServer;
+                IsOwner = networkObject.IsOwner;
+                OwnerClientId = networkObject.OwnerClientId;
 
                 // Set NetworkManager dependent properties
-                if (NetworkManager != null)
+                if (networkManager != null)
                 {
-                    IsHost = NetworkManager.IsListening && NetworkManager.IsHost;
-                    IsClient = NetworkManager.IsListening && NetworkManager.IsClient;
-                    IsServer = NetworkManager.IsListening && NetworkManager.IsServer;
+                    IsHost = networkManager.IsListening && networkManager.IsHost;
+                    IsClient = networkManager.IsListening && networkManager.IsClient;
+                    IsServer = networkManager.IsListening && networkManager.IsServer;
+                    LocalClient = networkManager.LocalClient;
+                    HasAuthority = networkObject.HasAuthority;
+                    ServerIsHost = networkManager.IsListening && networkManager.ServerIsHost;
                 }
             }
             else // Shouldn't happen, but if so then set the properties to their default value;
             {
                 OwnerClientId = NetworkObjectId = default;
-                IsOwnedByServer = IsOwner = IsHost = IsClient = IsServer = default;
+                IsOwnedByServer = IsOwner = IsHost = IsClient = IsServer = ServerIsHost = default;
                 NetworkBehaviourId = default;
+                LocalClient = default;
+                HasAuthority = default;
             }
         }
 
+        /// <summary>
+        /// Distributed Authority Mode Only
+        /// Invoked only on the authority instance when a <see cref="NetworkObject"/> is deferring its despawn on non-authoritative instances.
+        /// </summary>
+        /// <remarks>
+        /// See also: <see cref="NetworkObject.DeferDespawn(int, bool)"/>
+        /// </remarks>
+        /// <param name="despawnTick">the future network tick that the <see cref="NetworkObject"/> will be despawned on non-authoritative instances</param>
+        public virtual void OnDeferringDespawn(int despawnTick) { }
+
         /// <summary>
         /// Gets called when the <see cref="NetworkObject"/> gets spawned, message handlers are ready to be registered and the network is setup.
         /// </summary>
@@ -496,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.
@@ -530,6 +724,23 @@ namespace Unity.Netcode
             OnGainedOwnership();
         }
 
+        /// <summary>
+        /// Invoked on all clients, override this method to be notified of any
+        /// ownership changes (even if the instance was niether the previous or
+        /// newly assigned current owner).
+        /// </summary>
+        /// <param name="previous">the previous owner</param>
+        /// <param name="current">the current owner</param>
+        protected virtual void OnOwnershipChanged(ulong previous, ulong current)
+        {
+
+        }
+
+        internal void InternalOnOwnershipChanged(ulong previous, ulong current)
+        {
+            OnOwnershipChanged(previous, current);
+        }
+
         /// <summary>
         /// Gets called when we loose ownership of this object
         /// </summary>
@@ -551,38 +762,44 @@ namespace Unity.Netcode
 
         private readonly List<HashSet<int>> m_DeliveryMappedNetworkVariableIndices = new List<HashSet<int>>();
         private readonly List<NetworkDelivery> m_DeliveryTypesForNetworkVariableGroups = new List<NetworkDelivery>();
+
+        // RuntimeAccessModifiersILPP will make this `protected`
         internal readonly List<NetworkVariableBase> NetworkVariableFields = new List<NetworkVariableBase>();
 
-        private static Dictionary<Type, FieldInfo[]> s_FieldTypes = new Dictionary<Type, FieldInfo[]>();
-
-        private static FieldInfo[] GetFieldInfoForType(Type type)
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal virtual void __initializeVariables()
+#pragma warning restore IDE1006 // restore naming rule violation check
         {
-            if (!s_FieldTypes.ContainsKey(type))
-            {
-                s_FieldTypes.Add(type, GetFieldInfoForTypeRecursive(type));
-            }
-
-            return s_FieldTypes[type];
+            // ILPP generates code for all NetworkBehaviour subtypes to initialize each type's network variables.
         }
 
-        private static FieldInfo[] GetFieldInfoForTypeRecursive(Type type, List<FieldInfo> list = null)
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal virtual void __initializeRpcs()
+#pragma warning restore IDE1006 // restore naming rule violation check
         {
-            if (list == null)
-            {
-                list = new List<FieldInfo>();
-                list.AddRange(type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
-            }
-            else
-            {
-                list.AddRange(type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
-            }
+            // ILPP generates code for all NetworkBehaviour subtypes to initialize each type's RPCs.
+        }
 
-            if (type.BaseType != null && type.BaseType != typeof(NetworkBehaviour))
-            {
-                return GetFieldInfoForTypeRecursive(type.BaseType, list);
-            }
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal void __registerRpc(uint hash, RpcReceiveHandler handler, string rpcMethodName)
+#pragma warning restore IDE1006 // restore naming rule violation check
+        {
+            __rpc_func_table[GetType()][hash] = handler;
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+            __rpc_name_table[GetType()][hash] = rpcMethodName;
+#endif
+        }
 
-            return list.OrderBy(x => x.Name, StringComparer.Ordinal).ToArray();
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        // Using this method here because ILPP doesn't seem to let us do visibility modification on properties.
+        internal void __nameNetworkVariable(NetworkVariableBase variable, string varName)
+#pragma warning restore IDE1006 // restore naming rule violation check
+        {
+            variable.Name = varName;
         }
 
         internal void InitializeVariables()
@@ -594,28 +811,15 @@ namespace Unity.Netcode
 
             m_VarInit = true;
 
-            var sortedFields = GetFieldInfoForType(GetType());
-            for (int i = 0; i < sortedFields.Length; i++)
+            if (!__rpc_func_table.ContainsKey(GetType()))
             {
-                var fieldType = sortedFields[i].FieldType;
-                if (fieldType.IsSubclassOf(typeof(NetworkVariableBase)))
-                {
-                    var instance = (NetworkVariableBase)sortedFields[i].GetValue(this);
-
-                    if (instance == null)
-                    {
-                        throw new Exception($"{GetType().FullName}.{sortedFields[i].Name} cannot be null. All {nameof(NetworkVariableBase)} instances must be initialized.");
-                    }
-
-                    instance.Initialize(this);
-
-                    var instanceNameProperty = fieldType.GetProperty(nameof(NetworkVariableBase.Name));
-                    var sanitizedVariableName = sortedFields[i].Name.Replace("<", string.Empty).Replace(">k__BackingField", string.Empty);
-                    instanceNameProperty?.SetValue(instance, sanitizedVariableName);
-
-                    NetworkVariableFields.Add(instance);
-                }
+                __rpc_func_table[GetType()] = new Dictionary<uint, RpcReceiveHandler>();
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
+                __rpc_name_table[GetType()] = new Dictionary<uint, string>();
+#endif
+                __initializeRpcs();
             }
+            __initializeVariables();
 
             {
                 // Create index map for delivery types
@@ -682,65 +886,83 @@ namespace Unity.Netcode
             PreNetworkVariableWrite();
         }
 
-        internal void VariableUpdate(ulong targetClientId)
-        {
-            NetworkVariableUpdate(targetClientId, NetworkBehaviourId);
-        }
-
         internal readonly List<int> NetworkVariableIndexesToReset = new List<int>();
         internal readonly HashSet<int> NetworkVariableIndexesToResetSet = new HashSet<int>();
 
-        private void NetworkVariableUpdate(ulong targetClientId, int behaviourIndex)
+        internal void NetworkVariableUpdate(ulong targetClientId)
         {
             if (!CouldHaveDirtyNetworkVariables())
             {
                 return;
             }
 
+            // Getting these ahead of time actually improves performance
+            var networkManager = NetworkManager;
+            var networkObject = NetworkObject;
+            var behaviourIndex = networkObject.GetNetworkBehaviourOrderIndex(this);
+            var messageManager = networkManager.MessageManager;
+            var connectionManager = networkManager.ConnectionManager;
+
             for (int j = 0; j < m_DeliveryMappedNetworkVariableIndices.Count; j++)
             {
+                var networkVariable = (NetworkVariableBase)null;
                 var shouldSend = false;
                 for (int k = 0; k < NetworkVariableFields.Count; k++)
                 {
-                    var networkVariable = NetworkVariableFields[k];
+                    networkVariable = NetworkVariableFields[k];
                     if (networkVariable.IsDirty() && networkVariable.CanClientRead(targetClientId))
                     {
                         shouldSend = true;
                         break;
                     }
                 }
-
-                if (shouldSend)
+                // All of this is just to prevent the DA Host from re-sending a NetworkVariable update it received from the client owner
+                // If this NetworkManager is running as a DAHost:
+                // - Only when the write permissions is owner (to pass existing integration tests running as DAHost)
+                // - If the target client ID is the owner and the owner is not the local NetworkManager instance
+                // - **Special** As long as ownership did not just change and we are sending the new owner any dirty/updated NetworkVariables
+                // Under these conditions we should not send to the client
+                if (shouldSend && networkManager.DAHost && networkVariable.WritePerm == NetworkVariableWritePermission.Owner &&
+                    networkObject.OwnerClientId == targetClientId && networkObject.OwnerClientId != networkManager.LocalClientId &&
+                    networkObject.PreviousOwnerId == networkObject.OwnerClientId)
                 {
-                    var message = new NetworkVariableDeltaMessage
+                    shouldSend = false;
+                }
+
+                if (!shouldSend)
+                {
+                    continue;
+                }
+                var message = new NetworkVariableDeltaMessage
+                {
+                    NetworkObjectId = NetworkObjectId,
+                    NetworkBehaviourIndex = behaviourIndex,
+                    NetworkBehaviour = this,
+                    TargetClientId = targetClientId,
+                    DeliveryMappedNetworkVariableIndex = m_DeliveryMappedNetworkVariableIndices[j]
+                };
+                // TODO: Serialization is where the IsDirty flag gets changed.
+                // Messages don't get sent from the server to itself, so if we're host and sending to ourselves,
+                // we still have to actually serialize the message even though we're not sending it, otherwise
+                // the dirty flag doesn't change properly. These two pieces should be decoupled at some point
+                // so we don't have to do this serialization work if we're not going to use the result.
+                if (IsServer && targetClientId == NetworkManager.ServerClientId)
+                {
+                    var tmpWriter = new FastBufferWriter(messageManager.NonFragmentedMessageMaxSize, Allocator.Temp, messageManager.FragmentedMessageMaxSize);
+                    using (tmpWriter)
                     {
-                        NetworkObjectId = NetworkObjectId,
-                        NetworkBehaviourIndex = NetworkObject.GetNetworkBehaviourOrderIndex(this),
-                        NetworkBehaviour = this,
-                        TargetClientId = targetClientId,
-                        DeliveryMappedNetworkVariableIndex = m_DeliveryMappedNetworkVariableIndices[j]
-                    };
-                    // TODO: Serialization is where the IsDirty flag gets changed.
-                    // Messages don't get sent from the server to itself, so if we're host and sending to ourselves,
-                    // we still have to actually serialize the message even though we're not sending it, otherwise
-                    // the dirty flag doesn't change properly. These two pieces should be decoupled at some point
-                    // so we don't have to do this serialization work if we're not going to use the result.
-                    if (IsServer && targetClientId == NetworkManager.ServerClientId)
-                    {
-                        var tmpWriter = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, MessagingSystem.FRAGMENTED_MESSAGE_MAX_SIZE);
-                        using (tmpWriter)
-                        {
-                            message.Serialize(tmpWriter, message.Version);
-                        }
-                    }
-                    else
-                    {
-                        NetworkManager.SendMessage(ref message, m_DeliveryTypesForNetworkVariableGroups[j], targetClientId);
+                        message.Serialize(tmpWriter, message.Version);
                     }
                 }
+                else
+                {
+                    connectionManager.SendMessage(ref message, m_DeliveryTypesForNetworkVariableGroups[j], targetClientId);
+                }
             }
         }
 
+        internal static bool LogSentVariableUpdateMessage;
+
         private bool CouldHaveDirtyNetworkVariables()
         {
             // TODO: There should be a better way by reading one dirty variable vs. 'n'
@@ -773,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
@@ -804,10 +1039,13 @@ namespace Unity.Netcode
                         NetworkVariableFields[j].WriteField(writer);
                     }
                 }
-                else // Only if EnsureNetworkVariableLengthSafety, otherwise just skip
-                if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                else
                 {
-                    writer.WriteValueSafe((ushort)0);
+                    // Only if EnsureNetworkVariableLengthSafety, otherwise just skip
+                    if (networkManager.DistributedAuthorityMode || networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                    {
+                        writer.WriteValueSafe((ushort)0);
+                    }
                 }
             }
         }
@@ -822,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)
@@ -843,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))
                     {
@@ -899,11 +1173,23 @@ namespace Unity.Netcode
         /// Either BufferSerializerReader or BufferSerializerWriter, depending whether the serializer
         /// is in read mode or write mode.
         /// </typeparam>
+        /// <param name="targetClientId">the relative client identifier being synchronized</param>
         protected virtual void OnSynchronize<T>(ref BufferSerializer<T> serializer) where T : IReaderWriter
         {
 
         }
 
+        /// <summary>
+        /// The relative client identifier targeted for the serialization of this <see cref="NetworkBehaviour"/> instance.
+        /// </summary>
+        /// <remarks>
+        /// This value will be set prior to <see cref="OnSynchronize{T}(ref BufferSerializer{T})"/> being invoked.
+        /// For writing (server-side), this is useful to know which client will receive the serialized data.
+        /// For reading (client-side), this will be the <see cref="NetworkManager.LocalClientId"/>.
+        /// When synchronization of this instance is complete, this value will be reset to 0
+        /// </remarks>
+        protected ulong m_TargetIdBeingSynchronized { get; private set; }
+
         /// <summary>
         /// Internal method that determines if a NetworkBehaviour has additional synchronization data to
         /// be synchronized when first instantiated prior to its associated NetworkObject being spawned.
@@ -913,8 +1199,9 @@ namespace Unity.Netcode
         /// synchronize any remaining NetworkBehaviours.
         /// </remarks>
         /// <returns>true if it wrote synchronization data and false if it did not</returns>
-        internal bool Synchronize<T>(ref BufferSerializer<T> serializer) where T : IReaderWriter
+        internal bool Synchronize<T>(ref BufferSerializer<T> serializer, ulong targetClientId = 0) where T : IReaderWriter
         {
+            m_TargetIdBeingSynchronized = targetClientId;
             if (serializer.IsWriter)
             {
                 // Get the writer to handle seeking and determining how many bytes were written
@@ -949,10 +1236,14 @@ namespace Unity.Netcode
                 }
                 var finalPosition = writer.Position;
 
+                // Reset before exiting
+                m_TargetIdBeingSynchronized = default;
                 // If we wrote nothing then skip writing anything for this NetworkBehaviour
                 if (finalPosition == positionBeforeSynchronize || threwException)
                 {
                     writer.Seek(positionBeforeWrite);
+                    // Truncate back to the size before
+                    writer.Truncate();
                     return false;
                 }
                 else
@@ -997,11 +1288,14 @@ 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;
                 }
 
+                // Reset before exiting
+                m_TargetIdBeingSynchronized = default;
+
                 // Skip over the entry if deserialization fails
                 if (synchronizationError)
                 {

Runtime/Core/NetworkBehaviourUpdater.cs

@@ -8,6 +8,8 @@ namespace Unity.Netcode
     /// </summary>
     public class NetworkBehaviourUpdater
     {
+        private NetworkManager m_NetworkManager;
+        private NetworkConnectionManager m_ConnectionManager;
         private HashSet<NetworkObject> m_DirtyNetworkObjects = new HashSet<NetworkObject>();
 
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
@@ -19,7 +21,7 @@ namespace Unity.Netcode
             m_DirtyNetworkObjects.Add(networkObject);
         }
 
-        internal void NetworkBehaviourUpdate(NetworkManager networkManager)
+        internal void NetworkBehaviourUpdate()
         {
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             m_NetworkBehaviourUpdate.Begin();
@@ -30,7 +32,7 @@ namespace Unity.Netcode
                 // trying to process them, even if they were previously marked as dirty.
                 m_DirtyNetworkObjects.RemoveWhere((sobj) => sobj == null);
 
-                if (networkManager.IsServer)
+                if (m_ConnectionManager.LocalClient.IsServer)
                 {
                     foreach (var dirtyObj in m_DirtyNetworkObjects)
                     {
@@ -39,16 +41,15 @@ namespace Unity.Netcode
                             dirtyObj.ChildNetworkBehaviours[k].PreVariableUpdate();
                         }
 
-                        for (int i = 0; i < networkManager.ConnectedClientsList.Count; i++)
+                        for (int i = 0; i < m_ConnectionManager.ConnectedClientsList.Count; i++)
                         {
-                            var client = networkManager.ConnectedClientsList[i];
-
-                            if (dirtyObj.IsNetworkVisibleTo(client.ClientId))
+                            var client = m_ConnectionManager.ConnectedClientsList[i];
+                            if (m_NetworkManager.DistributedAuthorityMode || dirtyObj.IsNetworkVisibleTo(client.ClientId))
                             {
                                 // Sync just the variables for just the objects this client sees
                                 for (int k = 0; k < dirtyObj.ChildNetworkBehaviours.Count; k++)
                                 {
-                                    dirtyObj.ChildNetworkBehaviours[k].VariableUpdate(client.ClientId);
+                                    dirtyObj.ChildNetworkBehaviours[k].NetworkVariableUpdate(client.ClientId);
                                 }
                             }
                         }
@@ -67,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);
                             }
                         }
                     }
@@ -93,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();
             }
@@ -104,5 +107,26 @@ namespace Unity.Netcode
             }
         }
 
+        internal void Initialize(NetworkManager networkManager)
+        {
+            m_NetworkManager = networkManager;
+            m_ConnectionManager = networkManager.ConnectionManager;
+            m_NetworkManager.NetworkTickSystem.Tick += NetworkBehaviourUpdater_Tick;
+        }
+
+        internal void Shutdown()
+        {
+            m_NetworkManager.NetworkTickSystem.Tick -= NetworkBehaviourUpdater_Tick;
+        }
+
+        // Order of operations requires NetworkVariable updates first then showing NetworkObjects
+        private void NetworkBehaviourUpdater_Tick()
+        {
+            // First update NetworkVariables
+            NetworkBehaviourUpdate();
+
+            // Then show any NetworkObjects queued to be made visible/shown
+            m_NetworkManager.SpawnManager.HandleNetworkObjectShow();
+        }
     }
 }

Runtime/Core/NetworkObjectRefreshTool.cs

@@ -0,0 +1,118 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// This is a helper tool to update all in-scene placed instances of a prefab that 
+    /// originally did not have a NetworkObject component but one was added to the prefab
+    /// later.
+    /// </summary>
+    internal class NetworkObjectRefreshTool
+    {
+        private static List<string> s_ScenesToUpdate = new List<string>();
+        private static bool s_ProcessScenes;
+        private static bool s_CloseScenes;
+
+        internal static Action AllScenesProcessed;
+
+        internal static void ProcessScene(string scenePath, bool processScenes = true)
+        {
+            if (!s_ScenesToUpdate.Contains(scenePath))
+            {
+                if (s_ScenesToUpdate.Count == 0)
+                {
+                    EditorSceneManager.sceneOpened += EditorSceneManager_sceneOpened;
+                    EditorSceneManager.sceneSaved += EditorSceneManager_sceneSaved;
+                }
+                s_ScenesToUpdate.Add(scenePath);
+            }
+            s_ProcessScenes = processScenes;
+        }
+
+        internal static void ProcessActiveScene()
+        {
+            var activeScene = SceneManager.GetActiveScene();
+            if (s_ScenesToUpdate.Contains(activeScene.path) && s_ProcessScenes)
+            {
+                SceneOpened(activeScene);
+            }
+        }
+
+        internal static void ProcessScenes()
+        {
+            if (s_ScenesToUpdate.Count != 0)
+            {
+                s_CloseScenes = true;
+                var scenePath = s_ScenesToUpdate.First();
+                EditorSceneManager.OpenScene(scenePath, OpenSceneMode.Additive);
+            }
+            else
+            {
+                s_CloseScenes = false;
+                EditorSceneManager.sceneSaved -= EditorSceneManager_sceneSaved;
+                EditorSceneManager.sceneOpened -= EditorSceneManager_sceneOpened;
+                AllScenesProcessed?.Invoke();
+            }
+        }
+
+        private static void FinishedProcessingScene(Scene scene, bool refreshed = false)
+        {
+            if (s_ScenesToUpdate.Contains(scene.path))
+            {
+                // Provide a log of all scenes that were modified to the user
+                if (refreshed)
+                {
+                    Debug.Log($"Refreshed and saved updates to scene: {scene.name}");
+                }
+                s_ProcessScenes = false;
+                s_ScenesToUpdate.Remove(scene.path);
+
+                if (scene != SceneManager.GetActiveScene())
+                {
+                    EditorSceneManager.CloseScene(scene, s_CloseScenes);
+                }
+                ProcessScenes();
+            }
+        }
+
+        private static void EditorSceneManager_sceneSaved(Scene scene)
+        {
+            FinishedProcessingScene(scene, true);
+        }
+
+        private static void SceneOpened(Scene scene)
+        {
+            if (s_ScenesToUpdate.Contains(scene.path))
+            {
+                if (s_ProcessScenes)
+                {
+                    if (!EditorSceneManager.MarkSceneDirty(scene))
+                    {
+                        Debug.Log($"Scene {scene.name} did not get marked as dirty!");
+                        FinishedProcessingScene(scene);
+                    }
+                    else
+                    {
+                        EditorSceneManager.SaveScene(scene);
+                    }
+                }
+                else
+                {
+                    FinishedProcessingScene(scene);
+                }
+            }
+        }
+
+        private static void EditorSceneManager_sceneOpened(Scene scene, OpenSceneMode mode)
+        {
+            SceneOpened(scene);
+        }
+    }
+}
+#endif // UNITY_EDITOR

Runtime/Core/NetworkObjectRefreshTool.cs.meta

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

Runtime/Core/NetworkUpdateLoop.cs

@@ -167,7 +167,7 @@ namespace Unity.Netcode
         /// </summary>
         public static NetworkUpdateStage UpdateStage;
 
-        private static void RunNetworkUpdateStage(NetworkUpdateStage updateStage)
+        internal static void RunNetworkUpdateStage(NetworkUpdateStage updateStage)
         {
             UpdateStage = updateStage;
 

Runtime/Hashing/XXHash.cs

@@ -1,6 +1,6 @@
 using System;
-using System.Text;
 using System.Runtime.CompilerServices;
+using System.Text;
 
 namespace Unity.Netcode
 {

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>
@@ -51,41 +57,76 @@ namespace Unity.Netcode
         /// <param name="message">The message to log</param>
         public static void LogErrorServer(string message) => LogServer(message, LogType.Error);
 
+        internal static NetworkManager NetworkManagerOverride;
+
         private static void LogServer(string message, LogType logType)
         {
+            var networkManager = NetworkManagerOverride ??= NetworkManager.Singleton;
             // Get the sender of the local log
-            ulong localId = NetworkManager.Singleton != null ? NetworkManager.Singleton.LocalClientId : 0;
-
+            ulong localId = networkManager?.LocalClientId ?? 0;
+            bool isServer = networkManager && networkManager.DistributedAuthorityMode ? networkManager.LocalClient.IsSessionOwner :
+                networkManager && !networkManager.DistributedAuthorityMode ? networkManager.IsServer : true;
             switch (logType)
             {
                 case LogType.Info:
-                    LogInfoServerLocal(message, localId);
+                    if (isServer)
+                    {
+                        LogInfoServerLocal(message, localId);
+                    }
+                    else
+                    {
+                        LogInfo(message);
+                    }
                     break;
                 case LogType.Warning:
-                    LogWarningServerLocal(message, localId);
+                    if (isServer)
+                    {
+                        LogWarningServerLocal(message, localId);
+                    }
+                    else
+                    {
+                        LogWarning(message);
+                    }
                     break;
                 case LogType.Error:
-                    LogErrorServerLocal(message, localId);
+                    if (isServer)
+                    {
+                        LogErrorServerLocal(message, localId);
+                    }
+                    else
+                    {
+                        LogError(message);
+                    }
                     break;
             }
 
-            if (NetworkManager.Singleton != null && !NetworkManager.Singleton.IsServer && NetworkManager.Singleton.NetworkConfig.EnableNetworkLogs)
+            if (!isServer && networkManager.NetworkConfig.EnableNetworkLogs)
             {
-
                 var networkMessage = new ServerLogMessage
                 {
                     LogType = logType,
-                    Message = message
+                    Message = message,
+                    SenderId = localId
                 };
-                var size = NetworkManager.Singleton.SendMessage(ref networkMessage, NetworkDelivery.ReliableFragmentedSequenced, NetworkManager.ServerClientId);
+                var size = networkManager.ConnectionManager.SendMessage(ref networkMessage, NetworkDelivery.ReliableFragmentedSequenced, NetworkManager.ServerClientId);
 
-                NetworkManager.Singleton.NetworkMetrics.TrackServerLogSent(NetworkManager.ServerClientId, (uint)logType, size);
+                networkManager.NetworkMetrics.TrackServerLogSent(NetworkManager.ServerClientId, (uint)logType, size);
             }
         }
 
-        internal static void LogInfoServerLocal(string message, ulong sender) => Debug.Log($"[Netcode-Server Sender={sender}] {message}");
-        internal static void LogWarningServerLocal(string message, ulong sender) => Debug.LogWarning($"[Netcode-Server Sender={sender}] {message}");
-        internal static void LogErrorServerLocal(string message, ulong sender) => Debug.LogError($"[Netcode-Server Sender={sender}] {message}");
+        private static string Header()
+        {
+            var networkManager = NetworkManagerOverride ??= NetworkManager.Singleton;
+            if (networkManager.DistributedAuthorityMode)
+            {
+                return "Session-Owner";
+            }
+            return "Netcode-Server";
+        }
+
+        internal static void LogInfoServerLocal(string message, ulong sender) => Debug.Log($"[{Header()} Sender={sender}] {message}");
+        internal static void LogWarningServerLocal(string message, ulong sender) => Debug.LogWarning($"[{Header()} Sender={sender}] {message}");
+        internal static void LogErrorServerLocal(string message, ulong sender) => Debug.LogError($"[{Header()} Sender={sender}] {message}");
 
         internal enum LogType : byte
         {

Runtime/Messaging/CustomMessageManager.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using Unity.Collections;
+using UnityEngine;
 
 namespace Unity.Netcode
 {
@@ -90,7 +91,7 @@ namespace Unity.Netcode
             {
                 SendData = messageBuffer
             };
-            var size = m_NetworkManager.SendMessage(ref message, networkDelivery, clientIds);
+            var size = m_NetworkManager.ConnectionManager.SendMessage(ref message, networkDelivery, clientIds);
 
             // Size is zero if we were only sending the message to ourself in which case it isn't sent.
             if (size != 0)
@@ -123,7 +124,7 @@ namespace Unity.Netcode
             {
                 SendData = messageBuffer
             };
-            var size = m_NetworkManager.SendMessage(ref message, networkDelivery, clientId);
+            var size = m_NetworkManager.ConnectionManager.SendMessage(ref message, networkDelivery, clientId);
             // Size is zero if we were only sending the message to ourself in which case it isn't sent.
             if (size != 0)
             {
@@ -191,6 +192,14 @@ namespace Unity.Netcode
         /// <param name="callback">The callback to run when a named message is received.</param>
         public void RegisterNamedMessageHandler(string name, HandleNamedMessageDelegate callback)
         {
+            if (string.IsNullOrEmpty(name))
+            {
+                if (m_NetworkManager.LogLevel <= LogLevel.Error)
+                {
+                    Debug.LogError($"[{nameof(RegisterNamedMessageHandler)}] Cannot register a named message of type null or empty!");
+                }
+                return;
+            }
             var hash32 = XXHash.Hash32(name);
             var hash64 = XXHash.Hash64(name);
 
@@ -207,6 +216,15 @@ namespace Unity.Netcode
         /// <param name="name">The name of the message.</param>
         public void UnregisterNamedMessageHandler(string name)
         {
+            if (string.IsNullOrEmpty(name))
+            {
+                if (m_NetworkManager.LogLevel <= LogLevel.Error)
+                {
+                    Debug.LogError($"[{nameof(UnregisterNamedMessageHandler)}] Cannot unregister a named message of type null or empty!");
+                }
+                return;
+            }
+
             var hash32 = XXHash.Hash32(name);
             var hash64 = XXHash.Hash64(name);
 
@@ -267,7 +285,7 @@ namespace Unity.Netcode
                 Hash = hash,
                 SendData = messageStream,
             };
-            var size = m_NetworkManager.SendMessage(ref message, networkDelivery, clientId);
+            var size = m_NetworkManager.ConnectionManager.SendMessage(ref message, networkDelivery, clientId);
 
             // Size is zero if we were only sending the message to ourself in which case it isn't sent.
             if (size != 0)
@@ -325,7 +343,7 @@ namespace Unity.Netcode
                 Hash = hash,
                 SendData = messageStream
             };
-            var size = m_NetworkManager.SendMessage(ref message, networkDelivery, clientIds);
+            var size = m_NetworkManager.ConnectionManager.SendMessage(ref message, networkDelivery, clientIds);
 
             // Size is zero if we were only sending the message to ourself in which case it isn't sent.
             if (size != 0)

Runtime/Messaging/DefaultMessageSender.cs

@@ -0,0 +1,26 @@
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// Default NetworkTransport Message Sender
+    /// <see cref="NetworkMessageManager"/>
+    /// </summary>
+    internal class DefaultMessageSender : INetworkMessageSender
+    {
+        private NetworkTransport m_NetworkTransport;
+        private NetworkConnectionManager m_ConnectionManager;
+
+        public DefaultMessageSender(NetworkManager manager)
+        {
+            m_NetworkTransport = manager.NetworkConfig.NetworkTransport;
+            m_ConnectionManager = manager.ConnectionManager;
+        }
+
+        public void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData)
+        {
+            var sendBuffer = batchData.ToTempByteArray();
+
+            m_NetworkTransport.Send(m_ConnectionManager.ClientIdToTransportId(clientId), sendBuffer, delivery);
+        }
+    }
+}

Runtime/Messaging/DefaultMessageSender.cs.meta

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

Runtime/Messaging/DeferredMessageManager.cs

@@ -1,26 +1,26 @@
 using System.Collections.Generic;
 using Unity.Collections;
-using Time = UnityEngine.Time;
 
 namespace Unity.Netcode
 {
-    internal class DeferredMessageManager : IDeferredMessageManager
+    internal class DeferredMessageManager : IDeferredNetworkMessageManager
     {
         protected struct TriggerData
         {
             public FastBufferReader Reader;
-            public MessageHeader Header;
+            public NetworkMessageHeader Header;
             public ulong SenderId;
             public float Timestamp;
             public int SerializedHeaderSize;
         }
         protected struct TriggerInfo
         {
+            public string MessageType;
             public float Expiry;
             public NativeList<TriggerData> TriggerData;
         }
 
-        protected readonly Dictionary<IDeferredMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>> m_Triggers = new Dictionary<IDeferredMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>>();
+        protected readonly Dictionary<IDeferredNetworkMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>> m_Triggers = new Dictionary<IDeferredNetworkMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>>();
 
         private readonly NetworkManager m_NetworkManager;
 
@@ -37,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(IDeferredMessageManager.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))
             {
@@ -49,7 +49,8 @@ namespace Unity.Netcode
             {
                 triggerInfo = new TriggerInfo
                 {
-                    Expiry = Time.realtimeSinceStartup + m_NetworkManager.NetworkConfig.SpawnTimeout,
+                    MessageType = messageType,
+                    Expiry = m_NetworkManager.RealTimeProvider.RealTimeSinceStartup + m_NetworkManager.NetworkConfig.SpawnTimeout,
                     TriggerData = new NativeList<TriggerData>(Allocator.Persistent)
                 };
                 triggers[key] = triggerInfo;
@@ -77,7 +78,7 @@ namespace Unity.Netcode
                 int index = 0;
                 foreach (var kvp2 in kvp.Value)
                 {
-                    if (kvp2.Value.Expiry < Time.realtimeSinceStartup)
+                    if (kvp2.Value.Expiry < m_NetworkManager.RealTimeProvider.RealTimeSinceStartup)
                     {
                         staleKeys[index++] = kvp2.Key;
                         PurgeTrigger(kvp.Key, kvp2.Key, kvp2.Value);
@@ -91,11 +92,29 @@ namespace Unity.Netcode
             }
         }
 
-        protected virtual void PurgeTrigger(IDeferredMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo)
+        /// <summary>
+        /// Used for testing purposes
+        /// </summary>
+        internal static bool IncludeMessageType = true;
+
+        private string GetWarningMessage(IDeferredNetworkMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo, float spawnTimeout)
         {
-            if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+            if (IncludeMessageType)
             {
-                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).");
+                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)
+        {
+            var logLevel = m_NetworkManager.DistributedAuthorityMode ? LogLevel.Developer : LogLevel.Normal;
+            if (NetworkLog.CurrentLogLevel <= logLevel)
+            {
+                NetworkLog.LogWarning(GetWarningMessage(triggerType, key, triggerInfo, m_NetworkManager.NetworkConfig.SpawnTimeout));
             }
 
             foreach (var data in triggerInfo.TriggerData)
@@ -106,7 +125,7 @@ namespace Unity.Netcode
             triggerInfo.TriggerData.Dispose();
         }
 
-        public virtual void ProcessTriggers(IDeferredMessageManager.TriggerType trigger, ulong key)
+        public virtual void ProcessTriggers(IDeferredNetworkMessageManager.TriggerType trigger, ulong key)
         {
             if (m_Triggers.TryGetValue(trigger, out var triggers))
             {
@@ -114,14 +133,14 @@ namespace Unity.Netcode
                 // processed before the object is fully spawned. This must be the last thing done in the spawn process.
                 if (triggers.TryGetValue(key, out var triggerInfo))
                 {
+                    triggers.Remove(key);
                     foreach (var deferredMessage in triggerInfo.TriggerData)
                     {
                         // Reader will be disposed within HandleMessage
-                        m_NetworkManager.MessagingSystem.HandleMessage(deferredMessage.Header, deferredMessage.Reader, deferredMessage.SenderId, deferredMessage.Timestamp, deferredMessage.SerializedHeaderSize);
+                        m_NetworkManager.ConnectionManager.MessageManager.HandleMessage(deferredMessage.Header, deferredMessage.Reader, deferredMessage.SenderId, deferredMessage.Timestamp, deferredMessage.SerializedHeaderSize);
                     }
 
                     triggerInfo.TriggerData.Dispose();
-                    triggers.Remove(key);
                 }
             }
         }

Runtime/Messaging/DisconnectReasonMessage.cs

@@ -8,17 +8,11 @@ namespace Unity.Netcode
 
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
-            string reasonSent = Reason;
-            if (reasonSent == null)
-            {
-                reasonSent = string.Empty;
-            }
+            string reasonSent = Reason ?? string.Empty;
 
-            // Since we don't send a ConnectionApprovedMessage, the version for this message is encded with the message
-            // itself. However, note that we HAVE received a ConnectionRequestMessage, so we DO have a valid targetVersion
-            // on this side of things - we just have to make sure the receiving side knows what version we sent it,
-            // since whoever has the higher version number is responsible for versioning and they may be the one
-            // with the higher version number.
+            // Since we don't send a ConnectionApprovedMessage, the version for this message is encded with the message itself.
+            // However, note that we HAVE received a ConnectionRequestMessage, so we DO have a valid targetVersion on this side of things.
+            // We just have to make sure the receiving side knows what version we sent it, since whoever has the higher version number is responsible for versioning and they may be the one with the higher version number.
             BytePacker.WriteValueBitPacked(writer, Version);
 
             if (writer.TryBeginWrite(FastBufferWriter.GetWriteSize(reasonSent)))
@@ -28,15 +22,14 @@ namespace Unity.Netcode
             else
             {
                 writer.WriteValueSafe(string.Empty);
-                NetworkLog.LogWarning(
-                    "Disconnect reason didn't fit. Disconnected without sending a reason. Consider shortening the reason string.");
+                NetworkLog.LogWarning("Disconnect reason didn't fit. Disconnected without sending a reason. Consider shortening the reason string.");
             }
         }
 
         public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
         {
-            // Since we don't get a ConnectionApprovedMessage, the version for this message is encded with the message
-            // itself. This will override what we got from MessagingSystem... which will always be 0 here.
+            // Since we don't get a ConnectionApprovedMessage, the version for this message is encded with the message itself.
+            // This will override what we got from MessageManager... which will always be 0 here.
             ByteUnpacker.ReadValueBitPacked(reader, out receivedMessageVersion);
             reader.ReadValueSafe(out Reason);
             return true;
@@ -44,7 +37,7 @@ namespace Unity.Netcode
 
         public void Handle(ref NetworkContext context)
         {
-            ((NetworkManager)context.SystemOwner).DisconnectReason = Reason;
+            ((NetworkManager)context.SystemOwner).ConnectionManager.DisconnectReason = Reason;
         }
     };
 }

Runtime/Messaging/GenerateSerializationForGenericParameterAttribute.cs

@@ -0,0 +1,82 @@
+using System;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// Marks a generic parameter in this class as a type that should be serialized through
+    /// <see cref="NetworkVariableSerialization{T}"/>. This enables the use of the following methods to support
+    /// serialization within a Network Variable type:
+    /// <br/>
+    /// <br/>
+    /// <see cref="NetworkVariableSerialization{T}"/>.<see cref="NetworkVariableSerialization{T}.Read"/>
+    /// <br/>
+    /// <see cref="NetworkVariableSerialization{T}"/>.<see cref="NetworkVariableSerialization{T}.Write"/>
+    /// <br/>
+    /// <see cref="NetworkVariableSerialization{T}"/>.<see cref="NetworkVariableSerialization{T}.AreEqual"/>
+    /// <br/>
+    /// <see cref="NetworkVariableSerialization{T}"/>.<see cref="NetworkVariableSerialization{T}.Duplicate"/>
+    /// <br/>
+    /// <br/>
+    /// The parameter is indicated by index (and is 0-indexed); for example:
+    /// <br/>
+    /// <code>
+    /// [SerializesGenericParameter(1)]
+    /// public class MyClass&lt;TTypeOne, TTypeTwo&gt;
+    /// {
+    /// }
+    /// </code>
+    /// <br/>
+    /// This tells the code generation for <see cref="NetworkVariableSerialization{T}"/> to generate
+    /// serialized code for <b>TTypeTwo</b> (generic parameter 1).
+    /// <br/>
+    /// <br/>
+    /// Note that this is primarily intended to support subtypes of <see cref="NetworkVariableBase"/>,
+    /// and as such, the type resolution is done by examining fields of <see cref="NetworkBehaviour"/>
+    /// subclasses. If your type is not used in a <see cref="NetworkBehaviour"/>, the codegen will
+    /// not find the types, even with this attribute.
+    /// <br/>
+    /// <br/>
+    /// This attribute is properly inherited by subclasses. For example:
+    /// <br/>
+    /// <code>
+    /// [SerializesGenericParameter(0)]
+    /// public class MyClass&lt;T&gt;
+    /// {
+    /// }
+    /// <br/>
+    /// public class MySubclass1 : MyClass&lt;Foo&gt;
+    /// {
+    /// }
+    /// <br/>
+    /// public class MySubclass2&lt;T&gt; : MyClass&lt;T&gt;
+    /// {
+    /// }
+    /// <br/>
+    /// [SerializesGenericParameter(1)]
+    /// public class MySubclass3&lt;TTypeOne, TTypeTwo&gt; : MyClass&lt;TTypeOne&gt;
+    /// {
+    /// }
+    /// <br/>
+    /// public class MyBehaviour : NetworkBehaviour
+    /// {
+    ///     public MySubclass1 TheValue;
+    ///     public MySubclass2&lt;Bar&gt; TheValue;
+    ///     public MySubclass3&lt;Baz, Qux&gt; TheValue;
+    /// }
+    /// </code>
+    /// <br/>
+    /// The above code will trigger generation of serialization code for <b>Foo</b> (passed directly to the
+    /// base class), <b>Bar</b> (passed indirectly to the base class), <b>Baz</b> (passed indirectly to the base class),
+    /// and <b>Qux</b> (marked as serializable in the subclass).
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = true)]
+    public class GenerateSerializationForGenericParameterAttribute : Attribute
+    {
+        internal int ParameterIndex;
+
+        public GenerateSerializationForGenericParameterAttribute(int parameterIndex)
+        {
+            ParameterIndex = parameterIndex;
+        }
+    }
+}

Runtime/Messaging/GenerateSerializationForGenericParameterAttribute.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 18cdaa9c2f6446279b0c5948fcd34eec
+timeCreated: 1694029524

Runtime/Messaging/GenerateSerializationForTypeAttribute.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// Specifies a specific type that needs serialization to be generated by codegen.
+    /// This is only needed in special circumstances where manual serialization is being done.
+    /// If you are making a generic network variable-style class, use <see cref="GenerateSerializationForGenericParameterAttribute"/>.
+    /// <br />
+    /// <br />
+    /// This attribute can be attached to any class or method anywhere in the codebase and
+    /// will trigger codegen to generate serialization code for the provided type. It only needs
+    /// to be included once type per codebase, but including it multiple times for the same type
+    /// is safe.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method, AllowMultiple = true)]
+    public class GenerateSerializationForTypeAttribute : Attribute
+    {
+        internal Type Type;
+
+        public GenerateSerializationForTypeAttribute(Type type)
+        {
+            Type = type;
+        }
+    }
+}

Runtime/Messaging/GenerateSerializationForTypeAttribute.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1bd80306706f4054b9ba514a72076df5
+timeCreated: 1694103021

Runtime/Messaging/IDeferredNetworkMessageManager.cs

@@ -1,11 +1,13 @@
+
 namespace Unity.Netcode
 {
-    internal interface IDeferredMessageManager
+    internal interface IDeferredNetworkMessageManager
     {
         internal enum TriggerType
         {
             OnSpawn,
             OnAddPrefab,
+            OnNextFrame,
         }
 
         /// <summary>
@@ -16,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/ILPPMessageProvider.cs

@@ -1,17 +1,39 @@
 using System.Collections.Generic;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
 
 namespace Unity.Netcode
 {
-    internal struct ILPPMessageProvider : IMessageProvider
+    internal struct ILPPMessageProvider : INetworkMessageProvider
     {
 #pragma warning disable IDE1006 // disable naming rule violation check
         // This is NOT modified by RuntimeAccessModifiersILPP right now, but is populated by ILPP.
-        internal static readonly List<MessagingSystem.MessageWithHandler> __network_message_types = new List<MessagingSystem.MessageWithHandler>();
+        internal static readonly List<NetworkMessageManager.MessageWithHandler> __network_message_types = new List<NetworkMessageManager.MessageWithHandler>();
 #pragma warning restore IDE1006 // restore naming rule violation check
 
-        public List<MessagingSystem.MessageWithHandler> GetMessages()
+        public List<NetworkMessageManager.MessageWithHandler> GetMessages()
         {
             return __network_message_types;
         }
+
+#if UNITY_EDITOR
+        [InitializeOnLoadMethod]
+        public static void NotifyOnPlayStateChange()
+        {
+            EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
+        }
+
+        public static void OnPlayModeStateChanged(PlayModeStateChange change)
+        {
+            if (change == PlayModeStateChange.ExitingPlayMode)
+            {
+                // Clear out the network message types, because ILPP-generated RuntimeInitializeOnLoad code will
+                // run again and add more messages to it.
+                __network_message_types.Clear();
+            }
+        }
+
+#endif
     }
 }

Runtime/Messaging/IMessageProvider.cs

@@ -1,9 +0,0 @@
-using System.Collections.Generic;
-
-namespace Unity.Netcode
-{
-    internal interface IMessageProvider
-    {
-        List<MessagingSystem.MessageWithHandler> GetMessages();
-    }
-}

Runtime/Messaging/INetworkMessage.cs

@@ -1,4 +1,3 @@
-using Unity.Collections;
 
 namespace Unity.Netcode
 {

Runtime/Messaging/INetworkMessageProvider.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace Unity.Netcode
+{
+    internal interface INetworkMessageProvider
+    {
+        List<NetworkMessageManager.MessageWithHandler> GetMessages();
+    }
+}

Runtime/Messaging/INetworkMessageSender.cs

@@ -1,6 +1,6 @@
 namespace Unity.Netcode
 {
-    internal interface IMessageSender
+    internal interface INetworkMessageSender
     {
         void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData);
     }

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,43 +158,240 @@ 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(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
-                return false;
+                ByteUnpacker.ReadValueBitPacked(reader, out ClientIdCount);
+                if (ClientIdCount > 0)
+                {
+                    ClientIds = new ulong[ClientIdCount];
+                    var clientId = (ulong)0;
+                    for (int i = 0; i < ClientIdCount; i++)
+                    {
+                        ByteUnpacker.ReadValueBitPacked(reader, out clientId);
+                        ClientIds[i] = clientId;
+                    }
+                }
+
+                reader.ReadValueSafe(out m_OwnershipMessageTypeFlags);
+                if (OwnershipFlagsUpdate || OwnershipIsChanging)
+                {
+                    reader.ReadValueSafe(out OwnershipFlags);
+                }
+
+                // When requesting, it is the requestor
+                // When approving, it is the owner that approved
+                // When denied, it is the requestor
+                if (RequestOwnership || RequestApproved || RequestDenied)
+                {
+                    reader.ReadValueSafe(out RequestClientId);
+
+                    if (RequestDenied)
+                    {
+                        reader.ReadValueSafe(out OwnershipRequestResponseStatus);
+                    }
+                }
             }
 
+            // If we are not a DAHost instance and the NetworkObject does not exist then defer it as it very likely is not spawned yet.
+            // Otherwise if we are the DAHost and it does not exist then we want to forward this message because when the NetworkObject
+            // is made visible again, the ownership flags and owner information will be synchronized with the DAHost by the current
+            // authority of the NetworkObject in question.
+            if (!networkManager.DAHost && !networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
+            {
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, GetType().Name);
+                return false;
+            }
             return true;
         }
 
         public void Handle(ref NetworkContext context)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
-            var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
-            var originalOwner = networkObject.OwnerClientId;
 
+            // If we are the DAHost then forward this message
+            if (networkManager.DAHost)
+            {
+                var clientList = ClientIdCount > 0 ? ClientIds : networkManager.ConnectedClientsIds;
+
+                var message = new ChangeOwnershipMessage()
+                {
+                    NetworkObjectId = NetworkObjectId,
+                    OwnerClientId = OwnerClientId,
+                    DistributedAuthorityMode = true,
+                    OwnershipFlags = OwnershipFlags,
+                    RequestClientId = RequestClientId,
+                    ClientIdCount = 0,
+                    m_OwnershipMessageTypeFlags = m_OwnershipMessageTypeFlags,
+                };
+
+                if (RequestDenied)
+                {
+                    // If the local DAHost's client is not the target, then forward to the target
+                    if (RequestClientId != networkManager.LocalClientId)
+                    {
+                        message.OwnershipRequestResponseStatus = OwnershipRequestResponseStatus;
+                        networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.Reliable, RequestClientId);
+                        // We don't want the local DAHost's client to process this message, so exit early
+                        return;
+                    }
+                }
+                else if (RequestOwnership)
+                {
+                    // If the DAHost client is not authority, just forward the message to the authority
+                    if (OwnerClientId != networkManager.LocalClientId)
+                    {
+                        networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.Reliable, OwnerClientId);
+                        // We don't want the local DAHost's client to process this message, so exit early
+                        return;
+                    }
+                    // Otherwise, fall through and process the request.
+                }
+                else
+                {
+                    foreach (var clientId in clientList)
+                    {
+                        if (clientId == networkManager.LocalClientId)
+                        {
+                            continue;
+                        }
+
+                        // If ownership is changing and this is not an ownership request approval then ignore the OnwerClientId
+                        // If it is just updating flags then ignore sending to the owner
+                        // If it is a request or approving request, then ignore the RequestClientId
+                        if ((OwnershipIsChanging && !RequestApproved && OwnerClientId == clientId) || (OwnershipFlagsUpdate && clientId == OwnerClientId)
+                            || ((RequestOwnership || RequestApproved) && clientId == RequestClientId))
+                        {
+                            continue;
+                        }
+
+                        networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.Reliable, clientId);
+                    }
+                }
+                // If the NetworkObject is not visible to the DAHost client, then exit early 
+                if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
+                {
+                    return;
+                }
+            }
+
+            // If ownership is changing, then run through the ownershipd changed sequence
+            // Note: There is some extended ownership script at the bottom of HandleOwnershipChange
+            // If not in distributed authority mode, then always go straight to HandleOwnershipChange
+            if (OwnershipIsChanging || !networkManager.DistributedAuthorityMode)
+            {
+                HandleOwnershipChange(ref context);
+            }
+            else if (networkManager.DistributedAuthorityMode)
+            {
+                // Otherwise, we handle and extended ownership update
+                HandleExtendedOwnershipUpdate(ref context);
+            }
+        }
+
+        /// <summary>
+        /// Handle the 
+        /// </summary>
+        /// <param name="context"></param>
+        private void HandleExtendedOwnershipUpdate(ref NetworkContext context)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+
+            // Handle the extended ownership message types
+            var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
+
+            if (OwnershipFlagsUpdate)
+            {
+                // Just update the ownership flags
+                networkObject.Ownership = (NetworkObject.OwnershipStatus)OwnershipFlags;
+            }
+            else if (RequestOwnership)
+            {
+                // Requesting ownership, if allowed it will automatically send the ownership change message
+                networkObject.OwnershipRequest(RequestClientId);
+            }
+            else if (RequestDenied)
+            {
+                networkObject.OwnershipRequestResponse((NetworkObject.OwnershipRequestResponseStatus)OwnershipRequestResponseStatus);
+            }
+        }
+
+        /// <summary>
+        /// Handle the traditional change in ownership message type logic
+        /// </summary>
+        /// <param name="context"></param>
+        private void HandleOwnershipChange(ref NetworkContext context)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
+
+            // DANGO-TODO: This probably shouldn't be allowed to happen.
+            if (networkObject.OwnerClientId == OwnerClientId)
+            {
+                UnityEngine.Debug.LogWarning($"Unnecessary ownership changed message for {NetworkObjectId}");
+            }
+
+            var originalOwner = networkObject.OwnerClientId;
             networkObject.OwnerClientId = OwnerClientId;
 
-            // We are current owner.
-            if (originalOwner == networkManager.LocalClientId)
+            if (networkManager.DistributedAuthorityMode)
+            {
+                networkObject.Ownership = (NetworkObject.OwnershipStatus)OwnershipFlags;
+            }
+
+            // We are current owner (client-server) or running in distributed authority mode
+            if (originalOwner == networkManager.LocalClientId || networkManager.DistributedAuthorityMode)
             {
                 networkObject.InvokeBehaviourOnLostOwnership();
             }
 
-            // We are new owner.
-            if (OwnerClientId == networkManager.LocalClientId)
+            // We are new owner or (client-server) or running in distributed authority mode
+            if (OwnerClientId == networkManager.LocalClientId || networkManager.DistributedAuthorityMode)
             {
                 networkObject.InvokeBehaviourOnGainedOwnership();
             }
 
-            // For all other clients that are neither the former or current owner, update the behaviours' properties
-            if (OwnerClientId != networkManager.LocalClientId && originalOwner != networkManager.LocalClientId)
+            // If in distributed authority mode 
+            if (networkManager.DistributedAuthorityMode)
             {
+                // Always update the network properties in distributed authority mode 
                 for (int i = 0; i < networkObject.ChildNetworkBehaviours.Count; i++)
                 {
                     networkObject.ChildNetworkBehaviours[i].UpdateNetworkProperties();
                 }
             }
+            else // Otherwise update properties like we would in client-server
+            {
+                // For all other clients that are neither the former or current owner, update the behaviours' properties
+                if (OwnerClientId != networkManager.LocalClientId && originalOwner != networkManager.LocalClientId)
+                {
+                    for (int i = 0; i < networkObject.ChildNetworkBehaviours.Count; i++)
+                    {
+                        networkObject.ChildNetworkBehaviours[i].UpdateNetworkProperties();
+                    }
+                }
+            }
+
+            // Always invoke ownership change notifications
+            networkObject.InvokeOwnershipChanged(originalOwner, OwnerClientId);
+
+            // If this change was requested, then notify that the request was approved (doing this last so all ownership
+            // changes have already been applied if the callback is invoked)
+            if (networkManager.DistributedAuthorityMode && networkManager.LocalClientId == OwnerClientId)
+            {
+                if (RequestApproved)
+                {
+                    networkObject.OwnershipRequestResponse(NetworkObject.OwnershipRequestResponseStatus.Approved);
+                }
+
+                // If the NetworkObject changed ownership and the Requested flag was set (i.e. it was an ownership request),
+                // then the new owner granted ownership removes the Requested flag and sends out an ownership status update.
+                if (networkObject.HasExtendedOwnershipStatus(NetworkObject.OwnershipStatusExtended.Requested))
+                {
+                    networkObject.RemoveOwnershipExtended(NetworkObject.OwnershipStatusExtended.Requested);
+                    networkObject.SendOwnershipStatusUpdate();
+                }
+            }
 
             networkManager.NetworkMetrics.TrackOwnershipChangeReceived(context.SenderId, networkObject, context.MessageSize);
         }

Runtime/Messaging/Messages/ClientConnectedMessage.cs

@@ -0,0 +1,66 @@
+namespace Unity.Netcode
+{
+    internal struct ClientConnectedMessage : INetworkMessage, INetworkSerializeByMemcpy
+    {
+        public int Version => 0;
+
+        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)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            if (!networkManager.IsClient)
+            {
+                return false;
+            }
+            ByteUnpacker.ReadValueBitPacked(reader, out ClientId);
+            reader.ReadValueSafe(out ShouldSynchronize);
+
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            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/ClientConnectedMessage.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 158454105806474cba54a4ea5a0bfb12
+timeCreated: 1697836112

Runtime/Messaging/Messages/ClientDisconnectedMessage.cs

@@ -0,0 +1,37 @@
+namespace Unity.Netcode
+{
+    internal struct ClientDisconnectedMessage : INetworkMessage, INetworkSerializeByMemcpy
+    {
+        public int Version => 0;
+
+        public ulong ClientId;
+
+        public void Serialize(FastBufferWriter writer, int targetVersion)
+        {
+            BytePacker.WriteValueBitPacked(writer, ClientId);
+        }
+
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            if (!networkManager.IsClient)
+            {
+                return false;
+            }
+            ByteUnpacker.ReadValueBitPacked(reader, out ClientId);
+            return true;
+        }
+
+        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)
+            {
+                networkManager.ConnectionManager.InvokeOnPeerDisconnectedCallback(ClientId);
+            }
+        }
+    }
+}

Runtime/Messaging/Messages/ClientDisconnectedMessage.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8f91296c8e5f40b1a2a03d74a31526b6
+timeCreated: 1697836161

Runtime/Messaging/Messages/ConnectionApprovedMessage.cs

@@ -5,10 +5,16 @@ namespace Unity.Netcode
 {
     internal struct ConnectionApprovedMessage : INetworkMessage
     {
-        public int Version => 0;
+        private const int k_VersionAddClientIds = 1;
+        public int Version => k_VersionAddClientIds;
 
         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;
@@ -17,6 +23,8 @@ namespace Unity.Netcode
 
         public NativeArray<MessageVersionData> MessageVersions;
 
+        public NativeArray<ulong> ConnectedClientIds;
+
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
             // ============================================================
@@ -35,8 +43,21 @@ namespace Unity.Netcode
 
             BytePacker.WriteValueBitPacked(writer, OwnerClientId);
             BytePacker.WriteValueBitPacked(writer, NetworkTick);
+            if (IsDistributedAuthority)
+            {
+                writer.WriteValueSafe(IsRestoredSession);
+                BytePacker.WriteValueBitPacked(writer, CurrentSessionOwner);
+            }
+
+            if (targetVersion >= k_VersionAddClientIds)
+            {
+                writer.WriteValueSafe(ConnectedClientIds);
+            }
 
             uint sceneObjectCount = 0;
+
+            // When SpawnedObjectsList is not null then scene management is disabled. Provide a list of
+            // all observed and spawned NetworkObjects that the approved client needs to synchronize.
             if (SpawnedObjectsList != null)
             {
                 var pos = writer.Position;
@@ -45,10 +66,11 @@ namespace Unity.Netcode
                 // Serialize NetworkVariable data
                 foreach (var sobj in SpawnedObjectsList)
                 {
-                    if (sobj.CheckObjectVisibility == null || sobj.CheckObjectVisibility(OwnerClientId))
+                    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;
                     }
@@ -84,18 +106,18 @@ namespace Unity.Netcode
             {
                 var messageVersion = new MessageVersionData();
                 messageVersion.Deserialize(reader);
-                networkManager.MessagingSystem.SetVersion(context.SenderId, messageVersion.Hash, messageVersion.Version);
+                networkManager.ConnectionManager.MessageManager.SetVersion(context.SenderId, messageVersion.Hash, messageVersion.Version);
                 messageHashesInOrder[i] = messageVersion.Hash;
 
                 // Update the received version since this message will always be passed version 0, due to the map not
                 // being initialized until just now.
-                var messageType = networkManager.MessagingSystem.GetMessageForHash(messageVersion.Hash);
+                var messageType = networkManager.ConnectionManager.MessageManager.GetMessageForHash(messageVersion.Hash);
                 if (messageType == typeof(ConnectionApprovedMessage))
                 {
                     receivedMessageVersion = messageVersion.Version;
                 }
             }
-            networkManager.MessagingSystem.SetServerMessageOrder(messageHashesInOrder);
+            networkManager.ConnectionManager.MessageManager.SetServerMessageOrder(messageHashesInOrder);
             messageHashesInOrder.Dispose();
             // ============================================================
             // END FORBIDDEN SEGMENT
@@ -103,6 +125,21 @@ 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)
+            {
+                reader.ReadValueSafe(out ConnectedClientIds, Allocator.TempJob);
+            }
+            else
+            {
+                ConnectedClientIds = new NativeArray<ulong>(0, Allocator.TempJob);
+            }
+
             m_ReceivedSceneObjectData = reader;
             return true;
         }
@@ -110,20 +147,56 @@ 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);
 
-            networkManager.LocalClient = new NetworkClient() { ClientId = networkManager.LocalClientId };
-            networkManager.IsApproved = true;
+            networkManager.ConnectionManager.LocalClient.SetRole(false, true, networkManager);
+            networkManager.ConnectionManager.LocalClient.IsApproved = true;
+            networkManager.ConnectionManager.LocalClient.ClientId = OwnerClientId;
+            // Stop the client-side approval timeout coroutine since we are approved.
+            networkManager.ConnectionManager.StopClientApprovalCoroutine();
+
+            networkManager.ConnectionManager.ConnectedClientIds.Clear();
+            foreach (var clientId in ConnectedClientIds)
+            {
+                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
@@ -137,9 +210,39 @@ 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.InvokeOnClientConnectedCallback(context.SenderId);
+                networkManager.ConnectionManager.InvokeOnClientConnectedCallback(context.SenderId);
             }
+            else
+            {
+                if (networkManager.DistributedAuthorityMode && networkManager.CMBServiceConnection && networkManager.LocalClient.IsSessionOwner && networkManager.NetworkConfig.EnableSceneManagement)
+                {
+                    // Mark the client being connected
+                    networkManager.IsConnectedClient = true;
+
+                    // Spawn any in-scene placed NetworkObjects
+                    networkManager.SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
+
+                    // Spawn the local player of the session owner
+                    if (networkManager.AutoSpawnPlayerPrefabClientSide)
+                    {
+                        networkManager.ConnectionManager.CreateAndSpawnPlayer(OwnerClientId);
+                    }
+                    // Synchronize the service with the initial session owner's loaded scenes and spawned objects
+                    networkManager.SceneManager.SynchronizeNetworkObjects(NetworkManager.ServerClientId);
+                }
+            }
+            ConnectedClientIds.Dispose();
         }
     }
 }

Runtime/Messaging/Messages/ConnectionRequestMessage.cs

@@ -8,6 +8,10 @@ namespace Unity.Netcode
 
         public ulong ConfigHash;
 
+        public bool CMBServiceConnection;
+        public uint TickRate;
+        public bool EnableSceneManagement;
+
         public byte[] ConnectionData;
 
         public bool ShouldSendConnectionData;
@@ -30,6 +34,12 @@ namespace Unity.Netcode
             // END FORBIDDEN SEGMENT
             // ============================================================
 
+            if (CMBServiceConnection)
+            {
+                writer.WriteValueSafe(TickRate);
+                writer.WriteValueSafe(EnableSceneManagement);
+            }
+
             if (ShouldSendConnectionData)
             {
                 writer.WriteValueSafe(ConfigHash);
@@ -59,11 +69,11 @@ namespace Unity.Netcode
             {
                 var messageVersion = new MessageVersionData();
                 messageVersion.Deserialize(reader);
-                networkManager.MessagingSystem.SetVersion(context.SenderId, messageVersion.Hash, messageVersion.Version);
+                networkManager.ConnectionManager.MessageManager.SetVersion(context.SenderId, messageVersion.Hash, messageVersion.Version);
 
                 // Update the received version since this message will always be passed version 0, due to the map not
                 // being initialized until just now.
-                var messageType = networkManager.MessagingSystem.GetMessageForHash(messageVersion.Hash);
+                var messageType = networkManager.ConnectionManager.MessageManager.GetMessageForHash(messageVersion.Hash);
                 if (messageType == typeof(ConnectionRequestMessage))
                 {
                     receivedMessageVersion = messageVersion.Version;
@@ -135,7 +145,7 @@ namespace Unity.Netcode
             var networkManager = (NetworkManager)context.SystemOwner;
             var senderId = context.SenderId;
 
-            if (networkManager.PendingClients.TryGetValue(senderId, out PendingClient client))
+            if (networkManager.ConnectionManager.PendingClients.TryGetValue(senderId, out PendingClient client))
             {
                 // Set to pending approval to prevent future connection requests from being approved
                 client.ConnectionState = PendingClient.State.PendingApproval;
@@ -143,26 +153,17 @@ namespace Unity.Netcode
 
             if (networkManager.NetworkConfig.ConnectionApproval)
             {
-                // Note: Delegate creation allocates.
-                // Note: ToArray() also allocates. :(
-                var response = new NetworkManager.ConnectionApprovalResponse();
-                networkManager.ClientsToApprove[senderId] = response;
-
-                networkManager.ConnectionApprovalCallback(
-                    new NetworkManager.ConnectionApprovalRequest
-                    {
-                        Payload = ConnectionData,
-                        ClientNetworkId = senderId
-                    }, response);
+                var messageRequest = this;
+                networkManager.ConnectionManager.ApproveConnection(ref messageRequest, ref context);
             }
             else
             {
                 var response = new NetworkManager.ConnectionApprovalResponse
                 {
                     Approved = true,
-                    CreatePlayerObject = networkManager.NetworkConfig.PlayerPrefab != null
+                    CreatePlayerObject = networkManager.DistributedAuthorityMode && networkManager.AutoSpawnPlayerPrefabClientSide ? false : networkManager.NetworkConfig.PlayerPrefab != null
                 };
-                networkManager.HandleConnectionApproval(senderId, response);
+                networkManager.ConnectionManager.HandleConnectionApproval(senderId, response);
             }
         }
     }

Runtime/Messaging/Messages/CreateObjectMessage.cs

@@ -1,3 +1,6 @@
+using System.Linq;
+using System.Runtime.CompilerServices;
+
 namespace Unity.Netcode
 {
     internal struct CreateObjectMessage : INetworkMessage
@@ -7,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)
@@ -20,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(IDeferredMessageManager.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;
@@ -34,9 +172,138 @@ namespace Unity.Netcode
         public void Handle(ref NetworkContext context)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
-            var networkObject = NetworkObject.AddSceneObject(ObjectInfo, m_ReceivedNetworkVariableData, networkManager);
+            // 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, ObserverIds, NewObserverIds);
+            }
+            else
+            {
+                if (networkManager.DistributedAuthorityMode && !IncludesSerializedObject && UpdateObservers)
+                {
+                    ObjectInfo = new NetworkObject.SceneObject()
+                    {
+                        NetworkObjectId = NetworkObjectId,
+                    };
+                }
+                CreateObject(ref networkManager, context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData, ObserverIds, NewObserverIds);
+            }
+        }
 
-            networkManager.NetworkMetrics.TrackObjectSpawnReceived(context.SenderId, networkObject, context.MessageSize);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        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
+            {
+                if (!networkManager.DistributedAuthorityMode)
+                {
+                    networkObject = NetworkObject.AddSceneObject(sceneObject, networkVariableData, networkManager);
+                }
+                else
+                {
+                    var hasObserverIdList = observerIds != null && observerIds.Length > 0;
+                    var hasNewObserverIdList = newObserverIds != null && newObserverIds.Length > 0;
+                    // Depending upon visibility of the NetworkObject and the client in question, it could be that
+                    // this client already has visibility of this NetworkObject
+                    if (networkManager.SpawnManager.SpawnedObjects.ContainsKey(sceneObject.NetworkObjectId))
+                    {
+                        // If so, then just get the local instance
+                        networkObject = networkManager.SpawnManager.SpawnedObjects[sceneObject.NetworkObjectId];
+
+                        // This should not happen, logging error just in case
+                        if (hasNewObserverIdList && newObserverIds.Contains(networkManager.LocalClientId))
+                        {
+                            NetworkLog.LogErrorServer($"[{nameof(CreateObjectMessage)}][Duplicate-Broadcast] Detected duplicated object creation for {sceneObject.NetworkObjectId}!");
+                        }
+                        else // Trap to make sure the owner is not receiving any messages it sent
+                        if (networkManager.CMBServiceConnection && networkManager.LocalClientId == networkObject.OwnerClientId)
+                        {
+                            NetworkLog.LogWarning($"[{nameof(CreateObjectMessage)}][Client-{networkManager.LocalClientId}][Duplicate-CreateObjectMessage][Client Is Owner] Detected duplicated object creation for {networkObject.name}-{sceneObject.NetworkObjectId}!");
+                        }
+                    }
+                    else
+                    {
+                        networkObject = NetworkObject.AddSceneObject(sceneObject, networkVariableData, networkManager, true);
+                    }
+
+                    // DA - NGO CMB SERVICE NOTES:
+                    // It is possible for two clients to connect at the exact same time which, due to client-side spawning, can cause each client
+                    // to miss their spawns. For now, all player NetworkObject spawns will always be visible to all known connected clients
+                    var clientList = hasObserverIdList && !networkObject.IsPlayerObject ? observerIds : networkManager.ConnectedClientsIds;
+
+                    // Update the observers for this instance
+                    foreach (var clientId in clientList)
+                    {
+                        networkObject.Observers.Add(clientId);
+                    }
+
+                    // Mock CMB Service and forward to all clients
+                    if (networkManager.DAHost)
+                    {
+                        // DA - NGO CMB SERVICE NOTES:
+                        // (*** See above notes fist ***)
+                        // If it is a player object freshly spawning and one or more clients all connect at the exact same time (i.e. received on effectively 
+                        // the same frame), then we need to check the observers list to make sure all players are visible upon first spawning. At a later date,
+                        // for area of interest we will need to have some form of follow up "observer update" message to cull out players not within each
+                        // player's AOI.
+                        if (networkObject.IsPlayerObject && hasNewObserverIdList && clientList.Count != observerIds.Length)
+                        {
+                            // For same-frame newly spawned players that might not be aware of all other players, update the player's observer
+                            // list.
+                            observerIds = clientList.ToArray();
+                        }
+
+                        var createObjectMessage = new CreateObjectMessage()
+                        {
+                            ObjectInfo = sceneObject,
+                            m_ReceivedNetworkVariableData = networkVariableData,
+                            ObserverIds = hasObserverIdList ? observerIds : null,
+                            NetworkObjectId = networkObject.NetworkObjectId,
+                            IncludesSerializedObject = true,
+                        };
+                        foreach (var clientId in clientList)
+                        {
+                            // DA - NGO CMB SERVICE NOTES:
+                            // If the authority did not specify the list of clients and the client is not an observer or we are the owner/originator
+                            // or we are the DAHost, then we skip sending the message.
+                            if ((!hasObserverIdList && (!networkObject.Observers.Contains(clientId)) ||
+                                clientId == networkObject.OwnerClientId || clientId == NetworkManager.ServerClientId))
+                            {
+                                continue;
+                            }
+
+                            // DA - NGO CMB SERVICE NOTES:
+                            // If this included a list of new observers and the targeted clientId is one of the observers, then send the serialized data.
+                            // Otherwise, the targeted clientId has already has visibility (i.e. it is already spawned) and so just send the updated
+                            // observers list to that client's instance.
+                            createObjectMessage.IncludesSerializedObject = hasNewObserverIdList && newObserverIds.Contains(clientId);
+
+                            networkManager.SpawnManager.SendSpawnCallForObject(clientId, networkObject);
+                        }
+                    }
+                }
+                if (networkObject != null)
+                {
+                    networkManager.NetworkMetrics.TrackObjectSpawnReceived(senderId, networkObject, messageSize);
+                }
+            }
+            catch (System.Exception ex)
+            {
+                UnityEngine.Debug.LogException(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(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
-                return false;
+                // Client-Server mode we always defer where in distributed authority mode we only defer if it is not a targeted destroy
+                if (!networkManager.DistributedAuthorityMode || (networkManager.DistributedAuthorityMode && !IsTargetedDestroy))
+                {
+                    networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, GetType().Name);
+                }
             }
             return true;
         }
@@ -35,14 +93,80 @@ namespace Unity.Netcode
         public void Handle(ref NetworkContext context)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
-            if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
+
+            var networkObject = (NetworkObject)null;
+            if (!networkManager.DistributedAuthorityMode)
             {
-                // This is the same check and log message that happens inside OnDespawnObject, but we have to do it here
-                return;
+                // If this NetworkObject does not exist on this instance then exit early
+                if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out networkObject))
+                {
+                    return;
+                }
+            }
+            else
+            {
+                networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out networkObject);
+                if (!networkManager.DAHost && networkObject == null)
+                {
+                    // If this NetworkObject does not exist on this instance then exit early
+                    return;
+                }
+            }
+            // DANGO-TODO: This is just a quick way to foward despawn messages to the remaining clients
+            if (networkManager.DistributedAuthorityMode && networkManager.DAHost)
+            {
+                var message = new DestroyObjectMessage
+                {
+                    NetworkObjectId = NetworkObjectId,
+                    DestroyGameObject = DestroyGameObject,
+                    IsDistributedAuthority = true,
+                    IsTargetedDestroy = IsTargetedDestroy,
+                    TargetClientId = TargetClientId, // Just always populate this value whether we write it or not
+                    DeferredDespawnTick = DeferredDespawnTick,
+                };
+                var ownerClientId = networkObject == null ? context.SenderId : networkObject.OwnerClientId;
+                var clientIds = networkObject == null ? networkManager.ConnectedClientsIds.ToList() : networkObject.Observers.ToList();
+
+                foreach (var clientId in clientIds)
+                {
+                    if (clientId == networkManager.LocalClientId || clientId == ownerClientId)
+                    {
+                        continue;
+                    }
+                    networkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientId);
+                }
             }
 
-            networkManager.NetworkMetrics.TrackObjectDestroyReceived(context.SenderId, networkObject, context.MessageSize);
-            networkManager.SpawnManager.OnDespawnObject(networkObject, DestroyGameObject);
+            // If we are deferring the despawn, then add it to the deferred despawn queue
+            if (networkManager.DistributedAuthorityMode)
+            {
+                if (DeferredDespawnTick > 0)
+                {
+                    // Clients always add it to the queue while DAHost will only add it to the queue if it is not a targeted destroy or it is and the target is the
+                    // DAHost client.
+                    if (!networkManager.DAHost || (networkManager.DAHost && (!IsTargetedDestroy || (IsTargetedDestroy && TargetClientId == 0))))
+                    {
+                        networkObject.DeferredDespawnTick = DeferredDespawnTick;
+                        var hasCallback = networkObject.OnDeferredDespawnComplete != null;
+                        networkManager.SpawnManager.DeferDespawnNetworkObject(NetworkObjectId, DeferredDespawnTick, hasCallback);
+                        return;
+                    }
+                }
+
+                // If this is targeted and we are not the target, then just update our local observers for this object
+                if (IsTargetedDestroy && TargetClientId != networkManager.LocalClientId && networkObject != null)
+                {
+                    networkObject.Observers.Remove(TargetClientId);
+                    return;
+                }
+            }
+
+            if (networkObject != null)
+            {
+                // Otherwise just despawn the NetworkObject right now
+                networkManager.SpawnManager.OnDespawnObject(networkObject, DestroyGameObject);
+                networkManager.NetworkMetrics.TrackObjectDestroyReceived(context.SenderId, networkObject, context.MessageSize);
+            }
         }
     }
 }

Runtime/Messaging/Messages/NamedMessage.cs

@@ -24,7 +24,11 @@ namespace Unity.Netcode
 
         public void Handle(ref NetworkContext context)
         {
-            ((NetworkManager)context.SystemOwner).CustomMessagingManager.InvokeNamedMessage(Hash, context.SenderId, m_ReceiveData, context.SerializedHeaderSize);
+            var networkManager = (NetworkManager)context.SystemOwner;
+            if (!networkManager.ShutdownInProgress && networkManager.CustomMessagingManager != null)
+            {
+                networkManager.CustomMessagingManager.InvokeNamedMessage(Hash, context.SenderId, m_ReceiveData, context.SerializedHeaderSize);
+            }
         }
     }
 }

Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs

@@ -23,6 +23,8 @@ namespace Unity.Netcode
 
         private FastBufferReader m_ReceivedNetworkVariableData;
 
+        // DANGO-TODO: Made some modifications here that overlap/won't play nice with EnsureNetworkVariableLenghtSafety.
+        // Worth either merging or more cleanly separating these codepaths.
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
             if (!writer.TryBeginWrite(FastBufferWriter.GetWriteSize(NetworkObjectId) + FastBufferWriter.GetWriteSize(NetworkBehaviourIndex)))
@@ -30,15 +32,26 @@ namespace Unity.Netcode
                 throw new OverflowException($"Not enough space in the buffer to write {nameof(NetworkVariableDeltaMessage)}");
             }
 
+            var obj = NetworkBehaviour.NetworkObject;
+            var networkManager = obj.NetworkManagerOwner;
+
             BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
             BytePacker.WriteValueBitPacked(writer, NetworkBehaviourIndex);
+            if (networkManager.DistributedAuthorityMode)
+            {
+                writer.WriteValueSafe((ushort)NetworkBehaviour.NetworkVariableFields.Count);
+            }
 
             for (int i = 0; i < NetworkBehaviour.NetworkVariableFields.Count; i++)
             {
                 if (!DeliveryMappedNetworkVariableIndex.Contains(i))
                 {
                     // This var does not belong to the currently iterating delivery group.
-                    if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                    if (networkManager.DistributedAuthorityMode)
+                    {
+                        writer.WriteValueSafe<ushort>(0);
+                    }
+                    else if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                     {
                         BytePacker.WriteValueBitPacked(writer, (ushort)0);
                     }
@@ -54,7 +67,7 @@ namespace Unity.Netcode
                 var networkVariable = NetworkBehaviour.NetworkVariableFields[i];
                 var shouldWrite = networkVariable.IsDirty() &&
                     networkVariable.CanClientRead(TargetClientId) &&
-                    (NetworkBehaviour.NetworkManager.IsServer || networkVariable.CanClientWrite(NetworkBehaviour.NetworkManager.LocalClientId));
+                    (networkManager.IsServer || networkVariable.CanClientWrite(networkManager.LocalClientId));
 
                 // Prevent the server from writing to the client that owns a given NetworkVariable
                 // Allowing the write would send an old value to the client and cause jitter
@@ -67,14 +80,21 @@ namespace Unity.Netcode
                 // The object containing the behaviour we're about to process is about to be shown to this client
                 // As a result, the client will get the fully serialized NetworkVariable and would be confused by
                 // an extraneous delta
-                if (NetworkBehaviour.NetworkManager.ObjectsToShowToClient.ContainsKey(TargetClientId) &&
-                    NetworkBehaviour.NetworkManager.ObjectsToShowToClient[TargetClientId]
-                    .Contains(NetworkBehaviour.NetworkObject))
+                if (networkManager.SpawnManager.ObjectsToShowToClient.ContainsKey(TargetClientId) &&
+                    networkManager.SpawnManager.ObjectsToShowToClient[TargetClientId]
+                    .Contains(obj))
                 {
                     shouldWrite = false;
                 }
 
-                if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                if (networkManager.DistributedAuthorityMode)
+                {
+                    if (!shouldWrite)
+                    {
+                        writer.WriteValueSafe<ushort>(0);
+                    }
+                }
+                else if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                 {
                     if (!shouldWrite)
                     {
@@ -88,9 +108,9 @@ namespace Unity.Netcode
 
                 if (shouldWrite)
                 {
-                    if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                    if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                     {
-                        var tempWriter = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, MessagingSystem.FRAGMENTED_MESSAGE_MAX_SIZE);
+                        var tempWriter = new FastBufferWriter(networkManager.MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp, networkManager.MessageManager.FragmentedMessageMaxSize);
                         NetworkBehaviour.NetworkVariableFields[i].WriteDelta(tempWriter);
                         BytePacker.WriteValueBitPacked(writer, tempWriter.Length);
 
@@ -103,12 +123,30 @@ namespace Unity.Netcode
                     }
                     else
                     {
-                        networkVariable.WriteDelta(writer);
+                        // DANGO-TODO:
+                        // Complex types with custom type serialization (either registered custom types or INetworkSerializable implementations) will be problematic
+                        // Non-complex types always provide a full state update per delta
+                        // DANGO-TODO: Add NetworkListEvent<T>.EventType awareness to the cloud-state server
+                        if (networkManager.DistributedAuthorityMode)
+                        {
+                            var size_marker = writer.Position;
+                            writer.WriteValueSafe<ushort>(0);
+                            var start_marker = writer.Position;
+                            networkVariable.WriteDelta(writer);
+                            var end_marker = writer.Position;
+                            writer.Seek(size_marker);
+                            var size = end_marker - start_marker;
+                            writer.WriteValueSafe((ushort)size);
+                            writer.Seek(end_marker);
+                        }
+                        else
+                        {
+                            networkVariable.WriteDelta(writer);
+                        }
                     }
-
-                    NetworkBehaviour.NetworkManager.NetworkMetrics.TrackNetworkVariableDeltaSent(
+                    networkManager.NetworkMetrics.TrackNetworkVariableDeltaSent(
                         TargetClientId,
-                        NetworkBehaviour.NetworkObject,
+                        obj,
                         networkVariable.Name,
                         NetworkBehaviour.__getTypeName(),
                         writer.Length - startingSize);
@@ -126,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;
@@ -143,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);
 
@@ -198,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(
@@ -207,8 +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))
                             {
@@ -234,7 +293,10 @@ namespace Unity.Netcode
             }
             else
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.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(IDeferredMessageManager.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

@@ -0,0 +1,83 @@
+using System;
+using Unity.Collections;
+
+namespace Unity.Netcode
+{
+    internal struct ProxyMessage : INetworkMessage
+    {
+        public NativeArray<ulong> TargetClientIds;
+        public NetworkDelivery Delivery;
+        public RpcMessage WrappedMessage;
+
+        // Version of ProxyMessage and RpcMessage must always match.
+        // If ProxyMessage needs to change, increment RpcMessage's version
+        public int Version => new RpcMessage().Version;
+
+        public void Serialize(FastBufferWriter writer, int targetVersion)
+        {
+            writer.WriteValueSafe(TargetClientIds);
+            BytePacker.WriteValuePacked(writer, Delivery);
+            WrappedMessage.Serialize(writer, targetVersion);
+        }
+
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+        {
+            reader.ReadValueSafe(out TargetClientIds, Allocator.Temp);
+            ByteUnpacker.ReadValuePacked(reader, out Delivery);
+            WrappedMessage = new RpcMessage();
+            WrappedMessage.Deserialize(reader, ref context, receivedMessageVersion);
+            return true;
+        }
+
+        public unsafe void Handle(ref NetworkContext context)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(WrappedMessage.Metadata.NetworkObjectId, out var networkObject))
+            {
+                // 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;
+
+            var nonServerIds = new NativeList<ulong>(Allocator.Temp);
+            for (var i = 0; i < TargetClientIds.Length; ++i)
+            {
+                if (!observers.Contains(TargetClientIds[i]))
+                {
+                    continue;
+                }
+
+                if (TargetClientIds[i] == NetworkManager.ServerClientId)
+                {
+                    WrappedMessage.Handle(ref context);
+                }
+                else
+                {
+                    nonServerIds.Add(TargetClientIds[i]);
+                }
+            }
+
+            WrappedMessage.WriteBuffer = new FastBufferWriter(WrappedMessage.ReadBuffer.Length, Allocator.Temp);
+
+            using (WrappedMessage.WriteBuffer)
+            {
+                WrappedMessage.WriteBuffer.WriteBytesSafe(WrappedMessage.ReadBuffer.GetUnsafePtr(), WrappedMessage.ReadBuffer.Length);
+                networkManager.MessageManager.SendMessage(ref WrappedMessage, Delivery, nonServerIds);
+            }
+        }
+    }
+}

Runtime/Messaging/Messages/ProxyMessage.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e9ee0457d5b740b38dfe6542658fb522
+timeCreated: 1697825043

Runtime/Messaging/Messages/RpcMessages.cs

@@ -1,6 +1,6 @@
 using System;
-using UnityEngine;
 using Unity.Collections;
+using UnityEngine;
 
 namespace Unity.Netcode
 {
@@ -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(IDeferredMessageManager.TriggerType.OnSpawn, metadata.NetworkObjectId, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, metadata.NetworkObjectId, reader, ref context, messageType);
                 return false;
             }
 
@@ -34,7 +34,7 @@ namespace Unity.Netcode
                 return false;
             }
 
-            if (!NetworkManager.__rpc_func_table.ContainsKey(metadata.NetworkRpcMethodId))
+            if (!NetworkBehaviour.__rpc_func_table[networkBehaviour.GetType()].ContainsKey(metadata.NetworkRpcMethodId))
             {
                 return false;
             }
@@ -42,7 +42,7 @@ namespace Unity.Netcode
             payload = new FastBufferReader(reader.GetUnsafePtrAtCurrentPosition(), Allocator.None, reader.Length - reader.Position);
 
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (NetworkManager.__rpc_name_table.TryGetValue(metadata.NetworkRpcMethodId, out var rpcMethodName))
+            if (NetworkBehaviour.__rpc_name_table[networkBehaviour.GetType()].TryGetValue(metadata.NetworkRpcMethodId, out var rpcMethodName))
             {
                 networkManager.NetworkMetrics.TrackRpcReceived(
                     context.SenderId,
@@ -52,7 +52,6 @@ namespace Unity.Netcode
                     reader.Length);
             }
 #endif
-
             return true;
         }
 
@@ -67,11 +66,19 @@ namespace Unity.Netcode
 
             try
             {
-                NetworkManager.__rpc_func_table[metadata.NetworkRpcMethodId](networkBehaviour, payload, rpcParams);
+                NetworkBehaviour.__rpc_func_table[networkBehaviour.GetType()][metadata.NetworkRpcMethodId](networkBehaviour, payload, rpcParams);
             }
             catch (Exception ex)
             {
                 Debug.LogException(new Exception("Unhandled RPC exception!", ex));
+                if (networkManager.LogLevel == LogLevel.Developer)
+                {
+                    Debug.Log($"RPC Table Contents");
+                    foreach (var entry in NetworkBehaviour.__rpc_func_table[networkBehaviour.GetType()])
+                    {
+                        Debug.Log($"{entry.Key} | {entry.Value.Method.Name}");
+                    }
+                }
             }
         }
     }
@@ -99,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)
@@ -134,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)
@@ -151,4 +158,177 @@ namespace Unity.Netcode
             RpcMessageHelpers.Handle(ref context, ref Metadata, ref ReadBuffer, ref rpcParams);
         }
     }
+
+    internal struct RpcMessage : INetworkMessage
+    {
+        public int Version => 0;
+
+        public RpcMetadata Metadata;
+        public ulong SenderClientId;
+
+        public FastBufferWriter WriteBuffer;
+        public FastBufferReader ReadBuffer;
+
+        public unsafe void Serialize(FastBufferWriter writer, int targetVersion)
+        {
+            BytePacker.WriteValuePacked(writer, SenderClientId);
+            RpcMessageHelpers.Serialize(ref writer, ref Metadata, ref WriteBuffer);
+        }
+
+        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, GetType().Name);
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            var rpcParams = new __RpcParams
+            {
+                Ext = new RpcParams
+                {
+                    Receive = new RpcReceiveParams
+                    {
+                        SenderClientId = SenderClientId
+                    }
+                }
+            };
+            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/NetworkBatchHeader.cs

@@ -3,7 +3,7 @@ namespace Unity.Netcode
     /// <summary>
     /// Header placed at the start of each message batch
     /// </summary>
-    internal struct BatchHeader : INetworkSerializeByMemcpy
+    internal struct NetworkBatchHeader : INetworkSerializeByMemcpy
     {
         internal const ushort MagicValue = 0x1160;
         /// <summary>
@@ -12,6 +12,11 @@ namespace Unity.Netcode
         /// </summary>
         public ushort Magic;
 
+        /// <summary>
+        /// Total number of messages in the batch.
+        /// </summary>
+        public ushort BatchCount;
+
         /// <summary>
         /// Total number of bytes in the batch.
         /// </summary>
@@ -22,9 +27,5 @@ namespace Unity.Netcode
         /// </summary>
         public ulong BatchHash;
 
-        /// <summary>
-        /// Total number of messages in the batch.
-        /// </summary>
-        public ushort BatchCount;
     }
 }

Runtime/Messaging/NetworkContext.cs

@@ -6,7 +6,7 @@ namespace Unity.Netcode
     internal ref struct NetworkContext
     {
         /// <summary>
-        /// An opaque object used to represent the owner of the MessagingSystem that's receiving the message.
+        /// An opaque object used to represent the owner of the NetworkMessageManager that's receiving the message.
         /// Outside of testing environments, the type of this variable will be <see cref="NetworkManager"/>
         /// </summary>
         public object SystemOwner;
@@ -24,7 +24,7 @@ namespace Unity.Netcode
         /// <summary>
         /// The header data that was sent with the message
         /// </summary>
-        public MessageHeader Header;
+        public NetworkMessageHeader Header;
 
         /// <summary>
         /// The actual serialized size of the header when packed into the buffer