com.unity.netcode.gameobjects@1.9.1

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).

## [1.9.1] - 2024-04-18

### Added
- Added AnticipatedNetworkVariable<T>, which adds support for client anticipation of NetworkVariable values, allowing for more responsive gameplay (#2820)
- Added AnticipatedNetworkTransform, which adds support for client anticipation of NetworkTransforms (#2820)
- Added NetworkVariableBase.ExceedsDirtinessThreshold to allow network variables to throttle updates by only sending updates when the difference between the current and previous values exceeds a threshold. (This is exposed in NetworkVariable<T> with the callback NetworkVariable<T>.CheckExceedsDirtinessThreshold) (#2820)
- Added NetworkVariableUpdateTraits, which add additional throttling support: MinSecondsBetweenUpdates will prevent the NetworkVariable from sending updates more often than the specified time period (even if it exceeds the dirtiness threshold), while MaxSecondsBetweenUpdates will force a dirty NetworkVariable to send an update after the specified time period even if it has not yet exceeded the dirtiness threshold. (#2820)
- Added virtual method NetworkVariableBase.OnInitialize() which can be used by NetworkVariable subclasses to add initialization code (#2820)
- Added virtual method NetworkVariableBase.Update(), which is called once per frame to support behaviors such as interpolation between an anticipated value and an authoritative one. (#2820)
- Added NetworkTime.TickWithPartial, which represents the current tick as a double that includes the fractional/partial tick value. (#2820)
- Added NetworkTickSystem.AnticipationTick, which can be helpful with implementation of client anticipation. This value represents the tick the current local client was at at the beginning of the most recent network round trip, which enables it to correlate server update ticks with the client tick that may have triggered them. (#2820)
- `NetworkVariable` now includes built-in support for `NativeHashSet`, `NativeHashMap`, `List`, `HashSet`, and `Dictionary` (#2813)
- `NetworkVariable` now includes delta compression for collection values (`NativeList`, `NativeArray`, `NativeHashSet`, `NativeHashMap`, `List`, `HashSet`, `Dictionary`, and `FixedString` types) to save bandwidth by only sending the values that changed. (Note: For `NativeList`, `NativeArray`, and `List`, this algorithm works differently than that used in `NetworkList`. This algorithm will use less bandwidth for "set" and "add" operations, but `NetworkList` is more bandwidth-efficient if you are performing frequent "insert" operations.) (#2813)
- `UserNetworkVariableSerialization` now has optional callbacks for `WriteDelta` and `ReadDelta`. If both are provided, they will be used for all serialization operations on NetworkVariables of that type except for the first one for each client. If either is missing, the existing `Write` and `Read` will always be used. (#2813)
- Network variables wrapping `INetworkSerializable` types can perform delta serialization by setting `UserNetworkVariableSerialization<T>.WriteDelta` and `UserNetworkVariableSerialization<T>.ReadDelta` for those types. The built-in `INetworkSerializable` serializer will continue to be used for all other serialization operations, but if those callbacks are set, it will call into them on all but the initial serialization to perform delta serialization. (This could be useful if you have a large struct where most values do not change regularly and you want to send only the fields that did change.) (#2813)

### Fixed

- Fixed issue where NetworkTransformEditor would throw and exception if you excluded the physics package. (#2871)
- Fixed issue where `NetworkTransform` could not properly synchronize its base position when using half float precision. (#2845)
- Fixed issue where the host was not invoking `OnClientDisconnectCallback` for its own local client when internally shutting down. (#2822)
- Fixed issue where NetworkTransform could potentially attempt to "unregister" a named message prior to it being registered. (#2807)
- Fixed issue where in-scene placed `NetworkObject`s with complex nested children `NetworkObject`s (more than one child in depth) would not synchronize properly if WorldPositionStays was set to true. (#2796)

### Changed

- Changed `NetworkObjectReference` and `NetworkBehaviourReference` to allow null references when constructing and serializing. (#2874)
- Changed `NetworkAnimator` no longer requires the `Animator` component to exist on the same `GameObject`. (#2872)
- 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,237 +6,17 @@ 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] - 2024-09-12
-
-### Added
-
-- Added tooltips for all of the `NetworkObject` component's properties. (#3052)
-- Added message size validation to named and unnamed message sending functions for better error messages. (#3049)
-- Added "Check for NetworkObject Component" property to the Multiplayer->Netcode for GameObjects project settings. When disabled, this will bypass the in-editor `NetworkObject` check on `NetworkBehaviour` components. (#3031)
-- Added `NetworkTransform.SwitchTransformSpaceWhenParented` property that, when enabled, will handle the world to local, local to world, and local to local transform space transitions when interpolation is enabled. (#3013)
-- Added `NetworkTransform.TickSyncChildren` that, when enabled, will tick synchronize nested and/or child `NetworkTransform` components to eliminate any potential visual jittering that could occur if the `NetworkTransform` instances get into a state where their state updates are landing on different network ticks. (#3013)
-- Added `NetworkObject.AllowOwnerToParent` property to provide the ability to allow clients to parent owned objects when running in a client-server network topology. (#3013)
-- Added `NetworkObject.SyncOwnerTransformWhenParented` property to provide a way to disable applying the server's transform information in the parenting message on the client owner instance which can be useful for owner authoritative motion models. (#3013)
-- Added `NetcodeEditorBase` editor helper class to provide easier modification and extension of the SDK's components. (#3013)
-
-### Fixed
-
-- Fixed issue where `NetworkAnimator` would send updates to non-observer clients. (#3057)
-- Fixed issue where an exception could occur when receiving a universal RPC for a `NetworkObject` that has been despawned. (#3052)
-- Fixed issue where a NetworkObject hidden from a client that is then promoted to be session owner was not being synchronized with newly joining clients.(#3051)
-- Fixed issue where clients could have a wrong time delta on `NetworkVariableBase` which could prevent from sending delta state updates. (#3045)
-- Fixed issue where setting a prefab hash value during connection approval but not having a player prefab assigned could cause an exception when spawning a player. (#3042)
-- Fixed issue where the `NetworkSpawnManager.HandleNetworkObjectShow` could throw an exception if one of the `NetworkObject` components to show was destroyed during the same frame. (#3030)
-- Fixed issue where the `NetworkManagerHelper` was continuing to check for hierarchy changes when in play mode. (#3026)
-- Fixed issue with newly/late joined clients and `NetworkTransform` synchronization of parented `NetworkObject` instances. (#3013)
-- Fixed issue with smooth transitions between transform spaces when interpolation is enabled (requires `NetworkTransform.SwitchTransformSpaceWhenParented` to be enabled). (#3013)
-
-### Changed
-
-- Changed `NetworkTransformEditor` now uses `NetworkTransform` as the base type class to assure it doesn't display a foldout group when using the base `NetworkTransform` component class. (#3052)
-- Changed `NetworkAnimator.Awake` is now a protected virtual method. (#3052)
-- Changed  when invoking `NetworkManager.ConnectionManager.DisconnectClient` during a distributed authority session a more appropriate message is logged. (#3052)
-- Changed `NetworkTransformEditor` so it now derives from `NetcodeEditorBase`. (#3013)
-- Changed `NetworkRigidbodyBaseEditor` so it now derives from `NetcodeEditorBase`. (#3013)
-- Changed `NetworkManagerEditor` so it now derives from `NetcodeEditorBase`. (#3013)
-
-
-## [2.0.0-pre.4] - 2024-08-21
-
-### Added
-
-- Added `NetworkVariable.CheckDirtyState` that is to be used in tandem with collections in order to detect whether the collection or an item within the collection has changed. (#3004)
-
-### Fixed
-
-- Fixed issue where nested `NetworkTransform` components were not getting updated. (#3016)
-- Fixed issue by adding null checks in `NetworkVariableBase.CanClientRead` and `NetworkVariableBase.CanClientWrite` methods to ensure safe access to `NetworkBehaviour`. (#3012)
-- Fixed issue where `FixedStringSerializer<T>` was using `NetworkVariableSerialization<byte>.AreEqual` to determine if two bytes were equal causes an exception to be thrown due to no byte serializer having been defined. (#3009)
-- Fixed Issue where a state with dual triggers, inbound and outbound, could cause a false layer to layer state transition message to be sent to non-authority `NetworkAnimator` instances and cause a warning message to be logged. (#3008)
-- Fixed issue using collections within `NetworkVariable` where the collection would not detect changes to items or nested items. (#3004)
-- Fixed issue where `List`, `Dictionary`, and `HashSet` collections would not uniquely duplicate nested collections. (#3004)
-- Fixed issue where `NotAuthorityTarget` would include the service observer in the list of targets to send the RPC to as opposed to excluding the service observer as it should. (#3000)
-- Fixed issue where `ProxyRpcTargetGroup` could attempt to send a message if there were no targets to send to. (#3000)
-
-### Changed
-
-- Changed `NetworkAnimator` to automatically switch to owner authoritative mode when using a distributed authority network topology. (#3021)
-- Changed permissions exception thrown in `NetworkList` to exiting early with a logged error that is now a unified permissions message within `NetworkVariableBase`. (#3004)
-- Changed permissions exception thrown in `NetworkVariable.Value` to exiting early with a logged error that is now a unified permissions message within `NetworkVariableBase`. (#3004)
-
-
-## [2.0.0-pre.3] - 2024-07-23
-
-### Added
-- Added: `UnityTransport.GetNetworkDriver` and `UnityTransport.GetLocalEndpoint` methods to expose the driver and local endpoint being used. (#2978)
-
-### Fixed
-
-- Fixed issue where deferred despawn was causing GC allocations when converting an `IEnumerable` to a list. (#2983)
-- Fixed issue where the realtime network stats monitor was not able to display RPC traffic in release builds due to those stats being only available in development builds or the editor. (#2979)
-- Fixed issue where `NetworkManager.ScenesLoaded` was not being updated if `PostSynchronizationSceneUnloading` was set and any loaded scenes not used during synchronization were unloaded. (#2971)
-- Fixed issue where `Rigidbody2d` under Unity 6000.0.11f1 has breaking changes where `velocity` is now `linearVelocity` and `isKinematic` is replaced by `bodyType`. (#2971)
-- Fixed issue where `NetworkSpawnManager.InstantiateAndSpawn` and `NetworkObject.InstantiateAndSpawn` were not honoring the ownerClientId parameter when using a client-server network topology. (#2968)
-- Fixed issue where internal delta serialization could not have a byte serializer defined when serializing deltas for other types. Added `[GenerateSerializationForType(typeof(byte))]` to both the `NetworkVariable` and `AnticipatedNetworkVariable` classes to assure a byte serializer is defined.(#2962)
-- Fixed issue when scene management was disabled and the session owner would still try to synchronize a late joining client. (#2962)
-- Fixed issue when using a distributed authority network topology where it would allow a session owner to spawn a `NetworkObject` prior to being approved. Now, an error message is logged and the `NetworkObject` will not be spawned prior to the client being approved.  (#2962)
-- Fixed issue where attempting to spawn during `NetworkBehaviour.OnInSceneObjectsSpawned` and `NetworkBehaviour.OnNetworkSessionSynchronized` notifications would throw a collection modified exception.  (#2962)
-
-### Changed
-
-- Changed logic where clients can now set the `NetworkSceneManager` client synchronization mode when using a distributed authority network topology. (#2985)
-
-
-## [2.0.0-pre.2] - 2024-06-17
-
-### Added
-
-- Added `AnticipatedNetworkVariable<T>`, which adds support for client anticipation of `NetworkVariable` values, allowing for more responsive gameplay. (#2957)
-- Added `AnticipatedNetworkTransform`, which adds support for client anticipation of NetworkTransforms. (#2957)
-- Added `NetworkVariableBase.ExceedsDirtinessThreshold` to allow network variables to throttle updates by only sending updates when the difference between the current and previous values exceeds a threshold. (This is exposed in `NetworkVariable<T>` with the callback `NetworkVariable<T>.CheckExceedsDirtinessThreshold`). (#2957)
-- Added `NetworkVariableUpdateTraits`, which add additional throttling support: `MinSecondsBetweenUpdates` will prevent the `NetworkVariable` from sending updates more often than the specified time period (even if it exceeds the dirtiness threshold), while `MaxSecondsBetweenUpdates` will force a dirty `NetworkVariable` to send an update after the specified time period even if it has not yet exceeded the dirtiness threshold. (#2957)
-- Added virtual method `NetworkVariableBase.OnInitialize` which can be used by `NetworkVariable` subclasses to add initialization code. (#2957)
-- Added `NetworkTime.TickWithPartial`, which represents the current tick as a double that includes the fractional/partial tick value. (#2957)
-- Added `NetworkTickSystem.AnticipationTick`, which can be helpful with implementation of client anticipation. This value represents the tick the current local client was at at the beginning of the most recent network round trip, which enables it to correlate server update ticks with the client tick that may have triggered them. (#2957)
-- Added event `NetworkManager.OnSessionOwnerPromoted` that is invoked when a new session owner promotion occurs. (#2948)
-- Added `NetworkRigidBodyBase.GetLinearVelocity` and `NetworkRigidBodyBase.SetLinearVelocity` convenience/helper methods. (#2948)
-- Added `NetworkRigidBodyBase.GetAngularVelocity` and `NetworkRigidBodyBase.SetAngularVelocity` convenience/helper methods. (#2948)
-
-### Fixed
-
-- Fixed issue when `NetworkTransform` half float precision is enabled and ownership changes the current base position was not being synchronized. (#2948)
-- Fixed issue where `OnClientConnected` not being invoked on the session owner when connecting to a new distributed authority session. (#2948)
-- Fixed issue where Rigidbody micro-motion (i.e. relatively small velocities) would result in non-authority instances slightly stuttering as the body would come to a rest (i.e. no motion). Now, the threshold value can increase at higher velocities and can decrease slightly below the provided threshold to account for this. (#2948)
-
-### Changed
-
-- Changed `NetworkAnimator` no longer requires the `Animator` component to exist on the same `GameObject`. (#2957)
-- Changed `NetworkObjectReference` and `NetworkBehaviourReference` to allow null references when constructing and serializing. (#2957)
-- Changed the client's owned objects is now returned (`NetworkClient` and `NetworkSpawnManager`) as an array as opposed to a list for performance purposes. (#2948)
-- Changed `NetworkTransfrom.TryCommitTransformToServer` to be internal as it will be removed by the final 2.0.0 release. (#2948)
-- Changed `NetworkTransformEditor.OnEnable` to a virtual method to be able to customize a `NetworkTransform` derived class by creating a derived editor control from `NetworkTransformEditor`. (#2948)
-
-
-## [2.0.0-exp.5] - 2024-06-03
-
-### Added
-
-
-### Fixed
-
-- Fixed issue where SessionOwner message was being treated as a new entry for the new message indexing when it should have been ordinally sorted with the legacy message indices. (#2942)
-
-### Changed
-- Changed `FastBufferReader` and `FastBufferWriter` so that they always ensure the length of items serialized is always serialized as an `uint` and added a check before casting for safe reading and writing.(#2946)
-
-
-## [2.0.0-exp.4] - 2024-05-31
-
-### Added
-
-- Added `NetworkRigidbodyBase.AttachToFixedJoint` and `NetworkRigidbodyBase.DetachFromFixedJoint` to replace parenting for rigid bodies that have `NetworkRigidbodyBase.UseRigidBodyForMotion` enabled. (#2933)
-- Added `NetworkBehaviour.OnNetworkPreSpawn` and `NetworkBehaviour.OnNetworkPostSpawn` methods that provide the ability to handle pre and post spawning actions during the `NetworkObject` spawn sequence. (#2912)
-- Added a client-side only `NetworkBehaviour.OnNetworkSessionSynchronized` convenience method that is invoked on all `NetworkBehaviour`s after a newly joined client has finished synchronizing with the network session in progress. (#2912)
-- Added `NetworkBehaviour.OnInSceneObjectsSpawned` convenience method that is invoked when all in-scene `NetworkObject`s have been spawned after a scene has been loaded or upon a host or server starting. (#2912)
-
-### Fixed
-
-- Fixed issue where non-authoritative rigid bodies with `NetworkRigidbodyBase.UseRigidBodyForMotion` enabled would constantly log errors about the renderTime being before `StartTimeConsumed`. (#2933)
-- Fixed issue where in-scene placed NetworkObjects could be destroyed if a client disconnects early and/or before approval. (#2924)
-- Fixed issue where a `NetworkObject` component's associated `NetworkBehaviour` components would not be detected if scene loading is disabled in the editor and the currently loaded scene has in-scene placed `NetworkObject`s. (#2912)
-- Fixed issue where an in-scene placed `NetworkObject` with `NetworkTransform` that is also parented under a `GameObject` would not properly synchronize when the parent `GameObject` had a world space position other than 0,0,0. (#2898)
-
-### Changed
-
-- Change all the access modifiers of test class from Public to Internal (#2930)
-- Changed messages are now sorted by enum values as opposed to ordinally sorting the messages by their type name. (#2929)
-- Changed `NetworkClient.SessionModeTypes` to `NetworkClient.NetworkTopologyTypes`. (#2875)
-- Changed `NetworkClient.SessionModeType` to `NetworkClient.NetworkTopologyType`. (#2875)
-- Changed `NetworkConfig.SessionMode` to `NeworkConfig.NetworkTopology`. (#2875)
-
-## [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 automatically 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.9.1] - 2024-04-18
 
 ### Added
-- Added `AnticipatedNetworkVariable<T>`, which adds support for client anticipation of NetworkVariable values, allowing for more responsive game play (#2820)
-- Added `AnticipatedNetworkTransform`, which adds support for client anticipation of `NetworkTransform`s (#2820)
-- Added `NetworkVariableBase.ExceedsDirtinessThreshold` to allow network variables to throttle updates by only sending updates when the difference between the current and previous values exceeds a threshold. (This is exposed in NetworkVariable<T> with the callback NetworkVariable<T>.CheckExceedsDirtinessThreshold) (#2820)
-- Added `NetworkVariableUpdateTraits`, which add additional throttling support: `MinSecondsBetweenUpdates` will prevent the `NetworkVariable` from sending updates more often than the specified time period (even if it exceeds the dirtiness threshold), while `MaxSecondsBetweenUpdates` will force a dirty `NetworkVariable` to send an update after the specified time period even if it has not yet exceeded the dirtiness threshold. (#2820)
-- Added virtual method `NetworkVariableBase.OnInitialize()` which can be used by `NetworkVariable` subclasses to add initialization code (#2820)
-- Added virtual method `NetworkVariableBase.Update()`, which is called once per frame to support behaviors such as interpolation between an anticipated value and an authoritative one. (#2820)
-- Added `NetworkTime.TickWithPartial`, which represents the current tick as a double that includes the fractional/partial tick value. (#2820)
+- Added AnticipatedNetworkVariable<T>, which adds support for client anticipation of NetworkVariable values, allowing for more responsive gameplay (#2820)
+- Added AnticipatedNetworkTransform, which adds support for client anticipation of NetworkTransforms (#2820)
+- Added NetworkVariableBase.ExceedsDirtinessThreshold to allow network variables to throttle updates by only sending updates when the difference between the current and previous values exceeds a threshold. (This is exposed in NetworkVariable<T> with the callback NetworkVariable<T>.CheckExceedsDirtinessThreshold) (#2820)
+- Added NetworkVariableUpdateTraits, which add additional throttling support: MinSecondsBetweenUpdates will prevent the NetworkVariable from sending updates more often than the specified time period (even if it exceeds the dirtiness threshold), while MaxSecondsBetweenUpdates will force a dirty NetworkVariable to send an update after the specified time period even if it has not yet exceeded the dirtiness threshold. (#2820)
+- Added virtual method NetworkVariableBase.OnInitialize() which can be used by NetworkVariable subclasses to add initialization code (#2820)
+- Added virtual method NetworkVariableBase.Update(), which is called once per frame to support behaviors such as interpolation between an anticipated value and an authoritative one. (#2820)
+- Added NetworkTime.TickWithPartial, which represents the current tick as a double that includes the fractional/partial tick value. (#2820)
+- Added NetworkTickSystem.AnticipationTick, which can be helpful with implementation of client anticipation. This value represents the tick the current local client was at at the beginning of the most recent network round trip, which enables it to correlate server update ticks with the client tick that may have triggered them. (#2820)
 - `NetworkVariable` now includes built-in support for `NativeHashSet`, `NativeHashMap`, `List`, `HashSet`, and `Dictionary` (#2813)
 - `NetworkVariable` now includes delta compression for collection values (`NativeList`, `NativeArray`, `NativeHashSet`, `NativeHashMap`, `List`, `HashSet`, `Dictionary`, and `FixedString` types) to save bandwidth by only sending the values that changed. (Note: For `NativeList`, `NativeArray`, and `List`, this algorithm works differently than that used in `NetworkList`. This algorithm will use less bandwidth for "set" and "add" operations, but `NetworkList` is more bandwidth-efficient if you are performing frequent "insert" operations.) (#2813)
 - `UserNetworkVariableSerialization` now has optional callbacks for `WriteDelta` and `ReadDelta`. If both are provided, they will be used for all serialization operations on NetworkVariables of that type except for the first one for each client. If either is missing, the existing `Write` and `Read` will always be used. (#2813)
@@ -244,7 +24,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Fixed
 
-- Fixed issue where `NetworkTransformEditor` would throw and exception if you excluded the physics package. (#2871)
+- Fixed issue where NetworkTransformEditor would throw and exception if you excluded the physics package. (#2871)
 - Fixed issue where `NetworkTransform` could not properly synchronize its base position when using half float precision. (#2845)
 - Fixed issue where the host was not invoking `OnClientDisconnectCallback` for its own local client when internally shutting down. (#2822)
 - Fixed issue where NetworkTransform could potentially attempt to "unregister" a named message prior to it being registered. (#2807)

Components.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 2e42215d00468b549bbc69ebf8a74a1e
+guid: 8b267eb841a574dc083ac248a95d4443
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Components/AnticipatedNetworkTransform.cs

@@ -43,13 +43,9 @@ namespace Unity.Netcode.Components
 #pragma warning restore IDE0001
     [DisallowMultipleComponent]
     [AddComponentMenu("Netcode/Anticipated Network Transform")]
+    [DefaultExecutionOrder(100000)] // this is needed to catch the update time after the transform was updated by user scripts
     public class AnticipatedNetworkTransform : NetworkTransform
     {
-
-#if UNITY_EDITOR
-        internal override bool HideInterpolateValue => true;
-#endif
-
         public struct TransformState
         {
             public Vector3 Position;
@@ -61,6 +57,7 @@ namespace Unity.Netcode.Components
         private TransformState m_AnticipatedTransform = new TransformState();
         private TransformState m_PreviousAnticipatedTransform = new TransformState();
         private ulong m_LastAnticipaionCounter;
+        private double m_LastAnticipationTime;
         private ulong m_LastAuthorityUpdateCounter;
 
         private TransformState m_SmoothFrom;
@@ -155,6 +152,7 @@ namespace Unity.Netcode.Components
             m_PreviousAnticipatedTransform = m_AnticipatedTransform;
 
             m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
+            m_LastAnticipationTime = NetworkManager.LocalTime.Time;
 
             m_SmoothDuration = 0;
             m_CurrentSmoothTime = 0;
@@ -181,6 +179,7 @@ namespace Unity.Netcode.Components
             m_PreviousAnticipatedTransform = m_AnticipatedTransform;
 
             m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
+            m_LastAnticipationTime = NetworkManager.LocalTime.Time;
 
             m_SmoothDuration = 0;
             m_CurrentSmoothTime = 0;
@@ -207,6 +206,7 @@ namespace Unity.Netcode.Components
             m_PreviousAnticipatedTransform = m_AnticipatedTransform;
 
             m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
+            m_LastAnticipationTime = NetworkManager.LocalTime.Time;
 
             m_SmoothDuration = 0;
             m_CurrentSmoothTime = 0;
@@ -235,17 +235,26 @@ namespace Unity.Netcode.Components
 
             m_PreviousAnticipatedTransform = m_AnticipatedTransform;
 
+            m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
+            m_LastAnticipationTime = NetworkManager.LocalTime.Time;
+
             m_SmoothDuration = 0;
             m_CurrentSmoothTime = 0;
         }
 
-        private void ProcessSmoothing()
+        protected override void Update()
         {
             // If not spawned or this instance has authority, exit early
             if (!IsSpawned)
             {
                 return;
             }
+            // Do not call the base class implementation...
+            // AnticipatedNetworkTransform applies its authoritative state immediately rather than waiting for update
+            // This is because AnticipatedNetworkTransforms may need to reference each other in reanticipating
+            // and we will want all reanticipation done before anything else wants to reference the transform in
+            // Update()
+            //base.Update();
 
             if (m_CurrentSmoothTime < m_SmoothDuration)
             {
@@ -256,7 +265,7 @@ namespace Unity.Netcode.Components
                 m_AnticipatedTransform = new TransformState
                 {
                     Position = Vector3.Lerp(m_SmoothFrom.Position, m_SmoothTo.Position, pct),
-                    Rotation = Quaternion.Lerp(m_SmoothFrom.Rotation, m_SmoothTo.Rotation, pct),
+                    Rotation = Quaternion.Slerp(m_SmoothFrom.Rotation, m_SmoothTo.Rotation, pct),
                     Scale = Vector3.Lerp(m_SmoothFrom.Scale, m_SmoothTo.Scale, pct)
                 };
                 m_PreviousAnticipatedTransform = m_AnticipatedTransform;
@@ -269,32 +278,6 @@ namespace Unity.Netcode.Components
             }
         }
 
-        // TODO: This does not handle OnFixedUpdate
-        // This requires a complete overhaul in this class to switch between using
-        // NetworkRigidbody's position and rotation values.
-        public override void OnUpdate()
-        {
-            ProcessSmoothing();
-            // Do not call the base class implementation...
-            // AnticipatedNetworkTransform applies its authoritative state immediately rather than waiting for update
-            // This is because AnticipatedNetworkTransforms may need to reference each other in reanticipating
-            // and we will want all reanticipation done before anything else wants to reference the transform in
-            // OnUpdate()
-            //base.OnUpdate();
-        }
-
-        /// <summary>
-        /// Since authority does not subscribe to updates (OnUpdate or OnFixedUpdate),
-        /// we have to update every frame to assure authority processes soothing.
-        /// </summary>
-        private void Update()
-        {
-            if (CanCommitToTransform && IsSpawned)
-            {
-                ProcessSmoothing();
-            }
-        }
-
         internal class AnticipatedObject : IAnticipationEventReceiver, IAnticipatedObject
         {
             public AnticipatedNetworkTransform Transform;
@@ -338,7 +321,7 @@ namespace Unity.Netcode.Components
 
             public void Update()
             {
-                // No need to do this, it's handled by NetworkTransform.OnUpdate
+                // No need to do this, it's handled by NetworkBehaviour.Update
             }
 
             public void ResetAnticipation()
@@ -367,61 +350,20 @@ namespace Unity.Netcode.Components
             m_CurrentSmoothTime = 0;
         }
 
-        /// <summary>
-        /// (This replaces the first OnSynchronize for NetworkTransforms)
-        /// This is needed to initialize when fully synchronized since non-authority instances
-        /// don't apply the initial synchronization (new client synchronization) until after
-        /// everything has been spawned and synchronized.
-        /// </summary>
-        protected internal override void InternalOnNetworkSessionSynchronized()
+        protected override void OnSynchronize<T>(ref BufferSerializer<T> serializer)
         {
-            var wasSynchronizing = SynchronizeState.IsSynchronizing;
-            base.InternalOnNetworkSessionSynchronized();
-            if (!CanCommitToTransform && wasSynchronizing && !SynchronizeState.IsSynchronizing)
+            base.OnSynchronize(ref serializer);
+            if (!CanCommitToTransform)
             {
                 m_OutstandingAuthorityChange = true;
                 ApplyAuthoritativeState();
                 ResetAnticipatedState();
-
-                m_AnticipatedObject = new AnticipatedObject { Transform = this };
-                NetworkManager.AnticipationSystem.RegisterForAnticipationEvents(m_AnticipatedObject);
-                NetworkManager.AnticipationSystem.AllAnticipatedObjects.Add(m_AnticipatedObject);
-            }
-        }
-
-        /// <summary>
-        /// (This replaces the any subsequent OnSynchronize for NetworkTransforms post client synchronization)
-        /// This occurs on already connected clients when dynamically spawning a NetworkObject for
-        /// non-authoritative instances.
-        /// </summary>
-        protected internal override void InternalOnNetworkPostSpawn()
-        {
-            base.InternalOnNetworkPostSpawn();
-            if (!CanCommitToTransform && NetworkManager.IsConnectedClient && !SynchronizeState.IsSynchronizing)
-            {
-                m_OutstandingAuthorityChange = true;
-                ApplyAuthoritativeState();
-                ResetAnticipatedState();
-                m_AnticipatedObject = new AnticipatedObject { Transform = this };
-                NetworkManager.AnticipationSystem.RegisterForAnticipationEvents(m_AnticipatedObject);
-                NetworkManager.AnticipationSystem.AllAnticipatedObjects.Add(m_AnticipatedObject);
             }
         }
 
         public override void OnNetworkSpawn()
         {
-            if (NetworkManager.DistributedAuthorityMode)
-            {
-                Debug.LogWarning($"This component is not currently supported in distributed authority.");
-            }
             base.OnNetworkSpawn();
-
-            // Non-authoritative instances exit early if the synchronization has yet to
-            // be applied at this point
-            if (SynchronizeState.IsSynchronizing && !CanCommitToTransform)
-            {
-                return;
-            }
             m_OutstandingAuthorityChange = true;
             ApplyAuthoritativeState();
             ResetAnticipatedState();

Components/AnticipatedNetworkTransform.cs.meta

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

Components/AssemblyInfo.cs

@@ -0,0 +1,15 @@
+using System.Runtime.CompilerServices;
+
+#if UNITY_EDITOR
+[assembly: InternalsVisibleTo("Unity.Netcode.Editor")]
+[assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")]
+#endif // UNITY_EDITOR
+
+#if UNITY_INCLUDE_TESTS
+[assembly: InternalsVisibleTo("Unity.Netcode.RuntimeTests")]
+[assembly: InternalsVisibleTo("TestProject.RuntimeTests")]
+#if UNITY_EDITOR
+[assembly: InternalsVisibleTo("Unity.Netcode.EditorTests")]
+[assembly: InternalsVisibleTo("TestProject.EditorTests")]
+#endif // UNITY_EDITOR
+#endif // UNITY_INCLUDE_TESTS

Components/AssemblyInfo.cs.meta

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

Components/HalfVector3.cs

@@ -8,7 +8,7 @@ namespace Unity.Netcode.Components
     /// Half float precision <see cref="Vector3"/>.
     /// </summary>
     /// <remarks>
-    /// The Vector3T&lt;ushort&gt; values are half float values returned by <see cref="Mathf.FloatToHalf(float)"/> for each
+    /// 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>

Components/HalfVector4.cs

@@ -8,7 +8,7 @@ namespace Unity.Netcode.Components
     /// Half Precision <see cref="Vector4"/> that can also be used to convert a <see cref="Quaternion"/> to half precision.
     /// </summary>
     /// <remarks>
-    /// The Vector4T&lt;ushort&gt; values are half float values returned by <see cref="Mathf.FloatToHalf(float)"/> for each
+    /// 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>

Components/Interpolator/BufferedLinearInterpolator.cs

@@ -5,14 +5,14 @@ using UnityEngine;
 namespace Unity.Netcode
 {
     /// <summary>
-    /// Solves for incoming values that are jittered.
+    /// Solves for incoming values that are jittered
     /// Partially solves for message loss. Unclamped lerping helps hide this, but not completely
     /// </summary>
     /// <typeparam name="T">The type of interpolated value</typeparam>
     public abstract class BufferedLinearInterpolator<T> where T : struct
     {
         internal float MaxInterpolationBound = 3.0f;
-        protected internal struct BufferedItem
+        private struct BufferedItem
         {
             public T Item;
             public double TimeSent;
@@ -31,16 +31,14 @@ namespace Unity.Netcode
 
         private const double k_SmallValue = 9.999999439624929E-11; // copied from Vector3's equal operator
 
-        protected internal T m_InterpStartValue;
-        protected internal T m_CurrentInterpValue;
-        protected internal T m_InterpEndValue;
+        private T m_InterpStartValue;
+        private T m_CurrentInterpValue;
+        private T m_InterpEndValue;
 
         private double m_EndTimeConsumed;
         private double m_StartTimeConsumed;
 
-        protected internal readonly List<BufferedItem> m_Buffer = new List<BufferedItem>(k_BufferCountLimit);
-
-
+        private readonly List<BufferedItem> m_Buffer = new List<BufferedItem>(k_BufferCountLimit);
 
         // Buffer consumption scenarios
         // Perfect case consumption
@@ -75,21 +73,6 @@ namespace Unity.Netcode
 
         private bool InvalidState => m_Buffer.Count == 0 && m_LifetimeConsumedCount == 0;
 
-        internal bool EndOfBuffer => m_Buffer.Count == 0;
-
-        internal bool InLocalSpace;
-
-        protected internal virtual void OnConvertTransformSpace(Transform transform, bool inLocalSpace)
-        {
-
-        }
-
-        internal void ConvertTransformSpace(Transform transform, bool inLocalSpace)
-        {
-            OnConvertTransformSpace(transform, inLocalSpace);
-            InLocalSpace = inLocalSpace;
-        }
-
         /// <summary>
         /// Resets interpolator to initial state
         /// </summary>
@@ -212,9 +195,7 @@ namespace Unity.Netcode
                 double range = m_EndTimeConsumed - m_StartTimeConsumed;
                 if (range > k_SmallValue)
                 {
-                    var rangeFactor = 1.0f / (float)range;
-
-                    t = ((float)renderTime - (float)m_StartTimeConsumed) * rangeFactor;
+                    t = (float)((renderTime - m_StartTimeConsumed) / range);
 
                     if (t < 0.0f)
                     {
@@ -368,35 +349,6 @@ namespace Unity.Netcode
                 return Quaternion.Lerp(start, end, time);
             }
         }
-
-        private Quaternion ConvertToNewTransformSpace(Transform transform, Quaternion rotation, bool inLocalSpace)
-        {
-            if (inLocalSpace)
-            {
-                return Quaternion.Inverse(transform.rotation) * rotation;
-
-            }
-            else
-            {
-                return transform.rotation * rotation;
-            }
-        }
-
-        protected internal override void OnConvertTransformSpace(Transform transform, bool inLocalSpace)
-        {
-            for (int i = 0; i < m_Buffer.Count; i++)
-            {
-                var entry = m_Buffer[i];
-                entry.Item = ConvertToNewTransformSpace(transform, entry.Item, inLocalSpace);
-                m_Buffer[i] = entry;
-            }
-
-            m_InterpStartValue = ConvertToNewTransformSpace(transform, m_InterpStartValue, inLocalSpace);
-            m_CurrentInterpValue = ConvertToNewTransformSpace(transform, m_CurrentInterpValue, inLocalSpace);
-            m_InterpEndValue = ConvertToNewTransformSpace(transform, m_InterpEndValue, inLocalSpace);
-
-            base.OnConvertTransformSpace(transform, inLocalSpace);
-        }
     }
 
     /// <summary>
@@ -434,34 +386,5 @@ namespace Unity.Netcode
                 return Vector3.Lerp(start, end, time);
             }
         }
-
-        private Vector3 ConvertToNewTransformSpace(Transform transform, Vector3 position, bool inLocalSpace)
-        {
-            if (inLocalSpace)
-            {
-                return transform.InverseTransformPoint(position);
-
-            }
-            else
-            {
-                return transform.TransformPoint(position);
-            }
-        }
-
-        protected internal override void OnConvertTransformSpace(Transform transform, bool inLocalSpace)
-        {
-            for (int i = 0; i < m_Buffer.Count; i++)
-            {
-                var entry = m_Buffer[i];
-                entry.Item = ConvertToNewTransformSpace(transform, entry.Item, inLocalSpace);
-                m_Buffer[i] = entry;
-            }
-
-            m_InterpStartValue = ConvertToNewTransformSpace(transform, m_InterpStartValue, inLocalSpace);
-            m_CurrentInterpValue = ConvertToNewTransformSpace(transform, m_CurrentInterpValue, inLocalSpace);
-            m_InterpEndValue = ConvertToNewTransformSpace(transform, m_InterpEndValue, inLocalSpace);
-
-            base.OnConvertTransformSpace(transform, inLocalSpace);
-        }
     }
 }

Components/Messages.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 421e3306c97e10f47b9efb6101a998ee
+guid: a9db1d18fa0117f4da5e8e65386b894a
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Components/Messages/NetworkTransformMessage.cs

@@ -0,0 +1,116 @@
+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;
+        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);
+            }
+        }
+
+        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);
+            if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
+            {
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                return false;
+            }
+            // Get the behaviour index
+            ByteUnpacker.ReadValueBitPacked(reader, out NetworkBehaviourId);
+
+            // Deserialize the state
+            reader.ReadNetworkSerializable(out State);
+
+            var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
+
+            // Get the target NetworkTransform
+            m_ReceiverNetworkTransform = networkObject.ChildNetworkBehaviours[NetworkBehaviourId] as NetworkTransform;
+
+            var isServerAuthoritative = m_ReceiverNetworkTransform.IsServerAuthoritative();
+            var ownerAuthoritativeServerSide = !isServerAuthoritative && networkManager.IsServer;
+            if (ownerAuthoritativeServerSide)
+            {
+                var 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;
+                }
+
+                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))
+                {
+                    // 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
+                    var clientCount = networkManager.ConnectionManager.ConnectedClientsList.Count;
+                    for (int i = 0; i < clientCount; i++)
+                    {
+                        var clientId = networkManager.ConnectionManager.ConnectedClientsList[i].ClientId;
+                        if (NetworkManager.ServerClientId == clientId || (!isServerAuthoritative && clientId == ownerClientId) || !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)
+        {
+            if (m_ReceiverNetworkTransform == null)
+            {
+                Debug.LogError($"[{nameof(NetworkTransformMessage)}][Dropped] Reciever {nameof(NetworkTransform)} was not set!");
+                return;
+            }
+            m_ReceiverNetworkTransform.TransformStateUpdate(ref State);
+        }
+    }
+}

Components/NetworkAnimator.cs

@@ -25,48 +25,26 @@ namespace Unity.Netcode.Components
         {
             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_NetworkAnimator.SendAnimStateClientRpc(animationUpdate.AnimationMessage, animationUpdate.ClientRpcParams);
             }
 
             m_SendAnimationUpdates.Clear();
 
             foreach (var sendEntry in m_SendParameterUpdates)
             {
-                if (m_NetworkAnimator.NetworkManager.DistributedAuthorityMode)
-                {
-                    m_NetworkAnimator.SendParametersUpdateRpc(sendEntry.ParametersUpdateMessage);
-                }
-                else
-                {
-                    m_NetworkAnimator.SendParametersUpdateClientRpc(sendEntry.ParametersUpdateMessage, sendEntry.ClientRpcParams);
-                }
+                m_NetworkAnimator.SendParametersUpdateClientRpc(sendEntry.ParametersUpdateMessage, sendEntry.ClientRpcParams);
             }
             m_SendParameterUpdates.Clear();
 
             foreach (var sendEntry in m_SendTriggerUpdates)
             {
-                if (m_NetworkAnimator.NetworkManager.DistributedAuthorityMode)
+                if (!sendEntry.SendToServer)
                 {
-                    m_NetworkAnimator.SendAnimTriggerRpc(sendEntry.AnimationTriggerMessage);
+                    m_NetworkAnimator.SendAnimTriggerClientRpc(sendEntry.AnimationTriggerMessage, sendEntry.ClientRpcParams);
                 }
                 else
                 {
-                    if (!sendEntry.SendToServer)
-                    {
-                        m_NetworkAnimator.SendAnimTriggerClientRpc(sendEntry.AnimationTriggerMessage, sendEntry.ClientRpcParams);
-                    }
-                    else
-                    {
-                        m_NetworkAnimator.SendAnimTriggerServerRpc(sendEntry.AnimationTriggerMessage);
-                    }
+                    m_NetworkAnimator.SendAnimTriggerServerRpc(sendEntry.AnimationTriggerMessage);
                 }
             }
             m_SendTriggerUpdates.Clear();
@@ -498,13 +476,9 @@ namespace Unity.Netcode.Components
         /// <summary>
         /// Override this method and return false to switch to owner authoritative mode
         /// </summary>
-        /// <remarks>
-        /// When using a distributed authority network topology, this will default to
-        /// owner authoritative.
-        /// </remarks>
         protected virtual bool OnIsServerAuthoritative()
         {
-            return NetworkManager ? !NetworkManager.DistributedAuthorityMode : true;
+            return true;
         }
 
         // Animators only support up to 32 parameters
@@ -584,7 +558,7 @@ namespace Unity.Netcode.Components
             base.OnDestroy();
         }
 
-        protected virtual void Awake()
+        private void Awake()
         {
             int layers = m_Animator.layerCount;
             // Initializing the below arrays for everyone handles an issue
@@ -677,14 +651,17 @@ namespace Unity.Netcode.Components
                 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
+            if (IsServer)
             {
-                Send = new ClientRpcSendParams
+                m_ClientSendList = new List<ulong>(128);
+                m_ClientRpcParams = new ClientRpcParams
                 {
-                    TargetClientIds = m_ClientSendList
-                }
-            };
+                    Send = new ClientRpcSendParams
+                    {
+                        TargetClientIds = m_ClientSendList
+                    }
+                };
+            }
 
             // Create a handler for state changes
             m_NetworkAnimatorStateChangeHandler = new NetworkAnimatorStateChangeHandler(this);
@@ -855,12 +832,7 @@ namespace Unity.Netcode.Components
                     stateChangeDetected = true;
                     //Debug.Log($"[Cross-Fade] To-Hash: {nt.fullPathHash} | TI-Duration: ({tt.duration}) | TI-Norm: ({tt.normalizedTime}) | From-Hash: ({m_AnimationHash[layer]}) | SI-FPHash: ({st.fullPathHash}) | SI-Norm: ({st.normalizedTime})");
                 }
-                // If we are not transitioned into the "any state" and the animator transition isn't a full path hash (layer to layer) and our pre-built destination state to transition does not contain the
-                // current layer (i.e. transitioning into a state from another layer) =or= we do contain the layer and the layer contains state to transition to is contained within our pre-built destination
-                // state then we can handle this transition as a non-cross fade state transition between layers.
-                // Otherwise, if we don't enter into this then this is a "trigger transition to some state that is now being transitioned back to the Idle state via trigger" or "Dual Triggers" IDLE<-->State.
-                else if (!tt.anyState && tt.fullPathHash != m_TransitionHash[layer] && (!m_DestinationStateToTransitioninfo.ContainsKey(layer) ||
-                    (m_DestinationStateToTransitioninfo.ContainsKey(layer) && m_DestinationStateToTransitioninfo[layer].ContainsKey(nt.fullPathHash))))
+                else if (!tt.anyState && tt.fullPathHash != m_TransitionHash[layer])
                 {
                     // first time in this transition for this layer
                     m_TransitionHash[layer] = tt.fullPathHash;
@@ -869,10 +841,6 @@ namespace Unity.Netcode.Components
                     animState.CrossFade = false;
                     animState.Transition = true;
                     animState.NormalizedTime = tt.normalizedTime;
-                    if (m_DestinationStateToTransitioninfo.ContainsKey(layer) && m_DestinationStateToTransitioninfo[layer].ContainsKey(nt.fullPathHash))
-                    {
-                        animState.DestinationStateHash = nt.fullPathHash;
-                    }
                     stateChangeDetected = true;
                     //Debug.Log($"[Transition] TI-Duration: ({tt.duration}) | TI-Norm: ({tt.normalizedTime}) | From-Hash: ({m_AnimationHash[layer]}) |SI-FPHash: ({st.fullPathHash}) | SI-Norm: ({st.normalizedTime})");
                 }
@@ -939,11 +907,6 @@ namespace Unity.Netcode.Components
             // Send an AnimationMessage only if there are dirty AnimationStates to send
             if (m_AnimationMessage.IsDirtyCount > 0)
             {
-                if (NetworkManager.DistributedAuthorityMode)
-                {
-                    SendAnimStateRpc(m_AnimationMessage);
-                }
-                else
                 if (!IsServer && IsOwner)
                 {
                     SendAnimStateServerRpc(m_AnimationMessage);
@@ -952,14 +915,8 @@ namespace Unity.Netcode.Components
                 {
                     // Just notify all remote clients and not the local server
                     m_ClientSendList.Clear();
-                    foreach (var clientId in NetworkManager.ConnectedClientsIds)
-                    {
-                        if (clientId == NetworkManager.LocalClientId || !NetworkObject.Observers.Contains(clientId))
-                        {
-                            continue;
-                        }
-                        m_ClientSendList.Add(clientId);
-                    }
+                    m_ClientSendList.AddRange(NetworkManager.ConnectedClientsIds);
+                    m_ClientSendList.Remove(NetworkManager.LocalClientId);
                     m_ClientRpcParams.Send.TargetClientIds = m_ClientSendList;
                     SendAnimStateClientRpc(m_AnimationMessage, m_ClientRpcParams);
                 }
@@ -974,33 +931,20 @@ namespace Unity.Netcode.Components
             {
                 Parameters = m_ParameterWriter.ToArray()
             };
-            if (NetworkManager.DistributedAuthorityMode)
+
+            if (!IsServer)
             {
-                if (IsOwner)
-                {
-                    SendParametersUpdateRpc(parametersMessage);
-                }
-                else
-                {
-                    Debug.LogError($"[{name}][Client-{NetworkManager.LocalClientId}] Attempting to send parameter updates but not the owner!");
-                }
+                SendParametersUpdateServerRpc(parametersMessage);
             }
             else
             {
-                if (!IsServer)
+                if (sendDirect)
                 {
-                    SendParametersUpdateServerRpc(parametersMessage);
+                    SendParametersUpdateClientRpc(parametersMessage, clientRpcParams);
                 }
                 else
                 {
-                    if (sendDirect)
-                    {
-                        SendParametersUpdateClientRpc(parametersMessage, clientRpcParams);
-                    }
-                    else
-                    {
-                        m_NetworkAnimatorStateChangeHandler.SendParameterUpdate(parametersMessage, clientRpcParams);
-                    }
+                    m_NetworkAnimatorStateChangeHandler.SendParameterUpdate(parametersMessage, clientRpcParams);
                 }
             }
         }
@@ -1270,15 +1214,9 @@ namespace Unity.Netcode.Components
                 if (NetworkManager.ConnectedClientsIds.Count > (IsHost ? 2 : 1))
                 {
                     m_ClientSendList.Clear();
-                    foreach (var clientId in NetworkManager.ConnectedClientsIds)
-                    {
-                        if (clientId == serverRpcParams.Receive.SenderClientId || clientId == NetworkManager.ServerClientId || !NetworkObject.Observers.Contains(clientId))
-                        {
-                            continue;
-                        }
-                        m_ClientSendList.Add(clientId);
-                    }
-
+                    m_ClientSendList.AddRange(NetworkManager.ConnectedClientsIds);
+                    m_ClientSendList.Remove(serverRpcParams.Receive.SenderClientId);
+                    m_ClientSendList.Remove(NetworkManager.ServerClientId);
                     m_ClientRpcParams.Send.TargetClientIds = m_ClientSendList;
                     m_NetworkAnimatorStateChangeHandler.SendParameterUpdate(parametersUpdate, m_ClientRpcParams);
                 }
@@ -1286,19 +1224,10 @@ namespace Unity.Netcode.Components
         }
 
         /// <summary>
-        /// 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
+        /// Updates the client's animator's parameters
         /// </summary>
         [ClientRpc]
-        internal void SendParametersUpdateClientRpc(ParametersUpdateMessage parametersUpdate, ClientRpcParams clientRpcParams = default)
+        internal unsafe void SendParametersUpdateClientRpc(ParametersUpdateMessage parametersUpdate, ClientRpcParams clientRpcParams = default)
         {
             var isServerAuthoritative = IsServerAuthoritative();
             if (!isServerAuthoritative && !IsOwner || isServerAuthoritative)
@@ -1312,7 +1241,7 @@ namespace Unity.Netcode.Components
         /// The server sets its local state and then forwards the message to the remaining clients
         /// </summary>
         [ServerRpc]
-        private void SendAnimStateServerRpc(AnimationMessage animationMessage, ServerRpcParams serverRpcParams = default)
+        private unsafe void SendAnimStateServerRpc(AnimationMessage animationMessage, ServerRpcParams serverRpcParams = default)
         {
             if (IsServerAuthoritative())
             {
@@ -1333,14 +1262,9 @@ namespace Unity.Netcode.Components
                 if (NetworkManager.ConnectedClientsIds.Count > (IsHost ? 2 : 1))
                 {
                     m_ClientSendList.Clear();
-                    foreach (var clientId in NetworkManager.ConnectedClientsIds)
-                    {
-                        if (clientId == serverRpcParams.Receive.SenderClientId || clientId == NetworkManager.ServerClientId || !NetworkObject.Observers.Contains(clientId))
-                        {
-                            continue;
-                        }
-                        m_ClientSendList.Add(clientId);
-                    }
+                    m_ClientSendList.AddRange(NetworkManager.ConnectedClientsIds);
+                    m_ClientSendList.Remove(serverRpcParams.Receive.SenderClientId);
+                    m_ClientSendList.Remove(NetworkManager.ServerClientId);
                     m_ClientRpcParams.Send.TargetClientIds = m_ClientSendList;
                     m_NetworkAnimatorStateChangeHandler.SendAnimationUpdate(animationMessage, m_ClientRpcParams);
                 }
@@ -1348,44 +1272,26 @@ namespace Unity.Netcode.Components
         }
 
         /// <summary>
-        /// Client-Server: Internally-called RPC client-side receiving function to update animation states
+        /// Internally-called RPC client receiving function to update some animation state on a client
         /// </summary>
         [ClientRpc]
-        internal void SendAnimStateClientRpc(AnimationMessage animationMessage, ClientRpcParams clientRpcParams = default)
+        internal unsafe void SendAnimStateClientRpc(AnimationMessage animationMessage, ClientRpcParams clientRpcParams = default)
         {
-            ProcessAnimStates(animationMessage);
-        }
-
-        /// <summary>
-        /// Distributed Authority: Internally-called RPC non-authority receiving function to update animation states
-        /// </summary>
-        [Rpc(SendTo.NotAuthority)]
-        internal void SendAnimStateRpc(AnimationMessage animationMessage)
-        {
-            ProcessAnimStates(animationMessage);
-        }
-
-        private void ProcessAnimStates(AnimationMessage animationMessage)
-        {
-            if (HasAuthority)
+            // This should never happen
+            if (IsHost)
             {
                 if (NetworkManager.LogLevel == LogLevel.Developer)
                 {
-                    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.");
+                    NetworkLog.LogWarning("Detected the Host is sending itself animation updates! Please report this issue.");
                 }
                 return;
             }
-
             foreach (var animationState in animationMessage.AnimationStates)
             {
                 UpdateAnimationState(animationState);
             }
         }
 
-
-
         /// <summary>
         /// Server-side trigger state update request
         /// The server sets its local state and then forwards the message to the remaining clients
@@ -1407,14 +1313,9 @@ namespace Unity.Netcode.Components
             InternalSetTrigger(animationTriggerMessage.Hash, animationTriggerMessage.IsTriggerSet);
 
             m_ClientSendList.Clear();
-            foreach (var clientId in NetworkManager.ConnectedClientsIds)
-            {
-                if (clientId == NetworkManager.ServerClientId || !NetworkObject.Observers.Contains(clientId))
-                {
-                    continue;
-                }
-                m_ClientSendList.Add(clientId);
-            }
+            m_ClientSendList.AddRange(NetworkManager.ConnectedClientsIds);
+            m_ClientSendList.Remove(NetworkManager.ServerClientId);
+
             if (IsServerAuthoritative())
             {
                 m_NetworkAnimatorStateChangeHandler.QueueTriggerUpdateToClient(animationTriggerMessage, m_ClientRpcParams);
@@ -1435,18 +1336,7 @@ namespace Unity.Netcode.Components
         }
 
         /// <summary>
-        /// 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
+        /// 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>
@@ -1471,26 +1361,15 @@ 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.
-            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))
+            if (IsOwner || IsServer)
             {
+                var animTriggerMessage = new AnimationTriggerMessage() { Hash = hash, IsTriggerSet = setTrigger };
                 if (IsServer)
                 {
                     /// <see cref="UpdatePendingTriggerStates"/> as to why we queue

Components/NetworkDeltaPosition.cs

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

Components/NetworkRigidbody.cs

@@ -0,0 +1,113 @@
+#if COM_UNITY_MODULES_PHYSICS
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+    /// <summary>
+    /// 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))]
+    [AddComponentMenu("Netcode/Network Rigidbody")]
+    public class NetworkRigidbody : NetworkBehaviour
+    {
+        /// <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()
+        {
+            m_NetworkTransform = GetComponent<NetworkTransform>();
+            m_IsServerAuthoritative = m_NetworkTransform.IsServerAuthoritative();
+
+            SetupRigidBody();
+        }
+
+        /// <summary>
+        /// If the current <see cref="NetworkTransform"/> has authority,
+        /// then use the <see cref="RigidBody"/> interpolation strategy,
+        /// if the <see cref="NetworkTransform"/> is handling interpolation,
+        /// set interpolation to none on the <see cref="RigidBody"/>
+        /// <br/>
+        /// Turn off physics for the rigid body until spawned, otherwise
+        /// clients can run fixed update before the first
+        /// full <see cref="NetworkTransform"/> update
+        /// </summary>
+        private void SetupRigidBody()
+        {
+            m_Rigidbody = GetComponent<Rigidbody>();
+            m_OriginalInterpolation = m_Rigidbody.interpolation;
+
+            m_Rigidbody.interpolation = m_IsAuthority ? m_OriginalInterpolation : (m_NetworkTransform.Interpolate ? RigidbodyInterpolation.None : m_OriginalInterpolation);
+            m_Rigidbody.isKinematic = true;
+        }
+
+        /// <summary>
+        /// For owner authoritative (i.e. ClientNetworkTransform)
+        /// we adjust our authority when we gain ownership
+        /// </summary>
+        public override void OnGainedOwnership()
+        {
+            UpdateOwnershipAuthority();
+        }
+
+        /// <summary>
+        /// For owner authoritative(i.e. ClientNetworkTransform)
+        /// we adjust our authority when we have lost ownership
+        /// </summary>
+        public override void OnLostOwnership()
+        {
+            UpdateOwnershipAuthority();
+        }
+
+        /// <summary>
+        /// Sets the authority differently depending upon
+        /// whether it is server or owner authoritative
+        /// </summary>
+        private void UpdateOwnershipAuthority()
+        {
+            if (m_IsServerAuthoritative)
+            {
+                m_IsAuthority = NetworkManager.IsServer;
+            }
+            else
+            {
+                m_IsAuthority = IsOwner;
+            }
+
+            // If you have authority then you are not kinematic
+            m_Rigidbody.isKinematic = !m_IsAuthority;
+
+            // Set interpolation of the Rigidbody based on authority
+            // With authority: let local transform handle interpolation
+            // Without authority: let the NetworkTransform handle interpolation
+            m_Rigidbody.interpolation = m_IsAuthority ? m_OriginalInterpolation : RigidbodyInterpolation.None;
+        }
+
+        /// <inheritdoc />
+        public override void OnNetworkSpawn()
+        {
+            UpdateOwnershipAuthority();
+        }
+
+        /// <inheritdoc />
+        public override void OnNetworkDespawn()
+        {
+            m_Rigidbody.interpolation = m_OriginalInterpolation;
+            // Turn off physics for the rigid body until spawned, otherwise
+            // non-owners can run fixed updates before the first full
+            // NetworkTransform update and physics will be applied (i.e. gravity, etc)
+            m_Rigidbody.isKinematic = true;
+        }
+    }
+}
+#endif // COM_UNITY_MODULES_PHYSICS

Components/NetworkRigidbody2D.cs

@@ -0,0 +1,88 @@
+#if COM_UNITY_MODULES_PHYSICS2D
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+    /// <summary>
+    /// 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))]
+    [AddComponentMenu("Netcode/Network Rigidbody 2D")]
+    public class NetworkRigidbody2D : NetworkBehaviour
+    {
+        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()
+        {
+            m_Rigidbody = GetComponent<Rigidbody2D>();
+            m_NetworkTransform = GetComponent<NetworkTransform>();
+
+            // 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;
+        }
+
+        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();
+        }
+    }
+}
+#endif // COM_UNITY_MODULES_PHYSICS2D

Components/QuaternionCompressor.cs

@@ -14,7 +14,7 @@ namespace Unity.Netcode
     /// 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 number avoids potential loss of precision in the smallest three values.
+    /// Using the largest the number avoids potential loss of precision in the smallest three values.
     /// </remarks>
     public static class QuaternionCompressor
     {

Components/com.unity.netcode.components.asmdef

@@ -0,0 +1,27 @@
+{
+    "name": "Unity.Netcode.Components",
+    "rootNamespace": "Unity.Netcode.Components",
+    "references": [
+        "Unity.Netcode.Runtime",
+        "Unity.Collections",
+        "Unity.Mathematics"
+    ],
+    "allowUnsafeCode": true,
+    "versionDefines": [
+        {
+            "name": "com.unity.modules.animation",
+            "expression": "",
+            "define": "COM_UNITY_MODULES_ANIMATION"
+        },
+        {
+            "name": "com.unity.modules.physics",
+            "expression": "",
+            "define": "COM_UNITY_MODULES_PHYSICS"
+        },
+        {
+            "name": "com.unity.modules.physics2d",
+            "expression": "",
+            "define": "COM_UNITY_MODULES_PHYSICS2D"
+        }
+    ]
+}

Components/com.unity.netcode.components.asmdef.meta

@@ -1,7 +1,6 @@
 fileFormatVersion: 2
-guid: 7b4da27c6efa9684893f85f5d3ad80e6
-folderAsset: yes
-DefaultImporter:
+guid: 3b8ed52f1b5c64994af4c4e0aa4b6c4b
+AssemblyDefinitionImporter:
   externalObjects: {}
   userData: 
   assetBundleName: 

Editor/AnticipatedNetworkTransformEditor.cs

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

Editor/AnticipatedNetworkTransformEditor.cs.meta

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

Editor/CodeGen/NetworkBehaviourILPP.cs

@@ -27,8 +27,7 @@ namespace Unity.Netcode.Editor.CodeGen
 
         public override ILPPInterface GetInstance() => this;
 
-        public override bool WillProcess(ICompiledAssembly compiledAssembly) => compiledAssembly.Name == CodeGenHelpers.RuntimeAssemblyName ||
-            compiledAssembly.References.Any(filePath => Path.GetFileNameWithoutExtension(filePath) == CodeGenHelpers.RuntimeAssemblyName);
+        public override bool WillProcess(ICompiledAssembly compiledAssembly) => compiledAssembly.References.Any(filePath => Path.GetFileNameWithoutExtension(filePath) == CodeGenHelpers.RuntimeAssemblyName);
 
         private readonly List<DiagnosticMessage> m_Diagnostics = new List<DiagnosticMessage>();
 
@@ -722,7 +721,7 @@ namespace Unity.Netcode.Editor.CodeGen
                     continue;
                 }
 
-                if (networkVariableSerializationTypesTypeDef == null && netcodeTypeDef.Name == nameof(NetworkVariableSerializationTypedInitializers))
+                if (networkVariableSerializationTypesTypeDef == null && netcodeTypeDef.Name == nameof(NetworkVariableSerializationTypes))
                 {
                     networkVariableSerializationTypesTypeDef = netcodeTypeDef;
                     continue;
@@ -1008,103 +1007,103 @@ namespace Unity.Netcode.Editor.CodeGen
 
                 switch (method.Name)
                 {
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_UnmanagedByMemcpy):
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpy_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_UnmanagedByMemcpyArray):
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpyArray):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyArray_MethodRef = method;
                         break;
 
 #if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_UnmanagedByMemcpyList):
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpyList):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyList_MethodRef = method;
                         break;
 #endif
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_UnmanagedINetworkSerializable):
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializable):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializable_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_UnmanagedINetworkSerializableArray):
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializableArray):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableArray_MethodRef = method;
                         break;
 
 #if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_UnmanagedINetworkSerializableList):
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializableList):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableList_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_NativeHashSet):
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_NativeHashSet):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_NativeHashSet_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_NativeHashMap):
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_NativeHashMap):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_NativeHashMap_MethodRef = method;
                         break;
 #endif
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_List):
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_List):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_List_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_HashSet):
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_HashSet):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_HashSet_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_Dictionary):
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_Dictionary):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_Dictionary_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_ManagedINetworkSerializable):
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_ManagedINetworkSerializable):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_ManagedINetworkSerializable_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_FixedString):
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_FixedString):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_FixedString_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_FixedStringArray):
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_FixedStringArray):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringArray_MethodRef = method;
                         break;
 
 #if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_FixedStringList):
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_FixedStringList):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringList_MethodRef = method;
                         break;
 #endif
 
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_ManagedIEquatable):
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_ManagedIEquatable):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedIEquatable_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_UnmanagedIEquatable):
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatable_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_UnmanagedIEquatableArray):
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatableArray):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableArray_MethodRef = method;
                         break;
 
 #if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_UnmanagedIEquatableList):
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatableList):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableList_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_NativeHashSet):
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_NativeHashSet):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_NativeHashSet_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_NativeHashMap):
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_NativeHashMap):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_NativeHashMap_MethodRef = method;
                         break;
 #endif
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_List):
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_List):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_List_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_HashSet):
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_HashSet):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_HashSet_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_Dictionary):
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_Dictionary):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_Dictionary_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_UnmanagedValueEquals):
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEquals):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEquals_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_UnmanagedValueEqualsArray):
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEqualsArray):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsArray_MethodRef = method;
                         break;
 #if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_UnmanagedValueEqualsList):
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEqualsList):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsList_MethodRef = method;
                         break;
 #endif
-                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_ManagedClassEquals):
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_ManagedClassEquals):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedClassEquals_MethodRef = method;
                         break;
                 }

Editor/Configuration/NetcodeForGameObjectsSettings.cs

@@ -5,7 +5,6 @@ namespace Unity.Netcode.Editor.Configuration
     internal class NetcodeForGameObjectsEditorSettings
     {
         internal const string AutoAddNetworkObjectIfNoneExists = "AutoAdd-NetworkObject-When-None-Exist";
-        internal const string CheckForNetworkObject = "NetworkBehaviour-Check-For-NetworkObject";
         internal const string InstallMultiplayerToolsTipDismissedPlayerPrefKey = "Netcode_Tip_InstallMPTools_Dismissed";
 
         internal static int GetNetcodeInstallMultiplayerToolTips()
@@ -29,7 +28,7 @@ namespace Unity.Netcode.Editor.Configuration
             {
                 return EditorPrefs.GetBool(AutoAddNetworkObjectIfNoneExists);
             }
-            // Default for this is false
+
             return false;
         }
 
@@ -37,20 +36,5 @@ namespace Unity.Netcode.Editor.Configuration
         {
             EditorPrefs.SetBool(AutoAddNetworkObjectIfNoneExists, autoAddSetting);
         }
-
-        internal static bool GetCheckForNetworkObjectSetting()
-        {
-            if (EditorPrefs.HasKey(CheckForNetworkObject))
-            {
-                return EditorPrefs.GetBool(CheckForNetworkObject);
-            }
-            // Default for this is true
-            return true;
-        }
-
-        internal static void SetCheckForNetworkObjectSetting(bool checkForNetworkObject)
-        {
-            EditorPrefs.SetBool(CheckForNetworkObject, checkForNetworkObject);
-        }
     }
 }

Editor/Configuration/NetcodeSettingsProvider.cs

@@ -19,7 +19,7 @@ namespace Unity.Netcode.Editor.Configuration
         {
             // First parameter is the path in the Settings window.
             // Second parameter is the scope of this setting: it only appears in the Settings window for the Project scope.
-            var provider = new SettingsProvider("Project/Multiplayer/NetcodeForGameObjects", SettingsScope.Project)
+            var provider = new SettingsProvider("Project/NetcodeForGameObjects", SettingsScope.Project)
             {
                 label = "Netcode for GameObjects",
                 keywords = new[] { "netcode", "editor" },
@@ -81,7 +81,6 @@ namespace Unity.Netcode.Editor.Configuration
 
         internal static NetcodeSettingsLabel NetworkObjectsSectionLabel;
         internal static NetcodeSettingsToggle AutoAddNetworkObjectToggle;
-        internal static NetcodeSettingsToggle CheckForNetworkObjectToggle;
         internal static NetcodeSettingsLabel MultiplayerToolsLabel;
         internal static NetcodeSettingsToggle MultiplayerToolTipStatusToggle;
 
@@ -104,11 +103,6 @@ namespace Unity.Netcode.Editor.Configuration
                 AutoAddNetworkObjectToggle = new NetcodeSettingsToggle("Auto-Add NetworkObject Component", "When enabled, NetworkObject components are automatically added to GameObjects when NetworkBehaviour components are added first.", 20);
             }
 
-            if (CheckForNetworkObjectToggle == null)
-            {
-                CheckForNetworkObjectToggle = new NetcodeSettingsToggle("Check for NetworkObject Component", "When disabled, the automatic check on NetworkBehaviours for an associated NetworkObject component will not be performed and Auto-Add NetworkObject Component will be disabled.", 20);
-            }
-
             if (MultiplayerToolsLabel == null)
             {
                 MultiplayerToolsLabel = new NetcodeSettingsLabel("Multiplayer Tools", 20);
@@ -126,9 +120,7 @@ namespace Unity.Netcode.Editor.Configuration
             CheckForInitialize();
 
             var autoAddNetworkObjectSetting = NetcodeForGameObjectsEditorSettings.GetAutoAddNetworkObjectSetting();
-            var checkForNetworkObjectSetting = NetcodeForGameObjectsEditorSettings.GetCheckForNetworkObjectSetting();
             var multiplayerToolsTipStatus = NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() == 0;
-
             var settings = NetcodeForGameObjectsProjectSettings.instance;
             var generateDefaultPrefabs = settings.GenerateDefaultNetworkPrefabs;
             var networkPrefabsPath = settings.TempNetworkPrefabsPath;
@@ -142,13 +134,7 @@ namespace Unity.Netcode.Editor.Configuration
             {
                 GUILayout.BeginVertical("Box");
                 NetworkObjectsSectionLabel.DrawLabel();
-
-                autoAddNetworkObjectSetting = AutoAddNetworkObjectToggle.DrawToggle(autoAddNetworkObjectSetting, checkForNetworkObjectSetting);
-                checkForNetworkObjectSetting = CheckForNetworkObjectToggle.DrawToggle(checkForNetworkObjectSetting);
-                if (autoAddNetworkObjectSetting && !checkForNetworkObjectSetting)
-                {
-                    autoAddNetworkObjectSetting = false;
-                }
+                autoAddNetworkObjectSetting = AutoAddNetworkObjectToggle.DrawToggle(autoAddNetworkObjectSetting);
                 GUILayout.EndVertical();
 
                 GUILayout.BeginVertical("Box");
@@ -198,7 +184,6 @@ namespace Unity.Netcode.Editor.Configuration
             if (EditorGUI.EndChangeCheck())
             {
                 NetcodeForGameObjectsEditorSettings.SetAutoAddNetworkObjectSetting(autoAddNetworkObjectSetting);
-                NetcodeForGameObjectsEditorSettings.SetCheckForNetworkObjectSetting(checkForNetworkObjectSetting);
                 NetcodeForGameObjectsEditorSettings.SetNetcodeInstallMultiplayerToolTips(multiplayerToolsTipStatus ? 0 : 1);
                 settings.GenerateDefaultNetworkPrefabs = generateDefaultPrefabs;
                 settings.TempNetworkPrefabsPath = networkPrefabsPath;
@@ -228,13 +213,10 @@ namespace Unity.Netcode.Editor.Configuration
     {
         private GUIContent m_ToggleContent;
 
-        public bool DrawToggle(bool currentSetting, bool enabled = true)
+        public bool DrawToggle(bool currentSetting)
         {
             EditorGUIUtility.labelWidth = m_LabelSize;
-            GUI.enabled = enabled;
-            var returnValue = EditorGUILayout.Toggle(m_ToggleContent, currentSetting, m_LayoutWidth);
-            GUI.enabled = true;
-            return returnValue;
+            return EditorGUILayout.Toggle(m_ToggleContent, currentSetting, m_LayoutWidth);
         }
 
         public NetcodeSettingsToggle(string labelText, string toolTip, float layoutOffset)

Editor/NetcodeEditorBase.cs

@@ -1,62 +0,0 @@
-using System;
-using UnityEditor;
-using UnityEngine;
-
-namespace Unity.Netcode.Editor
-{
-    /// <summary>
-    /// The base Netcode Editor helper class to display derived <see cref="MonoBehaviour"/> based components <br />
-    /// where each child generation's properties will be displayed within a FoldoutHeaderGroup.
-    /// </summary>
-    [CanEditMultipleObjects]
-    public partial class NetcodeEditorBase<TT> : UnityEditor.Editor where TT : MonoBehaviour
-    {
-        /// <inheritdoc/>
-        public virtual void OnEnable()
-        {
-        }
-
-        /// <summary>
-        /// Helper method to draw the properties of the specified child type <typeparamref name="T"/> component within a FoldoutHeaderGroup.
-        /// </summary>
-        /// <typeparam name="T">The specific child type that should have its properties drawn.</typeparam>
-        /// <param name="type">The component type of the <see cref="UnityEditor.Editor.target"/>.</param>
-        /// <param name="displayProperties">The <see cref="Action"/> to invoke that will draw the type <typeparamref name="T"/> properties.</param>
-        /// <param name="expanded">The <typeparamref name="T"/> current expanded property value</param>
-        /// <param name="setExpandedProperty">The <see cref="Action{bool}"/> invoked to apply the updated <paramref name="expanded"/> value.</param>
-        protected void DrawFoldOutGroup<T>(Type type, Action displayProperties, bool expanded, Action<bool> setExpandedProperty)
-        {
-            var baseClass = target as TT;
-            EditorGUI.BeginChangeCheck();
-            serializedObject.Update();
-            var currentClass = typeof(T);
-            if (type.IsSubclassOf(currentClass) || (!type.IsSubclassOf(currentClass) && currentClass.IsSubclassOf(typeof(TT))))
-            {
-                var expandedValue = EditorGUILayout.BeginFoldoutHeaderGroup(expanded, $"{currentClass.Name} Properties");
-                if (expandedValue)
-                {
-                    EditorGUILayout.EndFoldoutHeaderGroup();
-                    displayProperties.Invoke();
-                }
-                else
-                {
-                    EditorGUILayout.EndFoldoutHeaderGroup();
-                }
-                EditorGUILayout.Space();
-                setExpandedProperty.Invoke(expandedValue);
-            }
-            else
-            {
-                displayProperties.Invoke();
-            }
-            serializedObject.ApplyModifiedProperties();
-            EditorGUI.EndChangeCheck();
-        }
-
-        /// <inheritdoc/>
-        public override void OnInspectorGUI()
-        {
-            serializedObject.ApplyModifiedProperties();
-        }
-    }
-}

Editor/NetcodeEditorBase.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 4ce97256a2d80f94bb340e13c71a24b8

Editor/NetworkBehaviourEditor.cs

@@ -301,8 +301,9 @@ namespace Unity.Netcode.Editor
 
                 expanded = false;
             }
-            EditorGUI.EndChangeCheck();
+
             serializedObject.ApplyModifiedProperties();
+            EditorGUI.EndChangeCheck();
         }
 
         /// <summary>
@@ -351,12 +352,6 @@ namespace Unity.Netcode.Editor
                 return;
             }
 
-            // If this automatic check is disabled, then do not perform this check.
-            if (!NetcodeForGameObjectsEditorSettings.GetCheckForNetworkObjectSetting())
-            {
-                return;
-            }
-
             // Now get the root parent transform to the current GameObject (or itself)
             var rootTransform = GetRootParentTransform(gameObject.transform);
             if (!rootTransform.TryGetComponent<NetworkManager>(out var networkManager))

Editor/NetworkManagerEditor.cs

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

Editor/NetworkManagerHelper.cs

@@ -61,12 +61,6 @@ namespace Unity.Netcode.Editor
                     {
                         s_LastKnownNetworkManagerParents.Clear();
                         ScenesInBuildActiveSceneCheck();
-                        EditorApplication.hierarchyChanged -= EditorApplication_hierarchyChanged;
-                        break;
-                    }
-                case PlayModeStateChange.EnteredEditMode:
-                    {
-                        EditorApplication.hierarchyChanged += EditorApplication_hierarchyChanged;
                         break;
                     }
             }
@@ -116,12 +110,6 @@ namespace Unity.Netcode.Editor
         /// </summary>
         private static void EditorApplication_hierarchyChanged()
         {
-            if (Application.isPlaying)
-            {
-                EditorApplication.hierarchyChanged -= EditorApplication_hierarchyChanged;
-                return;
-            }
-
             var allNetworkManagers = Resources.FindObjectsOfTypeAll<NetworkManager>();
             foreach (var networkManager in allNetworkManagers)
             {

Editor/NetworkObjectEditor.cs

@@ -1,7 +1,4 @@
 using System.Collections.Generic;
-#if BYPASS_DEFAULT_ENUM_DRAWER && MULTIPLAYER_SERVICES_SDK_INSTALLED
-using System.Linq;
-#endif
 using UnityEditor;
 using UnityEngine;
 
@@ -52,10 +49,6 @@ 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());
@@ -145,52 +138,4 @@ namespace Unity.Netcode.Editor
             NetworkBehaviourEditor.CheckForNetworkObject(m_GameObject, true);
         }
     }
-
-    // Keeping this here just in case, but it appears that in Unity 6 the visual bugs with
-    // enum flags is resolved
-#if BYPASS_DEFAULT_ENUM_DRAWER && MULTIPLAYER_SERVICES_SDK_INSTALLED
-    [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();
-        }
-    }
-#endif
 }

Editor/NetworkRigidbodyBaseEditor.cs

@@ -1,42 +0,0 @@
-#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
-using Unity.Netcode.Components;
-using UnityEditor;
-
-namespace Unity.Netcode.Editor
-{
-    [CustomEditor(typeof(NetworkRigidbodyBase), true)]
-    [CanEditMultipleObjects]
-    public class NetworkRigidbodyBaseEditor : NetcodeEditorBase<NetworkBehaviour>
-    {
-        private SerializedProperty m_UseRigidBodyForMotion;
-        private SerializedProperty m_AutoUpdateKinematicState;
-        private SerializedProperty m_AutoSetKinematicOnDespawn;
-
-
-        public override void OnEnable()
-        {
-            m_UseRigidBodyForMotion = serializedObject.FindProperty(nameof(NetworkRigidbodyBase.UseRigidBodyForMotion));
-            m_AutoUpdateKinematicState = serializedObject.FindProperty(nameof(NetworkRigidbodyBase.AutoUpdateKinematicState));
-            m_AutoSetKinematicOnDespawn = serializedObject.FindProperty(nameof(NetworkRigidbodyBase.AutoSetKinematicOnDespawn));
-
-            base.OnEnable();
-        }
-
-        private void DisplayNetworkRigidbodyProperties()
-        {
-            EditorGUILayout.PropertyField(m_UseRigidBodyForMotion);
-            EditorGUILayout.PropertyField(m_AutoUpdateKinematicState);
-            EditorGUILayout.PropertyField(m_AutoSetKinematicOnDespawn);
-        }
-
-        /// <inheritdoc/>
-        public override void OnInspectorGUI()
-        {
-            var networkRigidbodyBase = target as NetworkRigidbodyBase;
-            void SetExpanded(bool expanded) { networkRigidbodyBase.NetworkRigidbodyBaseExpanded = expanded; };
-            DrawFoldOutGroup<NetworkRigidbodyBase>(networkRigidbodyBase.GetType(), DisplayNetworkRigidbodyProperties, networkRigidbodyBase.NetworkRigidbodyBaseExpanded, SetExpanded);
-            base.OnInspectorGUI();
-        }
-    }
-}
-#endif

Editor/NetworkRigidbodyBaseEditor.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 06561c57f81a6354f8bb16076f1de3a9

Editor/NetworkTransformEditor.cs

@@ -8,11 +8,8 @@ namespace Unity.Netcode.Editor
     /// The <see cref="CustomEditor"/> for <see cref="NetworkTransform"/>
     /// </summary>
     [CustomEditor(typeof(NetworkTransform), true)]
-    [CanEditMultipleObjects]
-    public class NetworkTransformEditor : NetcodeEditorBase<NetworkTransform>
+    public class NetworkTransformEditor : UnityEditor.Editor
     {
-        private SerializedProperty m_SwitchTransformSpaceWhenParented;
-        private SerializedProperty m_TickSyncChildren;
         private SerializedProperty m_UseUnreliableDeltas;
         private SerializedProperty m_SyncPositionXProperty;
         private SerializedProperty m_SyncPositionYProperty;
@@ -33,7 +30,6 @@ namespace Unity.Netcode.Editor
         private SerializedProperty m_UseQuaternionCompression;
         private SerializedProperty m_UseHalfFloatPrecision;
         private SerializedProperty m_SlerpPosition;
-        private SerializedProperty m_AuthorityMode;
 
         private static int s_ToggleOffset = 45;
         private static float s_MaxRowWidth = EditorGUIUtility.labelWidth + EditorGUIUtility.fieldWidth + 5;
@@ -41,11 +37,11 @@ namespace Unity.Netcode.Editor
         private static GUIContent s_RotationLabel = EditorGUIUtility.TrTextContent("Rotation");
         private static GUIContent s_ScaleLabel = EditorGUIUtility.TrTextContent("Scale");
 
+        public virtual bool HideInterpolateValue => false;
+
         /// <inheritdoc/>
-        public override void OnEnable()
+        public void OnEnable()
         {
-            m_SwitchTransformSpaceWhenParented = serializedObject.FindProperty(nameof(NetworkTransform.SwitchTransformSpaceWhenParented));
-            m_TickSyncChildren = serializedObject.FindProperty(nameof(NetworkTransform.TickSyncChildren));
             m_UseUnreliableDeltas = serializedObject.FindProperty(nameof(NetworkTransform.UseUnreliableDeltas));
             m_SyncPositionXProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionX));
             m_SyncPositionYProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionY));
@@ -65,14 +61,12 @@ namespace Unity.Netcode.Editor
             m_UseQuaternionCompression = serializedObject.FindProperty(nameof(NetworkTransform.UseQuaternionCompression));
             m_UseHalfFloatPrecision = serializedObject.FindProperty(nameof(NetworkTransform.UseHalfFloatPrecision));
             m_SlerpPosition = serializedObject.FindProperty(nameof(NetworkTransform.SlerpPosition));
-            m_AuthorityMode = serializedObject.FindProperty(nameof(NetworkTransform.AuthorityMode));
-            base.OnEnable();
         }
 
-        private void DisplayNetworkTransformProperties()
+        /// <inheritdoc/>
+        public override void OnInspectorGUI()
         {
-            var networkTransform = target as NetworkTransform;
-            EditorGUILayout.LabelField("Axis to Synchronize", EditorStyles.boldLabel);
+            EditorGUILayout.LabelField("Syncing", EditorStyles.boldLabel);
             {
                 GUILayout.BeginHorizontal();
 
@@ -134,11 +128,6 @@ namespace Unity.Netcode.Editor
                 GUILayout.EndHorizontal();
             }
 
-            EditorGUILayout.Space();
-            EditorGUILayout.LabelField("Authority", EditorStyles.boldLabel);
-            {
-                EditorGUILayout.PropertyField(m_AuthorityMode);
-            }
             EditorGUILayout.Space();
             EditorGUILayout.LabelField("Thresholds", EditorStyles.boldLabel);
             EditorGUILayout.PropertyField(m_PositionThresholdProperty);
@@ -146,20 +135,15 @@ namespace Unity.Netcode.Editor
             EditorGUILayout.PropertyField(m_ScaleThresholdProperty);
             EditorGUILayout.Space();
             EditorGUILayout.LabelField("Delivery", EditorStyles.boldLabel);
-            EditorGUILayout.PropertyField(m_TickSyncChildren);
             EditorGUILayout.PropertyField(m_UseUnreliableDeltas);
             EditorGUILayout.Space();
             EditorGUILayout.LabelField("Configurations", EditorStyles.boldLabel);
-            EditorGUILayout.PropertyField(m_SwitchTransformSpaceWhenParented);
-            if (m_SwitchTransformSpaceWhenParented.boolValue)
-            {
-                m_TickSyncChildren.boolValue = true;
-            }
             EditorGUILayout.PropertyField(m_InLocalSpaceProperty);
-            if (!networkTransform.HideInterpolateValue)
+            if (!HideInterpolateValue)
             {
                 EditorGUILayout.PropertyField(m_InterpolateProperty);
             }
+
             EditorGUILayout.PropertyField(m_SlerpPosition);
             EditorGUILayout.PropertyField(m_UseQuaternionSynchronization);
             if (m_UseQuaternionSynchronization.boolValue)
@@ -172,9 +156,11 @@ namespace Unity.Netcode.Editor
             }
             EditorGUILayout.PropertyField(m_UseHalfFloatPrecision);
 
-#if COM_UNITY_MODULES_PHYSICS
             // if rigidbody is present but network rigidbody is not present
-            if (networkTransform.TryGetComponent<Rigidbody>(out _) && networkTransform.TryGetComponent<NetworkRigidbody>(out _) == false)
+            var go = ((NetworkTransform)target).gameObject;
+
+#if COM_UNITY_MODULES_PHYSICS
+            if (go.TryGetComponent<Rigidbody>(out _) && go.TryGetComponent<NetworkRigidbody>(out _) == false)
             {
                 EditorGUILayout.HelpBox("This GameObject contains a Rigidbody but no NetworkRigidbody.\n" +
                     "Add a NetworkRigidbody component to improve Rigidbody synchronization.", MessageType.Warning);
@@ -182,23 +168,14 @@ namespace Unity.Netcode.Editor
 #endif // COM_UNITY_MODULES_PHYSICS
 
 #if COM_UNITY_MODULES_PHYSICS2D
-            if (networkTransform.TryGetComponent<Rigidbody2D>(out _) && networkTransform.TryGetComponent<NetworkRigidbody2D>(out _) == false)
+            if (go.TryGetComponent<Rigidbody2D>(out _) && go.TryGetComponent<NetworkRigidbody2D>(out _) == false)
             {
                 EditorGUILayout.HelpBox("This GameObject contains a Rigidbody2D but no NetworkRigidbody2D.\n" +
                     "Add a NetworkRigidbody2D component to improve Rigidbody2D synchronization.", MessageType.Warning);
             }
 #endif // COM_UNITY_MODULES_PHYSICS2D
-        }
 
-
-
-        /// <inheritdoc/>
-        public override void OnInspectorGUI()
-        {
-            var networkTransform = target as NetworkTransform;
-            void SetExpanded(bool expanded) { networkTransform.NetworkTransformExpanded = expanded; };
-            DrawFoldOutGroup<NetworkTransform>(networkTransform.GetType(), DisplayNetworkTransformProperties, networkTransform.NetworkTransformExpanded, SetExpanded);
-            base.OnInspectorGUI();
+            serializedObject.ApplyModifiedProperties();
         }
     }
 }

Editor/com.unity.netcode.editor.asmdef

@@ -53,11 +53,6 @@
             "name": "com.unity.transport",
             "expression": "2.0",
             "define": "UTP_TRANSPORT_2_0_ABOVE"
-        },
-        {
-            "name": "com.unity.services.multiplayer",
-            "expression": "0.2.0",
-            "define": "MULTIPLAYER_SERVICES_SDK_INSTALLED"
         }
     ],
     "noEngineReferences": false

LICENSE.md

@@ -1,7 +1,9 @@
-Unity Companion License (UCL License)
+MIT License
 
-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.
+Copyright (c) 2021 Unity Technologies
 
+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/Components/AnticipatedNetworkTransform.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 5abfce83aadd948498d4990c645a017b

Runtime/Components/NetworkRigidBodyBase.cs

@@ -1,884 +0,0 @@
-#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
-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
-    {
-#if UNITY_EDITOR
-        [HideInInspector]
-        [SerializeField]
-        internal bool NetworkRigidbodyBaseExpanded;
-#endif
-
-        /// <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>
-        [Tooltip("When enabled and a NetworkTransform component is attached, the NetworkTransform will use the rigid body for motion and detecting changes in state.")]
-        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;
-
-        protected internal Rigidbody m_InternalRigidbody { get; private set; }
-        protected internal Rigidbody2D m_InternalRigidbody2D { get; private set; }
-
-        internal NetworkTransform NetworkTransform;
-        private float m_TickFrequency;
-        private float m_TickRate;
-
-        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_InternalRigidbody2D = rigidbody2D;
-            m_InternalRigidbody = rigidbody;
-            NetworkTransform = networkTransform;
-
-            if (m_IsRigidbody2D && m_InternalRigidbody2D == null)
-            {
-                m_InternalRigidbody2D = GetComponent<Rigidbody2D>();
-
-            }
-            else if (m_InternalRigidbody == null)
-            {
-                m_InternalRigidbody = GetComponent<Rigidbody>();
-            }
-
-            SetOriginalInterpolation();
-
-            if (NetworkTransform == null)
-            {
-                NetworkTransform = GetComponent<NetworkTransform>();
-            }
-
-            if (NetworkTransform != null)
-            {
-                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);
-            }
-        }
-
-        internal Vector3 GetAdjustedPositionThreshold()
-        {
-            // Since the threshold is a measurement of unity world space units per tick, we will allow for the maximum threshold
-            // to be no greater than the threshold measured in unity world space units per second
-            var thresholdMax = NetworkTransform.PositionThreshold * m_TickRate;
-            // Get the velocity in unity world space units per tick
-            var perTickVelocity = GetLinearVelocity() * m_TickFrequency;
-            // Since a rigid body can have "micro-motion" when allowed to come to rest (based on friction etc), we will allow for
-            // no less than 1/10th the threshold value.
-            var minThreshold = NetworkTransform.PositionThreshold * 0.1f;
-
-            // Finally, we adjust the threshold based on the body's current velocity
-            perTickVelocity.x = Mathf.Clamp(Mathf.Abs(perTickVelocity.x), minThreshold, thresholdMax);
-            perTickVelocity.y = Mathf.Clamp(Mathf.Abs(perTickVelocity.y), minThreshold, thresholdMax);
-            // 2D Rigidbody only moves on x & y axis
-            if (!m_IsRigidbody2D)
-            {
-                perTickVelocity.z = Mathf.Clamp(Mathf.Abs(perTickVelocity.z), minThreshold, thresholdMax);
-            }
-
-            return perTickVelocity;
-        }
-
-        internal Vector3 GetAdjustedRotationThreshold()
-        {
-            // Since the rotation threshold is a measurement pf degrees per tick, we get the maximum threshold
-            // by calculating the threshold in degrees per second.
-            var thresholdMax = NetworkTransform.RotAngleThreshold * m_TickRate;
-            // Angular velocity is expressed in radians per second where as the rotation being checked is in degrees.
-            // Convert the angular velocity to degrees per second and then convert that to degrees per tick.
-            var rotationPerTick = (GetAngularVelocity() * Mathf.Rad2Deg) * m_TickFrequency;
-            var minThreshold = NetworkTransform.RotAngleThreshold * m_TickFrequency;
-
-            // 2D Rigidbody only rotates around Z axis
-            if (!m_IsRigidbody2D)
-            {
-                rotationPerTick.x = Mathf.Clamp(Mathf.Abs(rotationPerTick.x), minThreshold, thresholdMax);
-                rotationPerTick.y = Mathf.Clamp(Mathf.Abs(rotationPerTick.y), minThreshold, thresholdMax);
-            }
-            rotationPerTick.z = Mathf.Clamp(Mathf.Abs(rotationPerTick.z), minThreshold, thresholdMax);
-
-            return rotationPerTick;
-        }
-
-        /// <summary>
-        /// Sets the linear velocity of the Rigidbody.
-        /// </summary>
-        /// <remarks>
-        /// For <see cref="Rigidbody2D"/>, only the x and y components of the <see cref="Vector3"/> are applied.
-        /// </remarks>        
-        public void SetLinearVelocity(Vector3 linearVelocity)
-        {
-            if (m_IsRigidbody2D)
-            {
-#if COM_UNITY_MODULES_PHYSICS2D_LINEAR
-                m_InternalRigidbody2D.linearVelocity = linearVelocity;
-#else
-                m_InternalRigidbody2D.velocity = linearVelocity;
-#endif
-            }
-            else
-            {
-                m_InternalRigidbody.linearVelocity = linearVelocity;
-            }
-        }
-
-        /// <summary>
-        /// Gets the linear velocity of the Rigidbody.
-        /// </summary>
-        /// <remarks>
-        /// For <see cref="Rigidbody2D"/>, the <see cref="Vector3"/> velocity returned is only applied to the x and y components.
-        /// </remarks>
-        /// <returns><see cref="Vector3"/> as the linear velocity</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public Vector3 GetLinearVelocity()
-        {
-            if (m_IsRigidbody2D)
-            {
-#if COM_UNITY_MODULES_PHYSICS2D_LINEAR
-                return m_InternalRigidbody2D.linearVelocity;
-#else
-                return m_InternalRigidbody2D.velocity;
-#endif
-            }
-            else
-            {
-                return m_InternalRigidbody.linearVelocity;
-            }
-        }
-
-        /// <summary>
-        /// Sets the angular velocity for the Rigidbody.
-        /// </summary>
-        /// <remarks>
-        /// For <see cref="Rigidbody2D"/>, the z component of <param name="angularVelocity"/> is only used to set the angular velocity.
-        /// A quick way to pass in a 2D angular velocity component is: <see cref="Vector3.forward"/> * angularVelocity (where angularVelocity is a float)
-        /// </remarks>
-        /// <param name="angularVelocity">the angular velocity to apply to the body</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetAngularVelocity(Vector3 angularVelocity)
-        {
-            if (m_IsRigidbody2D)
-            {
-                m_InternalRigidbody2D.angularVelocity = angularVelocity.z;
-            }
-            else
-            {
-                m_InternalRigidbody.angularVelocity = angularVelocity;
-            }
-        }
-
-        /// <summary>
-        /// Gets the angular velocity for the Rigidbody.
-        /// </summary>
-        /// <remarks>
-        /// For <see cref="Rigidbody2D"/>, the z component of the <see cref="Vector3"/> returned is the angular velocity of the object.
-        /// </remarks>
-        /// <returns>angular velocity as a <see cref="Vector3"/></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public Vector3 GetAngularVelocity()
-        {
-            if (m_IsRigidbody2D)
-            {
-                return Vector3.forward * m_InternalRigidbody2D.angularVelocity;
-            }
-            else
-            {
-                return m_InternalRigidbody.angularVelocity;
-            }
-        }
-
-        /// <summary>
-        /// Gets the position of the Rigidbody
-        /// </summary>
-        /// <returns><see cref="Vector3"/></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public Vector3 GetPosition()
-        {
-            if (m_IsRigidbody2D)
-            {
-                return m_InternalRigidbody2D.position;
-            }
-            else
-            {
-                return m_InternalRigidbody.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_InternalRigidbody2D.rotation;
-                quaternion.eulerAngles = angles;
-                return quaternion;
-            }
-            else
-            {
-                return m_InternalRigidbody.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_InternalRigidbody2D.MovePosition(position);
-            }
-            else
-            {
-                m_InternalRigidbody.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_InternalRigidbody2D.position = position;
-            }
-            else
-            {
-                m_InternalRigidbody.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_InternalRigidbody2D.position = transform.position;
-                m_InternalRigidbody2D.rotation = transform.eulerAngles.z;
-            }
-            else
-            {
-                m_InternalRigidbody.position = transform.position;
-                m_InternalRigidbody.rotation = transform.rotation;
-            }
-        }
-
-        // Used for Rigidbody only (see info on normalized below)
-        private Vector4 m_QuaternionCheck = Vector4.zero;
-
-        /// <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)
-            {
-                var quaternion = Quaternion.identity;
-                var angles = quaternion.eulerAngles;
-                angles.z = m_InternalRigidbody2D.rotation;
-                quaternion.eulerAngles = angles;
-                m_InternalRigidbody2D.MoveRotation(quaternion);
-            }
-            else
-            {
-                // Evidently we need to check to make sure the quaternion is a perfect
-                // magnitude of 1.0f when applying the rotation to a rigid body.
-                m_QuaternionCheck.x = rotation.x;
-                m_QuaternionCheck.y = rotation.y;
-                m_QuaternionCheck.z = rotation.z;
-                m_QuaternionCheck.w = rotation.w;
-                // If the magnitude is greater than 1.0f (even by a very small fractional value), then normalize the quaternion
-                if (m_QuaternionCheck.magnitude != 1.0f)
-                {
-                    rotation.Normalize();
-                }
-                m_InternalRigidbody.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_InternalRigidbody2D.rotation = rotation.eulerAngles.z;
-            }
-            else
-            {
-                m_InternalRigidbody.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_InternalRigidbody2D.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_InternalRigidbody.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_InternalRigidbody2D.IsSleeping())
-                {
-                    m_InternalRigidbody2D.WakeUp();
-                }
-            }
-            else
-            {
-                if (m_InternalRigidbody.IsSleeping())
-                {
-                    m_InternalRigidbody.WakeUp();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Puts the Rigidbody to sleep
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SleepRigidbody()
-        {
-            if (m_IsRigidbody2D)
-            {
-                m_InternalRigidbody2D.Sleep();
-            }
-            else
-            {
-                m_InternalRigidbody.Sleep();
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool IsKinematic()
-        {
-            if (m_IsRigidbody2D)
-            {
-                return m_InternalRigidbody2D.bodyType == RigidbodyType2D.Kinematic;
-            }
-            else
-            {
-                return m_InternalRigidbody.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_InternalRigidbody2D.bodyType = isKinematic ? RigidbodyType2D.Kinematic : RigidbodyType2D.Dynamic;
-            }
-            else
-            {
-                m_InternalRigidbody.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 (NetworkTransform.Interpolate && m_OriginalInterpolation == InterpolationTypes.Extrapolate)
-                {
-                    if (IsKinematic())
-                    {
-                        // If not already set to interpolate then set the Rigidbody to interpolate 
-                        if (m_InternalRigidbody.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 : (NetworkTransform.Interpolate ? InterpolationTypes.None : m_OriginalInterpolation));
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void SetInterpolation(InterpolationTypes interpolationType)
-        {
-            switch (interpolationType)
-            {
-                case InterpolationTypes.None:
-                    {
-                        if (m_IsRigidbody2D)
-                        {
-                            m_InternalRigidbody2D.interpolation = RigidbodyInterpolation2D.None;
-                        }
-                        else
-                        {
-                            m_InternalRigidbody.interpolation = RigidbodyInterpolation.None;
-                        }
-                        break;
-                    }
-                case InterpolationTypes.Interpolate:
-                    {
-                        if (m_IsRigidbody2D)
-                        {
-                            m_InternalRigidbody2D.interpolation = RigidbodyInterpolation2D.Interpolate;
-                        }
-                        else
-                        {
-                            m_InternalRigidbody.interpolation = RigidbodyInterpolation.Interpolate;
-                        }
-                        break;
-                    }
-                case InterpolationTypes.Extrapolate:
-                    {
-                        if (m_IsRigidbody2D)
-                        {
-                            m_InternalRigidbody2D.interpolation = RigidbodyInterpolation2D.Extrapolate;
-                        }
-                        else
-                        {
-                            m_InternalRigidbody.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 (NetworkTransform.IsServerAuthoritative())
-                {
-                    m_IsAuthority = NetworkManager.IsServer;
-                }
-                else
-                {
-                    m_IsAuthority = IsOwner;
-                }
-            }
-
-            if (AutoUpdateKinematicState)
-            {
-                SetIsKinematic(!m_IsAuthority);
-            }
-        }
-
-        /// <inheritdoc />
-        public override void OnNetworkSpawn()
-        {
-            m_TickFrequency = 1.0f / NetworkManager.NetworkConfig.TickRate;
-            m_TickRate = NetworkManager.NetworkConfig.TickRate;
-            UpdateOwnershipAuthority();
-        }
-
-        /// <inheritdoc />
-        public override void OnNetworkDespawn()
-        {
-            if (UseRigidBodyForMotion && HasAuthority)
-            {
-                DetachFromFixedJoint();
-                NetworkRigidbodyConnections.Clear();
-            }
-
-            // 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);
-        }
-
-        // TODO: Possibly provide a NetworkJoint that allows for more options than fixed.
-        // Rigidbodies do not have the concept of "local space", and as such using a fixed joint will hold the object
-        // in place relative to the parent so jitter/stutter does not occur.
-        // Alternately, users can affix the fixed joint to a child GameObject (without a rigid body) of the parent NetworkObject
-        // and then add a NetworkTransform to that in order to get the parented child NetworkObject to move around in "local space"
-        public FixedJoint FixedJoint { get; private set; }
-        public FixedJoint2D FixedJoint2D { get; private set; }
-
-        internal System.Collections.Generic.List<NetworkRigidbodyBase> NetworkRigidbodyConnections = new System.Collections.Generic.List<NetworkRigidbodyBase>();
-        internal NetworkRigidbodyBase ParentBody;
-
-        private bool m_FixedJoint2DUsingGravity;
-        private bool m_OriginalGravitySetting;
-        private float m_OriginalGravityScale;
-
-        /// <summary>
-        /// When using a custom <see cref="NetworkRigidbodyBase"/>, this virtual method is invoked when the
-        /// <see cref="FixedJoint"/> is created in the event any additional adjustments are needed.
-        /// </summary>
-        protected virtual void OnFixedJointCreated()
-        {
-
-        }
-
-        /// <summary>
-        /// When using a custom <see cref="NetworkRigidbodyBase"/>, this virtual method is invoked when the
-        /// <see cref="FixedJoint2D"/> is created in the event any additional adjustments are needed.
-        /// </summary>
-        protected virtual void OnFixedJoint2DCreated()
-        {
-
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void ApplyFixedJoint2D(NetworkRigidbodyBase bodyToConnect, Vector3 position, float connectedMassScale = 0.0f, float massScale = 1.0f, bool useGravity = false, bool zeroVelocity = true)
-        {
-            transform.position = position;
-            m_InternalRigidbody2D.position = position;
-            m_OriginalGravitySetting = bodyToConnect.m_InternalRigidbody.useGravity;
-            m_FixedJoint2DUsingGravity = useGravity;
-
-            if (!useGravity)
-            {
-                m_OriginalGravityScale = m_InternalRigidbody2D.gravityScale;
-                m_InternalRigidbody2D.gravityScale = 0.0f;
-            }
-
-            if (zeroVelocity)
-            {
-#if COM_UNITY_MODULES_PHYSICS2D_LINEAR
-                m_InternalRigidbody2D.linearVelocity = Vector2.zero;
-#else
-                m_InternalRigidbody2D.velocity = Vector2.zero;
-#endif
-                m_InternalRigidbody2D.angularVelocity = 0.0f;
-            }
-
-            FixedJoint2D = gameObject.AddComponent<FixedJoint2D>();
-            FixedJoint2D.connectedBody = bodyToConnect.m_InternalRigidbody2D;
-            OnFixedJoint2DCreated();
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void ApplyFixedJoint(NetworkRigidbodyBase bodyToConnectTo, Vector3 position, float connectedMassScale = 0.0f, float massScale = 1.0f, bool useGravity = false, bool zeroVelocity = true)
-        {
-            transform.position = position;
-            m_InternalRigidbody.position = position;
-            if (zeroVelocity)
-            {
-                m_InternalRigidbody.linearVelocity = Vector3.zero;
-                m_InternalRigidbody.angularVelocity = Vector3.zero;
-            }
-            m_OriginalGravitySetting = m_InternalRigidbody.useGravity;
-            m_InternalRigidbody.useGravity = useGravity;
-            FixedJoint = gameObject.AddComponent<FixedJoint>();
-            FixedJoint.connectedBody = bodyToConnectTo.m_InternalRigidbody;
-            FixedJoint.connectedMassScale = connectedMassScale;
-            FixedJoint.massScale = massScale;
-            OnFixedJointCreated();
-        }
-
-
-        /// <summary>
-        /// Authority Only:
-        /// When invoked and not already attached to a fixed joint, this will connect two rigid bodies with <see cref="UseRigidBodyForMotion"/> enabled.
-        /// Invoke this method on the rigid body you wish to attach to another (i.e. weapon to player, sticky bomb to player/object, etc).
-        /// <seealso cref="FixedJoint"/>
-        /// <seealso cref="FixedJoint2D"/>
-        /// </summary>
-        /// <remarks>
-        /// Parenting relative:
-        /// - This instance can be viewed as the child.
-        /// - The <param name="objectToConnectTo"/> can be viewed as the parent.
-        /// <br/>
-        /// This is the recommended way, as opposed to parenting, to attached/detatch two rigid bodies to one another when <see cref="UseRigidBodyForMotion"/> is enabled.
-        /// For more details on using <see cref="UnityEngine.FixedJoint"/> and <see cref="UnityEngine.FixedJoint2D"/>.
-        /// <br/>
-        /// This provides a simple joint solution between two rigid bodies and serves as an example. You can add different joint types by creating a customized/derived
-        /// version of <see cref="NetworkRigidbodyBase"/>.
-        /// </remarks>
-        /// <param name="objectToConnectTo">The target object to attach to.</param>
-        /// <param name="positionOfConnection">The position of the connection (i.e. where you want the object to be affixed).</param>
-        /// <param name="connectedMassScale">The target object's mass scale relative to this object being attached.</param>
-        /// <param name="massScale">This object's mass scale relative to the target object's.</param>
-        /// <param name="useGravity">Determines if this object will have gravity applied to it along with the object you are connecting this one to (the default is to not use gravity for this object)</param>
-        /// <param name="zeroVelocity">When true (the default), both linear and angular velocities of this object are set to zero.</param>
-        /// <param name="teleportObject">When true (the default), this object will teleport itself to the position of connection.</param>
-        /// <returns>true (success) false (failed)</returns>
-        public bool AttachToFixedJoint(NetworkRigidbodyBase objectToConnectTo, Vector3 positionOfConnection, float connectedMassScale = 0.0f, float massScale = 1.0f, bool useGravity = false, bool zeroVelocity = true, bool teleportObject = true)
-        {
-            if (!UseRigidBodyForMotion)
-            {
-                Debug.LogError($"[{GetType().Name}] {name} does not have {nameof(UseRigidBodyForMotion)} set! Either enable {nameof(UseRigidBodyForMotion)} on this component or do not use a {nameof(FixedJoint)} when parenting under a {nameof(NetworkObject)}.");
-                return false;
-            }
-
-            if (IsKinematic())
-            {
-                Debug.LogError($"[{GetType().Name}] {name} is currently kinematic! You cannot use a {nameof(FixedJoint)} with Kinematic bodies!");
-                return false;
-            }
-
-            if (objectToConnectTo != null)
-            {
-                if (m_IsRigidbody2D)
-                {
-                    ApplyFixedJoint2D(objectToConnectTo, positionOfConnection, connectedMassScale, massScale, useGravity, zeroVelocity);
-                }
-                else
-                {
-                    ApplyFixedJoint(objectToConnectTo, positionOfConnection, connectedMassScale, massScale, useGravity, zeroVelocity);
-                }
-
-                ParentBody = objectToConnectTo;
-                ParentBody.NetworkRigidbodyConnections.Add(this);
-                if (teleportObject)
-                {
-                    NetworkTransform.SetState(teleportDisabled: false);
-                }
-                return true;
-            }
-            return false;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void RemoveFromParentBody()
-        {
-            ParentBody.NetworkRigidbodyConnections.Remove(this);
-            ParentBody = null;
-        }
-
-        /// <summary>
-        /// Authority Only:
-        /// When invoked and already connected to an object via <see cref="FixedJoint"/> or <see cref="FixedJoint2D"/> (depending upon the type of rigid body),
-        /// this will detach from the fixed joint and destroy the fixed joint component.
-        /// </summary>
-        /// <remarks>
-        /// This is the recommended way, as opposed to parenting, to attached/detatch two rigid bodies to one another when <see cref="UseRigidBodyForMotion"/> is enabled.
-        /// </remarks>
-        public void DetachFromFixedJoint()
-        {
-            if (!HasAuthority)
-            {
-                Debug.LogError($"[{name}] Only authority can invoke {nameof(DetachFromFixedJoint)}!");
-            }
-            if (UseRigidBodyForMotion)
-            {
-                if (m_IsRigidbody2D)
-                {
-                    if (FixedJoint2D != null)
-                    {
-                        if (!m_FixedJoint2DUsingGravity)
-                        {
-                            FixedJoint2D.connectedBody.gravityScale = m_OriginalGravityScale;
-                        }
-                        FixedJoint2D.connectedBody = null;
-                        Destroy(FixedJoint2D);
-                        FixedJoint2D = null;
-                        ResetInterpolation();
-                        RemoveFromParentBody();
-                    }
-                }
-                else
-                {
-                    if (FixedJoint != null)
-                    {
-                        FixedJoint.connectedBody = null;
-                        m_InternalRigidbody.useGravity = m_OriginalGravitySetting;
-                        Destroy(FixedJoint);
-                        FixedJoint = null;
-                        ResetInterpolation();
-                        RemoveFromParentBody();
-                    }
-                }
-            }
-        }
-    }
-}
-#endif // COM_UNITY_MODULES_PHYSICS
-

Runtime/Components/NetworkRigidbody.cs

@@ -1,24 +0,0 @@
-#if COM_UNITY_MODULES_PHYSICS
-using UnityEngine;
-
-namespace Unity.Netcode.Components
-{
-    /// <summary>
-    /// 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(NetworkTransform))]
-    [RequireComponent(typeof(Rigidbody))]
-    [AddComponentMenu("Netcode/Network Rigidbody")]
-    public class NetworkRigidbody : NetworkRigidbodyBase
-    {
-
-        public Rigidbody Rigidbody => m_InternalRigidbody;
-
-        protected virtual void Awake()
-        {
-            Initialize(RigidbodyTypes.Rigidbody);
-        }
-    }
-}
-#endif // COM_UNITY_MODULES_PHYSICS

Runtime/Components/NetworkRigidbody2D.cs

@@ -1,22 +0,0 @@
-#if COM_UNITY_MODULES_PHYSICS2D
-using UnityEngine;
-
-namespace Unity.Netcode.Components
-{
-    /// <summary>
-    /// 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(NetworkTransform))]
-    [RequireComponent(typeof(Rigidbody2D))]
-    [AddComponentMenu("Netcode/Network Rigidbody 2D")]
-    public class NetworkRigidbody2D : NetworkRigidbodyBase
-    {
-        public Rigidbody2D Rigidbody2D => m_InternalRigidbody2D;
-        protected virtual void Awake()
-        {
-            Initialize(RigidbodyTypes.Rigidbody2D);
-        }
-    }
-}
-#endif // COM_UNITY_MODULES_PHYSICS2D

Runtime/Components/RigidbodyContactEventManager.cs

@@ -1,230 +0,0 @@
-#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

Runtime/Components/RigidbodyContactEventManager.cs.meta

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

Runtime/Configuration/NetworkConfig.cs

@@ -129,9 +129,9 @@ namespace Unity.Netcode
         public int LoadSceneTimeOut = 120;
 
         /// <summary>
-        /// 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.
+        /// 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.
         /// </summary>
-        [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.")]
+        [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 = 10f;
 
         /// <summary>
@@ -149,33 +149,6 @@ 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 whether to use the client-server or distributed authority network topology.")]
-        public NetworkTopologyTypes NetworkTopology;
-
-        [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;
-
-#if MULTIPLAYER_TOOLS
-        /// <summary>
-        /// Controls whether network messaging metrics will be gathered. (defaults to true)
-        /// There is a slight performance cost to having this enabled, and can increase in processing time based on network message traffic.
-        /// </summary>
-        /// <remarks>
-        /// The Realtime Network Stats Monitoring tool requires this to be enabled.
-        /// </remarks>
-        [Tooltip("Enable (default) if you want to gather messaging metrics. Realtime Network Stats Monitor requires this to be enabled. Disabling this can improve performance in release builds.")]
-        public bool NetworkMessageMetrics = true;
-#endif
-        /// <summary>
-        /// When enabled (default, this enables network profiling information. This does come with a per message processing cost.
-        /// Network profiling information is automatically disabled in release builds.
-        /// </summary>
-        [Tooltip("Enable (default) if you want to profile network messages with development builds and defaults to being disabled in release builds. When disabled, network messaging profiling will be disabled in development builds.")]
-        public bool NetworkProfilingMetrics = true;
-
         /// <summary>
         /// Returns a base64 encoded version of the configuration
         /// </summary>

Runtime/Connection/NetworkClient.cs

@@ -1,8 +1,7 @@
-using UnityEngine;
+using System.Collections.Generic;
 
 namespace Unity.Netcode
 {
-
     /// <summary>
     /// A NetworkClient
     /// </summary>
@@ -34,15 +33,6 @@ namespace Unity.Netcode
         /// </summary>
         internal bool IsApproved { get; set; }
 
-        public NetworkTopologyTypes NetworkTopologyType { 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>
@@ -54,60 +44,27 @@ namespace Unity.Netcode
         public NetworkObject PlayerObject;
 
         /// <summary>
-        /// The NetworkObject's owned by this client instance
+        /// The list of NetworkObject's owned by this client instance
         /// </summary>
-        public NetworkObject[] OwnedObjects => IsConnected ? SpawnManager.GetClientOwnedObjects(ClientId) : new NetworkObject[] { };
+        public List<NetworkObject> OwnedObjects => IsConnected ? SpawnManager.GetClientOwnedObjects(ClientId) : new List<NetworkObject>();
 
         internal NetworkSpawnManager SpawnManager { get; private set; }
 
-        internal bool SetRole(bool isServer, bool isClient, NetworkManager networkManager = null)
+        internal void SetRole(bool isServer, bool isClient, NetworkManager networkManager = null)
         {
-            ResetClient(isServer, isClient);
-
             IsServer = isServer;
             IsClient = isClient;
-
-            if (networkManager != null)
-            {
-                SpawnManager = networkManager.SpawnManager;
-                NetworkTopologyType = networkManager.NetworkConfig.NetworkTopology;
-
-                if (NetworkTopologyType == NetworkTopologyTypes.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)
+            if (!IsServer && !isClient)
             {
                 PlayerObject = null;
                 ClientId = 0;
                 IsConnected = false;
                 IsApproved = false;
-                SpawnManager = null;
-                DAHost = false;
+            }
+
+            if (networkManager != null)
+            {
+                SpawnManager = networkManager.SpawnManager;
             }
         }
 

Runtime/Connection/NetworkConnectionManager.cs

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

Runtime/Core/NetworkBehaviour.cs

@@ -15,16 +15,10 @@ namespace Unity.Netcode
     }
 
     /// <summary>
-    /// The base class to override to write network code. Inherits MonoBehaviour.
+    /// The base class to override to write network code. Inherits MonoBehaviour
     /// </summary>
     public abstract class NetworkBehaviour : MonoBehaviour
     {
-#if UNITY_EDITOR
-        [HideInInspector]
-        [SerializeField]
-        internal bool ShowTopMostFoldoutHeaderGroup = true;
-#endif
-
 #pragma warning disable IDE1006 // disable naming rule violation check
 
         // RuntimeAccessModifiersILPP will make this `public`
@@ -33,7 +27,7 @@ namespace Unity.Netcode
         // RuntimeAccessModifiersILPP will make this `public`
         internal static readonly Dictionary<Type, Dictionary<uint, RpcReceiveHandler>> __rpc_func_table = new Dictionary<Type, Dictionary<uint, RpcReceiveHandler>>();
 
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
         // RuntimeAccessModifiersILPP will make this `public`
         internal static readonly Dictionary<Type, Dictionary<uint, string>> __rpc_name_table = new Dictionary<Type, Dictionary<uint, string>>();
 #endif
@@ -75,7 +69,6 @@ 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
@@ -95,7 +88,7 @@ namespace Unity.Netcode
                     networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
                     break;
                 case RpcDelivery.Unreliable:
-                    if (bufferWriter.Length > networkManager.MessageManager.NonFragmentedMessageMaxSize)
+                    if (bufferWriter.Length > NetworkManager.MessageManager.NonFragmentedMessageMaxSize)
                     {
                         throw new OverflowException("RPC parameters are too large for unreliable delivery.");
                     }
@@ -104,16 +97,16 @@ namespace Unity.Netcode
             }
 
             var rpcWriteSize = 0;
-            // Authority just no ops and sends to itself
-            // Client-Server: Only the server-host sends to self
-            if (IsServer)
+
+            // If we are a server/host then we just no op and send to ourself
+            if (IsHost || IsServer)
             {
                 using var tempBuffer = new FastBufferReader(bufferWriter, Allocator.Temp);
                 var context = new NetworkContext
                 {
                     SenderId = NetworkManager.ServerClientId,
-                    Timestamp = networkManager.RealTimeProvider.RealTimeSinceStartup,
-                    SystemOwner = networkManager,
+                    Timestamp = NetworkManager.RealTimeProvider.RealTimeSinceStartup,
+                    SystemOwner = NetworkManager,
                     // header information isn't valid since it's not a real message.
                     // RpcMessage doesn't access this stuff so it's just left empty.
                     Header = new NetworkMessageHeader(),
@@ -130,7 +123,7 @@ namespace Unity.Netcode
             }
 
             bufferWriter.Dispose();
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
             if (__rpc_name_table[GetType()].TryGetValue(rpcMethodId, out var rpcMethodName))
             {
                 NetworkManager.NetworkMetrics.TrackRpcSent(
@@ -156,7 +149,6 @@ 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
@@ -176,7 +168,7 @@ namespace Unity.Netcode
                     networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
                     break;
                 case RpcDelivery.Unreliable:
-                    if (bufferWriter.Length > networkManager.MessageManager.NonFragmentedMessageMaxSize)
+                    if (bufferWriter.Length > NetworkManager.MessageManager.NonFragmentedMessageMaxSize)
                     {
                         throw new OverflowException("RPC parameters are too large for unreliable delivery.");
                     }
@@ -188,22 +180,24 @@ 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 shouldInvokeLocally = false;
+            bool shouldSendToHost = false;
             if (clientRpcParams.Send.TargetClientIds != null)
             {
                 foreach (var targetClientId in clientRpcParams.Send.TargetClientIds)
                 {
                     if (targetClientId == NetworkManager.ServerClientId)
                     {
-                        shouldInvokeLocally = true;
-                        continue;
+                        shouldSendToHost = true;
+                        break;
                     }
+
                     // Check to make sure we are sending to only observers, if not log an error.
-                    if (networkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
+                    if (NetworkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
                     {
                         NetworkLog.LogError(GenerateObserverErrorMessage(clientRpcParams, targetClientId));
                     }
                 }
+
                 rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, in clientRpcParams.Send.TargetClientIds);
             }
             else if (clientRpcParams.Send.TargetClientIdsNativeArray != null)
@@ -212,15 +206,17 @@ namespace Unity.Netcode
                 {
                     if (targetClientId == NetworkManager.ServerClientId)
                     {
-                        shouldInvokeLocally = true;
-                        continue;
+                        shouldSendToHost = true;
+                        break;
                     }
+
                     // Check to make sure we are sending to only observers, if not log an error.
-                    if (networkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
+                    if (NetworkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
                     {
                         NetworkLog.LogError(GenerateObserverErrorMessage(clientRpcParams, targetClientId));
                     }
                 }
+
                 rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, clientRpcParams.Send.TargetClientIdsNativeArray.Value);
             }
             else
@@ -231,7 +227,7 @@ namespace Unity.Netcode
                     // Skip over the host
                     if (IsHost && observerEnumerator.Current == NetworkManager.LocalClientId)
                     {
-                        shouldInvokeLocally = true;
+                        shouldSendToHost = true;
                         continue;
                     }
                     rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, observerEnumerator.Current);
@@ -239,14 +235,14 @@ namespace Unity.Netcode
             }
 
             // If we are a server/host then we just no op and send to ourself
-            if (shouldInvokeLocally)
+            if (shouldSendToHost)
             {
                 using var tempBuffer = new FastBufferReader(bufferWriter, Allocator.Temp);
                 var context = new NetworkContext
                 {
                     SenderId = NetworkManager.ServerClientId,
-                    Timestamp = networkManager.RealTimeProvider.RealTimeSinceStartup,
-                    SystemOwner = networkManager,
+                    Timestamp = NetworkManager.RealTimeProvider.RealTimeSinceStartup,
+                    SystemOwner = NetworkManager,
                     // header information isn't valid since it's not a real message.
                     // RpcMessage doesn't access this stuff so it's just left empty.
                     Header = new NetworkMessageHeader(),
@@ -258,14 +254,14 @@ namespace Unity.Netcode
             }
 
             bufferWriter.Dispose();
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
             if (__rpc_name_table[GetType()].TryGetValue(rpcMethodId, out var rpcMethodName))
             {
                 if (clientRpcParams.Send.TargetClientIds != null)
                 {
                     foreach (var targetClientId in clientRpcParams.Send.TargetClientIds)
                     {
-                        networkManager.NetworkMetrics.TrackRpcSent(
+                        NetworkManager.NetworkMetrics.TrackRpcSent(
                             targetClientId,
                             NetworkObject,
                             rpcMethodName,
@@ -277,7 +273,7 @@ namespace Unity.Netcode
                 {
                     foreach (var targetClientId in clientRpcParams.Send.TargetClientIdsNativeArray)
                     {
-                        networkManager.NetworkMetrics.TrackRpcSent(
+                        NetworkManager.NetworkMetrics.TrackRpcSent(
                             targetClientId,
                             NetworkObject,
                             rpcMethodName,
@@ -290,7 +286,7 @@ namespace Unity.Netcode
                     var observerEnumerator = NetworkObject.Observers.GetEnumerator();
                     while (observerEnumerator.MoveNext())
                     {
-                        networkManager.NetworkMetrics.TrackRpcSent(
+                        NetworkManager.NetworkMetrics.TrackRpcSent(
                             observerEnumerator.Current,
                             NetworkObject,
                             rpcMethodName,
@@ -376,12 +372,6 @@ namespace Unity.Netcode
                     case SendTo.ClientsAndHost:
                         rpcParams.Send.Target = RpcTarget.ClientsAndHost;
                         break;
-                    case SendTo.Authority:
-                        rpcParams.Send.Target = RpcTarget.Authority;
-                        break;
-                    case SendTo.NotAuthority:
-                        rpcParams.Send.Target = RpcTarget.NotAuthority;
-                        break;
                     case SendTo.SpecifiedInParams:
                         throw new RpcException("This method requires a runtime-specified send target.");
                 }
@@ -416,8 +406,8 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets the NetworkManager that owns this NetworkBehaviour instance.
-        /// See `NetworkObject` note for how there is a chicken/egg problem when not initialized.
+        /// Gets the NetworkManager that owns this NetworkBehaviour instance
+        ///   See note around `NetworkObject` for how there is a chicken / egg problem when we are not initialized
         /// </summary>
         public NetworkManager NetworkManager
         {
@@ -445,78 +435,51 @@ namespace Unity.Netcode
         /// <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)"/>.
+        /// <see cref="Unity.Netcode.RpcTarget.Not{T}(T)"/>
         /// </summary>
 #pragma warning restore IDE0001
         public RpcTarget RpcTarget => NetworkManager.RpcTarget;
 
         /// <summary>
-        /// If a NetworkObject is assigned, returns whether the NetworkObject
-        /// is the local player object. If no NetworkObject is assigned, returns false.
+        /// 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.
         /// </summary>
         public bool IsLocalPlayer { get; private set; }
 
         /// <summary>
-        /// Gets whether the object is owned by the local player or if the object is the local player object.
+        /// Gets if the object is owned by the local player or if the object is the local player object
         /// </summary>
         public bool IsOwner { get; internal set; }
 
         /// <summary>
-        /// Gets whether executing as a server.
+        /// Gets if we are executing as server
         /// </summary>
         public bool IsServer { get; private set; }
 
         /// <summary>
-        /// Determines if the local client has authority over the associated NetworkObject.
-        /// <list type="bullet">
-        /// <item>In client-server contexts: returns true if `IsServer` or `IsHost`.</item>
-        /// <item>In distributed authority contexts: returns true if `IsOwner`.</item>
-        /// </list>
-        /// </summary>
-        public bool HasAuthority { get; internal set; }
-
-        internal NetworkClient LocalClient { get; private set; }
-
-        /// <summary>
-        /// Gets whether the client is the distributed authority mode session owner.
-        /// </summary>
-        public bool IsSessionOwner
-        {
-            get
-            {
-                if (LocalClient == null)
-                {
-                    return false;
-                }
-
-                return LocalClient.IsSessionOwner;
-            }
-        }
-
-        /// <summary>
-        /// Gets whether the server (local or remote) is a host.
+        /// Gets if the server (local or remote) is a host - i.e., also a client
         /// </summary>
         public bool ServerIsHost { get; private set; }
 
         /// <summary>
-        /// Gets whether executing as a client.
+        /// Gets if we are executing as client
         /// </summary>
         public bool IsClient { get; private set; }
 
 
         /// <summary>
-        /// Gets whether executing as a host (both server and client).
+        /// Gets if we are executing as Host, I.E Server and Client
         /// </summary>
         public bool IsHost { get; private set; }
 
         /// <summary>
-        /// Gets whether the object has an owner.
+        /// Gets Whether or not the object has a owner
         /// </summary>
         public bool IsOwnedByServer { get; internal set; }
 
         /// <summary>
-        /// Determines whether it's safe to access a NetworkObject and NetworkManager from within a NetworkBehaviour component.
-        /// Primarily useful when checking NetworkObject or NetworkManager properties within FixedUpate.
+        /// Used to determine if it is safe to access NetworkObject and NetworkManager from within a NetworkBehaviour component
+        /// Primarily useful when checking NetworkObject/NetworkManager properties within FixedUpate
         /// </summary>
         public bool IsSpawned { get; internal set; }
 
@@ -536,7 +499,7 @@ namespace Unity.Netcode
         ///   the warning below.  This is why IsBehaviourEditable had to be created.  Matt was going to re-do
         ///   how NetworkObject works but it was close to the release and too risky to change
         /// <summary>
-        /// Gets the NetworkObject that owns this NetworkBehaviour instance.
+        /// Gets the NetworkObject that owns this NetworkBehaviour instance
         /// </summary>
         public NetworkObject NetworkObject
         {
@@ -575,19 +538,19 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets whether this NetworkBehaviour instance has a NetworkObject owner.
+        /// Gets whether or not this NetworkBehaviour instance has a NetworkObject owner.
         /// </summary>
         public bool HasNetworkObject => NetworkObject != null;
 
         private NetworkObject m_NetworkObject = null;
 
         /// <summary>
-        /// Gets the NetworkId of the NetworkObject that owns this NetworkBehaviour instance.
+        /// Gets the NetworkId of the NetworkObject that owns this NetworkBehaviour
         /// </summary>
         public ulong NetworkObjectId { get; internal set; }
 
         /// <summary>
-        /// Gets NetworkId for this NetworkBehaviour from the owner NetworkObject.
+        /// Gets NetworkId for this NetworkBehaviour from the owner NetworkObject
         /// </summary>
         public ushort NetworkBehaviourId { get; internal set; }
 
@@ -597,7 +560,7 @@ namespace Unity.Netcode
         internal ushort NetworkBehaviourIdCache = 0;
 
         /// <summary>
-        /// Returns the NetworkBehaviour with a given BehaviourId for the current NetworkObject.
+        /// Returns a the NetworkBehaviour with a given BehaviourId for the current NetworkObject
         /// </summary>
         /// <param name="behaviourId">The behaviourId to return</param>
         /// <returns>Returns NetworkBehaviour with given behaviourId</returns>
@@ -607,7 +570,7 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets the ClientId that owns this NetworkObject.
+        /// Gets the ClientId that owns the NetworkObject
         /// </summary>
         public ulong OwnerClientId { get; internal set; }
 
@@ -618,34 +581,30 @@ 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;
-                    LocalClient = networkManager.LocalClient;
-                    HasAuthority = networkObject.HasAuthority;
-                    ServerIsHost = networkManager.IsListening && networkManager.ServerIsHost;
+                    IsHost = NetworkManager.IsListening && NetworkManager.IsHost;
+                    IsClient = NetworkManager.IsListening && NetworkManager.IsClient;
+                    IsServer = NetworkManager.IsListening && NetworkManager.IsServer;
+                    ServerIsHost = NetworkManager.IsListening && NetworkManager.ServerIsHost;
                 }
             }
             else // Shouldn't happen, but if so then set the properties to their default value;
@@ -653,89 +612,19 @@ namespace Unity.Netcode
                 OwnerClientId = NetworkObjectId = default;
                 IsOwnedByServer = IsOwner = IsHost = IsClient = IsServer = ServerIsHost = default;
                 NetworkBehaviourId = default;
-                LocalClient = default;
-                HasAuthority = default;
             }
         }
 
         /// <summary>
-        /// Only for use in distributed authority mode.
-        /// 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 after the <see cref="NetworkObject"/> is spawned. No NetworkBehaviours associated with the NetworkObject will have had <see cref="OnNetworkSpawn"/> invoked yet.
-        /// A reference to <see cref="NetworkManager"/> is passed in as a parameter to determine the context of execution (`IsServer` or `IsClient`).
-        /// </summary>
-        /// <param name="networkManager">a ref to the <see cref="NetworkManager"/> since this is not yet set on the <see cref="NetworkBehaviour"/></param>
-        /// <remarks>
-        /// The <see cref="NetworkBehaviour"/> will not have anything assigned to it at this point in time.
-        /// Settings like ownership, NetworkBehaviourId, NetworkManager, and most other spawn-related properties will not be set.
-        /// This can be used to handle things like initializing a NetworkVariable.
-        /// </remarks>
-        protected virtual void OnNetworkPreSpawn(ref NetworkManager networkManager) { }
-
-        /// <summary>
-        /// Gets called when the <see cref="NetworkObject"/> gets spawned, message handlers are ready to be registered, and the network is set up.
+        /// Gets called when the <see cref="NetworkObject"/> gets spawned, message handlers are ready to be registered and the network is setup.
         /// </summary>
         public virtual void OnNetworkSpawn() { }
 
         /// <summary>
-        /// Gets called after the <see cref="NetworkObject"/> is spawned. All NetworkBehaviours associated with the NetworkObject will have had <see cref="OnNetworkSpawn"/> invoked.
-        /// </summary>
-        /// <remarks>
-        /// Will be invoked on each <see cref="NetworkBehaviour"/> associated with the <see cref="NetworkObject"/> being spawned.
-        /// All associated <see cref="NetworkBehaviour"/> components will have had <see cref="OnNetworkSpawn"/> invoked on the spawned <see cref="NetworkObject"/>.
-        /// </remarks>
-        protected virtual void OnNetworkPostSpawn() { }
-
-        protected internal virtual void InternalOnNetworkPostSpawn() { }
-
-        /// <summary>
-        /// This method is only available client-side.
-        /// When a new client joins it's synchronized with all spawned NetworkObjects and scenes loaded for the session joined. At the end of the synchronization process, when all
-        /// <see cref="NetworkObject"/>s and scenes (if scene management is enabled) have finished synchronizing, all NetworkBehaviour components associated with spawned <see cref="NetworkObject"/>s
-        /// will have this method invoked.
-        /// </summary>
-        /// <remarks>
-        /// This can be used to handle post-synchronization actions where you might need to access a different NetworkObject and/or NetworkBehaviour not local to the current NetworkObject context.
-        /// This is only invoked on clients during a client-server network topology session.
-        /// </remarks>
-        protected virtual void OnNetworkSessionSynchronized() { }
-
-        protected internal virtual void InternalOnNetworkSessionSynchronized() { }
-
-        /// <summary>
-        /// When a scene is loaded and in-scene placed NetworkObjects are finished spawning, this method is invoked on all of the newly spawned in-scene placed NetworkObjects.
-        /// This method runs both client and server side.
-        /// </summary>
-        /// <remarks>
-        /// This method can be used to handle post-scene loaded actions for in-scene placed NetworkObjcts where you might need to access a different NetworkObject and/or NetworkBehaviour not local to the current NetworkObject context.
-        /// </remarks>
-        protected virtual void OnInSceneObjectsSpawned() { }
-
-        /// <summary>
-        /// Gets called when the <see cref="NetworkObject"/> gets despawned. This method runs both client and server side.
+        /// Gets called when the <see cref="NetworkObject"/> gets despawned. Is called both on the server and clients.
         /// </summary>
         public virtual void OnNetworkDespawn() { }
 
-        internal void NetworkPreSpawn(ref NetworkManager networkManager)
-        {
-            try
-            {
-                OnNetworkPreSpawn(ref networkManager);
-            }
-            catch (Exception e)
-            {
-                Debug.LogException(e);
-            }
-        }
-
         internal void InternalOnNetworkSpawn()
         {
             IsSpawned = true;
@@ -755,8 +644,7 @@ namespace Unity.Netcode
             }
 
             InitializeVariables();
-
-            if (NetworkObject.HasAuthority)
+            if (IsServer)
             {
                 // 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.
@@ -765,44 +653,6 @@ namespace Unity.Netcode
             }
         }
 
-        internal void NetworkPostSpawn()
-        {
-            try
-            {
-                InternalOnNetworkPostSpawn();
-                OnNetworkPostSpawn();
-            }
-            catch (Exception e)
-            {
-                Debug.LogException(e);
-            }
-        }
-
-        internal void NetworkSessionSynchronized()
-        {
-            try
-            {
-                InternalOnNetworkSessionSynchronized();
-                OnNetworkSessionSynchronized();
-            }
-            catch (Exception e)
-            {
-                Debug.LogException(e);
-            }
-        }
-
-        internal void InSceneNetworkObjectsSpawned()
-        {
-            try
-            {
-                OnInSceneObjectsSpawned();
-            }
-            catch (Exception e)
-            {
-                Debug.LogException(e);
-            }
-        }
-
         internal void InternalOnNetworkDespawn()
         {
             IsSpawned = false;
@@ -818,8 +668,7 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// In client-server contexts, this method is invoked on both the server and the local client of the owner when <see cref="Netcode.NetworkObject"/> ownership is assigned.
-        /// <para>In distributed authority contexts, this method is only invoked on the local client that has been assigned ownership of the associated <see cref="Netcode.NetworkObject"/>.</para>
+        /// Gets called when the local client gains ownership of this object
         /// </summary>
         public virtual void OnGainedOwnership() { }
 
@@ -830,9 +679,9 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Invoked on all clients. Override this method to be notified of any
-        /// ownership changes (even if the instance was neither the previous or
-        /// newly assigned current owner).
+        /// 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>
@@ -847,9 +696,7 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// In client-server contexts, this method is invoked on the local client when it loses ownership of the associated <see cref="Netcode.NetworkObject"/>
-        /// and on the server when any client loses ownership.
-        /// <para>In distributed authority contexts, this method is only invoked on the local client that has lost ownership of the associated <see cref="Netcode.NetworkObject"/>.</para>
+        /// Gets called when we loose ownership of this object
         /// </summary>
         public virtual void OnLostOwnership() { }
 
@@ -860,13 +707,11 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets called when the parent NetworkObject of this NetworkBehaviour's NetworkObject has changed.
+        /// Gets called when the parent NetworkObject of this NetworkBehaviour's NetworkObject has changed
         /// </summary>
         /// <param name="parentNetworkObject">the new <see cref="NetworkObject"/> parent</param>
         public virtual void OnNetworkObjectParentChanged(NetworkObject parentNetworkObject) { }
 
-        internal virtual void InternalOnNetworkObjectParentChanged(NetworkObject parentNetworkObject) { }
-
         private bool m_VarInit = false;
 
         private readonly List<HashSet<int>> m_DeliveryMappedNetworkVariableIndices = new List<HashSet<int>>();
@@ -897,7 +742,7 @@ namespace Unity.Netcode
 #pragma warning restore IDE1006 // restore naming rule violation check
         {
             __rpc_func_table[GetType()][hash] = handler;
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
             __rpc_name_table[GetType()][hash] = rpcMethodName;
 #endif
         }
@@ -923,7 +768,7 @@ namespace Unity.Netcode
             if (!__rpc_func_table.ContainsKey(GetType()))
             {
                 __rpc_func_table[GetType()] = new Dictionary<uint, RpcReceiveHandler>();
-#if UNITY_EDITOR || DEVELOPMENT_BUILD || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
                 __rpc_name_table[GetType()] = new Dictionary<uint, string>();
 #endif
                 __initializeRpcs();
@@ -999,8 +844,6 @@ namespace Unity.Netcode
                     }
                 }
             }
-
-            MarkVariablesDirty(false);
         }
 
         internal void PreVariableUpdate()
@@ -1009,34 +852,30 @@ namespace Unity.Netcode
             {
                 InitializeVariables();
             }
-
             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>();
 
-        internal void NetworkVariableUpdate(ulong targetClientId)
+        private void NetworkVariableUpdate(ulong targetClientId, int behaviourIndex)
         {
             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++)
                 {
-                    networkVariable = NetworkVariableFields[k];
+                    var networkVariable = NetworkVariableFields[k];
                     if (networkVariable.IsDirty() && networkVariable.CanClientRead(targetClientId))
                     {
                         if (networkVariable.CanSend())
@@ -1046,53 +885,38 @@ namespace Unity.Netcode
                         break;
                     }
                 }
-                // 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)
-                {
-                    shouldSend = false;
-                }
 
-                if (!shouldSend)
+                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)
+                    var message = new NetworkVariableDeltaMessage
                     {
-                        message.Serialize(tmpWriter, message.Version);
+                        NetworkObjectId = NetworkObjectId,
+                        NetworkBehaviourIndex = NetworkObject.GetNetworkBehaviourOrderIndex(this),
+                        NetworkBehaviour = this,
+                        TargetClientId = targetClientId,
+                        DeliveryMappedNetworkVariableIndex = m_DeliveryMappedNetworkVariableIndices[j]
+                    };
+                    // TODO: Serialization is where the IsDirty flag gets changed.
+                    // Messages don't get sent from the server to itself, so if we're host and sending to ourselves,
+                    // we still have to actually serialize the message even though we're not sending it, otherwise
+                    // the dirty flag doesn't change properly. These two pieces should be decoupled at some point
+                    // so we don't have to do this serialization work if we're not going to use the result.
+                    if (IsServer && targetClientId == NetworkManager.ServerClientId)
+                    {
+                        var tmpWriter = new FastBufferWriter(NetworkManager.MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp, NetworkManager.MessageManager.FragmentedMessageMaxSize);
+                        using (tmpWriter)
+                        {
+                            message.Serialize(tmpWriter, message.Version);
+                        }
+                    }
+                    else
+                    {
+                        NetworkManager.ConnectionManager.SendMessage(ref message, m_DeliveryTypesForNetworkVariableGroups[j], targetClientId);
                     }
-                }
-                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'
@@ -1132,18 +956,6 @@ namespace Unity.Netcode
         /// </remarks>
         internal void WriteNetworkVariableData(FastBufferWriter writer, ulong targetClientId)
         {
-            // Create any values that require accessing the NetworkManager locally (it is expensive to access it in NetworkBehaviour)
-            var networkManager = NetworkManager;
-            var distributedAuthority = networkManager.DistributedAuthorityMode;
-            var ensureLengthSafety = networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety;
-
-            // Always write the NetworkVariable count even if zero for distributed authority (used by comb server)
-            if (distributedAuthority)
-            {
-                writer.WriteValueSafe((ushort)NetworkVariableFields.Count);
-            }
-
-            // Exit early if there are no NetworkVariables
             if (NetworkVariableFields.Count == 0)
             {
                 return;
@@ -1151,19 +963,11 @@ namespace Unity.Netcode
 
             for (int j = 0; j < NetworkVariableFields.Count; j++)
             {
-                // Client-Server: Try to write values only for clients that have read permissions.
-                // Distributed Authority: All clients have read permissions, always try to write the value.
+
                 if (NetworkVariableFields[j].CanClientRead(targetClientId))
                 {
-                    // Write additional NetworkVariable information when length safety is enabled or when in distributed authority mode
-                    if (ensureLengthSafety || distributedAuthority)
+                    if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                     {
-                        // Write the type being serialized for distributed authority (only for comb-server)
-                        if (distributedAuthority)
-                        {
-                            writer.WriteValueSafe(NetworkVariableFields[j].Type);
-                        }
-
                         var writePos = writer.Position;
                         // Note: This value can't be packed because we don't know how large it will be in advance
                         // we reserve space for it, then write the data, then come back and fill in the space
@@ -1175,22 +979,18 @@ namespace Unity.Netcode
                         NetworkVariableFields[j].WriteField(writer);
                         var size = writer.Position - startPos;
                         writer.Seek(writePos);
-                        // Write the NetworkVariable value
                         writer.WriteValueSafe((ushort)size);
                         writer.Seek(startPos + size);
                     }
-                    else // Client-Server Only: Should only ever be invoked when using a client-server NetworkTopology
+                    else
                     {
-                        // Write the NetworkVariable value
                         NetworkVariableFields[j].WriteField(writer);
                     }
                 }
-                else if (ensureLengthSafety)
+                else // Only if EnsureNetworkVariableLengthSafety, otherwise just skip
+                if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                 {
-                    // Client-Server Only: If the client cannot read this field, then skip it but write a 0 for this NetworkVariable's position
-                    {
-                        writer.WriteValueSafe((ushort)0);
-                    }
+                    writer.WriteValueSafe((ushort)0);
                 }
             }
         }
@@ -1205,23 +1005,6 @@ namespace Unity.Netcode
         /// </remarks>
         internal void SetNetworkVariableData(FastBufferReader reader, ulong clientId)
         {
-            // Stack cache any values that requires accessing the NetworkManager (it is expensive to access it in NetworkBehaviour)
-            var networkManager = NetworkManager;
-            var distributedAuthority = networkManager.DistributedAuthorityMode;
-            var ensureLengthSafety = networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety;
-
-            // Always read the NetworkVariable count when in distributed authority (sanity check if comb-server matches what client has locally)
-            if (distributedAuthority)
-            {
-                reader.ReadValueSafe(out ushort variableCount);
-                if (variableCount != NetworkVariableFields.Count)
-                {
-                    Debug.LogError($"[{name}][NetworkObjectId: {NetworkObjectId}][NetworkBehaviourId: {NetworkBehaviourId}] NetworkVariable count mismatch! (Read: {variableCount} vs. Expected: {NetworkVariableFields.Count})");
-                    return;
-                }
-            }
-
-            // Exit early if nothing else to read
             if (NetworkVariableFields.Count == 0)
             {
                 return;
@@ -1231,52 +1014,30 @@ namespace Unity.Netcode
             {
                 var varSize = (ushort)0;
                 var readStartPos = 0;
-                // Client-Server: Clients that only have read permissions will try to read the value
-                // Distributed Authority: All clients have read permissions, always try to read the value
-                if (NetworkVariableFields[j].CanClientRead(clientId))
+                if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                 {
-                    if (ensureLengthSafety || distributedAuthority)
+                    reader.ReadValueSafe(out varSize);
+                    if (varSize == 0)
                     {
-                        // Read the type being serialized and discard it (for now) when in a distributed authority network topology (only used by comb-server)
-                        if (distributedAuthority)
-                        {
-                            reader.ReadValueSafe(out NetworkVariableType _);
-                        }
-
-                        reader.ReadValueSafe(out varSize);
-                        if (varSize == 0)
-                        {
-                            Debug.LogError($"[{name}][NetworkObjectId: {NetworkObjectId}][NetworkBehaviourId: {NetworkBehaviourId}][{NetworkVariableFields[j].Name}] Expected non-zero size readable NetworkVariable! (Skipping)");
-                            continue;
-                        }
-                        readStartPos = reader.Position;
+                        continue;
                     }
+                    readStartPos = reader.Position;
                 }
-                else // Client-Server Only: If the client cannot read this field, then skip it
+                else // If the client cannot read this field, then skip it
+                if (!NetworkVariableFields[j].CanClientRead(clientId))
                 {
-                    // If skipping and length safety, then fill in a 0 size for this one spot
-                    if (ensureLengthSafety)
-                    {
-                        reader.ReadValueSafe(out ushort size);
-                        if (size != 0)
-                        {
-                            Debug.LogError($"[{name}][NetworkObjectId: {NetworkObjectId}][NetworkBehaviourId: {NetworkBehaviourId}][{NetworkVariableFields[j].Name}] Expected zero size for non-readable NetworkVariable when EnsureNetworkVariableLengthSafety is enabled! (Skipping)");
-                        }
-                    }
                     continue;
                 }
 
-                // Read the NetworkVarible value
                 NetworkVariableFields[j].ReadField(reader);
 
-                // When EnsureNetworkVariableLengthSafety or DistributedAuthorityMode always do a bounds check
-                if (ensureLengthSafety || distributedAuthority)
+                if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                 {
                     if (reader.Position > (readStartPos + varSize))
                     {
                         if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                         {
-                            NetworkLog.LogWarning($"[{name}][NetworkObjectId: {NetworkObjectId}][NetworkBehaviourId: {NetworkBehaviourId}][{NetworkVariableFields[j].Name}] NetworkVariable data read too big. {reader.Position - (readStartPos + varSize)} bytes.");
+                            NetworkLog.LogWarning($"Var data read too far. {reader.Position - (readStartPos + varSize)} bytes.");
                         }
 
                         reader.Seek(readStartPos + varSize);
@@ -1285,7 +1046,7 @@ namespace Unity.Netcode
                     {
                         if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                         {
-                            NetworkLog.LogWarning($"[{name}][NetworkObjectId: {NetworkObjectId}][NetworkBehaviourId: {NetworkBehaviourId}][{NetworkVariableFields[j].Name}] NetworkVariable data read too small. {(readStartPos + varSize) - reader.Position} bytes.");
+                            NetworkLog.LogWarning($"Var data read too little. {(readStartPos + varSize) - reader.Position} bytes.");
                         }
 
                         reader.Seek(readStartPos + varSize);
@@ -1295,7 +1056,7 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets the local instance of a NetworkObject with a given NetworkId.
+        /// Gets the local instance of a object with a given NetworkId
         /// </summary>
         /// <param name="networkId"></param>
         /// <returns></returns>
@@ -1306,14 +1067,14 @@ namespace Unity.Netcode
 
         /// <summary>
         /// Override this method if your derived NetworkBehaviour requires custom synchronization data.
-        /// Use of this method is only for the initial client synchronization of NetworkBehaviours
+        /// Note: Use of this method is only for the initial client synchronization of NetworkBehaviours
         /// and will increase the payload size for client synchronization and dynamically spawned
         /// <see cref="NetworkObject"/>s.
         /// </summary>
         /// <remarks>
-        /// When serializing (writing), this method is invoked during the client synchronization period and
+        /// When serializing (writing) this will be invoked during the client synchronization period and
         /// when spawning new NetworkObjects.
-        /// When deserializing (reading), this method is invoked prior to the NetworkBehaviour's associated
+        /// When deserializing (reading), this will be invoked prior to the NetworkBehaviour's associated
         /// NetworkObject being spawned.
         /// </remarks>
         /// <param name="serializer">The serializer to use to read and write the data.</param>
@@ -1336,10 +1097,10 @@ namespace Unity.Netcode
         /// The relative client identifier targeted for the serialization of this <see cref="NetworkBehaviour"/> instance.
         /// </summary>
         /// <remarks>
-        /// This value is set prior to <see cref="OnSynchronize{T}(ref BufferSerializer{T})"/> being invoked.
+        /// 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 is reset to 0.
+        /// When synchronization of this instance is complete, this value will be reset to 0
         /// </remarks>
         protected ulong m_TargetIdBeingSynchronized { get; private set; }
 
@@ -1441,7 +1202,7 @@ namespace Unity.Netcode
                 {
                     if (NetworkManager.LogLevel <= LogLevel.Normal)
                     {
-                        NetworkLog.LogWarning($"{name} read {totalBytesRead} bytes but was expected to read {expectedBytesToRead} bytes during synchronization deserialization! This {nameof(NetworkBehaviour)}({GetType().Name})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)} is being skipped and will not be synchronized!");
                     }
                     synchronizationError = true;
                 }
@@ -1462,8 +1223,9 @@ namespace Unity.Netcode
 
 
         /// <summary>
-        /// Invoked when the <see cref="GameObject"/> the <see cref="NetworkBehaviour"/> is attached to is destroyed.
-        /// If you override this, you must always invoke the base class version of this <see cref="OnDestroy"/> method.
+        /// Invoked when the <see cref="GameObject"/> the <see cref="NetworkBehaviour"/> is attached to.
+        /// NOTE:  If you override this, you will want to always invoke this base class version of this
+        /// <see cref="OnDestroy"/> method!!
         /// </summary>
         public virtual void OnDestroy()
         {

Runtime/Core/NetworkBehaviourUpdater.cs

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

Runtime/Core/NetworkManager.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using Unity.Collections;
-using System.Linq;
 using UnityEngine;
 #if UNITY_EDITOR
 using UnityEditor;
@@ -17,12 +16,6 @@ namespace Unity.Netcode
     [AddComponentMenu("Netcode/Network Manager", -100)]
     public class NetworkManager : MonoBehaviour, INetworkUpdateSystem
     {
-#if UNITY_EDITOR
-        // Inspector view expand/collapse settings for this derived child class
-        [HideInInspector]
-        public bool NetworkManagerExpanded;
-#endif
-
         // TODO: Deprecate...
         // The following internal values are not used, but because ILPP makes them public in the assembly, they cannot
         // be removed thanks to our semver validation.
@@ -34,251 +27,19 @@ namespace Unity.Netcode
         // RuntimeAccessModifiersILPP will make this `public`
         internal static readonly Dictionary<uint, RpcReceiveHandler> __rpc_func_table = new Dictionary<uint, RpcReceiveHandler>();
 
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
         // RuntimeAccessModifiersILPP will make this `public`
         internal static readonly Dictionary<uint, string> __rpc_name_table = new Dictionary<uint, string>();
 #endif
 
 #pragma warning restore IDE1006 // restore naming rule violation check
 
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
-        private static List<Type> s_SerializedType = new List<Type>();
-        // This is used to control the serialized type not optimized messaging for integration test purposes
-        internal static bool DisableNotOptimizedSerializedType;
-        /// <summary>
-        /// Until all serialized types are optimized for the distributed authority network topology,
-        /// this will handle the notification to the user that the type being serialized is not yet
-        /// optimized but will only log the message once to prevent log spamming.
-        /// </summary>
-        internal static void LogSerializedTypeNotOptimized<T>()
-        {
-            if (DisableNotOptimizedSerializedType)
-            {
-                return;
-            }
-            var type = typeof(T);
-            if (!s_SerializedType.Contains(type))
-            {
-                s_SerializedType.Add(type);
-                if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
-                {
-                    Debug.LogWarning($"[{type.Name}] Serialized type has not been optimized for use with Distributed Authority!");
-                }
-            }
-        }
-#endif
-
-        internal static bool IsDistributedAuthority;
-
-        /// <summary>
-        /// Distributed Authority Mode
-        /// Returns true if the current session is running in distributed authority mode.
-        /// </summary>
-        public bool DistributedAuthorityMode { get; private set; }
-
-        /// <summary>
-        /// Distributed Authority Mode
-        /// Gets whether the NetworkManager is connected to a distributed authority state service.
-        /// <see cref="NetworkClient.DAHost"/> to determine if the instance is mocking the state service.
-        /// </summary>
-        public bool CMBServiceConnection
-        {
-            get
-            {
-                return NetworkConfig.UseCMBService;
-            }
-        }
-
-        /// <summary>
-        /// Distributed Authority Mode
-        /// When enabled, the player prefab will be automatically spawned on the newly connected client-side.
-        /// </summary>
-        /// <remarks>
-        /// Refer to <see cref="NetworkConfig.AutoSpawnPlayerPrefabClientSide"/> to enable/disable automatic spawning of the player prefab.
-        /// Alternately, override the <see cref="FetchLocalPlayerPrefabToSpawn"/> to control what prefab the player should spawn.
-        /// </remarks>
-        public bool AutoSpawnPlayerPrefabClientSide
-        {
-            get
-            {
-                return NetworkConfig.AutoSpawnPlayerPrefabClientSide;
-            }
-        }
-
-        /// <summary>
-        /// Distributed Authority Mode
-        /// Delegate definition for <see cref="FetchLocalPlayerPrefabToSpawn"/>
-        /// </summary>
-        /// <returns>Player Prefab <see cref="GameObject"/></returns>
-        public delegate GameObject OnFetchLocalPlayerPrefabToSpawnDelegateHandler();
-
-        /// <summary>
-        /// Distributed Authority Mode
-        /// When a callback is assigned, this provides control over what player prefab a client will be using.
-        /// This is invoked only when <see cref="NetworkConfig.AutoSpawnPlayerPrefabClientSide"/> is enabled.
-        /// </summary>
-        public OnFetchLocalPlayerPrefabToSpawnDelegateHandler OnFetchLocalPlayerPrefabToSpawn;
-
-        internal GameObject FetchLocalPlayerPrefabToSpawn()
-        {
-            if (!AutoSpawnPlayerPrefabClientSide)
-            {
-                Debug.LogError($"[{nameof(FetchLocalPlayerPrefabToSpawn)}] Invoked when {nameof(NetworkConfig.AutoSpawnPlayerPrefabClientSide)} was not set! Check call paths!");
-                return null;
-            }
-            if (OnFetchLocalPlayerPrefabToSpawn == null && NetworkConfig.PlayerPrefab == null)
-            {
-                return null;
-            }
-
-            if (OnFetchLocalPlayerPrefabToSpawn != null)
-            {
-                return OnFetchLocalPlayerPrefabToSpawn();
-            }
-            return NetworkConfig.PlayerPrefab;
-        }
-
-        /// <summary>
-        /// Distributed Authority Mode
-        /// Gets whether the current NetworkManager is running as a mock distributed authority state service (DAHost)
-        /// </summary>
-        public bool DAHost
-        {
-            get
-            {
-                return LocalClient.DAHost;
-            }
-        }
-
-        // DANGO-TODO-MVP: Remove these properties once the service handles object distribution
-        internal ulong ClientToRedistribute;
-        internal bool RedistributeToClient;
-        internal int TickToRedistribute;
-
-        internal List<NetworkObject> DeferredDespawnObjects = new List<NetworkObject>();
-
-        public ulong CurrentSessionOwner { get; internal set; }
-
-        /// <summary>
-        /// Delegate declaration for <see cref="OnSessionOwnerPromoted"/>
-        /// </summary>
-        /// <param name="sessionOwnerPromoted">the new session owner client identifier</param>
-        public delegate void OnSessionOwnerPromotedDelegateHandler(ulong sessionOwnerPromoted);
-
-        /// <summary>
-        /// Network Topology: Distributed Authority
-        /// When a new session owner is promoted, this event is triggered on all connected clients
-        /// </summary>
-        public event OnSessionOwnerPromotedDelegateHandler OnSessionOwnerPromoted;
-
-        internal void SetSessionOwner(ulong sessionOwner)
-        {
-            var previousSessionOwner = CurrentSessionOwner;
-            CurrentSessionOwner = sessionOwner;
-            LocalClient.IsSessionOwner = LocalClientId == sessionOwner;
-            if (LocalClient.IsSessionOwner)
-            {
-                foreach (var networkObjectEntry in SpawnManager.SpawnedObjects)
-                {
-                    var networkObject = networkObjectEntry.Value;
-                    if (networkObject.IsSceneObject == null || !networkObject.IsSceneObject.Value)
-                    {
-                        continue;
-                    }
-                    if (networkObject.OwnerClientId != LocalClientId)
-                    {
-                        SpawnManager.ChangeOwnership(networkObject, LocalClientId, true);
-                    }
-                }
-            }
-
-            OnSessionOwnerPromoted?.Invoke(sessionOwner);
-        }
-
-        internal void PromoteSessionOwner(ulong clientId)
-        {
-            if (!DistributedAuthorityMode)
-            {
-                NetworkLog.LogErrorServer($"[SceneManagement][NotDA] Invoking promote session owner while not in distributed authority mode!");
-                return;
-            }
-            if (!DAHost)
-            {
-                NetworkLog.LogErrorServer($"[SceneManagement][NotDAHost] Client is attempting to promote another client as the session owner!");
-                return;
-            }
-            SetSessionOwner(clientId);
-            var sessionOwnerMessage = new SessionOwnerMessage()
-            {
-                SessionOwner = clientId,
-            };
-            var clients = ConnectionManager.ConnectedClientIds.Where(c => c != LocalClientId).ToArray();
-            foreach (var targetClient in clients)
-            {
-                ConnectionManager.SendMessage(ref sessionOwnerMessage, NetworkDelivery.ReliableSequenced, targetClient);
-            }
-        }
-
-        internal Dictionary<ulong, NetworkObject> NetworkTransformUpdate = new Dictionary<ulong, NetworkObject>();
-#if COM_UNITY_MODULES_PHYSICS
-        internal Dictionary<ulong, NetworkObject> NetworkTransformFixedUpdate = new Dictionary<ulong, NetworkObject>();
-#endif
-
-        internal void NetworkTransformRegistration(NetworkObject networkObject, bool onUpdate = true, bool register = true)
-        {
-            if (onUpdate)
-            {
-                if (register)
-                {
-                    if (!NetworkTransformUpdate.ContainsKey(networkObject.NetworkObjectId))
-                    {
-                        NetworkTransformUpdate.Add(networkObject.NetworkObjectId, networkObject);
-                    }
-                }
-                else
-                {
-                    NetworkTransformUpdate.Remove(networkObject.NetworkObjectId);
-                }
-            }
-#if COM_UNITY_MODULES_PHYSICS
-            else
-            {
-                if (register)
-                {
-                    if (!NetworkTransformFixedUpdate.ContainsKey(networkObject.NetworkObjectId))
-                    {
-                        NetworkTransformFixedUpdate.Add(networkObject.NetworkObjectId, networkObject);
-                    }
-                }
-                else
-                {
-                    NetworkTransformFixedUpdate.Remove(networkObject.NetworkObjectId);
-                }
-            }
-#endif
-        }
-
-        private void UpdateTopology()
-        {
-            var transportTopology = IsListening ? NetworkConfig.NetworkTransport.CurrentTopology() : NetworkConfig.NetworkTopology;
-            if (transportTopology != NetworkConfig.NetworkTopology)
-            {
-                NetworkLog.LogErrorServer($"[Topology Mismatch] Transport detected an issue with the topology ({transportTopology} | {NetworkConfig.NetworkTopology}) usage or setting! Disconnecting from session.");
-                Shutdown();
-            }
-            else
-            {
-                IsDistributedAuthority = DistributedAuthorityMode = transportTopology == NetworkTopologyTypes.DistributedAuthority;
-            }
-        }
-
         public void NetworkUpdate(NetworkUpdateStage updateStage)
         {
             switch (updateStage)
             {
                 case NetworkUpdateStage.EarlyUpdate:
                     {
-                        UpdateTopology();
                         ConnectionManager.ProcessPendingApprovals();
                         ConnectionManager.PollAndHandleNetworkEvents();
 
@@ -287,77 +48,24 @@ namespace Unity.Netcode
                         AnticipationSystem.SetupForUpdate();
                         MessageManager.ProcessIncomingMessageQueue();
                         MessageManager.CleanupDisconnectedClients();
+
                         AnticipationSystem.ProcessReanticipation();
                     }
                     break;
-#if COM_UNITY_MODULES_PHYSICS
-                case NetworkUpdateStage.FixedUpdate:
-                    {
-                        foreach (var networkObjectEntry in NetworkTransformFixedUpdate)
-                        {
-                            // if not active or not spawned then skip
-                            if (!networkObjectEntry.Value.gameObject.activeInHierarchy || !networkObjectEntry.Value.IsSpawned)
-                            {
-                                continue;
-                            }
-
-                            foreach (var networkTransformEntry in networkObjectEntry.Value.NetworkTransforms)
-                            {
-                                // only update if enabled
-                                if (networkTransformEntry.enabled)
-                                {
-                                    networkTransformEntry.OnFixedUpdate();
-                                }
-                            }
-                        }
-                    }
-                    break;
-#endif
                 case NetworkUpdateStage.PreUpdate:
                     {
                         NetworkTimeSystem.UpdateTime();
                         AnticipationSystem.Update();
                     }
                     break;
-                case NetworkUpdateStage.PreLateUpdate:
-                    {
-                        // Non-physics based non-authority NetworkTransforms update their states after all other components
-                        foreach (var networkObjectEntry in NetworkTransformUpdate)
-                        {
-                            // if not active or not spawned then skip
-                            if (!networkObjectEntry.Value.gameObject.activeInHierarchy || !networkObjectEntry.Value.IsSpawned)
-                            {
-                                continue;
-                            }
-
-                            foreach (var networkTransformEntry in networkObjectEntry.Value.NetworkTransforms)
-                            {
-                                // only update if enabled
-                                if (networkTransformEntry.enabled)
-                                {
-                                    networkTransformEntry.OnUpdate();
-                                }
-                            }
-                        }
-                    }
-                    break;
                 case NetworkUpdateStage.PostScriptLateUpdate:
-                    {
-                        AnticipationSystem.Sync();
-                        AnticipationSystem.SetupForRender();
-                    }
+
+                    AnticipationSystem.Sync();
+                    AnticipationSystem.SetupForRender();
                     break;
+
                 case NetworkUpdateStage.PostLateUpdate:
                     {
-                        // Handle deferred despawning
-                        if (DistributedAuthorityMode)
-                        {
-                            SpawnManager.DeferredDespawnUpdate(ServerTime);
-                        }
-
-                        // Update any NetworkObject's registered to notify of scene migration changes.
-                        NetworkObject.UpdateNetworkObjectSceneChanges();
-
                         // This should be invoked just prior to the MessageManager processes its outbound queue.
                         SceneManager.CheckForAndSendNetworkObjectSceneChanged();
 
@@ -373,16 +81,6 @@ namespace Unity.Netcode
                         // This is "ok" to invoke when not processing messages since it is just cleaning up messages that never got handled within their timeout period.
                         DeferredMessageManager.CleanupStaleTriggers();
 
-                        // DANGO-TODO-MVP: Remove this once the service handles object distribution
-                        // NOTE: This needs to be the last thing done and should happen exactly at this point
-                        // in the update
-                        if (RedistributeToClient && ServerTime.Tick <= TickToRedistribute)
-                        {
-                            RedistributeToClient = false;
-                            SpawnManager.DistributeNetworkObjects(ClientToRedistribute);
-                            ClientToRedistribute = 0;
-                        }
-
                         if (m_ShuttingDown)
                         {
                             // Host-server will disconnect any connected clients prior to finalizing its shutdown
@@ -483,17 +181,17 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets a dictionary of connected clients and their clientId keys.
+        /// Gets a dictionary of connected clients and their clientId keys. This is only accessible on the server.
         /// </summary>
-        public IReadOnlyDictionary<ulong, NetworkClient> ConnectedClients => ConnectionManager.ConnectedClients;
+        public IReadOnlyDictionary<ulong, NetworkClient> ConnectedClients => IsServer ? ConnectionManager.ConnectedClients : throw new NotServerException($"{nameof(ConnectionManager.ConnectedClients)} should only be accessed on server.");
 
         /// <summary>
-        /// Gets a list of connected clients.
+        /// Gets a list of connected clients. This is only accessible on the server.
         /// </summary>
-        public IReadOnlyList<NetworkClient> ConnectedClientsList => ConnectionManager.ConnectedClientsList;
+        public IReadOnlyList<NetworkClient> ConnectedClientsList => IsServer ? ConnectionManager.ConnectedClientsList : throw new NotServerException($"{nameof(ConnectionManager.ConnectedClientsList)} should only be accessed on server.");
 
         /// <summary>
-        /// Gets a list of just the IDs of all connected clients.
+        /// Gets a list of just the IDs of all connected clients. This is only accessible on the server.
         /// </summary>
         public IReadOnlyList<ulong> ConnectedClientsIds => ConnectionManager.ConnectedClientIds;
 
@@ -895,11 +593,6 @@ namespace Unity.Netcode
             OnNetworkManagerReset?.Invoke(this);
         }
 
-        protected virtual void OnValidateComponent()
-        {
-
-        }
-
         internal void OnValidate()
         {
             if (NetworkConfig == null)
@@ -960,15 +653,6 @@ namespace Unity.Netcode
                     }
                 }
             }
-
-            try
-            {
-                OnValidateComponent();
-            }
-            catch (Exception ex)
-            {
-                Debug.LogException(ex);
-            }
         }
 
         private void ModeChanged(PlayModeStateChange change)
@@ -1127,23 +811,6 @@ namespace Unity.Netcode
 
         internal void Initialize(bool server)
         {
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (!DisableNotOptimizedSerializedType)
-            {
-                s_SerializedType.Clear();
-            }
-#endif
-
-#if COM_UNITY_MODULES_PHYSICS
-            NetworkTransformFixedUpdate.Clear();
-#endif
-            NetworkTransformUpdate.Clear();
-
-            UpdateTopology();
-
-            //DANGOEXP TODO: Remove this before finalizing the experimental release
-            NetworkConfig.AutoSpawnPlayerPrefabClientSide = DistributedAuthorityMode;
-
             // Make sure the ServerShutdownState is reset when initializing
             if (server)
             {
@@ -1176,12 +843,8 @@ namespace Unity.Netcode
             }
 
             this.RegisterNetworkUpdate(NetworkUpdateStage.EarlyUpdate);
-#if COM_UNITY_MODULES_PHYSICS
-            this.RegisterNetworkUpdate(NetworkUpdateStage.FixedUpdate);
-#endif
             this.RegisterNetworkUpdate(NetworkUpdateStage.PreUpdate);
             this.RegisterNetworkUpdate(NetworkUpdateStage.PostScriptLateUpdate);
-            this.RegisterNetworkUpdate(NetworkUpdateStage.PreLateUpdate);
             this.RegisterNetworkUpdate(NetworkUpdateStage.PostLateUpdate);
 
             // ComponentFactory needs to set its defaults next
@@ -1197,17 +860,11 @@ namespace Unity.Netcode
                 MessageManager.Hook(new NetworkManagerHooks(this));
 
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
-                if (NetworkConfig.NetworkProfilingMetrics)
-                {
-                    MessageManager.Hook(new ProfilingHooks());
-                }
+                MessageManager.Hook(new ProfilingHooks());
 #endif
 
 #if MULTIPLAYER_TOOLS
-                if (NetworkConfig.NetworkMessageMetrics)
-                {
-                    MessageManager.Hook(new MetricHooks(this));
-                }
+                MessageManager.Hook(new MetricHooks(this));
 #endif
 
                 // Assures there is a server message queue available
@@ -1306,10 +963,7 @@ namespace Unity.Netcode
                 return false;
             }
 
-            if (!ConnectionManager.LocalClient.SetRole(true, false, this))
-            {
-                return false;
-            }
+            ConnectionManager.LocalClient.SetRole(true, false, this);
             ConnectionManager.LocalClient.ClientId = ServerClientId;
 
             Initialize(true);
@@ -1322,8 +976,6 @@ namespace Unity.Netcode
                 {
                     SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
 
-                    // Notify the server that everything should be synchronized/spawned at this time.
-                    SpawnManager.NotifyNetworkObjectsSynchronized();
                     OnServerStarted?.Invoke();
                     ConnectionManager.LocalClient.IsApproved = true;
                     return true;
@@ -1357,10 +1009,7 @@ namespace Unity.Netcode
                 return false;
             }
 
-            if (!ConnectionManager.LocalClient.SetRole(false, true, this))
-            {
-                return false;
-            }
+            ConnectionManager.LocalClient.SetRole(false, true, this);
 
             Initialize(false);
 
@@ -1403,11 +1052,7 @@ namespace Unity.Netcode
                 return false;
             }
 
-            if (!ConnectionManager.LocalClient.SetRole(true, true, this))
-            {
-                return false;
-            }
-
+            ConnectionManager.LocalClient.SetRole(true, true, this);
             Initialize(true);
             try
             {
@@ -1463,17 +1108,13 @@ namespace Unity.Netcode
                 var response = new ConnectionApprovalResponse
                 {
                     Approved = true,
-                    // Distributed authority always returns true since the client side handles spawning (whether automatically or manually)
-                    CreatePlayerObject = DistributedAuthorityMode || NetworkConfig.PlayerPrefab != null,
+                    CreatePlayerObject = NetworkConfig.PlayerPrefab != null
                 };
                 ConnectionManager.HandleConnectionApproval(ServerClientId, response);
             }
 
             SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
 
-            // Notify the host that everything should be synchronized/spawned at this time.
-            SpawnManager.NotifyNetworkObjectsSynchronized();
-
             OnServerStarted?.Invoke();
             OnClientStarted?.Invoke();
 
@@ -1616,7 +1257,6 @@ namespace Unity.Netcode
             NetworkTickSystem = null;
         }
 
-
         // Ensures that the NetworkManager is cleaned up before OnDestroy is run on NetworkObjects and NetworkBehaviours when quitting the application.
         private void OnApplicationQuit()
         {

Runtime/Core/NetworkUpdateLoop.cs

@@ -61,6 +61,7 @@ namespace Unity.Netcode
         PostScriptLateUpdate = 8,
         /// <summary>
         /// Updated after the Monobehaviour.LateUpdate for all components is invoked
+        /// and all rendering is complete
         /// </summary>
         PostLateUpdate = 7
     }

Runtime/Logging/NetworkLog.cs

@@ -39,12 +39,6 @@ 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>
@@ -64,8 +58,7 @@ namespace Unity.Netcode
             var networkManager = NetworkManagerOverride ??= NetworkManager.Singleton;
             // Get the sender of the local log
             ulong localId = networkManager?.LocalClientId ?? 0;
-            bool isServer = networkManager && networkManager.DistributedAuthorityMode ? networkManager.LocalClient.IsSessionOwner :
-                networkManager && !networkManager.DistributedAuthorityMode ? networkManager.IsServer : true;
+            bool isServer = networkManager?.IsServer ?? true;
             switch (logType)
             {
                 case LogType.Info:
@@ -105,8 +98,7 @@ namespace Unity.Netcode
                 var networkMessage = new ServerLogMessage
                 {
                     LogType = logType,
-                    Message = message,
-                    SenderId = localId
+                    Message = message
                 };
                 var size = networkManager.ConnectionManager.SendMessage(ref networkMessage, NetworkDelivery.ReliableFragmentedSequenced, NetworkManager.ServerClientId);
 
@@ -114,19 +106,9 @@ namespace Unity.Netcode
             }
         }
 
-        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 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}");
 
         internal enum LogType : byte
         {

Runtime/Messaging/CustomMessageManager.cs

@@ -63,40 +63,16 @@ namespace Unity.Netcode
         /// <param name="networkDelivery">The delivery type (QoS) to send data with</param>
         public void SendUnnamedMessage(IReadOnlyList<ulong> clientIds, FastBufferWriter messageBuffer, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
         {
+            if (!m_NetworkManager.IsServer)
+            {
+                throw new InvalidOperationException("Can not send unnamed messages to multiple users as a client");
+            }
+
             if (clientIds == null)
             {
-                throw new ArgumentNullException(nameof(clientIds), "You must pass in a valid clientId List!");
+                throw new ArgumentNullException(nameof(clientIds), "You must pass in a valid clientId List");
             }
 
-            if (!m_NetworkManager.DistributedAuthorityMode && !m_NetworkManager.IsServer)
-            {
-                if (clientIds.Count > 1 || (clientIds.Count == 1 && clientIds[0] != NetworkManager.ServerClientId))
-                {
-                    Debug.LogError("Clients cannot send unnamed messages to other clients!");
-                    return;
-                }
-                else if (clientIds.Count == 1)
-                {
-                    SendUnnamedMessage(clientIds[0], messageBuffer, networkDelivery);
-                }
-            }
-            else if (m_NetworkManager.DistributedAuthorityMode && !m_NetworkManager.DAHost)
-            {
-                if (clientIds.Count > 1)
-                {
-                    Debug.LogError("Sending an unnamed message to multiple clients is not yet supported in distributed authority.");
-                    return;
-                }
-            }
-
-            if (clientIds.Count == 0)
-            {
-                Debug.LogError($"{nameof(clientIds)} is empty! No clients to send to.");
-                return;
-            }
-
-            ValidateMessageSize(messageBuffer, networkDelivery, isNamed: false);
-
             if (m_NetworkManager.IsHost)
             {
                 for (var i = 0; i < clientIds.Count; ++i)
@@ -132,8 +108,6 @@ namespace Unity.Netcode
         /// <param name="networkDelivery">The delivery type (QoS) to send data with</param>
         public void SendUnnamedMessage(ulong clientId, FastBufferWriter messageBuffer, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
         {
-            ValidateMessageSize(messageBuffer, networkDelivery, isNamed: false);
-
             if (m_NetworkManager.IsHost)
             {
                 if (clientId == m_NetworkManager.LocalClientId)
@@ -178,14 +152,18 @@ namespace Unity.Netcode
                 // We dont know what size to use. Try every (more collision prone)
                 if (m_NamedMessageHandlers32.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler32))
                 {
+                    // handler can remove itself, cache the name for metrics
+                    string messageName = m_MessageHandlerNameLookup32[hash];
                     messageHandler32(sender, reader);
-                    m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup32[hash], bytesCount);
+                    m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount);
                 }
 
                 if (m_NamedMessageHandlers64.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler64))
                 {
+                    // handler can remove itself, cache the name for metrics
+                    string messageName = m_MessageHandlerNameLookup64[hash];
                     messageHandler64(sender, reader);
-                    m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup64[hash], bytesCount);
+                    m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount);
                 }
             }
             else
@@ -196,15 +174,19 @@ namespace Unity.Netcode
                     case HashSize.VarIntFourBytes:
                         if (m_NamedMessageHandlers32.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler32))
                         {
+                            // handler can remove itself, cache the name for metrics
+                            string messageName = m_MessageHandlerNameLookup32[hash];
                             messageHandler32(sender, reader);
-                            m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup32[hash], bytesCount);
+                            m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount);
                         }
                         break;
                     case HashSize.VarIntEightBytes:
                         if (m_NamedMessageHandlers64.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler64))
                         {
+                            // handler can remove itself, cache the name for metrics
+                            string messageName = m_MessageHandlerNameLookup64[hash];
                             messageHandler64(sender, reader);
-                            m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup64[hash], bytesCount);
+                            m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount);
                         }
                         break;
                 }
@@ -229,14 +211,6 @@ namespace Unity.Netcode
             var hash32 = XXHash.Hash32(name);
             var hash64 = XXHash.Hash64(name);
 
-            if (m_NetworkManager.LogLevel <= LogLevel.Developer)
-            {
-                if (m_MessageHandlerNameLookup32.ContainsKey(hash32) || m_MessageHandlerNameLookup64.ContainsKey(hash64))
-                {
-                    Debug.LogWarning($"Registering {name} named message over existing registration! Your previous registration's callback is being overwritten!");
-                }
-            }
-
             m_NamedMessageHandlers32[hash32] = callback;
             m_NamedMessageHandlers64[hash64] = callback;
 
@@ -289,8 +263,6 @@ namespace Unity.Netcode
         /// <param name="networkDelivery">The delivery type (QoS) to send data with</param>
         public void SendNamedMessage(string messageName, ulong clientId, FastBufferWriter messageStream, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
         {
-            ValidateMessageSize(messageStream, networkDelivery, isNamed: true);
-
             ulong hash = 0;
             switch (m_NetworkManager.NetworkConfig.RpcHashSize)
             {
@@ -339,41 +311,16 @@ namespace Unity.Netcode
         /// <param name="networkDelivery">The delivery type (QoS) to send data with</param>
         public void SendNamedMessage(string messageName, IReadOnlyList<ulong> clientIds, FastBufferWriter messageStream, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
         {
+            if (!m_NetworkManager.IsServer)
+            {
+                throw new InvalidOperationException("Can not send unnamed messages to multiple users as a client");
+            }
+
             if (clientIds == null)
             {
-                throw new ArgumentNullException(nameof(clientIds), "Client list is null! You must pass in a valid clientId list to send a named message.");
+                throw new ArgumentNullException(nameof(clientIds), "You must pass in a valid clientId List");
             }
 
-            if (!m_NetworkManager.DistributedAuthorityMode && !m_NetworkManager.IsServer)
-            {
-                if (clientIds.Count > 1 || (clientIds.Count == 1 && clientIds[0] != NetworkManager.ServerClientId))
-                {
-                    Debug.LogError("Clients cannot send named messages to other clients!");
-                    return;
-                }
-                else if (clientIds.Count == 1)
-                {
-                    SendNamedMessage(messageName, clientIds[0], messageStream, networkDelivery);
-                    return;
-                }
-            }
-            else if (m_NetworkManager.DistributedAuthorityMode && !m_NetworkManager.DAHost)
-            {
-                if (clientIds.Count > 1)
-                {
-                    Debug.LogError("Sending a named message to multiple clients is not yet supported in distributed authority.");
-                    return;
-                }
-            }
-
-            if (clientIds.Count == 0)
-            {
-                Debug.LogError($"{nameof(clientIds)} is empty! No clients to send the named message {messageName} to!");
-                return;
-            }
-
-            ValidateMessageSize(messageStream, networkDelivery, isNamed: true);
-
             ulong hash = 0;
             switch (m_NetworkManager.NetworkConfig.RpcHashSize)
             {
@@ -412,32 +359,5 @@ namespace Unity.Netcode
                 m_NetworkManager.NetworkMetrics.TrackNamedMessageSent(clientIds, messageName, size);
             }
         }
-
-        /// <summary>
-        /// Validate the size of the message. If it's a non-fragmented delivery type the message must fit within the
-        /// max allowed size with headers also subtracted. Named messages also include the hash
-        /// of the name string. Only validates in editor and development builds.
-        /// </summary>
-        /// <param name="messageStream">The named message payload</param>
-        /// <param name="networkDelivery">Delivery method</param>
-        /// <param name="isNamed">Is the message named (or unnamed)</param>
-        /// <exception cref="OverflowException">Exception thrown in case validation fails</exception>
-        private unsafe void ValidateMessageSize(FastBufferWriter messageStream, NetworkDelivery networkDelivery, bool isNamed)
-        {
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
-            var maxNonFragmentedSize = m_NetworkManager.MessageManager.NonFragmentedMessageMaxSize - FastBufferWriter.GetWriteSize<NetworkMessageHeader>() - sizeof(NetworkBatchHeader);
-            if (isNamed)
-            {
-                maxNonFragmentedSize -= sizeof(ulong); // MessageName hash
-            }
-            if (networkDelivery != NetworkDelivery.ReliableFragmentedSequenced
-                && messageStream.Length > maxNonFragmentedSize)
-            {
-                throw new OverflowException($"Given message size ({messageStream.Length} bytes) is greater than " +
-                    $"the maximum allowed for the selected delivery method ({maxNonFragmentedSize} bytes). Try using " +
-                    $"ReliableFragmentedSequenced delivery method instead.");
-            }
-#endif
-        }
     }
 }

Runtime/Messaging/DeferredMessageManager.cs

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

Runtime/Messaging/IDeferredNetworkMessageManager.cs

@@ -1,4 +1,3 @@
-
 namespace Unity.Netcode
 {
     internal interface IDeferredNetworkMessageManager
@@ -18,7 +17,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, string messageType = null);
+        void DeferMessage(TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context);
 
         /// <summary>
         /// Cleans up any trigger that's existed for more than a second.

Runtime/Messaging/ILPPMessageProvider.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Generic;
 #if UNITY_EDITOR
 using UnityEditor;
@@ -13,121 +12,9 @@ namespace Unity.Netcode
         internal static readonly List<NetworkMessageManager.MessageWithHandler> __network_message_types = new List<NetworkMessageManager.MessageWithHandler>();
 #pragma warning restore IDE1006 // restore naming rule violation check
 
-        /// <summary>
-        /// Enum representing the different types of messages that can be sent over the network.
-        /// The values cannot be changed, as they are used to serialize and deserialize messages.
-        /// Adding new messages should be done by adding new values to the end of the enum 
-        /// using the next free value.
-        /// </summary>
-        /// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-        /// Add any new Message types to this table at the END with incremented index value
-        /// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-        internal enum NetworkMessageTypes : uint
-        {
-            ConnectionApproved = 0,
-            ConnectionRequest = 1,
-            ChangeOwnership = 2,
-            ClientConnected = 3,
-            ClientDisconnected = 4,
-            ClientRpc = 5,
-            CreateObject = 6,
-            DestroyObject = 7,
-            DisconnectReason = 8,
-            ForwardClientRpc = 9,
-            ForwardServerRpc = 10,
-            NamedMessage = 11,
-            NetworkTransformMessage = 12,
-            NetworkVariableDelta = 13,
-            ParentSync = 14,
-            Proxy = 15,
-            Rpc = 16,
-            SceneEvent = 17,
-            ServerLog = 18,
-            ServerRpc = 19,
-            SessionOwner = 20,
-            TimeSync = 21,
-            Unnamed = 22,
-            AnticipationCounterSyncPingMessage = 23,
-            AnticipationCounterSyncPongMessage = 24,
-        }
-
-
-        // Enable this for integration tests that need no message types defined
-        internal static bool IntegrationTestNoMessages;
-
         public List<NetworkMessageManager.MessageWithHandler> GetMessages()
         {
-            // return no message types when defined for integration tests
-            if (IntegrationTestNoMessages)
-            {
-                return new List<NetworkMessageManager.MessageWithHandler>();
-            }
-            var messageTypeCount = Enum.GetValues(typeof(NetworkMessageTypes)).Length;
-            // Assure the allowed types count is the same as our NetworkMessageType enum count
-            if (__network_message_types.Count != messageTypeCount)
-            {
-                throw new Exception($"Allowed types is not equal to the number of message type indices! Allowed Count: {__network_message_types.Count} | Index Count: {messageTypeCount}");
-            }
-
-            // Populate with blanks to be replaced later
-            var adjustedMessageTypes = new List<NetworkMessageManager.MessageWithHandler>();
-            var blank = new NetworkMessageManager.MessageWithHandler();
-            for (int i = 0; i < messageTypeCount; i++)
-            {
-                adjustedMessageTypes.Add(blank);
-            }
-
-            // Create a type to enum index lookup table
-            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-            // Add new Message types to this table paired with its new NetworkMessageTypes enum
-            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-            var messageTypes = new Dictionary<Type, NetworkMessageTypes>
-            {
-                { typeof(ConnectionApprovedMessage), NetworkMessageTypes.ConnectionApproved }, // This MUST be first
-                { typeof(ConnectionRequestMessage), NetworkMessageTypes.ConnectionRequest }, // This MUST be second
-                { typeof(ChangeOwnershipMessage), NetworkMessageTypes.ChangeOwnership },
-                { typeof(ClientConnectedMessage), NetworkMessageTypes.ClientConnected },
-                { typeof(ClientDisconnectedMessage), NetworkMessageTypes.ClientDisconnected },
-                { typeof(ClientRpcMessage), NetworkMessageTypes.ClientRpc },
-                { typeof(CreateObjectMessage), NetworkMessageTypes.CreateObject },
-                { typeof(DestroyObjectMessage), NetworkMessageTypes.DestroyObject },
-                { typeof(DisconnectReasonMessage), NetworkMessageTypes.DisconnectReason },
-                { typeof(ForwardClientRpcMessage), NetworkMessageTypes.ForwardClientRpc },
-                { typeof(ForwardServerRpcMessage), NetworkMessageTypes.ForwardServerRpc },
-                { typeof(NamedMessage), NetworkMessageTypes.NamedMessage },
-                { typeof(NetworkTransformMessage), NetworkMessageTypes.NetworkTransformMessage },
-                { typeof(NetworkVariableDeltaMessage), NetworkMessageTypes.NetworkVariableDelta },
-                { typeof(ParentSyncMessage), NetworkMessageTypes.ParentSync },
-                { typeof(ProxyMessage), NetworkMessageTypes.Proxy },
-                { typeof(RpcMessage), NetworkMessageTypes.Rpc },
-                { typeof(SceneEventMessage), NetworkMessageTypes.SceneEvent },
-                { typeof(ServerLogMessage), NetworkMessageTypes.ServerLog },
-                { typeof(ServerRpcMessage), NetworkMessageTypes.ServerRpc },
-                { typeof(TimeSyncMessage), NetworkMessageTypes.TimeSync },
-                { typeof(UnnamedMessage), NetworkMessageTypes.Unnamed },
-                { typeof(SessionOwnerMessage), NetworkMessageTypes.SessionOwner },
-                { typeof(AnticipationCounterSyncPingMessage), NetworkMessageTypes.AnticipationCounterSyncPingMessage},
-                { typeof(AnticipationCounterSyncPongMessage), NetworkMessageTypes.AnticipationCounterSyncPongMessage},
-            };
-
-            // Assure the type to lookup table count and NetworkMessageType enum count matches (i.e. to catch human error when adding new messages)
-            if (messageTypes.Count != messageTypeCount)
-            {
-                throw new Exception($"Message type to Message type index count mistmatch! Table Count: {messageTypes.Count} | Index Count: {messageTypeCount}");
-            }
-
-            // Now order the allowed types list based on the order of the NetworkMessageType enum
-            foreach (var messageHandler in __network_message_types)
-            {
-                if (!messageTypes.ContainsKey(messageHandler.MessageType))
-                {
-                    throw new Exception($"Missing message type from lookup table: {messageHandler.MessageType}");
-                }
-                adjustedMessageTypes[(int)messageTypes[messageHandler.MessageType]] = messageHandler;
-            }
-
-            // return the NetworkMessageType enum ordered list
-            return adjustedMessageTypes;
+            return __network_message_types;
         }
 
 #if UNITY_EDITOR

Runtime/Messaging/Messages/AnticipationCounterSync.cs.meta

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

Runtime/Messaging/Messages/AnticipationCounterSyncPingMessage.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: b7d5c92979ad7e646a078aaf058b53a9

Runtime/Messaging/Messages/ChangeOwnershipMessage.cs

@@ -1,154 +1,16 @@
-
 namespace Unity.Netcode
 {
     internal struct ChangeOwnershipMessage : INetworkMessage, INetworkSerializeByMemcpy
     {
         public int Version => 0;
 
-        private const string k_Name = "ChangeOwnershipMessage";
-
         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)
@@ -160,241 +22,46 @@ namespace Unity.Netcode
             }
             ByteUnpacker.ReadValueBitPacked(reader, out NetworkObjectId);
             ByteUnpacker.ReadValueBitPacked(reader, out OwnerClientId);
-
-            if (networkManager.DistributedAuthorityMode)
+            if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
             {
-                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, k_Name);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
                 return false;
             }
+
             return true;
         }
 
         public void Handle(ref NetworkContext context)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
-
-            // 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;
 
-            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)
+            // We are current owner.
+            if (originalOwner == networkManager.LocalClientId)
             {
                 networkObject.InvokeBehaviourOnLostOwnership();
             }
 
-            // We are new owner or (client-server) or running in distributed authority mode
-            if (OwnerClientId == networkManager.LocalClientId || networkManager.DistributedAuthorityMode)
+            // We are new owner.
+            if (OwnerClientId == networkManager.LocalClientId)
             {
                 networkObject.InvokeBehaviourOnGainedOwnership();
             }
 
-            // If in distributed authority mode 
-            if (networkManager.DistributedAuthorityMode)
+            // For all other clients that are neither the former or current owner, update the behaviours' properties
+            if (OwnerClientId != networkManager.LocalClientId && originalOwner != networkManager.LocalClientId)
             {
-                // Always update the network properties in distributed authority mode 
                 for (int i = 0; i < networkObject.ChildNetworkBehaviours.Count; i++)
                 {
                     networkObject.ChildNetworkBehaviours[i].UpdateNetworkProperties();
                 }
             }
-            else // Otherwise update properties like we would in client-server
-            {
-                // For all other clients that are neither the former or current owner, update the behaviours' properties
-                if (OwnerClientId != networkManager.LocalClientId && originalOwner != networkManager.LocalClientId)
-                {
-                    for (int i = 0; i < networkObject.ChildNetworkBehaviours.Count; i++)
-                    {
-                        networkObject.ChildNetworkBehaviours[i].UpdateNetworkProperties();
-                    }
-                }
-            }
 
-            // Always invoke ownership change notifications
             networkObject.InvokeOwnershipChanged(originalOwner, OwnerClientId);
 
-            // If this change was requested, then notify that the request was approved (doing this last so all ownership
-            // changes have already been applied if the callback is invoked)
-            if (networkManager.DistributedAuthorityMode && networkManager.LocalClientId == OwnerClientId)
-            {
-                if (RequestApproved)
-                {
-                    networkObject.OwnershipRequestResponse(NetworkObject.OwnershipRequestResponseStatus.Approved);
-                }
-
-                // If the NetworkObject changed ownership and the Requested flag was set (i.e. it was an ownership request),
-                // then the new owner granted ownership removes the Requested flag and sends out an ownership status update.
-                if (networkObject.HasExtendedOwnershipStatus(NetworkObject.OwnershipStatusExtended.Requested))
-                {
-                    networkObject.RemoveOwnershipExtended(NetworkObject.OwnershipStatusExtended.Requested);
-                    networkObject.SendOwnershipStatusUpdate();
-                }
-            }
-
             networkManager.NetworkMetrics.TrackOwnershipChangeReceived(context.SenderId, networkObject, context.MessageSize);
         }
     }

Runtime/Messaging/Messages/ClientConnectedMessage.cs

@@ -6,13 +6,9 @@ namespace Unity.Netcode
 
         public ulong ClientId;
 
-        public bool ShouldSynchronize;
-
-
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
             BytePacker.WriteValueBitPacked(writer, ClientId);
-            writer.WriteValueSafe(ShouldSynchronize);
         }
 
         public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
@@ -23,53 +19,17 @@ namespace Unity.Netcode
                 return false;
             }
             ByteUnpacker.ReadValueBitPacked(reader, out ClientId);
-            reader.ReadValueSafe(out ShouldSynchronize);
-
             return true;
         }
 
         public void Handle(ref NetworkContext context)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
-            if (ShouldSynchronize && networkManager.NetworkConfig.EnableSceneManagement && 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);
-            }
+            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)
-                {
-                    // Show any NetworkObjects that are:
-                    // - Hidden from the session owner
-                    // - Owned by this client
-                    // - Has NetworkObject.SpawnWithObservers set to true (the default)
-                    if (!networkManager.LocalClient.IsSessionOwner)
-                    {
-                        networkManager.SpawnManager.ShowHiddenObjectsToNewlyJoinedClient(ClientId);
-                    }
-
-                    // We defer redistribution to the end of the NetworkUpdateStage.PostLateUpdate
-                    networkManager.RedistributeToClient = true;
-                    networkManager.ClientToRedistribute = ClientId;
-                    networkManager.TickToRedistribute = networkManager.ServerTime.Tick + 20;
-                }
-            }
         }
     }
 }

Runtime/Messaging/Messages/ClientDisconnectedMessage.cs

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

Runtime/Messaging/Messages/ConnectionApprovedMessage.cs

@@ -10,11 +10,6 @@ namespace Unity.Netcode
 
         public ulong OwnerClientId;
         public int NetworkTick;
-        // The cloud state service should set this if we are restoring a session
-        public bool IsRestoredSession;
-        public ulong CurrentSessionOwner;
-        // Not serialized
-        public bool IsDistributedAuthority;
 
         // Not serialized, held as references to serialize NetworkVariable data
         public HashSet<NetworkObject> SpawnedObjectsList;
@@ -43,11 +38,6 @@ namespace Unity.Netcode
 
             BytePacker.WriteValueBitPacked(writer, OwnerClientId);
             BytePacker.WriteValueBitPacked(writer, NetworkTick);
-            if (IsDistributedAuthority)
-            {
-                writer.WriteValueSafe(IsRestoredSession);
-                BytePacker.WriteValueBitPacked(writer, CurrentSessionOwner);
-            }
 
             if (targetVersion >= k_VersionAddClientIds)
             {
@@ -69,8 +59,7 @@ namespace Unity.Netcode
                     if (sobj.SpawnWithObservers && (sobj.CheckObjectVisibility == null || sobj.CheckObjectVisibility(OwnerClientId)))
                     {
                         sobj.Observers.Add(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);
+                        var sceneObject = sobj.GetMessageSceneObject(OwnerClientId);
                         sceneObject.Serialize(writer);
                         ++sceneObjectCount;
                     }
@@ -125,11 +114,6 @@ 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)
             {
@@ -147,23 +131,10 @@ 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);
@@ -177,26 +148,13 @@ namespace Unity.Netcode
             networkManager.ConnectionManager.ConnectedClientIds.Clear();
             foreach (var clientId in ConnectedClientIds)
             {
-                if (!networkManager.ConnectionManager.ConnectedClientIds.Contains(clientId))
-                {
-                    networkManager.ConnectionManager.AddClient(clientId);
-                }
+                networkManager.ConnectionManager.ConnectedClientIds.Add(clientId);
             }
 
             // Only if scene management is disabled do we handle NetworkObject synchronization at this point
             if (!networkManager.NetworkConfig.EnableSceneManagement)
             {
-                // 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();
-                }
-
+                networkManager.SpawnManager.DestroySceneObjects();
                 m_ReceivedSceneObjectData.ReadValueSafe(out uint sceneObjectCount);
 
                 // Deserializing NetworkVariable data is deferred from Receive() to Handle to avoid needing
@@ -210,58 +168,10 @@ namespace Unity.Netcode
 
                 // Mark the client being connected
                 networkManager.IsConnectedClient = true;
-
-                if (networkManager.AutoSpawnPlayerPrefabClientSide)
-                {
-                    networkManager.ConnectionManager.CreateAndSpawnPlayer(OwnerClientId);
-                }
-
-                if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
-                {
-                    NetworkLog.LogInfo($"[Client-{OwnerClientId}][Scene Management Disabled] Synchronization complete!");
-                }
                 // When scene management is disabled we notify after everything is synchronized
                 networkManager.ConnectionManager.InvokeOnClientConnectedCallback(context.SenderId);
-
-                // For convenience, notify all NetworkBehaviours that synchronization is complete.
-                networkManager.SpawnManager.NotifyNetworkObjectsSynchronized();
             }
-            else
-            {
-                if (networkManager.DistributedAuthorityMode && networkManager.CMBServiceConnection && networkManager.LocalClient.IsSessionOwner && networkManager.NetworkConfig.EnableSceneManagement)
-                {
-                    // Mark the client being connected
-                    networkManager.IsConnectedClient = true;
 
-                    networkManager.SceneManager.IsRestoringSession = IsRestoredSession;
-
-                    if (!IsRestoredSession)
-                    {
-                        // Synchronize the service with the initial session owner's loaded scenes and spawned objects
-                        networkManager.SceneManager.SynchronizeNetworkObjects(NetworkManager.ServerClientId);
-
-                        // 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);
-
-                        // With scene management enabled and since the session owner doesn't send a Synchronize scene event synchronize itself,
-                        // we need to notify the session owner that everything should be synchronized/spawned at this time.
-                        networkManager.SpawnManager.NotifyNetworkObjectsSynchronized();
-
-                        // When scene management is enabled and since the session owner is synchronizing the service (i.e. acting like  host),
-                        // we need to locallyh invoke the OnClientConnected callback at this point in time.
-                        networkManager.ConnectionManager.InvokeOnClientConnectedCallback(OwnerClientId);
-                    }
-                }
-            }
             ConnectedClientIds.Dispose();
         }
     }

Runtime/Messaging/Messages/ConnectionRequestMessage.cs

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

Runtime/Messaging/Messages/CreateObjectMessage.cs

@@ -1,120 +1,16 @@
-using System.Linq;
 using System.Runtime.CompilerServices;
-
 namespace Unity.Netcode
 {
     internal struct CreateObjectMessage : INetworkMessage
     {
         public int Version => 0;
 
-        private const string k_Name = "CreateObjectMessage";
-
         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)
         {
-            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);
-            }
+            ObjectInfo.Serialize(writer);
         }
 
         public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
@@ -125,45 +21,10 @@ namespace Unity.Netcode
                 return false;
             }
 
-            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);
-            }
-
+            ObjectInfo.Deserialize(reader);
             if (!networkManager.NetworkConfig.ForceSamePrefabs && !networkManager.SpawnManager.HasPrefab(ObjectInfo))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context, k_Name);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context);
                 return false;
             }
             m_ReceivedNetworkVariableData = reader;
@@ -177,130 +38,21 @@ namespace Unity.Netcode
             // If a client receives a create object message and it is still synchronizing, then defer the object creation until it has finished synchronizing
             if (networkManager.SceneManager.ShouldDeferCreateObject())
             {
-                networkManager.SceneManager.DeferCreateObject(context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData, ObserverIds, NewObserverIds);
+                networkManager.SceneManager.DeferCreateObject(context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData);
             }
             else
             {
-                if (networkManager.DistributedAuthorityMode && !IncludesSerializedObject && UpdateObservers)
-                {
-                    ObjectInfo = new NetworkObject.SceneObject()
-                    {
-                        NetworkObjectId = NetworkObjectId,
-                    };
-                }
-                CreateObject(ref networkManager, context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData, ObserverIds, NewObserverIds);
+                CreateObject(ref networkManager, context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData);
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static void CreateObject(ref NetworkManager networkManager, ref NetworkSceneManager.DeferredObjectCreation deferredObjectCreation)
+        internal static void CreateObject(ref NetworkManager networkManager, ulong senderId, uint messageSize, NetworkObject.SceneObject sceneObject, FastBufferReader networkVariableData)
         {
-            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);
-                }
+                var networkObject = NetworkObject.AddSceneObject(sceneObject, networkVariableData, networkManager);
+                networkManager.NetworkMetrics.TrackObjectSpawnReceived(senderId, networkObject, messageSize);
             }
             catch (System.Exception ex)
             {

Runtime/Messaging/Messages/DestroyObjectMessage.cs

@@ -1,62 +1,15 @@
-using System.Linq;
-
 namespace Unity.Netcode
 {
     internal struct DestroyObjectMessage : INetworkMessage, INetworkSerializeByMemcpy
     {
         public int Version => 0;
 
-        private const string k_Name = "DestroyObjectMessage";
-
         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);
         }
 
@@ -69,25 +22,12 @@ 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))
             {
-                // 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, k_Name);
-                }
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                return false;
             }
             return true;
         }
@@ -95,80 +35,14 @@ namespace Unity.Netcode
         public void Handle(ref NetworkContext context)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
-
-            var networkObject = (NetworkObject)null;
-            if (!networkManager.DistributedAuthorityMode)
+            if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
             {
-                // 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);
-                }
+                // This is the same check and log message that happens inside OnDespawnObject, but we have to do it here
+                return;
             }
 
-            // 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);
-            }
+            networkManager.NetworkMetrics.TrackObjectDestroyReceived(context.SenderId, networkObject, context.MessageSize);
+            networkManager.SpawnManager.OnDespawnObject(networkObject, DestroyGameObject);
         }
     }
 }

Runtime/Messaging/Messages/NetworkTransformMessage.cs

@@ -1,193 +0,0 @@
-using Unity.Netcode.Components;
-using UnityEngine;
-
-namespace Unity.Netcode
-{
-    /// <summary>
-    /// NetworkTransform State Update Message
-    /// </summary>
-    internal struct NetworkTransformMessage : INetworkMessage
-    {
-        public int Version => 0;
-        private const string k_Name = "NetworkTransformMessage";
-
-        internal NetworkTransform NetworkTransform;
-
-        // Only used for DAHost
-        internal NetworkTransform.NetworkTransformState State;
-        private FastBufferReader m_CurrentReader;
-
-        internal int BytesWritten;
-
-        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
-            {
-                BytesWritten = NetworkTransform.SerializeMessage(writer, targetVersion);
-            }
-        }
-
-        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;
-            var networkObjectId = (ulong)0;
-            var networkBehaviourId = 0;
-
-            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, k_Name);
-                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);
-
-            if (isSpawnedLocally)
-            {
-                networkObject = networkManager.SpawnManager.SpawnedObjects[networkObjectId];
-                // Get the target NetworkTransform
-                NetworkTransform = networkObject.ChildNetworkBehaviours[networkBehaviourId] as NetworkTransform;
-                isServerAuthoritative = NetworkTransform.IsServerAuthoritative();
-                ownerAuthoritativeServerSide = !isServerAuthoritative && networkManager.IsServer;
-
-                reader.ReadNetworkSerializableInPlace(ref NetworkTransform.InboundState);
-                NetworkTransform.InboundState.LastSerializedSize = reader.Position - currentPosition;
-            }
-            else
-            {
-                // Deserialize the state
-                reader.ReadNetworkSerializableInPlace(ref State);
-            }
-
-            unsafe
-            {
-                if (ownerAuthoritativeServerSide)
-                {
-                    var targetCount = 1;
-
-                    if (networkManager.DistributedAuthorityMode && networkManager.DAHost)
-                    {
-                        ByteUnpacker.ReadValueBitPacked(reader, out targetCount);
-                    }
-
-                    var targetIds = stackalloc ulong[targetCount];
-
-                    if (networkManager.DistributedAuthorityMode && networkManager.DAHost)
-                    {
-                        var targetId = (ulong)0;
-                        for (int i = 0; i < targetCount; i++)
-                        {
-                            ByteUnpacker.ReadValueBitPacked(reader, out targetId);
-                            targetIds[i] = targetId;
-                        }
-
-                        if (!isSpawnedLocally)
-                        {
-                            // If we are the DAHost and the NetworkObject is hidden from the host we still need to forward this message
-                            ownerAuthoritativeServerSide = networkManager.DAHost && !isSpawnedLocally;
-                        }
-                    }
-
-                    var 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 ? targetCount : 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 && NetworkTransform == null)
-            {
-                return;
-            }
-
-            if (NetworkTransform == null)
-            {
-                Debug.LogError($"[{nameof(NetworkTransformMessage)}][Dropped] Reciever {nameof(NetworkTransform)} was not set!");
-                return;
-            }
-            NetworkTransform.TransformStateUpdate(context.SenderId);
-        }
-    }
-}

Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs

@@ -23,8 +23,6 @@ namespace Unity.Netcode
 
         private FastBufferReader m_ReceivedNetworkVariableData;
 
-        private const string k_Name = "NetworkVariableDeltaMessage";
-
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
             if (!writer.TryBeginWrite(FastBufferWriter.GetWriteSize(NetworkObjectId) + FastBufferWriter.GetWriteSize(NetworkBehaviourIndex)))
@@ -37,21 +35,13 @@ namespace Unity.Netcode
 
             BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
             BytePacker.WriteValueBitPacked(writer, NetworkBehaviourIndex);
-            if (networkManager.DistributedAuthorityMode)
-            {
-                writer.WriteValueSafe((ushort)NetworkBehaviour.NetworkVariableFields.Count);
-            }
 
             for (int i = 0; i < NetworkBehaviour.NetworkVariableFields.Count; i++)
             {
                 if (!DeliveryMappedNetworkVariableIndex.Contains(i))
                 {
                     // This var does not belong to the currently iterating delivery group.
-                    if (networkManager.DistributedAuthorityMode)
-                    {
-                        writer.WriteValueSafe<ushort>(0);
-                    }
-                    else if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                    if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                     {
                         BytePacker.WriteValueBitPacked(writer, (ushort)0);
                     }
@@ -65,6 +55,7 @@ namespace Unity.Netcode
 
                 var startingSize = writer.Length;
                 var networkVariable = NetworkBehaviour.NetworkVariableFields[i];
+
                 var shouldWrite = networkVariable.IsDirty() &&
                     networkVariable.CanClientRead(TargetClientId) &&
                     (networkManager.IsServer || networkVariable.CanClientWrite(networkManager.LocalClientId)) &&
@@ -88,14 +79,7 @@ namespace Unity.Netcode
                     shouldWrite = false;
                 }
 
-                if (networkManager.DistributedAuthorityMode)
-                {
-                    if (!shouldWrite)
-                    {
-                        writer.WriteValueSafe<ushort>(0);
-                    }
-                }
-                else if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                 {
                     if (!shouldWrite)
                     {
@@ -124,22 +108,7 @@ namespace Unity.Netcode
                     }
                     else
                     {
-                        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);
-                        }
+                        networkVariable.WriteDelta(writer);
                     }
                     networkManager.NetworkMetrics.TrackNetworkVariableDeltaSent(
                         TargetClientId,
@@ -178,29 +147,10 @@ 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.DistributedAuthorityMode)
-                        {
-                            m_ReceivedNetworkVariableData.ReadValueSafe(out ushort variableSize);
-                            varSize = variableSize;
-
-                            if (varSize == 0)
-                            {
-                                continue;
-                            }
-                        }
-                        else if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                        if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                         {
                             ByteUnpacker.ReadValueBitPacked(m_ReceivedNetworkVariableData, out varSize);
 
@@ -252,7 +202,6 @@ 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(
@@ -262,7 +211,7 @@ namespace Unity.Netcode
                             networkBehaviour.__getTypeName(),
                             context.MessageSize);
 
-                        if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety || networkManager.DistributedAuthorityMode)
+                        if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                         {
                             if (m_ReceivedNetworkVariableData.Position > (readStartPos + varSize))
                             {
@@ -288,10 +237,7 @@ namespace Unity.Netcode
             }
             else
             {
-                // 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, k_Name);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, m_ReceivedNetworkVariableData, ref context);
             }
         }
     }

Runtime/Messaging/Messages/ParentSyncMessage.cs

@@ -6,8 +6,6 @@ namespace Unity.Netcode
     {
         public int Version => 0;
 
-        private const string k_Name = "DestroyObjectMessage";
-
         public ulong NetworkObjectId;
 
         private byte m_BitField;
@@ -35,12 +33,6 @@ 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
@@ -91,10 +83,9 @@ namespace Unity.Netcode
             reader.ReadValueSafe(out Rotation);
             reader.ReadValueSafe(out Scale);
 
-            // 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)))
+            if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, k_Name);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
                 return false;
             }
             return true;
@@ -104,62 +95,22 @@ 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);
 
-            // This check is primarily for client-server network topologies when the motion model is owner authoritative:
-            // When SyncOwnerTransformWhenParented is enabled, then always apply the transform values.
-            // When SyncOwnerTransformWhenParented is disabled, then only synchronize the transform on non-owner instances.
-            if (networkObject.SyncOwnerTransformWhenParented || (!networkObject.SyncOwnerTransformWhenParented && !networkObject.IsOwner))
+            // We set all of the transform values after parenting as they are
+            // the values of the server-side post-parenting transform values
+            if (!WorldPositionStays)
             {
-                // We set all of the transform values after parenting as they are
-                // the values of the server-side post-parenting transform values
-                if (!WorldPositionStays)
-                {
-                    networkObject.transform.localPosition = Position;
-                    networkObject.transform.localRotation = Rotation;
-                }
-                else
-                {
-                    networkObject.transform.position = Position;
-                    networkObject.transform.rotation = Rotation;
-                }
-                networkObject.transform.localScale = Scale;
+                networkObject.transform.localPosition = Position;
+                networkObject.transform.localRotation = Rotation;
             }
-
-            // 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) || (networkObject.AllowOwnerToParent && context.SenderId == networkObject.OwnerClientId && networkManager.IsServer))
+            else
             {
-                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}!");
-                    }
-                }
+                networkObject.transform.position = Position;
+                networkObject.transform.rotation = Rotation;
             }
+            networkObject.transform.localScale = Scale;
         }
     }
 }

Runtime/Messaging/Messages/ProxyMessage.cs

@@ -1,3 +1,4 @@
+using System;
 using Unity.Collections;
 
 namespace Unity.Netcode
@@ -30,16 +31,11 @@ namespace Unity.Netcode
 
         public unsafe void Handle(ref NetworkContext context)
         {
+
             var networkManager = (NetworkManager)context.SystemOwner;
             if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(WrappedMessage.Metadata.NetworkObjectId, out var networkObject))
             {
-                // If the NetworkObject no longer exists then just log a warning when developer mode logging is enabled and exit.
-                // This can happen if NetworkObject is despawned and a client sends an RPC before receiving the despawn message.
-                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;
+                throw new InvalidOperationException($"An RPC called on a {nameof(NetworkObject)} that is not in the spawned objects list. Please make sure the {nameof(NetworkObject)} is spawned before calling RPCs.");
             }
 
             var observers = networkObject.Observers;

Runtime/Messaging/Messages/RpcMessages.cs

@@ -14,7 +14,7 @@ namespace Unity.Netcode
             writer.WriteBytesSafe(payload.GetUnsafePtr(), payload.Length);
         }
 
-        public static unsafe bool Deserialize(ref FastBufferReader reader, ref NetworkContext context, ref RpcMetadata metadata, ref FastBufferReader payload, string messageType)
+        public static unsafe bool Deserialize(ref FastBufferReader reader, ref NetworkContext context, ref RpcMetadata metadata, ref FastBufferReader payload)
         {
             ByteUnpacker.ReadValueBitPacked(reader, out metadata.NetworkObjectId);
             ByteUnpacker.ReadValueBitPacked(reader, out metadata.NetworkBehaviourId);
@@ -23,7 +23,7 @@ namespace Unity.Netcode
             var networkManager = (NetworkManager)context.SystemOwner;
             if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(metadata.NetworkObjectId))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, metadata.NetworkObjectId, reader, ref context, messageType);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, metadata.NetworkObjectId, reader, ref context);
                 return false;
             }
 
@@ -41,7 +41,7 @@ namespace Unity.Netcode
 
             payload = new FastBufferReader(reader.GetUnsafePtrAtCurrentPosition(), Allocator.None, reader.Length - reader.Position);
 
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
             if (NetworkBehaviour.__rpc_name_table[networkBehaviour.GetType()].TryGetValue(metadata.NetworkRpcMethodId, out var rpcMethodName))
             {
                 networkManager.NetworkMetrics.TrackRpcReceived(
@@ -52,6 +52,7 @@ namespace Unity.Netcode
                     reader.Length);
             }
 #endif
+
             return true;
         }
 
@@ -60,13 +61,7 @@ namespace Unity.Netcode
             var networkManager = (NetworkManager)context.SystemOwner;
             if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(metadata.NetworkObjectId, out var networkObject))
             {
-                // If the NetworkObject no longer exists then just log a warning when developer mode logging is enabled and exit.
-                // This can happen if NetworkObject is despawned and a client sends an RPC before receiving the despawn message.
-                if (networkManager.LogLevel == LogLevel.Developer)
-                {
-                    NetworkLog.LogWarning($"[{metadata.NetworkObjectId}, {metadata.NetworkBehaviourId}, {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;
+                throw new InvalidOperationException($"An RPC called on a {nameof(NetworkObject)} that is not in the spawned objects list. Please make sure the {nameof(NetworkObject)} is spawned before calling RPCs.");
             }
             var networkBehaviour = networkObject.GetNetworkBehaviourAtOrderIndex(metadata.NetworkBehaviourId);
 
@@ -105,8 +100,6 @@ namespace Unity.Netcode
         public FastBufferWriter WriteBuffer;
         public FastBufferReader ReadBuffer;
 
-        private const string k_Name = "ServerRpcMessage";
-
         public unsafe void Serialize(FastBufferWriter writer, int targetVersion)
         {
             RpcMessageHelpers.Serialize(ref writer, ref Metadata, ref WriteBuffer);
@@ -114,7 +107,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, k_Name);
+            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer);
         }
 
         public void Handle(ref NetworkContext context)
@@ -142,8 +135,6 @@ namespace Unity.Netcode
         public FastBufferWriter WriteBuffer;
         public FastBufferReader ReadBuffer;
 
-        private const string k_Name = "ClientRpcMessage";
-
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
             RpcMessageHelpers.Serialize(ref writer, ref Metadata, ref WriteBuffer);
@@ -151,7 +142,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, k_Name);
+            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer);
         }
 
         public void Handle(ref NetworkContext context)
@@ -179,8 +170,6 @@ namespace Unity.Netcode
         public FastBufferWriter WriteBuffer;
         public FastBufferReader ReadBuffer;
 
-        private const string k_Name = "RpcMessage";
-
         public unsafe void Serialize(FastBufferWriter writer, int targetVersion)
         {
             BytePacker.WriteValuePacked(writer, SenderClientId);
@@ -190,8 +179,7 @@ namespace Unity.Netcode
         public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
         {
             ByteUnpacker.ReadValuePacked(reader, out SenderClientId);
-
-            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, k_Name);
+            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer);
         }
 
         public void Handle(ref NetworkContext context)
@@ -209,138 +197,4 @@ namespace Unity.Netcode
             RpcMessageHelpers.Handle(ref context, ref Metadata, ref ReadBuffer, ref rpcParams);
         }
     }
-
-    // DANGO-EXP TODO: REMOVE THIS
-    internal struct ForwardServerRpcMessage : INetworkMessage
-    {
-        public int Version => 0;
-        public ulong OwnerId;
-        public NetworkDelivery NetworkDelivery;
-        public ServerRpcMessage ServerRpcMessage;
-
-        public unsafe void Serialize(FastBufferWriter writer, int targetVersion)
-        {
-            writer.WriteValueSafe(OwnerId);
-            writer.WriteValueSafe(NetworkDelivery);
-            ServerRpcMessage.Serialize(writer, targetVersion);
-        }
-
-        public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
-        {
-            reader.ReadValueSafe(out OwnerId);
-            reader.ReadValueSafe(out NetworkDelivery);
-            ServerRpcMessage.ReadBuffer = new FastBufferReader(reader, Allocator.Persistent, reader.Length - reader.Position, sizeof(RpcMetadata));
-
-            // If deserializing failed or this message was deferred.
-            if (!ServerRpcMessage.Deserialize(reader, ref context, receivedMessageVersion))
-            {
-                // release this reader as the handler will either be invoked later (deferred) or will not be invoked at all.
-                ServerRpcMessage.ReadBuffer.Dispose();
-                return false;
-            }
-            return true;
-        }
-
-        public void Handle(ref NetworkContext context)
-        {
-            var networkManager = (NetworkManager)context.SystemOwner;
-            if (networkManager.DAHost)
-            {
-                try
-                {
-                    // Since this is temporary, we will not be collection metrics for this.
-                    // DAHost just forwards the message to the owner
-                    ServerRpcMessage.WriteBuffer = new FastBufferWriter(ServerRpcMessage.ReadBuffer.Length, Allocator.TempJob);
-                    ServerRpcMessage.WriteBuffer.WriteBytesSafe(ServerRpcMessage.ReadBuffer.ToArray());
-                    networkManager.ConnectionManager.SendMessage(ref ServerRpcMessage, NetworkDelivery, OwnerId);
-                }
-                catch (Exception ex)
-                {
-                    Debug.LogException(ex);
-                }
-            }
-            else
-            {
-                NetworkLog.LogErrorServer($"Received {nameof(ForwardServerRpcMessage)} on client-{networkManager.LocalClientId}! Only DAHost may forward RPC messages!");
-            }
-            ServerRpcMessage.ReadBuffer.Dispose();
-            ServerRpcMessage.WriteBuffer.Dispose();
-        }
-
-    }
-
-    // DANGO-EXP TODO: REMOVE THIS
-    internal struct ForwardClientRpcMessage : INetworkMessage
-    {
-        public int Version => 0;
-        public bool BroadCast;
-        public ulong[] TargetClientIds;
-        public NetworkDelivery NetworkDelivery;
-        public ClientRpcMessage ClientRpcMessage;
-
-        public unsafe void Serialize(FastBufferWriter writer, int targetVersion)
-        {
-            if (TargetClientIds == null)
-            {
-                BroadCast = true;
-                writer.WriteValueSafe(BroadCast);
-            }
-            else
-            {
-                BroadCast = false;
-                writer.WriteValueSafe(BroadCast);
-                writer.WriteValueSafe(TargetClientIds);
-            }
-            writer.WriteValueSafe(NetworkDelivery);
-            ClientRpcMessage.Serialize(writer, targetVersion);
-        }
-
-        public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
-        {
-            reader.ReadValueSafe(out BroadCast);
-
-            if (!BroadCast)
-            {
-                reader.ReadValueSafe(out TargetClientIds);
-            }
-
-            reader.ReadValueSafe(out NetworkDelivery);
-
-            ClientRpcMessage.ReadBuffer = new FastBufferReader(reader, Allocator.Persistent, reader.Length - reader.Position, sizeof(RpcMetadata));
-            // If deserializing failed or this message was deferred.
-            if (!ClientRpcMessage.Deserialize(reader, ref context, receivedMessageVersion))
-            {
-                // release this reader as the handler will either be invoked later (deferred) or will not be invoked at all.
-                ClientRpcMessage.ReadBuffer.Dispose();
-                return false;
-            }
-            return true;
-        }
-
-        public void Handle(ref NetworkContext context)
-        {
-            var networkManager = (NetworkManager)context.SystemOwner;
-            if (networkManager.DAHost)
-            {
-                ClientRpcMessage.WriteBuffer = new FastBufferWriter(ClientRpcMessage.ReadBuffer.Length, Allocator.TempJob);
-                ClientRpcMessage.WriteBuffer.WriteBytesSafe(ClientRpcMessage.ReadBuffer.ToArray());
-                // Since this is temporary, we will not be collection metrics for this.
-                // DAHost just forwards the message to the clients
-                if (BroadCast)
-                {
-                    networkManager.ConnectionManager.SendMessage(ref ClientRpcMessage, NetworkDelivery, networkManager.ConnectedClientsIds);
-                }
-                else
-                {
-                    networkManager.ConnectionManager.SendMessage(ref ClientRpcMessage, NetworkDelivery, TargetClientIds);
-                }
-            }
-            else
-            {
-                NetworkLog.LogErrorServer($"Received {nameof(ForwardClientRpcMessage)} on client-{networkManager.LocalClientId}! Only DAHost may forward RPC messages!");
-            }
-            ClientRpcMessage.WriteBuffer.Dispose();
-            ClientRpcMessage.ReadBuffer.Dispose();
-        }
-    }
 }

Runtime/Messaging/Messages/SceneEventMessage.cs

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

Runtime/Messaging/Messages/ServerLogMessage.cs

@@ -4,8 +4,6 @@ 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
@@ -14,39 +12,30 @@ 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.LocalClient.IsSessionOwner) && networkManager.NetworkConfig.EnableNetworkLogs)
+            if (networkManager.IsServer && 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 = networkManager.DistributedAuthorityMode ? SenderId : context.SenderId;
+            var senderId = context.SenderId;
 
             networkManager.NetworkMetrics.TrackServerLogReceived(senderId, (uint)LogType, context.MessageSize);
 

Runtime/Messaging/Messages/SessionOwnerMessage.cs

@@ -1,26 +0,0 @@
-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

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

Runtime/Messaging/Messages/UnnamedMessage.cs

@@ -20,7 +20,7 @@ namespace Unity.Netcode
 
         public void Handle(ref NetworkContext context)
         {
-            ((NetworkManager)context.SystemOwner).CustomMessagingManager?.InvokeUnnamedMessage(context.SenderId, m_ReceivedData, context.SerializedHeaderSize);
+            ((NetworkManager)context.SystemOwner).CustomMessagingManager.InvokeUnnamedMessage(context.SenderId, m_ReceivedData, context.SerializedHeaderSize);
         }
     }
 }

Runtime/Messaging/NetworkMessageManager.cs

@@ -34,9 +34,6 @@ namespace Unity.Netcode
     internal class NetworkMessageManager : IDisposable
     {
         public bool StopProcessing = false;
-        private static Type s_ConnectionApprovedType = typeof(ConnectionApprovedMessage);
-        private static Type s_ConnectionRequestType = typeof(ConnectionRequestMessage);
-        private static Type s_DisconnectReasonType = typeof(DisconnectReasonMessage);
 
         private struct ReceiveQueueItem
         {
@@ -123,46 +120,53 @@ namespace Unity.Netcode
             public VersionGetter GetVersion;
         }
 
+        internal List<MessageWithHandler> PrioritizeMessageOrder(List<MessageWithHandler> allowedTypes)
+        {
+            var prioritizedTypes = new List<MessageWithHandler>();
+
+            // First pass puts the priority message in the first indices
+            // Those are the messages that must be delivered in order to allow re-ordering the others later
+            foreach (var t in allowedTypes)
+            {
+                if (t.MessageType.FullName == typeof(ConnectionRequestMessage).FullName ||
+                    t.MessageType.FullName == typeof(ConnectionApprovedMessage).FullName)
+                {
+                    prioritizedTypes.Add(t);
+                }
+            }
+
+            foreach (var t in allowedTypes)
+            {
+                if (t.MessageType.FullName != typeof(ConnectionRequestMessage).FullName &&
+                    t.MessageType.FullName != typeof(ConnectionApprovedMessage).FullName)
+                {
+                    prioritizedTypes.Add(t);
+                }
+            }
+
+            return prioritizedTypes;
+        }
+
         public NetworkMessageManager(INetworkMessageSender sender, object owner, INetworkMessageProvider provider = null)
         {
             try
             {
                 m_Sender = sender;
                 m_Owner = owner;
+
                 if (provider == null)
                 {
                     provider = new ILPPMessageProvider();
                 }
 
-                // Get the presorted message types returned by the provider
                 var allowedTypes = provider.GetMessages();
 
+                allowedTypes.Sort((a, b) => string.CompareOrdinal(a.MessageType.FullName, b.MessageType.FullName));
+                allowedTypes = PrioritizeMessageOrder(allowedTypes);
                 foreach (var type in allowedTypes)
                 {
                     RegisterMessageType(type);
                 }
-
-#if UNITY_EDITOR
-                if (EnableMessageOrderConsoleLog)
-                {
-                    // DANGO-TODO: Remove this when we have some form of message type indices stability in place
-                    // For now, just log the messages and their assigned types for reference purposes.
-                    var networkManager = m_Owner as NetworkManager;
-                    if (networkManager != null)
-                    {
-                        if (networkManager.DistributedAuthorityMode)
-                        {
-                            var messageListing = new StringBuilder();
-                            messageListing.AppendLine("NGO Message Index to Type Listing:");
-                            foreach (var message in m_MessageTypes)
-                            {
-                                messageListing.AppendLine($"[{message.Value}][{message.Key.Name}]");
-                            }
-                            Debug.Log(messageListing);
-                        }
-                    }
-                }
-#endif
             }
             catch (Exception)
             {
@@ -171,8 +175,6 @@ namespace Unity.Netcode
             }
         }
 
-        internal static bool EnableMessageOrderConsoleLog = false;
-
         public void Dispose()
         {
             if (m_Disposed)
@@ -527,7 +529,6 @@ namespace Unity.Netcode
             return new T().Version;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal int GetMessageVersion(Type type, ulong clientId, bool forReceive = false)
         {
             if (!m_PerClientMessageVersions.TryGetValue(clientId, out var versionMap))
@@ -555,20 +556,16 @@ namespace Unity.Netcode
             return messageVersion;
         }
 
-
-
         public static void ReceiveMessage<T>(FastBufferReader reader, ref NetworkContext context, NetworkMessageManager manager) where T : INetworkMessage, new()
         {
-            var messageType = typeof(T);
             var message = new T();
             var messageVersion = 0;
-
             // Special cases because these are the messages that carry the version info - thus the version info isn't
             // populated yet when we get these. The first part of these messages always has to be the version data
             // and can't change.
-            if (messageType != s_ConnectionRequestType && messageType != s_ConnectionApprovedType && messageType != s_DisconnectReasonType && context.SenderId != manager.m_LocalClientId)
+            if (typeof(T) != typeof(ConnectionRequestMessage) && typeof(T) != typeof(ConnectionApprovedMessage) && typeof(T) != typeof(DisconnectReasonMessage) && context.SenderId != manager.m_LocalClientId)
             {
-                messageVersion = manager.GetMessageVersion(messageType, context.SenderId, true);
+                messageVersion = manager.GetMessageVersion(typeof(T), context.SenderId, true);
                 if (messageVersion < 0)
                 {
                     return;
@@ -620,7 +617,7 @@ namespace Unity.Netcode
                 var messageVersion = 0;
                 // Special case because this is the message that carries the version info - thus the version info isn't populated yet when we get this.
                 // The first part of this message always has to be the version data and can't change.
-                if (typeof(TMessageType) != s_ConnectionRequestType)
+                if (typeof(TMessageType) != typeof(ConnectionRequestMessage))
                 {
                     messageVersion = GetMessageVersion(typeof(TMessageType), clientIds[i]);
                     if (messageVersion < 0)
@@ -674,7 +671,7 @@ namespace Unity.Netcode
 
                 // Special case because this is the message that carries the version info - thus the version info isn't populated yet when we get this.
                 // The first part of this message always has to be the version data and can't change.
-                if (typeof(TMessageType) != s_ConnectionRequestType)
+                if (typeof(TMessageType) != typeof(ConnectionRequestMessage))
                 {
                     var messageVersion = GetMessageVersion(typeof(TMessageType), clientIds[i]);
                     if (messageVersion < 0)
@@ -733,11 +730,7 @@ namespace Unity.Netcode
                 }
 
                 ref var writeQueueItem = ref sendQueueItem.ElementAt(sendQueueItem.Length - 1);
-                if (!writeQueueItem.Writer.TryBeginWrite(tmpSerializer.Length + headerSerializer.Length))
-                {
-                    Debug.LogError($"Not enough space to write message, size={tmpSerializer.Length + headerSerializer.Length} space used={writeQueueItem.Writer.Position} total size={writeQueueItem.Writer.Capacity}");
-                    continue;
-                }
+                writeQueueItem.Writer.TryBeginWrite(tmpSerializer.Length + headerSerializer.Length);
 
                 writeQueueItem.Writer.WriteBytes(headerSerializer.GetUnsafePtr(), headerSerializer.Length);
                 writeQueueItem.Writer.WriteBytes(tmpSerializer.GetUnsafePtr(), tmpSerializer.Length);
@@ -758,7 +751,7 @@ namespace Unity.Netcode
             // Special case because this is the message that carries the version info - thus the version info isn't
             // populated yet when we get this. The first part of this message always has to be the version data
             // and can't change.
-            if (typeof(TMessageType) != s_ConnectionRequestType)
+            if (typeof(TMessageType) != typeof(ConnectionRequestMessage))
             {
                 messageVersion = GetMessageVersion(typeof(TMessageType), clientId);
                 if (messageVersion < 0)
@@ -830,11 +823,7 @@ namespace Unity.Netcode
         internal unsafe int SendMessage<T>(ref T message, NetworkDelivery delivery, in NativeList<ulong> clientIds)
             where T : INetworkMessage
         {
-#if UTP_TRANSPORT_2_0_ABOVE
-            return SendMessage(ref message, delivery, new PointerListWrapper<ulong>(clientIds.GetUnsafePtr(), clientIds.Length));
-#else
             return SendMessage(ref message, delivery, new PointerListWrapper<ulong>((ulong*)clientIds.GetUnsafePtr(), clientIds.Length));
-#endif
         }
 
         internal unsafe void ProcessSendQueues()

Runtime/Messaging/RpcTargets/AuthorityRpcTarget.cs

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

Runtime/Messaging/RpcTargets/AuthorityRpcTarget.cs.meta

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

Runtime/Messaging/RpcTargets/BaseRpcTarget.cs

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

Runtime/Messaging/RpcTargets/EveryoneRpcTarget.cs

@@ -4,37 +4,23 @@ namespace Unity.Netcode
     {
         private NotServerRpcTarget m_NotServerRpcTarget;
         private ServerRpcTarget m_ServerRpcTarget;
-        private NotAuthorityRpcTarget m_NotAuthorityRpcTarget;
-        private AuthorityRpcTarget m_AuthorityRpcTarget;
 
         public override void Dispose()
         {
             m_NotServerRpcTarget.Dispose();
             m_ServerRpcTarget.Dispose();
-            m_NotAuthorityRpcTarget.Dispose();
-            m_AuthorityRpcTarget.Dispose();
         }
 
         internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
         {
-            if (NetworkManager.IsDistributedAuthority)
-            {
-                m_NotAuthorityRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
-                m_AuthorityRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
-            }
-            else
-            {
-                m_NotServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
-                m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
-            }
+            m_NotServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+            m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
         }
 
         internal EveryoneRpcTarget(NetworkManager manager) : base(manager)
         {
             m_NotServerRpcTarget = new NotServerRpcTarget(manager);
             m_ServerRpcTarget = new ServerRpcTarget(manager);
-            m_NotAuthorityRpcTarget = new NotAuthorityRpcTarget(manager);
-            m_AuthorityRpcTarget = new AuthorityRpcTarget(manager);
         }
     }
 }

Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs

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

Runtime/Messaging/RpcTargets/NotAuthorityRpcTarget.cs

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

Runtime/Messaging/RpcTargets/NotAuthorityRpcTarget.cs.meta

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

Runtime/Messaging/RpcTargets/NotMeRpcTarget.cs

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

Runtime/Messaging/RpcTargets/NotServerRpcTarget.cs

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

Runtime/Messaging/RpcTargets/ProxyRpcTargetGroup.cs

@@ -17,18 +17,13 @@ namespace Unity.Netcode
 
         internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
         {
-            // If there are no targets then don't attempt to send anything.
-            if (TargetClientIds.Length == 0 && Ids.Count == 0)
-            {
-                return;
-            }
             var proxyMessage = new ProxyMessage { Delivery = delivery, TargetClientIds = TargetClientIds.AsArray(), WrappedMessage = message };
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
             var size =
 #endif
                 behaviour.NetworkManager.MessageManager.SendMessage(ref proxyMessage, delivery, NetworkManager.ServerClientId);
 
-#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
             if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
             {
                 foreach (var clientId in TargetClientIds)

Runtime/Messaging/RpcTargets/RpcTarget.cs

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

Runtime/Messaging/RpcTargets/ServerRpcTarget.cs

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

Runtime/NetworkVariable/AnticipatedNetworkVariable.cs.meta

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

Runtime/NetworkVariable/CollectionSerializationUtility.cs

@@ -505,13 +505,8 @@ namespace Unity.Netcode
             writer.WriteValueSafe(changes);
             unsafe
             {
-#if UTP_TRANSPORT_2_0_ABOVE
-                var ptr = value.GetUnsafePtr();
-                var prevPtr = previousValue.GetUnsafePtr();
-#else
                 var ptr = (T*)value.GetUnsafePtr();
                 var prevPtr = (T*)previousValue.GetUnsafePtr();
-#endif
                 for (int i = 0; i < value.Length; ++i)
                 {
                     if (changes.IsSet(i))
@@ -554,11 +549,7 @@ namespace Unity.Netcode
 
                 unsafe
                 {
-#if UTP_TRANSPORT_2_0_ABOVE
-                    var ptr = value.GetUnsafePtr();
-#else
                     var ptr = (T*)value.GetUnsafePtr();
-#endif
                     for (var i = 0; i < value.Length; ++i)
                     {
                         if (changes.IsSet(i))
@@ -580,8 +571,8 @@ namespace Unity.Netcode
         public static unsafe void WriteNativeHashSetDelta<T>(FastBufferWriter writer, ref NativeHashSet<T> value, ref NativeHashSet<T> previousValue) where T : unmanaged, IEquatable<T>
         {
             // See WriteHashSet; this is the same algorithm, adjusted for the NativeHashSet API
-            var added = stackalloc T[value.Count];
-            var removed = stackalloc T[previousValue.Count];
+            var added = stackalloc T[value.Count()];
+            var removed = stackalloc T[previousValue.Count()];
             var addedCount = 0;
             var removedCount = 0;
             foreach (var item in value)
@@ -601,11 +592,8 @@ namespace Unity.Netcode
                     ++removedCount;
                 }
             }
-#if UTP_TRANSPORT_2_0_ABOVE
-            if (addedCount + removedCount >= value.Count)
-#else
+
             if (addedCount + removedCount >= value.Count())
-#endif
             {
                 writer.WriteByteSafe(1);
                 writer.WriteValueSafe(value);
@@ -655,21 +643,14 @@ namespace Unity.Netcode
             where TVal : unmanaged
         {
             // See WriteDictionary; this is the same algorithm, adjusted for the NativeHashMap API
-#if UTP_TRANSPORT_2_0_ABOVE
-            var added = stackalloc KVPair<TKey, TVal>[value.Count];
-            var changed = stackalloc KVPair<TKey, TVal>[value.Count];
-            var removed = stackalloc KVPair<TKey, TVal>[previousValue.Count];
-#else
             var added = stackalloc KeyValue<TKey, TVal>[value.Count()];
             var changed = stackalloc KeyValue<TKey, TVal>[value.Count()];
             var removed = stackalloc KeyValue<TKey, TVal>[previousValue.Count()];
-#endif
             var addedCount = 0;
             var changedCount = 0;
             var removedCount = 0;
             foreach (var item in value)
             {
-
                 var hasPrevVal = previousValue.TryGetValue(item.Key, out var prevVal);
                 if (!hasPrevVal)
                 {
@@ -692,11 +673,7 @@ namespace Unity.Netcode
                 }
             }
 
-#if UTP_TRANSPORT_2_0_ABOVE
-            if (addedCount + removedCount + changedCount >= value.Count)
-#else
             if (addedCount + removedCount + changedCount >= value.Count())
-#endif
             {
                 writer.WriteByteSafe(1);
                 writer.WriteValueSafe(value);