com.unity.netcode.gameobjects@1.8.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.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)

CHANGELOG.md

@@ -6,6 +6,49 @@ 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.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
@@ -15,8 +58,6 @@ Additional documentation and release notes are available at [Multiplayer Documen
 - 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)
 
-### Changed
-
 ## [1.7.0] - 2023-10-11
 
 ### Added
@@ -74,7 +115,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 ### 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)

Components/NetworkAnimator.cs

@@ -833,8 +833,7 @@ namespace Unity.Netcode.Components
                     stateChangeDetected = true;
                     //Debug.Log($"[Cross-Fade] To-Hash: {nt.fullPathHash} | TI-Duration: ({tt.duration}) | TI-Norm: ({tt.normalizedTime}) | From-Hash: ({m_AnimationHash[layer]}) | SI-FPHash: ({st.fullPathHash}) | SI-Norm: ({st.normalizedTime})");
                 }
-                else
+                else if (!tt.anyState && tt.fullPathHash != m_TransitionHash[layer])
-                if (!tt.anyState && tt.fullPathHash != m_TransitionHash[layer])
                 {
                     // first time in this transition for this layer
                     m_TransitionHash[layer] = tt.fullPathHash;
@@ -1053,8 +1052,7 @@ namespace Unity.Netcode.Components
                         BytePacker.WriteValuePacked(writer, valueBool);
                     }
                 }
-                else
+                else if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterFloat)
-                if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterFloat)
                 {
                     var valueFloat = m_Animator.GetFloat(hash);
                     fixed (void* value = cacheValue.Value)

Components/NetworkDeltaPosition.cs

@@ -23,12 +23,20 @@ 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)
+            {
+                serializer.SerializeValue(ref CurrentBasePosition);
+            }
         }
 
         /// <summary>
@@ -122,6 +130,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 +145,7 @@ namespace Unity.Netcode.Components
                         CurrentBasePosition[i] += HalfDeltaConvertedBack[i];
                         HalfDeltaConvertedBack[i] = 0.0f;
                         DeltaPosition[i] = 0.0f;
+                        CollapsedDeltaIntoBase = true;
                     }
                 }
             }
@@ -164,6 +174,8 @@ namespace Unity.Netcode.Components
             DeltaPosition = Vector3.zero;
             HalfDeltaConvertedBack = Vector3.zero;
             HalfVector3 = new HalfVector3(vector3, axisToSynchronize);
+            SynchronizeBase = false;
+            CollapsedDeltaIntoBase = false;
             UpdateFrom(ref vector3, networkTick);
         }
 

Documentation~/index.md

@@ -16,7 +16,7 @@ See guides below to install Unity Netcode for GameObjects, set up your project,
 ## 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

Editor/CodeGen/CodeGenHelpers.cs

@@ -26,8 +26,10 @@ namespace Unity.Netcode.Editor.CodeGen
         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;

Editor/CodeGen/NetworkBehaviourILPP.cs

@@ -363,11 +363,14 @@ namespace Unity.Netcode.Editor.CodeGen
         private FieldReference m_NetworkManager_LogLevel_FieldRef;
         private MethodReference m_NetworkBehaviour___registerRpc_MethodRef;
         private TypeReference m_NetworkBehaviour_TypeRef;
+        private TypeReference m_AttributeParamsType_TypeRef;
         private TypeReference m_NetworkVariableBase_TypeRef;
         private MethodReference m_NetworkVariableBase_Initialize_MethodRef;
         private MethodReference m_NetworkBehaviour___nameNetworkVariable_MethodRef;
         private MethodReference m_NetworkBehaviour_beginSendServerRpc_MethodRef;
         private MethodReference m_NetworkBehaviour_endSendServerRpc_MethodRef;
+        private MethodReference m_NetworkBehaviour_beginSendRpc_MethodRef;
+        private MethodReference m_NetworkBehaviour_endSendRpc_MethodRef;
         private MethodReference m_NetworkBehaviour_beginSendClientRpc_MethodRef;
         private MethodReference m_NetworkBehaviour_endSendClientRpc_MethodRef;
         private FieldReference m_NetworkBehaviour_rpc_exec_stage_FieldRef;
@@ -378,9 +381,13 @@ namespace Unity.Netcode.Editor.CodeGen
         private TypeReference m_RpcParams_TypeRef;
         private FieldReference m_RpcParams_Server_FieldRef;
         private FieldReference m_RpcParams_Client_FieldRef;
+        private FieldReference m_RpcParams_Ext_FieldRef;
         private TypeReference m_ServerRpcParams_TypeRef;
         private FieldReference m_ServerRpcParams_Receive_FieldRef;
         private FieldReference m_ServerRpcParams_Receive_SenderClientId_FieldRef;
+        private FieldReference m_UniversalRpcParams_Receive_FieldRef;
+        private FieldReference m_UniversalRpcParams_Receive_SenderClientId_FieldRef;
+        private TypeReference m_UniversalRpcParams_TypeRef;
         private TypeReference m_ClientRpcParams_TypeRef;
         private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpy_MethodRef;
         private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyArray_MethodRef;
@@ -495,6 +502,8 @@ namespace Unity.Netcode.Editor.CodeGen
         private const string k_NetworkBehaviour_NetworkVariableFields = nameof(NetworkBehaviour.NetworkVariableFields);
         private const string k_NetworkBehaviour_beginSendServerRpc = nameof(NetworkBehaviour.__beginSendServerRpc);
         private const string k_NetworkBehaviour_endSendServerRpc = nameof(NetworkBehaviour.__endSendServerRpc);
+        private const string k_NetworkBehaviour_beginSendRpc = nameof(NetworkBehaviour.__beginSendRpc);
+        private const string k_NetworkBehaviour_endSendRpc = nameof(NetworkBehaviour.__endSendRpc);
         private const string k_NetworkBehaviour_beginSendClientRpc = nameof(NetworkBehaviour.__beginSendClientRpc);
         private const string k_NetworkBehaviour_endSendClientRpc = nameof(NetworkBehaviour.__endSendClientRpc);
         private const string k_NetworkBehaviour___initializeVariables = nameof(NetworkBehaviour.__initializeVariables);
@@ -511,8 +520,11 @@ namespace Unity.Netcode.Editor.CodeGen
         private const string k_ServerRpcAttribute_RequireOwnership = nameof(ServerRpcAttribute.RequireOwnership);
         private const string k_RpcParams_Server = nameof(__RpcParams.Server);
         private const string k_RpcParams_Client = nameof(__RpcParams.Client);
+        private const string k_RpcParams_Ext = nameof(__RpcParams.Ext);
         private const string k_ServerRpcParams_Receive = nameof(ServerRpcParams.Receive);
+        private const string k_RpcParams_Receive = nameof(RpcParams.Receive);
         private const string k_ServerRpcReceiveParams_SenderClientId = nameof(ServerRpcReceiveParams.SenderClientId);
+        private const string k_RpcReceiveParams_SenderClientId = nameof(RpcReceiveParams.SenderClientId);
 
         // CodeGen cannot reference the collections assembly to do a typeof() on it due to a bug that causes that to crash.
         private const string k_INativeListBool_FullName = "Unity.Collections.INativeList`1<System.Byte>";
@@ -545,13 +557,20 @@ namespace Unity.Netcode.Editor.CodeGen
             TypeDefinition rpcParamsTypeDef = null;
             TypeDefinition serverRpcParamsTypeDef = null;
             TypeDefinition clientRpcParamsTypeDef = null;
+            TypeDefinition universalRpcParamsTypeDef = null;
             TypeDefinition fastBufferWriterTypeDef = null;
             TypeDefinition fastBufferReaderTypeDef = null;
             TypeDefinition networkVariableSerializationTypesTypeDef = null;
             TypeDefinition bytePackerTypeDef = null;
             TypeDefinition byteUnpackerTypeDef = null;
+            TypeDefinition attributeParamsType = null;
             foreach (var netcodeTypeDef in m_NetcodeModule.GetAllTypes())
             {
+                if (attributeParamsType == null && netcodeTypeDef.Name == nameof(RpcAttribute.RpcAttributeParams))
+                {
+                    attributeParamsType = netcodeTypeDef;
+                    continue;
+                }
                 if (networkManagerTypeDef == null && netcodeTypeDef.Name == nameof(NetworkManager))
                 {
                     networkManagerTypeDef = netcodeTypeDef;
@@ -588,6 +607,12 @@ namespace Unity.Netcode.Editor.CodeGen
                     continue;
                 }
 
+                if (universalRpcParamsTypeDef == null && netcodeTypeDef.Name == nameof(RpcParams))
+                {
+                    universalRpcParamsTypeDef = netcodeTypeDef;
+                    continue;
+                }
+
                 if (clientRpcParamsTypeDef == null && netcodeTypeDef.Name == nameof(ClientRpcParams))
                 {
                     clientRpcParamsTypeDef = netcodeTypeDef;
@@ -662,6 +687,8 @@ namespace Unity.Netcode.Editor.CodeGen
                 }
             }
 
+            m_AttributeParamsType_TypeRef = moduleDefinition.ImportReference(attributeParamsType);
+
             foreach (var fieldDef in networkManagerTypeDef.Fields)
             {
                 switch (fieldDef.Name)
@@ -696,6 +723,12 @@ namespace Unity.Netcode.Editor.CodeGen
                     case k_NetworkBehaviour_endSendServerRpc:
                         m_NetworkBehaviour_endSendServerRpc_MethodRef = moduleDefinition.ImportReference(methodDef);
                         break;
+                    case k_NetworkBehaviour_beginSendRpc:
+                        m_NetworkBehaviour_beginSendRpc_MethodRef = moduleDefinition.ImportReference(methodDef);
+                        break;
+                    case k_NetworkBehaviour_endSendRpc:
+                        m_NetworkBehaviour_endSendRpc_MethodRef = moduleDefinition.ImportReference(methodDef);
+                        break;
                     case k_NetworkBehaviour_beginSendClientRpc:
                         m_NetworkBehaviour_beginSendClientRpc_MethodRef = moduleDefinition.ImportReference(methodDef);
                         break;
@@ -763,6 +796,9 @@ namespace Unity.Netcode.Editor.CodeGen
                     case k_RpcParams_Client:
                         m_RpcParams_Client_FieldRef = moduleDefinition.ImportReference(fieldDef);
                         break;
+                    case k_RpcParams_Ext:
+                        m_RpcParams_Ext_FieldRef = moduleDefinition.ImportReference(fieldDef);
+                        break;
                 }
             }
 
@@ -786,6 +822,26 @@ namespace Unity.Netcode.Editor.CodeGen
                         break;
                 }
             }
+            m_UniversalRpcParams_TypeRef = moduleDefinition.ImportReference(rpcParamsTypeDef);
+            foreach (var fieldDef in rpcParamsTypeDef.Fields)
+            {
+                switch (fieldDef.Name)
+                {
+                    case k_RpcParams_Receive:
+                        foreach (var recvFieldDef in fieldDef.FieldType.Resolve().Fields)
+                        {
+                            switch (recvFieldDef.Name)
+                            {
+                                case k_RpcReceiveParams_SenderClientId:
+                                    m_UniversalRpcParams_Receive_SenderClientId_FieldRef = moduleDefinition.ImportReference(recvFieldDef);
+                                    break;
+                            }
+                        }
+
+                        m_UniversalRpcParams_Receive_FieldRef = moduleDefinition.ImportReference(fieldDef);
+                        break;
+                }
+            }
 
             m_ClientRpcParams_TypeRef = moduleDefinition.ImportReference(clientRpcParamsTypeDef);
             m_FastBufferWriter_TypeRef = moduleDefinition.ImportReference(fastBufferWriterTypeDef);
@@ -1354,7 +1410,8 @@ namespace Unity.Netcode.Editor.CodeGen
                 var customAttributeType_FullName = customAttribute.AttributeType.FullName;
 
                 if (customAttributeType_FullName == CodeGenHelpers.ServerRpcAttribute_FullName ||
-                    customAttributeType_FullName == CodeGenHelpers.ClientRpcAttribute_FullName)
+                    customAttributeType_FullName == CodeGenHelpers.ClientRpcAttribute_FullName ||
+                    customAttributeType_FullName == CodeGenHelpers.RpcAttribute_FullName)
                 {
                     bool isValid = true;
 
@@ -1389,6 +1446,13 @@ namespace Unity.Netcode.Editor.CodeGen
                         isValid = false;
                     }
 
+                    if (customAttributeType_FullName == CodeGenHelpers.RpcAttribute_FullName &&
+                        !methodDefinition.Name.EndsWith("Rpc", StringComparison.OrdinalIgnoreCase))
+                    {
+                        m_Diagnostics.AddError(methodDefinition, "Rpc method must end with 'Rpc' suffix!");
+                        isValid = false;
+                    }
+
                     if (customAttributeType_FullName == CodeGenHelpers.ClientRpcAttribute_FullName &&
                         !methodDefinition.Name.EndsWith("ClientRpc", StringComparison.OrdinalIgnoreCase))
                     {
@@ -1411,11 +1475,15 @@ namespace Unity.Netcode.Editor.CodeGen
             {
                 if (methodDefinition.Name.EndsWith("ServerRpc", StringComparison.OrdinalIgnoreCase))
                 {
-                    m_Diagnostics.AddError(methodDefinition, "ServerRpc method must be marked with 'ServerRpc' attribute!");
+                    m_Diagnostics.AddError(methodDefinition, $"ServerRpc method {methodDefinition} must be marked with 'ServerRpc' attribute!");
                 }
                 else if (methodDefinition.Name.EndsWith("ClientRpc", StringComparison.OrdinalIgnoreCase))
                 {
-                    m_Diagnostics.AddError(methodDefinition, "ClientRpc method must be marked with 'ClientRpc' attribute!");
+                    m_Diagnostics.AddError(methodDefinition, $"ClientRpc method {methodDefinition} must be marked with 'ClientRpc' attribute!");
+                }
+                else if (methodDefinition.Name.EndsWith("ExtRpc", StringComparison.OrdinalIgnoreCase))
+                {
+                    m_Diagnostics.AddError(methodDefinition, $"Ext Rpc method {methodDefinition} must be marked with 'ExtRpc' attribute!");
                 }
 
                 return null;
@@ -1887,8 +1955,17 @@ namespace Unity.Netcode.Editor.CodeGen
             var instructions = new List<Instruction>();
             var processor = methodDefinition.Body.GetILProcessor();
             var isServerRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.ServerRpcAttribute_FullName;
+            var isClientRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.ClientRpcAttribute_FullName;
+            var isGenericRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.RpcAttribute_FullName;
             var requireOwnership = true; // default value MUST be == `ServerRpcAttribute.RequireOwnership`
             var rpcDelivery = RpcDelivery.Reliable; // default value MUST be == `RpcAttribute.Delivery`
+            var defaultTarget = SendTo.Everyone;
+            var allowTargetOverride = false;
+
+            if (isGenericRpc)
+            {
+                defaultTarget = (SendTo)rpcAttribute.ConstructorArguments[0].Value;
+            }
             foreach (var attrField in rpcAttribute.Fields)
             {
                 switch (attrField.Name)
@@ -1899,6 +1976,9 @@ namespace Unity.Netcode.Editor.CodeGen
                     case k_ServerRpcAttribute_RequireOwnership:
                         requireOwnership = attrField.Argument.Type == typeSystem.Boolean && (bool)attrField.Argument.Value;
                         break;
+                    case nameof(RpcAttribute.AllowTargetOverride):
+                        allowTargetOverride = attrField.Argument.Type == typeSystem.Boolean && (bool)attrField.Argument.Value;
+                        break;
                 }
             }
 
@@ -1906,7 +1986,33 @@ namespace Unity.Netcode.Editor.CodeGen
             var hasRpcParams =
                 paramCount > 0 &&
                 ((isServerRpc && methodDefinition.Parameters[paramCount - 1].ParameterType.FullName == CodeGenHelpers.ServerRpcParams_FullName) ||
-                 (!isServerRpc && methodDefinition.Parameters[paramCount - 1].ParameterType.FullName == CodeGenHelpers.ClientRpcParams_FullName));
+                 (isClientRpc && methodDefinition.Parameters[paramCount - 1].ParameterType.FullName == CodeGenHelpers.ClientRpcParams_FullName) ||
+                 (isGenericRpc && methodDefinition.Parameters[paramCount - 1].ParameterType.FullName == CodeGenHelpers.RpcParams_FullName));
+
+            if (isGenericRpc && defaultTarget == SendTo.SpecifiedInParams)
+            {
+                if (!hasRpcParams)
+                {
+                    m_Diagnostics.AddError($"{methodDefinition}: {nameof(SendTo)}.{nameof(SendTo.SpecifiedInParams)} cannot be used without a final parameter of type {CodeGenHelpers.RpcParams_FullName}.");
+                }
+
+                foreach (var attrField in rpcAttribute.Fields)
+                {
+                    switch (attrField.Name)
+                    {
+                        case nameof(RpcAttribute.AllowTargetOverride):
+                            m_Diagnostics.AddWarning($"{methodDefinition}: {nameof(RpcAttribute.AllowTargetOverride)} is ignored with {nameof(SendTo)}.{nameof(SendTo.SpecifiedInParams)}");
+                            break;
+                    }
+                }
+            }
+            if (isGenericRpc && allowTargetOverride)
+            {
+                if (!hasRpcParams)
+                {
+                    m_Diagnostics.AddError($"{methodDefinition}: {nameof(RpcAttribute.AllowTargetOverride)} cannot be used without a final parameter of type {CodeGenHelpers.RpcParams_FullName}.");
+                }
+            }
 
             methodDefinition.Body.InitLocals = true;
             // NetworkManager networkManager;
@@ -1919,10 +2025,17 @@ namespace Unity.Netcode.Editor.CodeGen
             // XXXRpcParams
             if (!hasRpcParams)
             {
-                methodDefinition.Body.Variables.Add(new VariableDefinition(isServerRpc ? m_ServerRpcParams_TypeRef : m_ClientRpcParams_TypeRef));
+                methodDefinition.Body.Variables.Add(new VariableDefinition(isServerRpc ? m_ServerRpcParams_TypeRef : (isClientRpc ? m_ClientRpcParams_TypeRef : m_UniversalRpcParams_TypeRef)));
             }
             int rpcParamsIdx = !hasRpcParams ? methodDefinition.Body.Variables.Count - 1 : -1;
 
+            if (isGenericRpc)
+            {
+                methodDefinition.Body.Variables.Add(new VariableDefinition(m_AttributeParamsType_TypeRef));
+            }
+
+            int rpcAttributeParamsIdx = isGenericRpc ? methodDefinition.Body.Variables.Count - 1 : -1;
+
             {
                 var returnInstr = processor.Create(OpCodes.Ret);
                 var lastInstr = processor.Create(OpCodes.Nop);
@@ -1952,12 +2065,14 @@ namespace Unity.Netcode.Editor.CodeGen
                 // if (__rpc_exec_stage != __RpcExecStage.Client) -> ClientRpc
                 instructions.Add(processor.Create(OpCodes.Ldarg_0));
                 instructions.Add(processor.Create(OpCodes.Ldfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
-                instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)(isServerRpc ? NetworkBehaviour.__RpcExecStage.Server : NetworkBehaviour.__RpcExecStage.Client)));
+                instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Execute));
                 instructions.Add(processor.Create(OpCodes.Ceq));
                 instructions.Add(processor.Create(OpCodes.Ldc_I4, 0));
                 instructions.Add(processor.Create(OpCodes.Ceq));
                 instructions.Add(processor.Create(OpCodes.Brfalse, lastInstr));
 
+                if (!isGenericRpc)
+                {
                     // if (networkManager.IsClient || networkManager.IsHost) { ... } -> ServerRpc
                     // if (networkManager.IsServer || networkManager.IsHost) { ... } -> ClientRpc
                     instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
@@ -1966,6 +2081,7 @@ namespace Unity.Netcode.Editor.CodeGen
                     instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
                     instructions.Add(processor.Create(OpCodes.Callvirt, m_NetworkManager_getIsHost_MethodRef));
                     instructions.Add(processor.Create(OpCodes.Brfalse, lastInstr));
+                }
 
                 instructions.Add(beginInstr);
 
@@ -2027,7 +2143,7 @@ namespace Unity.Netcode.Editor.CodeGen
                     instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_beginSendServerRpc_MethodRef));
                     instructions.Add(processor.Create(OpCodes.Stloc, bufWriterLocIdx));
                 }
-                else
+                else if (isClientRpc)
                 {
                     // ClientRpc
 
@@ -2047,6 +2163,89 @@ namespace Unity.Netcode.Editor.CodeGen
                     instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_beginSendClientRpc_MethodRef));
                     instructions.Add(processor.Create(OpCodes.Stloc, bufWriterLocIdx));
                 }
+                else
+                {
+                    // Generic RPC
+
+                    // var bufferWriter = __beginSendRpc(rpcMethodId, rpcParams, rpcAttributeParams, defaultTarget, rpcDelivery);
+                    instructions.Add(processor.Create(OpCodes.Ldarg_0));
+
+                    // rpcMethodId
+                    instructions.Add(processor.Create(OpCodes.Ldc_I4, unchecked((int)rpcMethodId)));
+
+                    // rpcParams
+                    instructions.Add(hasRpcParams ? processor.Create(OpCodes.Ldarg, paramCount) : processor.Create(OpCodes.Ldloc, rpcParamsIdx));
+
+                    // rpcAttributeParams
+                    instructions.Add(processor.Create(OpCodes.Ldloca, rpcAttributeParamsIdx));
+                    instructions.Add(processor.Create(OpCodes.Initobj, m_AttributeParamsType_TypeRef));
+
+                    RpcAttribute.RpcAttributeParams dflt = default;
+                    foreach (var field in rpcAttribute.Fields)
+                    {
+                        var found = false;
+                        foreach (var attrField in m_AttributeParamsType_TypeRef.Resolve().Fields)
+                        {
+                            if (attrField.Name == field.Name)
+                            {
+                                found = true;
+                                var value = field.Argument.Value;
+                                var paramField = dflt.GetType().GetField(attrField.Name);
+                                if (value != paramField.GetValue(dflt))
+                                {
+                                    instructions.Add(processor.Create(OpCodes.Ldloca, rpcAttributeParamsIdx));
+                                    var type = value.GetType();
+                                    if (type == typeof(bool))
+                                    {
+                                        instructions.Add(processor.Create(OpCodes.Ldc_I4, (bool)value ? 1 : 0));
+                                    }
+                                    else if (type == typeof(short) || type == typeof(int) || type == typeof(ushort)
+                                       || type == typeof(byte) || type == typeof(sbyte) || type == typeof(char))
+                                    {
+                                        instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)value));
+                                    }
+                                    else if (type == typeof(long) || type == typeof(ulong))
+                                    {
+                                        instructions.Add(processor.Create(OpCodes.Ldc_I8, (long)value));
+                                    }
+                                    else if (type == typeof(float))
+                                    {
+                                        instructions.Add(processor.Create(OpCodes.Ldc_R8, (float)value));
+
+                                    }
+                                    else if (type == typeof(double))
+                                    {
+                                        instructions.Add(processor.Create(OpCodes.Ldc_R8, (double)value));
+                                    }
+                                    else
+                                    {
+                                        m_Diagnostics.AddError("Unsupported attribute parameter type.");
+                                    }
+                                }
+
+                                instructions.Add(processor.Create(OpCodes.Stfld, m_MainModule.ImportReference(attrField)));
+
+                                break;
+                            }
+                        }
+
+                        if (!found)
+                        {
+                            m_Diagnostics.AddError($"{nameof(RpcAttribute)} contains field {field} which is not present in {nameof(RpcAttribute.RpcAttributeParams)}.");
+                        }
+                    }
+                    instructions.Add(processor.Create(OpCodes.Ldloc, rpcAttributeParamsIdx));
+
+                    // defaultTarget
+                    instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)defaultTarget));
+
+                    // rpcDelivery
+                    instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)rpcDelivery));
+
+                    // __beginSendRpc
+                    instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_beginSendRpc_MethodRef));
+                    instructions.Add(processor.Create(OpCodes.Stloc, bufWriterLocIdx));
+                }
 
                 // write method parameters into stream
                 for (int paramIndex = 0; paramIndex < paramCount; ++paramIndex)
@@ -2075,7 +2274,7 @@ namespace Unity.Netcode.Editor.CodeGen
                         }
                         if (!isServerRpc)
                         {
-                            m_Diagnostics.AddError($"ClientRpcs may not accept {nameof(ServerRpcParams)} as a parameter.");
+                            m_Diagnostics.AddError($"Only ServerRpcs may accept {nameof(ServerRpcParams)} as a parameter.");
                         }
                         continue;
                     }
@@ -2086,9 +2285,22 @@ namespace Unity.Netcode.Editor.CodeGen
                         {
                             m_Diagnostics.AddError(methodDefinition, $"{nameof(ClientRpcParams)} must be the last parameter in a ClientRpc.");
                         }
-                        if (isServerRpc)
+                        if (!isClientRpc)
                         {
-                            m_Diagnostics.AddError($"ServerRpcs may not accept {nameof(ClientRpcParams)} as a parameter.");
+                            m_Diagnostics.AddError($"Only clientRpcs may accept {nameof(ClientRpcParams)} as a parameter.");
+                        }
+                        continue;
+                    }
+                    // RpcParams
+                    if (paramType.FullName == CodeGenHelpers.RpcParams_FullName)
+                    {
+                        if (paramIndex != paramCount - 1)
+                        {
+                            m_Diagnostics.AddError(methodDefinition, $"{nameof(RpcParams)} must be the last parameter in a ClientRpc.");
+                        }
+                        if (!isGenericRpc)
+                        {
+                            m_Diagnostics.AddError($"Only Rpcs may accept {nameof(RpcParams)} as a parameter.");
                         }
                         continue;
                     }
@@ -2251,7 +2463,7 @@ namespace Unity.Netcode.Editor.CodeGen
                     // __endSendServerRpc
                     instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_endSendServerRpc_MethodRef));
                 }
-                else
+                else if (isClientRpc)
                 {
                     // ClientRpc
 
@@ -2279,6 +2491,41 @@ namespace Unity.Netcode.Editor.CodeGen
                     // __endSendClientRpc
                     instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_endSendClientRpc_MethodRef));
                 }
+                else
+                {
+                    // Generic Rpc
+
+                    // __endSendRpc(ref bufferWriter, rpcMethodId, rpcParams, rpcAttributeParams, defaultTarget, rpcDelivery);
+                    instructions.Add(processor.Create(OpCodes.Ldarg_0));
+
+                    // bufferWriter
+                    instructions.Add(processor.Create(OpCodes.Ldloca, bufWriterLocIdx));
+
+                    // rpcMethodId
+                    instructions.Add(processor.Create(OpCodes.Ldc_I4, unchecked((int)rpcMethodId)));
+                    if (hasRpcParams)
+                    {
+                        // rpcParams
+                        instructions.Add(processor.Create(OpCodes.Ldarg, paramCount));
+                    }
+                    else
+                    {
+                        // default
+                        instructions.Add(processor.Create(OpCodes.Ldloc, rpcParamsIdx));
+                    }
+
+                    // rpcAttributeParams
+                    instructions.Add(processor.Create(OpCodes.Ldloc, rpcAttributeParamsIdx));
+
+                    // defaultTarget
+                    instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)defaultTarget));
+
+                    // rpcDelivery
+                    instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)rpcDelivery));
+
+                    // __endSendClientRpc
+                    instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_endSendRpc_MethodRef));
+                }
 
                 instructions.Add(lastInstr);
             }
@@ -2287,11 +2534,12 @@ namespace Unity.Netcode.Editor.CodeGen
                 var returnInstr = processor.Create(OpCodes.Ret);
                 var lastInstr = processor.Create(OpCodes.Nop);
 
-                // if (__rpc_exec_stage == __RpcExecStage.Server) -> ServerRpc
+                if (!isGenericRpc)
-                // if (__rpc_exec_stage == __RpcExecStage.Client) -> ClientRpc
+                {
+                    // if (__rpc_exec_stage == __RpcExecStage.Execute)
                     instructions.Add(processor.Create(OpCodes.Ldarg_0));
                     instructions.Add(processor.Create(OpCodes.Ldfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
-                instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)(isServerRpc ? NetworkBehaviour.__RpcExecStage.Server : NetworkBehaviour.__RpcExecStage.Client)));
+                    instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Execute));
                     instructions.Add(processor.Create(OpCodes.Ceq));
                     instructions.Add(processor.Create(OpCodes.Brfalse, returnInstr));
 
@@ -2303,9 +2551,36 @@ namespace Unity.Netcode.Editor.CodeGen
                     instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
                     instructions.Add(processor.Create(OpCodes.Callvirt, m_NetworkManager_getIsHost_MethodRef));
                     instructions.Add(processor.Create(OpCodes.Brtrue, lastInstr));
+                    instructions.Add(returnInstr);
+                    instructions.Add(lastInstr);
+
+                    // This needs to be set back before executing the callback or else sending another RPC
+                    // from within an RPC will not work.
+                    // __rpc_exec_stage = __RpcExecStage.Send
+                    instructions.Add(processor.Create(OpCodes.Ldarg_0));
+                    instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Send));
+                    instructions.Add(processor.Create(OpCodes.Stfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
+                }
+                else
+                {
+                    // if (__rpc_exec_stage == __RpcExecStage.Execute)
+                    instructions.Add(processor.Create(OpCodes.Ldarg_0));
+                    instructions.Add(processor.Create(OpCodes.Ldfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
+                    instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Execute));
+                    instructions.Add(processor.Create(OpCodes.Ceq));
+                    instructions.Add(processor.Create(OpCodes.Brtrue, lastInstr));
 
                     instructions.Add(returnInstr);
                     instructions.Add(lastInstr);
+
+                    // This needs to be set back before executing the callback or else sending another RPC
+                    // from within an RPC will not work.
+                    // __rpc_exec_stage = __RpcExecStage.Send
+                    instructions.Add(processor.Create(OpCodes.Ldarg_0));
+                    instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Send));
+                    instructions.Add(processor.Create(OpCodes.Stfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
+                }
+
             }
 
             instructions.Reverse();
@@ -2458,6 +2733,8 @@ namespace Unity.Netcode.Editor.CodeGen
             var processor = rpcHandler.Body.GetILProcessor();
 
             var isServerRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.ServerRpcAttribute_FullName;
+            var isCientRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.ClientRpcAttribute_FullName;
+            var isGenericRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.RpcAttribute_FullName;
             var requireOwnership = true; // default value MUST be == `ServerRpcAttribute.RequireOwnership`
             foreach (var attrField in rpcAttribute.Fields)
             {
@@ -2564,6 +2841,15 @@ namespace Unity.Netcode.Editor.CodeGen
                         processor.Emit(OpCodes.Stloc, localIndex);
                         continue;
                     }
+
+                    // RpcParams
+                    if (paramType.FullName == CodeGenHelpers.RpcParams_FullName)
+                    {
+                        processor.Emit(OpCodes.Ldarg_2);
+                        processor.Emit(OpCodes.Ldfld, m_RpcParams_Ext_FieldRef);
+                        processor.Emit(OpCodes.Stloc, localIndex);
+                        continue;
+                    }
                 }
 
                 Instruction jumpInstruction = null;
@@ -2690,7 +2976,7 @@ namespace Unity.Netcode.Editor.CodeGen
             // NetworkBehaviour.__rpc_exec_stage = __RpcExecStage.Server; -> ServerRpc
             // NetworkBehaviour.__rpc_exec_stage = __RpcExecStage.Client; -> ClientRpc
             processor.Emit(OpCodes.Ldarg_0);
-            processor.Emit(OpCodes.Ldc_I4, (int)(isServerRpc ? NetworkBehaviour.__RpcExecStage.Server : NetworkBehaviour.__RpcExecStage.Client));
+            processor.Emit(OpCodes.Ldc_I4, (int)(NetworkBehaviour.__RpcExecStage.Execute));
             processor.Emit(OpCodes.Stfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef);
 
             // NetworkBehaviour.XXXRpc(...);
@@ -2713,7 +2999,7 @@ namespace Unity.Netcode.Editor.CodeGen
 
             // NetworkBehaviour.__rpc_exec_stage = __RpcExecStage.None;
             processor.Emit(OpCodes.Ldarg_0);
-            processor.Emit(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.None);
+            processor.Emit(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Send);
             processor.Emit(OpCodes.Stfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef);
 
             processor.Emit(OpCodes.Ret);

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,6 +53,15 @@ 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;
@@ -154,6 +164,8 @@ namespace Unity.Netcode.Editor.CodeGen
                     methodDefinition.Name == nameof(NetworkBehaviour.__endSendServerRpc) ||
                     methodDefinition.Name == nameof(NetworkBehaviour.__beginSendClientRpc) ||
                     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) ||

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,17 +162,7 @@ namespace Unity.Netcode.Editor
                 .FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists));
         }
 
-        /// <inheritdoc/>
+        private void DrawAllPropertyFields()
-        public override void OnInspectorGUI()
-        {
-            Initialize();
-            CheckNullProperties();
-
-#if !MULTIPLAYER_TOOLS
-            DrawInstallMultiplayerToolsTip();
-#endif
-
-            if (!m_NetworkManager.IsServer && !m_NetworkManager.IsClient)
         {
             serializedObject.Update();
             EditorGUILayout.PropertyField(m_RunInBackgroundProperty);
@@ -158,85 +172,14 @@ namespace Unity.Netcode.Editor
             EditorGUILayout.PropertyField(m_PlayerPrefabProperty);
             EditorGUILayout.Space();
 
-                if (m_NetworkManager.NetworkConfig.HasOldPrefabList())
+            DrawPrefabListField();
-                {
-                    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);
+            DrawTransportField();
-
-                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);
 
@@ -255,7 +198,6 @@ namespace Unity.Netcode.Editor
             EditorGUILayout.LabelField("Spawning", EditorStyles.boldLabel);
             EditorGUILayout.PropertyField(m_ForceSamePrefabsProperty);
 
-
             EditorGUILayout.PropertyField(m_RecycleNetworkIdsProperty);
 
             using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.RecycleNetworkIds))
@@ -275,10 +217,86 @@ namespace Unity.Netcode.Editor
             }
 
             serializedObject.ApplyModifiedProperties();
+        }
 
-
+        private void DrawTransportField()
-                // Start buttons below
         {
+#if RELAY_INTEGRATION_AVAILABLE
+            var useRelay = EditorPrefs.GetBool(k_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)
+                {
+                    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 k_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(k_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(k_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)
@@ -287,6 +305,88 @@ namespace Unity.Netcode.Editor
                 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();
@@ -301,14 +401,9 @@ namespace Unity.Netcode.Editor
             {
                 m_NetworkManager.StartClient();
             }
+        }
 
-                    if (!EditorApplication.isPlaying)
+        private void DrawDisconnectButton()
-                    {
-                        GUI.enabled = true;
-                    }
-                }
-            }
-            else
         {
             string instanceType = string.Empty;
 
@@ -325,22 +420,53 @@ namespace Unity.Netcode.Editor
                 instanceType = "Client";
             }
 
-                EditorGUILayout.HelpBox("You cannot edit the NetworkConfig when a " + instanceType + " is running.", MessageType.Info);
+            EditorGUILayout.HelpBox($"You cannot edit the NetworkConfig when a {instanceType} is running.", MessageType.Info);
 
-                if (GUILayout.Button(new GUIContent("Stop " + instanceType, "Stops the " + instanceType + " instance.")))
+#if RELAY_INTEGRATION_AVAILABLE
+            if (!string.IsNullOrEmpty(m_JoinCode) && !string.IsNullOrEmpty(m_Region))
             {
+                var style = new GUIStyle(EditorStyles.helpBox)
+                {
+                    fontSize = 10,
+                    alignment = TextAnchor.MiddleCenter,
+                };
+
+                GUILayout.BeginHorizontal(style, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false), GUILayout.MaxWidth(800));
+                GUILayout.Label(new GUIContent(EditorGUIUtility.IconContent(k_InfoIconName)), GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true));
+                GUILayout.Space(25f);
+                GUILayout.BeginVertical();
+                GUILayout.Space(4f);
+                GUILayout.Label($"Connected via relay ({m_Region}).\nJoin code: {m_JoinCode}", EditorStyles.miniLabel, GUILayout.ExpandHeight(true));
+
+                if (GUILayout.Button("Copy code", GUILayout.ExpandHeight(true)))
+                {
+                    GUIUtility.systemCopyBuffer = m_JoinCode;
+                }
+
+                GUILayout.Space(4f);
+                GUILayout.EndVertical();
+                GUILayout.Space(2f);
+                GUILayout.EndHorizontal();
+            }
+#endif
+
+            if (GUILayout.Button(new GUIContent($"Stop {instanceType}", $"Stops the {instanceType} instance.")))
+            {
+#if RELAY_INTEGRATION_AVAILABLE
+                m_JoinCode = "";
+#endif
                 m_NetworkManager.Shutdown();
             }
         }
-        }
 
+        private const string k_InfoIconName = "console.infoicon";
         private static void DrawInstallMultiplayerToolsTip()
         {
             const string getToolsText = "Access additional tools for multiplayer development by installing the Multiplayer Tools package in the Package Manager.";
             const string openDocsButtonText = "Open Docs";
             const string dismissButtonText = "Dismiss";
             const string targetUrl = "https://docs-multiplayer.unity3d.com/tools/current/install-tools";
-            const string infoIconName = "console.infoicon";
+
 
             if (NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() != 0)
             {
@@ -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;
@@ -39,6 +40,7 @@ namespace Unity.Netcode.Editor
         /// <inheritdoc/>
         public void OnEnable()
         {
+            m_UseUnreliableDeltas = serializedObject.FindProperty(nameof(NetworkTransform.UseUnreliableDeltas));
             m_SyncPositionXProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionX));
             m_SyncPositionYProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionY));
             m_SyncPositionZProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionZ));
@@ -129,7 +131,9 @@ 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);

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.

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>();
 
@@ -234,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;
                 }
@@ -262,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)
         {
@@ -296,29 +303,17 @@ 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);
+                        if (!OverrideToNetworkPrefab.ContainsKey(target))
+                        {
                             OverrideToNetworkPrefab.Add(target, source);
                         }
+                    }
                     break;
             }
 

Runtime/Connection/NetworkConnectionManager.cs

@@ -10,6 +10,38 @@ using Object = UnityEngine.Object;
 
 namespace Unity.Netcode
 {
+
+    public enum ConnectionEvent
+    {
+        ClientConnected,
+        PeerConnected,
+        ClientDisconnected,
+        PeerDisconnected
+    }
+
+    public struct ConnectionEventData
+    {
+        public ConnectionEvent EventType;
+
+        /// <summary>
+        /// The client ID for the client that just connected
+        /// For the <see cref="ConnectionEvent.ClientConnected"/> and <see cref="ConnectionEvent.ClientDisconnected"/>
+        /// events on the client side, this will be LocalClientId.
+        /// On the server side, this will be the ID of the client that just connected.
+        ///
+        /// For the <see cref="ConnectionEvent.PeerConnected"/> and <see cref="ConnectionEvent.PeerDisconnected"/>
+        /// events on the client side, this will be the client ID assigned by the server to the remote peer.
+        /// </summary>
+        public ulong ClientId;
+
+        /// <summary>
+        /// This is only populated in <see cref="ConnectionEvent.ClientConnected"/> on the client side, and
+        /// contains the list of other peers who were present before you connected. In all other situations,
+        /// this array will be uninitialized.
+        /// </summary>
+        public NativeArray<ulong> PeerClientIds;
+    }
+
     /// <summary>
     /// The NGO connection manager handles:
     /// - Client Connections
@@ -42,7 +74,105 @@ namespace Unity.Netcode
         /// </summary>
         public event Action<ulong> OnClientDisconnectCallback = null;
 
-        internal void InvokeOnClientConnectedCallback(ulong clientId) => OnClientConnectedCallback?.Invoke(clientId);
+        /// <summary>
+        /// The callback to invoke once a peer connects. This callback is only ran on the server and on the local client that connects.
+        /// </summary>
+        public event Action<NetworkManager, ConnectionEventData> OnConnectionEvent = null;
+
+
+        internal void InvokeOnClientConnectedCallback(ulong clientId)
+        {
+            try
+            {
+                OnClientConnectedCallback?.Invoke(clientId);
+            }
+            catch (Exception exception)
+            {
+                Debug.LogException(exception);
+            }
+
+            if (!NetworkManager.IsServer)
+            {
+                var peerClientIds = new NativeArray<ulong>(Math.Max(NetworkManager.ConnectedClientsIds.Count - 1, 0), Allocator.Temp);
+                // `using var peerClientIds` or `using(peerClientIds)` renders it immutable...
+                using var sentinel = peerClientIds;
+
+                var idx = 0;
+                foreach (var peerId in NetworkManager.ConnectedClientsIds)
+                {
+                    if (peerId == NetworkManager.LocalClientId)
+                    {
+                        continue;
+                    }
+
+                    peerClientIds[idx] = peerId;
+                    ++idx;
+                }
+
+                try
+                {
+                    OnConnectionEvent?.Invoke(NetworkManager, new ConnectionEventData { ClientId = NetworkManager.LocalClientId, EventType = ConnectionEvent.ClientConnected, PeerClientIds = peerClientIds });
+                }
+                catch (Exception exception)
+                {
+                    Debug.LogException(exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    OnConnectionEvent?.Invoke(NetworkManager, new ConnectionEventData { ClientId = clientId, EventType = ConnectionEvent.ClientConnected });
+                }
+                catch (Exception exception)
+                {
+                    Debug.LogException(exception);
+                }
+            }
+        }
+
+        internal void InvokeOnClientDisconnectCallback(ulong clientId)
+        {
+            try
+            {
+                OnClientDisconnectCallback?.Invoke(clientId);
+            }
+            catch (Exception exception)
+            {
+                Debug.LogException(exception);
+            }
+            try
+            {
+                OnConnectionEvent?.Invoke(NetworkManager, new ConnectionEventData { ClientId = clientId, EventType = ConnectionEvent.ClientDisconnected });
+            }
+            catch (Exception exception)
+            {
+                Debug.LogException(exception);
+            }
+        }
+
+        internal void InvokeOnPeerConnectedCallback(ulong clientId)
+        {
+            try
+            {
+                OnConnectionEvent?.Invoke(NetworkManager, new ConnectionEventData { ClientId = clientId, EventType = ConnectionEvent.PeerConnected });
+            }
+            catch (Exception exception)
+            {
+                Debug.LogException(exception);
+            }
+        }
+        internal void InvokeOnPeerDisconnectedCallback(ulong clientId)
+        {
+            try
+            {
+                OnConnectionEvent?.Invoke(NetworkManager, new ConnectionEventData { ClientId = clientId, EventType = ConnectionEvent.PeerDisconnected });
+            }
+            catch (Exception exception)
+            {
+                Debug.LogException(exception);
+            }
+        }
 
         /// <summary>
         /// The callback to invoke if the <see cref="NetworkTransport"/> fails.
@@ -217,7 +347,7 @@ namespace Unity.Netcode
             // When this happens, the client will not have an entry within the m_TransportIdToClientIdMap or m_ClientIdToTransportIdMap lookup tables so we exit early and just return 0 to be used for the disconnect event.
             if (!LocalClient.IsServer && !TransportIdToClientIdMap.ContainsKey(transportId))
             {
-                return 0;
+                return NetworkManager.LocalClientId;
             }
 
             var clientId = TransportIdToClientId(transportId);
@@ -346,31 +476,38 @@ namespace Unity.Netcode
             s_TransportDisconnect.Begin();
 #endif
             var clientId = TransportIdCleanUp(transportClientId);
-
             if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
             {
                 NetworkLog.LogInfo($"Disconnect Event From {clientId}");
             }
 
+            // If we are a client and we have gotten the ServerClientId back, then use our assigned local id as the client that was
+            // disconnected (either the user disconnected or the server disconnected, but the client that disconnected is the LocalClientId)
+            if (!NetworkManager.IsServer && clientId == NetworkManager.ServerClientId)
+            {
+                clientId = NetworkManager.LocalClientId;
+            }
+
             // Process the incoming message queue so that we get everything from the server disconnecting us or, if we are the server, so we got everything from that client.
             MessageManager.ProcessIncomingMessageQueue();
 
-            try
+            InvokeOnClientDisconnectCallback(clientId);
+
+            if (LocalClient.IsHost)
             {
-                OnClientDisconnectCallback?.Invoke(clientId);
+                InvokeOnPeerDisconnectedCallback(clientId);
-            }
-            catch (Exception exception)
-            {
-                Debug.LogException(exception);
             }
 
             if (LocalClient.IsServer)
             {
                 OnClientDisconnectFromServer(clientId);
             }
-            else
+            else // As long as we are not in the middle of a shutdown
+            if (!NetworkManager.ShutdownInProgress)
             {
-                // We must pass true here and not process any sends messages as we are no longer connected and thus there is no one to send any messages to and this will cause an exception within UnityTransport as the client ID is no longer valid.
+                // We must pass true here and not process any sends messages as we are no longer connected.
+                // Otherwise, attempting to process messages here can cause an exception within UnityTransport
+                // as the client ID is no longer valid.
                 NetworkManager.Shutdown(true);
             }
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
@@ -623,8 +760,17 @@ namespace Unity.Netcode
                     var message = new ConnectionApprovedMessage
                     {
                         OwnerClientId = ownerClientId,
-                        NetworkTick = NetworkManager.LocalTime.Tick
+                        NetworkTick = NetworkManager.LocalTime.Tick,
+                        ConnectedClientIds = new NativeArray<ulong>(ConnectedClientIds.Count, Allocator.Temp)
                     };
+
+                    var i = 0;
+                    foreach (var clientId in ConnectedClientIds)
+                    {
+                        message.ConnectedClientIds[i] = clientId;
+                        ++i;
+                    }
+
                     if (!NetworkManager.NetworkConfig.EnableSceneManagement)
                     {
                         // Update the observed spawned NetworkObjects for the newly connected player when scene management is disabled
@@ -651,12 +797,17 @@ namespace Unity.Netcode
 
                     SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ownerClientId);
                     message.MessageVersions.Dispose();
+                    message.ConnectedClientIds.Dispose();
 
                     // If scene management is disabled, then we are done and notify the local host-server the client is connected
                     if (!NetworkManager.NetworkConfig.EnableSceneManagement)
                     {
                         NetworkManager.ConnectedClients[ownerClientId].IsConnected = true;
                         InvokeOnClientConnectedCallback(ownerClientId);
+                        if (LocalClient.IsHost)
+                        {
+                            InvokeOnPeerConnectedCallback(ownerClientId);
+                        }
                     }
                     else // Otherwise, let NetworkSceneManager handle the initial scene and NetworkObject synchronization
                     {
@@ -740,6 +891,8 @@ namespace Unity.Netcode
 
             ConnectedClients.Add(clientId, networkClient);
             ConnectedClientsList.Add(networkClient);
+            var message = new ClientConnectedMessage { ClientId = clientId };
+            NetworkManager.MessageManager.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ConnectedClientIds);
             ConnectedClientIds.Add(clientId);
             return networkClient;
         }
@@ -757,6 +910,7 @@ namespace Unity.Netcode
 
             // If we are shutting down and this is the server or host disconnecting, then ignore
             // clean up as everything that needs to be destroyed will be during shutdown.
+
             if (NetworkManager.ShutdownInProgress && clientId == NetworkManager.ServerClientId)
             {
                 return;
@@ -780,7 +934,7 @@ namespace Unity.Netcode
                             NetworkManager.SpawnManager.DespawnObject(playerObject, true);
                         }
                     }
-                    else
+                    else if (!NetworkManager.ShutdownInProgress)
                     {
                         playerObject.RemoveOwnership();
                     }
@@ -816,7 +970,7 @@ namespace Unity.Netcode
                                     Object.Destroy(ownedObject.gameObject);
                                 }
                             }
-                            else
+                            else if (!NetworkManager.ShutdownInProgress)
                             {
                                 ownedObject.RemoveOwnership();
                             }
@@ -837,6 +991,8 @@ namespace Unity.Netcode
                 }
 
                 ConnectedClientIds.Remove(clientId);
+                var message = new ClientDisconnectedMessage { ClientId = clientId };
+                MessageManager?.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ConnectedClientIds);
             }
 
             // If the client ID transport map exists
@@ -845,13 +1001,11 @@ namespace Unity.Netcode
                 var transportId = ClientIdToTransportId(clientId);
                 NetworkManager.NetworkConfig.NetworkTransport.DisconnectRemoteClient(transportId);
 
-                try
+                InvokeOnClientDisconnectCallback(clientId);
+
+                if (LocalClient.IsHost)
                 {
-                    OnClientDisconnectCallback?.Invoke(clientId);
+                    InvokeOnPeerDisconnectedCallback(clientId);
-                }
-                catch (Exception exception)
-                {
-                    Debug.LogException(exception);
                 }
 
                 // Clean up the transport to client (and vice versa) mappings
@@ -889,6 +1043,12 @@ namespace Unity.Netcode
                 throw new NotServerException($"Only server can disconnect remote clients. Please use `{nameof(Shutdown)}()` instead.");
             }
 
+            if (clientId == NetworkManager.ServerClientId)
+            {
+                Debug.LogWarning($"Disconnecting the local server-host client is not allowed. Use NetworkManager.Shutdown instead.");
+                return;
+            }
+
             if (!string.IsNullOrEmpty(reason))
             {
                 var disconnectReason = new DisconnectReasonMessage
@@ -933,13 +1093,8 @@ namespace Unity.Netcode
         /// </summary>
         internal void Shutdown()
         {
-            LocalClient.IsApproved = false;
-            LocalClient.IsConnected = false;
             if (LocalClient.IsServer)
             {
-                // make sure all messages are flushed before transport disconnect clients
-                MessageManager?.ProcessSendQueues();
-
                 // Build a list of all client ids to be disconnected
                 var disconnectedIds = new HashSet<ulong>();
 
@@ -975,9 +1130,15 @@ namespace Unity.Netcode
                 {
                     DisconnectRemoteClient(clientId);
                 }
+
+                // make sure all messages are flushed before transport disconnects clients
+                MessageManager?.ProcessSendQueues();
             }
             else if (NetworkManager != null && NetworkManager.IsListening && LocalClient.IsClient)
             {
+                // make sure all messages are flushed before disconnecting
+                MessageManager?.ProcessSendQueues();
+
                 // Client only, send disconnect and if transport throws and exception, log the exception and continue the shutdown sequence (or forever be shutting down)
                 try
                 {
@@ -989,6 +1150,12 @@ namespace Unity.Netcode
                 }
             }
 
+            LocalClient.IsApproved = false;
+            LocalClient.IsConnected = false;
+            ConnectedClients.Clear();
+            ConnectedClientIds.Clear();
+            ConnectedClientsList.Clear();
+
             if (NetworkManager != null && NetworkManager.NetworkConfig?.NetworkTransport != null)
             {
                 NetworkManager.NetworkConfig.NetworkTransport.OnTransportEvent -= HandleNetworkEvent;

Runtime/Core/NetworkBehaviour.cs

@@ -6,6 +6,14 @@ 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>
@@ -27,16 +35,22 @@ namespace Unity.Netcode
         // 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
@@ -284,6 +298,99 @@ 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
@@ -315,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.
@@ -331,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>
@@ -472,12 +602,13 @@ 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;
             }
         }

Runtime/Core/NetworkManager.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Unity.Collections;
 using UnityEngine;
 #if UNITY_EDITOR
 using UnityEditor;
@@ -42,6 +43,8 @@ namespace Unity.Netcode
                         ConnectionManager.ProcessPendingApprovals();
                         ConnectionManager.PollAndHandleNetworkEvents();
 
+                        DeferredMessageManager.ProcessTriggers(IDeferredNetworkMessageManager.TriggerType.OnNextFrame, 0);
+
                         MessageManager.ProcessIncomingMessageQueue();
                         MessageManager.CleanupDisconnectedClients();
                     }
@@ -70,13 +73,89 @@ namespace Unity.Netcode
 
                         if (m_ShuttingDown)
                         {
+                            // Host-server will disconnect any connected clients prior to finalizing its shutdown
+                            if (IsServer)
+                            {
+                                ProcessServerShutdown();
+                            }
+                            else
+                            {
+                                // Clients just disconnect immediately
                                 ShutdownInternal();
                             }
                         }
+                    }
                     break;
             }
         }
 
+        /// <summary>
+        /// Used to provide a graceful shutdown sequence
+        /// </summary>
+        internal enum ServerShutdownStates
+        {
+            None,
+            WaitForClientDisconnects,
+            InternalShutdown,
+            ShuttingDown,
+        };
+
+        internal ServerShutdownStates ServerShutdownState;
+        private float m_ShutdownTimeout;
+
+        /// <summary>
+        /// This is a "soft shutdown" where the host or server will disconnect
+        /// all clients, with a provided reasons, prior to invoking its final
+        /// internal shutdown.
+        /// </summary>
+        internal void ProcessServerShutdown()
+        {
+            var minClientCount = IsHost ? 2 : 1;
+            switch (ServerShutdownState)
+            {
+                case ServerShutdownStates.None:
+                    {
+                        if (ConnectedClients.Count >= minClientCount)
+                        {
+                            var hostServer = IsHost ? "host" : "server";
+                            var disconnectReason = $"Disconnected due to {hostServer} shutting down.";
+                            for (int i = ConnectedClientsIds.Count - 1; i >= 0; i--)
+                            {
+                                var clientId = ConnectedClientsIds[i];
+                                if (clientId == ServerClientId)
+                                {
+                                    continue;
+                                }
+                                ConnectionManager.DisconnectClient(clientId, disconnectReason);
+                            }
+                            ServerShutdownState = ServerShutdownStates.WaitForClientDisconnects;
+                            m_ShutdownTimeout = Time.realtimeSinceStartup + 5.0f;
+                        }
+                        else
+                        {
+                            ServerShutdownState = ServerShutdownStates.InternalShutdown;
+                            ProcessServerShutdown();
+                        }
+                        break;
+                    }
+                case ServerShutdownStates.WaitForClientDisconnects:
+                    {
+                        if (ConnectedClients.Count < minClientCount || m_ShutdownTimeout < Time.realtimeSinceStartup)
+                        {
+                            ServerShutdownState = ServerShutdownStates.InternalShutdown;
+                            ProcessServerShutdown();
+                        }
+                        break;
+                    }
+                case ServerShutdownStates.InternalShutdown:
+                    {
+                        ServerShutdownState = ServerShutdownStates.ShuttingDown;
+                        ShutdownInternal();
+                        break;
+                    }
+            }
+        }
+
         /// <summary>
         /// The client id used to represent the server
         /// </summary>
@@ -104,7 +183,7 @@ namespace Unity.Netcode
         /// <summary>
         /// Gets a list of just the IDs of all connected clients. This is only accessible on the server.
         /// </summary>
-        public IReadOnlyList<ulong> ConnectedClientsIds => IsServer ? ConnectionManager.ConnectedClientIds : throw new NotServerException($"{nameof(ConnectionManager.ConnectedClientIds)} should only be accessed on server.");
+        public IReadOnlyList<ulong> ConnectedClientsIds => ConnectionManager.ConnectedClientIds;
 
         /// <summary>
         /// Gets the local <see cref="NetworkClient"/> for this client.
@@ -122,6 +201,11 @@ namespace Unity.Netcode
         /// </summary>
         public bool IsServer => ConnectionManager.LocalClient.IsServer;
 
+        /// <summary>
+        /// Gets whether or not the current server (local or remote) is a host - i.e., also a client
+        /// </summary>
+        public bool ServerIsHost => ConnectionManager.ConnectedClientIds.Contains(ServerClientId);
+
         /// <summary>
         /// Gets Whether or not a client is running
         /// </summary>
@@ -209,6 +293,8 @@ namespace Unity.Netcode
 
         /// <summary>
         /// The callback to invoke once a client connects. This callback is only ran on the server and on the local client that connects.
+        ///
+        /// It is recommended to use OnConnectionEvent instead, as this will eventually be deprecated
         /// </summary>
         public event Action<ulong> OnClientConnectedCallback
         {
@@ -218,6 +304,8 @@ namespace Unity.Netcode
 
         /// <summary>
         /// The callback to invoke when a client disconnects. This callback is only ran on the server and on the local client that disconnects.
+        ///
+        /// It is recommended to use OnConnectionEvent instead, as this will eventually be deprecated
         /// </summary>
         public event Action<ulong> OnClientDisconnectCallback
         {
@@ -225,6 +313,16 @@ namespace Unity.Netcode
             remove => ConnectionManager.OnClientDisconnectCallback -= value;
         }
 
+        /// <summary>
+        /// The callback to invoke on any connection event. See <see cref="ConnectionEvent"/> and <see cref="ConnectionEventData"/>
+        /// for more info.
+        /// </summary>
+        public event Action<NetworkManager, ConnectionEventData> OnConnectionEvent
+        {
+            add => ConnectionManager.OnConnectionEvent += value;
+            remove => ConnectionManager.OnConnectionEvent -= value;
+        }
+
         /// <summary>
         /// The current host name we are connected to, used to validate certificate
         /// </summary>
@@ -379,6 +477,24 @@ namespace Unity.Netcode
 
         internal IDeferredNetworkMessageManager DeferredMessageManager { get; private set; }
 
+        // 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;
+
         /// <summary>
         /// Gets the CustomMessagingManager for this NetworkManager
         /// </summary>
@@ -664,6 +780,12 @@ namespace Unity.Netcode
 
         internal void Initialize(bool server)
         {
+            // Make sure the ServerShutdownState is reset when initializing
+            if (server)
+            {
+                ServerShutdownState = ServerShutdownStates.None;
+            }
+
             // Don't allow the user to start a network session if the NetworkManager is
             // still parented under another GameObject
             if (NetworkManagerCheckForParent(true))
@@ -729,6 +851,8 @@ namespace Unity.Netcode
 
             DeferredMessageManager = ComponentFactory.Create<IDeferredNetworkMessageManager>(this);
 
+            RpcTarget = new RpcTarget(this);
+
             CustomMessagingManager = new CustomMessagingManager(this);
 
             SceneManager = new NetworkSceneManager(this);
@@ -929,6 +1053,7 @@ namespace Unity.Netcode
         {
             LocalClientId = ServerClientId;
             NetworkMetrics.SetConnectionId(LocalClientId);
+            MessageManager.SetLocalClientId(LocalClientId);
 
             if (NetworkConfig.ConnectionApproval && ConnectionApprovalCallback != null)
             {
@@ -1007,11 +1132,6 @@ namespace Unity.Netcode
                     MessageManager.StopProcessing = discardMessageQueue;
                 }
             }
-
-            if (NetworkConfig != null && NetworkConfig.NetworkTransport != null)
-            {
-                NetworkConfig.NetworkTransport.OnTransportEvent -= ConnectionManager.HandleNetworkEvent;
-            }
         }
 
         // Ensures that the NetworkManager is cleaned up before OnDestroy is run on NetworkObjects and NetworkBehaviours when unloading a scene with a NetworkManager
@@ -1036,6 +1156,9 @@ namespace Unity.Netcode
             DeferredMessageManager?.CleanupAllTriggers();
             CustomMessagingManager = null;
 
+            RpcTarget?.Dispose();
+            RpcTarget = null;
+
             BehaviourUpdater?.Shutdown();
             BehaviourUpdater = null;
 

Runtime/Core/NetworkObject.cs

@@ -26,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>
@@ -33,19 +49,11 @@ namespace Unity.Netcode
         public uint PrefabIdHash
         {
             get
-            {
-                foreach (var prefab in NetworkManager.NetworkConfig.Prefabs.Prefabs)
-                {
-                    if (prefab.Prefab == gameObject)
             {
                 return GlobalObjectIdHash;
             }
         }
 
-                return 0;
-            }
-        }
-
 #if UNITY_EDITOR
         private const string k_GlobalIdTemplate = "GlobalObjectId_V1-{0}-{1}-{2}-{3}";
 
@@ -149,6 +157,9 @@ namespace Unity.Netcode
                     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()
@@ -164,6 +175,33 @@ namespace Unity.Netcode
             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);
@@ -703,7 +741,7 @@ namespace Unity.Netcode
                     // 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($"Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call {nameof(Destroy)} or {nameof(Despawn)} on the server/host instead.");
+                        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;
                 }
@@ -720,7 +758,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)
             {
@@ -743,6 +781,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>
@@ -969,20 +1079,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)
@@ -1017,16 +1128,37 @@ namespace Unity.Netcode
             }
 
             if (!NetworkManager.IsServer)
+            {
+                // 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)
+            {
+                // ,,,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;
@@ -1869,16 +2001,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/Messaging/DeferredMessageManager.cs

@@ -113,6 +113,7 @@ 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
@@ -120,7 +121,6 @@ namespace Unity.Netcode
                     }
 
                     triggerInfo.TriggerData.Dispose();
-                    triggers.Remove(key);
                 }
             }
         }

Runtime/Messaging/IDeferredNetworkMessageManager.cs

@@ -6,6 +6,7 @@ namespace Unity.Netcode
         {
             OnSpawn,
             OnAddPrefab,
+            OnNextFrame,
         }
 
         /// <summary>

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,6 +39,11 @@ 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
@@ -106,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;
         }
@@ -114,6 +132,7 @@ 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);
@@ -126,6 +145,12 @@ namespace Unity.Netcode
             // 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)
             {
@@ -146,6 +171,8 @@ namespace Unity.Netcode
                 // When scene management is disabled we notify after everything is synchronized
                 networkManager.ConnectionManager.InvokeOnClientConnectedCallback(context.SenderId);
             }
+
+            ConnectedClientIds.Dispose();
         }
     }
 }

Runtime/Messaging/Messages/CreateObjectMessage.cs

@@ -1,3 +1,4 @@
+using System.Runtime.CompilerServices;
 namespace Unity.Netcode
 {
     internal struct CreateObjectMessage : INetworkMessage
@@ -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/NamedMessage.cs

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

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

@@ -159,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/NetworkManagerHooks.cs

@@ -1,4 +1,5 @@
 using System;
+using Unity.Netcode.Transports.UTP;
 
 namespace Unity.Netcode
 {
@@ -56,7 +57,8 @@ namespace Unity.Netcode
                 {
                     if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                     {
-                        NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side. 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)}");
+                        var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
+                        NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side. {transportErrorMsg}");
                     }
 
                     return false;
@@ -66,7 +68,7 @@ namespace Unity.Netcode
                 {
                     if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                     {
-                        NetworkLog.LogWarning($"Message received from {nameof(senderId)}={senderId} before it has been accepted");
+                        NetworkLog.LogWarning($"Message received from {nameof(senderId)}={senderId} before it has been accepted.");
                     }
 
                     return false;
@@ -76,7 +78,8 @@ namespace Unity.Netcode
                 {
                     if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                     {
-                        NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from a client when the connection has already been established. 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)}");
+                        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;
@@ -88,7 +91,8 @@ namespace Unity.Netcode
                 {
                     if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                     {
-                        NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side. 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)}");
+                        var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
+                        NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side. {transportErrorMsg}");
                     }
 
                     return false;
@@ -98,7 +102,8 @@ namespace Unity.Netcode
                 {
                     if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                     {
-                        NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from the server when the connection has already been established. 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)}");
+                        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;
@@ -108,6 +113,28 @@ namespace Unity.Netcode
             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
         {
         }

Runtime/Messaging/NetworkMessageManager.cs

@@ -85,6 +85,8 @@ namespace Unity.Netcode
         private INetworkMessageSender m_Sender;
         private bool m_Disposed;
 
+        private ulong m_LocalClientId;
+
         internal Type[] MessageTypes => m_ReverseTypeMap;
         internal MessageHandler[] MessageHandlers => m_MessageHandlers;
 
@@ -95,6 +97,16 @@ namespace Unity.Netcode
             return m_MessageTypes[t];
         }
 
+        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;
@@ -551,7 +563,7 @@ namespace Unity.Netcode
             // 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 = manager.GetMessageVersion(typeof(T), context.SenderId, true);
                 if (messageVersion < 0)
@@ -808,6 +820,12 @@ 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)

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>
+        public new bool RequireOwnership;
-        /// Whether or not the ServerRpc should only be run if executed by the owner of the object
+
-        /// </summary>
+        public ServerRpcAttribute() : base(SendTo.Server)
-        public bool RequireOwnership = true;
+        {
+
+        }
     }
 
     /// <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
+            var size =
+#endif
+                behaviour.NetworkManager.MessageManager.SendMessage(ref message, delivery, clientId);
+
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+            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);
+        }
+    }
+}

Runtime/Messaging/RpcTargets/EveryoneRpcTarget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 675d4a5c79fc47078092ac15d255745d
+timeCreated: 1697824941

Runtime/Messaging/RpcTargets/IGroupRpcTarget.cs

@@ -0,0 +1,9 @@
+namespace Unity.Netcode
+{
+    internal interface IGroupRpcTarget
+    {
+        void Add(ulong clientId);
+        void Clear();
+        BaseRpcTarget Target { get; }
+    }
+}

Runtime/Messaging/RpcTargets/IGroupRpcTarget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: beb19a6bb1334252a89b21c8490f7cbe
+timeCreated: 1697825109

Runtime/Messaging/RpcTargets/IIndividualRpcTarget.cs

@@ -0,0 +1,8 @@
+namespace Unity.Netcode
+{
+    internal interface IIndividualRpcTarget
+    {
+        void SetClientId(ulong clientId);
+        BaseRpcTarget Target { get; }
+    }
+}

Runtime/Messaging/RpcTargets/IIndividualRpcTarget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c658d9641f564d9890bef4f558f1cea6
+timeCreated: 1697825115

Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs

@@ -0,0 +1,67 @@
+using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
+
+namespace Unity.Netcode
+{
+    internal class LocalSendRpcTarget : BaseRpcTarget
+    {
+        public override void Dispose()
+        {
+
+        }
+
+        internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
+        {
+            var networkManager = behaviour.NetworkManager;
+            var context = new NetworkContext
+            {
+                SenderId = m_NetworkManager.LocalClientId,
+                Timestamp = networkManager.RealTimeProvider.RealTimeSinceStartup,
+                SystemOwner = networkManager,
+                // header information isn't valid since it's not a real message.
+                // RpcMessage doesn't access this stuff so it's just left empty.
+                Header = new NetworkMessageHeader(),
+                SerializedHeaderSize = 0,
+                MessageSize = 0
+            };
+            int length;
+            if (rpcParams.Send.LocalDeferMode == LocalDeferMode.Defer)
+            {
+                using var serializedWriter = new FastBufferWriter(message.WriteBuffer.Length + UnsafeUtility.SizeOf<RpcMetadata>(), Allocator.Temp, int.MaxValue);
+                message.Serialize(serializedWriter, message.Version);
+                using var reader = new FastBufferReader(serializedWriter, Allocator.None);
+                context.Header = new NetworkMessageHeader
+                {
+                    MessageSize = (uint)reader.Length,
+                    MessageType = m_NetworkManager.MessageManager.GetMessageType(typeof(RpcMessage))
+                };
+
+                behaviour.NetworkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnNextFrame, 0, reader, ref context);
+                length = reader.Length;
+            }
+            else
+            {
+                using var tempBuffer = new FastBufferReader(message.WriteBuffer, Allocator.None);
+                message.ReadBuffer = tempBuffer;
+                message.Handle(ref context);
+                length = tempBuffer.Length;
+            }
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+            if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
+            {
+                behaviour.NetworkManager.NetworkMetrics.TrackRpcSent(
+                    behaviour.NetworkManager.LocalClientId,
+                    behaviour.NetworkObject,
+                    rpcMethodName,
+                    behaviour.__getTypeName(),
+                    length);
+            }
+#endif
+        }
+
+        internal LocalSendRpcTarget(NetworkManager manager) : base(manager)
+        {
+
+        }
+    }
+}

Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c3b290cdc20d4d2293652ec79652962a
+timeCreated: 1697824985

Runtime/Messaging/RpcTargets/NotMeRpcTarget.cs

@@ -0,0 +1,67 @@
+namespace Unity.Netcode
+{
+    internal class NotMeRpcTarget : BaseRpcTarget
+    {
+        private IGroupRpcTarget m_GroupSendTarget;
+        private ServerRpcTarget m_ServerRpcTarget;
+
+        public override void Dispose()
+        {
+            m_ServerRpcTarget.Dispose();
+            if (m_GroupSendTarget != null)
+            {
+                m_GroupSendTarget.Target.Dispose();
+                m_GroupSendTarget = null;
+            }
+        }
+
+        internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
+        {
+            if (m_GroupSendTarget == null)
+            {
+                if (behaviour.IsServer)
+                {
+                    m_GroupSendTarget = new RpcTargetGroup(m_NetworkManager);
+                }
+                else
+                {
+                    m_GroupSendTarget = new ProxyRpcTargetGroup(m_NetworkManager);
+                }
+            }
+
+            m_GroupSendTarget.Clear();
+            if (behaviour.IsServer)
+            {
+                foreach (var clientId in behaviour.NetworkObject.Observers)
+                {
+                    if (clientId == behaviour.NetworkManager.LocalClientId)
+                    {
+                        continue;
+                    }
+                    m_GroupSendTarget.Add(clientId);
+                }
+            }
+            else
+            {
+                foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
+                {
+                    if (clientId == behaviour.NetworkManager.LocalClientId)
+                    {
+                        continue;
+                    }
+                    m_GroupSendTarget.Add(clientId);
+                }
+            }
+            m_GroupSendTarget.Target.Send(behaviour, ref message, delivery, rpcParams);
+            if (!behaviour.IsServer)
+            {
+                m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+            }
+        }
+
+        internal NotMeRpcTarget(NetworkManager manager) : base(manager)
+        {
+            m_ServerRpcTarget = new ServerRpcTarget(manager);
+        }
+    }
+}

Runtime/Messaging/RpcTargets/NotMeRpcTarget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 99cd5e8be7bd454bab700ee08b8dad7b
+timeCreated: 1697824966

Runtime/Messaging/RpcTargets/NotOwnerRpcTarget.cs

@@ -0,0 +1,83 @@
+namespace Unity.Netcode
+{
+    internal class NotOwnerRpcTarget : BaseRpcTarget
+    {
+        private IGroupRpcTarget m_GroupSendTarget;
+        private ServerRpcTarget m_ServerRpcTarget;
+        private LocalSendRpcTarget m_LocalSendRpcTarget;
+
+        public override void Dispose()
+        {
+            m_ServerRpcTarget.Dispose();
+            m_LocalSendRpcTarget.Dispose();
+            if (m_GroupSendTarget != null)
+            {
+                m_GroupSendTarget.Target.Dispose();
+                m_GroupSendTarget = null;
+            }
+        }
+
+        internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
+        {
+            if (m_GroupSendTarget == null)
+            {
+                if (behaviour.IsServer)
+                {
+                    m_GroupSendTarget = new RpcTargetGroup(m_NetworkManager);
+                }
+                else
+                {
+                    m_GroupSendTarget = new ProxyRpcTargetGroup(m_NetworkManager);
+                }
+            }
+            m_GroupSendTarget.Clear();
+
+            if (behaviour.IsServer)
+            {
+                foreach (var clientId in behaviour.NetworkObject.Observers)
+                {
+                    if (clientId == behaviour.OwnerClientId)
+                    {
+                        continue;
+                    }
+                    if (clientId == behaviour.NetworkManager.LocalClientId)
+                    {
+                        m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+                        continue;
+                    }
+
+                    m_GroupSendTarget.Add(clientId);
+                }
+            }
+            else
+            {
+                foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
+                {
+                    if (clientId == behaviour.OwnerClientId)
+                    {
+                        continue;
+                    }
+                    if (clientId == behaviour.NetworkManager.LocalClientId)
+                    {
+                        m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+                        continue;
+                    }
+
+                    m_GroupSendTarget.Add(clientId);
+                }
+            }
+
+            m_GroupSendTarget.Target.Send(behaviour, ref message, delivery, rpcParams);
+            if (behaviour.OwnerClientId != NetworkManager.ServerClientId)
+            {
+                m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+            }
+        }
+
+        internal NotOwnerRpcTarget(NetworkManager manager) : base(manager)
+        {
+            m_ServerRpcTarget = new ServerRpcTarget(manager);
+            m_LocalSendRpcTarget = new LocalSendRpcTarget(manager);
+        }
+    }
+}

Runtime/Messaging/RpcTargets/NotOwnerRpcTarget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d7bc66c5253b44d09ad978ea9e51c96f
+timeCreated: 1698789420

Runtime/Messaging/RpcTargets/NotServerRpcTarget.cs

@@ -0,0 +1,72 @@
+namespace Unity.Netcode
+{
+    internal class NotServerRpcTarget : BaseRpcTarget
+    {
+        private IGroupRpcTarget m_GroupSendTarget;
+        private LocalSendRpcTarget m_LocalSendRpcTarget;
+
+        public override void Dispose()
+        {
+            m_LocalSendRpcTarget.Dispose();
+            if (m_GroupSendTarget != null)
+            {
+                m_GroupSendTarget.Target.Dispose();
+                m_GroupSendTarget = null;
+            }
+        }
+
+        internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
+        {
+            if (m_GroupSendTarget == null)
+            {
+                if (behaviour.IsServer)
+                {
+                    m_GroupSendTarget = new RpcTargetGroup(m_NetworkManager);
+                }
+                else
+                {
+                    m_GroupSendTarget = new ProxyRpcTargetGroup(m_NetworkManager);
+                }
+            }
+            m_GroupSendTarget.Clear();
+
+            if (behaviour.IsServer)
+            {
+                foreach (var clientId in behaviour.NetworkObject.Observers)
+                {
+                    if (clientId == NetworkManager.ServerClientId)
+                    {
+                        continue;
+                    }
+
+                    m_GroupSendTarget.Add(clientId);
+                }
+            }
+            else
+            {
+                foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
+                {
+                    if (clientId == NetworkManager.ServerClientId)
+                    {
+                        continue;
+                    }
+
+                    if (clientId == behaviour.NetworkManager.LocalClientId)
+                    {
+                        m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+                        continue;
+                    }
+
+                    m_GroupSendTarget.Add(clientId);
+                }
+            }
+
+            m_GroupSendTarget.Target.Send(behaviour, ref message, delivery, rpcParams);
+        }
+
+        internal NotServerRpcTarget(NetworkManager manager) : base(manager)
+        {
+            m_LocalSendRpcTarget = new LocalSendRpcTarget(manager);
+        }
+    }
+}

Runtime/Messaging/RpcTargets/NotServerRpcTarget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c63787afe52f45ffbd5d801f78e7c0d6
+timeCreated: 1697824954

Runtime/Messaging/RpcTargets/OwnerRpcTarget.cs

@@ -0,0 +1,54 @@
+namespace Unity.Netcode
+{
+    internal class OwnerRpcTarget : BaseRpcTarget
+    {
+        private IIndividualRpcTarget m_UnderlyingTarget;
+        private LocalSendRpcTarget m_LocalRpcTarget;
+        private ServerRpcTarget m_ServerRpcTarget;
+
+        public override void Dispose()
+        {
+            m_LocalRpcTarget.Dispose();
+            if (m_UnderlyingTarget != null)
+            {
+                m_UnderlyingTarget.Target.Dispose();
+                m_UnderlyingTarget = null;
+            }
+        }
+
+        internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
+        {
+            if (behaviour.OwnerClientId == behaviour.NetworkManager.LocalClientId)
+            {
+                m_LocalRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+                return;
+            }
+
+            if (behaviour.OwnerClientId == NetworkManager.ServerClientId)
+            {
+                m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+                return;
+            }
+
+            if (m_UnderlyingTarget == null)
+            {
+                if (behaviour.NetworkManager.IsServer)
+                {
+                    m_UnderlyingTarget = new DirectSendRpcTarget(m_NetworkManager);
+                }
+                else
+                {
+                    m_UnderlyingTarget = new ProxyRpcTarget(behaviour.OwnerClientId, m_NetworkManager);
+                }
+            }
+            m_UnderlyingTarget.SetClientId(behaviour.OwnerClientId);
+            m_UnderlyingTarget.Target.Send(behaviour, ref message, delivery, rpcParams);
+        }
+
+        internal OwnerRpcTarget(NetworkManager manager) : base(manager)
+        {
+            m_LocalRpcTarget = new LocalSendRpcTarget(manager);
+            m_ServerRpcTarget = new ServerRpcTarget(manager);
+        }
+    }
+}

Runtime/Messaging/RpcTargets/OwnerRpcTarget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 23c4d52455fc419aaf03094617894257
+timeCreated: 1697824972

Runtime/Messaging/RpcTargets/ProxyRpcTarget.cs

@@ -0,0 +1,16 @@
+namespace Unity.Netcode
+{
+    internal class ProxyRpcTarget : ProxyRpcTargetGroup, IIndividualRpcTarget
+    {
+        internal ProxyRpcTarget(ulong clientId, NetworkManager manager) : base(manager)
+        {
+            Add(clientId);
+        }
+
+        public void SetClientId(ulong clientId)
+        {
+            Clear();
+            Add(clientId);
+        }
+    }
+}

Runtime/Messaging/RpcTargets/ProxyRpcTarget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 86002805bb9e422e8b71581d1325357f
+timeCreated: 1697825007

Runtime/Messaging/RpcTargets/ProxyRpcTargetGroup.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using Unity.Collections;
+
+namespace Unity.Netcode
+{
+    internal class ProxyRpcTargetGroup : BaseRpcTarget, IDisposable, IGroupRpcTarget
+    {
+        public BaseRpcTarget Target => this;
+
+        private ServerRpcTarget m_ServerRpcTarget;
+        private LocalSendRpcTarget m_LocalSendRpcTarget;
+
+        private bool m_Disposed;
+        public NativeList<ulong> TargetClientIds;
+        internal HashSet<ulong> Ids = new HashSet<ulong>();
+
+        internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
+        {
+            var proxyMessage = new ProxyMessage { Delivery = delivery, TargetClientIds = TargetClientIds.AsArray(), WrappedMessage = message };
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+            var size =
+#endif
+                behaviour.NetworkManager.MessageManager.SendMessage(ref proxyMessage, delivery, NetworkManager.ServerClientId);
+
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+            if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
+            {
+                foreach (var clientId in TargetClientIds)
+                {
+                    behaviour.NetworkManager.NetworkMetrics.TrackRpcSent(
+                        clientId,
+                        behaviour.NetworkObject,
+                        rpcMethodName,
+                        behaviour.__getTypeName(),
+                        size);
+                }
+            }
+#endif
+            if (Ids.Contains(NetworkManager.ServerClientId))
+            {
+                m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+            }
+            if (Ids.Contains(m_NetworkManager.LocalClientId))
+            {
+                m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+            }
+        }
+
+        internal ProxyRpcTargetGroup(NetworkManager manager) : base(manager)
+        {
+            TargetClientIds = new NativeList<ulong>(Allocator.Persistent);
+            m_ServerRpcTarget = new ServerRpcTarget(manager);
+            m_LocalSendRpcTarget = new LocalSendRpcTarget(manager);
+        }
+
+        public override void Dispose()
+        {
+            CheckLockBeforeDispose();
+            if (!m_Disposed)
+            {
+                TargetClientIds.Dispose();
+                m_Disposed = true;
+                m_ServerRpcTarget.Dispose();
+                m_LocalSendRpcTarget.Dispose();
+            }
+        }
+
+        public void Add(ulong clientId)
+        {
+            if (!Ids.Contains(clientId))
+            {
+                Ids.Add(clientId);
+                if (clientId != NetworkManager.ServerClientId && clientId != m_NetworkManager.LocalClientId)
+                {
+                    TargetClientIds.Add(clientId);
+                }
+            }
+        }
+
+        public void Remove(ulong clientId)
+        {
+            Ids.Remove(clientId);
+            for (var i = 0; i < TargetClientIds.Length; ++i)
+            {
+                if (TargetClientIds[i] == clientId)
+                {
+                    TargetClientIds.RemoveAt(i);
+                    break;
+                }
+            }
+        }
+
+        public void Clear()
+        {
+            Ids.Clear();
+            TargetClientIds.Clear();
+        }
+    }
+}

Runtime/Messaging/RpcTargets/ProxyRpcTargetGroup.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5728dbab532e46a88127510b4ec75af9
+timeCreated: 1697825000

Runtime/Messaging/RpcTargets/RpcTarget.cs

@@ -0,0 +1,564 @@
+using System.Collections.Generic;
+using Unity.Collections;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// Configuration for the default method by which an RPC is communicated across the network
+    /// </summary>
+    public enum SendTo
+    {
+        /// <summary>
+        /// Send to the NetworkObject's current owner.
+        /// Will execute locally if the local process is the owner.
+        /// </summary>
+        Owner,
+        /// <summary>
+        /// Send to everyone but the current owner, filtered to the current observer list.
+        /// Will execute locally if the local process is not the owner.
+        /// </summary>
+        NotOwner,
+        /// <summary>
+        /// Send to the server, regardless of ownership.
+        /// Will execute locally if invoked on the server.
+        /// </summary>
+        Server,
+        /// <summary>
+        /// Send to everyone but the server, filtered to the current observer list.
+        /// Will NOT send to a server running in host mode - it is still treated as a server.
+        /// If you want to send to servers when they are host, but not when they are dedicated server, use
+        /// <see cref="ClientsAndHost"/>.
+        /// <br />
+        /// <br />
+        /// Will execute locally if invoked on a client.
+        /// Will NOT execute locally if invoked on a server running in host mode.
+        /// </summary>
+        NotServer,
+        /// <summary>
+        /// Execute this RPC locally.
+        /// <br />
+        /// <br />
+        /// Normally this is no different from a standard function call.
+        /// <br />
+        /// <br />
+        /// Using the DeferLocal parameter of the attribute or the LocalDeferMode override in RpcSendParams,
+        /// this can allow an RPC to be processed on localhost with a one-frame delay as if it were sent over
+        /// the network.
+        /// </summary>
+        Me,
+        /// <summary>
+        /// Send this RPC to everyone but the local machine, filtered to the current observer list.
+        /// </summary>
+        NotMe,
+        /// <summary>
+        /// Send this RPC to everone, filtered to the current observer list.
+        /// Will execute locally.
+        /// </summary>
+        Everyone,
+        /// <summary>
+        /// Send this RPC to all clients, including the host, if a host exists.
+        /// If the server is running in host mode, this is the same as <see cref="Everyone" />.
+        /// If the server is running in dedicated server mode, this is the same as <see cref="NotServer" />.
+        /// </summary>
+        ClientsAndHost,
+        /// <summary>
+        /// This RPC cannot be sent without passing in a target in RpcSendParams.
+        /// </summary>
+        SpecifiedInParams
+    }
+
+    public enum RpcTargetUse
+    {
+        Temp,
+        Persistent
+    }
+
+    /// <summary>
+    /// Implementations of the various <see cref="SendTo"/> options, as well as additional runtime-only options
+    /// <see cref="Single"/>,
+    /// <see cref="Group(NativeArray{ulong})"/>,
+    /// <see cref="Group(NativeList{ulong})"/>,
+    /// <see cref="Group(ulong[])"/>,
+    /// <see cref="Group{T}(T)"/>, <see cref="Not(ulong)"/>,
+    /// <see cref="Not(NativeArray{ulong})"/>,
+    /// <see cref="Not(NativeList{ulong})"/>,
+    /// <see cref="Not(ulong[])"/>, and
+    /// <see cref="Not{T}(T)"/>
+    /// </summary>
+    public class RpcTarget
+    {
+        private NetworkManager m_NetworkManager;
+        internal RpcTarget(NetworkManager manager)
+        {
+            m_NetworkManager = manager;
+
+            Everyone = new EveryoneRpcTarget(manager);
+            Owner = new OwnerRpcTarget(manager);
+            NotOwner = new NotOwnerRpcTarget(manager);
+            Server = new ServerRpcTarget(manager);
+            NotServer = new NotServerRpcTarget(manager);
+            NotMe = new NotMeRpcTarget(manager);
+            Me = new LocalSendRpcTarget(manager);
+            ClientsAndHost = new ClientsAndHostRpcTarget(manager);
+
+            m_CachedProxyRpcTargetGroup = new ProxyRpcTargetGroup(manager);
+            m_CachedTargetGroup = new RpcTargetGroup(manager);
+            m_CachedDirectSendTarget = new DirectSendRpcTarget(manager);
+            m_CachedProxyRpcTarget = new ProxyRpcTarget(0, manager);
+
+            m_CachedProxyRpcTargetGroup.Lock();
+            m_CachedTargetGroup.Lock();
+            m_CachedDirectSendTarget.Lock();
+            m_CachedProxyRpcTarget.Lock();
+        }
+
+        public void Dispose()
+        {
+            Everyone.Dispose();
+            Owner.Dispose();
+            NotOwner.Dispose();
+            Server.Dispose();
+            NotServer.Dispose();
+            NotMe.Dispose();
+            Me.Dispose();
+            ClientsAndHost.Dispose();
+
+            m_CachedProxyRpcTargetGroup.Unlock();
+            m_CachedTargetGroup.Unlock();
+            m_CachedDirectSendTarget.Unlock();
+            m_CachedProxyRpcTarget.Unlock();
+
+            m_CachedProxyRpcTargetGroup.Dispose();
+            m_CachedTargetGroup.Dispose();
+            m_CachedDirectSendTarget.Dispose();
+            m_CachedProxyRpcTarget.Dispose();
+        }
+
+
+        /// <summary>
+        /// Send to the NetworkObject's current owner.
+        /// Will execute locally if the local process is the owner.
+        /// </summary>
+        public BaseRpcTarget Owner;
+
+        /// <summary>
+        /// Send to everyone but the current owner, filtered to the current observer list.
+        /// Will execute locally if the local process is not the owner.
+        /// </summary>
+        public BaseRpcTarget NotOwner;
+
+        /// <summary>
+        /// Send to the server, regardless of ownership.
+        /// Will execute locally if invoked on the server.
+        /// </summary>
+        public BaseRpcTarget Server;
+
+        /// <summary>
+        /// Send to everyone but the server, filtered to the current observer list.
+        /// Will NOT send to a server running in host mode - it is still treated as a server.
+        /// If you want to send to servers when they are host, but not when they are dedicated server, use
+        /// <see cref="SendTo.ClientsAndHost"/>.
+        /// <br />
+        /// <br />
+        /// Will execute locally if invoked on a client.
+        /// Will NOT execute locally if invoked on a server running in host mode.
+        /// </summary>
+        public BaseRpcTarget NotServer;
+
+        /// <summary>
+        /// Execute this RPC locally.
+        /// <br />
+        /// <br />
+        /// Normally this is no different from a standard function call.
+        /// <br />
+        /// <br />
+        /// Using the DeferLocal parameter of the attribute or the LocalDeferMode override in RpcSendParams,
+        /// this can allow an RPC to be processed on localhost with a one-frame delay as if it were sent over
+        /// the network.
+        /// </summary>
+        public BaseRpcTarget Me;
+
+        /// <summary>
+        /// Send this RPC to everyone but the local machine, filtered to the current observer list.
+        /// </summary>
+        public BaseRpcTarget NotMe;
+
+        /// <summary>
+        /// Send this RPC to everone, filtered to the current observer list.
+        /// Will execute locally.
+        /// </summary>
+        public BaseRpcTarget Everyone;
+
+        /// <summary>
+        /// Send this RPC to all clients, including the host, if a host exists.
+        /// If the server is running in host mode, this is the same as <see cref="Everyone" />.
+        /// If the server is running in dedicated server mode, this is the same as <see cref="NotServer" />.
+        /// </summary>
+        public BaseRpcTarget ClientsAndHost;
+
+        /// <summary>
+        /// Send to a specific single client ID.
+        /// </summary>
+        /// <param name="clientId"></param>
+        /// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
+        /// be overwritten in future calls to Single(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
+        /// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
+        /// <returns></returns>
+        public BaseRpcTarget Single(ulong clientId, RpcTargetUse use)
+        {
+            if (clientId == m_NetworkManager.LocalClientId)
+            {
+                return Me;
+            }
+
+            if (m_NetworkManager.IsServer || clientId == NetworkManager.ServerClientId)
+            {
+                if (use == RpcTargetUse.Persistent)
+                {
+                    return new DirectSendRpcTarget(clientId, m_NetworkManager);
+                }
+                m_CachedDirectSendTarget.SetClientId(clientId);
+                return m_CachedDirectSendTarget;
+            }
+
+            if (use == RpcTargetUse.Persistent)
+            {
+                return new ProxyRpcTarget(clientId, m_NetworkManager);
+            }
+            m_CachedProxyRpcTarget.SetClientId(clientId);
+            return m_CachedProxyRpcTarget;
+        }
+
+        /// <summary>
+        /// Send to everyone EXCEPT a specific single client ID.
+        /// </summary>
+        /// <param name="excludedClientId"></param>
+        /// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
+        /// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
+        /// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
+        /// <returns></returns>
+        public BaseRpcTarget Not(ulong excludedClientId, RpcTargetUse use)
+        {
+            IGroupRpcTarget target;
+            if (m_NetworkManager.IsServer)
+            {
+                if (use == RpcTargetUse.Persistent)
+                {
+                    target = new RpcTargetGroup(m_NetworkManager);
+                }
+                else
+                {
+                    target = m_CachedTargetGroup;
+                }
+            }
+            else
+            {
+                if (use == RpcTargetUse.Persistent)
+                {
+                    target = new ProxyRpcTargetGroup(m_NetworkManager);
+                }
+                else
+                {
+                    target = m_CachedProxyRpcTargetGroup;
+                }
+            }
+            target.Clear();
+            foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
+            {
+                if (clientId != excludedClientId)
+                {
+                    target.Add(clientId);
+                }
+            }
+
+            // If ServerIsHost, ConnectedClientIds already contains ServerClientId and this would duplicate it.
+            if (!m_NetworkManager.ServerIsHost && excludedClientId != NetworkManager.ServerClientId)
+            {
+                target.Add(NetworkManager.ServerClientId);
+            }
+
+            return target.Target;
+        }
+
+        /// <summary>
+        /// Sends to a group of client IDs.
+        /// NativeArrays can be trivially constructed using Allocator.Temp, making this an efficient
+        /// Group method if the group list is dynamically constructed.
+        /// </summary>
+        /// <param name="clientIds"></param>
+        /// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
+        /// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
+        /// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
+        /// <returns></returns>
+        public BaseRpcTarget Group(NativeArray<ulong> clientIds, RpcTargetUse use)
+        {
+            IGroupRpcTarget target;
+            if (m_NetworkManager.IsServer)
+            {
+                if (use == RpcTargetUse.Persistent)
+                {
+                    target = new RpcTargetGroup(m_NetworkManager);
+                }
+                else
+                {
+                    target = m_CachedTargetGroup;
+                }
+            }
+            else
+            {
+                if (use == RpcTargetUse.Persistent)
+                {
+                    target = new ProxyRpcTargetGroup(m_NetworkManager);
+                }
+                else
+                {
+                    target = m_CachedProxyRpcTargetGroup;
+                }
+            }
+            target.Clear();
+            foreach (var clientId in clientIds)
+            {
+                target.Add(clientId);
+            }
+
+            return target.Target;
+        }
+
+        /// <summary>
+        /// Sends to a group of client IDs.
+        /// NativeList can be trivially constructed using Allocator.Temp, making this an efficient
+        /// Group method if the group list is dynamically constructed.
+        /// </summary>
+        /// <param name="clientIds"></param>
+        /// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
+        /// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
+        /// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
+        /// <returns></returns>
+        public BaseRpcTarget Group(NativeList<ulong> clientIds, RpcTargetUse use)
+        {
+            var asArray = clientIds.AsArray();
+            return Group(asArray, use);
+        }
+
+        /// <summary>
+        /// Sends to a group of client IDs.
+        /// Constructing arrays requires garbage collected allocations. This override is only recommended
+        /// if you either have no strict performance requirements, or have the group of client IDs cached so
+        /// it is not created each time.
+        /// </summary>
+        /// <param name="clientIds"></param>
+        /// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
+        /// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
+        /// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
+        /// <returns></returns>
+        public BaseRpcTarget Group(ulong[] clientIds, RpcTargetUse use)
+        {
+            return Group(new NativeArray<ulong>(clientIds, Allocator.Temp), use);
+        }
+
+        /// <summary>
+        /// Sends to a group of client IDs.
+        /// This accepts any IEnumerable type, such as List&lt;ulong&gt;, but cannot be called without
+        /// a garbage collected allocation (even if the type itself is a struct type, due to boxing).
+        /// This override is only recommended if you either have no strict performance requirements,
+        /// or have the group of client IDs cached so it is not created each time.
+        /// </summary>
+        /// <param name="clientIds"></param>
+        /// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
+        /// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
+        /// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
+        /// <returns></returns>
+        public BaseRpcTarget Group<T>(T clientIds, RpcTargetUse use) where T : IEnumerable<ulong>
+        {
+            IGroupRpcTarget target;
+            if (m_NetworkManager.IsServer)
+            {
+                if (use == RpcTargetUse.Persistent)
+                {
+                    target = new RpcTargetGroup(m_NetworkManager);
+                }
+                else
+                {
+                    target = m_CachedTargetGroup;
+                }
+            }
+            else
+            {
+                if (use == RpcTargetUse.Persistent)
+                {
+                    target = new ProxyRpcTargetGroup(m_NetworkManager);
+                }
+                else
+                {
+                    target = m_CachedProxyRpcTargetGroup;
+                }
+            }
+            target.Clear();
+            foreach (var clientId in clientIds)
+            {
+                target.Add(clientId);
+            }
+
+            return target.Target;
+        }
+
+        /// <summary>
+        /// Sends to everyone EXCEPT a group of client IDs.
+        /// NativeArrays can be trivially constructed using Allocator.Temp, making this an efficient
+        /// Group method if the group list is dynamically constructed.
+        /// </summary>
+        /// <param name="excludedClientIds"></param>
+        /// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
+        /// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
+        /// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
+        /// <returns></returns>
+        public BaseRpcTarget Not(NativeArray<ulong> excludedClientIds, RpcTargetUse use)
+        {
+            IGroupRpcTarget target;
+            if (m_NetworkManager.IsServer)
+            {
+                if (use == RpcTargetUse.Persistent)
+                {
+                    target = new RpcTargetGroup(m_NetworkManager);
+                }
+                else
+                {
+                    target = m_CachedTargetGroup;
+                }
+            }
+            else
+            {
+                if (use == RpcTargetUse.Persistent)
+                {
+                    target = new ProxyRpcTargetGroup(m_NetworkManager);
+                }
+                else
+                {
+                    target = m_CachedProxyRpcTargetGroup;
+                }
+            }
+            target.Clear();
+
+            using var asASet = new NativeHashSet<ulong>(excludedClientIds.Length, Allocator.Temp);
+            foreach (var clientId in excludedClientIds)
+            {
+                asASet.Add(clientId);
+            }
+
+            foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
+            {
+                if (!asASet.Contains(clientId))
+                {
+                    target.Add(clientId);
+                }
+            }
+
+            // If ServerIsHost, ConnectedClientIds already contains ServerClientId and this would duplicate it.
+            if (!m_NetworkManager.ServerIsHost && !asASet.Contains(NetworkManager.ServerClientId))
+            {
+                target.Add(NetworkManager.ServerClientId);
+            }
+
+            return target.Target;
+        }
+
+        /// <summary>
+        /// Sends to everyone EXCEPT a group of client IDs.
+        /// NativeList can be trivially constructed using Allocator.Temp, making this an efficient
+        /// Group method if the group list is dynamically constructed.
+        /// </summary>
+        /// <param name="excludedClientIds"></param>
+        /// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
+        /// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
+        /// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
+        /// <returns></returns>
+        public BaseRpcTarget Not(NativeList<ulong> excludedClientIds, RpcTargetUse use)
+        {
+            var asArray = excludedClientIds.AsArray();
+            return Not(asArray, use);
+        }
+
+        /// <summary>
+        /// Sends to everyone EXCEPT a group of client IDs.
+        /// Constructing arrays requires garbage collected allocations. This override is only recommended
+        /// if you either have no strict performance requirements, or have the group of client IDs cached so
+        /// it is not created each time.
+        /// </summary>
+        /// <param name="excludedClientIds"></param>
+        /// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
+        /// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
+        /// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
+        /// <returns></returns>
+        public BaseRpcTarget Not(ulong[] excludedClientIds, RpcTargetUse use)
+        {
+            return Not(new NativeArray<ulong>(excludedClientIds, Allocator.Temp), use);
+        }
+
+        /// <summary>
+        /// Sends to everyone EXCEPT a group of client IDs.
+        /// This accepts any IEnumerable type, such as List&lt;ulong&gt;, but cannot be called without
+        /// a garbage collected allocation (even if the type itself is a struct type, due to boxing).
+        /// This override is only recommended if you either have no strict performance requirements,
+        /// or have the group of client IDs cached so it is not created each time.
+        /// </summary>
+        /// <param name="excludedClientIds"></param>
+        /// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
+        /// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
+        /// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
+        /// <returns></returns>
+        public BaseRpcTarget Not<T>(T excludedClientIds, RpcTargetUse use) where T : IEnumerable<ulong>
+        {
+            IGroupRpcTarget target;
+            if (m_NetworkManager.IsServer)
+            {
+                if (use == RpcTargetUse.Persistent)
+                {
+                    target = new RpcTargetGroup(m_NetworkManager);
+                }
+                else
+                {
+                    target = m_CachedTargetGroup;
+                }
+            }
+            else
+            {
+                if (use == RpcTargetUse.Persistent)
+                {
+                    target = new ProxyRpcTargetGroup(m_NetworkManager);
+                }
+                else
+                {
+                    target = m_CachedProxyRpcTargetGroup;
+                }
+            }
+            target.Clear();
+
+            using var asASet = new NativeHashSet<ulong>(m_NetworkManager.ConnectedClientsIds.Count, Allocator.Temp);
+            foreach (var clientId in excludedClientIds)
+            {
+                asASet.Add(clientId);
+            }
+
+            foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
+            {
+                if (!asASet.Contains(clientId))
+                {
+                    target.Add(clientId);
+                }
+            }
+
+            // If ServerIsHost, ConnectedClientIds already contains ServerClientId and this would duplicate it.
+            if (!m_NetworkManager.ServerIsHost && !asASet.Contains(NetworkManager.ServerClientId))
+            {
+                target.Add(NetworkManager.ServerClientId);
+            }
+
+            return target.Target;
+        }
+
+        private ProxyRpcTargetGroup m_CachedProxyRpcTargetGroup;
+        private RpcTargetGroup m_CachedTargetGroup;
+        private DirectSendRpcTarget m_CachedDirectSendTarget;
+        private ProxyRpcTarget m_CachedProxyRpcTarget;
+    }
+}

Runtime/Messaging/RpcTargets/RpcTarget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1b26d0227e71408b918ae25ca2a0179b
+timeCreated: 1699555535

Runtime/Messaging/RpcTargets/RpcTargetGroup.cs

@@ -0,0 +1,80 @@
+using System.Collections.Generic;
+
+namespace Unity.Netcode
+{
+    internal class RpcTargetGroup : BaseRpcTarget, IGroupRpcTarget
+    {
+        public BaseRpcTarget Target => this;
+
+        internal List<BaseRpcTarget> Targets = new List<BaseRpcTarget>();
+
+        private LocalSendRpcTarget m_LocalSendRpcTarget;
+        private HashSet<ulong> m_Ids = new HashSet<ulong>();
+        private Stack<DirectSendRpcTarget> m_TargetCache = new Stack<DirectSendRpcTarget>();
+
+        public override void Dispose()
+        {
+            CheckLockBeforeDispose();
+            foreach (var target in Targets)
+            {
+                target.Dispose();
+            }
+            foreach (var target in m_TargetCache)
+            {
+                target.Dispose();
+            }
+            m_LocalSendRpcTarget.Dispose();
+        }
+
+        internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
+        {
+            foreach (var target in Targets)
+            {
+                target.Send(behaviour, ref message, delivery, rpcParams);
+            }
+        }
+
+        public void Add(ulong clientId)
+        {
+            if (!m_Ids.Contains(clientId))
+            {
+                m_Ids.Add(clientId);
+                if (clientId == m_NetworkManager.LocalClientId)
+                {
+                    Targets.Add(m_LocalSendRpcTarget);
+                }
+                else
+                {
+                    if (m_TargetCache.Count == 0)
+                    {
+                        Targets.Add(new DirectSendRpcTarget(m_NetworkManager) { ClientId = clientId });
+                    }
+                    else
+                    {
+                        var target = m_TargetCache.Pop();
+                        target.ClientId = clientId;
+                        Targets.Add(target);
+                    }
+                }
+            }
+        }
+
+        public void Clear()
+        {
+            m_Ids.Clear();
+            foreach (var target in Targets)
+            {
+                if (target is DirectSendRpcTarget directSendRpcTarget)
+                {
+                    m_TargetCache.Push(directSendRpcTarget);
+                }
+            }
+            Targets.Clear();
+        }
+
+        internal RpcTargetGroup(NetworkManager manager) : base(manager)
+        {
+            m_LocalSendRpcTarget = new LocalSendRpcTarget(manager);
+        }
+    }
+}

Runtime/Messaging/RpcTargets/RpcTargetGroup.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7f8c0fc053b64a588c99dd7d706d9f0a
+timeCreated: 1697824991

Runtime/Messaging/RpcTargets/ServerRpcTarget.cs

@@ -0,0 +1,36 @@
+namespace Unity.Netcode
+{
+    internal class ServerRpcTarget : BaseRpcTarget
+    {
+        private BaseRpcTarget m_UnderlyingTarget;
+
+        public override void Dispose()
+        {
+            if (m_UnderlyingTarget != null)
+            {
+                m_UnderlyingTarget.Dispose();
+                m_UnderlyingTarget = null;
+            }
+        }
+
+        internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
+        {
+            if (m_UnderlyingTarget == null)
+            {
+                if (behaviour.NetworkManager.IsServer)
+                {
+                    m_UnderlyingTarget = new LocalSendRpcTarget(m_NetworkManager);
+                }
+                else
+                {
+                    m_UnderlyingTarget = new DirectSendRpcTarget(m_NetworkManager) { ClientId = NetworkManager.ServerClientId };
+                }
+            }
+            m_UnderlyingTarget.Send(behaviour, ref message, delivery, rpcParams);
+        }
+
+        internal ServerRpcTarget(NetworkManager manager) : base(manager)
+        {
+        }
+    }
+}

Runtime/Messaging/RpcTargets/ServerRpcTarget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c911725afb6d44f3bb1a1d567d9dee0f
+timeCreated: 1697824979

Runtime/NetworkVariable/NetworkVariableBase.cs

@@ -100,7 +100,15 @@ namespace Unity.Netcode
                                  "Are you modifying a NetworkVariable before the NetworkObject is spawned?");
                 return;
             }
-
+            if (m_NetworkBehaviour.NetworkManager.ShutdownInProgress)
+            {
+                if (m_NetworkBehaviour.NetworkManager.LogLevel <= LogLevel.Developer)
+                {
+                    Debug.LogWarning($"NetworkVariable is written to during the NetworkManager shutdown! " +
+                 "Are you modifying a NetworkVariable within a NetworkBehaviour.OnDestroy or NetworkBehaviour.OnDespawn method?");
+                }
+                return;
+            }
             m_NetworkBehaviour.NetworkManager.BehaviourUpdater.AddForUpdate(m_NetworkBehaviour.NetworkObject);
         }
 

Runtime/SceneManagement/NetworkSceneManager.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Unity.Collections;
 using UnityEngine;
 using UnityEngine.SceneManagement;
 
@@ -597,6 +598,47 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// Used for integration tests, normal runtime mode this will always be LoadSceneMode.Single
+        /// </summary>
+        internal LoadSceneMode DeferLoadingFilter = LoadSceneMode.Single;
+        /// <summary>
+        /// Determines if a remote client should defer object creation initiated by CreateObjectMessage
+        /// until a scene event is completed.
+        /// </summary>
+        /// <remarks>
+        /// Deferring object creation should only occur when there is a possibility the objects could be
+        /// instantiated in a currently active scene that will be unloaded during single mode scene loading
+        /// to prevent the newly created objects from being destroyed when the scene is unloaded.
+        /// </remarks>
+        internal bool ShouldDeferCreateObject()
+        {
+            // This applies only to remote clients and when scene management is enabled
+            if (!NetworkManager.NetworkConfig.EnableSceneManagement || NetworkManager.IsServer)
+            {
+                return false;
+            }
+            var synchronizeEventDetected = false;
+            var loadingEventDetected = false;
+            foreach (var entry in SceneEventDataStore)
+            {
+                if (entry.Value.SceneEventType == SceneEventType.Synchronize)
+                {
+                    synchronizeEventDetected = true;
+                }
+
+                // When loading a scene and the load scene mode is single we should defer object creation
+                if (entry.Value.SceneEventType == SceneEventType.Load && entry.Value.LoadSceneMode == DeferLoadingFilter)
+                {
+                    loadingEventDetected = true;
+                }
+            }
+
+            // Synchronizing while in client synchronization mode single --> Defer
+            // When not synchronizing but loading a scene in single mode --> Defer
+            return (synchronizeEventDetected && ClientSynchronizationMode == LoadSceneMode.Single) || (!synchronizeEventDetected && loadingEventDetected);
+        }
+
         /// <summary>
         /// Gets the scene name from full path to the scene
         /// </summary>
@@ -740,12 +782,17 @@ namespace Unity.Netcode
             // Since NetworkManager is now always migrated to the DDOL we will use this to get the DDOL scene
             DontDestroyOnLoadScene = networkManager.gameObject.scene;
 
-            // Since the server tracks loaded scenes, we need to add the currently active scene
+            // Since the server tracks loaded scenes, we need to add any currently loaded scenes on the 
-            // to the list of scenes that can be unloaded.
+            // server side when the NetworkManager is started and NetworkSceneManager instantiated when
-            if (networkManager.IsServer)
+            // scene management is enabled.
+            if (networkManager.IsServer && networkManager.NetworkConfig.EnableSceneManagement)
             {
-                var activeScene = SceneManager.GetActiveScene();
+                for (int i = 0; i < SceneManager.sceneCount; i++)
-                ScenesLoaded.Add(activeScene.handle, activeScene);
+                {
+                    var loadedScene = SceneManager.GetSceneAt(i);
+                    ScenesLoaded.Add(loadedScene.handle, loadedScene);
+                }
+                SceneManagerHandler.PopulateLoadedScenes(ref ScenesLoaded, NetworkManager);
             }
 
             // Add to the server to client scene handle table
@@ -969,17 +1016,16 @@ namespace Unity.Netcode
         /// <returns></returns>
         private SceneEventProgress ValidateSceneEventUnloading(Scene scene)
         {
-            if (!NetworkManager.IsServer)
-            {
-                throw new NotServerException("Only server can start a scene event!");
-            }
-
             if (!NetworkManager.NetworkConfig.EnableSceneManagement)
             {
-                //Log message about enabling SceneManagement
+                Debug.LogWarning($"{nameof(LoadScene)} was called, but {nameof(NetworkConfig.EnableSceneManagement)} was not enabled! Enable {nameof(NetworkConfig.EnableSceneManagement)} prior to starting a client, host, or server prior to using {nameof(NetworkSceneManager)}!");
-                throw new Exception(
+                return new SceneEventProgress(null, SceneEventProgressStatus.SceneManagementNotEnabled);
-                    $"{nameof(NetworkConfig.EnableSceneManagement)} flag is not enabled in the {nameof(Netcode.NetworkManager)}'s {nameof(NetworkConfig)}. " +
+            }
-                    $"Please set {nameof(NetworkConfig.EnableSceneManagement)} flag to true before calling {nameof(LoadScene)} or {nameof(UnloadScene)}.");
+
+            if (!NetworkManager.IsServer)
+            {
+                Debug.LogWarning($"[{nameof(SceneEventProgressStatus.ServerOnlyAction)}][Unload] Clients cannot invoke the {nameof(UnloadScene)} method!");
+                return new SceneEventProgress(null, SceneEventProgressStatus.ServerOnlyAction);
             }
 
             if (!scene.isLoaded)
@@ -998,16 +1044,16 @@ namespace Unity.Netcode
         /// <returns></returns>
         private SceneEventProgress ValidateSceneEventLoading(string sceneName)
         {
-            if (!NetworkManager.IsServer)
-            {
-                throw new NotServerException("Only server can start a scene event!");
-            }
             if (!NetworkManager.NetworkConfig.EnableSceneManagement)
             {
-                //Log message about enabling SceneManagement
+                Debug.LogWarning($"{nameof(LoadScene)} was called, but {nameof(NetworkConfig.EnableSceneManagement)} was not enabled! Enable {nameof(NetworkConfig.EnableSceneManagement)} prior to starting a client, host, or server prior to using {nameof(NetworkSceneManager)}!");
-                throw new Exception(
+                return new SceneEventProgress(null, SceneEventProgressStatus.SceneManagementNotEnabled);
-                    $"{nameof(NetworkConfig.EnableSceneManagement)} flag is not enabled in the {nameof(Netcode.NetworkManager)}'s {nameof(NetworkConfig)}. " +
+            }
-                    $"Please set {nameof(NetworkConfig.EnableSceneManagement)} flag to true before calling {nameof(LoadScene)} or {nameof(UnloadScene)}.");
+
+            if (!NetworkManager.IsServer)
+            {
+                Debug.LogWarning($"[{nameof(SceneEventProgressStatus.ServerOnlyAction)}][Load] Clients cannot invoke the {nameof(LoadScene)} method!");
+                return new SceneEventProgress(null, SceneEventProgressStatus.ServerOnlyAction);
             }
 
             return ValidateSceneEvent(sceneName);
@@ -1112,6 +1158,7 @@ namespace Unity.Netcode
         {
             var sceneName = scene.name;
             var sceneHandle = scene.handle;
+
             if (!scene.isLoaded)
             {
                 Debug.LogWarning($"{nameof(UnloadScene)} was called, but the scene {scene.name} is not currently loaded!");
@@ -1697,6 +1744,9 @@ namespace Unity.Netcode
             SendSceneEventData(sceneEventId, new ulong[] { NetworkManager.ServerClientId });
             m_IsSceneEventActive = false;
 
+            // Process any pending create object messages that the client received while loading a scene
+            ProcessDeferredCreateObjectMessages();
+
             // Notify local client that the scene was loaded
             OnSceneEvent?.Invoke(new SceneEvent()
             {
@@ -2058,6 +2108,9 @@ namespace Unity.Netcode
                             // If needed, migrate dynamically spawned NetworkObjects to the same scene as they are on the server
                             SynchronizeNetworkObjectScene();
 
+                            // Process any pending create object messages that the client received during synchronization
+                            ProcessDeferredCreateObjectMessages();
+
                             sceneEventData.SceneEventType = SceneEventType.SynchronizeComplete;
                             SendSceneEventData(sceneEventId, new ulong[] { NetworkManager.ServerClientId });
 
@@ -2213,6 +2266,11 @@ namespace Unity.Netcode
                         // of the client was persisted since MLAPI)
                         NetworkManager.ConnectionManager.InvokeOnClientConnectedCallback(clientId);
 
+                        if (NetworkManager.IsHost)
+                        {
+                            NetworkManager.ConnectionManager.InvokeOnPeerConnectedCallback(clientId);
+                        }
+
                         // Check to see if the client needs to resynchronize and before sending the message make sure the client is still connected to avoid
                         // a potential crash within the MessageSystem (i.e. sending to a client that no longer exists)
                         if (sceneEventData.ClientNeedsReSynchronization() && !DisableReSynchronization && NetworkManager.ConnectedClients.ContainsKey(clientId))
@@ -2549,5 +2607,50 @@ namespace Unity.Netcode
             internal Dictionary<int, List<ulong>> ObjectsMigratedTable;
         }
         internal List<DeferredObjectsMovedEvent> DeferredObjectsMovedEvents = new List<DeferredObjectsMovedEvent>();
+
+        internal struct DeferredObjectCreation
+        {
+            internal ulong SenderId;
+            internal uint MessageSize;
+            internal NetworkObject.SceneObject SceneObject;
+            internal FastBufferReader FastBufferReader;
+        }
+
+        internal List<DeferredObjectCreation> DeferredObjectCreationList = new List<DeferredObjectCreation>();
+        internal int DeferredObjectCreationCount;
+
+        internal void DeferCreateObject(ulong senderId, uint messageSize, NetworkObject.SceneObject sceneObject, FastBufferReader fastBufferReader)
+        {
+            var deferredObjectCreationEntry = new DeferredObjectCreation()
+            {
+                SenderId = senderId,
+                MessageSize = messageSize,
+                SceneObject = sceneObject,
+            };
+
+            unsafe
+            {
+                deferredObjectCreationEntry.FastBufferReader = new FastBufferReader(fastBufferReader.GetUnsafePtrAtCurrentPosition(), Allocator.Persistent, fastBufferReader.Length - fastBufferReader.Position);
+            }
+
+            DeferredObjectCreationList.Add(deferredObjectCreationEntry);
+        }
+
+        private void ProcessDeferredCreateObjectMessages()
+        {
+            // If no pending create object messages exit early
+            if (DeferredObjectCreationList.Count == 0)
+            {
+                return;
+            }
+            var networkManager = NetworkManager;
+            // Process all deferred create object messages.
+            foreach (var deferredObjectCreation in DeferredObjectCreationList)
+            {
+                CreateObjectMessage.CreateObject(ref networkManager, deferredObjectCreation.SenderId, deferredObjectCreation.MessageSize, deferredObjectCreation.SceneObject, deferredObjectCreation.FastBufferReader);
+            }
+            DeferredObjectCreationCount = DeferredObjectCreationList.Count;
+            DeferredObjectCreationList.Clear();
+        }
     }
 }

Runtime/SceneManagement/SceneEventProgress.cs

@@ -47,6 +47,14 @@ namespace Unity.Netcode
         /// If you receive this event then it is most likely due to a bug (<em>please open a GitHub issue with steps to replicate</em>).<br/>
         /// </summary>
         InternalNetcodeError,
+        /// <summary>
+        /// This is returned when an unload or load action is attempted and scene management is disabled
+        /// </summary>
+        SceneManagementNotEnabled,
+        /// <summary>
+        /// This is returned when a client attempts to perform a server only action
+        /// </summary>
+        ServerOnlyAction,
     }
 
     /// <summary>

Runtime/Spawning/NetworkSpawnManager.cs

@@ -322,6 +322,167 @@ namespace Unity.Netcode
             return networkObject != null;
         }
 
+        internal enum InstantiateAndSpawnErrorTypes
+        {
+            NetworkPrefabNull,
+            NotAuthority,
+            InvokedWhenShuttingDown,
+            NotRegisteredNetworkPrefab,
+            NetworkManagerNull,
+            NoActiveSession,
+        }
+
+        internal static readonly Dictionary<InstantiateAndSpawnErrorTypes, string> InstantiateAndSpawnErrors = new Dictionary<InstantiateAndSpawnErrorTypes, string>(
+            new KeyValuePair<InstantiateAndSpawnErrorTypes, string>[]{
+                new KeyValuePair<InstantiateAndSpawnErrorTypes, string>(InstantiateAndSpawnErrorTypes.NetworkPrefabNull, $"The {nameof(NetworkObject)} prefab parameter was null!"),
+                new KeyValuePair<InstantiateAndSpawnErrorTypes, string>(InstantiateAndSpawnErrorTypes.NotAuthority, $"Only the server has authority to {nameof(InstantiateAndSpawn)}!"),
+                new KeyValuePair<InstantiateAndSpawnErrorTypes, string>(InstantiateAndSpawnErrorTypes.InvokedWhenShuttingDown, $"Invoking {nameof(InstantiateAndSpawn)} while shutting down! Calls to {nameof(InstantiateAndSpawn)} will be ignored."),
+                new KeyValuePair<InstantiateAndSpawnErrorTypes, string>(InstantiateAndSpawnErrorTypes.NotRegisteredNetworkPrefab, $"The {nameof(NetworkObject)} parameter is not a registered network prefab. Did you forget to register it or are you trying to instantiate and spawn an instance of a network prefab?"),
+                new KeyValuePair<InstantiateAndSpawnErrorTypes, string>(InstantiateAndSpawnErrorTypes.NetworkManagerNull, $"The {nameof(NetworkManager)} parameter was null!"),
+                new KeyValuePair<InstantiateAndSpawnErrorTypes, string>(InstantiateAndSpawnErrorTypes.NoActiveSession, "You can only invoke this method when you are connected to an existing/in-progress network session!")
+            });
+
+        /// <summary>
+        /// Use this method to easily instantiate and spawn an instance of a network prefab.
+        /// InstantiateAndSpawn will:
+        /// - Find any override associated with the <see cref="NetworkObject"/> prefab
+        ///   - If there is no override, then the current <see cref="NetworkObject"/> prefab type is used.
+        /// - Create an instance of the <see cref="NetworkObject"/> prefab (or its override).
+        /// - Spawn the <see cref="NetworkObject"/> prefab instance
+        /// </summary>
+        /// <param name="networkPrefab">The <see cref="NetworkObject"/> of the pefab asset.</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(NetworkObject networkPrefab, ulong ownerClientId = NetworkManager.ServerClientId, bool destroyWithScene = false, bool isPlayerObject = false, bool forceOverride = false, Vector3 position = default, Quaternion rotation = default)
+        {
+            if (networkPrefab == null)
+            {
+                Debug.LogError(InstantiateAndSpawnErrors[InstantiateAndSpawnErrorTypes.NetworkPrefabNull]);
+                return null;
+            }
+
+            if (!NetworkManager.IsServer)
+            {
+                Debug.LogError(InstantiateAndSpawnErrors[InstantiateAndSpawnErrorTypes.NotAuthority]);
+                return null;
+            }
+
+            if (NetworkManager.ShutdownInProgress)
+            {
+                Debug.LogWarning(InstantiateAndSpawnErrors[InstantiateAndSpawnErrorTypes.InvokedWhenShuttingDown]);
+                return null;
+            }
+
+            // Verify it is actually a valid prefab
+            if (!NetworkManager.NetworkConfig.Prefabs.Contains(networkPrefab.gameObject))
+            {
+                Debug.LogError(InstantiateAndSpawnErrors[InstantiateAndSpawnErrorTypes.NotRegisteredNetworkPrefab]);
+                return null;
+            }
+
+            return InstantiateAndSpawnNoParameterChecks(networkPrefab, ownerClientId, destroyWithScene, isPlayerObject, forceOverride, position, rotation);
+        }
+
+        /// <summary>
+        /// !!! Does not perform any parameter checks prior to attempting to instantiate and spawn the NetworkObject !!!
+        /// </summary>
+        internal NetworkObject InstantiateAndSpawnNoParameterChecks(NetworkObject networkPrefab, ulong ownerClientId = NetworkManager.ServerClientId, bool destroyWithScene = false, bool isPlayerObject = false, bool forceOverride = false, Vector3 position = default, Quaternion rotation = default)
+        {
+
+            var networkObject = networkPrefab;
+            // Host spawns the ovveride and server spawns the original prefab unless forceOverride is set to true where both server or host will spawn the override.
+            if (forceOverride || NetworkManager.IsHost)
+            {
+                networkObject = GetNetworkObjectToSpawn(networkPrefab.GlobalObjectIdHash, ownerClientId, position, rotation);
+            }
+            if (networkObject == null)
+            {
+                Debug.LogError($"Failed to instantiate and spawn {networkPrefab.name}!");
+                return null;
+            }
+            networkObject.IsPlayerObject = isPlayerObject;
+            networkObject.transform.position = position;
+            networkObject.transform.rotation = rotation;
+            networkObject.SpawnWithOwnership(ownerClientId, destroyWithScene);
+            return networkObject;
+        }
+
+        /// <summary>
+        /// Gets the right NetworkObject prefab instance to spawn. If a handler is registered or there is an override assigned to the 
+        /// passed in globalObjectIdHash value, then that is what will be instantiated, spawned, and returned.
+        /// </summary>
+        internal NetworkObject GetNetworkObjectToSpawn(uint globalObjectIdHash, ulong ownerId, Vector3 position = default, Quaternion rotation = default, bool isScenePlaced = false)
+        {
+            NetworkObject networkObject = null;
+            // If the prefab hash has a registered INetworkPrefabInstanceHandler derived class
+            if (NetworkManager.PrefabHandler.ContainsHandler(globalObjectIdHash))
+            {
+                // Let the handler spawn the NetworkObject
+                networkObject = NetworkManager.PrefabHandler.HandleNetworkPrefabSpawn(globalObjectIdHash, ownerId, position, rotation);
+                networkObject.NetworkManagerOwner = NetworkManager;
+            }
+            else
+            {
+                // See if there is a valid registered NetworkPrefabOverrideLink associated with the provided prefabHash
+                var networkPrefabReference = (GameObject)null;
+                var inScenePlacedWithNoSceneManagement = !NetworkManager.NetworkConfig.EnableSceneManagement && isScenePlaced;
+
+                if (NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.ContainsKey(globalObjectIdHash))
+                {
+                    var networkPrefab = NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash];
+
+                    switch (networkPrefab.Override)
+                    {
+                        default:
+                        case NetworkPrefabOverride.None:
+                            networkPrefabReference = networkPrefab.Prefab;
+                            break;
+                        case NetworkPrefabOverride.Hash:
+                        case NetworkPrefabOverride.Prefab:
+                            {
+                                // When scene management is disabled and this is an in-scene placed NetworkObject, we want to always use the 
+                                // SourcePrefabToOverride and not any possible prefab override as a user might want to spawn overrides dynamically 
+                                // but might want to use the same source network prefab as an in-scene placed NetworkObject.
+                                // (When scene management is enabled, clients don't delete their in-scene placed NetworkObjects prior to dynamically
+                                // spawning them so the original prefab placed is preserved and this is not needed)
+                                if (inScenePlacedWithNoSceneManagement)
+                                {
+                                    networkPrefabReference = networkPrefab.SourcePrefabToOverride ? networkPrefab.SourcePrefabToOverride : networkPrefab.Prefab;
+                                }
+                                else
+                                {
+                                    networkPrefabReference = NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash].OverridingTargetPrefab;
+                                }
+                                break;
+                            }
+                    }
+                }
+
+                // If not, then there is an issue (user possibly didn't register the prefab properly?)
+                if (networkPrefabReference == null)
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
+                    {
+                        NetworkLog.LogError($"Failed to create object locally. [{nameof(globalObjectIdHash)}={globalObjectIdHash}]. {nameof(NetworkPrefab)} could not be found. Is the prefab registered with {nameof(NetworkManager)}?");
+                    }
+                }
+                else
+                {
+                    // Create prefab instance
+                    networkObject = UnityEngine.Object.Instantiate(networkPrefabReference).GetComponent<NetworkObject>();
+                    networkObject.NetworkManagerOwner = NetworkManager;
+                    networkObject.PrefabGlobalObjectIdHash = globalObjectIdHash;
+                }
+            }
+            return networkObject;
+        }
+
         /// <summary>
         /// Creates a local NetowrkObject to be spawned.
         /// </summary>
@@ -343,48 +504,7 @@ namespace Unity.Netcode
             // If scene management is disabled or the NetworkObject was dynamically spawned
             if (!NetworkManager.NetworkConfig.EnableSceneManagement || !sceneObject.IsSceneObject)
             {
-                // If the prefab hash has a registered INetworkPrefabInstanceHandler derived class
+                networkObject = GetNetworkObjectToSpawn(sceneObject.Hash, sceneObject.OwnerClientId, position, rotation, sceneObject.IsSceneObject);
-                if (NetworkManager.PrefabHandler.ContainsHandler(globalObjectIdHash))
-                {
-                    // Let the handler spawn the NetworkObject
-                    networkObject = NetworkManager.PrefabHandler.HandleNetworkPrefabSpawn(globalObjectIdHash, sceneObject.OwnerClientId, position, rotation);
-                    networkObject.NetworkManagerOwner = NetworkManager;
-                    isSpawnedByPrefabHandler = true;
-                }
-                else
-                {
-                    // See if there is a valid registered NetworkPrefabOverrideLink associated with the provided prefabHash
-                    GameObject networkPrefabReference = null;
-                    if (NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.ContainsKey(globalObjectIdHash))
-                    {
-                        switch (NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash].Override)
-                        {
-                            default:
-                            case NetworkPrefabOverride.None:
-                                networkPrefabReference = NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash].Prefab;
-                                break;
-                            case NetworkPrefabOverride.Hash:
-                            case NetworkPrefabOverride.Prefab:
-                                networkPrefabReference = NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash].OverridingTargetPrefab;
-                                break;
-                        }
-                    }
-
-                    // If not, then there is an issue (user possibly didn't register the prefab properly?)
-                    if (networkPrefabReference == null)
-                    {
-                        if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
-                        {
-                            NetworkLog.LogError($"Failed to create object locally. [{nameof(globalObjectIdHash)}={globalObjectIdHash}]. {nameof(NetworkPrefab)} could not be found. Is the prefab registered with {nameof(NetworkManager)}?");
-                        }
-                    }
-                    else
-                    {
-                        // Create prefab instance
-                        networkObject = UnityEngine.Object.Instantiate(networkPrefabReference).GetComponent<NetworkObject>();
-                        networkObject.NetworkManagerOwner = NetworkManager;
-                    }
-                }
             }
             else // Get the in-scene placed NetworkObject
             {
@@ -624,6 +744,13 @@ namespace Unity.Netcode
             {
                 networkObject.SubscribeToActiveSceneForSynch();
             }
+
+            // If we are an in-scene placed NetworkObject and our InScenePlacedSourceGlobalObjectIdHash is set
+            // then assign this to the PrefabGlobalObjectIdHash
+            if (networkObject.IsSceneObject.Value && networkObject.InScenePlacedSourceGlobalObjectIdHash != 0)
+            {
+                networkObject.PrefabGlobalObjectIdHash = networkObject.InScenePlacedSourceGlobalObjectIdHash;
+            }
         }
 
         internal void SendSpawnCallForObject(ulong clientId, NetworkObject networkObject)
@@ -728,21 +855,47 @@ namespace Unity.Netcode
                         // Leave destruction up to the handler
                         NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(networkObjects[i]);
                     }
-                    else if (networkObjects[i].IsSpawned)
+                    else
                     {
-                        // If it is an in-scene placed NetworkObject then just despawn
+                        // If it is an in-scene placed NetworkObject then just despawn and let it be destroyed when the scene
-                        // and let it be destroyed when the scene is unloaded. Otherwise, despawn and destroy it.
+                        // is unloaded. Otherwise, despawn and destroy it.
                         var shouldDestroy = !(networkObjects[i].IsSceneObject != null && networkObjects[i].IsSceneObject.Value);
 
+                        // If we are going to destroy this NetworkObject, check for any in-scene placed children that need to be removed
+                        if (shouldDestroy)
+                        {
+                            // Check to see if there are any in-scene placed children that are marked to be destroyed with the scene
+                            var childrenObjects = networkObjects[i].GetComponentsInChildren<NetworkObject>();
+                            foreach (var childObject in childrenObjects)
+                            {
+                                if (childObject == networkObjects[i])
+                                {
+                                    continue;
+                                }
+
+                                // If the child is an in-scene placed NetworkObject then remove the child from the parent (which was dynamically spawned)
+                                // and set its parent to root
+                                if (childObject.IsSceneObject != null && childObject.IsSceneObject.Value)
+                                {
+                                    childObject.TryRemoveParent(childObject.WorldPositionStays());
+                                }
+                            }
+                        }
+
+                        // If spawned, then despawn and potentially destroy. 
+                        if (networkObjects[i].IsSpawned)
+                        {
                             OnDespawnObject(networkObjects[i], shouldDestroy);
                         }
-                    else if (networkObjects[i].IsSceneObject != null && !networkObjects[i].IsSceneObject.Value)
+                        else // Otherwise, if we are not spawned and we should destroy...then destroy.
+                        if (shouldDestroy)
                         {
                             UnityEngine.Object.Destroy(networkObjects[i].gameObject);
                         }
                     }
                 }
             }
+        }
 
         internal void DestroySceneObjects()
         {
@@ -788,7 +941,7 @@ namespace Unity.Netcode
             {
                 if (networkObjects[i].NetworkManager == NetworkManager)
                 {
-                    if (networkObjects[i].IsSceneObject == null)
+                    if (networkObjects[i].IsSceneObject == null || (networkObjects[i].IsSceneObject.HasValue && networkObjects[i].IsSceneObject.Value))
                     {
                         networkObjectsToSpawn.Add(networkObjects[i]);
                     }
@@ -937,7 +1090,7 @@ namespace Unity.Netcode
                 if (sobj.CheckObjectVisibility == null)
                 {
                     // If the client is not part of the observers and spawn with observers is enabled on this instance or the clientId is the server
-                    if (!sobj.Observers.Contains(clientId) && (sobj.SpawnWithObservers || clientId == NetworkManager.ServerClientId))
+                    if (sobj.SpawnWithObservers || clientId == NetworkManager.ServerClientId)
                     {
                         sobj.Observers.Add(clientId);
                     }
@@ -950,7 +1103,6 @@ namespace Unity.Netcode
                         sobj.Observers.Add(clientId);
                     }
                     else // Otherwise, if the observers contains the clientId (shouldn't happen) then remove it since CheckObjectVisibility returned false
-                    if (sobj.Observers.Contains(clientId))
                     {
                         sobj.Observers.Remove(clientId);
                     }

Runtime/Transports/UTP/BatchedSendQueue.cs

@@ -198,43 +198,69 @@ namespace Unity.Netcode.Transports.UTP
         /// could lead to a corrupted queue.
         /// </remarks>
         /// <param name="writer">The <see cref="DataStreamWriter"/> to write to.</param>
+        /// <param name="softMaxBytes">
+        /// Maximum number of bytes to copy (0 means writer capacity). This is a soft limit only.
+        /// If a message is larger than that but fits in the writer, it will be written. In effect,
+        /// this parameter is the maximum size that small messages can be coalesced together.
+        /// </param>
         /// <returns>How many bytes were written to the writer.</returns>
-        public int FillWriterWithMessages(ref DataStreamWriter writer)
+        public int FillWriterWithMessages(ref DataStreamWriter writer, int softMaxBytes = 0)
         {
             if (!IsCreated || Length == 0)
             {
                 return 0;
             }
 
+            softMaxBytes = softMaxBytes == 0 ? writer.Capacity : Math.Min(softMaxBytes, writer.Capacity);
+
             unsafe
             {
                 var reader = new DataStreamReader(m_Data.AsArray());
-
-                var writerAvailable = writer.Capacity;
                 var readerOffset = HeadIndex;
 
+                reader.SeekSet(readerOffset);
+                var messageLength = reader.ReadInt();
+                var bytesToWrite = messageLength + sizeof(int);
+
+                // Our behavior here depends on the size of the first message in the queue. If it's
+                // larger than the soft limit, then add only that message to the writer (we want
+                // large payloads to be fragmented on their own). Otherwise coalesce all small
+                // messages until we hit the soft limit (which presumably means they won't be
+                // fragmented, which is the desired behavior for smaller messages).
+
+                if (bytesToWrite > softMaxBytes && bytesToWrite <= writer.Capacity)
+                {
+                    writer.WriteInt(messageLength);
+                    WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + reader.GetBytesRead(), messageLength);
+
+                    return bytesToWrite;
+                }
+                else
+                {
+                    var bytesWritten = 0;
+
                     while (readerOffset < TailIndex)
                     {
                         reader.SeekSet(readerOffset);
-                    var messageLength = reader.ReadInt();
+                        messageLength = reader.ReadInt();
+                        bytesToWrite = messageLength + sizeof(int);
 
-                    if (writerAvailable < sizeof(int) + messageLength)
+                        if (bytesWritten + bytesToWrite <= softMaxBytes)
                         {
-                        break;
+                            writer.WriteInt(messageLength);
+                            WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + reader.GetBytesRead(), messageLength);
+
+                            readerOffset += bytesToWrite;
+                            bytesWritten += bytesToWrite;
                         }
                         else
                         {
-                        writer.WriteInt(messageLength);
+                            break;
-
-                        var messageOffset = reader.GetBytesRead();
-                        WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + messageOffset, messageLength);
-
-                        writerAvailable -= sizeof(int) + messageLength;
-                        readerOffset += sizeof(int) + messageLength;
                         }
                     }
 
-                return writer.Capacity - writerAvailable;
+                    return bytesWritten;
+                }
             }
         }
 

Runtime/Transports/UTP/UnityTransport.cs

@@ -753,7 +753,7 @@ namespace Unity.Netcode.Transports.UTP
                     // in the stream (the send queue does that automatically) we are sure they'll be
                     // reassembled properly at the other end. This allows us to lift the limit of ~44KB
                     // on reliable payloads (because of the reliable window size).
-                    var written = pipeline == ReliablePipeline ? Queue.FillWriterWithBytes(ref writer, MTU) : Queue.FillWriterWithMessages(ref writer);
+                    var written = pipeline == ReliablePipeline ? Queue.FillWriterWithBytes(ref writer, MTU) : Queue.FillWriterWithMessages(ref writer, MTU);
 
                     result = Driver.EndSend(writer);
                     if (result == written)
@@ -995,6 +995,11 @@ namespace Unity.Netcode.Transports.UTP
 
         private void ExtractNetworkMetricsFromPipeline(NetworkPipeline pipeline, NetworkConnection networkConnection)
         {
+            if (m_Driver.GetConnectionState(networkConnection) != NetworkConnection.State.Connected)
+            {
+                return;
+            }
+
             //Don't need to dispose of the buffers, they are filled with data pointers.
             m_Driver.GetPipelineBuffers(pipeline,
 #if UTP_TRANSPORT_2_0_ABOVE
@@ -1229,7 +1234,18 @@ namespace Unity.Netcode.Transports.UTP
             // Bump the reliable window size to its maximum size of 64. Since NGO makes heavy use of
             // reliable delivery, we're better off with the increased window size compared to the
             // extra 4 bytes of header that this costs us.
-            m_NetworkSettings.WithReliableStageParameters(windowSize: 64);
+            //
+            // We also increase the maximum resend timeout since the default one in UTP is very
+            // aggressive (optimized for latency and low bandwidth). With NGO, it's too low and
+            // we sometimes notice a lot of useless resends, especially if using Relay. (We can
+            // only do this with UTP 2.0 because 1.X doesn't support that parameter.)
+            m_NetworkSettings.WithReliableStageParameters(
+                windowSize: 64
+#if UTP_TRANSPORT_2_0_ABOVE
+                ,
+                maximumResendTime: m_ProtocolType == ProtocolType.RelayUnityTransport ? 750 : 500
+#endif
+            );
 
 #if !UTP_TRANSPORT_2_0_ABOVE && !UNITY_WEBGL
             m_NetworkSettings.WithBaselibNetworkInterfaceParameters(

TestHelpers/Runtime/NetcodeIntegrationTest.cs

@@ -305,8 +305,12 @@ namespace Unity.Netcode.TestHelpers.Runtime
         public IEnumerator SetUp()
         {
             VerboseDebug($"Entering {nameof(SetUp)}");
-
             NetcodeLogAssert = new NetcodeLogAssert();
+            if (m_EnableTimeTravel)
+            {
+                // Setup the frames per tick for time travel advance to next tick
+                ConfigureFramesPerTick();
+            }
             if (m_SetupIsACoroutine)
             {
                 yield return OnSetup();
@@ -732,6 +736,16 @@ namespace Unity.Netcode.TestHelpers.Runtime
                     Assert.Fail("Failed to start instances");
                 }
 
+                // When scene management is enabled, we need to re-apply the scenes populated list since we have overriden the ISceneManagerHandler
+                // imeplementation at this point. This assures any pre-loaded scenes will be automatically assigned to the server and force clients 
+                // to load their own scenes.
+                if (m_ServerNetworkManager.NetworkConfig.EnableSceneManagement)
+                {
+                    var scenesLoaded = m_ServerNetworkManager.SceneManager.ScenesLoaded;
+                    m_ServerNetworkManager.SceneManager.SceneManagerHandler.PopulateLoadedScenes(ref scenesLoaded, m_ServerNetworkManager);
+                }
+
+
                 if (LogAllMessages)
                 {
                     EnableMessageLogging();
@@ -799,6 +813,12 @@ namespace Unity.Netcode.TestHelpers.Runtime
                     Assert.Fail("Failed to start instances");
                 }
 
+                // Time travel does not play nice with scene loading, clear out server side pre-loaded scenes.
+                if (m_ServerNetworkManager.NetworkConfig.EnableSceneManagement)
+                {
+                    m_ServerNetworkManager.SceneManager.ScenesLoaded.Clear();
+                }
+
                 if (LogAllMessages)
                 {
                     EnableMessageLogging();
@@ -1544,8 +1564,42 @@ namespace Unity.Netcode.TestHelpers.Runtime
             }
         }
 
+        protected virtual uint GetTickRate()
+        {
+            return k_DefaultTickRate;
+        }
+
+        protected virtual int GetFrameRate()
+        {
+            return Application.targetFrameRate == 0 ? 60 : Application.targetFrameRate;
+        }
+
+        private int m_FramesPerTick = 0;
+        private float m_TickFrequency = 0;
+
+        /// <summary>
+        /// Recalculates the <see cref="m_TickFrequency"/> and <see cref="m_FramesPerTick"/> that is
+        /// used in <see cref="TimeTravelAdvanceTick"/>.
+        /// </summary>
+        protected void ConfigureFramesPerTick()
+        {
+            m_TickFrequency = 1.0f / GetTickRate();
+            m_FramesPerTick = Math.Max((int)(m_TickFrequency / GetFrameRate()), 1);
+        }
+
         /// <summary>
         /// Helper function to time travel exactly one tick's worth of time at the current frame and tick rates.
+        /// This is NetcodeIntegrationTest instance relative and will automatically adjust based on <see cref="GetFrameRate"/>
+        /// and <see cref="GetTickRate"/>.
+        /// </summary>
+        protected void TimeTravelAdvanceTick()
+        {
+            TimeTravel(m_TickFrequency, m_FramesPerTick);
+        }
+
+        /// <summary>
+        /// Helper function to time travel exactly one tick's worth of time at the current frame and tick rates.
+        /// ** Is based on the global k_DefaultTickRate and is not local to each NetcodeIntegrationTest instance **
         /// </summary>
         public static void TimeTravelToNextTick()
         {
@@ -1555,7 +1609,6 @@ namespace Unity.Netcode.TestHelpers.Runtime
             {
                 frameRate = 60;
             }
-
             var frames = Math.Max((int)(timePassed / frameRate), 1);
             TimeTravel(timePassed, frames);
         }

TestHelpers/Runtime/NetcodeIntegrationTestHelpers.cs

@@ -813,7 +813,8 @@ namespace Unity.Netcode.TestHelpers.Runtime
 
             if (minFrames > 0)
             {
-                yield return new WaitUntil(() => Time.frameCount >= minFrames);
+                var waitForFrameCount = Time.frameCount + minFrames;
+                yield return new WaitUntil(() => Time.frameCount >= waitForFrameCount);
             }
 
             while (Time.realtimeSinceStartup - startTime < timeout && !predicate())

Tests/Editor/Transports/BatchedSendQueueTests.cs

@@ -237,6 +237,35 @@ namespace Unity.Netcode.EditorTests
             AssertIsTestMessage(data);
         }
 
+        [Test]
+        public void BatchedSendQueue_FillWriterWithMessages_StopOnSoftMaxBytes()
+        {
+            var smallMessage = new ArraySegment<byte>(new byte[10]);
+            var largeMessage = new ArraySegment<byte>(new byte[3000]);
+
+            var smallMessageSize = smallMessage.Count + BatchedSendQueue.PerMessageOverhead;
+            var largeMessageSize = largeMessage.Count + BatchedSendQueue.PerMessageOverhead;
+
+            using var q = new BatchedSendQueue(k_TestQueueCapacity);
+            using var data = new NativeArray<byte>(largeMessageSize, Allocator.Temp);
+
+            q.PushMessage(smallMessage);
+            q.PushMessage(largeMessage);
+            q.PushMessage(smallMessage);
+
+            var writer = new DataStreamWriter(data);
+            Assert.AreEqual(smallMessageSize, q.FillWriterWithMessages(ref writer, 1000));
+            q.Consume(smallMessageSize);
+
+            writer = new DataStreamWriter(data);
+            Assert.AreEqual(largeMessageSize, q.FillWriterWithMessages(ref writer, 1000));
+            q.Consume(largeMessageSize);
+
+            writer = new DataStreamWriter(data);
+            Assert.AreEqual(smallMessageSize, q.FillWriterWithMessages(ref writer, 1000));
+            q.Consume(smallMessageSize);
+        }
+
         [Test]
         public void BatchedSendQueue_FillWriterWithBytes_NoopIfNoData()
         {

Tests/Runtime/DeferredMessagingTests.cs

@@ -94,6 +94,10 @@ namespace Unity.Netcode.RuntimeTests
 
         public override void ProcessTriggers(IDeferredNetworkMessageManager.TriggerType trigger, ulong key)
         {
+            if (trigger == IDeferredNetworkMessageManager.TriggerType.OnNextFrame)
+            {
+                return;
+            }
             ProcessTriggersCalled = true;
             base.ProcessTriggers(trigger, key);
         }

Tests/Runtime/InvalidConnectionEventsTest.cs

@@ -79,7 +79,10 @@ namespace Unity.Netcode.RuntimeTests
         [UnityTest]
         public IEnumerator WhenSendingConnectionApprovedToAlreadyConnectedClient_ConnectionApprovedMessageIsRejected()
         {
-            var message = new ConnectionApprovedMessage();
+            var message = new ConnectionApprovedMessage
+            {
+                ConnectedClientIds = new NativeArray<ulong>(0, Allocator.Temp)
+            };
             m_ServerNetworkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.Reliable, m_ClientNetworkManagers[0].LocalClientId);
 
             // Unnamed message is something to wait for. When this one is received,
@@ -93,7 +96,7 @@ namespace Unity.Netcode.RuntimeTests
 
             m_ClientNetworkManagers[0].ConnectionManager.MessageManager.Hook(new Hooks<ConnectionApprovedMessage>());
 
-            LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionApprovedMessage)} was received from the server when the connection has already been established\\. This should not happen\\."));
+            LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionApprovedMessage)} was received from the server when the connection has already been established\\. NetworkTransport: Unity.Netcode.Transports.UTP.UnityTransport UnityTransportProtocol: UnityTransport. This should not happen\\."));
 
             yield return WaitForMessageReceived<UnnamedMessage>(m_ClientNetworkManagers.ToList());
         }
@@ -115,7 +118,7 @@ namespace Unity.Netcode.RuntimeTests
 
             m_ClientNetworkManagers[0].ConnectionManager.MessageManager.Hook(new Hooks<ConnectionRequestMessage>());
 
-            LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side\\. This should not happen\\."));
+            LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side\\. NetworkTransport: Unity.Netcode.Transports.UTP.UnityTransport UnityTransportProtocol: UnityTransport. This should not happen\\."));
 
             yield return WaitForMessageReceived<UnnamedMessage>(m_ClientNetworkManagers.ToList());
         }
@@ -137,7 +140,7 @@ namespace Unity.Netcode.RuntimeTests
 
             m_ServerNetworkManager.ConnectionManager.MessageManager.Hook(new Hooks<ConnectionRequestMessage>());
 
-            LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionRequestMessage)} was received from a client when the connection has already been established\\. This should not happen\\."));
+            LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionRequestMessage)} was received from a client when the connection has already been established\\. NetworkTransport: Unity.Netcode.Transports.UTP.UnityTransport UnityTransportProtocol: UnityTransport. This should not happen\\."));
 
             yield return WaitForMessageReceived<UnnamedMessage>(new List<NetworkManager> { m_ServerNetworkManager });
         }
@@ -145,7 +148,10 @@ namespace Unity.Netcode.RuntimeTests
         [UnityTest]
         public IEnumerator WhenSendingConnectionApprovedFromAnyClient_ConnectionApprovedMessageIsRejected()
         {
-            var message = new ConnectionApprovedMessage();
+            var message = new ConnectionApprovedMessage
+            {
+                ConnectedClientIds = new NativeArray<ulong>(0, Allocator.Temp)
+            };
             m_ClientNetworkManagers[0].ConnectionManager.SendMessage(ref message, NetworkDelivery.Reliable, m_ServerNetworkManager.LocalClientId);
 
             // Unnamed message is something to wait for. When this one is received,
@@ -159,7 +165,7 @@ namespace Unity.Netcode.RuntimeTests
 
             m_ServerNetworkManager.ConnectionManager.MessageManager.Hook(new Hooks<ConnectionApprovedMessage>());
 
-            LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side\\. This should not happen\\."));
+            LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side\\. NetworkTransport: Unity.Netcode.Transports.UTP.UnityTransport UnityTransportProtocol: UnityTransport. This should not happen\\."));
 
             yield return WaitForMessageReceived<UnnamedMessage>(new List<NetworkManager> { m_ServerNetworkManager });
         }

Tests/Runtime/NetworkObject/NetworkObjectDestroyTests.cs

@@ -58,6 +58,9 @@ namespace Unity.Netcode.RuntimeTests
             ShuttingDown,
             ActiveSession
         }
+
+        private string m_ClientPlayerName;
+        private ulong m_ClientNetworkObjectId;
         /// <summary>
         /// Validates the expected behavior when the client-side destroys a <see cref="NetworkObject"/>
         /// </summary>
@@ -78,7 +81,8 @@ namespace Unity.Netcode.RuntimeTests
                 LogAssert.ignoreFailingMessages = true;
                 NetworkLog.NetworkManagerOverride = m_ClientNetworkManagers[0];
             }
-
+            m_ClientPlayerName = clientPlayer.gameObject.name;
+            m_ClientNetworkObjectId = clientPlayer.NetworkObjectId;
             Object.DestroyImmediate(clientPlayer.gameObject);
 
             // destroying a NetworkObject while a session is active is not allowed
@@ -91,12 +95,12 @@ namespace Unity.Netcode.RuntimeTests
 
         private bool HaveLogsBeenReceived()
         {
-            if (!NetcodeLogAssert.HasLogBeenReceived(LogType.Error, "[Netcode] Destroy a spawned NetworkObject on a non-host client is not valid. Call Destroy or Despawn on the server/host instead."))
+            if (!NetcodeLogAssert.HasLogBeenReceived(LogType.Error, $"[Netcode] [Invalid Destroy][{m_ClientPlayerName}][NetworkObjectId:{m_ClientNetworkObjectId}] Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call Destroy or Despawn on the server/host instead."))
             {
                 return false;
             }
 
-            if (!NetcodeLogAssert.HasLogBeenReceived(LogType.Error, $"[Netcode-Server Sender={m_ClientNetworkManagers[0].LocalClientId}] Destroy a spawned NetworkObject on a non-host client is not valid. Call Destroy or Despawn on the server/host instead."))
+            if (!NetcodeLogAssert.HasLogBeenReceived(LogType.Error, $"[Netcode-Server Sender={m_ClientNetworkManagers[0].LocalClientId}] [Invalid Destroy][{m_ClientPlayerName}][NetworkObjectId:{m_ClientNetworkObjectId}] Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call Destroy or Despawn on the server/host instead."))
             {
                 return false;
             }

Tests/Runtime/NetworkObject/NetworkObjectOnNetworkDespawnTests.cs

@@ -10,111 +10,104 @@ namespace Unity.Netcode.RuntimeTests
     /// <summary>
     /// Tests that check OnNetworkDespawn being invoked
     /// </summary>
-    public class NetworkObjectOnNetworkDespawnTests
+    [TestFixture(HostOrServer.Host)]
+    [TestFixture(HostOrServer.Server)]
+    public class NetworkObjectOnNetworkDespawnTests : NetcodeIntegrationTest
     {
-        private NetworkManager m_ServerHost;
+        private const string k_ObjectName = "TestDespawn";
-        private NetworkManager[] m_Clients;
+        public enum InstanceType
+        {
+            Server,
+            Client
+        }
 
+        protected override int NumberOfClients => 1;
         private GameObject m_ObjectToSpawn;
-        private NetworkObject m_NetworkObject;
+        private HostOrServer m_HostOrServer;
+        public NetworkObjectOnNetworkDespawnTests(HostOrServer hostOrServer) : base(hostOrServer)
+        {
+            m_HostOrServer = hostOrServer;
+        }
 
         internal class OnNetworkDespawnTestComponent : NetworkBehaviour
         {
-            public bool OnNetworkDespawnCalled { get; internal set; }
+            public static bool OnServerNetworkDespawnCalled { get; internal set; }
+            public static bool OnClientNetworkDespawnCalled { get; internal set; }
 
             public override void OnNetworkSpawn()
             {
-                OnNetworkDespawnCalled = false;
+                if (IsServer)
+                {
+                    OnServerNetworkDespawnCalled = false;
+                }
+                else
+                {
+                    OnClientNetworkDespawnCalled = false;
+                }
                 base.OnNetworkSpawn();
             }
 
             public override void OnNetworkDespawn()
             {
-                OnNetworkDespawnCalled = true;
+                if (IsServer)
+                {
+                    OnServerNetworkDespawnCalled = true;
+                }
+                else
+                {
+                    OnClientNetworkDespawnCalled = true;
+                }
                 base.OnNetworkDespawn();
             }
         }
 
-        [UnitySetUp]
+        protected override void OnServerAndClientsCreated()
-        public IEnumerator Setup()
         {
-            Assert.IsTrue(NetcodeIntegrationTestHelpers.Create(1, out m_ServerHost, out m_Clients));
+            m_ObjectToSpawn = CreateNetworkObjectPrefab(k_ObjectName);
-
-            m_ObjectToSpawn = NetcodeIntegrationTestHelpers.CreateNetworkObjectPrefab(nameof(NetworkObjectOnNetworkDespawnTests), m_ServerHost, m_Clients);
             m_ObjectToSpawn.AddComponent<OnNetworkDespawnTestComponent>();
-            m_NetworkObject = m_ObjectToSpawn.GetComponent<NetworkObject>();
+            base.OnServerAndClientsCreated();
-
-            yield return null;
-        }
-
-        [UnityTearDown]
-        public IEnumerator Teardown()
-        {
-            // Shutdown and clean up both of our NetworkManager instances
-            if (m_ObjectToSpawn)
-            {
-                Object.Destroy(m_ObjectToSpawn);
-                m_ObjectToSpawn = null;
-            }
-            NetcodeIntegrationTestHelpers.Destroy();
-            yield return null;
-        }
-
-        public enum InstanceType
-        {
-            Server,
-            Host,
-            Client
         }
 
         /// <summary>
-        /// Tests that a spawned NetworkObject's associated NetworkBehaviours will have
+        /// This test validates that <see cref="NetworkBehaviour.OnNetworkDespawn"/> is invoked when the
-        /// their OnNetworkDespawn invoked during NetworkManager shutdown.
+        /// <see cref="NetworkManager"/> is shutdown.
         /// </summary>
         [UnityTest]
-        public IEnumerator TestNetworkObjectDespawnOnShutdown([Values(InstanceType.Server, InstanceType.Host, InstanceType.Client)] InstanceType despawnCheck)
+        public IEnumerator TestNetworkObjectDespawnOnShutdown()
         {
-            var useHost = despawnCheck != InstanceType.Server;
-            var networkManager = despawnCheck == InstanceType.Host || despawnCheck == InstanceType.Server ? m_ServerHost : m_Clients[0];
-
-            // Start the instances
-            if (!NetcodeIntegrationTestHelpers.Start(useHost, m_ServerHost, m_Clients))
-            {
-                Debug.LogError("Failed to start instances");
-                Assert.Fail("Failed to start instances");
-            }
-
-            // [Client-Side] Wait for a connection to the server
-            yield return NetcodeIntegrationTestHelpers.WaitForClientsConnected(m_Clients, null, 512);
-
-            // [Host-Server-Side] Check to make sure all clients are connected
-            var clientCount = useHost ? m_Clients.Length + 1 : m_Clients.Length;
-            yield return NetcodeIntegrationTestHelpers.WaitForClientsConnectedToServer(m_ServerHost, clientCount, null, 512);
-
             // Spawn the test object
-            var spawnedObject = Object.Instantiate(m_NetworkObject);
+            var spawnedObject = SpawnObject(m_ObjectToSpawn, m_ServerNetworkManager);
             var spawnedNetworkObject = spawnedObject.GetComponent<NetworkObject>();
-            spawnedNetworkObject.NetworkManagerOwner = m_ServerHost;
-            spawnedNetworkObject.Spawn(true);
 
-            // Get the spawned object relative to which NetworkManager instance we are testing.
+            // Wait for the client to spawn the object
-            var relativeSpawnedObject = new NetcodeIntegrationTestHelpers.ResultWrapper<NetworkObject>();
+            yield return WaitForConditionOrTimeOut(() =>
-            yield return NetcodeIntegrationTestHelpers.GetNetworkObjectByRepresentation((x => x.GetComponent<OnNetworkDespawnTestComponent>() != null), networkManager, relativeSpawnedObject);
+            {
-            var onNetworkDespawnTestComponent = relativeSpawnedObject.Result.GetComponent<OnNetworkDespawnTestComponent>();
+                if (!s_GlobalNetworkObjects.ContainsKey(m_ClientNetworkManagers[0].LocalClientId))
+                {
+                    return false;
+                }
+                if (!s_GlobalNetworkObjects[m_ClientNetworkManagers[0].LocalClientId].ContainsKey(spawnedNetworkObject.NetworkObjectId))
+                {
+                    return false;
+                }
+                return true;
+            });
+
+            AssertOnTimeout($"Timed out waiting for client to spawn {k_ObjectName}!");
 
             // Confirm it is not set before shutting down the NetworkManager
-            Assert.IsFalse(onNetworkDespawnTestComponent.OnNetworkDespawnCalled);
+            Assert.IsFalse(OnNetworkDespawnTestComponent.OnClientNetworkDespawnCalled, "[Client-side] despawn state is already set (should not be set at this point)!");
+            Assert.IsFalse(OnNetworkDespawnTestComponent.OnServerNetworkDespawnCalled, $"[{m_HostOrServer}-side] despawn state is already set (should not be set at this point)!");
 
-            // Shutdown the NetworkManager instance we are testing.
+            // Shutdown the client-side first to validate the client-side instance invokes OnNetworkDespawn
-            networkManager.Shutdown();
+            m_ClientNetworkManagers[0].Shutdown();
+            yield return WaitForConditionOrTimeOut(() => OnNetworkDespawnTestComponent.OnClientNetworkDespawnCalled);
+            AssertOnTimeout($"[Client-side] Timed out waiting for {k_ObjectName}'s {nameof(NetworkBehaviour.OnNetworkDespawn)} to be invoked!");
 
-            // Since shutdown is now delayed until the post frame update
+            // Shutdown the servr-host-side second to validate servr-host-side instance invokes OnNetworkDespawn
-            // just wait 2 frames before checking to see if OnNetworkDespawnCalled is true
+            m_ServerNetworkManager.Shutdown();
-            var currentFrame = Time.frameCount + 2;
+            yield return WaitForConditionOrTimeOut(() => OnNetworkDespawnTestComponent.OnClientNetworkDespawnCalled);
-            yield return new WaitUntil(() => Time.frameCount <= currentFrame);
+            AssertOnTimeout($"[{m_HostOrServer}-side]Timed out waiting for {k_ObjectName}'s {nameof(NetworkBehaviour.OnNetworkDespawn)} to be invoked!");
-
-            // Confirm that OnNetworkDespawn is invoked after shutdown
-            Assert.IsTrue(onNetworkDespawnTestComponent.OnNetworkDespawnCalled);
         }
     }
 }

Tests/Runtime/NetworkObject/NetworkObjectSpawnManyObjectsTests.cs

@@ -57,9 +57,9 @@ namespace Unity.Netcode.RuntimeTests
                 serverObject.NetworkManagerOwner = m_ServerNetworkManager;
                 serverObject.Spawn();
             }
-            // ensure all objects are replicated before spawning more
+            // ensure all objects are replicated
-            yield return WaitForConditionOrTimeOut(() => SpawnObjecTrackingComponent.SpawnedObjects < k_SpawnedObjects);
+            yield return WaitForConditionOrTimeOut(() => SpawnObjecTrackingComponent.SpawnedObjects == k_SpawnedObjects);
-            Assert.False(s_GlobalTimeoutHelper.TimedOut, $"Timed out waiting for the client to spawn {k_SpawnedObjects} objects!");
+            AssertOnTimeout($"Timed out waiting for the client to spawn {k_SpawnedObjects} objects!");
         }
     }
 }

Tests/Runtime/NetworkTransform/NetworkTransformBase.cs.meta

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

Tests/Runtime/NetworkTransform/NetworkTransformGeneral.cs

@@ -0,0 +1,314 @@
+using NUnit.Framework;
+using Unity.Netcode.Components;
+using UnityEngine;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    [TestFixture(HostOrServer.Host, Authority.OwnerAuthority)]
+    [TestFixture(HostOrServer.Host, Authority.ServerAuthority)]
+    public class NetworkTransformGeneral : NetworkTransformBase
+    {
+        public NetworkTransformGeneral(HostOrServer testWithHost, Authority authority) :
+            base(testWithHost, authority, RotationCompression.None, Rotation.Euler, Precision.Full)
+        { }
+
+        protected override bool m_EnableTimeTravel => true;
+        protected override bool m_SetupIsACoroutine => false;
+        protected override bool m_TearDownIsACoroutine => false;
+
+        /// <summary>
+        /// Test to verify nonAuthority cannot change the transform directly
+        /// </summary>
+        [Test]
+        public void VerifyNonAuthorityCantChangeTransform([Values] Interpolation interpolation)
+        {
+            m_AuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
+            m_NonAuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
+
+            Assert.AreEqual(Vector3.zero, m_NonAuthoritativeTransform.transform.position, "other side pos should be zero at first"); // sanity check
+
+            m_NonAuthoritativeTransform.transform.position = new Vector3(4, 5, 6);
+
+            TimeTravelAdvanceTick();
+            TimeTravelAdvanceTick();
+
+            Assert.AreEqual(Vector3.zero, m_NonAuthoritativeTransform.transform.position, "[Position] NonAuthority was able to change the position!");
+
+            var nonAuthorityRotation = m_NonAuthoritativeTransform.transform.rotation;
+            var originalNonAuthorityEulerRotation = nonAuthorityRotation.eulerAngles;
+            var nonAuthorityEulerRotation = originalNonAuthorityEulerRotation;
+            // Verify rotation is not marked dirty when rotated by half of the threshold
+            nonAuthorityEulerRotation.y += 20.0f;
+            nonAuthorityRotation.eulerAngles = nonAuthorityEulerRotation;
+            m_NonAuthoritativeTransform.transform.rotation = nonAuthorityRotation;
+            TimeTravelAdvanceTick();
+            var nonAuthorityCurrentEuler = m_NonAuthoritativeTransform.transform.rotation.eulerAngles;
+            Assert.True(originalNonAuthorityEulerRotation.Equals(nonAuthorityCurrentEuler), "[Rotation] NonAuthority was able to change the rotation!");
+
+            var nonAuthorityScale = m_NonAuthoritativeTransform.transform.localScale;
+            m_NonAuthoritativeTransform.transform.localScale = nonAuthorityScale * 100;
+
+            TimeTravelAdvanceTick();
+
+            Assert.True(nonAuthorityScale.Equals(m_NonAuthoritativeTransform.transform.localScale), "[Scale] NonAuthority was able to change the scale!");
+        }
+
+        /// <summary>
+        /// Validates that rotation checks don't produce false positive
+        /// results when rolling over between 0 and 360 degrees
+        /// </summary>
+        [Test]
+        public void TestRotationThresholdDeltaCheck([Values] Interpolation interpolation)
+        {
+            m_AuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
+            m_NonAuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
+            m_NonAuthoritativeTransform.RotAngleThreshold = m_AuthoritativeTransform.RotAngleThreshold = 5.0f;
+            var halfThreshold = m_AuthoritativeTransform.RotAngleThreshold * 0.5001f;
+
+            // Apply the current state prior to getting reference rotations which assures we have
+            // applied the most current rotation deltas and that all bitset flags are updated 
+            var results = m_AuthoritativeTransform.ApplyState();
+            TimeTravelAdvanceTick();
+
+            // Get the current rotation values;
+            var authorityRotation = m_AuthoritativeTransform.transform.rotation;
+            var authorityEulerRotation = authorityRotation.eulerAngles;
+
+            // Verify rotation is not marked dirty when rotated by half of the threshold
+            authorityEulerRotation.y += halfThreshold;
+            authorityRotation.eulerAngles = authorityEulerRotation;
+            m_AuthoritativeTransform.transform.rotation = authorityRotation;
+            results = m_AuthoritativeTransform.ApplyState();
+            Assert.IsFalse(results.isRotationDirty, $"Rotation is dirty when rotation threshold is {m_AuthoritativeTransform.RotAngleThreshold} degrees and only adjusted by {halfThreshold} degrees!");
+            // Now allow the delta state to be processed and sent (just allow for two ticks to cover edge cases with time travel and the testing environment)
+            TimeTravelAdvanceTick();
+            TimeTravelAdvanceTick();
+
+            // Verify rotation is marked dirty when rotated by another half threshold value
+            authorityEulerRotation.y += halfThreshold;
+            authorityRotation.eulerAngles = authorityEulerRotation;
+            m_AuthoritativeTransform.transform.rotation = authorityRotation;
+            results = m_AuthoritativeTransform.ApplyState();
+            Assert.IsTrue(results.isRotationDirty, $"Rotation was not dirty when rotated by the threshold value: {m_AuthoritativeTransform.RotAngleThreshold} degrees!");
+            // Now allow the delta state to be processed and sent (just allow for two ticks to cover edge cases with time travel and the testing environment)
+            TimeTravelAdvanceTick();
+            TimeTravelAdvanceTick();
+
+            //Reset rotation back to zero on all axis
+            authorityRotation.eulerAngles = authorityEulerRotation = Vector3.zero;
+            m_AuthoritativeTransform.transform.rotation = authorityRotation;
+            // Now allow the delta state to be processed and sent (just allow for two ticks to cover edge cases with time travel and the testing environment)
+            TimeTravelAdvanceTick();
+            TimeTravelAdvanceTick();
+
+            // Rotate by 360 minus halfThreshold (which is really just negative halfThreshold) and verify rotation is not marked dirty
+            authorityEulerRotation.y = 360 - halfThreshold;
+            authorityRotation.eulerAngles = authorityEulerRotation;
+            m_AuthoritativeTransform.transform.rotation = authorityRotation;
+            results = m_AuthoritativeTransform.ApplyState();
+            Assert.IsFalse(results.isRotationDirty, $"Rotation is dirty when rotation threshold is {m_AuthoritativeTransform.RotAngleThreshold} degrees and only adjusted by " +
+                $"{Mathf.DeltaAngle(0, authorityEulerRotation.y)} degrees!");
+            // Now allow the delta state to be processed and sent (just allow for two ticks to cover edge cases with time travel and the testing environment)
+            TimeTravelAdvanceTick();
+            TimeTravelAdvanceTick();
+
+            // Now apply one more minor decrement that should trigger a dirty flag
+            authorityEulerRotation.y -= halfThreshold;
+            authorityRotation.eulerAngles = authorityEulerRotation;
+            m_AuthoritativeTransform.transform.rotation = authorityRotation;
+            results = m_AuthoritativeTransform.ApplyState();
+            Assert.IsTrue(results.isRotationDirty, $"Rotation was not dirty when rotated by {Mathf.DeltaAngle(0, authorityEulerRotation.y)} degrees!");
+
+            //Reset rotation back to zero on all axis
+            authorityRotation.eulerAngles = authorityEulerRotation = Vector3.zero;
+            m_AuthoritativeTransform.transform.rotation = authorityRotation;
+            // Now allow the delta state to be processed and sent (just allow for two ticks to cover edge cases with time travel and the testing environment)
+            TimeTravelAdvanceTick();
+            TimeTravelAdvanceTick();
+
+            // Minor decrement again under the threshold value
+            authorityEulerRotation.y -= halfThreshold;
+            authorityRotation.eulerAngles = authorityEulerRotation;
+            m_AuthoritativeTransform.transform.rotation = authorityRotation;
+            results = m_AuthoritativeTransform.ApplyState();
+            Assert.IsFalse(results.isRotationDirty, $"Rotation is dirty when rotation threshold is {m_AuthoritativeTransform.RotAngleThreshold} degrees and only adjusted by " +
+                $"{Mathf.DeltaAngle(0, authorityEulerRotation.y)} degrees!");
+            // Now allow the delta state to be processed and sent (just allow for two ticks to cover edge cases with time travel and the testing environment)
+            TimeTravelAdvanceTick();
+            TimeTravelAdvanceTick();
+
+            // Now decrement another half threshold which should trigger the dirty flag
+            authorityEulerRotation.y -= halfThreshold;
+            authorityRotation.eulerAngles = authorityEulerRotation;
+            m_AuthoritativeTransform.transform.rotation = authorityRotation;
+            results = m_AuthoritativeTransform.ApplyState();
+            Assert.IsTrue(results.isRotationDirty, $"Rotation was not dirty when rotated by {Mathf.DeltaAngle(0, authorityEulerRotation.y)} degrees!");
+        }
+
+        private bool ValidateBitSetValues()
+        {
+            var serverState = m_AuthoritativeTransform.AuthorityLastSentState;
+            var clientState = m_NonAuthoritativeTransform.LocalAuthoritativeNetworkState;
+            if (serverState.HasPositionX == clientState.HasPositionX && serverState.HasPositionY == clientState.HasPositionY && serverState.HasPositionZ == clientState.HasPositionZ &&
+                serverState.HasRotAngleX == clientState.HasRotAngleX && serverState.HasRotAngleY == clientState.HasRotAngleY && serverState.HasRotAngleZ == clientState.HasRotAngleZ &&
+                serverState.HasScaleX == clientState.HasScaleX && serverState.HasScaleY == clientState.HasScaleY && serverState.HasScaleZ == clientState.HasScaleZ)
+            {
+                return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Test to make sure that the bitset value is updated properly
+        /// </summary>
+        [Test]
+        public void TestBitsetValue([Values] Interpolation interpolation)
+        {
+            m_AuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
+            m_NonAuthoritativeTransform.RotAngleThreshold = m_AuthoritativeTransform.RotAngleThreshold = 0.1f;
+            m_AuthoritativeTransform.transform.rotation = Quaternion.Euler(1, 2, 3);
+            TimeTravelAdvanceTick();
+            var success = WaitForConditionOrTimeOutWithTimeTravel(ValidateBitSetValues);
+            Assert.True(success, $"Timed out waiting for Authoritative Bitset state to equal NonAuthoritative replicated Bitset state!");
+            success = WaitForConditionOrTimeOutWithTimeTravel(() => RotationsMatch());
+            Assert.True(success, $"[Timed-Out] Authoritative rotation {m_AuthoritativeTransform.transform.rotation.eulerAngles} != Non-Authoritative rotation {m_NonAuthoritativeTransform.transform.rotation.eulerAngles}");
+        }
+
+        /// <summary>
+        /// This validates that you can perform multiple explicit <see cref="NetworkTransform.SetState(Vector3?, Quaternion?, Vector3?, bool)"/> calls
+        /// within the same fractional tick period without the loss of the states applied.
+        /// </summary>
+        [Test]
+        public void TestMultipleExplicitSetStates([Values] Interpolation interpolation)
+        {
+            var interpolate = interpolation == Interpolation.EnableInterpolate;
+            m_AuthoritativeTransform.Interpolate = interpolate;
+            var updatedPosition = GetRandomVector3(-5.0f, 5.0f);
+            m_AuthoritativeTransform.SetState(updatedPosition, null, null, !interpolate);
+            // Advance to next frame
+            TimeTravel(0.001f, 1);
+
+            updatedPosition += GetRandomVector3(-5.0f, 5.0f);
+            m_AuthoritativeTransform.SetState(updatedPosition, null, null, !interpolate);
+            TimeTravelAdvanceTick();
+
+            var success = WaitForConditionOrTimeOutWithTimeTravel(() => PositionsMatch());
+            Assert.True(success, $"[Timed-Out] Authoritative position {m_AuthoritativeTransform.transform.position} != Non-Authoritative position {m_NonAuthoritativeTransform.transform.position}");
+            Assert.True(Approximately(updatedPosition, m_NonAuthoritativeTransform.transform.position), $"NonAuthority position {m_NonAuthoritativeTransform.transform.position} does not equal the calculated position {updatedPosition}!");
+
+            var updatedRotation = m_AuthoritativeTransform.transform.rotation;
+            updatedRotation.eulerAngles += GetRandomVector3(-30.0f, 30.0f);
+            m_AuthoritativeTransform.SetState(null, updatedRotation, null, !interpolate);
+            // Advance to next frame
+            TimeTravel(0.001f, 1);
+
+            updatedRotation.eulerAngles += GetRandomVector3(-30.0f, 30.0f);
+            m_AuthoritativeTransform.SetState(null, updatedRotation, null, !interpolate);
+            TimeTravelAdvanceTick();
+
+            success = WaitForConditionOrTimeOutWithTimeTravel(() => RotationsMatch());
+            Assert.True(success, $"[Timed-Out] Authoritative rotation {m_AuthoritativeTransform.transform.rotation.eulerAngles} != Non-Authoritative rotation {m_NonAuthoritativeTransform.transform.rotation.eulerAngles}");
+            Assert.True(Approximately(updatedRotation.eulerAngles, m_NonAuthoritativeTransform.transform.rotation.eulerAngles), $"NonAuthority rotation {m_NonAuthoritativeTransform.transform.rotation.eulerAngles} does not equal the calculated rotation {updatedRotation.eulerAngles}!");
+
+            var updatedScale = m_AuthoritativeTransform.transform.localScale;
+            updatedScale += GetRandomVector3(-2.0f, 2.0f);
+            m_AuthoritativeTransform.SetState(null, null, updatedScale, !interpolate);
+            // Advance to next frame
+            TimeTravel(0.001f, 1);
+
+            updatedScale += GetRandomVector3(-2.0f, 2.0f);
+            m_AuthoritativeTransform.SetState(null, null, updatedScale, !interpolate);
+            TimeTravelAdvanceTick();
+
+            success = WaitForConditionOrTimeOutWithTimeTravel(() => ScaleValuesMatch());
+            Assert.True(success, $"[Timed-Out] Authoritative rotation {m_AuthoritativeTransform.transform.localScale} != Non-Authoritative rotation {m_NonAuthoritativeTransform.transform.localScale}");
+            Assert.True(Approximately(updatedScale, m_NonAuthoritativeTransform.transform.localScale), $"NonAuthority scale {m_NonAuthoritativeTransform.transform.localScale} does not equal the calculated scale {updatedScale}!");
+
+            // Now test explicitly setting all axis of transform multiple times during a fractional tick period
+            updatedPosition += GetRandomVector3(-5.0f, 5.0f);
+            updatedRotation.eulerAngles += GetRandomVector3(-30.0f, 30.0f);
+            updatedScale += GetRandomVector3(-2.0f, 2.0f);
+            m_AuthoritativeTransform.SetState(updatedPosition, updatedRotation, updatedScale, !interpolate);
+            // Advance to next frame
+            TimeTravel(0.001f, 1);
+
+            updatedPosition += GetRandomVector3(-5.0f, 5.0f);
+            updatedRotation.eulerAngles += GetRandomVector3(-30.0f, 30.0f);
+            updatedScale += GetRandomVector3(-2.0f, 2.0f);
+            m_AuthoritativeTransform.SetState(updatedPosition, updatedRotation, updatedScale, !interpolate);
+            // Advance to next frame
+            TimeTravel(0.001f, 1);
+
+            updatedPosition += GetRandomVector3(-5.0f, 5.0f);
+            updatedRotation.eulerAngles += GetRandomVector3(-30.0f, 30.0f);
+            updatedScale += GetRandomVector3(-2.0f, 2.0f);
+            m_AuthoritativeTransform.SetState(updatedPosition, updatedRotation, updatedScale, !interpolate);
+            // Advance to next frame
+            TimeTravel(0.001f, 1);
+
+            TimeTravelAdvanceTick();
+
+            success = WaitForConditionOrTimeOutWithTimeTravel(() => PositionsMatch() && RotationsMatch() && ScaleValuesMatch());
+            Assert.True(success, $"[Timed-Out] Authoritative transform != Non-Authoritative transform!");
+            Assert.True(Approximately(updatedPosition, m_NonAuthoritativeTransform.transform.position), $"NonAuthority position {m_NonAuthoritativeTransform.transform.position} does not equal the calculated position {updatedPosition}!");
+            Assert.True(Approximately(updatedRotation.eulerAngles, m_NonAuthoritativeTransform.transform.rotation.eulerAngles), $"NonAuthority rotation {m_NonAuthoritativeTransform.transform.rotation.eulerAngles} does not equal the calculated rotation {updatedRotation.eulerAngles}!");
+            Assert.True(Approximately(updatedScale, m_NonAuthoritativeTransform.transform.localScale), $"NonAuthority scale {m_NonAuthoritativeTransform.transform.localScale} does not equal the calculated scale {updatedScale}!");
+        }
+
+        /// <summary>
+        /// This test validates the <see cref="NetworkTransform.SetState(Vector3?, Quaternion?, Vector3?, bool)"/> method
+        /// usage for the non-authoritative side.  It will either be the owner or the server making/requesting state changes.
+        /// This validates that:
+        /// - The owner authoritative mode can still be controlled by the server (i.e. owner authoritative with server authority override capabilities)
+        /// - The server authoritative mode can still be directed by the client owner.
+        /// </summary>
+        /// <remarks>
+        /// This also tests that the original server authoritative model with client-owner driven NetworkTransforms is preserved.
+        /// </remarks>
+        [Test]
+        public void NonAuthorityOwnerSettingStateTest([Values] Interpolation interpolation)
+        {
+            var interpolate = interpolation != Interpolation.EnableInterpolate;
+            m_AuthoritativeTransform.Interpolate = interpolate;
+            m_NonAuthoritativeTransform.Interpolate = interpolate;
+            m_NonAuthoritativeTransform.RotAngleThreshold = m_AuthoritativeTransform.RotAngleThreshold = 0.1f;
+
+            // Test one parameter at a time first
+            var newPosition = new Vector3(125f, 35f, 65f);
+            var newRotation = Quaternion.Euler(1, 2, 3);
+            var newScale = new Vector3(2.0f, 2.0f, 2.0f);
+            m_NonAuthoritativeTransform.SetState(newPosition, null, null, interpolate);
+            var success = WaitForConditionOrTimeOutWithTimeTravel(() => PositionsMatchesValue(newPosition));
+            Assert.True(success, $"Timed out waiting for non-authoritative position state request to be applied!");
+            Assert.True(Approximately(newPosition, m_AuthoritativeTransform.transform.position), "Authoritative position does not match!");
+            Assert.True(Approximately(newPosition, m_NonAuthoritativeTransform.transform.position), "Non-Authoritative position does not match!");
+
+            m_NonAuthoritativeTransform.SetState(null, newRotation, null, interpolate);
+            success = WaitForConditionOrTimeOutWithTimeTravel(() => RotationMatchesValue(newRotation.eulerAngles));
+            Assert.True(success, $"Timed out waiting for non-authoritative rotation state request to be applied!");
+            Assert.True(Approximately(newRotation.eulerAngles, m_AuthoritativeTransform.transform.rotation.eulerAngles), "Authoritative rotation does not match!");
+            Assert.True(Approximately(newRotation.eulerAngles, m_NonAuthoritativeTransform.transform.rotation.eulerAngles), "Non-Authoritative rotation does not match!");
+
+            m_NonAuthoritativeTransform.SetState(null, null, newScale, interpolate);
+            success = WaitForConditionOrTimeOutWithTimeTravel(() => ScaleMatchesValue(newScale));
+            Assert.True(success, $"Timed out waiting for non-authoritative scale state request to be applied!");
+            Assert.True(Approximately(newScale, m_AuthoritativeTransform.transform.localScale), "Authoritative scale does not match!");
+            Assert.True(Approximately(newScale, m_NonAuthoritativeTransform.transform.localScale), "Non-Authoritative scale does not match!");
+
+            // Test all parameters at once
+            newPosition = new Vector3(55f, 95f, -25f);
+            newRotation = Quaternion.Euler(20, 5, 322);
+            newScale = new Vector3(0.5f, 0.5f, 0.5f);
+
+            m_NonAuthoritativeTransform.SetState(newPosition, newRotation, newScale, interpolate);
+            success = WaitForConditionOrTimeOutWithTimeTravel(() => PositionRotationScaleMatches(newPosition, newRotation.eulerAngles, newScale));
+            Assert.True(success, $"Timed out waiting for non-authoritative position, rotation, and scale state request to be applied!");
+            Assert.True(Approximately(newPosition, m_AuthoritativeTransform.transform.position), "Authoritative position does not match!");
+            Assert.True(Approximately(newPosition, m_NonAuthoritativeTransform.transform.position), "Non-Authoritative position does not match!");
+            Assert.True(Approximately(newRotation.eulerAngles, m_AuthoritativeTransform.transform.rotation.eulerAngles), "Authoritative rotation does not match!");
+            Assert.True(Approximately(newRotation.eulerAngles, m_NonAuthoritativeTransform.transform.rotation.eulerAngles), "Non-Authoritative rotation does not match!");
+            Assert.True(Approximately(newScale, m_AuthoritativeTransform.transform.localScale), "Authoritative scale does not match!");
+            Assert.True(Approximately(newScale, m_NonAuthoritativeTransform.transform.localScale), "Non-Authoritative scale does not match!");
+        }
+    }
+}

Tests/Runtime/NetworkTransform/NetworkTransformGeneral.cs.meta

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

Tests/Runtime/NetworkTransform/NetworkTransformPacketLossTests.cs

@@ -0,0 +1,485 @@
+// TODO: Rewrite test to use the tools package. Debug simulator not available in UTP 2.X.
+#if !UTP_TRANSPORT_2_0_ABOVE
+using System.Collections;
+using NUnit.Framework;
+using Unity.Netcode.Components;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    /// <summary>
+    /// Integration tests for NetworkTransform that will test both
+    /// server and host operating modes and will test both authoritative
+    /// models for each operating mode when packet loss and latency is
+    /// present.
+    /// </summary>
+    [TestFixture(HostOrServer.Host, Authority.ServerAuthority, RotationCompression.None, Rotation.Euler, Precision.Full)]
+    [TestFixture(HostOrServer.Host, Authority.ServerAuthority, RotationCompression.None, Rotation.Euler, Precision.Half)]
+    [TestFixture(HostOrServer.Host, Authority.ServerAuthority, RotationCompression.None, Rotation.Quaternion, Precision.Full)]
+    [TestFixture(HostOrServer.Host, Authority.ServerAuthority, RotationCompression.None, Rotation.Quaternion, Precision.Half)]
+    [TestFixture(HostOrServer.Host, Authority.ServerAuthority, RotationCompression.QuaternionCompress, Rotation.Quaternion, Precision.Full)]
+    [TestFixture(HostOrServer.Host, Authority.ServerAuthority, RotationCompression.QuaternionCompress, Rotation.Quaternion, Precision.Half)]
+    public class NetworkTransformPacketLossTests : NetworkTransformBase
+    {
+        private const int k_Latency = 50;
+        private const int k_PacketLoss = 2;
+
+        private Vector3 m_RandomPosition;
+        private Vector3 m_TeleportOffset = new Vector3(-1024f, 0f, 0f);
+        private bool m_Teleported;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="testWithHost">Determines if we are running as a server or host</param>
+        /// <param name="authority">Determines if we are using server or owner authority</param>
+        public NetworkTransformPacketLossTests(HostOrServer testWithHost, Authority authority, RotationCompression rotationCompression, Rotation rotation, Precision precision) :
+            base(testWithHost, authority, rotationCompression, rotation, precision)
+        { }
+
+        protected override void OnServerAndClientsCreated()
+        {
+            base.OnServerAndClientsCreated();
+
+            var unityTransport = m_ServerNetworkManager.NetworkConfig.NetworkTransport as Transports.UTP.UnityTransport;
+            unityTransport.SetDebugSimulatorParameters(k_Latency, 0, k_PacketLoss);
+        }
+
+        /// <summary>
+        /// Handles validating all children of the test objects have matching local and global space vaues.
+        /// </summary>
+        private IEnumerator AllChildrenLocalTransformValuesMatch(bool useSubChild, ChildrenTransformCheckType checkType)
+        {
+            // We don't assert on timeout here because we want to log this information during PostAllChildrenLocalTransformValuesMatch
+            yield return WaitForConditionOrTimeOut(() => AllInstancesKeptLocalTransformValues(useSubChild));
+            var success = true;
+            m_InfoMessage.AppendLine($"[{checkType}][{useSubChild}] Timed out waiting for all children to have the correct local space values:\n");
+            if (s_GlobalTimeoutHelper.TimedOut)
+            {
+                var waitForMs = new WaitForSeconds(0.001f);
+                // If we timed out, then wait for a full range of ticks to assure all data has been synchronized before declaring this a failed test.
+                for (int j = 0; j < m_ServerNetworkManager.NetworkConfig.TickRate; j++)
+                {
+                    var instances = useSubChild ? ChildObjectComponent.SubInstances : ChildObjectComponent.Instances;
+                    success = PostAllChildrenLocalTransformValuesMatch(useSubChild);
+                    yield return waitForMs;
+                }
+            }
+
+            if (!success)
+            {
+                Assert.True(success, m_InfoMessage.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Validates that transform values remain the same when a NetworkTransform is
+        /// parented under another NetworkTransform under all of the possible axial conditions
+        /// as well as when the parent has a varying scale.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator ParentedNetworkTransformTest([Values] Interpolation interpolation, [Values] bool worldPositionStays, [Values(0.5f, 1.0f, 5.0f)] float scale)
+        {
+            ChildObjectComponent.EnableChildLog = m_EnableVerboseDebug;
+            if (m_EnableVerboseDebug)
+            {
+                ChildObjectComponent.TestCount++;
+            }
+            // Get the NetworkManager that will have authority in order to spawn with the correct authority
+            var isServerAuthority = m_Authority == Authority.ServerAuthority;
+            var authorityNetworkManager = m_ServerNetworkManager;
+            if (!isServerAuthority)
+            {
+                authorityNetworkManager = m_ClientNetworkManagers[0];
+            }
+
+            // Spawn a parent and children
+            ChildObjectComponent.HasSubChild = true;
+            var serverSideParent = SpawnObject(m_ParentObject.gameObject, authorityNetworkManager).GetComponent<NetworkObject>();
+            var serverSideChild = SpawnObject(m_ChildObject.gameObject, authorityNetworkManager).GetComponent<NetworkObject>();
+            var serverSideSubChild = SpawnObject(m_SubChildObject.gameObject, authorityNetworkManager).GetComponent<NetworkObject>();
+
+            // Assure all of the child object instances are spawned before proceeding to parenting
+            yield return WaitForConditionOrTimeOut(AllChildObjectInstancesAreSpawned);
+            AssertOnTimeout("Timed out waiting for all child instances to be spawned!");
+
+            // Get the authority parent and child instances
+            m_AuthorityParentObject = NetworkTransformTestComponent.AuthorityInstance.NetworkObject;
+            m_AuthorityChildObject = ChildObjectComponent.AuthorityInstance.NetworkObject;
+            m_AuthoritySubChildObject = ChildObjectComponent.AuthoritySubInstance.NetworkObject;
+
+            // The child NetworkTransform will use world space when world position stays and
+            // local space when world position does not stay when parenting.
+            ChildObjectComponent.AuthorityInstance.InLocalSpace = !worldPositionStays;
+            ChildObjectComponent.AuthorityInstance.UseHalfFloatPrecision = m_Precision == Precision.Half;
+            ChildObjectComponent.AuthorityInstance.UseQuaternionSynchronization = m_Rotation == Rotation.Quaternion;
+            ChildObjectComponent.AuthorityInstance.UseQuaternionCompression = m_RotationCompression == RotationCompression.QuaternionCompress;
+
+            ChildObjectComponent.AuthoritySubInstance.InLocalSpace = !worldPositionStays;
+            ChildObjectComponent.AuthoritySubInstance.UseHalfFloatPrecision = m_Precision == Precision.Half;
+            ChildObjectComponent.AuthoritySubInstance.UseQuaternionSynchronization = m_Rotation == Rotation.Quaternion;
+            ChildObjectComponent.AuthoritySubInstance.UseQuaternionCompression = m_RotationCompression == RotationCompression.QuaternionCompress;
+
+            // Set whether we are interpolating or not
+            m_AuthorityParentNetworkTransform = m_AuthorityParentObject.GetComponent<NetworkTransformTestComponent>();
+            m_AuthorityParentNetworkTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
+            m_AuthorityChildNetworkTransform = m_AuthorityChildObject.GetComponent<ChildObjectComponent>();
+            m_AuthorityChildNetworkTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
+            m_AuthoritySubChildNetworkTransform = m_AuthoritySubChildObject.GetComponent<ChildObjectComponent>();
+            m_AuthoritySubChildNetworkTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
+
+
+            // Apply a scale to the parent object to make sure the scale on the child is properly updated on
+            // non-authority instances.
+            var halfScale = scale * 0.5f;
+            m_AuthorityParentObject.transform.localScale = GetRandomVector3(scale - halfScale, scale + halfScale);
+            m_AuthorityChildObject.transform.localScale = GetRandomVector3(scale - halfScale, scale + halfScale);
+            m_AuthoritySubChildObject.transform.localScale = GetRandomVector3(scale - halfScale, scale + halfScale);
+
+            // Allow one tick for authority to update these changes
+
+            yield return WaitForConditionOrTimeOut(PositionRotationScaleMatches);
+
+            AssertOnTimeout("All transform values did not match prior to parenting!");
+
+            // Parent the child under the parent with the current world position stays setting
+            Assert.True(serverSideChild.TrySetParent(serverSideParent.transform, worldPositionStays), "[Server-Side Child] Failed to set child's parent!");
+
+            // Parent the sub-child under the child with the current world position stays setting
+            Assert.True(serverSideSubChild.TrySetParent(serverSideChild.transform, worldPositionStays), "[Server-Side SubChild] Failed to set sub-child's parent!");
+
+            // This waits for all child instances to be parented
+            yield return WaitForConditionOrTimeOut(AllChildObjectInstancesHaveChild);
+            AssertOnTimeout("Timed out waiting for all instances to have parented a child!");
+            var latencyWait = new WaitForSeconds(k_Latency * 0.003f);
+            // Wait for at least 3x designated latency period
+            yield return latencyWait;
+
+            // This validates each child instance has preserved their local space values
+            yield return AllChildrenLocalTransformValuesMatch(false, ChildrenTransformCheckType.Connected_Clients);
+
+            // This validates each sub-child instance has preserved their local space values
+            yield return AllChildrenLocalTransformValuesMatch(true, ChildrenTransformCheckType.Connected_Clients);
+
+            // Verify that a late joining client will synchronize to the parented NetworkObjects properly
+            yield return CreateAndStartNewClient();
+
+            // Assure all of the child object instances are spawned (basically for the newly connected client)
+            yield return WaitForConditionOrTimeOut(AllChildObjectInstancesAreSpawned);
+            AssertOnTimeout("Timed out waiting for all child instances to be spawned!");
+
+            // This waits for all child instances to be parented
+            yield return WaitForConditionOrTimeOut(AllChildObjectInstancesHaveChild);
+            AssertOnTimeout("Timed out waiting for all instances to have parented a child!");
+
+            // Wait for at least 3x designated latency period
+            yield return latencyWait;
+
+            // This validates each child instance has preserved their local space values
+            yield return AllChildrenLocalTransformValuesMatch(false, ChildrenTransformCheckType.Late_Join_Client);
+
+            // This validates each sub-child instance has preserved their local space values
+            yield return AllChildrenLocalTransformValuesMatch(true, ChildrenTransformCheckType.Late_Join_Client);
+        }
+
+        /// <summary>
+        /// This validates that multiple changes can occur within the same tick or over
+        /// several ticks while still keeping non-authoritative instances synchronized.
+        /// </summary>
+        /// <remarks>
+        /// When testing < 3 axis: Interpolation is disabled and only 3 delta updates are applied per unique test
+        /// When testing 3 axis: Interpolation is enabled, sometimes an axis is intentionally excluded during a
+        /// delta update, and it runs through 8 delta updates per unique test.
+        /// </remarks>
+        [UnityTest]
+        public IEnumerator NetworkTransformMultipleChangesOverTime([Values] TransformSpace testLocalTransform, [Values] Axis axis)
+        {
+            yield return s_DefaultWaitForTick;
+            // Just test for OverrideState.Update (they are already being tested for functionality in normal NetworkTransformTests)
+            var overideState = OverrideState.Update;
+            var tickRelativeTime = new WaitForSeconds(1.0f / m_ServerNetworkManager.NetworkConfig.TickRate);
+            m_AuthoritativeTransform.InLocalSpace = testLocalTransform == TransformSpace.Local;
+            bool axisX = axis == Axis.X || axis == Axis.XY || axis == Axis.XZ || axis == Axis.XYZ;
+            bool axisY = axis == Axis.Y || axis == Axis.XY || axis == Axis.YZ || axis == Axis.XYZ;
+            bool axisZ = axis == Axis.Z || axis == Axis.XZ || axis == Axis.YZ || axis == Axis.XYZ;
+
+            var axisCount = axisX ? 1 : 0;
+            axisCount += axisY ? 1 : 0;
+            axisCount += axisZ ? 1 : 0;
+
+            m_AuthoritativeTransform.StatePushed = false;
+            // Enable interpolation when all 3 axis are selected to make sure we are synchronizing properly
+            // when interpolation is enabled.
+            m_AuthoritativeTransform.Interpolate = axisCount == 3 ? true : false;
+
+            m_CurrentAxis = axis;
+
+            // Authority dictates what is synchronized and what the precision is going to be
+            // so we only need to set this on the authoritative side.
+            m_AuthoritativeTransform.UseHalfFloatPrecision = m_Precision == Precision.Half;
+            m_AuthoritativeTransform.UseQuaternionSynchronization = m_Rotation == Rotation.Quaternion;
+            m_AuthoritativeTransform.UseQuaternionCompression = m_RotationCompression == RotationCompression.QuaternionCompress;
+
+            m_AuthoritativeTransform.SyncPositionX = axisX;
+            m_AuthoritativeTransform.SyncPositionY = axisY;
+            m_AuthoritativeTransform.SyncPositionZ = axisZ;
+
+            if (!m_AuthoritativeTransform.UseQuaternionSynchronization)
+            {
+                m_AuthoritativeTransform.SyncRotAngleX = axisX;
+                m_AuthoritativeTransform.SyncRotAngleY = axisY;
+                m_AuthoritativeTransform.SyncRotAngleZ = axisZ;
+            }
+            else
+            {
+                // This is not required for usage (setting the value should not matter when quaternion synchronization is enabled)
+                // but is required for this test so we don't get a failure on an axis that is marked to not be synchronized when
+                // validating the authority's values on non-authority instances.
+                m_AuthoritativeTransform.SyncRotAngleX = true;
+                m_AuthoritativeTransform.SyncRotAngleY = true;
+                m_AuthoritativeTransform.SyncRotAngleZ = true;
+            }
+
+            m_AuthoritativeTransform.SyncScaleX = axisX;
+            m_AuthoritativeTransform.SyncScaleY = axisY;
+            m_AuthoritativeTransform.SyncScaleZ = axisZ;
+
+            var positionStart = GetRandomVector3(0.25f, 1.75f);
+            var rotationStart = GetRandomVector3(1f, 15f);
+            var scaleStart = GetRandomVector3(0.25f, 2.0f);
+            var position = positionStart;
+            var rotation = rotationStart;
+            var scale = scaleStart;
+            var success = false;
+
+
+            // Wait for the deltas to be pushed
+            yield return WaitForConditionOrTimeOut(() => m_AuthoritativeTransform.StatePushed);
+
+            // Just in case we drop the first few state updates
+            if (s_GlobalTimeoutHelper.TimedOut)
+            {
+                // Set the local state to not reflect the authority state's local space settings
+                // to trigger the state update (it would eventually get there, but this is an integration test)
+                var state = m_AuthoritativeTransform.LocalAuthoritativeNetworkState;
+                state.InLocalSpace = !m_AuthoritativeTransform.InLocalSpace;
+                m_AuthoritativeTransform.LocalAuthoritativeNetworkState = state;
+                // Wait for the deltas to be pushed
+                yield return WaitForConditionOrTimeOut(() => m_AuthoritativeTransform.StatePushed);
+            }
+            AssertOnTimeout("State was never pushed!");
+
+            // Allow the precision settings to propagate first as changing precision
+            // causes a teleport event to occur
+            yield return s_DefaultWaitForTick;
+            yield return s_DefaultWaitForTick;
+            yield return s_DefaultWaitForTick;
+            yield return s_DefaultWaitForTick;
+            yield return s_DefaultWaitForTick;
+            var iterations = axisCount == 3 ? k_PositionRotationScaleIterations3Axis : k_PositionRotationScaleIterations;
+
+            // Move and rotate within the same tick, validate the non-authoritative instance updates
+            // to each set of changes.  Repeat several times.
+            for (int i = 0; i < iterations; i++)
+            {
+                // Always reset this per delta update pass
+                m_AxisExcluded = false;
+                var deltaPositionDelta = GetRandomVector3(-1.5f, 1.5f);
+                var deltaRotationDelta = GetRandomVector3(-3.5f, 3.5f);
+                var deltaScaleDelta = GetRandomVector3(-0.5f, 0.5f);
+
+                m_NonAuthoritativeTransform.StateUpdated = false;
+                m_AuthoritativeTransform.StatePushed = false;
+
+                // With two or more axis, excluding one of them while chaging another will validate that
+                // full precision updates are maintaining their target state value(s) to interpolate towards
+                if (axisCount == 3)
+                {
+                    position += RandomlyExcludeAxis(deltaPositionDelta);
+                    rotation += RandomlyExcludeAxis(deltaRotationDelta);
+                    scale += RandomlyExcludeAxis(deltaScaleDelta);
+                }
+                else
+                {
+                    position += deltaPositionDelta;
+                    rotation += deltaRotationDelta;
+                    scale += deltaScaleDelta;
+                }
+
+                // Apply delta between ticks
+                MoveRotateAndScaleAuthority(position, rotation, scale, overideState);
+
+                // Wait for the deltas to be pushed (unlike the original test, we don't wait for state to be updated as that could be dropped here)
+                yield return WaitForConditionOrTimeOut(() => m_AuthoritativeTransform.StatePushed);
+                AssertOnTimeout($"[Non-Interpolate {i}] Timed out waiting for state to be pushed ({m_AuthoritativeTransform.StatePushed})!");
+
+                // For 3 axis, we will skip validating that the non-authority interpolates to its target point at least once.
+                // This will validate that non-authoritative updates are maintaining their target state axis values if only 2
+                // of the axis are being updated to assure interpolation maintains the targeted axial value per axis.
+                // For 2 and 1 axis tests we always validate per delta update
+                if (m_AxisExcluded || axisCount < 3)
+                {
+                    // Wait for deltas to synchronize on non-authoritative side
+                    yield return WaitForConditionOrTimeOut(PositionRotationScaleMatches);
+                    // Provide additional debug info about what failed (if it fails)
+                    if (s_GlobalTimeoutHelper.TimedOut)
+                    {
+                        Debug.Log("[Synch Issue Start - 1]");
+                        // If we timed out, then wait for a full range of ticks (plus 1) to assure it sent synchronization data.
+                        for (int j = 0; j < m_ServerNetworkManager.NetworkConfig.TickRate * 2; j++)
+                        {
+                            success = PositionRotationScaleMatches();
+                            if (success)
+                            {
+                                // If we matched, then something was dropped and recovered when synchronized
+                                break;
+                            }
+                            yield return s_DefaultWaitForTick;
+                        }
+
+                        // Only if we still didn't match
+                        if (!success)
+                        {
+                            m_EnableVerboseDebug = true;
+                            success = PositionRotationScaleMatches();
+                            m_EnableVerboseDebug = false;
+                            Debug.Log("[Synch Issue END - 1]");
+                            AssertOnTimeout($"[Non-Interpolate {i}] Timed out waiting for non-authority to match authority's position or rotation");
+                        }
+                    }
+                }
+            }
+
+            if (axisCount == 3)
+            {
+                // As a final test, wait for deltas to synchronize on non-authoritative side to assure it interpolates to the correct values
+                yield return WaitForConditionOrTimeOut(PositionRotationScaleMatches);
+                // Provide additional debug info about what failed (if it fails)
+                if (s_GlobalTimeoutHelper.TimedOut)
+                {
+                    Debug.Log("[Synch Issue Start - 2]");
+                    // If we timed out, then wait for a full range of ticks (plus 1) to assure it sent synchronization data.
+                    for (int j = 0; j < m_ServerNetworkManager.NetworkConfig.TickRate * 2; j++)
+                    {
+                        success = PositionRotationScaleMatches();
+                        if (success)
+                        {
+                            // If we matched, then something was dropped and recovered when synchronized
+                            break;
+                        }
+                        yield return s_DefaultWaitForTick;
+                    }
+
+                    // Only if we still didn't match
+                    if (!success)
+                    {
+                        m_EnableVerboseDebug = true;
+                        PositionRotationScaleMatches();
+                        m_EnableVerboseDebug = false;
+                        Debug.Log("[Synch Issue END - 2]");
+                        AssertOnTimeout("Timed out waiting for non-authority to match authority's position or rotation");
+
+                    }
+                }
+
+            }
+        }
+
+        /// <summary>
+        /// Tests changing all axial values one at a time with packet loss
+        /// These tests are performed:
+        /// - While in local space and world space
+        /// - While interpolation is enabled and disabled
+        /// </summary>
+        [UnityTest]
+        public IEnumerator TestAuthoritativeTransformChangeOneAtATime([Values] TransformSpace testLocalTransform, [Values] Interpolation interpolation)
+        {
+            // Just test for OverrideState.Update (they are already being tested for functionality in normal NetworkTransformTests)
+            m_AuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
+            m_AuthoritativeTransform.InLocalSpace = testLocalTransform == TransformSpace.Local;
+            m_AuthoritativeTransform.UseQuaternionCompression = m_RotationCompression == RotationCompression.QuaternionCompress;
+            m_AuthoritativeTransform.UseHalfFloatPrecision = m_Precision == Precision.Half;
+            m_AuthoritativeTransform.UseQuaternionSynchronization = m_Rotation == Rotation.Quaternion;
+            m_NonAuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
+
+
+            // test position
+            var authPlayerTransform = m_AuthoritativeTransform.transform;
+
+            Assert.AreEqual(Vector3.zero, m_NonAuthoritativeTransform.transform.position, "server side pos should be zero at first"); // sanity check
+
+            m_AuthoritativeTransform.transform.position = GetRandomVector3(2f, 30f);
+
+            yield return WaitForConditionOrTimeOut(() => PositionsMatch());
+            AssertOnTimeout($"Timed out waiting for positions to match {m_AuthoritativeTransform.transform.position} | {m_NonAuthoritativeTransform.transform.position}");
+
+            // test rotation
+            Assert.AreEqual(Quaternion.identity, m_NonAuthoritativeTransform.transform.rotation, "wrong initial value for rotation"); // sanity check
+
+            m_AuthoritativeTransform.transform.rotation = Quaternion.Euler(GetRandomVector3(5, 60)); // using euler angles instead of quaternions directly to really see issues users might encounter
+
+            // Make sure the values match
+            yield return WaitForConditionOrTimeOut(() => RotationsMatch());
+            AssertOnTimeout($"Timed out waiting for rotations to match");
+
+            m_AuthoritativeTransform.StatePushed = false;
+            m_AuthoritativeTransform.transform.localScale = GetRandomVector3(1, 6);
+
+            // Make sure the scale values match
+            yield return WaitForConditionOrTimeOut(() => ScaleValuesMatch());
+            AssertOnTimeout($"Timed out waiting for scale values to match");
+        }
+
+        [UnityTest]
+        public IEnumerator TestSameFrameDeltaStateAndTeleport([Values] TransformSpace testLocalTransform, [Values] Interpolation interpolation)
+        {
+            m_AuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
+
+            m_NonAuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
+
+            m_AuthoritativeTransform.InLocalSpace = testLocalTransform == TransformSpace.Local;
+
+            // test position
+            var authPlayerTransform = m_AuthoritativeTransform.transform;
+
+            Assert.AreEqual(Vector3.zero, m_NonAuthoritativeTransform.transform.position, "server side pos should be zero at first"); // sanity check
+
+            m_AuthoritativeTransform.AuthorityPushedTransformState += OnAuthorityPushedTransformState;
+            m_RandomPosition = GetRandomVector3(2f, 30f);
+            m_AuthoritativeTransform.transform.position = m_RandomPosition;
+            m_Teleported = false;
+            yield return WaitForConditionOrTimeOut(() => m_Teleported);
+            AssertOnTimeout($"Timed out waiting for random position to be pushed!");
+
+            yield return WaitForConditionOrTimeOut(() => PositionsMatch());
+            AssertOnTimeout($"Timed out waiting for positions to match {m_AuthoritativeTransform.transform.position} | {m_NonAuthoritativeTransform.transform.position}");
+
+            var authPosition = m_AuthoritativeTransform.GetSpaceRelativePosition();
+            var nonAuthPosition = m_NonAuthoritativeTransform.GetSpaceRelativePosition();
+
+            var finalPosition = m_TeleportOffset + m_RandomPosition;
+            Assert.True(Approximately(authPosition, finalPosition), $"Authority did not set its position ({authPosition}) to the teleport position ({finalPosition})!");
+            Assert.True(Approximately(nonAuthPosition, finalPosition), $"NonAuthority did not set its position ({nonAuthPosition}) to the teleport position ({finalPosition})!");
+        }
+
+        /// <summary>
+        /// For the TestSameFrameDeltaStateAndTeleport test, we want to teleport on the same frame that we had a delta state update when
+        /// using unreliable delta state updates (i.e. we want the unreliable packet to be sent first and then the teleport to be sent on
+        /// the next tick. Store off both states when invoked
+        /// </summary>
+        /// <param name="networkTransformState"></param>
+        private void OnAuthorityPushedTransformState(ref NetworkTransform.NetworkTransformState networkTransformState)
+        {
+            // Match the first position update
+            if (Approximately(m_RandomPosition, networkTransformState.GetPosition()))
+            {
+                // Teleport to the m_RandomPosition plus the 
+                m_AuthoritativeTransform.SetState(m_TeleportOffset + m_RandomPosition, null, null, false);
+                m_AuthoritativeTransform.AuthorityPushedTransformState -= OnAuthorityPushedTransformState;
+                m_Teleported = true;
+            }
+        }
+    }
+}
+#endif

Tests/Runtime/NetworkTransform/NetworkTransformPacketLossTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e0f584e8eb891d5459373e96e54fe821
+timeCreated: 1620872927

Tests/Runtime/NetworkTransform/NetworkTransformStateTests.cs

@@ -230,6 +230,11 @@ namespace Unity.Netcode.RuntimeTests
             var gameObject = new GameObject($"Test-{nameof(NetworkTransformStateTests)}.{nameof(TestSyncAxes)}");
             var networkObject = gameObject.AddComponent<NetworkObject>();
             var networkTransform = gameObject.AddComponent<NetworkTransform>();
+
+            var manager = new GameObject($"Test-{nameof(NetworkManager)}.{nameof(TestSyncAxes)}");
+            var networkManager = manager.AddComponent<NetworkManager>();
+            networkObject.NetworkManagerOwner = networkManager;
+
             networkTransform.enabled = false; // do not tick `FixedUpdate()` or `Update()`
 
             var initialPosition = Vector3.zero;
@@ -269,6 +274,7 @@ namespace Unity.Netcode.RuntimeTests
 
                 if (syncPosX || syncPosY || syncPosZ || syncRotX || syncRotY || syncRotZ || syncScaX || syncScaY || syncScaZ)
                 {
+                    Assert.NotNull(networkTransform.NetworkManager, "NetworkManager is NULL!");
                     Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
                 }
             }
@@ -714,6 +720,7 @@ namespace Unity.Netcode.RuntimeTests
             }
 
             Object.DestroyImmediate(gameObject);
+            Object.DestroyImmediate(manager);
         }
 
 

Tests/Runtime/NetworkVariableTests.cs

@@ -2769,4 +2769,71 @@ namespace Unity.Netcode.RuntimeTests
             Assert.IsFalse(s_GlobalTimeoutHelper.TimedOut, nameof(CheckTestObjectComponentValuesOnAll));
         }
     }
+
+    public class NetvarDespawnShutdown : NetworkBehaviour
+    {
+        private NetworkVariable<int> m_IntNetworkVariable = new NetworkVariable<int>();
+        private NetworkList<int> m_IntList;
+
+        private void Awake()
+        {
+            m_IntList = new NetworkList<int>();
+        }
+
+        public override void OnNetworkDespawn()
+        {
+            if (IsServer)
+            {
+                m_IntNetworkVariable.Value = 5;
+                for (int i = 0; i < 10; i++)
+                {
+                    m_IntList.Add(i);
+                }
+            }
+            base.OnNetworkDespawn();
+        }
+    }
+
+    /// <summary>
+    /// Validates that setting values for NetworkVariable or NetworkList during the
+    /// OnNetworkDespawn method will not cause an exception to occur.
+    /// </summary>
+    public class NetworkVariableModifyOnNetworkDespawn : NetcodeIntegrationTest
+    {
+        protected override int NumberOfClients => 1;
+
+        private GameObject m_TestPrefab;
+
+        protected override void OnServerAndClientsCreated()
+        {
+            m_TestPrefab = CreateNetworkObjectPrefab("NetVarDespawn");
+            m_TestPrefab.AddComponent<NetvarDespawnShutdown>();
+            base.OnServerAndClientsCreated();
+        }
+
+        private bool OnClientSpawnedTestPrefab(ulong networkObjectId)
+        {
+            var clientId = m_ClientNetworkManagers[0].LocalClientId;
+            if (!s_GlobalNetworkObjects.ContainsKey(clientId))
+            {
+                return false;
+            }
+
+            if (!s_GlobalNetworkObjects[clientId].ContainsKey(networkObjectId))
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        [UnityTest]
+        public IEnumerator ModifyNetworkVariableOrListOnNetworkDespawn()
+        {
+            var instance = SpawnObject(m_TestPrefab, m_ServerNetworkManager);
+            yield return WaitForConditionOrTimeOut(() => OnClientSpawnedTestPrefab(instance.GetComponent<NetworkObject>().NetworkObjectId));
+            m_ServerNetworkManager.Shutdown();
+            // As long as no excetptions occur, the test passes.
+        }
+    }
 }

Tests/Runtime/PeerDisconnectCallbackTests.cs

@@ -0,0 +1,185 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Unity.Netcode.TestHelpers.Runtime;
+using UnityEngine.TestTools;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    /// <summary>
+    /// Validates the client disconnection process.
+    /// This assures that:
+    /// - When a client disconnects from the server that the server:
+    /// -- Detects the client disconnected.
+    /// -- Cleans up the transport to NGO client (and vice versa) mappings.
+    /// - When a server disconnects a client that:
+    /// -- The client detects this disconnection.
+    /// -- The server cleans up the transport to NGO client (and vice versa) mappings.
+    /// - When <see cref="DisconnectTests.OwnerPersistence.DestroyWithOwner"/> the server-side player object is destroyed
+    /// - When <see cref="DisconnectTests.OwnerPersistence.DontDestroyWithOwner"/> the server-side player object ownership is transferred back to the server
+    /// </summary>
+    [TestFixture(HostOrServer.Server)]
+    [TestFixture(HostOrServer.Host)]
+    public class PeerDisconnectCallbackTests : NetcodeIntegrationTest
+    {
+
+        public enum ClientDisconnectType
+        {
+            ServerDisconnectsClient,
+            ClientDisconnectsFromServer
+        }
+
+        protected override int NumberOfClients => 3;
+
+        private int m_ClientDisconnectCount;
+        private int m_PeerDisconnectCount;
+
+
+        public PeerDisconnectCallbackTests(HostOrServer hostOrServer)
+            : base(hostOrServer)
+        {
+        }
+
+        protected override void OnServerAndClientsCreated()
+        {
+            // Adjusting client and server timeout periods to reduce test time
+            // Get the tick frequency in milliseconds and triple it for the heartbeat timeout
+            var heartBeatTimeout = (int)(300 * (1.0f / m_ServerNetworkManager.NetworkConfig.TickRate));
+            var unityTransport = m_ServerNetworkManager.NetworkConfig.NetworkTransport as Transports.UTP.UnityTransport;
+            if (unityTransport != null)
+            {
+                unityTransport.HeartbeatTimeoutMS = heartBeatTimeout;
+            }
+
+            unityTransport = m_ClientNetworkManagers[0].NetworkConfig.NetworkTransport as Transports.UTP.UnityTransport;
+            if (unityTransport != null)
+            {
+                unityTransport.HeartbeatTimeoutMS = heartBeatTimeout;
+            }
+
+            base.OnServerAndClientsCreated();
+        }
+
+        protected override IEnumerator OnSetup()
+        {
+            m_ClientDisconnectCount = 0;
+            m_PeerDisconnectCount = 0;
+            return base.OnSetup();
+        }
+
+        private void OnConnectionEventCallback(NetworkManager networkManager, ConnectionEventData data)
+        {
+            switch (data.EventType)
+            {
+                case ConnectionEvent.ClientDisconnected:
+                    Assert.IsFalse(data.PeerClientIds.IsCreated);
+                    ++m_ClientDisconnectCount;
+                    break;
+                case ConnectionEvent.PeerDisconnected:
+                    Assert.IsFalse(data.PeerClientIds.IsCreated);
+                    ++m_PeerDisconnectCount;
+                    break;
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator TestPeerDisconnectCallback([Values] ClientDisconnectType clientDisconnectType, [Values(1ul, 2ul, 3ul)] ulong disconnectedClient)
+        {
+            foreach (var client in m_ClientNetworkManagers)
+            {
+                client.OnConnectionEvent += OnConnectionEventCallback;
+                if (m_UseHost)
+                {
+                    Assert.IsTrue(client.ConnectedClientsIds.Contains(0ul));
+                }
+                Assert.IsTrue(client.ConnectedClientsIds.Contains(1ul));
+                Assert.IsTrue(client.ConnectedClientsIds.Contains(2ul));
+                Assert.IsTrue(client.ConnectedClientsIds.Contains(3ul));
+                Assert.AreEqual(client.ServerIsHost, m_UseHost);
+            }
+            m_ServerNetworkManager.OnConnectionEvent += OnConnectionEventCallback;
+            if (m_UseHost)
+            {
+                Assert.IsTrue(m_ServerNetworkManager.ConnectedClientsIds.Contains(0ul));
+            }
+            Assert.IsTrue(m_ServerNetworkManager.ConnectedClientsIds.Contains(1ul));
+            Assert.IsTrue(m_ServerNetworkManager.ConnectedClientsIds.Contains(2ul));
+            Assert.IsTrue(m_ServerNetworkManager.ConnectedClientsIds.Contains(3ul));
+            Assert.AreEqual(m_ServerNetworkManager.ServerIsHost, m_UseHost);
+
+            // Set up a WaitForMessageReceived hook.
+            // In some cases the message will be received during StopOneClient, but it is not guaranteed
+            // So we start the listener before we call Stop so it will be noticed regardless of whether it happens
+            // during StopOneClient or whether we have to wait for it
+            var messageHookEntriesForSpawn = new List<MessageHookEntry>();
+            foreach (var clientNetworkManager in m_ClientNetworkManagers.Where(c => c.LocalClientId != disconnectedClient))
+            {
+                var messageHook = new MessageHookEntry(clientNetworkManager);
+                messageHook.AssignMessageType<ClientDisconnectedMessage>();
+                messageHookEntriesForSpawn.Add(messageHook);
+            }
+
+            // Used to determine if all clients received the CreateObjectMessage
+            var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
+
+            if (clientDisconnectType == ClientDisconnectType.ServerDisconnectsClient)
+            {
+                m_ServerNetworkManager.DisconnectClient(disconnectedClient);
+            }
+            else
+            {
+                yield return StopOneClient(m_ClientNetworkManagers[disconnectedClient - 1]);
+            }
+
+            yield return WaitForConditionOrTimeOut(hooks);
+            Assert.False(s_GlobalTimeoutHelper.TimedOut);
+
+            foreach (var client in m_ClientNetworkManagers)
+            {
+                if (!client.IsConnectedClient)
+                {
+                    Assert.IsEmpty(client.ConnectedClientsIds);
+                    continue;
+                }
+                if (m_UseHost)
+                {
+                    Assert.IsTrue(client.ConnectedClientsIds.Contains(0ul));
+                }
+
+                for (var i = 1ul; i < 3ul; ++i)
+                {
+                    if (i == disconnectedClient)
+                    {
+                        Assert.IsFalse(client.ConnectedClientsIds.Contains(i));
+                    }
+                    else
+                    {
+                        Assert.IsTrue(client.ConnectedClientsIds.Contains(i));
+                    }
+                }
+            }
+            if (m_UseHost)
+            {
+                Assert.IsTrue(m_ServerNetworkManager.ConnectedClientsIds.Contains(0ul));
+            }
+
+            for (var i = 1ul; i < 3ul; ++i)
+            {
+                if (i == disconnectedClient)
+                {
+                    Assert.IsFalse(m_ServerNetworkManager.ConnectedClientsIds.Contains(i));
+                }
+                else
+                {
+                    Assert.IsTrue(m_ServerNetworkManager.ConnectedClientsIds.Contains(i));
+                }
+            }
+
+            // If disconnected, the server and the client that disconnected will be notified
+            Assert.AreEqual(2, m_ClientDisconnectCount);
+            // Host receives peer disconnect, dedicated server does not
+            Assert.AreEqual(m_UseHost ? 3 : 2, m_PeerDisconnectCount);
+        }
+    }
+}

Tests/Runtime/PeerDisconnectCallbackTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 283ae7cc9a0641c8b49dacad79242287
+timeCreated: 1699978638

Tests/Runtime/RpcTests.cs

@@ -62,7 +62,6 @@ namespace Unity.Netcode.RuntimeTests
             }
 #endif
 
-
             [ClientRpc]
             public void MyClientRpc()
             {

Tests/Runtime/StopStartRuntimeTests.cs

@@ -1,7 +1,6 @@
 using System.Collections;
 using NUnit.Framework;
 using Unity.Netcode.TestHelpers.Runtime;
-using UnityEngine;
 using UnityEngine.TestTools;
 
 namespace Unity.Netcode.RuntimeTests
@@ -16,15 +15,19 @@ namespace Unity.Netcode.RuntimeTests
             base.OnOneTimeSetup();
         }
 
+
+        private bool m_ServerStopped;
         [UnityTest]
         public IEnumerator WhenShuttingDownAndRestarting_SDKRestartsSuccessfullyAndStaysRunning()
         {
             // shutdown the server
+            m_ServerNetworkManager.OnServerStopped += OnServerStopped;
             m_ServerNetworkManager.Shutdown();
 
-            // wait 1 frame because shutdowns are delayed
+            // wait until the OnServerStopped is invoked
-            var nextFrameNumber = Time.frameCount + 1;
+            m_ServerStopped = false;
-            yield return new WaitUntil(() => Time.frameCount >= nextFrameNumber);
+            yield return WaitForConditionOrTimeOut(() => m_ServerStopped);
+            AssertOnTimeout("Timed out waiting for the server to stop!");
 
             // Verify the shutdown occurred
             Assert.IsFalse(m_ServerNetworkManager.IsServer);
@@ -45,15 +48,23 @@ namespace Unity.Netcode.RuntimeTests
             Assert.IsTrue(m_ServerNetworkManager.IsListening);
         }
 
+        private void OnServerStopped(bool obj)
+        {
+            m_ServerNetworkManager.OnServerStopped -= OnServerStopped;
+            m_ServerStopped = true;
+        }
+
         [UnityTest]
         public IEnumerator WhenShuttingDownTwiceAndRestarting_SDKRestartsSuccessfullyAndStaysRunning()
         {
             // shutdown the server
+            m_ServerNetworkManager.OnServerStopped += OnServerStopped;
             m_ServerNetworkManager.Shutdown();
 
-            // wait 1 frame because shutdowns are delayed
+            // wait until the OnServerStopped is invoked
-            var nextFrameNumber = Time.frameCount + 1;
+            m_ServerStopped = false;
-            yield return new WaitUntil(() => Time.frameCount >= nextFrameNumber);
+            yield return WaitForConditionOrTimeOut(() => m_ServerStopped);
+            AssertOnTimeout("Timed out waiting for the server to stop!");
 
             // Verify the shutdown occurred
             Assert.IsFalse(m_ServerNetworkManager.IsServer);

Tests/Runtime/Transports/UnityTransportTests.cs

@@ -192,19 +192,31 @@ namespace Unity.Netcode.RuntimeTests
 
             yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
 
-            var data1 = new ArraySegment<byte>(new byte[] { 11 });
+            var data1 = new byte[10];
-            m_Client1.Send(m_Client1.ServerClientId, data1, delivery);
+            data1[0] = 11;
+            m_Client1.Send(m_Client1.ServerClientId, new ArraySegment<byte>(data1), delivery);
 
-            var data2 = new ArraySegment<byte>(new byte[] { 22 });
+            var data2 = new byte[3000];
-            m_Client1.Send(m_Client1.ServerClientId, data2, delivery);
+            data2[0] = 22;
+            m_Client1.Send(m_Client1.ServerClientId, new ArraySegment<byte>(data2), delivery);
+
+            var data3 = new byte[10];
+            data3[0] = 33;
+            m_Client1.Send(m_Client1.ServerClientId, new ArraySegment<byte>(data3), delivery);
 
             yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
 
-            Assert.AreEqual(3, m_ServerEvents.Count);
+            Assert.AreEqual(4, m_ServerEvents.Count);
-            Assert.AreEqual(NetworkEvent.Data, m_ServerEvents[2].Type);
+            Assert.AreEqual(NetworkEvent.Data, m_ServerEvents[3].Type);
 
             Assert.AreEqual(11, m_ServerEvents[1].Data.First());
+            Assert.AreEqual(10, m_ServerEvents[1].Data.Count);
+
             Assert.AreEqual(22, m_ServerEvents[2].Data.First());
+            Assert.AreEqual(3000, m_ServerEvents[2].Data.Count);
+
+            Assert.AreEqual(33, m_ServerEvents[3].Data.First());
+            Assert.AreEqual(10, m_ServerEvents[3].Data.Count);
 
             yield return null;
         }

Tests/Runtime/UniversalRpcTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: af2b96a4f4d34fa798385b487fc5c97d
+timeCreated: 1698158457