com.unity.netcode.gameobjects@1.11.0

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.11.0] - 2024-08-20

### 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. (#3005)

### Fixed

- Fixed issue by adding null checks in `NetworkVariableBase.CanClientRead` and `NetworkVariableBase.CanClientWrite` methods to ensure safe access to `NetworkBehaviour`. (#3011)
- Fixed issue using collections within `NetworkVariable` where the collection would not detect changes to items or nested items. (#3005)
- Fixed issue where `List`, `Dictionary`, and `HashSet` collections would not uniquely duplicate nested collections. (#3005)
- Fixed Issue where a state with dual triggers, inbound and outbound, could cause a false layer to layer state transition message to be sent to non-authority `NetworkAnimator` instances and cause a warning message to be logged. (#2999)
- Fixed issue where `FixedStringSerializer<T>` was using `NetworkVariableSerialization<byte>.AreEqual` to determine if two bytes were equal causes an exception to be thrown due to no byte serializer having been defined. (#2992)

### Changed

- Changed permissions exception thrown in `NetworkList` to exiting early with a logged error that is now a unified permissions message within `NetworkVariableBase`. (#3005)
- Changed permissions exception thrown in `NetworkVariable.Value` to exiting early with a logged error that is now a unified permissions message within `NetworkVariableBase`. (#3005)

CHANGELOG.md

@@ -6,6 +6,243 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 
 Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).
 
+## [1.11.0] - 2024-08-20
+
+### 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. (#3005)
+
+### Fixed
+
+- Fixed issue by adding null checks in `NetworkVariableBase.CanClientRead` and `NetworkVariableBase.CanClientWrite` methods to ensure safe access to `NetworkBehaviour`. (#3011)
+- Fixed issue using collections within `NetworkVariable` where the collection would not detect changes to items or nested items. (#3005)
+- Fixed issue where `List`, `Dictionary`, and `HashSet` collections would not uniquely duplicate nested collections. (#3005)
+- Fixed Issue where a state with dual triggers, inbound and outbound, could cause a false layer to layer state transition message to be sent to non-authority `NetworkAnimator` instances and cause a warning message to be logged. (#2999)
+- Fixed issue where `FixedStringSerializer<T>` was using `NetworkVariableSerialization<byte>.AreEqual` to determine if two bytes were equal causes an exception to be thrown due to no byte serializer having been defined. (#2992)
+
+### Changed
+
+- Changed permissions exception thrown in `NetworkList` to exiting early with a logged error that is now a unified permissions message within `NetworkVariableBase`. (#3005)
+- Changed permissions exception thrown in `NetworkVariable.Value` to exiting early with a logged error that is now a unified permissions message within `NetworkVariableBase`. (#3005)
+
+
+## [1.10.0] - 2024-07-22
+
+### Added
+
+- Added `NetworkBehaviour.OnNetworkPreSpawn` and `NetworkBehaviour.OnNetworkPostSpawn` methods that provide the ability to handle pre and post spawning actions during the `NetworkObject` spawn sequence. (#2906)
+- Added a client-side only `NetworkBehaviour.OnNetworkSessionSynchronized` convenience method that is invoked on all `NetworkBehaviour`s after a newly joined client has finished synchronizing with the network session in progress. (#2906)
+- Added `NetworkBehaviour.OnInSceneObjectsSpawned` convenience method that is invoked when all in-scene `NetworkObject`s have been spawned after a scene has been loaded or upon a host or server starting. (#2906)
+
+### Fixed
+
+- Fixed issue where the realtime network stats monitor was not able to display RPC traffic in release builds due to those stats being only available in development builds or the editor. (#2980)
+- Fixed issue where `NetworkManager.ScenesLoaded` was not being updated if `PostSynchronizationSceneUnloading` was set and any loaded scenes not used during synchronization were unloaded.(#2977)
+- Fixed issue where internal delta serialization could not have a byte serializer defined when serializing deltas for other types. Added `[GenerateSerializationForType(typeof(byte))]` to both the `NetworkVariable` and `AnticipatedNetworkVariable` classes to assure a byte serializer is defined. (#2953)
+- Fixed issue with the client count not being correct on the host or server side when a client disconnects itself from a session. (#2941)
+- Fixed issue with the host trying to send itself a message that it has connected when first starting up. (#2941)
+- Fixed issue where in-scene placed NetworkObjects could be destroyed if a client disconnects early and/or before approval. (#2923)
+- Fixed issue where `NetworkDeltaPosition` would "jitter" periodically if both unreliable delta state updates and half-floats were used together. (#2922)
+- Fixed issue where `NetworkRigidbody2D` would not properly change body type based on the instance's authority when spawned. (#2916)
+- Fixed issue where a `NetworkObject` component's associated `NetworkBehaviour` components would not be detected if scene loading is disabled in the editor and the currently loaded scene has in-scene placed `NetworkObject`s. (#2906)
+- Fixed issue where an in-scene placed `NetworkObject` with `NetworkTransform` that is also parented under a `GameObject` would not properly synchronize when the parent `GameObject` had a world space position other than 0,0,0. (#2895)
+
+### Changed
+
+
+## [1.9.1] - 2024-04-18
+
+### Added
+- Added AnticipatedNetworkVariable<T>, which adds support for client anticipation of NetworkVariable values, allowing for more responsive gameplay (#2820)
+- Added AnticipatedNetworkTransform, which adds support for client anticipation of NetworkTransforms (#2820)
+- Added NetworkVariableBase.ExceedsDirtinessThreshold to allow network variables to throttle updates by only sending updates when the difference between the current and previous values exceeds a threshold. (This is exposed in NetworkVariable<T> with the callback NetworkVariable<T>.CheckExceedsDirtinessThreshold) (#2820)
+- Added NetworkVariableUpdateTraits, which add additional throttling support: MinSecondsBetweenUpdates will prevent the NetworkVariable from sending updates more often than the specified time period (even if it exceeds the dirtiness threshold), while MaxSecondsBetweenUpdates will force a dirty NetworkVariable to send an update after the specified time period even if it has not yet exceeded the dirtiness threshold. (#2820)
+- Added virtual method NetworkVariableBase.OnInitialize() which can be used by NetworkVariable subclasses to add initialization code (#2820)
+- Added virtual method NetworkVariableBase.Update(), which is called once per frame to support behaviors such as interpolation between an anticipated value and an authoritative one. (#2820)
+- Added NetworkTime.TickWithPartial, which represents the current tick as a double that includes the fractional/partial tick value. (#2820)
+- `NetworkVariable` now includes built-in support for `NativeHashSet`, `NativeHashMap`, `List`, `HashSet`, and `Dictionary` (#2813)
+- `NetworkVariable` now includes delta compression for collection values (`NativeList`, `NativeArray`, `NativeHashSet`, `NativeHashMap`, `List`, `HashSet`, `Dictionary`, and `FixedString` types) to save bandwidth by only sending the values that changed. (Note: For `NativeList`, `NativeArray`, and `List`, this algorithm works differently than that used in `NetworkList`. This algorithm will use less bandwidth for "set" and "add" operations, but `NetworkList` is more bandwidth-efficient if you are performing frequent "insert" operations.) (#2813)
+- `UserNetworkVariableSerialization` now has optional callbacks for `WriteDelta` and `ReadDelta`. If both are provided, they will be used for all serialization operations on NetworkVariables of that type except for the first one for each client. If either is missing, the existing `Write` and `Read` will always be used. (#2813)
+- Network variables wrapping `INetworkSerializable` types can perform delta serialization by setting `UserNetworkVariableSerialization<T>.WriteDelta` and `UserNetworkVariableSerialization<T>.ReadDelta` for those types. The built-in `INetworkSerializable` serializer will continue to be used for all other serialization operations, but if those callbacks are set, it will call into them on all but the initial serialization to perform delta serialization. (This could be useful if you have a large struct where most values do not change regularly and you want to send only the fields that did change.) (#2813)
+
+### Fixed
+
+- Fixed issue where NetworkTransformEditor would throw and exception if you excluded the physics package. (#2871)
+- Fixed issue where `NetworkTransform` could not properly synchronize its base position when using half float precision. (#2845)
+- Fixed issue where the host was not invoking `OnClientDisconnectCallback` for its own local client when internally shutting down. (#2822)
+- Fixed issue where NetworkTransform could potentially attempt to "unregister" a named message prior to it being registered. (#2807)
+- Fixed issue where in-scene placed `NetworkObject`s with complex nested children `NetworkObject`s (more than one child in depth) would not synchronize properly if WorldPositionStays was set to true. (#2796)
+
+### Changed
+
+- Changed `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)
+
+## [1.8.1] - 2024-02-05
+
+### Fixed
+
+- Fixed a compile error when compiling for IL2CPP targets when using the new `[Rpc]` attribute. (#2824)
+
+## [1.8.0] - 2023-12-12
+
+### Added
+
+- Added a new RPC attribute, which is simply `Rpc`. (#2762)
+  - This is a generic attribute that can perform the functions of both Server and Client RPCs, as well as enabling client-to-client RPCs. Includes several default targets: `Server`, `NotServer`, `Owner`, `NotOwner`, `Me`, `NotMe`, `ClientsAndHost`, and `Everyone`. Runtime overrides are available for any of these targets, as well as for sending to a specific ID or groups of IDs.
+  - This attribute also includes the ability to defer RPCs that are sent to the local process to the start of the next frame instead of executing them immediately, treating them as if they had gone across the network. The default behavior is to execute immediately.
+  - This attribute effectively replaces `ServerRpc` and `ClientRpc`. `ServerRpc` and `ClientRpc` remain in their existing forms for backward compatibility, but `Rpc` will be the recommended and most supported option.
+- Added `NetworkManager.OnConnectionEvent` as a unified connection event callback to notify clients and servers of all client connections and disconnections within the session (#2762)
+- Added `NetworkManager.ServerIsHost` and `NetworkBehaviour.ServerIsHost` to allow a client to tell if it is connected to a host or to a dedicated server (#2762)
+- Added `SceneEventProgress.SceneManagementNotEnabled` return status to be returned when a `NetworkSceneManager` method is invoked and scene management is not enabled. (#2735)
+- Added `SceneEventProgress.ServerOnlyAction` return status to be returned when a `NetworkSceneManager` method is invoked by a client. (#2735)
+- Added `NetworkObject.InstantiateAndSpawn` and `NetworkSpawnManager.InstantiateAndSpawn` methods to simplify prefab spawning by assuring that the prefab is valid and applies any override prior to instantiating the `GameObject` and spawning the `NetworkObject` instance. (#2710)
+
+### Fixed
+
+- Fixed issue where a client disconnected by a server-host would not receive a local notification. (#2789)
+- Fixed issue where a server-host could shutdown during a relay connection but periodically the transport disconnect message sent to any connected clients could be dropped. (#2789)
+- Fixed issue where a host could disconnect its local client but remain running as a server. (#2789)
+- Fixed issue where `OnClientDisconnectedCallback` was not being invoked under certain conditions. (#2789)
+- Fixed issue where `OnClientDisconnectedCallback` was always returning 0 as the client identifier. (#2789)
+- Fixed issue where if a host or server shutdown while a client owned NetworkObjects (other than the player) it would throw an exception. (#2789)
+- Fixed issue where setting values on a `NetworkVariable` or `NetworkList` within `OnNetworkDespawn` during a shutdown sequence would throw an exception. (#2789)
+- Fixed issue where a teleport state could potentially be overridden by a previous unreliable delta state. (#2777)
+- Fixed issue where `NetworkTransform` was using the `NetworkManager.ServerTime.Tick` as opposed to `NetworkManager.NetworkTickSystem.ServerTime.Tick` during the authoritative side's tick update where it performed a delta state check. (#2777)
+- Fixed issue where a parented in-scene placed NetworkObject would be destroyed upon a client or server exiting a network session but not unloading the original scene in which the NetworkObject was placed. (#2737)
+- Fixed issue where during client synchronization and scene loading, when client synchronization or the scene loading mode are set to `LoadSceneMode.Single`, a `CreateObjectMessage` could be received, processed, and the resultant spawned `NetworkObject` could be instantiated in the client's currently active scene that could, towards the end of the client synchronization or loading process, be unloaded and cause the newly created `NetworkObject` to be destroyed (and throw and exception). (#2735)
+- Fixed issue where a `NetworkTransform` instance with interpolation enabled would result in wide visual motion gaps (stuttering) under above normal latency conditions and a 1-5% or higher packet are drop rate. (#2713)
+- Fixed issue where  you could not have multiple source network prefab overrides targeting the same network prefab as their override. (#2710)
+
+### Changed
+- Changed the server or host shutdown so it will now perform a "soft shutdown" when `NetworkManager.Shutdown` is invoked. This will send a disconnect notification to all connected clients and the server-host will wait for all connected clients to disconnect or timeout after a 5 second period before completing the shutdown process. (#2789)
+- Changed `OnClientDisconnectedCallback` will now return the assigned client identifier on the local client side if the client was approved and assigned one prior to being disconnected. (#2789)
+- Changed `NetworkTransform.SetState` (and related methods) now are cumulative during a fractional tick period and sent on the next pending tick. (#2777)
+- `NetworkManager.ConnectedClientsIds` is now accessible on the client side and will contain the list of all clients in the session, including the host client if the server is operating in host mode (#2762)
+- Changed `NetworkSceneManager` to return a `SceneEventProgress` status and not throw exceptions for methods invoked when scene management is disabled and when a client attempts to access a `NetworkSceneManager` method by a client. (#2735)
+- Changed `NetworkTransform` authoritative instance tick registration so a single `NetworkTransform` specific tick event update will update all authoritative instances to improve perofmance. (#2713)
+- Changed `NetworkPrefabs.OverrideToNetworkPrefab` dictionary is no longer used/populated due to it ending up being related to a regression bug and not allowing more than one override to be assigned to a network prefab asset. (#2710)
+- Changed in-scene placed `NetworkObject`s now store their source network prefab asset's `GlobalObjectIdHash` internally that is used, when scene management is disabled, by clients to spawn the correct prefab even if the `NetworkPrefab` entry has an override. This does not impact dynamically spawning the same prefab which will yield the override on both host and client. (#2710)
+- Changed in-scene placed `NetworkObject`s no longer require a `NetworkPrefab` entry with `GlobalObjectIdHash` override in order for clients to properly synchronize. (#2710)
+- Changed in-scene placed `NetworkObject`s now set their `IsSceneObject` value when generating their `GlobalObjectIdHash` value. (#2710)
+- Changed the default `NetworkConfig.SpawnTimeout` value from 1.0s to 10.0s. (#2710)
+
+## [1.7.1] - 2023-11-15
+
+### Added
+
+### Fixed
+
+- Fixed a bug where having a class with Rpcs that inherits from a class without Rpcs that inherits from NetworkVariable would cause a compile error. (#2751)
+- Fixed issue where `NetworkBehaviour.Synchronize` was not truncating the write buffer if nothing was serialized during `NetworkBehaviour.OnSynchronize` causing an additional 6 bytes to be written per `NetworkBehaviour` component instance. (#2749)
+
+## [1.7.0] - 2023-10-11
+
+### Added
+
+- exposed NetworkObject.GetNetworkBehaviourAtOrderIndex as a public API (#2724)
+- Added context menu tool that provides users with the ability to quickly update the GlobalObjectIdHash value for all in-scene placed prefab instances that were created prior to adding a NetworkObject component to it. (#2707)
+- Added methods NetworkManager.SetPeerMTU and NetworkManager.GetPeerMTU to be able to set MTU sizes per-peer (#2676)
+- Added `GenerateSerializationForGenericParameterAttribute`, which can be applied to user-created Network Variable types to ensure the codegen generates serialization for the generic types they wrap. (#2694)
+- Added `GenerateSerializationForTypeAttribute`, which can be applied to any class or method to ensure the codegen generates serialization for the specific provided type. (#2694)
+- Exposed `NetworkVariableSerialization<T>.Read`, `NetworkVariableSerialization<T>.Write`, `NetworkVariableSerialization<T>.AreEqual`, and `NetworkVariableSerialization<T>.Duplicate` to further support the creation of user-created network variables by allowing users to access the generated serialization methods and serialize generic types efficiently without boxing. (#2694)
+- Added `NetworkVariableBase.MarkNetworkBehaviourDirty` so that user-created network variable types can mark their containing `NetworkBehaviour` to be processed by the update loop. (#2694)
+
+### Fixed
+
+- Fixed issue where the server side `NetworkSceneManager` instance was not adding the currently active scene to its list of scenes loaded. (#2723)
+- Generic NetworkBehaviour types no longer result in compile errors or runtime errors (#2720)
+- Rpcs within Generic NetworkBehaviour types can now serialize parameters of the class's generic types (but may not have generic types of their own) (#2720)
+- Errors are no longer thrown when entering play mode with domain reload disabled (#2720)
+- NetworkSpawn is now correctly called each time when entering play mode with scene reload disabled (#2720)
+- NetworkVariables of non-integer types will no longer break the inspector (#2714)
+- NetworkVariables with NonSerializedAttribute will not appear in the inspector (#2714)
+- Fixed issue where `UnityTransport` would attempt to establish WebSocket connections even if using UDP/DTLS Relay allocations when the build target was WebGL. This only applied to working in the editor since UDP/DTLS can't work in the browser. (#2695)
+- Fixed issue where a `NetworkBehaviour` component's `OnNetworkDespawn` was not being invoked on the host-server side for an in-scene placed `NetworkObject` when a scene was unloaded (during a scene transition) and the `NetworkBehaviour` component was positioned/ordered before the `NetworkObject` component. (#2685)
+- Fixed issue where `SpawnWithObservers` was not being honored when `NetworkConfig.EnableSceneManagement` was disabled. (#2682)
+- Fixed issue where `NetworkAnimator` was not internally tracking changes to layer weights which prevented proper layer weight synchronization back to the original layer weight value. (#2674)
+- Fixed "writing past the end of the buffer" error when calling ResetDirty() on managed network variables that are larger than 256 bytes when serialized. (#2670)
+- Fixed issue where generation of the `DefaultNetworkPrefabs` asset was not enabled by default. (#2662)
+- Fixed issue where the `GlobalObjectIdHash` value could be updated but the asset not marked as dirty. (#2662)
+- Fixed issue where the `GlobalObjectIdHash` value of a (network) prefab asset could be assigned an incorrect value when editing the prefab in a temporary scene. (#2662)
+- Fixed issue where the `GlobalObjectIdHash` value generated after creating a (network) prefab from an object constructed within the scene would not be the correct final value in a stand alone build. (#2662)
+
+### Changed
+
+- Updated dependency on `com.unity.transport` to version 1.4.0. (#2716)
+
+## [1.6.0] - 2023-08-09
+
+### Added
+
+- Added a protected virtual method `NetworkTransform.OnInitialize(ref NetworkTransformState replicatedState)` that just returns the replicated state reference.
+  
+### Fixed
+
+- Fixed issue where invoking `NetworkManager.Shutdown` within `NetworkManager.OnClientStopped` or `NetworkManager.OnServerStopped` would force `NetworkManager.ShutdownInProgress` to remain true after completing the shutdown process. (#2661)
+- Fixed issue where ARMv7 Android builds would crash when trying to validate the batch header. (#2654)
+- Fixed issue with client synchronization of position when using half precision and the delta position reaches the maximum value and is collapsed on the host prior to being forwarded to the non-owner clients. (#2636)
+- Fixed issue with scale not synchronizing properly depending upon the spawn order of NetworkObjects. (#2636)
+- Fixed issue position was not properly transitioning between ownership changes with an owner authoritative NetworkTransform. (#2636)
+- Fixed issue where a late joining non-owner client could update an owner authoritative NetworkTransform if ownership changed without any updates to position prior to the non-owner client joining. (#2636)
+
+### Changed
+
+## [1.5.2] - 2023-07-24
+
+### Added
+
+### Fixed
+- Bumped minimum Unity version supported to 2021.3 LTS
+- Fixed issue where `NetworkClient.OwnedObjects` was not returning any owned objects due to the `NetworkClient.IsConnected` not being properly set. (#2631)
+- Fixed a crash when calling TrySetParent with a null Transform (#2625)
+- Fixed issue where a `NetworkTransform` using full precision state updates was losing transform state updates when interpolation was enabled. (#2624)
+- Fixed issue where `NetworkObject.SpawnWithObservers` was not being honored for late joining clients. (#2623)
+- Fixed issue where invoking `NetworkManager.Shutdown` multiple times, depending upon the timing, could cause an exception. (#2622)
+- Fixed issue where removing ownership would not notify the server that it gained ownership. This also resolves the issue where an owner authoritative NetworkTransform would not properly initialize upon removing ownership from a remote client. (#2618)
+- Fixed ILPP issues when using CoreCLR and for certain dedicated server builds. (#2614)
+- Fixed an ILPP compile error when creating a generic NetworkBehaviour singleton with a static T instance. (#2603)
+
+### Changed
+
+## [1.5.1] - 2023-06-07
+
+### Added
+
+- Added support for serializing `NativeArray<>` and `NativeList<>` in `FastBufferReader`/`FastBufferWriter`, `BufferSerializer`, `NetworkVariable`, and RPCs. (To use `NativeList<>`, add `UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT` to your Scripting Define Symbols in `Project Settings > Player`) (#2375)
+- The location of the automatically-created default network prefab list can now be configured (#2544)
+- Added: Message size limits (max single message and max fragmented message) can now be set using NetworkManager.MaximumTransmissionUnitSize and NetworkManager.MaximumFragmentedMessageSize for transports that don't work with the default values (#2530)
+- Added `NetworkObject.SpawnWithObservers` property (default is true) that when set to false will spawn a `NetworkObject` with no observers and will not be spawned on any client until `NetworkObject.NetworkShow` is invoked. (#2568)
+
+### Fixed
+
+- Fixed: Fixed a null reference in codegen in some projects (#2581)
+- Fixed issue where the `OnClientDisconnected` client identifier was incorrect after a pending client connection was denied. (#2569)
+- Fixed warning "Runtime Network Prefabs was not empty at initialization time." being erroneously logged when no runtime network prefabs had been added (#2565)
+- Fixed issue where some temporary debug console logging was left in a merged PR. (#2562)
+- Fixed the "Generate Default Network Prefabs List" setting not loading correctly and always reverting to being checked. (#2545)
+- Fixed issue where users could not use NetworkSceneManager.VerifySceneBeforeLoading to exclude runtime generated scenes from client synchronization. (#2550)
+- Fixed missing value on `NetworkListEvent` for `EventType.RemoveAt` events.  (#2542,#2543)
+- Fixed issue where parenting a NetworkTransform under a transform with a scale other than Vector3.one would result in incorrect values on non-authoritative instances. (#2538)
+- Fixed issue where a server would include scene migrated and then despawned NetworkObjects to a client that was being synchronized. (#2532)
+- Fixed the inspector throwing exceptions when attempting to render `NetworkVariable`s of enum types. (#2529)
+- Making a `NetworkVariable` with an `INetworkSerializable` type that doesn't meet the `new()` constraint will now create a compile-time error instead of an editor crash (#2528)
+- Fixed Multiplayer Tools package installation docs page link on the NetworkManager popup. (#2526)
+- Fixed an exception and error logging when two different objects are shown and hidden on the same frame (#2524)
+- Fixed a memory leak in `UnityTransport` that occurred if `StartClient` failed. (#2518)
+- Fixed issue where a client could throw an exception if abruptly disconnected from a network session with one or more spawned `NetworkObject`(s). (#2510)
+- Fixed issue where invalid endpoint addresses were not being detected and returning false from NGO UnityTransport. (#2496)
+- Fixed some errors that could occur if a connection is lost and the loss is detected when attempting to write to the socket. (#2495)
+
+## Changed
+
+- Adding network prefabs before NetworkManager initialization is now supported. (#2565)
+- Connecting clients being synchronized now switch to the server's active scene before spawning and synchronizing NetworkObjects. (#2532)
+- Updated `UnityTransport` dependency on `com.unity.transport` to 1.3.4. (#2533)
+- Improved performance of NetworkBehaviour initialization by replacing reflection when initializing NetworkVariables with compile-time code generation, which should help reduce hitching during additive scene loads. (#2522)
+
 ## [1.4.0] - 2023-04-10
 
 ### Added

Components/AnticipatedNetworkTransform.cs

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

Components/AnticipatedNetworkTransform.cs.meta

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

Components/HalfVector3.cs

@@ -27,7 +27,7 @@ namespace Unity.Netcode.Components
         /// <summary>
         /// The half float precision value of the z-axis as a <see cref="half"/>.
         /// </summary>
-        public half Z => Axis.x;
+        public half Z => Axis.z;
 
         /// <summary>
         /// Used to store the half float precision values as a <see cref="half3"/>
@@ -39,6 +39,17 @@ namespace Unity.Netcode.Components
         /// </summary>
         public bool3 AxisToSynchronize;
 
+        /// <summary>
+        /// Directly sets each axial value to the passed in full precision values
+        /// that are converted to half precision
+        /// </summary>
+        internal void Set(float x, float y, float z)
+        {
+            Axis.x = math.half(x);
+            Axis.y = math.half(y);
+            Axis.z = math.half(z);
+        }
+
         private void SerializeWrite(FastBufferWriter writer)
         {
             for (int i = 0; i < Length; i++)

Components/Messages.meta

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

Components/Messages/NetworkTransformMessage.cs

@@ -0,0 +1,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/Messages/NetworkTransformMessage.cs.meta

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

Components/NetworkAnimator.cs

@@ -164,7 +164,6 @@ namespace Unity.Netcode.Components
     /// NetworkAnimator enables remote synchronization of <see cref="UnityEngine.Animator"/> state for on network objects.
     /// </summary>
     [AddComponentMenu("Netcode/Network Animator")]
-    [RequireComponent(typeof(Animator))]
     public class NetworkAnimator : NetworkBehaviour, ISerializationCallbackReceiver
     {
         [Serializable]
@@ -833,8 +832,12 @@ 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})");
                 }
-                else
-                if (!tt.anyState && tt.fullPathHash != m_TransitionHash[layer])
+                // 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))))
                 {
                     // first time in this transition for this layer
                     m_TransitionHash[layer] = tt.fullPathHash;
@@ -843,6 +846,10 @@ 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})");
                 }
@@ -1053,8 +1060,7 @@ namespace Unity.Netcode.Components
                         BytePacker.WriteValuePacked(writer, valueBool);
                     }
                 }
-                else
-                if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterFloat)
+                else if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterFloat)
                 {
                     var valueFloat = m_Animator.GetFloat(hash);
                     fixed (void* value = cacheValue.Value)
@@ -1137,6 +1143,7 @@ namespace Unity.Netcode.Components
                 if (m_LayerWeights[animationState.Layer] != animationState.Weight)
                 {
                     m_Animator.SetLayerWeight(animationState.Layer, animationState.Weight);
+                    m_LayerWeights[animationState.Layer] = animationState.Weight;
                 }
             }
 

Components/NetworkDeltaPosition.cs

@@ -23,12 +23,24 @@ namespace Unity.Netcode.Components
         internal Vector3 DeltaPosition;
         internal int NetworkTick;
 
+        internal bool SynchronizeBase;
+
+        internal bool CollapsedDeltaIntoBase;
+
         /// <summary>
         /// The serialization implementation of <see cref="INetworkSerializable"/>
         /// </summary>
         public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
         {
-            HalfVector3.NetworkSerialize(serializer);
+            if (!SynchronizeBase)
+            {
+                HalfVector3.NetworkSerialize(serializer);
+            }
+            else
+            {
+                serializer.SerializeValue(ref DeltaPosition);
+                serializer.SerializeValue(ref CurrentBasePosition);
+            }
         }
 
         /// <summary>
@@ -122,6 +134,7 @@ namespace Unity.Netcode.Components
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void UpdateFrom(ref Vector3 vector3, int networkTick)
         {
+            CollapsedDeltaIntoBase = false;
             NetworkTick = networkTick;
             DeltaPosition = (vector3 + PrecisionLossDelta) - CurrentBasePosition;
             for (int i = 0; i < HalfVector3.Length; i++)
@@ -136,6 +149,7 @@ namespace Unity.Netcode.Components
                         CurrentBasePosition[i] += HalfDeltaConvertedBack[i];
                         HalfDeltaConvertedBack[i] = 0.0f;
                         DeltaPosition[i] = 0.0f;
+                        CollapsedDeltaIntoBase = true;
                     }
                 }
             }
@@ -164,6 +178,8 @@ namespace Unity.Netcode.Components
             DeltaPosition = Vector3.zero;
             HalfDeltaConvertedBack = Vector3.zero;
             HalfVector3 = new HalfVector3(vector3, axisToSynchronize);
+            SynchronizeBase = false;
+            CollapsedDeltaIntoBase = false;
             UpdateFrom(ref vector3, networkTick);
         }
 

Components/NetworkRigidbody.cs

@@ -29,15 +29,25 @@ namespace Unity.Netcode.Components
             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;
 
-            // Set interpolation to none if NetworkTransform is handling interpolation, otherwise it sets it to the original value
-            m_Rigidbody.interpolation = m_NetworkTransform.Interpolate ? RigidbodyInterpolation.None : m_OriginalInterpolation;
-
-            // Turn off physics for the rigid body until spawned, otherwise
-            // clients can run fixed update before the first full
-            // NetworkTransform update
+            m_Rigidbody.interpolation = m_IsAuthority ? m_OriginalInterpolation : (m_NetworkTransform.Interpolate ? RigidbodyInterpolation.None : m_OriginalInterpolation);
             m_Rigidbody.isKinematic = true;
         }
 

Components/NetworkRigidbody2D.cs

@@ -12,71 +12,101 @@ namespace Unity.Netcode.Components
     [AddComponentMenu("Netcode/Network Rigidbody 2D")]
     public class NetworkRigidbody2D : NetworkBehaviour
     {
+        /// <summary>
+        /// Determines if we are server (true) or owner (false) authoritative
+        /// </summary>
+        private bool m_IsServerAuthoritative;
+
         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>();
+            m_IsServerAuthoritative = m_NetworkTransform.IsServerAuthoritative();
+
+            SetupRigidBody();
         }
 
-        private void FixedUpdate()
+        /// <summary>
+        /// If the current <see cref="NetworkTransform"/> has authority,
+        /// then use the <see cref="Rigidbody2D"/> interpolation strategy,
+        /// if the <see cref="NetworkTransform"/> is handling interpolation,
+        /// set interpolation to none on the <see cref="Rigidbody2D"/>
+        /// <br/>
+        /// Turn off physics for the rigid body until spawned, otherwise
+        /// clients can run fixed update before the first
+        /// full <see cref="NetworkTransform"/> update
+        /// </summary>
+        private void SetupRigidBody()
         {
-            if (IsSpawned)
-            {
-                if (HasAuthority != m_IsAuthority)
-                {
-                    m_IsAuthority = HasAuthority;
-                    UpdateRigidbodyKinematicMode();
-                }
-            }
+            m_Rigidbody = GetComponent<Rigidbody2D>();
+            m_OriginalInterpolation = m_Rigidbody.interpolation;
+
+            m_Rigidbody.interpolation = m_IsAuthority ? m_OriginalInterpolation : (m_NetworkTransform.Interpolate ? RigidbodyInterpolation2D.None : m_OriginalInterpolation);
+            // Turn off physics for the rigid body until spawned, otherwise
+            // clients can run fixed update before the first full
+            // NetworkTransform update
+            m_Rigidbody.isKinematic = true;
         }
 
-        // Puts the rigidbody in a kinematic non-interpolated mode on everyone but the server.
-        private void UpdateRigidbodyKinematicMode()
+        /// <summary>
+        /// For owner authoritative (i.e. ClientNetworkTransform)
+        /// we adjust our authority when we gain ownership
+        /// </summary>
+        public override void OnGainedOwnership()
         {
-            if (m_IsAuthority == false)
-            {
-                m_OriginalKinematic = m_Rigidbody.isKinematic;
-                m_Rigidbody.isKinematic = true;
+            UpdateOwnershipAuthority();
+        }
 
-                m_OriginalInterpolation = m_Rigidbody.interpolation;
-                // Set interpolation to none, the NetworkTransform component interpolates the position of the object.
-                m_Rigidbody.interpolation = RigidbodyInterpolation2D.None;
+        /// <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
             {
-                // 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;
+                m_IsAuthority = IsOwner;
             }
+
+            // If you have authority then you are not kinematic
+            m_Rigidbody.isKinematic = !m_IsAuthority;
+
+            // Set interpolation of the Rigidbody2D based on authority
+            // With authority: let local transform handle interpolation
+            // Without authority: let the NetworkTransform handle interpolation
+            m_Rigidbody.interpolation = m_IsAuthority ? m_OriginalInterpolation : RigidbodyInterpolation2D.None;
         }
 
         /// <inheritdoc />
         public override void OnNetworkSpawn()
         {
-            m_IsAuthority = HasAuthority;
-            m_OriginalKinematic = m_Rigidbody.isKinematic;
-            m_OriginalInterpolation = m_Rigidbody.interpolation;
-            UpdateRigidbodyKinematicMode();
+            UpdateOwnershipAuthority();
         }
 
         /// <inheritdoc />
         public override void OnNetworkDespawn()
         {
-            UpdateRigidbodyKinematicMode();
+            UpdateOwnershipAuthority();
         }
     }
 }

Documentation~/index.md

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

Editor/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/CodeGenHelpers.cs

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

Editor/CodeGen/INetworkMessageILPP.cs

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

Editor/CodeGen/RuntimeAccessModifiersILPP.cs

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

Editor/Configuration/NetcodeForGameObjectsProjectSettings.cs

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

Editor/Configuration/NetcodeForGameObjectsProjectSettings.cs.meta

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

Editor/Configuration/NetcodeForGameObjectsSettings.cs

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

Editor/Configuration/NetcodeSettingsProvider.cs

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

Editor/Configuration/NetworkPrefabProcessor.cs

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

Editor/NetworkBehaviourEditor.cs

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

Editor/NetworkManagerEditor.cs

@@ -1,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;
@@ -48,6 +51,27 @@ namespace Unity.Netcode.Editor
         private readonly List<Type> m_TransportTypes = new List<Type>();
         private string[] m_TransportNames = { "Select transport..." };
 
+        /// <inheritdoc/>
+        public override void OnInspectorGUI()
+        {
+            Initialize();
+            CheckNullProperties();
+
+#if !MULTIPLAYER_TOOLS
+            DrawInstallMultiplayerToolsTip();
+#endif
+
+            if (m_NetworkManager.IsServer || m_NetworkManager.IsClient)
+            {
+                DrawDisconnectButton();
+            }
+            else
+            {
+                DrawAllPropertyFields();
+                ShowStartConnectionButtons();
+            }
+        }
+
         private void ReloadTransports()
         {
             m_TransportTypes.Clear();
@@ -138,209 +162,311 @@ namespace Unity.Netcode.Editor
                 .FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists));
         }
 
-        /// <inheritdoc/>
-        public override void OnInspectorGUI()
+        private void DrawAllPropertyFields()
         {
-            Initialize();
-            CheckNullProperties();
+            serializedObject.Update();
+            EditorGUILayout.PropertyField(m_RunInBackgroundProperty);
+            EditorGUILayout.PropertyField(m_LogLevelProperty);
+            EditorGUILayout.Space();
 
-#if !MULTIPLAYER_TOOLS
-            DrawInstallMultiplayerToolsTip();
-#endif
+            EditorGUILayout.PropertyField(m_PlayerPrefabProperty);
+            EditorGUILayout.Space();
 
-            if (!m_NetworkManager.IsServer && !m_NetworkManager.IsClient)
+            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.Space();
-
-                EditorGUILayout.PropertyField(m_PlayerPrefabProperty);
-                EditorGUILayout.Space();
-
-                if (m_NetworkManager.NetworkConfig.HasOldPrefabList())
-                {
-                    EditorGUILayout.HelpBox("Network Prefabs serialized in old format. Migrate to new format to edit the list.", MessageType.Info);
-                    if (GUILayout.Button(new GUIContent("Migrate Prefab List", "Converts the old format Network Prefab list to a new Scriptable Object")))
-                    {
-                        // Default directory
-                        var directory = "Assets/";
-                        var assetPath = AssetDatabase.GetAssetPath(m_NetworkManager);
-                        if (assetPath == "")
-                        {
-                            assetPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(m_NetworkManager);
-                        }
-
-                        if (assetPath != "")
-                        {
-                            directory = Path.GetDirectoryName(assetPath);
-                        }
-                        else
-                        {
-#if UNITY_2021_1_OR_NEWER
-                            var prefabStage = UnityEditor.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
-#else
-                            var prefabStage = UnityEditor.Experimental.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
-#endif
-                            if (prefabStage != null)
-                            {
-                                var prefabPath = prefabStage.assetPath;
-                                if (!string.IsNullOrEmpty(prefabPath))
-                                {
-                                    directory = Path.GetDirectoryName(prefabPath);
-                                }
-                            }
-                            if (m_NetworkManager.gameObject.scene != null)
-                            {
-                                var scenePath = m_NetworkManager.gameObject.scene.path;
-                                if (!string.IsNullOrEmpty(scenePath))
-                                {
-                                    directory = Path.GetDirectoryName(scenePath);
-                                }
-                            }
-                        }
-                        var networkPrefabs = m_NetworkManager.NetworkConfig.MigrateOldNetworkPrefabsToNetworkPrefabsList();
-                        string path = Path.Combine(directory, $"NetworkPrefabs-{m_NetworkManager.GetInstanceID()}.asset");
-                        Debug.Log("Saving migrated Network Prefabs List to " + path);
-                        AssetDatabase.CreateAsset(networkPrefabs, path);
-                        EditorUtility.SetDirty(m_NetworkManager);
-                    }
-                }
-                else
-                {
-                    if (m_NetworkManager.NetworkConfig.Prefabs.NetworkPrefabsLists.Count == 0)
-                    {
-                        EditorGUILayout.HelpBox("You have no prefab list selected. You will have to add your prefabs manually at runtime for netcode to work.", MessageType.Warning);
-                    }
-                    EditorGUILayout.PropertyField(m_PrefabsList);
-                }
-                EditorGUILayout.Space();
-
-                EditorGUILayout.LabelField("General", EditorStyles.boldLabel);
-                EditorGUILayout.PropertyField(m_ProtocolVersionProperty);
-
-                EditorGUILayout.PropertyField(m_NetworkTransportProperty);
-
-                if (m_NetworkTransportProperty.objectReferenceValue == null)
-                {
-                    EditorGUILayout.HelpBox("You have no transport selected. A transport is required for netcode to work. Which one do you want?", MessageType.Warning);
-
-                    int selection = EditorGUILayout.Popup(0, m_TransportNames);
-
-                    if (selection > 0)
-                    {
-                        ReloadTransports();
-
-                        var transportComponent = m_NetworkManager.gameObject.GetComponent(m_TransportTypes[selection - 1]) ?? m_NetworkManager.gameObject.AddComponent(m_TransportTypes[selection - 1]);
-                        m_NetworkTransportProperty.objectReferenceValue = transportComponent;
-
-                        Repaint();
-                    }
-                }
-
-                EditorGUILayout.PropertyField(m_TickRateProperty);
-
-                EditorGUILayout.LabelField("Performance", EditorStyles.boldLabel);
-
-                EditorGUILayout.PropertyField(m_EnsureNetworkVariableLengthSafetyProperty);
-
-                EditorGUILayout.LabelField("Connection", EditorStyles.boldLabel);
-                EditorGUILayout.PropertyField(m_ConnectionApprovalProperty);
-
-                using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.ConnectionApproval))
-                {
-                    EditorGUILayout.PropertyField(m_ClientConnectionBufferTimeoutProperty);
-                }
-
-                EditorGUILayout.LabelField("Spawning", EditorStyles.boldLabel);
-                EditorGUILayout.PropertyField(m_ForceSamePrefabsProperty);
-
-
-                EditorGUILayout.PropertyField(m_RecycleNetworkIdsProperty);
-
-                using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.RecycleNetworkIds))
-                {
-                    EditorGUILayout.PropertyField(m_NetworkIdRecycleDelayProperty);
-                }
-
-                EditorGUILayout.LabelField("Bandwidth", EditorStyles.boldLabel);
-                EditorGUILayout.PropertyField(m_RpcHashSizeProperty);
-
-                EditorGUILayout.LabelField("Scene Management", EditorStyles.boldLabel);
-                EditorGUILayout.PropertyField(m_EnableSceneManagementProperty);
-
-                using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.EnableSceneManagement))
-                {
-                    EditorGUILayout.PropertyField(m_LoadSceneTimeOutProperty);
-                }
-
-                serializedObject.ApplyModifiedProperties();
-
-
-                // Start buttons below
-                {
-                    string buttonDisabledReasonSuffix = "";
-
-                    if (!EditorApplication.isPlaying)
-                    {
-                        buttonDisabledReasonSuffix = ". This can only be done in play mode";
-                        GUI.enabled = false;
-                    }
-
-                    if (GUILayout.Button(new GUIContent("Start Host", "Starts a host instance" + buttonDisabledReasonSuffix)))
-                    {
-                        m_NetworkManager.StartHost();
-                    }
-
-                    if (GUILayout.Button(new GUIContent("Start Server", "Starts a server instance" + buttonDisabledReasonSuffix)))
-                    {
-                        m_NetworkManager.StartServer();
-                    }
-
-                    if (GUILayout.Button(new GUIContent("Start Client", "Starts a client instance" + buttonDisabledReasonSuffix)))
-                    {
-                        m_NetworkManager.StartClient();
-                    }
-
-                    if (!EditorApplication.isPlaying)
-                    {
-                        GUI.enabled = true;
-                    }
-                }
+                EditorGUILayout.PropertyField(m_ClientConnectionBufferTimeoutProperty);
             }
-            else
+
+            EditorGUILayout.LabelField("Spawning", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(m_ForceSamePrefabsProperty);
+
+            EditorGUILayout.PropertyField(m_RecycleNetworkIdsProperty);
+
+            using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.RecycleNetworkIds))
             {
-                string instanceType = string.Empty;
+                EditorGUILayout.PropertyField(m_NetworkIdRecycleDelayProperty);
+            }
 
-                if (m_NetworkManager.IsHost)
-                {
-                    instanceType = "Host";
-                }
-                else if (m_NetworkManager.IsServer)
-                {
-                    instanceType = "Server";
-                }
-                else if (m_NetworkManager.IsClient)
-                {
-                    instanceType = "Client";
-                }
+            EditorGUILayout.LabelField("Bandwidth", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(m_RpcHashSizeProperty);
 
-                EditorGUILayout.HelpBox("You cannot edit the NetworkConfig when a " + instanceType + " is running.", MessageType.Info);
+            EditorGUILayout.LabelField("Scene Management", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(m_EnableSceneManagementProperty);
 
-                if (GUILayout.Button(new GUIContent("Stop " + instanceType, "Stops the " + instanceType + " instance.")))
+            using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.EnableSceneManagement))
+            {
+                EditorGUILayout.PropertyField(m_LoadSceneTimeOutProperty);
+            }
+
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        private void DrawTransportField()
+        {
+#if RELAY_INTEGRATION_AVAILABLE
+            var useRelay = EditorPrefs.GetBool(m_UseEasyRelayIntegrationKey, false);
+#else
+            var useRelay = false;
+#endif
+
+            if (useRelay)
+            {
+                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;
+            }
+
+            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)
                 {
-                    m_NetworkManager.Shutdown();
+                    ReloadTransports();
+
+                    var transportComponent = m_NetworkManager.gameObject.GetComponent(m_TransportTypes[selection - 1]) ?? m_NetworkManager.gameObject.AddComponent(m_TransportTypes[selection - 1]);
+                    m_NetworkTransportProperty.objectReferenceValue = transportComponent;
+
+                    Repaint();
                 }
             }
         }
 
+#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()
+        {
+            EditorGUILayout.LabelField("Start Connection", EditorStyles.boldLabel);
+
+#if RELAY_INTEGRATION_AVAILABLE
+            // use editor prefs to persist the setting when entering / leaving play mode / exiting Unity
+            var useRelay = EditorPrefs.GetBool(m_UseEasyRelayIntegrationKey, false);
+            GUILayout.BeginHorizontal();
+            useRelay = GUILayout.Toggle(useRelay, "Try Relay in the Editor");
+
+            var icon = EditorGUIUtility.IconContent("_Help");
+            icon.tooltip = "This will help you test relay in the Editor. Click here to know how to integrate Relay in your build";
+            if (GUILayout.Button(icon, GUIStyle.none, GUILayout.Width(20)))
+            {
+                Application.OpenURL("https://docs-multiplayer.unity3d.com/netcode/current/relay/");
+            }
+            GUILayout.EndHorizontal();
+
+            EditorPrefs.SetBool(m_UseEasyRelayIntegrationKey, useRelay);
+            if (useRelay && !Application.isPlaying && !CloudProjectSettings.projectBound)
+            {
+                EditorGUILayout.HelpBox("To use relay, you need to setup your project in the Project Settings in the Services section.", MessageType.Warning);
+                if (GUILayout.Button("Open Project settings"))
+                {
+                    SettingsService.OpenProjectSettings("Project/Services");
+                }
+            }
+#else
+            var useRelay = false;
+#endif
+
+            string buttonDisabledReasonSuffix = "";
+
+            if (!EditorApplication.isPlaying)
+            {
+                buttonDisabledReasonSuffix = ". This can only be done in play mode";
+                GUI.enabled = false;
+            }
+
+            if (useRelay)
+            {
+                ShowStartConnectionButtons_Relay(buttonDisabledReasonSuffix);
+            }
+            else
+            {
+                ShowStartConnectionButtons_Standard(buttonDisabledReasonSuffix);
+            }
+
+            if (!EditorApplication.isPlaying)
+            {
+                GUI.enabled = true;
+            }
+        }
+
+        private void ShowStartConnectionButtons_Relay(string buttonDisabledReasonSuffix)
+        {
+#if RELAY_INTEGRATION_AVAILABLE
+
+            void AddStartServerOrHostButton(bool isServer)
+            {
+                var type = isServer ? "Server" : "Host";
+                if (GUILayout.Button(new GUIContent($"Start {type}", $"Starts a {type} instance with Relay{buttonDisabledReasonSuffix}")))
+                {
+                    m_StartConnectionError = null;
+                    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
+        }
+
+        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/netcode/current/tools/install-tools";
-            const string infoIconName = "console.infoicon";
+            const string targetUrl = "https://docs-multiplayer.unity3d.com/tools/current/install-tools";
+
 
             if (NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() != 0)
             {
@@ -371,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));
 
@@ -404,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/NetworkManagerRelayIntegration.cs

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

Editor/NetworkManagerRelayIntegration.cs.meta

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

Editor/NetworkTransformEditor.cs

@@ -10,6 +10,7 @@ namespace Unity.Netcode.Editor
     [CustomEditor(typeof(NetworkTransform), true)]
     public class NetworkTransformEditor : UnityEditor.Editor
     {
+        private SerializedProperty m_UseUnreliableDeltas;
         private SerializedProperty m_SyncPositionXProperty;
         private SerializedProperty m_SyncPositionYProperty;
         private SerializedProperty m_SyncPositionZProperty;
@@ -36,9 +37,12 @@ namespace Unity.Netcode.Editor
         private static GUIContent s_RotationLabel = EditorGUIUtility.TrTextContent("Rotation");
         private static GUIContent s_ScaleLabel = EditorGUIUtility.TrTextContent("Scale");
 
+        public virtual bool HideInterpolateValue => false;
+
         /// <inheritdoc/>
         public void OnEnable()
         {
+            m_UseUnreliableDeltas = serializedObject.FindProperty(nameof(NetworkTransform.UseUnreliableDeltas));
             m_SyncPositionXProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionX));
             m_SyncPositionYProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionY));
             m_SyncPositionZProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionZ));
@@ -129,11 +133,17 @@ namespace Unity.Netcode.Editor
             EditorGUILayout.PropertyField(m_PositionThresholdProperty);
             EditorGUILayout.PropertyField(m_RotAngleThresholdProperty);
             EditorGUILayout.PropertyField(m_ScaleThresholdProperty);
-
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Delivery", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(m_UseUnreliableDeltas);
             EditorGUILayout.Space();
             EditorGUILayout.LabelField("Configurations", EditorStyles.boldLabel);
             EditorGUILayout.PropertyField(m_InLocalSpaceProperty);
-            EditorGUILayout.PropertyField(m_InterpolateProperty);
+            if (!HideInterpolateValue)
+            {
+                EditorGUILayout.PropertyField(m_InterpolateProperty);
+            }
+
             EditorGUILayout.PropertyField(m_SlerpPosition);
             EditorGUILayout.PropertyField(m_UseQuaternionSynchronization);
             if (m_UseQuaternionSynchronization.boolValue)
@@ -146,9 +156,10 @@ namespace Unity.Netcode.Editor
             }
             EditorGUILayout.PropertyField(m_UseHalfFloatPrecision);
 
-#if COM_UNITY_MODULES_PHYSICS
             // if rigidbody is present but network rigidbody is not present
             var go = ((NetworkTransform)target).gameObject;
+
+#if COM_UNITY_MODULES_PHYSICS
             if (go.TryGetComponent<Rigidbody>(out _) && go.TryGetComponent<NetworkRigidbody>(out _) == false)
             {
                 EditorGUILayout.HelpBox("This GameObject contains a Rigidbody but no NetworkRigidbody.\n" +

Editor/com.unity.netcode.editor.asmdef

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

Runtime/Configuration/NetworkConfig.cs

@@ -132,7 +132,7 @@ namespace Unity.Netcode
         /// 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 should be buffered if the asset or object needed to process it doesn't exist yet. If the asset is not added/object is not spawned within this time, it will be dropped")]
-        public float SpawnTimeout = 1f;
+        public float SpawnTimeout = 10f;
 
         /// <summary>
         /// Whether or not to enable network logs.
@@ -156,7 +156,7 @@ namespace Unity.Netcode
         public string ToBase64()
         {
             NetworkConfig config = this;
-            var writer = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp);
+            var writer = new FastBufferWriter(1024, Allocator.Temp);
             using (writer)
             {
                 writer.WriteValueSafe(config.ProtocolVersion);
@@ -228,7 +228,7 @@ namespace Unity.Netcode
                 return m_ConfigHash.Value;
             }
 
-            var writer = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, int.MaxValue);
+            var writer = new FastBufferWriter(1024, Allocator.Temp, int.MaxValue);
             using (writer)
             {
                 writer.WriteValueSafe(ProtocolVersion);

Runtime/Configuration/NetworkPrefab.cs

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

Runtime/Configuration/NetworkPrefabs.cs

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

Runtime/Connection/NetworkClient.cs

@@ -7,6 +7,32 @@ namespace Unity.Netcode
     /// </summary>
     public class NetworkClient
     {
+        /// <summary>
+        /// Returns true if the session instance is considered a server
+        /// </summary>
+        internal bool IsServer { get; set; }
+
+        /// <summary>
+        /// Returns true if the session instance is considered a client
+        /// </summary>
+        internal bool IsClient { get; set; }
+
+        /// <summary>
+        /// Returns true if the session instance is considered a host
+        /// </summary>
+        internal bool IsHost => IsClient && IsServer;
+
+        /// <summary>
+        /// When true, the client is connected, approved, and synchronized with
+        /// the server.
+        /// </summary>
+        internal bool IsConnected { get; set; }
+
+        /// <summary>
+        /// Is true when the client has been approved.
+        /// </summary>
+        internal bool IsApproved { get; set; }
+
         /// <summary>
         /// The ClientId of the NetworkClient
         /// </summary>
@@ -18,19 +44,33 @@ namespace Unity.Netcode
         public NetworkObject PlayerObject;
 
         /// <summary>
-        /// The NetworkObject's owned by this Client
+        /// The list of NetworkObject's owned by this client instance
         /// </summary>
-        public List<NetworkObject> OwnedObjects
-        {
-            get
-            {
-                if (PlayerObject != null && PlayerObject.NetworkManager != null && PlayerObject.NetworkManager.IsListening)
-                {
-                    return PlayerObject.NetworkManager.SpawnManager.GetClientOwnedObjects(ClientId);
-                }
+        public List<NetworkObject> OwnedObjects => IsConnected ? SpawnManager.GetClientOwnedObjects(ClientId) : new List<NetworkObject>();
 
-                return new List<NetworkObject>();
+        internal NetworkSpawnManager SpawnManager { get; private set; }
+
+        internal void SetRole(bool isServer, bool isClient, NetworkManager networkManager = null)
+        {
+            IsServer = isServer;
+            IsClient = isClient;
+            if (!IsServer && !isClient)
+            {
+                PlayerObject = null;
+                ClientId = 0;
+                IsConnected = false;
+                IsApproved = false;
             }
+
+            if (networkManager != null)
+            {
+                SpawnManager = networkManager.SpawnManager;
+            }
+        }
+
+        internal void AssignPlayerObject(ref NetworkObject networkObject)
+        {
+            PlayerObject = networkObject;
         }
     }
 }

Runtime/Connection/NetworkConnectionManager.cs.meta

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

Runtime/Connection/PendingClient.cs

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

Runtime/Core/ComponentFactory.cs

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

Runtime/Core/NetworkBehaviour.cs

@@ -1,33 +1,56 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
 using Unity.Collections;
 using UnityEngine;
 
+
 namespace Unity.Netcode
 {
+    public class RpcException : Exception
+    {
+        public RpcException(string message) : base(message)
+        {
+
+        }
+    }
+
     /// <summary>
     /// The base class to override to write network code. Inherits MonoBehaviour
     /// </summary>
     public abstract class NetworkBehaviour : MonoBehaviour
     {
 #pragma warning disable IDE1006 // disable naming rule violation check
+
+        // RuntimeAccessModifiersILPP will make this `public`
+        internal delegate void RpcReceiveHandler(NetworkBehaviour behaviour, FastBufferReader reader, __RpcParams parameters);
+
+        // RuntimeAccessModifiersILPP will make this `public`
+        internal static readonly Dictionary<Type, Dictionary<uint, RpcReceiveHandler>> __rpc_func_table = new Dictionary<Type, Dictionary<uint, RpcReceiveHandler>>();
+
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+        // RuntimeAccessModifiersILPP will make this `public`
+        internal static readonly Dictionary<Type, Dictionary<uint, string>> __rpc_name_table = new Dictionary<Type, Dictionary<uint, string>>();
+#endif
+
         // RuntimeAccessModifiersILPP will make this `protected`
         internal enum __RpcExecStage
         {
+            // Technically will overlap with None and Server
+            // but it doesn't matter since we don't use None and Server
+            Send = 0,
+            Execute = 1,
+
+            // Backward compatibility, not used...
             None = 0,
             Server = 1,
-            Client = 2
+            Client = 2,
         }
-
-
         // NetworkBehaviourILPP will override this in derived classes to return the name of the concrete type
         internal virtual string __getTypeName() => nameof(NetworkBehaviour);
 
         [NonSerialized]
         // RuntimeAccessModifiersILPP will make this `protected`
-        internal __RpcExecStage __rpc_exec_stage = __RpcExecStage.None;
+        internal __RpcExecStage __rpc_exec_stage = __RpcExecStage.Send;
 #pragma warning restore IDE1006 // restore naming rule violation check
 
         private const int k_RpcMessageDefaultSize = 1024; // 1k
@@ -65,7 +88,7 @@ namespace Unity.Netcode
                     networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
                     break;
                 case RpcDelivery.Unreliable:
-                    if (bufferWriter.Length > MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE)
+                    if (bufferWriter.Length > NetworkManager.MessageManager.NonFragmentedMessageMaxSize)
                     {
                         throw new OverflowException("RPC parameters are too large for unreliable delivery.");
                     }
@@ -86,7 +109,7 @@ namespace Unity.Netcode
                     SystemOwner = NetworkManager,
                     // header information isn't valid since it's not a real message.
                     // RpcMessage doesn't access this stuff so it's just left empty.
-                    Header = new MessageHeader(),
+                    Header = new NetworkMessageHeader(),
                     SerializedHeaderSize = 0,
                     MessageSize = 0
                 };
@@ -96,13 +119,12 @@ namespace Unity.Netcode
             }
             else
             {
-                rpcWriteSize = NetworkManager.SendMessage(ref serverRpcMessage, networkDelivery, NetworkManager.ServerClientId);
+                rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref serverRpcMessage, networkDelivery, NetworkManager.ServerClientId);
             }
 
             bufferWriter.Dispose();
-
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (NetworkManager.__rpc_name_table.TryGetValue(rpcMethodId, out var rpcMethodName))
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+            if (__rpc_name_table[GetType()].TryGetValue(rpcMethodId, out var rpcMethodName))
             {
                 NetworkManager.NetworkMetrics.TrackRpcSent(
                     NetworkManager.ServerClientId,
@@ -146,7 +168,7 @@ namespace Unity.Netcode
                     networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
                     break;
                 case RpcDelivery.Unreliable:
-                    if (bufferWriter.Length > MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE)
+                    if (bufferWriter.Length > NetworkManager.MessageManager.NonFragmentedMessageMaxSize)
                     {
                         throw new OverflowException("RPC parameters are too large for unreliable delivery.");
                     }
@@ -176,7 +198,7 @@ namespace Unity.Netcode
                     }
                 }
 
-                rpcWriteSize = NetworkManager.SendMessage(ref clientRpcMessage, networkDelivery, in clientRpcParams.Send.TargetClientIds);
+                rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, in clientRpcParams.Send.TargetClientIds);
             }
             else if (clientRpcParams.Send.TargetClientIdsNativeArray != null)
             {
@@ -195,7 +217,7 @@ namespace Unity.Netcode
                     }
                 }
 
-                rpcWriteSize = NetworkManager.SendMessage(ref clientRpcMessage, networkDelivery, clientRpcParams.Send.TargetClientIdsNativeArray.Value);
+                rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, clientRpcParams.Send.TargetClientIdsNativeArray.Value);
             }
             else
             {
@@ -208,7 +230,7 @@ namespace Unity.Netcode
                         shouldSendToHost = true;
                         continue;
                     }
-                    rpcWriteSize = NetworkManager.MessagingSystem.SendMessage(ref clientRpcMessage, networkDelivery, observerEnumerator.Current);
+                    rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, observerEnumerator.Current);
                 }
             }
 
@@ -223,7 +245,7 @@ namespace Unity.Netcode
                     SystemOwner = NetworkManager,
                     // header information isn't valid since it's not a real message.
                     // RpcMessage doesn't access this stuff so it's just left empty.
-                    Header = new MessageHeader(),
+                    Header = new NetworkMessageHeader(),
                     SerializedHeaderSize = 0,
                     MessageSize = 0
                 };
@@ -232,9 +254,8 @@ namespace Unity.Netcode
             }
 
             bufferWriter.Dispose();
-
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (NetworkManager.__rpc_name_table.TryGetValue(rpcMethodId, out var rpcMethodName))
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+            if (__rpc_name_table[GetType()].TryGetValue(rpcMethodId, out var rpcMethodName))
             {
                 if (clientRpcParams.Send.TargetClientIds != null)
                 {
@@ -277,6 +298,107 @@ namespace Unity.Netcode
 #endif
         }
 
+
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal FastBufferWriter __beginSendRpc(uint rpcMethodId, RpcParams rpcParams, RpcAttribute.RpcAttributeParams attributeParams, SendTo defaultTarget, RpcDelivery rpcDelivery)
+#pragma warning restore IDE1006 // restore naming rule violation check
+        {
+            if (attributeParams.RequireOwnership && !IsOwner)
+            {
+                throw new RpcException("This RPC can only be sent by its owner.");
+            }
+            return new FastBufferWriter(k_RpcMessageDefaultSize, Allocator.Temp, k_RpcMessageMaximumSize);
+        }
+
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal void __endSendRpc(ref FastBufferWriter bufferWriter, uint rpcMethodId, RpcParams rpcParams, RpcAttribute.RpcAttributeParams attributeParams, SendTo defaultTarget, RpcDelivery rpcDelivery)
+#pragma warning restore IDE1006 // restore naming rule violation check
+        {
+            var rpcMessage = new RpcMessage
+            {
+                Metadata = new RpcMetadata
+                {
+                    NetworkObjectId = NetworkObjectId,
+                    NetworkBehaviourId = NetworkBehaviourId,
+                    NetworkRpcMethodId = rpcMethodId,
+                },
+                SenderClientId = NetworkManager.LocalClientId,
+                WriteBuffer = bufferWriter
+            };
+
+            NetworkDelivery networkDelivery;
+            switch (rpcDelivery)
+            {
+                default:
+                case RpcDelivery.Reliable:
+                    networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
+                    break;
+                case RpcDelivery.Unreliable:
+                    if (bufferWriter.Length > NetworkManager.MessageManager.NonFragmentedMessageMaxSize)
+                    {
+                        throw new OverflowException("RPC parameters are too large for unreliable delivery.");
+                    }
+                    networkDelivery = NetworkDelivery.Unreliable;
+                    break;
+            }
+
+            if (rpcParams.Send.Target == null)
+            {
+                switch (defaultTarget)
+                {
+                    case SendTo.Everyone:
+                        rpcParams.Send.Target = RpcTarget.Everyone;
+                        break;
+                    case SendTo.Owner:
+                        rpcParams.Send.Target = RpcTarget.Owner;
+                        break;
+                    case SendTo.Server:
+                        rpcParams.Send.Target = RpcTarget.Server;
+                        break;
+                    case SendTo.NotServer:
+                        rpcParams.Send.Target = RpcTarget.NotServer;
+                        break;
+                    case SendTo.NotMe:
+                        rpcParams.Send.Target = RpcTarget.NotMe;
+                        break;
+                    case SendTo.NotOwner:
+                        rpcParams.Send.Target = RpcTarget.NotOwner;
+                        break;
+                    case SendTo.Me:
+                        rpcParams.Send.Target = RpcTarget.Me;
+                        break;
+                    case SendTo.ClientsAndHost:
+                        rpcParams.Send.Target = RpcTarget.ClientsAndHost;
+                        break;
+                    case SendTo.SpecifiedInParams:
+                        throw new RpcException("This method requires a runtime-specified send target.");
+                }
+            }
+            else if (defaultTarget != SendTo.SpecifiedInParams && !attributeParams.AllowTargetOverride)
+            {
+                throw new RpcException("Target override is not allowed for this method.");
+            }
+
+            if (rpcParams.Send.LocalDeferMode == LocalDeferMode.Default)
+            {
+                rpcParams.Send.LocalDeferMode = attributeParams.DeferLocal ? LocalDeferMode.Defer : LocalDeferMode.SendImmediate;
+            }
+
+            rpcParams.Send.Target.Send(this, ref rpcMessage, networkDelivery, rpcParams);
+
+            bufferWriter.Dispose();
+        }
+
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal static NativeList<T> __createNativeList<T>() where T : unmanaged
+#pragma warning restore IDE1006 // restore naming rule violation check
+        {
+            return new NativeList<T>(Allocator.Temp);
+        }
+
         internal string GenerateObserverErrorMessage(ClientRpcParams clientRpcParams, ulong targetClientId)
         {
             var containerNameHoldingId = clientRpcParams.Send.TargetClientIds != null ? nameof(ClientRpcParams.Send.TargetClientIds) : nameof(ClientRpcParams.Send.TargetClientIdsNativeArray);
@@ -300,6 +422,24 @@ namespace Unity.Netcode
             }
         }
 
+        // This erroneously tries to simplify these method references but the docs do not pick it up correctly
+        // because they try to resolve it on the field rather than the class of the same name.
+#pragma warning disable IDE0001
+        /// <summary>
+        /// Provides access to the various <see cref="SendTo"/> targets at runtime, as well as
+        /// runtime-bound targets like <see cref="Unity.Netcode.RpcTarget.Single"/>,
+        /// <see cref="Unity.Netcode.RpcTarget.Group(NativeArray{ulong})"/>,
+        /// <see cref="Unity.Netcode.RpcTarget.Group(NativeList{ulong})"/>,
+        /// <see cref="Unity.Netcode.RpcTarget.Group(ulong[])"/>,
+        /// <see cref="Unity.Netcode.RpcTarget.Group{T}(T)"/>, <see cref="Unity.Netcode.RpcTarget.Not(ulong)"/>,
+        /// <see cref="Unity.Netcode.RpcTarget.Not(NativeArray{ulong})"/>,
+        /// <see cref="Unity.Netcode.RpcTarget.Not(NativeList{ulong})"/>,
+        /// <see cref="Unity.Netcode.RpcTarget.Not(ulong[])"/>, and
+        /// <see cref="Unity.Netcode.RpcTarget.Not{T}(T)"/>
+        /// </summary>
+#pragma warning restore IDE0001
+        public RpcTarget RpcTarget => NetworkManager.RpcTarget;
+
         /// <summary>
         /// If a NetworkObject is assigned, it will return whether or not this NetworkObject
         /// is the local player object.  If no NetworkObject is assigned it will always return false.
@@ -316,6 +456,11 @@ namespace Unity.Netcode
         /// </summary>
         public bool IsServer { get; private set; }
 
+        /// <summary>
+        /// Gets if the server (local or remote) is a host - i.e., also a client
+        /// </summary>
+        public bool ServerIsHost { get; private set; }
+
         /// <summary>
         /// Gets if we are executing as client
         /// </summary>
@@ -360,12 +505,14 @@ namespace Unity.Netcode
         {
             get
             {
+                if (m_NetworkObject != null)
+                {
+                    return m_NetworkObject;
+                }
+
                 try
                 {
-                    if (m_NetworkObject == null)
-                    {
-                        m_NetworkObject = GetComponentInParent<NetworkObject>();
-                    }
+                    m_NetworkObject = GetComponentInParent<NetworkObject>();
                 }
                 catch (Exception)
                 {
@@ -457,26 +604,81 @@ namespace Unity.Netcode
                     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;
             {
                 OwnerClientId = NetworkObjectId = default;
-                IsOwnedByServer = IsOwner = IsHost = IsClient = IsServer = default;
+                IsOwnedByServer = IsOwner = IsHost = IsClient = IsServer = ServerIsHost = default;
                 NetworkBehaviourId = default;
             }
         }
 
+        /// <summary>
+        /// Gets called after the <see cref="NetworkObject"/> is spawned. No NetworkBehaviours associated with the NetworkObject will have had <see cref="OnNetworkSpawn"/> invoked yet.
+        /// A reference to <see cref="NetworkManager"/> is passed in as a parameter to determine the context of execution (IsServer/IsClient)
+        /// </summary>
+        /// <remarks>
+        /// <param name="networkManager">a ref to the <see cref="NetworkManager"/> since this is not yet set on the <see cref="NetworkBehaviour"/></param>
+        /// The <see cref="NetworkBehaviour"/> will not have anything assigned to it at this point in time.
+        /// Settings like ownership, NetworkBehaviourId, NetworkManager, and most other spawn related properties will not be set.
+        /// This can be used to handle things like initializing/instantiating a NetworkVariable or the like.
+        /// </remarks>
+        protected virtual void OnNetworkPreSpawn(ref NetworkManager networkManager) { }
+
         /// <summary>
         /// Gets called when the <see cref="NetworkObject"/> gets spawned, message handlers are ready to be registered and the network is setup.
         /// </summary>
         public virtual void OnNetworkSpawn() { }
 
+        /// <summary>
+        /// Gets called after the <see cref="NetworkObject"/> is spawned. All NetworkBehaviours associated with the NetworkObject will have had <see cref="OnNetworkSpawn"/> invoked.
+        /// </summary>
+        /// <remarks>
+        /// Will be invoked on each <see cref="NetworkBehaviour"/> associated with the <see cref="NetworkObject"/> being spawned.
+        /// All associated <see cref="NetworkBehaviour"/> components will have had <see cref="OnNetworkSpawn"/> invoked on the spawned <see cref="NetworkObject"/>.
+        /// </remarks>
+        protected virtual void OnNetworkPostSpawn() { }
+
+        /// <summary>
+        /// [Client-Side Only]
+        /// When a new client joins it is synchronized with all spawned NetworkObjects and scenes loaded for the session joined. At the end of the synchronization process, when all
+        /// <see cref="NetworkObject"/>s and scenes (if scene management is enabled) have finished synchronizing, all NetworkBehaviour components associated with spawned <see cref="NetworkObject"/>s
+        /// will have this method invoked.
+        /// </summary>
+        /// <remarks>
+        /// This can be used to handle post synchronization actions where you might need to access a different NetworkObject and/or NetworkBehaviour not local to the current NetworkObject context.
+        /// This is only invoked on clients during a client-server network topology session.
+        /// </remarks>
+        protected virtual void OnNetworkSessionSynchronized() { }
+
+        /// <summary>
+        /// [Client & Server Side]
+        /// When a scene is loaded an in-scene placed NetworkObjects are all spawned, this method is invoked on all of the newly spawned in-scene placed NetworkObjects.
+        /// </summary>
+        /// <remarks>
+        /// This can be used to handle post scene loaded actions for in-scene placed NetworkObjcts where you might need to access a different NetworkObject and/or NetworkBehaviour not local to the current NetworkObject context.
+        /// </remarks>
+        protected virtual void OnInSceneObjectsSpawned() { }
+
         /// <summary>
         /// Gets called when the <see cref="NetworkObject"/> gets despawned. Is called both on the server and clients.
         /// </summary>
         public virtual void OnNetworkDespawn() { }
 
+        internal void NetworkPreSpawn(ref NetworkManager networkManager)
+        {
+            try
+            {
+                OnNetworkPreSpawn(ref networkManager);
+            }
+            catch (Exception e)
+            {
+                Debug.LogException(e);
+            }
+        }
+
         internal void InternalOnNetworkSpawn()
         {
             IsSpawned = true;
@@ -505,6 +707,42 @@ namespace Unity.Netcode
             }
         }
 
+        internal void NetworkPostSpawn()
+        {
+            try
+            {
+                OnNetworkPostSpawn();
+            }
+            catch (Exception e)
+            {
+                Debug.LogException(e);
+            }
+        }
+
+        internal void NetworkSessionSynchronized()
+        {
+            try
+            {
+                OnNetworkSessionSynchronized();
+            }
+            catch (Exception e)
+            {
+                Debug.LogException(e);
+            }
+        }
+
+        internal void InSceneNetworkObjectsSpawned()
+        {
+            try
+            {
+                OnInSceneObjectsSpawned();
+            }
+            catch (Exception e)
+            {
+                Debug.LogException(e);
+            }
+        }
+
         internal void InternalOnNetworkDespawn()
         {
             IsSpawned = false;
@@ -520,7 +758,7 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets called when the local client gains ownership of this object
+        /// Invoked on both the server and the local client of the owner when <see cref="Netcode.NetworkObject"/> ownership is assigned.
         /// </summary>
         public virtual void OnGainedOwnership() { }
 
@@ -531,7 +769,25 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Gets called when we loose ownership of this object
+        /// Invoked on all clients, override this method to be notified of any
+        /// ownership changes (even if the instance was niether the previous or
+        /// newly assigned current owner).
+        /// </summary>
+        /// <param name="previous">the previous owner</param>
+        /// <param name="current">the current owner</param>
+        protected virtual void OnOwnershipChanged(ulong previous, ulong current)
+        {
+
+        }
+
+        internal void InternalOnOwnershipChanged(ulong previous, ulong current)
+        {
+            OnOwnershipChanged(previous, current);
+        }
+
+        /// <summary>
+        /// Invoked on the local client when it loses ownership of the associated <see cref="Netcode.NetworkObject"/>.
+        /// This method is also invoked on the server when any client loses ownership.
         /// </summary>
         public virtual void OnLostOwnership() { }
 
@@ -551,35 +807,44 @@ namespace Unity.Netcode
 
         private readonly List<HashSet<int>> m_DeliveryMappedNetworkVariableIndices = new List<HashSet<int>>();
         private readonly List<NetworkDelivery> m_DeliveryTypesForNetworkVariableGroups = new List<NetworkDelivery>();
+
+        // RuntimeAccessModifiersILPP will make this `protected`
         internal readonly List<NetworkVariableBase> NetworkVariableFields = new List<NetworkVariableBase>();
 
-        private static Dictionary<Type, FieldInfo[]> s_FieldTypes = new Dictionary<Type, FieldInfo[]>();
-
-        private static FieldInfo[] GetFieldInfoForType(Type type)
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal virtual void __initializeVariables()
+#pragma warning restore IDE1006 // restore naming rule violation check
         {
-            if (!s_FieldTypes.ContainsKey(type))
-            {
-                s_FieldTypes.Add(type, GetFieldInfoForTypeRecursive(type));
-            }
-
-            return s_FieldTypes[type];
+            // ILPP generates code for all NetworkBehaviour subtypes to initialize each type's network variables.
         }
 
-        private static FieldInfo[] GetFieldInfoForTypeRecursive(Type type, List<FieldInfo> list = null)
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal virtual void __initializeRpcs()
+#pragma warning restore IDE1006 // restore naming rule violation check
         {
-            if (list == null)
-            {
-                list = new List<FieldInfo>();
-            }
+            // ILPP generates code for all NetworkBehaviour subtypes to initialize each type's RPCs.
+        }
 
-            list.AddRange(type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal void __registerRpc(uint hash, RpcReceiveHandler handler, string rpcMethodName)
+#pragma warning restore IDE1006 // restore naming rule violation check
+        {
+            __rpc_func_table[GetType()][hash] = handler;
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+            __rpc_name_table[GetType()][hash] = rpcMethodName;
+#endif
+        }
 
-            if (type.BaseType != null && type.BaseType != typeof(NetworkBehaviour))
-            {
-                return GetFieldInfoForTypeRecursive(type.BaseType, list);
-            }
-
-            return list.OrderBy(x => x.Name, StringComparer.Ordinal).ToArray();
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        // Using this method here because ILPP doesn't seem to let us do visibility modification on properties.
+        internal void __nameNetworkVariable(NetworkVariableBase variable, string varName)
+#pragma warning restore IDE1006 // restore naming rule violation check
+        {
+            variable.Name = varName;
         }
 
         internal void InitializeVariables()
@@ -591,22 +856,15 @@ namespace Unity.Netcode
 
             m_VarInit = true;
 
-            var sortedFields = GetFieldInfoForType(GetType());
-            for (int i = 0; i < sortedFields.Length; i++)
+            if (!__rpc_func_table.ContainsKey(GetType()))
             {
-                var fieldType = sortedFields[i].FieldType;
-                if (fieldType.IsSubclassOf(typeof(NetworkVariableBase)))
-                {
-                    var instance = (NetworkVariableBase)sortedFields[i].GetValue(this) ?? throw new Exception($"{GetType().FullName}.{sortedFields[i].Name} cannot be null. All {nameof(NetworkVariableBase)} instances must be initialized.");
-                    instance.Initialize(this);
-
-                    var instanceNameProperty = fieldType.GetProperty(nameof(NetworkVariableBase.Name));
-                    var sanitizedVariableName = sortedFields[i].Name.Replace("<", string.Empty).Replace(">k__BackingField", string.Empty);
-                    instanceNameProperty?.SetValue(instance, sanitizedVariableName);
-
-                    NetworkVariableFields.Add(instance);
-                }
+                __rpc_func_table[GetType()] = new Dictionary<uint, RpcReceiveHandler>();
+#if UNITY_EDITOR || DEVELOPMENT_BUILD || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+                __rpc_name_table[GetType()] = new Dictionary<uint, string>();
+#endif
+                __initializeRpcs();
             }
+            __initializeVariables();
 
             {
                 // Create index map for delivery types
@@ -648,7 +906,16 @@ namespace Unity.Netcode
                 // during OnNetworkSpawn has been sent and needs to be cleared
                 for (int i = 0; i < NetworkVariableFields.Count; i++)
                 {
-                    NetworkVariableFields[i].ResetDirty();
+                    var networkVariable = NetworkVariableFields[i];
+                    if (networkVariable.IsDirty())
+                    {
+                        if (networkVariable.CanSend())
+                        {
+                            networkVariable.UpdateLastSentTime();
+                            networkVariable.ResetDirty();
+                            networkVariable.SetDirty(false);
+                        }
+                    }
                 }
             }
             else
@@ -656,11 +923,18 @@ namespace Unity.Netcode
                 // mark any variables we wrote as no longer dirty
                 for (int i = 0; i < NetworkVariableIndexesToReset.Count; i++)
                 {
-                    NetworkVariableFields[NetworkVariableIndexesToReset[i]].ResetDirty();
+                    var networkVariable = NetworkVariableFields[NetworkVariableIndexesToReset[i]];
+                    if (networkVariable.IsDirty())
+                    {
+                        if (networkVariable.CanSend())
+                        {
+                            networkVariable.UpdateLastSentTime();
+                            networkVariable.ResetDirty();
+                            networkVariable.SetDirty(false);
+                        }
+                    }
                 }
             }
-
-            MarkVariablesDirty(false);
         }
 
         internal void PreVariableUpdate()
@@ -669,7 +943,6 @@ namespace Unity.Netcode
             {
                 InitializeVariables();
             }
-
             PreNetworkVariableWrite();
         }
 
@@ -696,7 +969,10 @@ namespace Unity.Netcode
                     var networkVariable = NetworkVariableFields[k];
                     if (networkVariable.IsDirty() && networkVariable.CanClientRead(targetClientId))
                     {
-                        shouldSend = true;
+                        if (networkVariable.CanSend())
+                        {
+                            shouldSend = true;
+                        }
                         break;
                     }
                 }
@@ -718,7 +994,7 @@ namespace Unity.Netcode
                     // so we don't have to do this serialization work if we're not going to use the result.
                     if (IsServer && targetClientId == NetworkManager.ServerClientId)
                     {
-                        var tmpWriter = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, MessagingSystem.FRAGMENTED_MESSAGE_MAX_SIZE);
+                        var tmpWriter = new FastBufferWriter(NetworkManager.MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp, NetworkManager.MessageManager.FragmentedMessageMaxSize);
                         using (tmpWriter)
                         {
                             message.Serialize(tmpWriter, message.Version);
@@ -726,7 +1002,7 @@ namespace Unity.Netcode
                     }
                     else
                     {
-                        NetworkManager.SendMessage(ref message, m_DeliveryTypesForNetworkVariableGroups[j], targetClientId);
+                        NetworkManager.ConnectionManager.SendMessage(ref message, m_DeliveryTypesForNetworkVariableGroups[j], targetClientId);
                     }
                 }
             }
@@ -737,9 +1013,16 @@ namespace Unity.Netcode
             // TODO: There should be a better way by reading one dirty variable vs. 'n'
             for (int i = 0; i < NetworkVariableFields.Count; i++)
             {
-                if (NetworkVariableFields[i].IsDirty())
+                var networkVariable = NetworkVariableFields[i];
+                if (networkVariable.IsDirty())
                 {
-                    return true;
+                    if (networkVariable.CanSend())
+                    {
+                        return true;
+                    }
+                    // If it's dirty but can't be sent yet, we have to keep monitoring it until one of the
+                    // conditions blocking its send changes.
+                    NetworkManager.BehaviourUpdater.AddForUpdate(NetworkObject);
                 }
             }
 
@@ -896,6 +1179,11 @@ namespace Unity.Netcode
 
         }
 
+        public virtual void OnReanticipate(double lastRoundTripTime)
+        {
+
+        }
+
         /// <summary>
         /// The relative client identifier targeted for the serialization of this <see cref="NetworkBehaviour"/> instance.
         /// </summary>
@@ -959,6 +1247,8 @@ namespace Unity.Netcode
                 if (finalPosition == positionBeforeSynchronize || threwException)
                 {
                     writer.Seek(positionBeforeWrite);
+                    // Truncate back to the size before
+                    writer.Truncate();
                     return false;
                 }
                 else
@@ -1024,9 +1314,9 @@ namespace Unity.Netcode
 
 
         /// <summary>
-        /// 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!!
+        /// Invoked when the <see cref="GameObject"/> the <see cref="NetworkBehaviour"/> is attached to is destroyed.
+        /// NOTE:  If you override this, you should invoke this base class version of this
+        /// <see cref="OnDestroy"/> method.
         /// </summary>
         public virtual void OnDestroy()
         {

Runtime/Core/NetworkBehaviourUpdater.cs

@@ -8,7 +8,10 @@ namespace Unity.Netcode
     /// </summary>
     public class NetworkBehaviourUpdater
     {
+        private NetworkManager m_NetworkManager;
+        private NetworkConnectionManager m_ConnectionManager;
         private HashSet<NetworkObject> m_DirtyNetworkObjects = new HashSet<NetworkObject>();
+        private HashSet<NetworkObject> m_PendingDirtyNetworkObjects = new HashSet<NetworkObject>();
 
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
         private ProfilerMarker m_NetworkBehaviourUpdate = new ProfilerMarker($"{nameof(NetworkBehaviour)}.{nameof(NetworkBehaviourUpdate)}");
@@ -16,21 +19,24 @@ namespace Unity.Netcode
 
         internal void AddForUpdate(NetworkObject networkObject)
         {
-            m_DirtyNetworkObjects.Add(networkObject);
+            m_PendingDirtyNetworkObjects.Add(networkObject);
         }
 
-        internal void NetworkBehaviourUpdate(NetworkManager networkManager)
+        internal void NetworkBehaviourUpdate()
         {
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             m_NetworkBehaviourUpdate.Begin();
 #endif
             try
             {
+                m_DirtyNetworkObjects.UnionWith(m_PendingDirtyNetworkObjects);
+                m_PendingDirtyNetworkObjects.Clear();
+
                 // NetworkObject references can become null, when hidden or despawned. Once NUll, there is no point
                 // trying to process them, even if they were previously marked as dirty.
                 m_DirtyNetworkObjects.RemoveWhere((sobj) => sobj == null);
 
-                if (networkManager.IsServer)
+                if (m_ConnectionManager.LocalClient.IsServer)
                 {
                     foreach (var dirtyObj in m_DirtyNetworkObjects)
                     {
@@ -39,9 +45,9 @@ namespace Unity.Netcode
                             dirtyObj.ChildNetworkBehaviours[k].PreVariableUpdate();
                         }
 
-                        for (int i = 0; i < networkManager.ConnectedClientsList.Count; i++)
+                        for (int i = 0; i < m_ConnectionManager.ConnectedClientsList.Count; i++)
                         {
-                            var client = networkManager.ConnectedClientsList[i];
+                            var client = m_ConnectionManager.ConnectedClientsList[i];
 
                             if (dirtyObj.IsNetworkVisibleTo(client.ClientId))
                             {
@@ -104,5 +110,26 @@ namespace Unity.Netcode
             }
         }
 
+        internal void Initialize(NetworkManager networkManager)
+        {
+            m_NetworkManager = networkManager;
+            m_ConnectionManager = networkManager.ConnectionManager;
+            m_NetworkManager.NetworkTickSystem.Tick += NetworkBehaviourUpdater_Tick;
+        }
+
+        internal void Shutdown()
+        {
+            m_NetworkManager.NetworkTickSystem.Tick -= NetworkBehaviourUpdater_Tick;
+        }
+
+        // Order of operations requires NetworkVariable updates first then showing NetworkObjects
+        private void NetworkBehaviourUpdater_Tick()
+        {
+            // First update NetworkVariables
+            NetworkBehaviourUpdate();
+
+            // Then show any NetworkObjects queued to be made visible/shown
+            m_NetworkManager.SpawnManager.HandleNetworkObjectShow();
+        }
     }
 }

Runtime/Core/NetworkObject.cs

@@ -1,9 +1,18 @@
 using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
+#if UNITY_EDITOR
+using UnityEditor;
+#if UNITY_2021_2_OR_NEWER
+using UnityEditor.SceneManagement;
+#else
+using UnityEditor.Experimental.SceneManagement;
+#endif
+#endif
 using UnityEngine;
 using UnityEngine.SceneManagement;
 
+
 namespace Unity.Netcode
 {
     /// <summary>
@@ -17,6 +26,22 @@ namespace Unity.Netcode
         [SerializeField]
         internal uint GlobalObjectIdHash;
 
+        /// <summary>
+        /// Used to track the source GlobalObjectIdHash value of the associated network prefab.
+        /// When an override exists or it is in-scene placed, GlobalObjectIdHash and PrefabGlobalObjectIdHash
+        /// will be different. The PrefabGlobalObjectIdHash value is what is used when sending a <see cref="CreateObjectMessage"/>.
+        /// </summary>
+        internal uint PrefabGlobalObjectIdHash;
+
+        /// <summary>
+        /// This is the source prefab of an in-scene placed NetworkObject. This is not set for in-scene 
+        /// placd NetworkObjects that are not prefab instances, dynamically spawned prefab instances,
+        /// or for network prefab assets.
+        /// </summary>
+        [HideInInspector]
+        [SerializeField]
+        internal uint InScenePlacedSourceGlobalObjectIdHash;
+
         /// <summary>
         /// Gets the Prefab Hash Id of this object if the object is registerd as a prefab otherwise it returns 0
         /// </summary>
@@ -25,42 +50,205 @@ namespace Unity.Netcode
         {
             get
             {
-                foreach (var prefab in NetworkManager.NetworkConfig.Prefabs.Prefabs)
-                {
-                    if (prefab.Prefab == gameObject)
-                    {
-                        return GlobalObjectIdHash;
-                    }
-                }
-
-                return 0;
+                return GlobalObjectIdHash;
             }
         }
 
-        private bool m_IsPrefab;
-
 #if UNITY_EDITOR
-        private void OnValidate()
+        private const string k_GlobalIdTemplate = "GlobalObjectId_V1-{0}-{1}-{2}-{3}";
+
+        /// <summary>
+        /// Object Types <see href="https://docs.unity3d.com/ScriptReference/GlobalObjectId.html"/>
+        /// Parameter 0 of <see cref="k_GlobalIdTemplate"/>
+        /// </summary>
+        // 0 = Null (when considered a null object type we can ignore)
+        // 1 = Imported Asset
+        // 2 = Scene Object
+        // 3 = Source Asset.
+        private const int k_NullObjectType = 0;
+        private const int k_ImportedAssetObjectType = 1;
+        private const int k_SceneObjectType = 2;
+        private const int k_SourceAssetObjectType = 3;
+
+        [ContextMenu("Refresh In-Scene Prefab Instances")]
+        internal void RefreshAllPrefabInstances()
         {
-            GenerateGlobalObjectIdHash();
+            var instanceGlobalId = GlobalObjectId.GetGlobalObjectIdSlow(this);
+            if (!PrefabUtility.IsPartOfAnyPrefab(this) || instanceGlobalId.identifierType != k_ImportedAssetObjectType)
+            {
+                EditorUtility.DisplayDialog("Network Prefab Assets Only", "This action can only be performed on a network prefab asset.", "Ok");
+                return;
+            }
+
+            // Handle updating the currently active scene
+            var networkObjects = FindObjectsByType<NetworkObject>(FindObjectsInactive.Include, FindObjectsSortMode.None);
+            foreach (var networkObject in networkObjects)
+            {
+                networkObject.OnValidate();
+            }
+            NetworkObjectRefreshTool.ProcessActiveScene();
+
+            // Refresh all build settings scenes
+            var activeScene = SceneManager.GetActiveScene();
+            foreach (var editorScene in EditorBuildSettings.scenes)
+            {
+                // skip disabled scenes and the currently active scene
+                if (!editorScene.enabled || activeScene.path == editorScene.path)
+                {
+                    continue;
+                }
+                // Add the scene to be processed
+                NetworkObjectRefreshTool.ProcessScene(editorScene.path, false);
+            }
+
+            // Process all added scenes
+            NetworkObjectRefreshTool.ProcessScenes();
         }
 
-        internal void GenerateGlobalObjectIdHash()
+        private void OnValidate()
         {
             // do NOT regenerate GlobalObjectIdHash for NetworkPrefabs while Editor is in PlayMode
-            if (UnityEditor.EditorApplication.isPlaying && !string.IsNullOrEmpty(gameObject.scene.name))
+            if (EditorApplication.isPlaying && !string.IsNullOrEmpty(gameObject.scene.name))
             {
                 return;
             }
 
             // do NOT regenerate GlobalObjectIdHash if Editor is transitioning into or out of PlayMode
-            if (!UnityEditor.EditorApplication.isPlaying && UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode)
+            if (!EditorApplication.isPlaying && EditorApplication.isPlayingOrWillChangePlaymode)
             {
                 return;
             }
 
-            var globalObjectIdString = UnityEditor.GlobalObjectId.GetGlobalObjectIdSlow(this).ToString();
-            GlobalObjectIdHash = XXHash.Hash32(globalObjectIdString);
+            // Get a global object identifier for this network prefab
+            var globalId = GetGlobalId();
+
+
+            // if the identifier type is 0, then don't update the GlobalObjectIdHash
+            if (globalId.identifierType == k_NullObjectType)
+            {
+                return;
+            }
+
+            var oldValue = GlobalObjectIdHash;
+            GlobalObjectIdHash = globalId.ToString().Hash32();
+
+            // If the GlobalObjectIdHash value changed, then mark the asset dirty
+            if (GlobalObjectIdHash != oldValue)
+            {
+                // Check if this is an in-scnee placed NetworkObject (Special Case for In-Scene Placed)
+                if (!IsEditingPrefab() && gameObject.scene.name != null && gameObject.scene.name != gameObject.name)
+                {
+                    // Sanity check to make sure this is a scene placed object
+                    if (globalId.identifierType != k_SceneObjectType)
+                    {
+                        // This should never happen, but in the event it does throw and error
+                        Debug.LogError($"[{gameObject.name}] is detected as an in-scene placed object but its identifier is of type {globalId.identifierType}! **Report this error**");
+                    }
+
+                    // If this is a prefab instance
+                    if (PrefabUtility.IsPartOfAnyPrefab(this))
+                    {
+                        // We must invoke this in order for the modifications to get saved with the scene (does not mark scene as dirty)
+                        PrefabUtility.RecordPrefabInstancePropertyModifications(this);
+                    }
+                }
+                else // Otherwise, this is a standard network prefab asset so we just mark it dirty for the AssetDatabase to update it
+                {
+                    EditorUtility.SetDirty(this);
+                }
+            }
+
+            // Always check for in-scene placed to assure any previous version scene assets with in-scene place NetworkObjects gets updated
+            CheckForInScenePlaced();
+        }
+
+        private bool IsEditingPrefab()
+        {
+            // Check if we are directly editing the prefab
+            var stage = PrefabStageUtility.GetPrefabStage(gameObject);
+
+            // if we are not editing the prefab directly (or a sub-prefab), then return the object identifier
+            if (stage == null || stage.assetPath == null)
+            {
+                return false;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// This checks to see if this NetworkObject is an in-scene placed prefab instance. If so it will 
+        /// automatically find the source prefab asset's GlobalObjectIdHash value, assign it to 
+        /// InScenePlacedSourceGlobalObjectIdHash and mark this as being in-scene placed.
+        /// </summary>
+        /// <remarks>
+        /// This NetworkObject is considered an in-scene placed prefab asset instance if it is:
+        /// - Part of a prefab
+        /// - Not being directly edited
+        /// - Within a valid scene that is part of the scenes in build list
+        /// (In-scene defined NetworkObjects that are not part of a prefab instance are excluded.)
+        /// </remarks>
+        private void CheckForInScenePlaced()
+        {
+            if (PrefabUtility.IsPartOfAnyPrefab(this) && !IsEditingPrefab() && gameObject.scene.IsValid() && gameObject.scene.isLoaded && gameObject.scene.buildIndex >= 0)
+            {
+                var prefab = PrefabUtility.GetCorrespondingObjectFromSource(gameObject);
+                var assetPath = AssetDatabase.GetAssetPath(prefab);
+                var sourceAsset = AssetDatabase.LoadAssetAtPath<NetworkObject>(assetPath);
+                if (sourceAsset != null && sourceAsset.GlobalObjectIdHash != 0 && InScenePlacedSourceGlobalObjectIdHash != sourceAsset.GlobalObjectIdHash)
+                {
+                    InScenePlacedSourceGlobalObjectIdHash = sourceAsset.GlobalObjectIdHash;
+                }
+                IsSceneObject = true;
+            }
+        }
+
+        private GlobalObjectId GetGlobalId()
+        {
+            var instanceGlobalId = GlobalObjectId.GetGlobalObjectIdSlow(this);
+
+            // If not editing a prefab, then just use the generated id
+            if (!IsEditingPrefab())
+            {
+                return instanceGlobalId;
+            }
+
+            // If the asset doesn't exist at the given path, then return the object identifier
+            var prefabStageAssetPath = PrefabStageUtility.GetPrefabStage(gameObject).assetPath;
+            // If (for some reason) the asset path is null return the generated id
+            if (prefabStageAssetPath == null)
+            {
+                return instanceGlobalId;
+            }
+
+            var theAsset = AssetDatabase.LoadAssetAtPath<NetworkObject>(prefabStageAssetPath);
+            // If there is no asset at that path (for some odd/edge case reason), return the generated id
+            if (theAsset == null)
+            {
+                return instanceGlobalId;
+            }
+
+            // If we can't get the asset GUID and/or the file identifier, then return the object identifier
+            if (!AssetDatabase.TryGetGUIDAndLocalFileIdentifier(theAsset, out var guid, out long localFileId))
+            {
+                return instanceGlobalId;
+            }
+
+            // Note: If we reached this point, then we are most likely opening a prefab to edit.
+            // The instanceGlobalId will be constructed as if it is a scene object, however when it
+            // is serialized its value will be treated as a file asset (the "why" to the below code).
+
+            // Construct an imported asset identifier with the type being a source asset object type
+            var prefabGlobalIdText = string.Format(k_GlobalIdTemplate, k_SourceAssetObjectType, guid, (ulong)localFileId, 0);
+
+            // If we can't parse the result log an error and return the instanceGlobalId
+            if (!GlobalObjectId.TryParse(prefabGlobalIdText, out var prefabGlobalId))
+            {
+                Debug.LogError($"[GlobalObjectId Gen] Failed to parse ({prefabGlobalIdText}) returning default ({instanceGlobalId})! ** Please Report This Error **");
+                return instanceGlobalId;
+            }
+
+            // Otherwise, return the constructed identifier for the source prefab asset
+            return prefabGlobalId;
         }
 #endif // UNITY_EDITOR
 
@@ -188,6 +376,12 @@ namespace Unity.Netcode
         /// </remarks>
         public Action OnMigratedToNewScene;
 
+        /// <summary>
+        /// When set to false, the NetworkObject will be spawned with no observers initially (other than the server)
+        /// </summary>
+        [Tooltip("When false, the NetworkObject will spawn with no observers initially. (default is true)")]
+        public bool SpawnWithObservers = true;
+
         /// <summary>
         /// Delegate type for checking visibility
         /// </summary>
@@ -318,6 +512,7 @@ namespace Unity.Netcode
 
         private void Awake()
         {
+            m_ChildNetworkBehaviours = null;
             SetCachedParent(transform.parent);
             SceneOrigin = gameObject.scene;
         }
@@ -361,8 +556,7 @@ namespace Unity.Netcode
                 }
                 return;
             }
-
-            NetworkManager.MarkObjectForShowingTo(this, clientId);
+            NetworkManager.SpawnManager.MarkObjectForShowingTo(this, clientId);
             Observers.Add(clientId);
         }
 
@@ -452,7 +646,7 @@ namespace Unity.Netcode
                 throw new VisibilityChangeException("Cannot hide an object from the server");
             }
 
-            if (!NetworkManager.RemoveObjectFromShowingTo(this, clientId))
+            if (!NetworkManager.SpawnManager.RemoveObjectFromShowingTo(this, clientId))
             {
                 if (!Observers.Contains(clientId))
                 {
@@ -466,7 +660,7 @@ namespace Unity.Netcode
                     DestroyGameObject = !IsSceneObject.Value
                 };
                 // Send destroy call
-                var size = NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientId);
+                var size = NetworkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientId);
                 NetworkManager.NetworkMetrics.TrackObjectDestroySent(clientId, this, size);
             }
         }
@@ -532,14 +726,30 @@ namespace Unity.Netcode
 
         private void OnDestroy()
         {
-            if (NetworkManager != null && NetworkManager.IsListening && NetworkManager.IsServer == false && IsSpawned &&
-                (IsSceneObject == null || (IsSceneObject.Value != true)))
+            // If no NetworkManager is assigned, then just exit early
+            if (!NetworkManager)
             {
-                throw new NotServerException($"Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call {nameof(Destroy)} or {nameof(Despawn)} on the server/host instead.");
+                return;
             }
 
-            if (NetworkManager != null && NetworkManager.SpawnManager != null &&
-                NetworkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
+            if (NetworkManager.IsListening && !NetworkManager.IsServer && IsSpawned &&
+                (IsSceneObject == null || (IsSceneObject.Value != true)))
+            {
+                // Clients should not despawn NetworkObjects while connected to a session, but we don't want to destroy the current call stack
+                // if this happens. Instead, we should just generate a network log error and exit early (as long as we are not shutting down).
+                if (!NetworkManager.ShutdownInProgress)
+                {
+                    // Since we still have a session connection, log locally and on the server to inform user of this issue.
+                    if (NetworkManager.LogLevel <= LogLevel.Error)
+                    {
+                        NetworkLog.LogErrorServer($"[Invalid Destroy][{gameObject.name}][NetworkObjectId:{NetworkObjectId}] Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call {nameof(Destroy)} or {nameof(Despawn)} on the server/host instead.");
+                    }
+                    return;
+                }
+                // Otherwise, clients can despawn NetworkObjects while shutting down and should not generate any messages when this happens
+            }
+
+            if (NetworkManager.SpawnManager != null && NetworkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
             {
                 if (this == networkObject)
                 {
@@ -549,7 +759,7 @@ namespace Unity.Netcode
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void SpawnInternal(bool destroyWithScene, ulong ownerClientId, bool playerObject)
+        internal void SpawnInternal(bool destroyWithScene, ulong ownerClientId, bool playerObject)
         {
             if (!NetworkManager.IsListening)
             {
@@ -572,6 +782,78 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// This invokes <see cref="NetworkSpawnManager.InstantiateAndSpawn(NetworkObject, ulong, bool, bool, bool, Vector3, Quaternion)"/>.
+        /// </summary>
+        /// <param name="networkPrefab">The NetworkPrefab to instantiate and spawn.</param>
+        /// <param name="networkManager">The local instance of the NetworkManager connected to an session in progress.</param>
+        /// <param name="ownerClientId">The owner of the <see cref="NetworkObject"/> instance (defaults to server).</param>
+        /// <param name="destroyWithScene">Whether the <see cref="NetworkObject"/> instance will be destroyed when the scene it is located within is unloaded (default is false).</param>
+        /// <param name="isPlayerObject">Whether the <see cref="NetworkObject"/> instance is a player object or not (default is false).</param>
+        /// <param name="forceOverride">Whether you want to force spawning the override when running as a host or server or if you want it to spawn the override for host mode and
+        /// the source prefab for server. If there is an override, clients always spawn that as opposed to the source prefab (defaults to false).  </param>
+        /// <param name="position">The starting poisiton of the <see cref="NetworkObject"/> instance.</param>
+        /// <param name="rotation">The starting rotation of the <see cref="NetworkObject"/> instance.</param>
+        /// <returns>The newly instantiated and spawned <see cref="NetworkObject"/> prefab instance.</returns>
+        public static NetworkObject InstantiateAndSpawn(GameObject networkPrefab, NetworkManager networkManager, ulong ownerClientId = NetworkManager.ServerClientId, bool destroyWithScene = false, bool isPlayerObject = false, bool forceOverride = false, Vector3 position = default, Quaternion rotation = default)
+        {
+            var networkObject = networkPrefab.GetComponent<NetworkObject>();
+            if (networkObject == null)
+            {
+                Debug.LogError($"The {nameof(NetworkPrefab)} {networkPrefab.name} does not have a {nameof(NetworkObject)} component!");
+                return null;
+            }
+            return networkObject.InstantiateAndSpawn(networkManager, ownerClientId, destroyWithScene, isPlayerObject, forceOverride, position, rotation);
+        }
+
+        /// <summary>
+        /// This invokes <see cref="NetworkSpawnManager.InstantiateAndSpawn(NetworkObject, ulong, bool, bool, bool, Vector3, Quaternion)"/>.
+        /// </summary>
+        /// <param name="networkManager">The local instance of the NetworkManager connected to an session in progress.</param>
+        /// <param name="ownerClientId">The owner of the <see cref="NetworkObject"/> instance (defaults to server).</param>
+        /// <param name="destroyWithScene">Whether the <see cref="NetworkObject"/> instance will be destroyed when the scene it is located within is unloaded (default is false).</param>
+        /// <param name="isPlayerObject">Whether the <see cref="NetworkObject"/> instance is a player object or not (default is false).</param>
+        /// <param name="forceOverride">Whether you want to force spawning the override when running as a host or server or if you want it to spawn the override for host mode and
+        /// the source prefab for server. If there is an override, clients always spawn that as opposed to the source prefab (defaults to false).  </param>
+        /// <param name="position">The starting poisiton of the <see cref="NetworkObject"/> instance.</param>
+        /// <param name="rotation">The starting rotation of the <see cref="NetworkObject"/> instance.</param>
+        /// <returns>The newly instantiated and spawned <see cref="NetworkObject"/> prefab instance.</returns>
+        public NetworkObject InstantiateAndSpawn(NetworkManager networkManager, ulong ownerClientId = NetworkManager.ServerClientId, bool destroyWithScene = false, bool isPlayerObject = false, bool forceOverride = false, Vector3 position = default, Quaternion rotation = default)
+        {
+            if (networkManager == null)
+            {
+                Debug.LogError(NetworkSpawnManager.InstantiateAndSpawnErrors[NetworkSpawnManager.InstantiateAndSpawnErrorTypes.NetworkManagerNull]);
+                return null;
+            }
+
+            if (!networkManager.IsListening)
+            {
+                Debug.LogError(NetworkSpawnManager.InstantiateAndSpawnErrors[NetworkSpawnManager.InstantiateAndSpawnErrorTypes.NoActiveSession]);
+                return null;
+            }
+
+            if (!networkManager.IsServer)
+            {
+                Debug.LogError(NetworkSpawnManager.InstantiateAndSpawnErrors[NetworkSpawnManager.InstantiateAndSpawnErrorTypes.NotAuthority]);
+                return null;
+            }
+
+            if (NetworkManager.ShutdownInProgress)
+            {
+                Debug.LogWarning(NetworkSpawnManager.InstantiateAndSpawnErrors[NetworkSpawnManager.InstantiateAndSpawnErrorTypes.InvokedWhenShuttingDown]);
+                return null;
+            }
+
+            // Verify it is actually a valid prefab
+            if (!NetworkManager.NetworkConfig.Prefabs.Contains(gameObject))
+            {
+                Debug.LogError(NetworkSpawnManager.InstantiateAndSpawnErrors[NetworkSpawnManager.InstantiateAndSpawnErrorTypes.NotRegisteredNetworkPrefab]);
+                return null;
+            }
+
+            return NetworkManager.SpawnManager.InstantiateAndSpawnNoParameterChecks(this, ownerClientId, destroyWithScene, isPlayerObject, forceOverride, position, rotation);
+        }
+
         /// <summary>
         /// Spawns this <see cref="NetworkObject"/> across the network. Can only be called from the Server
         /// </summary>
@@ -663,6 +945,21 @@ namespace Unity.Netcode
             }
         }
 
+        internal void InvokeOwnershipChanged(ulong previous, ulong next)
+        {
+            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
+            {
+                if (ChildNetworkBehaviours[i].gameObject.activeInHierarchy)
+                {
+                    ChildNetworkBehaviours[i].InternalOnOwnershipChanged(previous, next);
+                }
+                else
+                {
+                    Debug.LogWarning($"{ChildNetworkBehaviours[i].gameObject.name} is disabled! Netcode for GameObjects does not support disabled NetworkBehaviours! The {ChildNetworkBehaviours[i].GetType().Name} component was skipped during ownership assignment!");
+                }
+            }
+        }
+
         internal void InvokeBehaviourOnNetworkObjectParentChanged(NetworkObject parentNetworkObject)
         {
             for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
@@ -696,6 +993,11 @@ namespace Unity.Netcode
             m_CachedParent = parentTransform;
         }
 
+        internal Transform GetCachedParent()
+        {
+            return m_CachedParent;
+        }
+
         internal ulong? GetNetworkParenting() => m_LatestParent;
 
         internal void SetNetworkParenting(ulong? latestParent, bool worldPositionStays)
@@ -712,6 +1014,12 @@ namespace Unity.Netcode
         /// <returns>Whether or not reparenting was successful.</returns>
         public bool TrySetParent(Transform parent, bool worldPositionStays = true)
         {
+            // If we are removing ourself from a parent
+            if (parent == null)
+            {
+                return TrySetParent((NetworkObject)null, worldPositionStays);
+            }
+
             var networkObject = parent.GetComponent<NetworkObject>();
 
             // If the parent doesn't have a NetworkObjet then return false, otherwise continue trying to parent
@@ -777,20 +1085,21 @@ namespace Unity.Netcode
                 return false;
             }
 
-            if (!NetworkManager.IsServer)
+            if (!NetworkManager.IsServer && !NetworkManager.ShutdownInProgress)
             {
                 return false;
             }
 
-            if (!IsSpawned)
+            // If the parent is not null fail only if either of the two is true:
+            // - This instance is spawned and the parent is not.
+            // - This instance is not spawned and the parent is.
+            // Basically, don't allow parenting when either the child or parent is not spawned.
+            // Caveat: if the parent is null then we can allow parenting whether the instance is or is not spawned.
+            if (parent != null && (IsSpawned ^ parent.IsSpawned))
             {
                 return false;
             }
 
-            if (parent != null && !parent.IsSpawned)
-            {
-                return false;
-            }
             m_CachedWorldPositionStays = worldPositionStays;
 
             if (parent == null)
@@ -826,15 +1135,36 @@ namespace Unity.Netcode
 
             if (!NetworkManager.IsServer)
             {
-                transform.parent = m_CachedParent;
-                Debug.LogException(new NotServerException($"Only the server can reparent {nameof(NetworkObject)}s"));
+                // Log exception if we are a client and not shutting down.
+                if (!NetworkManager.ShutdownInProgress)
+                {
+                    transform.parent = m_CachedParent;
+                    Debug.LogException(new NotServerException($"Only the server can reparent {nameof(NetworkObject)}s"));
+                }
+                else // Otherwise, if we are removing a parent then go ahead and allow parenting to occur
+                if (transform.parent == null)
+                {
+                    m_LatestParent = null;
+                    m_CachedParent = null;
+                    InvokeBehaviourOnNetworkObjectParentChanged(null);
+                }
                 return;
             }
-
+            else // Otherwise, on the serer side if this instance is not spawned...
             if (!IsSpawned)
             {
-                transform.parent = m_CachedParent;
-                Debug.LogException(new SpawnStateException($"{nameof(NetworkObject)} can only be reparented after being spawned"));
+                // ,,,and we are removing the parent, then go ahead and allow parenting to occur
+                if (transform.parent == null)
+                {
+                    m_LatestParent = null;
+                    m_CachedParent = null;
+                    InvokeBehaviourOnNetworkObjectParentChanged(null);
+                }
+                else
+                {
+                    transform.parent = m_CachedParent;
+                    Debug.LogException(new SpawnStateException($"{nameof(NetworkObject)} can only be reparented after being spawned"));
+                }
                 return;
             }
             var removeParent = false;
@@ -898,7 +1228,7 @@ namespace Unity.Netcode
                     }
                 }
 
-                NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientIds, idx);
+                NetworkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientIds, idx);
             }
         }
 
@@ -912,7 +1242,7 @@ namespace Unity.Netcode
         // we call CheckOrphanChildren() method and quickly iterate over OrphanChildren set and see if we can reparent/adopt one.
         internal static HashSet<NetworkObject> OrphanChildren = new HashSet<NetworkObject>();
 
-        internal bool ApplyNetworkParenting(bool removeParent = false, bool ignoreNotSpawned = false)
+        internal bool ApplyNetworkParenting(bool removeParent = false, bool ignoreNotSpawned = false, bool orphanedChildPass = false)
         {
             if (!AutoObjectParentSync)
             {
@@ -1000,9 +1330,17 @@ namespace Unity.Netcode
             // If we made it here, then parent this instance under the parentObject
             var parentObject = NetworkManager.SpawnManager.SpawnedObjects[m_LatestParent.Value];
 
+            // If we are handling an orphaned child and its parent is orphaned too, then don't parent yet.
+            if (orphanedChildPass)
+            {
+                if (OrphanChildren.Contains(parentObject))
+                {
+                    return false;
+                }
+            }
+
             m_CachedParent = parentObject.transform;
             transform.SetParent(parentObject.transform, m_CachedWorldPositionStays);
-
             InvokeBehaviourOnNetworkObjectParentChanged(parentObject);
             return true;
         }
@@ -1012,7 +1350,7 @@ namespace Unity.Netcode
             var objectsToRemove = new List<NetworkObject>();
             foreach (var orphanObject in OrphanChildren)
             {
-                if (orphanObject.ApplyNetworkParenting())
+                if (orphanObject.ApplyNetworkParenting(orphanedChildPass: true))
                 {
                     objectsToRemove.Add(orphanObject);
                 }
@@ -1023,6 +1361,18 @@ namespace Unity.Netcode
             }
         }
 
+        internal void InvokeBehaviourNetworkPreSpawn()
+        {
+            var networkManager = NetworkManager;
+            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
+            {
+                if (ChildNetworkBehaviours[i].gameObject.activeInHierarchy)
+                {
+                    ChildNetworkBehaviours[i].NetworkPreSpawn(ref networkManager);
+                }
+            }
+        }
+
         internal void InvokeBehaviourNetworkSpawn()
         {
             NetworkManager.SpawnManager.UpdateOwnershipTable(this, OwnerClientId);
@@ -1047,6 +1397,42 @@ namespace Unity.Netcode
             }
         }
 
+        internal void InvokeBehaviourNetworkPostSpawn()
+        {
+            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
+            {
+                if (ChildNetworkBehaviours[i].gameObject.activeInHierarchy)
+                {
+                    ChildNetworkBehaviours[i].NetworkPostSpawn();
+                }
+            }
+        }
+
+
+        internal void InternalNetworkSessionSynchronized()
+        {
+            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
+            {
+                if (ChildNetworkBehaviours[i].gameObject.activeInHierarchy)
+                {
+                    ChildNetworkBehaviours[i].NetworkSessionSynchronized();
+                }
+            }
+        }
+
+        internal void InternalInSceneNetworkObjectsSpawned()
+        {
+            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
+            {
+                if (ChildNetworkBehaviours[i].gameObject.activeInHierarchy)
+                {
+                    ChildNetworkBehaviours[i].InSceneNetworkObjectsSpawned();
+                }
+            }
+        }
+
+
+
         internal void InvokeBehaviourNetworkDespawn()
         {
             NetworkManager.SpawnManager.UpdateOwnershipTable(this, OwnerClientId, true);
@@ -1163,7 +1549,7 @@ namespace Unity.Netcode
             return 0;
         }
 
-        internal NetworkBehaviour GetNetworkBehaviourAtOrderIndex(ushort index)
+        public NetworkBehaviour GetNetworkBehaviourAtOrderIndex(ushort index)
         {
             if (index >= ChildNetworkBehaviours.Count)
             {
@@ -1171,7 +1557,6 @@ namespace Unity.Netcode
                 {
                     NetworkLog.LogError($"{nameof(NetworkBehaviour)} index {index} was out of bounds for {name}. NetworkBehaviours must be the same, and in the same order, between server and client.");
                 }
-
                 if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
                 {
                     var currentKnownChildren = new System.Text.StringBuilder();
@@ -1184,7 +1569,6 @@ namespace Unity.Netcode
                     }
                     NetworkLog.LogInfo(currentKnownChildren.ToString());
                 }
-
                 return null;
             }
 
@@ -1475,6 +1859,12 @@ namespace Unity.Netcode
                 var syncRotationPositionLocalSpaceRelative = obj.HasParent && !m_CachedWorldPositionStays;
                 var syncScaleLocalSpaceRelative = obj.HasParent && !m_CachedWorldPositionStays;
 
+                // Always synchronize in-scene placed object's scale using local space
+                if (obj.IsSceneObject)
+                {
+                    syncScaleLocalSpaceRelative = obj.HasParent;
+                }
+
                 // If auto object synchronization is turned off
                 if (!AutoObjectParentSync)
                 {
@@ -1486,7 +1876,6 @@ namespace Unity.Netcode
                     syncScaleLocalSpaceRelative = obj.HasParent;
                 }
 
-
                 obj.Transform = new SceneObject.TransformData
                 {
                     // If we are parented and we have the m_CachedWorldPositionStays disabled, then use local space
@@ -1546,6 +1935,9 @@ namespace Unity.Netcode
             // in order to be able to determine which NetworkVariables the client will be allowed to read.
             networkObject.OwnerClientId = sceneObject.OwnerClientId;
 
+            // Special Case: Invoke NetworkBehaviour.OnPreSpawn methods here before SynchronizeNetworkBehaviours
+            networkObject.InvokeBehaviourNetworkPreSpawn();
+
             // Synchronize NetworkBehaviours
             var bufferSerializer = new BufferSerializer<BufferSerializerReader>(new BufferSerializerReader(reader));
             networkObject.SynchronizeNetworkBehaviours(ref bufferSerializer, networkManager.LocalClientId);
@@ -1679,16 +2071,39 @@ namespace Unity.Netcode
         /// <returns></returns>
         internal uint HostCheckForGlobalObjectIdHashOverride()
         {
-            if (NetworkManager.IsHost)
+            if (NetworkManager.IsServer)
             {
                 if (NetworkManager.PrefabHandler.ContainsHandler(this))
                 {
                     var globalObjectIdHash = NetworkManager.PrefabHandler.GetSourceGlobalObjectIdHash(GlobalObjectIdHash);
                     return globalObjectIdHash == 0 ? GlobalObjectIdHash : globalObjectIdHash;
                 }
-                if (NetworkManager.NetworkConfig.Prefabs.OverrideToNetworkPrefab.TryGetValue(GlobalObjectIdHash, out uint hash))
+
+                // If scene management is disabled and this is an in-scene placed NetworkObject then go ahead
+                // and send the InScenePlacedSourcePrefab's GlobalObjectIdHash value (i.e. what to dynamically spawn)
+                if (!NetworkManager.NetworkConfig.EnableSceneManagement && IsSceneObject.Value && InScenePlacedSourceGlobalObjectIdHash != 0)
                 {
-                    return hash;
+                    return InScenePlacedSourceGlobalObjectIdHash;
+                }
+
+                // If the PrefabGlobalObjectIdHash is a non-zero value and the GlobalObjectIdHash value is
+                // different from the PrefabGlobalObjectIdHash value, then the NetworkObject instance is
+                // an override for the original network prefab (i.e. PrefabGlobalObjectIdHash)
+                if (!IsSceneObject.Value && GlobalObjectIdHash != PrefabGlobalObjectIdHash)
+                {
+                    // If the PrefabGlobalObjectIdHash is already populated (i.e. InstantiateAndSpawn used), then return this
+                    if (PrefabGlobalObjectIdHash != 0)
+                    {
+                        return PrefabGlobalObjectIdHash;
+                    }
+                    else
+                    {
+                        // For legacy manual instantiation and spawning, check the OverrideToNetworkPrefab for a possible match
+                        if (NetworkManager.NetworkConfig.Prefabs.OverrideToNetworkPrefab.ContainsKey(GlobalObjectIdHash))
+                        {
+                            return NetworkManager.NetworkConfig.Prefabs.OverrideToNetworkPrefab[GlobalObjectIdHash];
+                        }
+                    }
                 }
             }
 

Runtime/Core/NetworkObjectRefreshTool.cs

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

Runtime/Core/NetworkObjectRefreshTool.cs.meta

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

Runtime/Core/NetworkUpdateLoop.cs

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

Runtime/Logging/NetworkLog.cs

@@ -51,35 +51,58 @@ namespace Unity.Netcode
         /// <param name="message">The message to log</param>
         public static void LogErrorServer(string message) => LogServer(message, LogType.Error);
 
+        internal static NetworkManager NetworkManagerOverride;
+
         private static void LogServer(string message, LogType logType)
         {
+            var networkManager = NetworkManagerOverride ??= NetworkManager.Singleton;
             // Get the sender of the local log
-            ulong localId = NetworkManager.Singleton != null ? NetworkManager.Singleton.LocalClientId : 0;
-
+            ulong localId = networkManager?.LocalClientId ?? 0;
+            bool isServer = networkManager?.IsServer ?? true;
             switch (logType)
             {
                 case LogType.Info:
-                    LogInfoServerLocal(message, localId);
+                    if (isServer)
+                    {
+                        LogInfoServerLocal(message, localId);
+                    }
+                    else
+                    {
+                        LogInfo(message);
+                    }
                     break;
                 case LogType.Warning:
-                    LogWarningServerLocal(message, localId);
+                    if (isServer)
+                    {
+                        LogWarningServerLocal(message, localId);
+                    }
+                    else
+                    {
+                        LogWarning(message);
+                    }
                     break;
                 case LogType.Error:
-                    LogErrorServerLocal(message, localId);
+                    if (isServer)
+                    {
+                        LogErrorServerLocal(message, localId);
+                    }
+                    else
+                    {
+                        LogError(message);
+                    }
                     break;
             }
 
-            if (NetworkManager.Singleton != null && !NetworkManager.Singleton.IsServer && NetworkManager.Singleton.NetworkConfig.EnableNetworkLogs)
+            if (!isServer && networkManager.NetworkConfig.EnableNetworkLogs)
             {
-
                 var networkMessage = new ServerLogMessage
                 {
                     LogType = logType,
                     Message = message
                 };
-                var size = NetworkManager.Singleton.SendMessage(ref networkMessage, NetworkDelivery.ReliableFragmentedSequenced, NetworkManager.ServerClientId);
+                var size = networkManager.ConnectionManager.SendMessage(ref networkMessage, NetworkDelivery.ReliableFragmentedSequenced, NetworkManager.ServerClientId);
 
-                NetworkManager.Singleton.NetworkMetrics.TrackServerLogSent(NetworkManager.ServerClientId, (uint)logType, size);
+                networkManager.NetworkMetrics.TrackServerLogSent(NetworkManager.ServerClientId, (uint)logType, size);
             }
         }
 

Runtime/Messaging/CustomMessageManager.cs

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

Runtime/Messaging/DefaultMessageSender.cs

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

Runtime/Messaging/DefaultMessageSender.cs.meta

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

Runtime/Messaging/DeferredMessageManager.cs

@@ -3,12 +3,12 @@ using Unity.Collections;
 
 namespace Unity.Netcode
 {
-    internal class DeferredMessageManager : IDeferredMessageManager
+    internal class DeferredMessageManager : IDeferredNetworkMessageManager
     {
         protected struct TriggerData
         {
             public FastBufferReader Reader;
-            public MessageHeader Header;
+            public NetworkMessageHeader Header;
             public ulong SenderId;
             public float Timestamp;
             public int SerializedHeaderSize;
@@ -19,7 +19,7 @@ namespace Unity.Netcode
             public NativeList<TriggerData> TriggerData;
         }
 
-        protected readonly Dictionary<IDeferredMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>> m_Triggers = new Dictionary<IDeferredMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>>();
+        protected readonly Dictionary<IDeferredNetworkMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>> m_Triggers = new Dictionary<IDeferredNetworkMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>>();
 
         private readonly NetworkManager m_NetworkManager;
 
@@ -36,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(IDeferredMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context)
+        public virtual unsafe void DeferMessage(IDeferredNetworkMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context)
         {
             if (!m_Triggers.TryGetValue(trigger, out var triggers))
             {
@@ -90,7 +90,7 @@ namespace Unity.Netcode
             }
         }
 
-        protected virtual void PurgeTrigger(IDeferredMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo)
+        protected virtual void PurgeTrigger(IDeferredNetworkMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo)
         {
             if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
             {
@@ -105,7 +105,7 @@ namespace Unity.Netcode
             triggerInfo.TriggerData.Dispose();
         }
 
-        public virtual void ProcessTriggers(IDeferredMessageManager.TriggerType trigger, ulong key)
+        public virtual void ProcessTriggers(IDeferredNetworkMessageManager.TriggerType trigger, ulong key)
         {
             if (m_Triggers.TryGetValue(trigger, out var triggers))
             {
@@ -113,14 +113,14 @@ namespace Unity.Netcode
                 // processed before the object is fully spawned. This must be the last thing done in the spawn process.
                 if (triggers.TryGetValue(key, out var triggerInfo))
                 {
+                    triggers.Remove(key);
                     foreach (var deferredMessage in triggerInfo.TriggerData)
                     {
                         // Reader will be disposed within HandleMessage
-                        m_NetworkManager.MessagingSystem.HandleMessage(deferredMessage.Header, deferredMessage.Reader, deferredMessage.SenderId, deferredMessage.Timestamp, deferredMessage.SerializedHeaderSize);
+                        m_NetworkManager.ConnectionManager.MessageManager.HandleMessage(deferredMessage.Header, deferredMessage.Reader, deferredMessage.SenderId, deferredMessage.Timestamp, deferredMessage.SerializedHeaderSize);
                     }
 
                     triggerInfo.TriggerData.Dispose();
-                    triggers.Remove(key);
                 }
             }
         }

Runtime/Messaging/DisconnectReasonMessage.cs

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

Runtime/Messaging/GenerateSerializationForGenericParameterAttribute.cs

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

Runtime/Messaging/GenerateSerializationForGenericParameterAttribute.cs.meta

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

Runtime/Messaging/GenerateSerializationForTypeAttribute.cs

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

Runtime/Messaging/GenerateSerializationForTypeAttribute.cs.meta

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

Runtime/Messaging/IDeferredNetworkMessageManager.cs

@@ -1,11 +1,12 @@
 namespace Unity.Netcode
 {
-    internal interface IDeferredMessageManager
+    internal interface IDeferredNetworkMessageManager
     {
         internal enum TriggerType
         {
             OnSpawn,
             OnAddPrefab,
+            OnNextFrame,
         }
 
         /// <summary>

Runtime/Messaging/ILPPMessageProvider.cs

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

Runtime/Messaging/IMessageProvider.cs

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

Runtime/Messaging/INetworkMessage.cs

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

Runtime/Messaging/INetworkMessageProvider.cs

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

Runtime/Messaging/INetworkMessageSender.cs

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

Runtime/Messaging/Messages/AnticipationCounterSync.cs

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

Runtime/Messaging/Messages/AnticipationCounterSync.cs.meta

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

Runtime/Messaging/Messages/ChangeOwnershipMessage.cs

@@ -24,7 +24,7 @@ namespace Unity.Netcode
             ByteUnpacker.ReadValueBitPacked(reader, out OwnerClientId);
             if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
                 return false;
             }
 
@@ -60,6 +60,8 @@ namespace Unity.Netcode
                 }
             }
 
+            networkObject.InvokeOwnershipChanged(originalOwner, OwnerClientId);
+
             networkManager.NetworkMetrics.TrackOwnershipChangeReceived(context.SenderId, networkObject, context.MessageSize);
         }
     }

Runtime/Messaging/Messages/ClientConnectedMessage.cs

@@ -0,0 +1,35 @@
+namespace Unity.Netcode
+{
+    internal struct ClientConnectedMessage : INetworkMessage, INetworkSerializeByMemcpy
+    {
+        public int Version => 0;
+
+        public ulong ClientId;
+
+        public void Serialize(FastBufferWriter writer, int targetVersion)
+        {
+            BytePacker.WriteValueBitPacked(writer, ClientId);
+        }
+
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            if (!networkManager.IsClient)
+            {
+                return false;
+            }
+            ByteUnpacker.ReadValueBitPacked(reader, out ClientId);
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            networkManager.ConnectionManager.ConnectedClientIds.Add(ClientId);
+            if (networkManager.IsConnectedClient)
+            {
+                networkManager.ConnectionManager.InvokeOnPeerConnectedCallback(ClientId);
+            }
+        }
+    }
+}

Runtime/Messaging/Messages/ClientConnectedMessage.cs.meta

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

Runtime/Messaging/Messages/ClientDisconnectedMessage.cs

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

Runtime/Messaging/Messages/ClientDisconnectedMessage.cs.meta

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

Runtime/Messaging/Messages/ConnectionApprovedMessage.cs

@@ -5,7 +5,8 @@ namespace Unity.Netcode
 {
     internal struct ConnectionApprovedMessage : INetworkMessage
     {
-        public int Version => 0;
+        private const int k_VersionAddClientIds = 1;
+        public int Version => k_VersionAddClientIds;
 
         public ulong OwnerClientId;
         public int NetworkTick;
@@ -17,6 +18,8 @@ namespace Unity.Netcode
 
         public NativeArray<MessageVersionData> MessageVersions;
 
+        public NativeArray<ulong> ConnectedClientIds;
+
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
             // ============================================================
@@ -36,7 +39,15 @@ namespace Unity.Netcode
             BytePacker.WriteValueBitPacked(writer, OwnerClientId);
             BytePacker.WriteValueBitPacked(writer, NetworkTick);
 
+            if (targetVersion >= k_VersionAddClientIds)
+            {
+                writer.WriteValueSafe(ConnectedClientIds);
+            }
+
             uint sceneObjectCount = 0;
+
+            // When SpawnedObjectsList is not null then scene management is disabled. Provide a list of
+            // all observed and spawned NetworkObjects that the approved client needs to synchronize.
             if (SpawnedObjectsList != null)
             {
                 var pos = writer.Position;
@@ -45,7 +56,7 @@ namespace Unity.Netcode
                 // Serialize NetworkVariable data
                 foreach (var sobj in SpawnedObjectsList)
                 {
-                    if (sobj.CheckObjectVisibility == null || sobj.CheckObjectVisibility(OwnerClientId))
+                    if (sobj.SpawnWithObservers && (sobj.CheckObjectVisibility == null || sobj.CheckObjectVisibility(OwnerClientId)))
                     {
                         sobj.Observers.Add(OwnerClientId);
                         var sceneObject = sobj.GetMessageSceneObject(OwnerClientId);
@@ -84,18 +95,18 @@ namespace Unity.Netcode
             {
                 var messageVersion = new MessageVersionData();
                 messageVersion.Deserialize(reader);
-                networkManager.MessagingSystem.SetVersion(context.SenderId, messageVersion.Hash, messageVersion.Version);
+                networkManager.ConnectionManager.MessageManager.SetVersion(context.SenderId, messageVersion.Hash, messageVersion.Version);
                 messageHashesInOrder[i] = messageVersion.Hash;
 
                 // Update the received version since this message will always be passed version 0, due to the map not
                 // being initialized until just now.
-                var messageType = networkManager.MessagingSystem.GetMessageForHash(messageVersion.Hash);
+                var messageType = networkManager.ConnectionManager.MessageManager.GetMessageForHash(messageVersion.Hash);
                 if (messageType == typeof(ConnectionApprovedMessage))
                 {
                     receivedMessageVersion = messageVersion.Version;
                 }
             }
-            networkManager.MessagingSystem.SetServerMessageOrder(messageHashesInOrder);
+            networkManager.ConnectionManager.MessageManager.SetServerMessageOrder(messageHashesInOrder);
             messageHashesInOrder.Dispose();
             // ============================================================
             // END FORBIDDEN SEGMENT
@@ -103,6 +114,16 @@ namespace Unity.Netcode
 
             ByteUnpacker.ReadValueBitPacked(reader, out OwnerClientId);
             ByteUnpacker.ReadValueBitPacked(reader, out NetworkTick);
+
+            if (receivedMessageVersion >= k_VersionAddClientIds)
+            {
+                reader.ReadValueSafe(out ConnectedClientIds, Allocator.TempJob);
+            }
+            else
+            {
+                ConnectedClientIds = new NativeArray<ulong>(0, Allocator.TempJob);
+            }
+
             m_ReceivedSceneObjectData = reader;
             return true;
         }
@@ -111,14 +132,24 @@ namespace Unity.Netcode
         {
             var networkManager = (NetworkManager)context.SystemOwner;
             networkManager.LocalClientId = OwnerClientId;
+            networkManager.MessageManager.SetLocalClientId(networkManager.LocalClientId);
             networkManager.NetworkMetrics.SetConnectionId(networkManager.LocalClientId);
 
             var time = new NetworkTime(networkManager.NetworkTickSystem.TickRate, NetworkTick);
             networkManager.NetworkTimeSystem.Reset(time.Time, 0.15f); // Start with a constant RTT of 150 until we receive values from the transport.
             networkManager.NetworkTickSystem.Reset(networkManager.NetworkTimeSystem.LocalTime, networkManager.NetworkTimeSystem.ServerTime);
 
-            networkManager.LocalClient = new NetworkClient() { ClientId = networkManager.LocalClientId };
-            networkManager.IsApproved = true;
+            networkManager.ConnectionManager.LocalClient.SetRole(false, true, networkManager);
+            networkManager.ConnectionManager.LocalClient.IsApproved = true;
+            networkManager.ConnectionManager.LocalClient.ClientId = OwnerClientId;
+            // Stop the client-side approval timeout coroutine since we are approved.
+            networkManager.ConnectionManager.StopClientApprovalCoroutine();
+
+            networkManager.ConnectionManager.ConnectedClientIds.Clear();
+            foreach (var clientId in ConnectedClientIds)
+            {
+                networkManager.ConnectionManager.ConnectedClientIds.Add(clientId);
+            }
 
             // Only if scene management is disabled do we handle NetworkObject synchronization at this point
             if (!networkManager.NetworkConfig.EnableSceneManagement)
@@ -138,8 +169,16 @@ namespace Unity.Netcode
                 // Mark the client being connected
                 networkManager.IsConnectedClient = true;
                 // When scene management is disabled we notify after everything is synchronized
-                networkManager.InvokeOnClientConnectedCallback(context.SenderId);
+                networkManager.ConnectionManager.InvokeOnClientConnectedCallback(context.SenderId);
+
+                // For convenience, notify all NetworkBehaviours that synchronization is complete.
+                foreach (var networkObject in networkManager.SpawnManager.SpawnedObjectsList)
+                {
+                    networkObject.InternalNetworkSessionSynchronized();
+                }
             }
+
+            ConnectedClientIds.Dispose();
         }
     }
 }

Runtime/Messaging/Messages/ConnectionRequestMessage.cs

@@ -59,11 +59,11 @@ namespace Unity.Netcode
             {
                 var messageVersion = new MessageVersionData();
                 messageVersion.Deserialize(reader);
-                networkManager.MessagingSystem.SetVersion(context.SenderId, messageVersion.Hash, messageVersion.Version);
+                networkManager.ConnectionManager.MessageManager.SetVersion(context.SenderId, messageVersion.Hash, messageVersion.Version);
 
                 // Update the received version since this message will always be passed version 0, due to the map not
                 // being initialized until just now.
-                var messageType = networkManager.MessagingSystem.GetMessageForHash(messageVersion.Hash);
+                var messageType = networkManager.ConnectionManager.MessageManager.GetMessageForHash(messageVersion.Hash);
                 if (messageType == typeof(ConnectionRequestMessage))
                 {
                     receivedMessageVersion = messageVersion.Version;
@@ -135,7 +135,7 @@ namespace Unity.Netcode
             var networkManager = (NetworkManager)context.SystemOwner;
             var senderId = context.SenderId;
 
-            if (networkManager.PendingClients.TryGetValue(senderId, out PendingClient client))
+            if (networkManager.ConnectionManager.PendingClients.TryGetValue(senderId, out PendingClient client))
             {
                 // Set to pending approval to prevent future connection requests from being approved
                 client.ConnectionState = PendingClient.State.PendingApproval;
@@ -143,17 +143,8 @@ namespace Unity.Netcode
 
             if (networkManager.NetworkConfig.ConnectionApproval)
             {
-                // Note: Delegate creation allocates.
-                // Note: ToArray() also allocates. :(
-                var response = new NetworkManager.ConnectionApprovalResponse();
-                networkManager.ClientsToApprove[senderId] = response;
-
-                networkManager.ConnectionApprovalCallback(
-                    new NetworkManager.ConnectionApprovalRequest
-                    {
-                        Payload = ConnectionData,
-                        ClientNetworkId = senderId
-                    }, response);
+                var messageRequest = this;
+                networkManager.ConnectionManager.ApproveConnection(ref messageRequest, ref context);
             }
             else
             {
@@ -162,7 +153,7 @@ namespace Unity.Netcode
                     Approved = true,
                     CreatePlayerObject = networkManager.NetworkConfig.PlayerPrefab != null
                 };
-                networkManager.HandleConnectionApproval(senderId, response);
+                networkManager.ConnectionManager.HandleConnectionApproval(senderId, response);
             }
         }
     }

Runtime/Messaging/Messages/CreateObjectMessage.cs

@@ -1,3 +1,4 @@
+using System.Runtime.CompilerServices;
 namespace Unity.Netcode
 {
     internal struct CreateObjectMessage : INetworkMessage
@@ -23,7 +24,7 @@ namespace Unity.Netcode
             ObjectInfo.Deserialize(reader);
             if (!networkManager.NetworkConfig.ForceSamePrefabs && !networkManager.SpawnManager.HasPrefab(ObjectInfo))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context);
                 return false;
             }
             m_ReceivedNetworkVariableData = reader;
@@ -34,9 +35,29 @@ namespace Unity.Netcode
         public void Handle(ref NetworkContext context)
         {
             var networkManager = (NetworkManager)context.SystemOwner;
-            var networkObject = NetworkObject.AddSceneObject(ObjectInfo, m_ReceivedNetworkVariableData, networkManager);
+            // If a client receives a create object message and it is still synchronizing, then defer the object creation until it has finished synchronizing
+            if (networkManager.SceneManager.ShouldDeferCreateObject())
+            {
+                networkManager.SceneManager.DeferCreateObject(context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData);
+            }
+            else
+            {
+                CreateObject(ref networkManager, context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData);
+            }
+        }
 
-            networkManager.NetworkMetrics.TrackObjectSpawnReceived(context.SenderId, networkObject, context.MessageSize);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static void CreateObject(ref NetworkManager networkManager, ulong senderId, uint messageSize, NetworkObject.SceneObject sceneObject, FastBufferReader networkVariableData)
+        {
+            try
+            {
+                var networkObject = NetworkObject.AddSceneObject(sceneObject, networkVariableData, networkManager);
+                networkManager.NetworkMetrics.TrackObjectSpawnReceived(senderId, networkObject, messageSize);
+            }
+            catch (System.Exception ex)
+            {
+                UnityEngine.Debug.LogException(ex);
+            }
         }
     }
 }

Runtime/Messaging/Messages/DestroyObjectMessage.cs

@@ -26,7 +26,7 @@ namespace Unity.Netcode
 
             if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
                 return false;
             }
             return true;

Runtime/Messaging/Messages/NamedMessage.cs

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

Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs

@@ -30,6 +30,9 @@ namespace Unity.Netcode
                 throw new OverflowException($"Not enough space in the buffer to write {nameof(NetworkVariableDeltaMessage)}");
             }
 
+            var obj = NetworkBehaviour.NetworkObject;
+            var networkManager = obj.NetworkManagerOwner;
+
             BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
             BytePacker.WriteValueBitPacked(writer, NetworkBehaviourIndex);
 
@@ -38,7 +41,7 @@ namespace Unity.Netcode
                 if (!DeliveryMappedNetworkVariableIndex.Contains(i))
                 {
                     // This var does not belong to the currently iterating delivery group.
-                    if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                    if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                     {
                         BytePacker.WriteValueBitPacked(writer, (ushort)0);
                     }
@@ -52,9 +55,11 @@ namespace Unity.Netcode
 
                 var startingSize = writer.Length;
                 var networkVariable = NetworkBehaviour.NetworkVariableFields[i];
+
                 var shouldWrite = networkVariable.IsDirty() &&
                     networkVariable.CanClientRead(TargetClientId) &&
-                    (NetworkBehaviour.NetworkManager.IsServer || networkVariable.CanClientWrite(NetworkBehaviour.NetworkManager.LocalClientId));
+                    (networkManager.IsServer || networkVariable.CanClientWrite(networkManager.LocalClientId)) &&
+                    networkVariable.CanSend();
 
                 // Prevent the server from writing to the client that owns a given NetworkVariable
                 // Allowing the write would send an old value to the client and cause jitter
@@ -67,14 +72,14 @@ namespace Unity.Netcode
                 // The object containing the behaviour we're about to process is about to be shown to this client
                 // As a result, the client will get the fully serialized NetworkVariable and would be confused by
                 // an extraneous delta
-                if (NetworkBehaviour.NetworkManager.ObjectsToShowToClient.ContainsKey(TargetClientId) &&
-                    NetworkBehaviour.NetworkManager.ObjectsToShowToClient[TargetClientId]
-                    .Contains(NetworkBehaviour.NetworkObject))
+                if (networkManager.SpawnManager.ObjectsToShowToClient.ContainsKey(TargetClientId) &&
+                    networkManager.SpawnManager.ObjectsToShowToClient[TargetClientId]
+                    .Contains(obj))
                 {
                     shouldWrite = false;
                 }
 
-                if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                 {
                     if (!shouldWrite)
                     {
@@ -88,9 +93,9 @@ namespace Unity.Netcode
 
                 if (shouldWrite)
                 {
-                    if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
+                    if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                     {
-                        var tempWriter = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, MessagingSystem.FRAGMENTED_MESSAGE_MAX_SIZE);
+                        var tempWriter = new FastBufferWriter(networkManager.MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp, networkManager.MessageManager.FragmentedMessageMaxSize);
                         NetworkBehaviour.NetworkVariableFields[i].WriteDelta(tempWriter);
                         BytePacker.WriteValueBitPacked(writer, tempWriter.Length);
 
@@ -105,10 +110,9 @@ namespace Unity.Netcode
                     {
                         networkVariable.WriteDelta(writer);
                     }
-
-                    NetworkBehaviour.NetworkManager.NetworkMetrics.TrackNetworkVariableDeltaSent(
+                    networkManager.NetworkMetrics.TrackNetworkVariableDeltaSent(
                         TargetClientId,
-                        NetworkBehaviour.NetworkObject,
+                        obj,
                         networkVariable.Name,
                         NetworkBehaviour.__getTypeName(),
                         writer.Length - startingSize);
@@ -207,7 +211,6 @@ namespace Unity.Netcode
                             networkBehaviour.__getTypeName(),
                             context.MessageSize);
 
-
                         if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                         {
                             if (m_ReceivedNetworkVariableData.Position > (readStartPos + varSize))
@@ -234,7 +237,7 @@ namespace Unity.Netcode
             }
             else
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, m_ReceivedNetworkVariableData, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, m_ReceivedNetworkVariableData, ref context);
             }
         }
     }

Runtime/Messaging/Messages/ParentSyncMessage.cs

@@ -85,7 +85,7 @@ namespace Unity.Netcode
 
             if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
                 return false;
             }
             return true;

Runtime/Messaging/Messages/ProxyMessage.cs

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

Runtime/Messaging/Messages/ProxyMessage.cs.meta

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

Runtime/Messaging/Messages/RpcMessages.cs

@@ -23,7 +23,7 @@ namespace Unity.Netcode
             var networkManager = (NetworkManager)context.SystemOwner;
             if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(metadata.NetworkObjectId))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, metadata.NetworkObjectId, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, metadata.NetworkObjectId, reader, ref context);
                 return false;
             }
 
@@ -34,15 +34,15 @@ namespace Unity.Netcode
                 return false;
             }
 
-            if (!NetworkManager.__rpc_func_table.ContainsKey(metadata.NetworkRpcMethodId))
+            if (!NetworkBehaviour.__rpc_func_table[networkBehaviour.GetType()].ContainsKey(metadata.NetworkRpcMethodId))
             {
                 return false;
             }
 
             payload = new FastBufferReader(reader.GetUnsafePtrAtCurrentPosition(), Allocator.None, reader.Length - reader.Position);
 
-#if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (NetworkManager.__rpc_name_table.TryGetValue(metadata.NetworkRpcMethodId, out var rpcMethodName))
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || UNITY_MP_TOOLS_NET_STATS_MONITOR_ENABLED_IN_RELEASE
+            if (NetworkBehaviour.__rpc_name_table[networkBehaviour.GetType()].TryGetValue(metadata.NetworkRpcMethodId, out var rpcMethodName))
             {
                 networkManager.NetworkMetrics.TrackRpcReceived(
                     context.SenderId,
@@ -67,11 +67,19 @@ namespace Unity.Netcode
 
             try
             {
-                NetworkManager.__rpc_func_table[metadata.NetworkRpcMethodId](networkBehaviour, payload, rpcParams);
+                NetworkBehaviour.__rpc_func_table[networkBehaviour.GetType()][metadata.NetworkRpcMethodId](networkBehaviour, payload, rpcParams);
             }
             catch (Exception ex)
             {
                 Debug.LogException(new Exception("Unhandled RPC exception!", ex));
+                if (networkManager.LogLevel == LogLevel.Developer)
+                {
+                    Debug.Log($"RPC Table Contents");
+                    foreach (var entry in NetworkBehaviour.__rpc_func_table[networkBehaviour.GetType()])
+                    {
+                        Debug.Log($"{entry.Key} | {entry.Value.Method.Name}");
+                    }
+                }
             }
         }
     }
@@ -151,4 +159,42 @@ namespace Unity.Netcode
             RpcMessageHelpers.Handle(ref context, ref Metadata, ref ReadBuffer, ref rpcParams);
         }
     }
+
+    internal struct RpcMessage : INetworkMessage
+    {
+        public int Version => 0;
+
+        public RpcMetadata Metadata;
+        public ulong SenderClientId;
+
+        public FastBufferWriter WriteBuffer;
+        public FastBufferReader ReadBuffer;
+
+        public unsafe void Serialize(FastBufferWriter writer, int targetVersion)
+        {
+            BytePacker.WriteValuePacked(writer, SenderClientId);
+            RpcMessageHelpers.Serialize(ref writer, ref Metadata, ref WriteBuffer);
+        }
+
+        public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+        {
+            ByteUnpacker.ReadValuePacked(reader, out SenderClientId);
+            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer);
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            var rpcParams = new __RpcParams
+            {
+                Ext = new RpcParams
+                {
+                    Receive = new RpcReceiveParams
+                    {
+                        SenderClientId = SenderClientId
+                    }
+                }
+            };
+            RpcMessageHelpers.Handle(ref context, ref Metadata, ref ReadBuffer, ref rpcParams);
+        }
+    }
 }

Runtime/Messaging/NetworkBatchHeader.cs

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

Runtime/Messaging/NetworkContext.cs

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

Runtime/Messaging/NetworkManagerHooks.cs

@@ -0,0 +1,146 @@
+using System;
+using Unity.Netcode.Transports.UTP;
+
+namespace Unity.Netcode
+{
+    internal class NetworkManagerHooks : INetworkHooks
+    {
+        private NetworkManager m_NetworkManager;
+
+        internal NetworkManagerHooks(NetworkManager manager)
+        {
+            m_NetworkManager = manager;
+        }
+
+        public void OnBeforeSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery) where T : INetworkMessage
+        {
+        }
+
+        public void OnAfterSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery, int messageSizeBytes) where T : INetworkMessage
+        {
+        }
+
+        public void OnBeforeReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes)
+        {
+        }
+
+        public void OnAfterReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes)
+        {
+        }
+
+        public void OnBeforeSendBatch(ulong clientId, int messageCount, int batchSizeInBytes, NetworkDelivery delivery)
+        {
+        }
+
+        public void OnAfterSendBatch(ulong clientId, int messageCount, int batchSizeInBytes, NetworkDelivery delivery)
+        {
+        }
+
+        public void OnBeforeReceiveBatch(ulong senderId, int messageCount, int batchSizeInBytes)
+        {
+        }
+
+        public void OnAfterReceiveBatch(ulong senderId, int messageCount, int batchSizeInBytes)
+        {
+        }
+
+        public bool OnVerifyCanSend(ulong destinationId, Type messageType, NetworkDelivery delivery)
+        {
+            return !m_NetworkManager.MessageManager.StopProcessing;
+        }
+
+        public bool OnVerifyCanReceive(ulong senderId, Type messageType, FastBufferReader messageContent, ref NetworkContext context)
+        {
+            if (m_NetworkManager.IsServer)
+            {
+                if (messageType == typeof(ConnectionApprovedMessage))
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    {
+                        var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
+                        NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side. {transportErrorMsg}");
+                    }
+
+                    return false;
+                }
+
+                if (m_NetworkManager.ConnectionManager.PendingClients.TryGetValue(senderId, out PendingClient client) && (client.ConnectionState == PendingClient.State.PendingApproval || (client.ConnectionState == PendingClient.State.PendingConnection && messageType != typeof(ConnectionRequestMessage))))
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    {
+                        NetworkLog.LogWarning($"Message received from {nameof(senderId)}={senderId} before it has been accepted.");
+                    }
+
+                    return false;
+                }
+
+                if (m_NetworkManager.ConnectedClients.TryGetValue(senderId, out NetworkClient connectedClient) && messageType == typeof(ConnectionRequestMessage))
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    {
+                        var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
+                        NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from a client when the connection has already been established. {transportErrorMsg}");
+                    }
+
+                    return false;
+                }
+            }
+            else
+            {
+                if (messageType == typeof(ConnectionRequestMessage))
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    {
+                        var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
+                        NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side. {transportErrorMsg}");
+                    }
+
+                    return false;
+                }
+
+                if (m_NetworkManager.IsConnectedClient && messageType == typeof(ConnectionApprovedMessage))
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    {
+                        var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
+                        NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from the server when the connection has already been established. {transportErrorMsg}");
+                    }
+
+                    return false;
+                }
+            }
+
+            return !m_NetworkManager.MessageManager.StopProcessing;
+        }
+
+        private static string GetTransportErrorMessage(FastBufferReader messageContent, NetworkManager networkManager)
+        {
+            if (networkManager.NetworkConfig.NetworkTransport is not UnityTransport)
+            {
+                return $"NetworkTransport: {networkManager.NetworkConfig.NetworkTransport.GetType()}. Please report this to the maintainer of transport layer.";
+            }
+
+            var transportVersion = GetTransportVersion(networkManager);
+            return $"{transportVersion}. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}";
+        }
+
+        private static string GetTransportVersion(NetworkManager networkManager)
+        {
+            var transportVersion = "NetworkTransport: " + networkManager.NetworkConfig.NetworkTransport.GetType();
+            if (networkManager.NetworkConfig.NetworkTransport is UnityTransport unityTransport)
+            {
+                transportVersion += " UnityTransportProtocol: " + unityTransport.Protocol;
+            }
+
+            return transportVersion;
+        }
+
+        public void OnBeforeHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
+        {
+        }
+
+        public void OnAfterHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
+        {
+        }
+    }
+}

Runtime/Messaging/NetworkManagerHooks.cs.meta

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

Runtime/Messaging/NetworkMessageHeader.cs

@@ -3,13 +3,11 @@ namespace Unity.Netcode
     /// <summary>
     /// This is the header data that's serialized to the network when sending an <see cref="INetworkMessage"/>
     /// </summary>
-    internal struct MessageHeader : INetworkSerializeByMemcpy
+    internal struct NetworkMessageHeader : INetworkSerializeByMemcpy
     {
         /// <summary>
-        /// The byte representation of the message type. This is automatically assigned to each message
-        /// by the MessagingSystem. This value is deterministic only so long as the list of messages remains
-        /// unchanged - if new messages are added or messages are removed, MessageType assignments may be
-        /// calculated differently.
+        /// The byte representation of the message type. This is automatically assigned to each message by the NetworkMessageManager.
+        /// This value is deterministic only so long as the list of messages remains unchanged - if new messages are added or messages are removed, MessageType assignments may be calculated differently.
         /// </summary>
         public uint MessageType;
 

Runtime/Messaging/NetworkMessageManager.cs

@@ -11,22 +11,34 @@ namespace Unity.Netcode
 {
     internal class HandlerNotRegisteredException : SystemException
     {
-        public HandlerNotRegisteredException() { }
-        public HandlerNotRegisteredException(string issue) : base(issue) { }
+        public HandlerNotRegisteredException()
+        {
+        }
+
+        public HandlerNotRegisteredException(string issue) : base(issue)
+        {
+        }
     }
 
     internal class InvalidMessageStructureException : SystemException
     {
-        public InvalidMessageStructureException() { }
-        public InvalidMessageStructureException(string issue) : base(issue) { }
+        public InvalidMessageStructureException()
+        {
+        }
+
+        public InvalidMessageStructureException(string issue) : base(issue)
+        {
+        }
     }
 
-    internal class MessagingSystem : IDisposable
+    internal class NetworkMessageManager : IDisposable
     {
+        public bool StopProcessing = false;
+
         private struct ReceiveQueueItem
         {
             public FastBufferReader Reader;
-            public MessageHeader Header;
+            public NetworkMessageHeader Header;
             public ulong SenderId;
             public float Timestamp;
             public int MessageHeaderSerializedSize;
@@ -34,7 +46,7 @@ namespace Unity.Netcode
 
         private struct SendQueueItem
         {
-            public BatchHeader BatchHeader;
+            public NetworkBatchHeader BatchHeader;
             public FastBufferWriter Writer;
             public readonly NetworkDelivery NetworkDelivery;
 
@@ -42,11 +54,12 @@ namespace Unity.Netcode
             {
                 Writer = new FastBufferWriter(writerSize, writerAllocator, maxWriterSize);
                 NetworkDelivery = delivery;
-                BatchHeader = new BatchHeader { Magic = BatchHeader.MagicValue };
+                BatchHeader = new NetworkBatchHeader { Magic = NetworkBatchHeader.MagicValue };
             }
         }
 
-        internal delegate void MessageHandler(FastBufferReader reader, ref NetworkContext context, MessagingSystem system);
+        internal delegate void MessageHandler(FastBufferReader reader, ref NetworkContext context, NetworkMessageManager manager);
+
         internal delegate int VersionGetter();
 
         private NativeList<ReceiveQueueItem> m_IncomingMessageQueue = new NativeList<ReceiveQueueItem>(16, Allocator.Persistent);
@@ -58,6 +71,8 @@ namespace Unity.Netcode
         private Dictionary<Type, uint> m_MessageTypes = new Dictionary<Type, uint>();
         private Dictionary<ulong, NativeList<SendQueueItem>> m_SendQueues = new Dictionary<ulong, NativeList<SendQueueItem>>();
 
+        private HashSet<ulong> m_DisconnectedClients = new HashSet<ulong>();
+
         // This is m_PerClientMessageVersion[clientId][messageType] = version
         private Dictionary<ulong, Dictionary<Type, int>> m_PerClientMessageVersions = new Dictionary<ulong, Dictionary<Type, int>>();
         private Dictionary<uint, Type> m_MessagesByHash = new Dictionary<uint, Type>();
@@ -67,9 +82,11 @@ namespace Unity.Netcode
 
         private uint m_HighMessageType;
         private object m_Owner;
-        private IMessageSender m_MessageSender;
+        private INetworkMessageSender m_Sender;
         private bool m_Disposed;
 
+        private ulong m_LocalClientId;
+
         internal Type[] MessageTypes => m_ReverseTypeMap;
         internal MessageHandler[] MessageHandlers => m_MessageHandlers;
 
@@ -80,8 +97,21 @@ namespace Unity.Netcode
             return m_MessageTypes[t];
         }
 
-        public const int NON_FRAGMENTED_MESSAGE_MAX_SIZE = 1300;
-        public const int FRAGMENTED_MESSAGE_MAX_SIZE = int.MaxValue;
+        internal object GetOwner()
+        {
+            return m_Owner;
+        }
+
+        internal void SetLocalClientId(ulong id)
+        {
+            m_LocalClientId = id;
+        }
+
+        public const int DefaultNonFragmentedMessageMaxSize = 1300 & ~7; // Round down to nearest word aligned size (1296)
+        public int NonFragmentedMessageMaxSize = DefaultNonFragmentedMessageMaxSize;
+        public int FragmentedMessageMaxSize = int.MaxValue;
+
+        public Dictionary<ulong, int> PeerMTUSizes = new Dictionary<ulong, int>();
 
         internal struct MessageWithHandler
         {
@@ -94,7 +124,7 @@ namespace Unity.Netcode
         {
             var prioritizedTypes = new List<MessageWithHandler>();
 
-            // first pass puts the priority message in the first indices
+            // 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)
             {
@@ -117,17 +147,18 @@ namespace Unity.Netcode
             return prioritizedTypes;
         }
 
-        public MessagingSystem(IMessageSender messageSender, object owner, IMessageProvider provider = null)
+        public NetworkMessageManager(INetworkMessageSender sender, object owner, INetworkMessageProvider provider = null)
         {
             try
             {
-                m_MessageSender = messageSender;
+                m_Sender = sender;
                 m_Owner = owner;
 
                 if (provider == null)
                 {
                     provider = new ILPPMessageProvider();
                 }
+
                 var allowedTypes = provider.GetMessages();
 
                 allowedTypes.Sort((a, b) => string.CompareOrdinal(a.MessageType.FullName, b.MessageType.FullName));
@@ -144,20 +175,21 @@ namespace Unity.Netcode
             }
         }
 
-        public unsafe void Dispose()
+        public void Dispose()
         {
             if (m_Disposed)
             {
                 return;
             }
 
-            // Can't just iterate SendQueues or SendQueues.Keys because ClientDisconnected removes
-            // from the queue.
+            // Can't just iterate SendQueues or SendQueues.Keys because ClientDisconnected removes from the queue.
             foreach (var kvp in m_SendQueues)
             {
-                CleanupDisconnectedClient(kvp.Key);
+                ClientDisconnected(kvp.Key);
             }
 
+            CleanupDisconnectedClients();
+
             for (var queueIndex = 0; queueIndex < m_IncomingMessageQueue.Length; ++queueIndex)
             {
                 // Avoid copies...
@@ -169,7 +201,7 @@ namespace Unity.Netcode
             m_Disposed = true;
         }
 
-        ~MessagingSystem()
+        ~NetworkMessageManager()
         {
             Dispose();
         }
@@ -186,7 +218,7 @@ namespace Unity.Netcode
 
         private void RegisterMessageType(MessageWithHandler messageWithHandler)
         {
-            // if we are out of space, perform amortized linear growth
+            // If we are out of space, perform amortized linear growth
             if (m_HighMessageType == m_MessageHandlers.Length)
             {
                 Array.Resize(ref m_MessageHandlers, 2 * m_MessageHandlers.Length);
@@ -220,19 +252,18 @@ namespace Unity.Netcode
         {
             unsafe
             {
-                fixed (byte* nativeData = data.Array)
+                fixed (byte* dataPtr = data.Array)
                 {
-                    var batchReader =
-                        new FastBufferReader(nativeData + data.Offset, Allocator.None, data.Count);
-                    if (!batchReader.TryBeginRead(sizeof(BatchHeader)))
+                    var batchReader = new FastBufferReader(dataPtr + data.Offset, Allocator.None, data.Count);
+                    if (!batchReader.TryBeginRead(sizeof(NetworkBatchHeader)))
                     {
                         NetworkLog.LogError("Received a packet too small to contain a BatchHeader. Ignoring it.");
                         return;
                     }
 
-                    batchReader.ReadValue(out BatchHeader batchHeader);
+                    batchReader.ReadValue(out NetworkBatchHeader batchHeader);
 
-                    if (batchHeader.Magic != BatchHeader.MagicValue)
+                    if (batchHeader.Magic != NetworkBatchHeader.MagicValue)
                     {
                         NetworkLog.LogError($"Received a packet with an invalid Magic Value. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Offset: {data.Offset}, Size: {data.Count}, Full receive array: {ByteArrayToString(data.Array, 0, data.Array.Length)}");
                         return;
@@ -259,8 +290,7 @@ namespace Unity.Netcode
 
                     for (var messageIdx = 0; messageIdx < batchHeader.BatchCount; ++messageIdx)
                     {
-
-                        var messageHeader = new MessageHeader();
+                        var messageHeader = new NetworkMessageHeader();
                         var position = batchReader.Position;
                         try
                         {
@@ -280,19 +310,20 @@ namespace Unity.Netcode
                             NetworkLog.LogError("Received a message that claimed a size larger than the packet, ending early!");
                             return;
                         }
+
                         m_IncomingMessageQueue.Add(new ReceiveQueueItem
                         {
                             Header = messageHeader,
                             SenderId = clientId,
                             Timestamp = receiveTime,
                             // Copy the data for this message into a new FastBufferReader that owns that memory.
-                            // We can't guarantee the memory in the ArraySegment stays valid because we don't own it,
-                            // so we must move it to memory we do own.
+                            // We can't guarantee the memory in the ArraySegment stays valid because we don't own it, so we must move it to memory we do own.
                             Reader = new FastBufferReader(batchReader.GetUnsafePtrAtCurrentPosition(), Allocator.TempJob, (int)messageHeader.MessageSize),
                             MessageHeaderSerializedSize = receivedHeaderSize,
                         });
                         batchReader.Seek(batchReader.Position + (int)messageHeader.MessageSize);
                     }
+
                     for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                     {
                         m_Hooks[hookIdx].OnAfterReceiveBatch(clientId, batchHeader.BatchCount, batchReader.Length);
@@ -320,6 +351,7 @@ namespace Unity.Netcode
             {
                 return null;
             }
+
             return m_MessagesByHash[messageHash];
         }
 
@@ -329,6 +361,7 @@ namespace Unity.Netcode
             {
                 return;
             }
+
             var messageType = m_MessagesByHash[messageHash];
 
             if (!m_PerClientMessageVersions.ContainsKey(clientId))
@@ -353,6 +386,7 @@ namespace Unity.Netcode
                 {
                     continue;
                 }
+
                 var messageType = m_MessagesByHash[messagesInIdOrder[i]];
                 var oldId = oldTypes[messageType];
                 var handler = oldHandlers[oldId];
@@ -363,7 +397,7 @@ namespace Unity.Netcode
             }
         }
 
-        public void HandleMessage(in MessageHeader header, FastBufferReader reader, ulong senderId, float timestamp, int serializedHeaderSize)
+        public void HandleMessage(in NetworkMessageHeader header, FastBufferReader reader, ulong senderId, float timestamp, int serializedHeaderSize)
         {
             using (reader)
             {
@@ -372,6 +406,7 @@ namespace Unity.Netcode
                     Debug.LogWarning($"Received a message with invalid message type value {header.MessageType}");
                     return;
                 }
+
                 var context = new NetworkContext
                 {
                     SystemOwner = m_Owner,
@@ -391,13 +426,12 @@ namespace Unity.Netcode
                 var handler = m_MessageHandlers[header.MessageType];
                 for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                 {
-                    m_Hooks[hookIdx].OnBeforeReceiveMessage(senderId, type, reader.Length + FastBufferWriter.GetWriteSize<MessageHeader>());
+                    m_Hooks[hookIdx].OnBeforeReceiveMessage(senderId, type, reader.Length + FastBufferWriter.GetWriteSize<NetworkMessageHeader>());
                 }
 
-                // This will also log an exception is if the server knows about a message type the client doesn't know
-                // about. In this case the handler will be null. It is still an issue the user must deal with: If the
-                // two connecting builds know about different messages, the server should not send a message to a client
-                // that doesn't know about it
+                // This will also log an exception is if the server knows about a message type the client doesn't know about.
+                // In this case the handler will be null. It is still an issue the user must deal with:
+                // If the two connecting builds know about different messages, the server should not send a message to a client that doesn't know about it
                 if (handler == null)
                 {
                     Debug.LogException(new HandlerNotRegisteredException(header.MessageType.ToString()));
@@ -406,9 +440,7 @@ namespace Unity.Netcode
                 {
                     // No user-land message handler exceptions should escape the receive loop.
                     // If an exception is throw, the message is ignored.
-                    // Example use case: A bad message is received that can't be deserialized and throws
-                    // an OverflowException because it specifies a length greater than the number of bytes in it
-                    // for some dynamic-length value.
+                    // Example use case: A bad message is received that can't be deserialized and throws an OverflowException because it specifies a length greater than the number of bytes in it for some dynamic-length value.
                     try
                     {
                         handler.Invoke(reader, ref context, this);
@@ -418,15 +450,21 @@ namespace Unity.Netcode
                         Debug.LogException(e);
                     }
                 }
+
                 for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                 {
-                    m_Hooks[hookIdx].OnAfterReceiveMessage(senderId, type, reader.Length + FastBufferWriter.GetWriteSize<MessageHeader>());
+                    m_Hooks[hookIdx].OnAfterReceiveMessage(senderId, type, reader.Length + FastBufferWriter.GetWriteSize<NetworkMessageHeader>());
                 }
             }
         }
 
-        internal unsafe void ProcessIncomingMessageQueue()
+        internal void ProcessIncomingMessageQueue()
         {
+            if (StopProcessing)
+            {
+                return;
+            }
+
             for (var index = 0; index < m_IncomingMessageQueue.Length; ++index)
             {
                 // Avoid copies...
@@ -447,21 +485,22 @@ namespace Unity.Netcode
             {
                 return;
             }
+
             m_SendQueues[clientId] = new NativeList<SendQueueItem>(16, Allocator.Persistent);
         }
 
         internal void ClientDisconnected(ulong clientId)
         {
-            if (!m_SendQueues.ContainsKey(clientId))
-            {
-                return;
-            }
-            CleanupDisconnectedClient(clientId);
-            m_SendQueues.Remove(clientId);
+            m_DisconnectedClients.Add(clientId);
         }
 
         private void CleanupDisconnectedClient(ulong clientId)
         {
+            if (!m_SendQueues.ContainsKey(clientId))
+            {
+                return;
+            }
+
             var queue = m_SendQueues[clientId];
             for (var i = 0; i < queue.Length; ++i)
             {
@@ -469,23 +508,20 @@ namespace Unity.Netcode
             }
 
             queue.Dispose();
+            m_SendQueues.Remove(clientId);
+
+            m_PerClientMessageVersions.Remove(clientId);
+            PeerMTUSizes.Remove(clientId);
         }
 
         internal void CleanupDisconnectedClients()
         {
-            var removeList = new NativeList<ulong>(Allocator.Temp);
-            foreach (var clientId in m_PerClientMessageVersions.Keys)
+            foreach (var clientId in m_DisconnectedClients)
             {
-                if (!m_SendQueues.ContainsKey(clientId))
-                {
-                    removeList.Add(clientId);
-                }
+                CleanupDisconnectedClient(clientId);
             }
 
-            foreach (var clientId in removeList)
-            {
-                m_PerClientMessageVersions.Remove(clientId);
-            }
+            m_DisconnectedClients.Clear();
         }
 
         public static int CreateMessageAndGetVersion<T>() where T : INetworkMessage, new()
@@ -497,17 +533,21 @@ namespace Unity.Netcode
         {
             if (!m_PerClientMessageVersions.TryGetValue(clientId, out var versionMap))
             {
-                if (forReceive)
+                var networkManager = NetworkManager.Singleton;
+                if (networkManager != null && networkManager.LogLevel == LogLevel.Developer)
                 {
-                    Debug.LogWarning($"Trying to receive {type.Name} from client {clientId} which is not in a connected state.");
-
-                }
-                else
-                {
-                    Debug.LogWarning($"Trying to send {type.Name} to client {clientId} which is not in a connected state.");
+                    if (forReceive)
+                    {
+                        NetworkLog.LogWarning($"Trying to receive {type.Name} from client {clientId} which is not in a connected state.");
+                    }
+                    else
+                    {
+                        NetworkLog.LogWarning($"Trying to send {type.Name} to client {clientId} which is not in a connected state.");
+                    }
                 }
                 return -1;
             }
+
             if (!versionMap.TryGetValue(type, out var messageVersion))
             {
                 return -1;
@@ -516,33 +556,34 @@ namespace Unity.Netcode
             return messageVersion;
         }
 
-        public static void ReceiveMessage<T>(FastBufferReader reader, ref NetworkContext context, MessagingSystem system) where T : INetworkMessage, new()
+        public static void ReceiveMessage<T>(FastBufferReader reader, ref NetworkContext context, NetworkMessageManager manager) where T : INetworkMessage, new()
         {
             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 (typeof(T) != typeof(ConnectionRequestMessage) && typeof(T) != typeof(ConnectionApprovedMessage) && typeof(T) != typeof(DisconnectReasonMessage))
+            if (typeof(T) != typeof(ConnectionRequestMessage) && typeof(T) != typeof(ConnectionApprovedMessage) && typeof(T) != typeof(DisconnectReasonMessage) && context.SenderId != manager.m_LocalClientId)
             {
-                messageVersion = system.GetMessageVersion(typeof(T), context.SenderId, true);
+                messageVersion = manager.GetMessageVersion(typeof(T), context.SenderId, true);
                 if (messageVersion < 0)
                 {
                     return;
                 }
             }
+
             if (message.Deserialize(reader, ref context, messageVersion))
             {
-                for (var hookIdx = 0; hookIdx < system.m_Hooks.Count; ++hookIdx)
+                for (var hookIdx = 0; hookIdx < manager.m_Hooks.Count; ++hookIdx)
                 {
-                    system.m_Hooks[hookIdx].OnBeforeHandleMessage(ref message, ref context);
+                    manager.m_Hooks[hookIdx].OnBeforeHandleMessage(ref message, ref context);
                 }
 
                 message.Handle(ref context);
 
-                for (var hookIdx = 0; hookIdx < system.m_Hooks.Count; ++hookIdx)
+                for (var hookIdx = 0; hookIdx < manager.m_Hooks.Count; ++hookIdx)
                 {
-                    system.m_Hooks[hookIdx].OnAfterHandleMessage(ref message, ref context);
+                    manager.m_Hooks[hookIdx].OnAfterHandleMessage(ref message, ref context);
                 }
             }
         }
@@ -574,9 +615,8 @@ namespace Unity.Netcode
             for (var i = 0; i < clientIds.Count; ++i)
             {
                 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.
+                // 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) != typeof(ConnectionRequestMessage))
                 {
                     messageVersion = GetMessageVersion(typeof(TMessageType), clientIds[i]);
@@ -594,9 +634,9 @@ namespace Unity.Netcode
 
                 sentMessageVersions.Add(messageVersion);
 
-                var maxSize = delivery == NetworkDelivery.ReliableFragmentedSequenced ? FRAGMENTED_MESSAGE_MAX_SIZE : NON_FRAGMENTED_MESSAGE_MAX_SIZE;
+                var maxSize = delivery == NetworkDelivery.ReliableFragmentedSequenced ? FragmentedMessageMaxSize : NonFragmentedMessageMaxSize;
 
-                using var tmpSerializer = new FastBufferWriter(NON_FRAGMENTED_MESSAGE_MAX_SIZE - FastBufferWriter.GetWriteSize<MessageHeader>(), Allocator.Temp, maxSize - FastBufferWriter.GetWriteSize<MessageHeader>());
+                using var tmpSerializer = new FastBufferWriter(NonFragmentedMessageMaxSize - FastBufferWriter.GetWriteSize<NetworkMessageHeader>(), Allocator.Temp, maxSize - FastBufferWriter.GetWriteSize<NetworkMessageHeader>());
 
                 message.Serialize(tmpSerializer, messageVersion);
 
@@ -612,9 +652,9 @@ namespace Unity.Netcode
         internal unsafe int SendPreSerializedMessage<TMessageType>(in FastBufferWriter tmpSerializer, int maxSize, ref TMessageType message, NetworkDelivery delivery, in IReadOnlyList<ulong> clientIds, int messageVersionFilter)
             where TMessageType : INetworkMessage
         {
-            using var headerSerializer = new FastBufferWriter(FastBufferWriter.GetWriteSize<MessageHeader>(), Allocator.Temp);
+            using var headerSerializer = new FastBufferWriter(FastBufferWriter.GetWriteSize<NetworkMessageHeader>(), Allocator.Temp);
 
-            var header = new MessageHeader
+            var header = new NetworkMessageHeader
             {
                 MessageSize = (uint)tmpSerializer.Length,
                 MessageType = m_MessageTypes[typeof(TMessageType)],
@@ -624,13 +664,16 @@ namespace Unity.Netcode
 
             for (var i = 0; i < clientIds.Count; ++i)
             {
-                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 (m_DisconnectedClients.Contains(clientIds[i]))
+                {
+                    continue;
+                }
+
+                // 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) != typeof(ConnectionRequestMessage))
                 {
-                    messageVersion = GetMessageVersion(typeof(TMessageType), clientIds[i]);
+                    var messageVersion = GetMessageVersion(typeof(TMessageType), clientIds[i]);
                     if (messageVersion < 0)
                     {
                         // Client doesn't know this message exists, don't send it at all.
@@ -650,6 +693,21 @@ namespace Unity.Netcode
                     continue;
                 }
 
+                var startSize = NonFragmentedMessageMaxSize;
+                if (delivery != NetworkDelivery.ReliableFragmentedSequenced)
+                {
+                    if (PeerMTUSizes.TryGetValue(clientId, out var clientMaxSize))
+                    {
+                        maxSize = clientMaxSize;
+                    }
+                    startSize = maxSize;
+                    if (tmpSerializer.Position >= maxSize)
+                    {
+                        Debug.LogError($"MTU size for {clientId} is too small to contain a message of type {typeof(TMessageType).FullName}");
+                        continue;
+                    }
+                }
+
                 for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                 {
                     m_Hooks[hookIdx].OnBeforeSendMessage(clientId, ref message, delivery);
@@ -658,20 +716,16 @@ namespace Unity.Netcode
                 var sendQueueItem = m_SendQueues[clientId];
                 if (sendQueueItem.Length == 0)
                 {
-                    sendQueueItem.Add(new SendQueueItem(delivery, NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.TempJob,
-                        maxSize));
-                    sendQueueItem.ElementAt(0).Writer.Seek(sizeof(BatchHeader));
+                    sendQueueItem.Add(new SendQueueItem(delivery, startSize, Allocator.TempJob, maxSize));
+                    sendQueueItem.ElementAt(0).Writer.Seek(sizeof(NetworkBatchHeader));
                 }
                 else
                 {
                     ref var lastQueueItem = ref sendQueueItem.ElementAt(sendQueueItem.Length - 1);
-                    if (lastQueueItem.NetworkDelivery != delivery ||
-                        lastQueueItem.Writer.MaxCapacity - lastQueueItem.Writer.Position
-                        < tmpSerializer.Length + headerSerializer.Length)
+                    if (lastQueueItem.NetworkDelivery != delivery || lastQueueItem.Writer.MaxCapacity - lastQueueItem.Writer.Position < tmpSerializer.Length + headerSerializer.Length)
                     {
-                        sendQueueItem.Add(new SendQueueItem(delivery, NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.TempJob,
-                            maxSize));
-                        sendQueueItem.ElementAt(sendQueueItem.Length - 1).Writer.Seek(sizeof(BatchHeader));
+                        sendQueueItem.Add(new SendQueueItem(delivery, startSize, Allocator.TempJob, maxSize));
+                        sendQueueItem.ElementAt(sendQueueItem.Length - 1).Writer.Seek(sizeof(NetworkBatchHeader));
                     }
                 }
 
@@ -766,8 +820,19 @@ namespace Unity.Netcode
             return SendMessage(ref message, delivery, new PointerListWrapper<ulong>((ulong*)clientIds.GetUnsafePtr(), clientIds.Length));
         }
 
+        internal unsafe int SendMessage<T>(ref T message, NetworkDelivery delivery, in NativeList<ulong> clientIds)
+            where T : INetworkMessage
+        {
+            return SendMessage(ref message, delivery, new PointerListWrapper<ulong>((ulong*)clientIds.GetUnsafePtr(), clientIds.Length));
+        }
+
         internal unsafe void ProcessSendQueues()
         {
+            if (StopProcessing)
+            {
+                return;
+            }
+
             foreach (var kvp in m_SendQueues)
             {
                 var clientId = kvp.Key;
@@ -775,6 +840,15 @@ namespace Unity.Netcode
                 for (var i = 0; i < sendQueueItem.Length; ++i)
                 {
                     ref var queueItem = ref sendQueueItem.ElementAt(i);
+                    // This is checked at every iteration because
+                    // 1) each writer needs to be disposed, so we have to do the full loop regardless, and
+                    // 2) the call to m_MessageSender.Send() may result in calling ClientDisconnected(), so the result of this check may change partway through iteration
+                    if (m_DisconnectedClients.Contains(clientId))
+                    {
+                        queueItem.Writer.Dispose();
+                        continue;
+                    }
+
                     if (queueItem.BatchHeader.BatchCount == 0)
                     {
                         queueItem.Writer.Dispose();
@@ -789,18 +863,24 @@ namespace Unity.Netcode
                     queueItem.Writer.Seek(0);
 #if UNITY_EDITOR || DEVELOPMENT_BUILD
                     // Skipping the Verify and sneaking the write mark in because we know it's fine.
-                    queueItem.Writer.Handle->AllowedWriteMark = sizeof(BatchHeader);
+                    queueItem.Writer.Handle->AllowedWriteMark = sizeof(NetworkBatchHeader);
 #endif
-                    queueItem.BatchHeader.BatchHash = XXHash.Hash64(queueItem.Writer.GetUnsafePtr() + sizeof(BatchHeader), queueItem.Writer.Length - sizeof(BatchHeader));
 
-                    queueItem.BatchHeader.BatchSize = queueItem.Writer.Length;
+
+                    var alignedLength = (queueItem.Writer.Length + 7) & ~7;
+                    queueItem.Writer.TryBeginWrite(alignedLength);
+
+                    queueItem.BatchHeader.BatchHash = XXHash.Hash64(queueItem.Writer.GetUnsafePtr() + sizeof(NetworkBatchHeader), alignedLength - sizeof(NetworkBatchHeader));
+
+                    queueItem.BatchHeader.BatchSize = alignedLength;
 
                     queueItem.Writer.WriteValue(queueItem.BatchHeader);
+                    queueItem.Writer.Seek(alignedLength);
 
 
                     try
                     {
-                        m_MessageSender.Send(clientId, queueItem.NetworkDelivery, queueItem.Writer);
+                        m_Sender.Send(clientId, queueItem.NetworkDelivery, queueItem.Writer);
 
                         for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                         {
@@ -812,6 +892,7 @@ namespace Unity.Netcode
                         queueItem.Writer.Dispose();
                     }
                 }
+
                 sendQueueItem.Clear();
             }
         }

Runtime/Messaging/RpcAttributes.cs

@@ -21,12 +21,36 @@ namespace Unity.Netcode
     /// <summary>
     /// <para>Represents the common base class for Rpc attributes.</para>
     /// </summary>
-    public abstract class RpcAttribute : Attribute
+    [AttributeUsage(AttributeTargets.Method)]
+    public class RpcAttribute : Attribute
     {
+        // Must match the set of parameters below
+        public struct RpcAttributeParams
+        {
+            public RpcDelivery Delivery;
+            public bool RequireOwnership;
+            public bool DeferLocal;
+            public bool AllowTargetOverride;
+        }
+
+        // Must match the fields in RemoteAttributeParams
         /// <summary>
         /// Type of RPC delivery method
         /// </summary>
         public RpcDelivery Delivery = RpcDelivery.Reliable;
+        public bool RequireOwnership;
+        public bool DeferLocal;
+        public bool AllowTargetOverride;
+
+        public RpcAttribute(SendTo target)
+        {
+        }
+
+        // To get around an issue with the release validator, RuntimeAccessModifiersILPP will make this 'public'
+        private RpcAttribute()
+        {
+
+        }
     }
 
     /// <summary>
@@ -36,10 +60,12 @@ namespace Unity.Netcode
     [AttributeUsage(AttributeTargets.Method)]
     public class ServerRpcAttribute : RpcAttribute
     {
-        /// <summary>
-        /// Whether or not the ServerRpc should only be run if executed by the owner of the object
-        /// </summary>
-        public bool RequireOwnership = true;
+        public new bool RequireOwnership;
+
+        public ServerRpcAttribute() : base(SendTo.Server)
+        {
+
+        }
     }
 
     /// <summary>
@@ -47,5 +73,11 @@ namespace Unity.Netcode
     /// <para>A ClientRpc marked method will be fired by the server but executed on clients.</para>
     /// </summary>
     [AttributeUsage(AttributeTargets.Method)]
-    public class ClientRpcAttribute : RpcAttribute { }
+    public class ClientRpcAttribute : RpcAttribute
+    {
+        public ClientRpcAttribute() : base(SendTo.NotServer)
+        {
+
+        }
+    }
 }

Runtime/Messaging/RpcParams.cs

@@ -3,6 +3,60 @@ using Unity.Collections;
 
 namespace Unity.Netcode
 {
+    public enum LocalDeferMode
+    {
+        Default,
+        Defer,
+        SendImmediate
+    }
+    /// <summary>
+    /// Generic RPC
+    /// </summary>
+    public struct RpcSendParams
+    {
+        public BaseRpcTarget Target;
+
+        public LocalDeferMode LocalDeferMode;
+
+        public static implicit operator RpcSendParams(BaseRpcTarget target) => new RpcSendParams { Target = target };
+        public static implicit operator RpcSendParams(LocalDeferMode deferMode) => new RpcSendParams { LocalDeferMode = deferMode };
+    }
+
+    /// <summary>
+    /// The receive parameters for server-side remote procedure calls
+    /// </summary>
+    public struct RpcReceiveParams
+    {
+        /// <summary>
+        /// Server-Side RPC
+        /// The client identifier of the sender
+        /// </summary>
+        public ulong SenderClientId;
+    }
+
+    /// <summary>
+    /// Server-Side RPC
+    /// Can be used with any sever-side remote procedure call
+    /// Note: typically this is use primarily for the <see cref="ServerRpcReceiveParams"/>
+    /// </summary>
+    public struct RpcParams
+    {
+        /// <summary>
+        /// The server RPC send parameters (currently a place holder)
+        /// </summary>
+        public RpcSendParams Send;
+
+        /// <summary>
+        /// The client RPC receive parameters provides you with the sender's identifier
+        /// </summary>
+        public RpcReceiveParams Receive;
+
+        public static implicit operator RpcParams(RpcSendParams send) => new RpcParams { Send = send };
+        public static implicit operator RpcParams(BaseRpcTarget target) => new RpcParams { Send = new RpcSendParams { Target = target } };
+        public static implicit operator RpcParams(LocalDeferMode deferMode) => new RpcParams { Send = new RpcSendParams { LocalDeferMode = deferMode } };
+        public static implicit operator RpcParams(RpcReceiveParams receive) => new RpcParams { Receive = receive };
+    }
+
     /// <summary>
     /// Server-Side RPC
     /// Place holder.  <see cref="ServerRpcParams"/>
@@ -99,6 +153,7 @@ namespace Unity.Netcode
     internal struct __RpcParams
 #pragma warning restore IDE1006 // restore naming rule violation check
     {
+        public RpcParams Ext;
         public ServerRpcParams Server;
         public ClientRpcParams Client;
     }

Runtime/Messaging/RpcTargets.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b02186acd1144e20acbd0dcb69b14938
+timeCreated: 1697824888

Runtime/Messaging/RpcTargets/BaseRpcTarget.cs

@@ -0,0 +1,57 @@
+using System;
+
+namespace Unity.Netcode
+{
+    public abstract class BaseRpcTarget : IDisposable
+    {
+        protected NetworkManager m_NetworkManager;
+        private bool m_Locked;
+
+        internal void Lock()
+        {
+            m_Locked = true;
+        }
+
+        internal void Unlock()
+        {
+            m_Locked = false;
+        }
+
+        internal BaseRpcTarget(NetworkManager manager)
+        {
+            m_NetworkManager = manager;
+        }
+
+        protected void CheckLockBeforeDispose()
+        {
+            if (m_Locked)
+            {
+                throw new Exception($"RPC targets obtained through {nameof(RpcTargetUse)}.{RpcTargetUse.Temp} may not be disposed.");
+            }
+        }
+
+        public abstract void Dispose();
+
+        internal abstract void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams);
+
+        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
+            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 (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
+            {
+                behaviour.NetworkManager.NetworkMetrics.TrackRpcSent(
+                    clientId,
+                    behaviour.NetworkObject,
+                    rpcMethodName,
+                    behaviour.__getTypeName(),
+                    size);
+            }
+#endif
+        }
+    }
+}

Runtime/Messaging/RpcTargets/BaseRpcTarget.cs.meta

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

Runtime/Messaging/RpcTargets/ClientsAndHostRpcTarget.cs

@@ -0,0 +1,37 @@
+namespace Unity.Netcode
+{
+    internal class ClientsAndHostRpcTarget : BaseRpcTarget
+    {
+        private BaseRpcTarget m_UnderlyingTarget;
+
+        public override void Dispose()
+        {
+            m_UnderlyingTarget = null;
+        }
+
+        internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
+        {
+            if (m_UnderlyingTarget == null)
+            {
+                // NotServer treats a host as being a server and will not send to it
+                // ClientsAndHost sends to everyone who runs any client logic
+                // So if the server is a host, this target includes it (as hosts run client logic)
+                // If the server is not a host, this target leaves it out, ergo the selection of NotServer.
+                if (behaviour.NetworkManager.ServerIsHost)
+                {
+                    m_UnderlyingTarget = behaviour.RpcTarget.Everyone;
+                }
+                else
+                {
+                    m_UnderlyingTarget = behaviour.RpcTarget.NotServer;
+                }
+            }
+
+            m_UnderlyingTarget.Send(behaviour, ref message, delivery, rpcParams);
+        }
+
+        internal ClientsAndHostRpcTarget(NetworkManager manager) : base(manager)
+        {
+        }
+    }
+}

Runtime/Messaging/RpcTargets/ClientsAndHostRpcTarget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c9f883d678ec4715b160dd9497d5f42d
+timeCreated: 1699481382

Runtime/Messaging/RpcTargets/DirectSendRpcTarget.cs

@@ -0,0 +1,34 @@
+namespace Unity.Netcode
+{
+    internal class DirectSendRpcTarget : BaseRpcTarget, IIndividualRpcTarget
+    {
+        public BaseRpcTarget Target => this;
+
+        internal ulong ClientId;
+
+        public override void Dispose()
+        {
+            CheckLockBeforeDispose();
+        }
+
+        internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
+        {
+            SendMessageToClient(behaviour, ClientId, ref message, delivery);
+        }
+
+        public void SetClientId(ulong clientId)
+        {
+            ClientId = clientId;
+        }
+
+        internal DirectSendRpcTarget(NetworkManager manager) : base(manager)
+        {
+
+        }
+
+        internal DirectSendRpcTarget(ulong clientId, NetworkManager manager) : base(manager)
+        {
+            ClientId = clientId;
+        }
+    }
+}

Runtime/Messaging/RpcTargets/DirectSendRpcTarget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 077544cfd0b94cfc8a2a55d3828b74bb
+timeCreated: 1697824873

Runtime/Messaging/RpcTargets/EveryoneRpcTarget.cs

@@ -0,0 +1,26 @@
+namespace Unity.Netcode
+{
+    internal class EveryoneRpcTarget : BaseRpcTarget
+    {
+        private NotServerRpcTarget m_NotServerRpcTarget;
+        private ServerRpcTarget m_ServerRpcTarget;
+
+        public override void Dispose()
+        {
+            m_NotServerRpcTarget.Dispose();
+            m_ServerRpcTarget.Dispose();
+        }
+
+        internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams 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);
+        }
+    }
+}