Changed messageType from string to byte

TwoTenPvP · TwoTenPvP · commit 12b6de26c7c4 · 2018-07-25T15:21:08.000+02:00
diff --git a/MLAPI/Data/MLAPIConstants.cs b/MLAPI/Data/MLAPIConstants.cs
@@ -8,22 +8,41 @@ public static class MLAPIConstants
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
         public const string MLAPI_PROTOCOL_VERSION = "2.0.0";
 
-        public const ushort MLAPI_CONNECTION_REQUEST = 0;
-        public const ushort MLAPI_CONNECTION_APPROVED = 1;
-        public const ushort MLAPI_ADD_OBJECT = 2;
-        public const ushort MLAPI_CLIENT_DISCONNECT = 3;
-        public const ushort MLAPI_DESTROY_OBJECT = 4;
-        public const ushort MLAPI_SWITCH_SCENE = 5;
-        public const ushort MLAPI_SPAWN_POOL_OBJECT = 6;
-        public const ushort MLAPI_DESTROY_POOL_OBJECT = 7;
-        public const ushort MLAPI_CHANGE_OWNER = 8;
-        public const ushort MLAPI_ADD_OBJECTS = 9;
-        public const ushort MLAPI_TIME_SYNC = 10;
-        public const ushort MLAPI_NETWORKED_VAR_DELTA = 11;
-        public const ushort MLAPI_NETWORKED_VAR_UPDATE = 12;
-        public const ushort MLAPI_SERVER_RPC = 13;
-        public const ushort MLAPI_CLIENT_RPC = 14;
-        public const ushort MLAPI_CUSTOM_MESSAGE = 15;
+        public const byte MLAPI_CONNECTION_REQUEST = 0;
+        public const byte MLAPI_CONNECTION_APPROVED = 1;
+        public const byte MLAPI_ADD_OBJECT = 2;
+        public const byte MLAPI_CLIENT_DISCONNECT = 3;
+        public const byte MLAPI_DESTROY_OBJECT = 4;
+        public const byte MLAPI_SWITCH_SCENE = 5;
+        public const byte MLAPI_SPAWN_POOL_OBJECT = 6;
+        public const byte MLAPI_DESTROY_POOL_OBJECT = 7;
+        public const byte MLAPI_CHANGE_OWNER = 8;
+        public const byte MLAPI_ADD_OBJECTS = 9;
+        public const byte MLAPI_TIME_SYNC = 10;
+        public const byte MLAPI_NETWORKED_VAR_DELTA = 11;
+        public const byte MLAPI_NETWORKED_VAR_UPDATE = 12;
+        public const byte MLAPI_SERVER_RPC = 13;
+        public const byte MLAPI_CLIENT_RPC = 14;
+        public const byte MLAPI_CUSTOM_MESSAGE = 15;
+        
+        public static readonly string[] MESSAGE_NAMES = {
+            "MLAPI_CONNECTION_REQUEST",
+            "MLAPI_CONNECTION_APPROVED",
+            "MLAPI_ADD_OBJECT",
+            "MLAPI_CLIENT_DISCONNECT",
+            "MLAPI_DESTROY_OBJECT",
+            "MLAPI_SWITCH_SCENE",
+            "MLAPI_SPAWN_POOL_OBJECT",
+            "MLAPI_DESTROY_POOL_OBJECT",
+            "MLAPI_CHANGE_OWNER",
+            "MLAPI_ADD_OBJECTS",
+            "MLAPI_TIME_SYNC",
+            "MLAPI_NETWORKED_VAR_DELTA",
+            "MLAPI_NETWORKED_VAR_UPDATE",
+            "MLAPI_SERVER_RPC",
+            "MLAPI_CLIENT_RPC",
+            "MLAPI_CUSTOM_MESSAGE"
+        };
 #pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
     }
 }
diff --git a/MLAPI/Data/NetworkProfiler/NetworkProfiler.cs b/MLAPI/Data/NetworkProfiler/NetworkProfiler.cs
@@ -1,4 +1,5 @@
 ﻿using System.Collections.Generic;
+using MLAPI.Data;
 using MLAPI.Internal;
 using MLAPI.Profiler;
 using UnityEngine;
@@ -112,14 +113,14 @@ internal static void EndTick()
             CurrentTick = null;
         }
         
-        internal static void StartEvent(TickType eventType, uint bytes, int channelId, ushort messageId)
+        internal static void StartEvent(TickType eventType, uint bytes, int channelId, byte messageType)
         {
             if (!isRunning)
                 return;
             if (CurrentTick == null)
                 return;
             string channelName = MessageManager.reverseChannels.ContainsKey(channelId) ? MessageManager.reverseChannels[channelId] : "INVALID_CHANNEL";
-            string messageName = MessageManager.reverseMessageTypes.ContainsKey(messageId) ? MessageManager.reverseMessageTypes[messageId] : "INVALID_MESSAGE_TYPE";
+            string messageName = MLAPIConstants.MESSAGE_NAMES.Length < messageType ? MLAPIConstants.MESSAGE_NAMES[messageType] : "INVALID_MESSAGE_TYPE";
 
             CurrentTick.StartEvent(eventType, bytes, channelName, messageName);
         }
diff --git a/MLAPI/MonoBehaviours/Core/NetworkedBehaviour.cs b/MLAPI/MonoBehaviours/Core/NetworkedBehaviour.cs
@@ -294,9 +294,9 @@ internal void NetworkedVarUpdate()
                         }
 
                         if (isServer)
-                            InternalMessageHandler.Send(clientId, "MLAPI_NETWORKED_VAR_DELTA", channelsForVarGroups[j], stream);
+                            InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_NETWORKED_VAR_DELTA, channelsForVarGroups[j], stream);
                         else
-							InternalMessageHandler.Send(NetworkingManager.singleton.NetworkConfig.NetworkTransport.ServerClientId, "MLAPI_NETWORKED_VAR_DELTA", channelsForVarGroups[j], stream);
+							InternalMessageHandler.Send(NetworkingManager.singleton.NetworkConfig.NetworkTransport.ServerClientId, MLAPIConstants.MLAPI_NETWORKED_VAR_DELTA, channelsForVarGroups[j], stream);
                     }
                 }
             }
@@ -574,7 +574,7 @@ internal void SendServerRPCPerformance(ulong hash, Stream messageStream)
 					InvokeServerRPCLocal(hash, NetworkingManager.singleton.LocalClientId, messageStream);
 				}
             
-				InternalMessageHandler.Send(NetworkingManager.singleton.ServerClientId, "MLAPI_SERVER_RPC", "MLAPI_DEFAULT_MESSAGE", stream);
+				InternalMessageHandler.Send(NetworkingManager.singleton.ServerClientId, MLAPIConstants.MLAPI_SERVER_RPC, "MLAPI_DEFAULT_MESSAGE", stream);
 	        }
         }
 
@@ -607,7 +607,7 @@ internal void SendClientRPCPerformance(ulong hash,  List<uint> clientIds, Stream
                         }
                         else
                         {
-                            InternalMessageHandler.Send(NetworkingManager.singleton.ConnectedClientsList[i].ClientId, "MLAPI_CLIENT_RPC", "MLAPI_DEFAULT_MESSAGE", stream);
+                            InternalMessageHandler.Send(NetworkingManager.singleton.ConnectedClientsList[i].ClientId, MLAPIConstants.MLAPI_CLIENT_RPC, "MLAPI_DEFAULT_MESSAGE", stream);
                         }
                     }
                 }
@@ -622,7 +622,7 @@ internal void SendClientRPCPerformance(ulong hash,  List<uint> clientIds, Stream
                         }
                         else
                         {
-                            InternalMessageHandler.Send(clientIds[i], "MLAPI_CLIENT_RPC", "MLAPI_DEFAULT_MESSAGE", stream);
+                            InternalMessageHandler.Send(clientIds[i], MLAPIConstants.MLAPI_CLIENT_RPC, "MLAPI_DEFAULT_MESSAGE", stream);
                         }
                     }
                 }
@@ -654,7 +654,7 @@ internal void SendClientRPCPerformance(ulong hash, uint clientId, Stream message
 				}
                 else
                 {
-                    InternalMessageHandler.Send(clientId, "MLAPI_CLIENT_RPC", "MLAPI_DEFAULT_MESSAGE", stream);
+                    InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_CLIENT_RPC, "MLAPI_DEFAULT_MESSAGE", stream);
                 }
             }
         }
diff --git a/MLAPI/MonoBehaviours/Core/NetworkingManager.cs b/MLAPI/MonoBehaviours/Core/NetworkingManager.cs
@@ -162,14 +162,14 @@ public void SendCustomMessage(List<uint> clientIds, Stream stream, string channe
             {
                 for (int i = 0; i < ConnectedClientsList.Count; i++)
                 {
-                    InternalMessageHandler.Send(ConnectedClientsList[i].ClientId, "MLAPI_CUSTOM_MESSAGE", channel, stream);
+                    InternalMessageHandler.Send(ConnectedClientsList[i].ClientId, MLAPIConstants.MLAPI_CUSTOM_MESSAGE, channel, stream);
                 }
             }
             else
             {
                 for (int i = 0; i < clientIds.Count; i++)
                 {
-                    InternalMessageHandler.Send(clientIds[i], "MLAPI_CUSTOM_MESSAGE", channel, stream);
+                    InternalMessageHandler.Send(clientIds[i], MLAPIConstants.MLAPI_CUSTOM_MESSAGE, channel, stream);
                 }
             }
         }
@@ -182,7 +182,7 @@ public void SendCustomMessage(List<uint> clientIds, Stream stream, string channe
         /// <param name="channel">The channel tos end the data on</param>
         public void SendCustomMessage(uint clientId, Stream stream, string channel = "MLAPI_DEFAULT_MESSAGE")
         {
-            InternalMessageHandler.Send(clientId, "MLAPI_CUSTOM_MESSAGE", channel, stream);
+            InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_CUSTOM_MESSAGE, channel, stream);
         }
 
 
@@ -281,9 +281,7 @@ private object Init(bool server)
             diffieHellmanPublicKeys.Clear();
 #endif
             MessageManager.channels.Clear();
-            MessageManager.messageTypes.Clear();
             MessageManager.reverseChannels.Clear();
-            MessageManager.reverseMessageTypes.Clear();
             SpawnManager.SpawnedObjects.Clear();
             SpawnManager.SpawnedObjectsList.Clear();
             SpawnManager.releasedNetworkObjectIds.Clear();
@@ -404,24 +402,6 @@ private object Init(bool server)
                 MessageManager.reverseChannels.Add(channelId, NetworkConfig.Channels[i].Name);
             }
 
-            //Add internal messagetypes directly
-            MessageManager.messageTypes.Add("MLAPI_CONNECTION_REQUEST", MLAPIConstants.MLAPI_CONNECTION_REQUEST);
-            MessageManager.messageTypes.Add("MLAPI_CONNECTION_APPROVED", MLAPIConstants.MLAPI_CONNECTION_APPROVED);
-            MessageManager.messageTypes.Add("MLAPI_ADD_OBJECT", MLAPIConstants.MLAPI_ADD_OBJECT);
-            MessageManager.messageTypes.Add("MLAPI_CLIENT_DISCONNECT", MLAPIConstants.MLAPI_CLIENT_DISCONNECT);
-            MessageManager.messageTypes.Add("MLAPI_DESTROY_OBJECT", MLAPIConstants.MLAPI_DESTROY_OBJECT);
-            MessageManager.messageTypes.Add("MLAPI_SWITCH_SCENE", MLAPIConstants.MLAPI_SWITCH_SCENE);
-            MessageManager.messageTypes.Add("MLAPI_SPAWN_POOL_OBJECT", MLAPIConstants.MLAPI_SPAWN_POOL_OBJECT);
-            MessageManager.messageTypes.Add("MLAPI_DESTROY_POOL_OBJECT", MLAPIConstants.MLAPI_DESTROY_POOL_OBJECT);
-            MessageManager.messageTypes.Add("MLAPI_CHANGE_OWNER", MLAPIConstants.MLAPI_CHANGE_OWNER);
-            MessageManager.messageTypes.Add("MLAPI_ADD_OBJECTS", MLAPIConstants.MLAPI_ADD_OBJECTS);
-            MessageManager.messageTypes.Add("MLAPI_TIME_SYNC", MLAPIConstants.MLAPI_TIME_SYNC);
-            MessageManager.messageTypes.Add("MLAPI_NETWORKED_VAR_DELTA", MLAPIConstants.MLAPI_NETWORKED_VAR_DELTA);
-            MessageManager.messageTypes.Add("MLAPI_NETWORKED_VAR_UPDATE", MLAPIConstants.MLAPI_NETWORKED_VAR_UPDATE);
-            MessageManager.messageTypes.Add("MLAPI_SERVER_RPC", MLAPIConstants.MLAPI_SERVER_RPC);
-            MessageManager.messageTypes.Add("MLAPI_CLIENT_RPC", MLAPIConstants.MLAPI_CLIENT_RPC);
-            MessageManager.messageTypes.Add("MLAPI_CUSTOM_MESSAGE", MLAPIConstants.MLAPI_CUSTOM_MESSAGE);
-
             return settings;
         }
 
@@ -703,7 +683,7 @@ private void Update()
                                         if (NetworkConfig.ConnectionApproval)
                                             writer.WriteByteArray(NetworkConfig.ConnectionData);
 
-                                        InternalMessageHandler.Send(clientId, "MLAPI_CONNECTION_REQUEST", "MLAPI_INTERNAL", stream, true);
+                                        InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_CONNECTION_REQUEST, "MLAPI_INTERNAL", stream, true);
                                     }
                                 }
                                 NetworkProfiler.EndEvent();
@@ -789,7 +769,7 @@ private void HandleIncomingData(uint clientId, byte[] data, int channelId, int t
 				stream.SetLength(totalSize);
                 BitReader reader = new BitReader(stream);
 
-                ushort messageType = reader.ReadUInt16Packed();
+                byte messageType = reader.ReadByteDirect();
 
                 uint headerByteSize = (uint)Arithmetic.VarIntSize(messageType);
                 NetworkProfiler.StartEvent(TickType.Receive, (uint)(totalSize - headerByteSize), channelId, messageType);
@@ -911,7 +891,7 @@ internal void OnClientDisconnectFromServer(uint clientId)
                 {
                     BitWriter writer = new BitWriter(stream);
                     writer.WriteUInt32Packed(clientId);
-                    InternalMessageHandler.Send("MLAPI_CLIENT_DISCONNECT", "MLAPI_INTERNAL", clientId, stream);
+                    InternalMessageHandler.Send(MLAPIConstants.MLAPI_CLIENT_DISCONNECT, "MLAPI_INTERNAL", clientId, stream);
                 }
             }
         }
@@ -926,7 +906,7 @@ private void SyncTime()
                 writer.WriteSinglePacked(NetworkTime);
                 int timestamp = NetworkConfig.NetworkTransport.GetNetworkTimestamp();
                 writer.WriteInt32Packed(timestamp);
-                InternalMessageHandler.Send("MLAPI_TIME_SYNC", "MLAPI_TIME_SYNC", stream);
+                InternalMessageHandler.Send(MLAPIConstants.MLAPI_TIME_SYNC, "MLAPI_TIME_SYNC", stream);
             }
         }
 
@@ -1035,7 +1015,7 @@ internal void HandleApproval(uint clientId, int prefabId, bool approved, Vector3
                             pair.Value.WriteNetworkedVarData(stream, clientId);
                         }
                     }
-                    InternalMessageHandler.Send(clientId, "MLAPI_CONNECTION_APPROVED", "MLAPI_INTERNAL", stream, true);
+                    InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_CONNECTION_APPROVED, "MLAPI_INTERNAL", stream, true);
 
                     if (OnClientConnectedCallback != null)
                         OnClientConnectedCallback.Invoke(clientId);
@@ -1075,7 +1055,7 @@ internal void HandleApproval(uint clientId, int prefabId, bool approved, Vector3
                         {
                             writer.WriteUInt32Packed(clientId);
                         }
-                        InternalMessageHandler.Send(clientPair.Key, "MLAPI_ADD_OBJECT", "MLAPI_INTERNAL", stream);
+                        InternalMessageHandler.Send(clientPair.Key, MLAPIConstants.MLAPI_ADD_OBJECT, "MLAPI_INTERNAL", stream);
                     }
                 }
             }
diff --git a/MLAPI/NetworkingManagerComponents/Core/InternalMessageHandler.Send.cs b/MLAPI/NetworkingManagerComponents/Core/InternalMessageHandler.Send.cs
@@ -1,21 +1,22 @@
 ﻿using System.IO;
 using MLAPI.Collections;
+using MLAPI.Data;
 using MLAPI.Profiler;
 using MLAPI.Serialization;
 
 namespace MLAPI.Internal
 {
     internal static partial class InternalMessageHandler
     {
-        internal static void Send(uint clientId, string messageType, string channelName, Stream messageStream, bool skipQueue = false)
+        internal static void Send(uint clientId, byte messageType, string channelName, Stream messageStream, bool skipQueue = false)
         {
             using (PooledBitStream stream = PooledBitStream.Get())
             {
                 BitWriter writer = new BitWriter(stream);
-                writer.WriteUInt16Packed(MessageManager.messageTypes[messageType]);
+                writer.WriteByte(messageType);
                 stream.CopyFrom(messageStream);
 
-                NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, messageType);
+                NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, MLAPIConstants.MESSAGE_NAMES[messageType]);
                 byte error;
                 if (skipQueue)
                     netManager.NetworkConfig.NetworkTransport.QueueMessageForSending(clientId, stream.GetBuffer(), (int)stream.Length, MessageManager.channels[channelName], true, out error);
@@ -25,15 +26,15 @@ internal static void Send(uint clientId, string messageType, string channelName,
             }
         }
 
-        internal static void Send(string messageType, string channelName, Stream messageStream)
+        internal static void Send(byte messageType, string channelName, Stream messageStream)
         {
             using (PooledBitStream stream = PooledBitStream.Get())
             {
                 BitWriter writer = new BitWriter(stream);
-                writer.WriteUInt16Packed(MessageManager.messageTypes[messageType]);
+                writer.WriteByte(messageType);
                 stream.CopyFrom(messageStream);
 
-                NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, messageType);
+                NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, MLAPIConstants.MESSAGE_NAMES[messageType]);
                 for (int i = 0; i < netManager.ConnectedClientsList.Count; i++)
                 {
                     byte error;
@@ -43,15 +44,15 @@ internal static void Send(string messageType, string channelName, Stream message
             }
         }
         
-        internal static void Send(string messageType, string channelName, uint clientIdToIgnore, Stream messageStream)
+        internal static void Send(byte messageType, string channelName, uint clientIdToIgnore, Stream messageStream)
         {
             using (PooledBitStream stream = PooledBitStream.Get())
             {
                 BitWriter writer = new BitWriter(stream);
-                writer.WriteUInt16Packed(MessageManager.messageTypes[messageType]);
+                writer.WriteByte(messageType);
                 stream.CopyFrom(messageStream);
 
-                NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, messageType);
+                NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, MLAPIConstants.MESSAGE_NAMES[messageType]);
                 for (int i = 0; i < netManager.ConnectedClientsList.Count; i++)
                 {
 					if (netManager.ConnectedClientsList[i].ClientId == clientIdToIgnore)
diff --git a/MLAPI/NetworkingManagerComponents/Core/MessageManager.cs b/MLAPI/NetworkingManagerComponents/Core/MessageManager.cs
@@ -6,7 +6,5 @@ internal static class MessageManager
     {
         internal static readonly Dictionary<string, int> channels = new Dictionary<string, int>();
         internal static readonly Dictionary<int, string> reverseChannels = new Dictionary<int, string>();
-        internal static readonly Dictionary<string, ushort> messageTypes = new Dictionary<string, ushort>();
-        internal static readonly Dictionary<ushort, string> reverseMessageTypes = new Dictionary<ushort, string>();
     }
 }
diff --git a/MLAPI/NetworkingManagerComponents/Core/NetworkPoolManager.cs b/MLAPI/NetworkingManagerComponents/Core/NetworkPoolManager.cs
@@ -1,4 +1,5 @@
 ﻿using System.Collections.Generic;
+using MLAPI.Data;
 using MLAPI.Internal;
 using MLAPI.Logging;
 using MLAPI.Serialization;
@@ -79,7 +80,7 @@ public static NetworkedObject SpawnPoolObject(string poolName, Vector3 position,
                 writer.WriteSinglePacked(rotation.eulerAngles.y);
                 writer.WriteSinglePacked(rotation.eulerAngles.z);
 
-                InternalMessageHandler.Send("MLAPI_SPAWN_POOL_OBJECT", "MLAPI_INTERNAL", stream);
+                InternalMessageHandler.Send(MLAPIConstants.MLAPI_SPAWN_POOL_OBJECT, "MLAPI_INTERNAL", stream);
             }
             return netObject;
         }
@@ -101,7 +102,7 @@ public static void DestroyPoolObject(NetworkedObject netObject)
                 BitWriter writer = new BitWriter(stream);
                 writer.WriteUInt32Packed(netObject.NetworkId);
 
-                InternalMessageHandler.Send("MLAPI_DESTROY_POOL_OBJECT", "MLAPI_INTERNAL", stream);
+                InternalMessageHandler.Send(MLAPIConstants.MLAPI_DESTROY_POOL_OBJECT, "MLAPI_INTERNAL", stream);
             }
         }
     }
diff --git a/MLAPI/NetworkingManagerComponents/Core/NetworkSceneManager.cs b/MLAPI/NetworkingManagerComponents/Core/NetworkSceneManager.cs
@@ -1,4 +1,5 @@
 ﻿using System.Collections.Generic;
+using MLAPI.Data;
 using MLAPI.Internal;
 using MLAPI.Logging;
 using MLAPI.Serialization;
@@ -63,7 +64,7 @@ public static void SwitchScene(string sceneName)
                 BitWriter writer = new BitWriter(stream);
                 writer.WriteUInt32Packed(sceneNameToIndex[sceneName]);
 
-                InternalMessageHandler.Send("MLAPI_SWITCH_SCENE", "MLAPI_INTERNAL", stream);
+                InternalMessageHandler.Send(MLAPIConstants.MLAPI_SWITCH_SCENE, "MLAPI_INTERNAL", stream);
             }
         }
 
diff --git a/MLAPI/NetworkingManagerComponents/Core/SpawnManager.cs b/MLAPI/NetworkingManagerComponents/Core/SpawnManager.cs

Original file line number	Diff line number	Diff line change
`@@ -294,9 +294,9 @@ internal void NetworkedVarUpdate()`
`294`	`294`	`}`
`295`	`295`
`296`	`296`	`if (isServer)`
`297`		`- InternalMessageHandler.Send(clientId, "MLAPI_NETWORKED_VAR_DELTA", channelsForVarGroups[j], stream);`
	`297`	`+ InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_NETWORKED_VAR_DELTA, channelsForVarGroups[j], stream);`
`298`	`298`	`else`
`299`		`- InternalMessageHandler.Send(NetworkingManager.singleton.NetworkConfig.NetworkTransport.ServerClientId, "MLAPI_NETWORKED_VAR_DELTA", channelsForVarGroups[j], stream);`
	`299`	`+ InternalMessageHandler.Send(NetworkingManager.singleton.NetworkConfig.NetworkTransport.ServerClientId, MLAPIConstants.MLAPI_NETWORKED_VAR_DELTA, channelsForVarGroups[j], stream);`
`300`	`300`	`}`
`301`	`301`	`}`
`302`	`302`	`}`
`@@ -574,7 +574,7 @@ internal void SendServerRPCPerformance(ulong hash, Stream messageStream)`
`574`	`574`	`InvokeServerRPCLocal(hash, NetworkingManager.singleton.LocalClientId, messageStream);`
`575`	`575`	`}`
`576`	`576`
`577`		`- InternalMessageHandler.Send(NetworkingManager.singleton.ServerClientId, "MLAPI_SERVER_RPC", "MLAPI_DEFAULT_MESSAGE", stream);`
	`577`	`+ InternalMessageHandler.Send(NetworkingManager.singleton.ServerClientId, MLAPIConstants.MLAPI_SERVER_RPC, "MLAPI_DEFAULT_MESSAGE", stream);`
`578`	`578`	`}`
`579`	`579`	`}`
`580`	`580`
`@@ -607,7 +607,7 @@ internal void SendClientRPCPerformance(ulong hash, List<uint> clientIds, Stream`
`607`	`607`	`}`
`608`	`608`	`else`
`609`	`609`	`{`
`610`		`- InternalMessageHandler.Send(NetworkingManager.singleton.ConnectedClientsList[i].ClientId, "MLAPI_CLIENT_RPC", "MLAPI_DEFAULT_MESSAGE", stream);`
	`610`	`+ InternalMessageHandler.Send(NetworkingManager.singleton.ConnectedClientsList[i].ClientId, MLAPIConstants.MLAPI_CLIENT_RPC, "MLAPI_DEFAULT_MESSAGE", stream);`
`611`	`611`	`}`
`612`	`612`	`}`
`613`	`613`	`}`
`@@ -622,7 +622,7 @@ internal void SendClientRPCPerformance(ulong hash, List<uint> clientIds, Stream`
`622`	`622`	`}`
`623`	`623`	`else`
`624`	`624`	`{`
`625`		`- InternalMessageHandler.Send(clientIds[i], "MLAPI_CLIENT_RPC", "MLAPI_DEFAULT_MESSAGE", stream);`
	`625`	`+ InternalMessageHandler.Send(clientIds[i], MLAPIConstants.MLAPI_CLIENT_RPC, "MLAPI_DEFAULT_MESSAGE", stream);`
`626`	`626`	`}`
`627`	`627`	`}`
`628`	`628`	`}`
`@@ -654,7 +654,7 @@ internal void SendClientRPCPerformance(ulong hash, uint clientId, Stream message`
`654`	`654`	`}`
`655`	`655`	`else`
`656`	`656`	`{`
`657`		`- InternalMessageHandler.Send(clientId, "MLAPI_CLIENT_RPC", "MLAPI_DEFAULT_MESSAGE", stream);`
	`657`	`+ InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_CLIENT_RPC, "MLAPI_DEFAULT_MESSAGE", stream);`
`658`	`658`	`}`
`659`	`659`	`}`
`660`	`660`	`}`
Original file line number	Diff line number	Diff line change
`@@ -162,14 +162,14 @@ public void SendCustomMessage(List<uint> clientIds, Stream stream, string channe`
`162`	`162`	`{`
`163`	`163`	`for (int i = 0; i < ConnectedClientsList.Count; i++)`
`164`	`164`	`{`
`165`		`- InternalMessageHandler.Send(ConnectedClientsList[i].ClientId, "MLAPI_CUSTOM_MESSAGE", channel, stream);`
	`165`	`+ InternalMessageHandler.Send(ConnectedClientsList[i].ClientId, MLAPIConstants.MLAPI_CUSTOM_MESSAGE, channel, stream);`
`166`	`166`	`}`
`167`	`167`	`}`
`168`	`168`	`else`
`169`	`169`	`{`
`170`	`170`	`for (int i = 0; i < clientIds.Count; i++)`
`171`	`171`	`{`
`172`		`- InternalMessageHandler.Send(clientIds[i], "MLAPI_CUSTOM_MESSAGE", channel, stream);`
	`172`	`+ InternalMessageHandler.Send(clientIds[i], MLAPIConstants.MLAPI_CUSTOM_MESSAGE, channel, stream);`
`173`	`173`	`}`
`174`	`174`	`}`
`175`	`175`	`}`
`@@ -182,7 +182,7 @@ public void SendCustomMessage(List<uint> clientIds, Stream stream, string channe`
`182`	`182`	`/// <param name="channel">The channel tos end the data on</param>`
`183`	`183`	`public void SendCustomMessage(uint clientId, Stream stream, string channel = "MLAPI_DEFAULT_MESSAGE")`
`184`	`184`	`{`
`185`		`- InternalMessageHandler.Send(clientId, "MLAPI_CUSTOM_MESSAGE", channel, stream);`
	`185`	`+ InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_CUSTOM_MESSAGE, channel, stream);`
`186`	`186`	`}`
`187`	`187`
`188`	`188`
`@@ -281,9 +281,7 @@ private object Init(bool server)`
`281`	`281`	`diffieHellmanPublicKeys.Clear();`
`282`	`282`	`#endif`
`283`	`283`	`MessageManager.channels.Clear();`
`284`		`- MessageManager.messageTypes.Clear();`
`285`	`284`	`MessageManager.reverseChannels.Clear();`
`286`		`- MessageManager.reverseMessageTypes.Clear();`
`287`	`285`	`SpawnManager.SpawnedObjects.Clear();`
`288`	`286`	`SpawnManager.SpawnedObjectsList.Clear();`
`289`	`287`	`SpawnManager.releasedNetworkObjectIds.Clear();`
`@@ -404,24 +402,6 @@ private object Init(bool server)`
`404`	`402`	`MessageManager.reverseChannels.Add(channelId, NetworkConfig.Channels[i].Name);`
`405`	`403`	`}`
`406`	`404`
`407`		`- //Add internal messagetypes directly`
`408`		`- MessageManager.messageTypes.Add("MLAPI_CONNECTION_REQUEST", MLAPIConstants.MLAPI_CONNECTION_REQUEST);`
`409`		`- MessageManager.messageTypes.Add("MLAPI_CONNECTION_APPROVED", MLAPIConstants.MLAPI_CONNECTION_APPROVED);`
`410`		`- MessageManager.messageTypes.Add("MLAPI_ADD_OBJECT", MLAPIConstants.MLAPI_ADD_OBJECT);`
`411`		`- MessageManager.messageTypes.Add("MLAPI_CLIENT_DISCONNECT", MLAPIConstants.MLAPI_CLIENT_DISCONNECT);`
`412`		`- MessageManager.messageTypes.Add("MLAPI_DESTROY_OBJECT", MLAPIConstants.MLAPI_DESTROY_OBJECT);`
`413`		`- MessageManager.messageTypes.Add("MLAPI_SWITCH_SCENE", MLAPIConstants.MLAPI_SWITCH_SCENE);`
`414`		`- MessageManager.messageTypes.Add("MLAPI_SPAWN_POOL_OBJECT", MLAPIConstants.MLAPI_SPAWN_POOL_OBJECT);`
`415`		`- MessageManager.messageTypes.Add("MLAPI_DESTROY_POOL_OBJECT", MLAPIConstants.MLAPI_DESTROY_POOL_OBJECT);`
`416`		`- MessageManager.messageTypes.Add("MLAPI_CHANGE_OWNER", MLAPIConstants.MLAPI_CHANGE_OWNER);`
`417`		`- MessageManager.messageTypes.Add("MLAPI_ADD_OBJECTS", MLAPIConstants.MLAPI_ADD_OBJECTS);`
`418`		`- MessageManager.messageTypes.Add("MLAPI_TIME_SYNC", MLAPIConstants.MLAPI_TIME_SYNC);`
`419`		`- MessageManager.messageTypes.Add("MLAPI_NETWORKED_VAR_DELTA", MLAPIConstants.MLAPI_NETWORKED_VAR_DELTA);`
`420`		`- MessageManager.messageTypes.Add("MLAPI_NETWORKED_VAR_UPDATE", MLAPIConstants.MLAPI_NETWORKED_VAR_UPDATE);`
`421`		`- MessageManager.messageTypes.Add("MLAPI_SERVER_RPC", MLAPIConstants.MLAPI_SERVER_RPC);`
`422`		`- MessageManager.messageTypes.Add("MLAPI_CLIENT_RPC", MLAPIConstants.MLAPI_CLIENT_RPC);`
`423`		`- MessageManager.messageTypes.Add("MLAPI_CUSTOM_MESSAGE", MLAPIConstants.MLAPI_CUSTOM_MESSAGE);`
`424`		`-`
`425`	`405`	`return settings;`
`426`	`406`	`}`
`427`	`407`
`@@ -703,7 +683,7 @@ private void Update()`
`703`	`683`	`if (NetworkConfig.ConnectionApproval)`
`704`	`684`	`writer.WriteByteArray(NetworkConfig.ConnectionData);`
`705`	`685`
`706`		`- InternalMessageHandler.Send(clientId, "MLAPI_CONNECTION_REQUEST", "MLAPI_INTERNAL", stream, true);`
	`686`	`+ InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_CONNECTION_REQUEST, "MLAPI_INTERNAL", stream, true);`
`707`	`687`	`}`
`708`	`688`	`}`
`709`	`689`	`NetworkProfiler.EndEvent();`
`@@ -789,7 +769,7 @@ private void HandleIncomingData(uint clientId, byte[] data, int channelId, int t`
`789`	`769`	`stream.SetLength(totalSize);`
`790`	`770`	`BitReader reader = new BitReader(stream);`
`791`	`771`
`792`		`- ushort messageType = reader.ReadUInt16Packed();`
	`772`	`+ byte messageType = reader.ReadByteDirect();`
`793`	`773`
`794`	`774`	`uint headerByteSize = (uint)Arithmetic.VarIntSize(messageType);`
`795`	`775`	`NetworkProfiler.StartEvent(TickType.Receive, (uint)(totalSize - headerByteSize), channelId, messageType);`
`@@ -911,7 +891,7 @@ internal void OnClientDisconnectFromServer(uint clientId)`
`911`	`891`	`{`
`912`	`892`	`BitWriter writer = new BitWriter(stream);`
`913`	`893`	`writer.WriteUInt32Packed(clientId);`
`914`		`- InternalMessageHandler.Send("MLAPI_CLIENT_DISCONNECT", "MLAPI_INTERNAL", clientId, stream);`
	`894`	`+ InternalMessageHandler.Send(MLAPIConstants.MLAPI_CLIENT_DISCONNECT, "MLAPI_INTERNAL", clientId, stream);`
`915`	`895`	`}`
`916`	`896`	`}`
`917`	`897`	`}`
`@@ -926,7 +906,7 @@ private void SyncTime()`
`926`	`906`	`writer.WriteSinglePacked(NetworkTime);`
`927`	`907`	`int timestamp = NetworkConfig.NetworkTransport.GetNetworkTimestamp();`
`928`	`908`	`writer.WriteInt32Packed(timestamp);`
`929`		`- InternalMessageHandler.Send("MLAPI_TIME_SYNC", "MLAPI_TIME_SYNC", stream);`
	`909`	`+ InternalMessageHandler.Send(MLAPIConstants.MLAPI_TIME_SYNC, "MLAPI_TIME_SYNC", stream);`
`930`	`910`	`}`
`931`	`911`	`}`
`932`	`912`
`@@ -1035,7 +1015,7 @@ internal void HandleApproval(uint clientId, int prefabId, bool approved, Vector3`
`1035`	`1015`	`pair.Value.WriteNetworkedVarData(stream, clientId);`
`1036`	`1016`	`}`
`1037`	`1017`	`}`
`1038`		`- InternalMessageHandler.Send(clientId, "MLAPI_CONNECTION_APPROVED", "MLAPI_INTERNAL", stream, true);`
	`1018`	`+ InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_CONNECTION_APPROVED, "MLAPI_INTERNAL", stream, true);`
`1039`	`1019`
`1040`	`1020`	`if (OnClientConnectedCallback != null)`
`1041`	`1021`	`OnClientConnectedCallback.Invoke(clientId);`
`@@ -1075,7 +1055,7 @@ internal void HandleApproval(uint clientId, int prefabId, bool approved, Vector3`
`1075`	`1055`	`{`
`1076`	`1056`	`writer.WriteUInt32Packed(clientId);`
`1077`	`1057`	`}`
`1078`		`- InternalMessageHandler.Send(clientPair.Key, "MLAPI_ADD_OBJECT", "MLAPI_INTERNAL", stream);`
	`1058`	`+ InternalMessageHandler.Send(clientPair.Key, MLAPIConstants.MLAPI_ADD_OBJECT, "MLAPI_INTERNAL", stream);`
`1079`	`1059`	`}`
`1080`	`1060`	`}`
`1081`	`1061`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,21 +1,22 @@`
`1`	`1`	`using System.IO;`
`2`	`2`	`using MLAPI.Collections;`
	`3`	`+using MLAPI.Data;`
`3`	`4`	`using MLAPI.Profiler;`
`4`	`5`	`using MLAPI.Serialization;`
`5`	`6`
`6`	`7`	`namespace MLAPI.Internal`
`7`	`8`	`{`
`8`	`9`	`internal static partial class InternalMessageHandler`
`9`	`10`	`{`
`10`		`- internal static void Send(uint clientId, string messageType, string channelName, Stream messageStream, bool skipQueue = false)`
	`11`	`+ internal static void Send(uint clientId, byte messageType, string channelName, Stream messageStream, bool skipQueue = false)`
`11`	`12`	`{`
`12`	`13`	`using (PooledBitStream stream = PooledBitStream.Get())`
`13`	`14`	`{`
`14`	`15`	`BitWriter writer = new BitWriter(stream);`
`15`		`- writer.WriteUInt16Packed(MessageManager.messageTypes[messageType]);`
	`16`	`+ writer.WriteByte(messageType);`
`16`	`17`	`stream.CopyFrom(messageStream);`
`17`	`18`
`18`		`- NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, messageType);`
	`19`	`+ NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, MLAPIConstants.MESSAGE_NAMES[messageType]);`
`19`	`20`	`byte error;`
`20`	`21`	`if (skipQueue)`
`21`	`22`	`netManager.NetworkConfig.NetworkTransport.QueueMessageForSending(clientId, stream.GetBuffer(), (int)stream.Length, MessageManager.channels[channelName], true, out error);`
`@@ -25,15 +26,15 @@ internal static void Send(uint clientId, string messageType, string channelName,`
`25`	`26`	`}`
`26`	`27`	`}`
`27`	`28`
`28`		`- internal static void Send(string messageType, string channelName, Stream messageStream)`
	`29`	`+ internal static void Send(byte messageType, string channelName, Stream messageStream)`
`29`	`30`	`{`
`30`	`31`	`using (PooledBitStream stream = PooledBitStream.Get())`
`31`	`32`	`{`
`32`	`33`	`BitWriter writer = new BitWriter(stream);`
`33`		`- writer.WriteUInt16Packed(MessageManager.messageTypes[messageType]);`
	`34`	`+ writer.WriteByte(messageType);`
`34`	`35`	`stream.CopyFrom(messageStream);`
`35`	`36`
`36`		`- NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, messageType);`
	`37`	`+ NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, MLAPIConstants.MESSAGE_NAMES[messageType]);`
`37`	`38`	`for (int i = 0; i < netManager.ConnectedClientsList.Count; i++)`
`38`	`39`	`{`
`39`	`40`	`byte error;`
`@@ -43,15 +44,15 @@ internal static void Send(string messageType, string channelName, Stream message`
`43`	`44`	`}`
`44`	`45`	`}`
`45`	`46`
`46`		`- internal static void Send(string messageType, string channelName, uint clientIdToIgnore, Stream messageStream)`
	`47`	`+ internal static void Send(byte messageType, string channelName, uint clientIdToIgnore, Stream messageStream)`
`47`	`48`	`{`
`48`	`49`	`using (PooledBitStream stream = PooledBitStream.Get())`
`49`	`50`	`{`
`50`	`51`	`BitWriter writer = new BitWriter(stream);`
`51`		`- writer.WriteUInt16Packed(MessageManager.messageTypes[messageType]);`
	`52`	`+ writer.WriteByte(messageType);`
`52`	`53`	`stream.CopyFrom(messageStream);`
`53`	`54`
`54`		`- NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, messageType);`
	`55`	`+ NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, MLAPIConstants.MESSAGE_NAMES[messageType]);`
`55`	`56`	`for (int i = 0; i < netManager.ConnectedClientsList.Count; i++)`
`56`	`57`	`{`
`57`	`58`	`if (netManager.ConnectedClientsList[i].ClientId == clientIdToIgnore)`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,5 @@ internal static class MessageManager`
`6`	`6`	`{`
`7`	`7`	`internal static readonly Dictionary<string, int> channels = new Dictionary<string, int>();`
`8`	`8`	`internal static readonly Dictionary<int, string> reverseChannels = new Dictionary<int, string>();`
`9`		`- internal static readonly Dictionary<string, ushort> messageTypes = new Dictionary<string, ushort>();`
`10`		`- internal static readonly Dictionary<ushort, string> reverseMessageTypes = new Dictionary<ushort, string>();`
`11`	`9`	`}`
`12`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using System.Collections.Generic;`
	`2`	`+using MLAPI.Data;`
`2`	`3`	`using MLAPI.Internal;`
`3`	`4`	`using MLAPI.Logging;`
`4`	`5`	`using MLAPI.Serialization;`
`@@ -79,7 +80,7 @@ public static NetworkedObject SpawnPoolObject(string poolName, Vector3 position,`
`79`	`80`	`writer.WriteSinglePacked(rotation.eulerAngles.y);`
`80`	`81`	`writer.WriteSinglePacked(rotation.eulerAngles.z);`
`81`	`82`
`82`		`- InternalMessageHandler.Send("MLAPI_SPAWN_POOL_OBJECT", "MLAPI_INTERNAL", stream);`
	`83`	`+ InternalMessageHandler.Send(MLAPIConstants.MLAPI_SPAWN_POOL_OBJECT, "MLAPI_INTERNAL", stream);`
`83`	`84`	`}`
`84`	`85`	`return netObject;`
`85`	`86`	`}`
`@@ -101,7 +102,7 @@ public static void DestroyPoolObject(NetworkedObject netObject)`
`101`	`102`	`BitWriter writer = new BitWriter(stream);`
`102`	`103`	`writer.WriteUInt32Packed(netObject.NetworkId);`
`103`	`104`
`104`		`- InternalMessageHandler.Send("MLAPI_DESTROY_POOL_OBJECT", "MLAPI_INTERNAL", stream);`
	`105`	`+ InternalMessageHandler.Send(MLAPIConstants.MLAPI_DESTROY_POOL_OBJECT, "MLAPI_INTERNAL", stream);`
`105`	`106`	`}`
`106`	`107`	`}`
`107`	`108`	`}`