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)

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,28 +303,16 @@ namespace Unity.Netcode
                 return true;
             }
 
-            // Make sure we don't have several overrides targeting the same prefab. Apparently we don't support that... shame.
-            if (OverrideToNetworkPrefab.ContainsKey(target))
-            {
-                var networkObject = networkPrefab.Prefab.GetComponent<NetworkObject>();
-
-                // This can happen if a user tries to make several GlobalObjectIdHash values point to the same target
-                Debug.LogError($"{nameof(NetworkPrefab)} (\"{networkObject.name}\") has a duplicate {nameof(NetworkObject.GlobalObjectIdHash)} target entry value of: {target}!");
-                return false;
-            }
-
             switch (networkPrefab.Override)
             {
                 case NetworkPrefabOverride.Prefab:
-                    {
-                        NetworkPrefabOverrideLinks.Add(source, networkPrefab);
-                        OverrideToNetworkPrefab.Add(target, source);
-                    }
-                    break;
                 case NetworkPrefabOverride.Hash:
                     {
                         NetworkPrefabOverrideLinks.Add(source, networkPrefab);
-                        OverrideToNetworkPrefab.Add(target, source);
+                        if (!OverrideToNetworkPrefab.ContainsKey(target))
+                        {
+                            OverrideToNetworkPrefab.Add(target, source);
+                        }
                     }
                     break;
             }

Runtime/Connection/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);
-            }
-            catch (Exception exception)
-            {
-                Debug.LogException(exception);
+                InvokeOnPeerDisconnectedCallback(clientId);
             }
 
             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();
                     }
@@ -799,7 +953,7 @@ namespace Unity.Netcode
                 }
                 else
                 {
-                    // Handle changing ownership and prefab handlers                    
+                    // Handle changing ownership and prefab handlers
                     for (int i = clientOwnedObjects.Count - 1; i >= 0; i--)
                     {
                         var ownedObject = clientOwnedObjects[i];
@@ -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);
-                }
-                catch (Exception exception)
-                {
-                    Debug.LogException(exception);
+                    InvokeOnPeerDisconnectedCallback(clientId);
                 }
 
                 // 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)
                         {
-                            ShutdownInternal();
+                            // 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>
@@ -34,15 +50,7 @@ namespace Unity.Netcode
         {
             get
             {
-                foreach (var prefab in NetworkManager.NetworkConfig.Prefabs.Prefabs)
-                {
-                    if (prefab.Prefab == gameObject)
-                    {
-                        return GlobalObjectIdHash;
-                    }
-                }
-
-                return 0;
+                return GlobalObjectIdHash;
             }
         }
 
@@ -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)
@@ -1018,15 +1129,36 @@ namespace Unity.Netcode
 
             if (!NetworkManager.IsServer)
             {
-                transform.parent = m_CachedParent;
-                Debug.LogException(new NotServerException($"Only the server can reparent {nameof(NetworkObject)}s"));
+                // Log exception if we are a client and not shutting down.
+                if (!NetworkManager.ShutdownInProgress)
+                {
+                    transform.parent = m_CachedParent;
+                    Debug.LogException(new NotServerException($"Only the server can reparent {nameof(NetworkObject)}s"));
+                }
+                else // Otherwise, if we are removing a parent then go ahead and allow parenting to occur
+                if (transform.parent == null)
+                {
+                    m_LatestParent = null;
+                    m_CachedParent = null;
+                    InvokeBehaviourOnNetworkObjectParentChanged(null);
+                }
                 return;
             }
-
+            else // Otherwise, on the serer side if this instance is not spawned...
             if (!IsSpawned)
             {
-                transform.parent = m_CachedParent;
-                Debug.LogException(new SpawnStateException($"{nameof(NetworkObject)} can only be reparented after being spawned"));
+                // ,,,and we are removing the parent, then go ahead and allow parenting to occur
+                if (transform.parent == null)
+                {
+                    m_LatestParent = null;
+                    m_CachedParent = null;
+                    InvokeBehaviourOnNetworkObjectParentChanged(null);
+                }
+                else
+                {
+                    transform.parent = m_CachedParent;
+                    Debug.LogException(new SpawnStateException($"{nameof(NetworkObject)} can only be reparented after being spawned"));
+                }
                 return;
             }
             var removeParent = false;
@@ -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>
-        /// Whether or not the ServerRpc should only be run if executed by the owner of the object
-        /// </summary>
-        public bool RequireOwnership = true;
+        public new bool RequireOwnership;
+
+        public ServerRpcAttribute() : base(SendTo.Server)
+        {
+
+        }
     }
 
     /// <summary>
@@ -47,5 +73,11 @@ namespace Unity.Netcode
     /// <para>A ClientRpc marked method will be fired by the server but executed on clients.</para>
     /// </summary>
     [AttributeUsage(AttributeTargets.Method)]
-    public class ClientRpcAttribute : RpcAttribute { }
+    public class ClientRpcAttribute : RpcAttribute
+    {
+        public ClientRpcAttribute() : base(SendTo.NotServer)
+        {
+
+        }
+    }
 }

Runtime/Messaging/RpcParams.cs

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

Runtime/Messaging/RpcTargets.meta

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

Runtime/Messaging/RpcTargets/BaseRpcTarget.cs

@@ -0,0 +1,57 @@
+using System;
+
+namespace Unity.Netcode
+{
+    public abstract class BaseRpcTarget : IDisposable
+    {
+        protected NetworkManager m_NetworkManager;
+        private bool m_Locked;
+
+        internal void Lock()
+        {
+            m_Locked = true;
+        }
+
+        internal void Unlock()
+        {
+            m_Locked = false;
+        }
+
+        internal BaseRpcTarget(NetworkManager manager)
+        {
+            m_NetworkManager = manager;
+        }
+
+        protected void CheckLockBeforeDispose()
+        {
+            if (m_Locked)
+            {
+                throw new Exception($"RPC targets obtained through {nameof(RpcTargetUse)}.{RpcTargetUse.Temp} may not be disposed.");
+            }
+        }
+
+        public abstract void Dispose();
+
+        internal abstract void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams);
+
+        private protected void SendMessageToClient(NetworkBehaviour behaviour, ulong clientId, ref RpcMessage message, NetworkDelivery delivery)
+        {
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+            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
-            // to the list of scenes that can be unloaded.
-            if (networkManager.IsServer)
+            // Since the server tracks loaded scenes, we need to add any currently loaded scenes on the 
+            // server side when the NetworkManager is started and NetworkSceneManager instantiated when
+            // scene management is enabled.
+            if (networkManager.IsServer && networkManager.NetworkConfig.EnableSceneManagement)
             {
-                var activeScene = SceneManager.GetActiveScene();
-                ScenesLoaded.Add(activeScene.handle, activeScene);
+                for (int i = 0; i < SceneManager.sceneCount; i++)
+                {
+                    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
-                throw new Exception(
-                    $"{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)}.");
+                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)}!");
+                return new SceneEventProgress(null, SceneEventProgressStatus.SceneManagementNotEnabled);
+            }
+
+            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
-                throw new Exception(
-                    $"{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)}.");
+                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)}!");
+                return new SceneEventProgress(null, SceneEventProgressStatus.SceneManagementNotEnabled);
+            }
+
+            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
-                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;
-                    }
-                }
+                networkObject = GetNetworkObjectToSpawn(sceneObject.Hash, sceneObject.OwnerClientId, position, rotation, sceneObject.IsSceneObject);
             }
             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,17 +855,43 @@ 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
-                        // and let it be destroyed when the scene is unloaded. Otherwise, despawn and destroy it.
+                        // If it is an in-scene placed NetworkObject then just despawn and let it be destroyed when the scene
+                        // is unloaded. Otherwise, despawn and destroy it.
                         var shouldDestroy = !(networkObjects[i].IsSceneObject != null && networkObjects[i].IsSceneObject.Value);
 
-                        OnDespawnObject(networkObjects[i], shouldDestroy);
-                    }
-                    else if (networkObjects[i].IsSceneObject != null && !networkObjects[i].IsSceneObject.Value)
-                    {
-                        UnityEngine.Object.Destroy(networkObjects[i].gameObject);
+                        // 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 // Otherwise, if we are not spawned and we should destroy...then destroy.
+                        if (shouldDestroy)
+                        {
+                            UnityEngine.Object.Destroy(networkObjects[i].gameObject);
+                        }
                     }
                 }
             }
@@ -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;
 
-                while (readerOffset < TailIndex)
+                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)
                 {
-                    reader.SeekSet(readerOffset);
-                    var messageLength = reader.ReadInt();
+                    writer.WriteInt(messageLength);
+                    WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + reader.GetBytesRead(), messageLength);
 
-                    if (writerAvailable < sizeof(int) + messageLength)
-                    {
-                        break;
-                    }
-                    else
-                    {
-                        writer.WriteInt(messageLength);
-
-                        var messageOffset = reader.GetBytesRead();
-                        WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + messageOffset, messageLength);
-
-                        writerAvailable -= sizeof(int) + messageLength;
-                        readerOffset += sizeof(int) + messageLength;
-                    }
+                    return bytesToWrite;
                 }
+                else
+                {
+                    var bytesWritten = 0;
 
-                return writer.Capacity - writerAvailable;
+                    while (readerOffset < TailIndex)
+                    {
+                        reader.SeekSet(readerOffset);
+                        messageLength = reader.ReadInt();
+                        bytesToWrite = messageLength + sizeof(int);
+
+                        if (bytesWritten + bytesToWrite <= softMaxBytes)
+                        {
+                            writer.WriteInt(messageLength);
+                            WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + reader.GetBytesRead(), messageLength);
+
+                            readerOffset += bytesToWrite;
+                            bytesWritten += bytesToWrite;
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+
+                    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(