feat: host tells client which IDs it uses for INetworkMessages

com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs

@@ -2065,6 +2065,21 @@ internal void HandleConnectionApproval(ulong ownerClientId, ConnectionApprovalRe
 
                     SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ownerClientId);
 
+                    for (int index = 0; index < MessagingSystem.MessageHandlers.Length; index++)
+                    {
+                        if (MessagingSystem.ReverseTypeMap[index] != null)
+                        {
+                            var orderingMessage = new OrderingMessage
+                            {
+                                Order = index,
+                                Hash = MessagingSystem.ReverseTypeMap[index].FullName.GetHashCode()
+                            };
+
+                            SendMessage(ref orderingMessage, NetworkDelivery.ReliableFragmentedSequenced,
+                                ownerClientId);
+                        }
+                    }
+
                     // If scene management is enabled, then let NetworkSceneManager handle the initial scene and NetworkObject synchronization
                     if (!NetworkConfig.EnableSceneManagement)
                     {

com.unity.netcode.gameobjects/Runtime/Messaging/Messages/OrderingMessage.cs

@@ -0,0 +1,45 @@
+using System;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// This particular struct is a little weird because it doesn't actually contain the data
+    /// it's serializing. Instead, it contains references to the data it needs to do the
+    /// serialization. This is due to the generally amorphous nature of network variable
+    /// deltas, since they're all driven by custom virtual method overloads.
+    /// </summary>
+    internal struct OrderingMessage : INetworkMessage
+    {
+        public int Order;
+        public int Hash;
+
+        public void Serialize(FastBufferWriter writer)
+        {
+            if (!writer.TryBeginWrite(FastBufferWriter.GetWriteSize(Order) + FastBufferWriter.GetWriteSize(Hash)))
+            {
+                throw new OverflowException($"Not enough space in the buffer to write {nameof(OrderingMessage)}");
+            }
+
+            writer.WriteValue(Order);
+            writer.WriteValue(Hash);
+        }
+
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
+        {
+            if (!reader.TryBeginRead(FastBufferWriter.GetWriteSize(Order) + FastBufferWriter.GetWriteSize(Hash)))
+            {
+                throw new OverflowException($"Not enough data in the buffer to read {nameof(OrderingMessage)}");
+            }
+
+            reader.ReadValue(out Order);
+            reader.ReadValue(out Hash);
+
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            ((NetworkManager)context.SystemOwner).MessagingSystem.ReorderMessage(Order, Hash);
+        }
+    }
+}

com.unity.netcode.gameobjects/Runtime/Messaging/MessagingSystem.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 using System.Runtime.CompilerServices;
 using Unity.Collections;
 using Unity.Collections.LowLevel.Unsafe;
@@ -59,6 +60,8 @@ public SendQueueItem(NetworkDelivery delivery, int writerSize, Allocator writerA
 
         internal Type[] MessageTypes => m_ReverseTypeMap;
         internal MessageHandler[] MessageHandlers => m_MessageHandlers;
+        internal Type[] ReverseTypeMap => m_ReverseTypeMap;
+
         internal uint MessageHandlerCount => m_HighMessageType;
 
         internal uint GetMessageType(Type t)
@@ -75,6 +78,35 @@ internal struct MessageWithHandler
             public MessageHandler Handler;
         }
 
+        private 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 == "Unity.Netcode.ConnectionRequestMessage" ||
+                    t.MessageType.FullName == "Unity.Netcode.ConnectionApprovedMessage" ||
+                    t.MessageType.FullName == "Unity.Netcode.OrderingMessage")
+                {
+                    prioritizedTypes.Add(t);
+                }
+            }
+
+            foreach (var t in allowedTypes)
+            {
+                if (t.MessageType.FullName != "Unity.Netcode.ConnectionRequestMessage" &&
+                    t.MessageType.FullName != "Unity.Netcode.ConnectionApprovedMessage" &&
+                    t.MessageType.FullName != "Unity.Netcode.OrderingMessage")
+                {
+                    prioritizedTypes.Add(t);
+                }
+            }
+
+            return prioritizedTypes;
+        }
+
         public MessagingSystem(IMessageSender messageSender, object owner, IMessageProvider provider = null)
         {
             try
@@ -89,6 +121,7 @@ public MessagingSystem(IMessageSender messageSender, object owner, IMessageProvi
                 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);
@@ -226,6 +259,66 @@ private bool CanReceive(ulong clientId, Type messageType, FastBufferReader messa
             return true;
         }
 
+        internal void ReorderMessage(int desiredOrder, int targetHash)
+        {
+            if (desiredOrder < 0)
+            {
+                // invalid message re-ordering request. Ignore.
+                return;
+            }
+
+            if (desiredOrder < m_ReverseTypeMap.Length &&
+                m_ReverseTypeMap[desiredOrder].FullName.GetHashCode() == targetHash)
+            {
+                // matching positions and hashes. All good.
+                return;
+            }
+
+            // Since the message at `desiredOrder` is not the expected one,
+            // insert an empty placeholder and move the messages down
+            var typesAsList = m_ReverseTypeMap.ToList();
+            typesAsList.Insert(desiredOrder, null);
+            m_ReverseTypeMap = typesAsList.ToArray();
+            var handlersAsList = m_MessageHandlers.ToList();
+            handlersAsList.Insert(desiredOrder, null);
+            m_MessageHandlers = handlersAsList.ToArray();
+
+            // we added a dummy message, bump the end up
+            m_HighMessageType++;
+
+            int position = desiredOrder;
+            bool found = false;
+            while (position < m_ReverseTypeMap.Length)
+            {
+                if (m_ReverseTypeMap[position] != null &&
+                    m_ReverseTypeMap[position].FullName.GetHashCode() == targetHash)
+                {
+                    found = true;
+                    break;
+                }
+
+                position++;
+            }
+
+            if (found)
+            {
+                // Copy the handler and type to the right index
+                m_ReverseTypeMap[desiredOrder] = m_ReverseTypeMap[position];
+                m_MessageHandlers[desiredOrder] = m_MessageHandlers[position];
+
+                // Shift back the remaining messages
+                typesAsList = m_ReverseTypeMap.ToList();
+                typesAsList.RemoveAt(position);
+                m_ReverseTypeMap = typesAsList.ToArray();
+                handlersAsList = m_MessageHandlers.ToList();
+                handlersAsList.RemoveAt(position);
+                m_MessageHandlers = handlersAsList.ToArray();
+
+                // we removed a copy after moving a message, reduce the high message index
+                m_HighMessageType--;
+            }
+        }
+
         public void HandleMessage(in MessageHeader header, FastBufferReader reader, ulong senderId, float timestamp, int serializedHeaderSize)
         {
             if (header.MessageType >= m_HighMessageType)