com.unity.netcode.gameobjects@2.0.0-exp.4

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).

## [2.0.0-exp.4] - 2024-05-31

### Added

- Added `NetworkRigidbodyBase.AttachToFixedJoint` and `NetworkRigidbodyBase.DetachFromFixedJoint` to replace parenting for rigid bodies that have `NetworkRigidbodyBase.UseRigidBodyForMotion` enabled. (#2933)
- Added `NetworkBehaviour.OnNetworkPreSpawn` and `NetworkBehaviour.OnNetworkPostSpawn` methods that provide the ability to handle pre and post spawning actions during the `NetworkObject` spawn sequence. (#2912)
- Added a client-side only `NetworkBehaviour.OnNetworkSessionSynchronized` convenience method that is invoked on all `NetworkBehaviour`s after a newly joined client has finished synchronizing with the network session in progress. (#2912)
- Added `NetworkBehaviour.OnInSceneObjectsSpawned` convenience method that is invoked when all in-scene `NetworkObject`s have been spawned after a scene has been loaded or upon a host or server starting. (#2912)

### Fixed

- Fixed issue where non-authoritative rigid bodies with `NetworkRigidbodyBase.UseRigidBodyForMotion` enabled would constantly log errors about the renderTime being before `StartTimeConsumed`. (#2933)
- Fixed issue where in-scene placed NetworkObjects could be destroyed if a client disconnects early and/or before approval. (#2924)
- Fixed issue where a `NetworkObject` component's associated `NetworkBehaviour` components would not be detected if scene loading is disabled in the editor and the currently loaded scene has in-scene placed `NetworkObject`s. (#2912)
- Fixed issue where an in-scene placed `NetworkObject` with `NetworkTransform` that is also parented under a `GameObject` would not properly synchronize when the parent `GameObject` had a world space position other than 0,0,0. (#2898)

### Changed

- Change all the access modifiers of test class from Public to Internal (#2930)
- Changed messages are now sorted by enum values as opposed to ordinally sorting the messages by their type name. (#2929)
- Changed `NetworkClient.SessionModeTypes` to `NetworkClient.NetworkTopologyTypes`. (#2875)
- Changed `NetworkClient.SessionModeType` to `NetworkClient.NetworkTopologyType`. (#2875)
- Changed `NetworkConfig.SessionMode` to `NeworkConfig.NetworkTopology`. (#2875)

Runtime/Messaging/CustomMessageManager.cs

@@ -63,16 +63,39 @@ namespace Unity.Netcode
         /// <param name="networkDelivery">The delivery type (QoS) to send data with</param>
         public void SendUnnamedMessage(IReadOnlyList<ulong> clientIds, FastBufferWriter messageBuffer, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
         {
-            if (!m_NetworkManager.IsServer)
-            {
-                throw new InvalidOperationException("Can not send unnamed messages to multiple users as a client");
-            }
-
             if (clientIds == null)
             {
-                throw new ArgumentNullException(nameof(clientIds), "You must pass in a valid clientId List");
+                throw new ArgumentNullException(nameof(clientIds), "You must pass in a valid clientId List!");
             }
 
+            if (!m_NetworkManager.DistributedAuthorityMode && !m_NetworkManager.IsServer)
+            {
+                if (clientIds.Count > 1 || (clientIds.Count == 1 && clientIds[0] != NetworkManager.ServerClientId))
+                {
+                    Debug.LogError("Clients cannot send unnamed messages to other clients!");
+                    return;
+                }
+                else if (clientIds.Count == 1)
+                {
+                    SendUnnamedMessage(clientIds[0], messageBuffer, networkDelivery);
+                }
+            }
+            else if (m_NetworkManager.DistributedAuthorityMode && !m_NetworkManager.DAHost)
+            {
+                if (clientIds.Count > 1)
+                {
+                    Debug.LogError("Sending an unnamed message to multiple clients is not yet supported in distributed authority.");
+                    return;
+                }
+            }
+
+            if (clientIds.Count == 0)
+            {
+                Debug.LogError($"{nameof(clientIds)} is empty! No clients to send to.");
+                return;
+            }
+
+
             if (m_NetworkManager.IsHost)
             {
                 for (var i = 0; i < clientIds.Count; ++i)
@@ -203,6 +226,14 @@ namespace Unity.Netcode
             var hash32 = XXHash.Hash32(name);
             var hash64 = XXHash.Hash64(name);
 
+            if (m_NetworkManager.LogLevel <= LogLevel.Developer)
+            {
+                if (m_MessageHandlerNameLookup32.ContainsKey(hash32) || m_MessageHandlerNameLookup64.ContainsKey(hash64))
+                {
+                    Debug.LogWarning($"Registering {name} named message over existing registration! Your previous registration's callback is being overwritten!");
+                }
+            }
+
             m_NamedMessageHandlers32[hash32] = callback;
             m_NamedMessageHandlers64[hash64] = callback;
 
@@ -303,14 +334,37 @@ namespace Unity.Netcode
         /// <param name="networkDelivery">The delivery type (QoS) to send data with</param>
         public void SendNamedMessage(string messageName, IReadOnlyList<ulong> clientIds, FastBufferWriter messageStream, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
         {
-            if (!m_NetworkManager.IsServer)
-            {
-                throw new InvalidOperationException("Can not send unnamed messages to multiple users as a client");
-            }
-
             if (clientIds == null)
             {
-                throw new ArgumentNullException(nameof(clientIds), "You must pass in a valid clientId List");
+                throw new ArgumentNullException(nameof(clientIds), "Client list is null! You must pass in a valid clientId list to send a named message.");
+            }
+
+            if (!m_NetworkManager.DistributedAuthorityMode && !m_NetworkManager.IsServer)
+            {
+                if (clientIds.Count > 1 || (clientIds.Count == 1 && clientIds[0] != NetworkManager.ServerClientId))
+                {
+                    Debug.LogError("Clients cannot send named messages to other clients!");
+                    return;
+                }
+                else if (clientIds.Count == 1)
+                {
+                    SendNamedMessage(messageName, clientIds[0], messageStream, networkDelivery);
+                    return;
+                }
+            }
+            else if (m_NetworkManager.DistributedAuthorityMode && !m_NetworkManager.DAHost)
+            {
+                if (clientIds.Count > 1)
+                {
+                    Debug.LogError("Sending a named message to multiple clients is not yet supported in distributed authority.");
+                    return;
+                }
+            }
+
+            if (clientIds.Count == 0)
+            {
+                Debug.LogError($"{nameof(clientIds)} is empty! No clients to send the named message {messageName} to!");
+                return;
             }
 
             ulong hash = 0;

Runtime/Messaging/ILPPMessageProvider.cs

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

Runtime/Messaging/Messages/ChangeOwnershipMessage.cs

@@ -5,6 +5,8 @@ namespace Unity.Netcode
     {
         public int Version => 0;
 
+        private const string k_Name = "ChangeOwnershipMessage";
+
         public ulong NetworkObjectId;
         public ulong OwnerClientId;
         // DANGOEXP TODO: Remove these notes or change their format
@@ -199,7 +201,7 @@ namespace Unity.Netcode
             // authority of the NetworkObject in question.
             if (!networkManager.DAHost && !networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, GetType().Name);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, k_Name);
                 return false;
             }
             return true;

Runtime/Messaging/Messages/ConnectionApprovedMessage.cs

@@ -222,6 +222,12 @@ namespace Unity.Netcode
                 }
                 // When scene management is disabled we notify after everything is synchronized
                 networkManager.ConnectionManager.InvokeOnClientConnectedCallback(context.SenderId);
+
+                // For convenience, notify all NetworkBehaviours that synchronization is complete.
+                foreach (var networkObject in networkManager.SpawnManager.SpawnedObjectsList)
+                {
+                    networkObject.InternalNetworkSessionSynchronized();
+                }
             }
             else
             {
@@ -230,16 +236,22 @@ namespace Unity.Netcode
                     // Mark the client being connected
                     networkManager.IsConnectedClient = true;
 
-                    // Spawn any in-scene placed NetworkObjects
-                    networkManager.SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
+                    networkManager.SceneManager.IsRestoringSession = IsRestoredSession;
 
-                    // Spawn the local player of the session owner
-                    if (networkManager.AutoSpawnPlayerPrefabClientSide)
+                    if (!IsRestoredSession)
                     {
-                        networkManager.ConnectionManager.CreateAndSpawnPlayer(OwnerClientId);
+                        // Spawn any in-scene placed NetworkObjects
+                        networkManager.SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
+
+                        // Spawn the local player of the session owner
+                        if (networkManager.AutoSpawnPlayerPrefabClientSide)
+                        {
+                            networkManager.ConnectionManager.CreateAndSpawnPlayer(OwnerClientId);
+                        }
+
+                        // Synchronize the service with the initial session owner's loaded scenes and spawned objects
+                        networkManager.SceneManager.SynchronizeNetworkObjects(NetworkManager.ServerClientId);
                     }
-                    // Synchronize the service with the initial session owner's loaded scenes and spawned objects
-                    networkManager.SceneManager.SynchronizeNetworkObjects(NetworkManager.ServerClientId);
                 }
             }
             ConnectedClientIds.Dispose();

Runtime/Messaging/Messages/CreateObjectMessage.cs

@@ -7,6 +7,8 @@ namespace Unity.Netcode
     {
         public int Version => 0;
 
+        private const string k_Name = "CreateObjectMessage";
+
         public NetworkObject.SceneObject ObjectInfo;
         private FastBufferReader m_ReceivedNetworkVariableData;
 
@@ -161,7 +163,7 @@ namespace Unity.Netcode
 
             if (!networkManager.NetworkConfig.ForceSamePrefabs && !networkManager.SpawnManager.HasPrefab(ObjectInfo))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context, GetType().Name);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context, k_Name);
                 return false;
             }
             m_ReceivedNetworkVariableData = reader;

Runtime/Messaging/Messages/DestroyObjectMessage.cs

@@ -6,6 +6,8 @@ namespace Unity.Netcode
     {
         public int Version => 0;
 
+        private const string k_Name = "DestroyObjectMessage";
+
         public ulong NetworkObjectId;
         public bool DestroyGameObject;
         private byte m_DestroyFlags;
@@ -84,7 +86,7 @@ namespace Unity.Netcode
                 // Client-Server mode we always defer where in distributed authority mode we only defer if it is not a targeted destroy
                 if (!networkManager.DistributedAuthorityMode || (networkManager.DistributedAuthorityMode && !IsTargetedDestroy))
                 {
-                    networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, GetType().Name);
+                    networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, k_Name);
                 }
             }
             return true;

Runtime/Messaging/Messages/NetworkTransformMessage.cs

@@ -0,0 +1,190 @@
+using Unity.Netcode.Components;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// NetworkTransform State Update Message
+    /// </summary>
+    internal struct NetworkTransformMessage : INetworkMessage
+    {
+        public int Version => 0;
+        private const string k_Name = "NetworkTransformMessage";
+
+        internal NetworkTransform NetworkTransform;
+
+        // Only used for DAHost
+        internal NetworkTransform.NetworkTransformState State;
+        private FastBufferReader m_CurrentReader;
+
+        private unsafe void CopyPayload(ref FastBufferWriter writer)
+        {
+            writer.WriteBytesSafe(m_CurrentReader.GetUnsafePtrAtCurrentPosition(), m_CurrentReader.Length - m_CurrentReader.Position);
+        }
+
+        public void Serialize(FastBufferWriter writer, int targetVersion)
+        {
+            if (m_CurrentReader.IsInitialized)
+            {
+                CopyPayload(ref writer);
+            }
+            else
+            {
+                NetworkTransform.SerializeMessage(writer, targetVersion);
+            }
+        }
+
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+        {
+            var networkManager = context.SystemOwner as NetworkManager;
+            if (networkManager == null)
+            {
+                Debug.LogError($"[{nameof(NetworkTransformMessage)}] System owner context was not of type {nameof(NetworkManager)}!");
+                return false;
+            }
+            var currentPosition = reader.Position;
+            var networkObjectId = (ulong)0;
+            var networkBehaviourId = 0;
+
+            ByteUnpacker.ReadValueBitPacked(reader, out networkObjectId);
+            var isSpawnedLocally = networkManager.SpawnManager.SpawnedObjects.ContainsKey(networkObjectId);
+
+            // Only defer if the NetworkObject is not spawned yet and the local NetworkManager is not running as a DAHost.
+            if (!isSpawnedLocally && !networkManager.DAHost)
+            {
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, networkObjectId, reader, ref context, k_Name);
+                return false;
+            }
+
+            // While the below check and assignment might seem out of place, this is specific to running in DAHost mode when a NetworkObject is
+            // hidden from the DAHost but is visible to other clients. Since the DAHost needs to forward updates to the clients, we ignore processing
+            // this message locally
+            var networkObject = (NetworkObject)null;
+            var isServerAuthoritative = false;
+            var ownerAuthoritativeServerSide = false;
+
+            // Get the behaviour index
+            ByteUnpacker.ReadValueBitPacked(reader, out networkBehaviourId);
+
+            if (isSpawnedLocally)
+            {
+                networkObject = networkManager.SpawnManager.SpawnedObjects[networkObjectId];
+                // Get the target NetworkTransform
+                NetworkTransform = networkObject.ChildNetworkBehaviours[networkBehaviourId] as NetworkTransform;
+                isServerAuthoritative = NetworkTransform.IsServerAuthoritative();
+                ownerAuthoritativeServerSide = !isServerAuthoritative && networkManager.IsServer;
+
+                reader.ReadNetworkSerializableInPlace(ref NetworkTransform.InboundState);
+            }
+            else
+            {
+                // Deserialize the state
+                reader.ReadNetworkSerializableInPlace(ref State);
+            }
+
+            unsafe
+            {
+                if (ownerAuthoritativeServerSide)
+                {
+                    var targetCount = 1;
+
+                    if (networkManager.DistributedAuthorityMode && networkManager.DAHost)
+                    {
+                        ByteUnpacker.ReadValueBitPacked(reader, out targetCount);
+                    }
+
+                    var targetIds = stackalloc ulong[targetCount];
+
+                    if (networkManager.DistributedAuthorityMode && networkManager.DAHost)
+                    {
+                        var targetId = (ulong)0;
+                        for (int i = 0; i < targetCount; i++)
+                        {
+                            ByteUnpacker.ReadValueBitPacked(reader, out targetId);
+                            targetIds[i] = targetId;
+                        }
+
+                        if (!isSpawnedLocally)
+                        {
+                            // If we are the DAHost and the NetworkObject is hidden from the host we still need to forward this message
+                            ownerAuthoritativeServerSide = networkManager.DAHost && !isSpawnedLocally;
+                        }
+                    }
+
+                    var ownerClientId = (ulong)0;
+
+                    if (networkObject != null)
+                    {
+                        ownerClientId = networkObject.OwnerClientId;
+                        if (ownerClientId == NetworkManager.ServerClientId)
+                        {
+                            // Ownership must have changed, ignore any additional pending messages that might have
+                            // come from a previous owner client.
+                            return true;
+                        }
+                    }
+                    else if (networkManager.DAHost)
+                    {
+                        // Specific to distributed authority mode, the only sender of state updates will be the owner 
+                        ownerClientId = context.SenderId;
+                    }
+
+                    var networkDelivery = State.IsReliableStateUpdate() ? NetworkDelivery.ReliableSequenced : NetworkDelivery.UnreliableSequenced;
+
+                    // Forward the state update if there are any remote clients to foward it to
+                    if (networkManager.ConnectionManager.ConnectedClientsList.Count > (networkManager.IsHost ? 2 : 1))
+                    {
+                        var clientCount = networkManager.DistributedAuthorityMode ? targetCount : networkManager.ConnectionManager.ConnectedClientsList.Count;
+                        if (clientCount == 0)
+                        {
+                            return true;
+                        }
+
+                        // This is only to copy the existing and already serialized struct for forwarding purposes only.
+                        // This will not include any changes made to this struct at this particular stage of processing the message.
+                        var currentMessage = this;
+                        // Create a new reader that replicates this message
+                        currentMessage.m_CurrentReader = new FastBufferReader(reader, Collections.Allocator.None);
+                        // Rewind the new reader to the beginning of the message's payload
+                        currentMessage.m_CurrentReader.Seek(currentPosition);
+                        // Forward the message to all connected clients that are observers of the associated NetworkObject
+
+                        for (int i = 0; i < clientCount; i++)
+                        {
+                            var clientId = networkManager.DistributedAuthorityMode ? targetIds[i] : networkManager.ConnectionManager.ConnectedClientsList[i].ClientId;
+                            if (NetworkManager.ServerClientId == clientId || (!isServerAuthoritative && clientId == ownerClientId) ||
+                                (!networkManager.DistributedAuthorityMode && !networkObject.Observers.Contains(clientId)))
+                            {
+                                continue;
+                            }
+
+                            networkManager.MessageManager.SendMessage(ref currentMessage, networkDelivery, clientId);
+                        }
+                        // Dispose of the reader used for forwarding
+                        currentMessage.m_CurrentReader.Dispose();
+                    }
+                }
+            }
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            var networkManager = context.SystemOwner as NetworkManager;
+            // Only if the local NetworkManager instance is running as the DAHost we just exit if there is no local
+            // NetworkTransform component to apply the state update to (i.e. it is hidden from the DAHost and it
+            // just forwarded the state update to any other connected client)
+            if (networkManager.DAHost && NetworkTransform == null)
+            {
+                return;
+            }
+
+            if (NetworkTransform == null)
+            {
+                Debug.LogError($"[{nameof(NetworkTransformMessage)}][Dropped] Reciever {nameof(NetworkTransform)} was not set!");
+                return;
+            }
+            NetworkTransform.TransformStateUpdate(context.SenderId);
+        }
+    }
+}

Runtime/Messaging/Messages/NetworkTransformMessage.cs.meta

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

Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs

@@ -23,6 +23,8 @@ namespace Unity.Netcode
 
         private FastBufferReader m_ReceivedNetworkVariableData;
 
+        private const string k_Name = "NetworkVariableDeltaMessage";
+
         // DANGO-TODO: Made some modifications here that overlap/won't play nice with EnsureNetworkVariableLenghtSafety.
         // Worth either merging or more cleanly separating these codepaths.
         public void Serialize(FastBufferWriter writer, int targetVersion)
@@ -296,7 +298,7 @@ namespace Unity.Netcode
                 // DANGO-TODO: Fix me!
                 // When a client-spawned NetworkObject is despawned by the owner client, the owner client will still get messages for deltas and cause this to
                 // log a warning. The issue is primarily how NetworkVariables handle updating and will require some additional re-factoring.
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, m_ReceivedNetworkVariableData, ref context, GetType().Name);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, m_ReceivedNetworkVariableData, ref context, k_Name);
             }
         }
     }

Runtime/Messaging/Messages/ParentSyncMessage.cs

@@ -6,6 +6,8 @@ namespace Unity.Netcode
     {
         public int Version => 0;
 
+        private const string k_Name = "DestroyObjectMessage";
+
         public ulong NetworkObjectId;
 
         private byte m_BitField;
@@ -92,7 +94,7 @@ namespace Unity.Netcode
             // If the target NetworkObject does not exist =or= the target latest parent does not exist then defer the message
             if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId) || (LatestParent.HasValue && !networkManager.SpawnManager.SpawnedObjects.ContainsKey(LatestParent.Value)))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, GetType().Name);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, k_Name);
                 return false;
             }
             return true;

Runtime/Messaging/Messages/RpcMessages.cs

@@ -99,6 +99,8 @@ namespace Unity.Netcode
         public FastBufferWriter WriteBuffer;
         public FastBufferReader ReadBuffer;
 
+        private const string k_Name = "ServerRpcMessage";
+
         public unsafe void Serialize(FastBufferWriter writer, int targetVersion)
         {
             RpcMessageHelpers.Serialize(ref writer, ref Metadata, ref WriteBuffer);
@@ -106,7 +108,7 @@ namespace Unity.Netcode
 
         public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
         {
-            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, GetType().Name);
+            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, k_Name);
         }
 
         public void Handle(ref NetworkContext context)
@@ -134,6 +136,8 @@ namespace Unity.Netcode
         public FastBufferWriter WriteBuffer;
         public FastBufferReader ReadBuffer;
 
+        private const string k_Name = "ClientRpcMessage";
+
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
             RpcMessageHelpers.Serialize(ref writer, ref Metadata, ref WriteBuffer);
@@ -141,7 +145,7 @@ namespace Unity.Netcode
 
         public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
         {
-            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, GetType().Name);
+            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, k_Name);
         }
 
         public void Handle(ref NetworkContext context)
@@ -169,6 +173,8 @@ namespace Unity.Netcode
         public FastBufferWriter WriteBuffer;
         public FastBufferReader ReadBuffer;
 
+        private const string k_Name = "RpcMessage";
+
         public unsafe void Serialize(FastBufferWriter writer, int targetVersion)
         {
             BytePacker.WriteValuePacked(writer, SenderClientId);
@@ -179,7 +185,7 @@ namespace Unity.Netcode
         {
             ByteUnpacker.ReadValuePacked(reader, out SenderClientId);
 
-            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, GetType().Name);
+            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, k_Name);
         }
 
         public void Handle(ref NetworkContext context)

Runtime/Messaging/NetworkMessageManager.cs

@@ -120,49 +120,20 @@ namespace Unity.Netcode
             public VersionGetter GetVersion;
         }
 
-        internal List<MessageWithHandler> PrioritizeMessageOrder(List<MessageWithHandler> allowedTypes)
-        {
-            var prioritizedTypes = new List<MessageWithHandler>();
-
-            // First pass puts the priority message in the first indices
-            // Those are the messages that must be delivered in order to allow re-ordering the others later
-            foreach (var t in allowedTypes)
-            {
-                if (t.MessageType.FullName == typeof(ConnectionRequestMessage).FullName ||
-                    t.MessageType.FullName == typeof(ConnectionApprovedMessage).FullName)
-                {
-                    prioritizedTypes.Add(t);
-                }
-            }
-
-            foreach (var t in allowedTypes)
-            {
-                if (t.MessageType.FullName != typeof(ConnectionRequestMessage).FullName &&
-                    t.MessageType.FullName != typeof(ConnectionApprovedMessage).FullName)
-                {
-                    prioritizedTypes.Add(t);
-                }
-            }
-
-            return prioritizedTypes;
-        }
-
         public NetworkMessageManager(INetworkMessageSender sender, object owner, INetworkMessageProvider provider = null)
         {
             try
             {
                 m_Sender = sender;
                 m_Owner = owner;
-
                 if (provider == null)
                 {
                     provider = new ILPPMessageProvider();
                 }
 
+                // Get the presorted message types returned by the provider
                 var allowedTypes = provider.GetMessages();
 
-                allowedTypes.Sort((a, b) => string.CompareOrdinal(a.MessageType.FullName, b.MessageType.FullName));
-                allowedTypes = PrioritizeMessageOrder(allowedTypes);
                 foreach (var type in allowedTypes)
                 {
                     RegisterMessageType(type);