Split apart the server packets from the client packets

MistoxServer/Client/TCPClient.cs

@@ -42,8 +42,13 @@ namespace Mistox.Client {
                         // Read off the data
                         await ns.ReadExactlyAsync(payloadBuffer, 0, dataLength);
 
+                        // Get the type from the tag
+                        if (!DataPacket.ServerToClientPackets.TryGetValue(packetbyte, out Type resolvedType)) {
+                            throw new Exception($"Unknown packet type ID: {packetbyte}");
+                        }
+
                         // Create the dataobject
-                        dynamic dataobject = DataPacket.Deserialize( packetbyte, dataLength, payloadBuffer.AsMemory(DataPacket.HeaderLength, dataLength) );
+                        dynamic dataobject = DataPacket.Deserialize( resolvedType, dataLength, payloadBuffer.AsMemory(DataPacket.HeaderLength, dataLength) );
 
                         // Return the object
                         ClientInterface.ServerClientInstance.InvokeOnReceived(dataobject);

MistoxServer/Client/UDPClient.cs

@@ -41,8 +41,13 @@ namespace Mistox.Client {
                     ushort DataLength = (ushort)((dataPacket[1] << 8) | dataPacket[2]);
                     ReadOnlyMemory<byte> data = dataMemory.Slice(DataPacket.HeaderLength, DataLength);
 
+                    // Get the type from the tag
+                    if (!DataPacket.ClientToClientPackets.TryGetValue(dataType, out Type resolvedType)) {
+                        throw new Exception($"Unknown packet type ID: {dataType}");
+                    }
+
                     // Extract the object
-                    dynamic buildObj = DataPacket.Deserialize( dataType, DataLength, data );
+                    dynamic buildObj = DataPacket.Deserialize( resolvedType, DataLength, data );
 
                     // Return the object
                     ClientInterface.ServerClientInstance.InvokeOnReceived( buildObj );

MistoxServer/Server/TCPConnection.cs

@@ -41,8 +41,13 @@ namespace Mistox.Server {
                         // Read off the data
                         await ns.ReadExactlyAsync(payloadBuffer, 0, dataLength);
 
+                        // Get the type from the tag
+                        if (!DataPacket.ServerToClientPackets.TryGetValue(packetbyte, out Type resolvedType)) {
+                            throw new Exception($"Unknown packet type ID: {packetbyte}");
+                        }
+
                         // Create the dataobject
-                        dynamic dataobject = DataPacket.Deserialize( packetbyte, dataLength, payloadBuffer.AsMemory(DataPacket.HeaderLength, dataLength) );
+                        dynamic dataobject = DataPacket.Deserialize( resolvedType, dataLength, payloadBuffer.AsMemory(DataPacket.HeaderLength, dataLength) );
 
                         // Return the object
                         ServerInterface.ServerInstance.InvokeDataReceived(dataobject);

MistoxServer/mPacket/DataPacket.cs

@@ -43,23 +43,18 @@ namespace Mistox {
 
         }
 
-        public static object Deserialize( byte PacketType, ushort DataLength, ReadOnlyMemory<byte> Data ) {
+        public static object Deserialize( Type PacketType, ushort DataLength, ReadOnlyMemory<byte> Data ) {
             
             // Sanity check: Ensure the packet we received actually has the payload bytes it claims to have
             if ( DataLength <= Data.Length ) {
                 throw new Exception("Malformed packet: Payload size mismatch.");
             }
 
-            // Get the type from the tag
-            if (!NetworkPackets.TryGetValue(PacketType, out Type resolvedType)) {
-                throw new Exception($"Unknown packet type ID: {PacketType}");
-            }
-
             // 4. Create the low-level reader struct directly over the memory slice
             var reader = new MessagePackReader(Data);
 
             // Extract the object
-            dynamic obj = MessagePackSerializer.Deserialize( resolvedType, ref reader, MessagePackSerializerOptions.Standard );
+            dynamic obj = MessagePackSerializer.Deserialize( PacketType, ref reader, MessagePackSerializerOptions.Standard );
 
             return obj;
 
@@ -69,13 +64,18 @@ namespace Mistox {
 
 
         // Fills out the NetworkPacket Lookup Dictionary
-        public static readonly Dictionary<byte, Type> NetworkPackets = new();
+        public static readonly Dictionary<byte, Type> ClientToClientPackets = new();
+        public static readonly Dictionary<byte, Type> ServerToClientPackets = new();
         public static void BuildNetworkPacketList() {
             Type[] allClasses = Assembly.GetExecutingAssembly().GetTypes();
             foreach( Type cur in allClasses) {
                 mPacket attribute = cur.GetCustomAttribute<mPacket>(false);
                 if (attribute != null) {
-                    NetworkPackets[attribute.ID] = cur;
+                    if ( attribute.PacketUse.HasFlag(PacketUsage.ClientToClient) ) {
+                        ClientToClientPackets[attribute.ID] = cur;
+                    } else if ( attribute.PacketUse.HasFlag(PacketUsage.ClientToServer) ) {
+                        ServerToClientPackets[attribute.ID] = cur;
+                    }
                 }
             }
         }

MistoxServer/mPacket/PacketAttribute.cs

@@ -5,9 +5,20 @@ namespace Mistox.Attributes {
     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = false, AllowMultiple = false)]
     public sealed class mPacket : Attribute {
         public byte ID { get; }
+        public PacketUsage PacketUse { get; }
         public mPacket(byte id) {
             ID = id;
+            PacketUse = PacketUsage.ClientToClient | PacketUsage.ClientToServer;
+        }
+        public mPacket(byte id, PacketUsage packetUse) {
+            ID = id;
+            PacketUse = packetUse;
         }
     }
 
+    public enum PacketUsage {
+        ClientToClient = 0x01,
+        ClientToServer = 0x10,
+    }
+
 }