Add long serialisation + improve enum serialisation

Author: AlchlcDvl

Reactor/Networking/Extensions/ExtraMessageExtensions.cs

@@ -2,6 +2,7 @@
 using System.Globalization;
 using Hazel;
 using Hazel.Udp;
+using Reactor.Networking.Serialization;
 using UnityEngine;
 
 namespace Reactor.Networking.Extensions;
@@ -38,30 +39,7 @@ public static void Write(this MessageWriter writer, Vector2 value)
     /// </summary>
     /// <param name="writer">The <see cref="MessageWriter"/> to write to.</param>
     /// <param name="value">The <see cref="Enum"/> to write.</param>
-    public static void Write(this MessageWriter writer, Enum value)
-    {
-        var enumType = value.GetType();
-        var underlyingType = enumType.GetEnumUnderlyingType();
-
-        if (underlyingType == typeof(byte))
-            writer.Write(Convert.ToByte(value, NumberFormatInfo.InvariantInfo));
-        else if (underlyingType == typeof(sbyte))
-            writer.Write(Convert.ToSByte(value, NumberFormatInfo.InvariantInfo));
-        else if (underlyingType == typeof(short))
-            writer.Write(Convert.ToInt16(value, NumberFormatInfo.InvariantInfo));
-        else if (underlyingType == typeof(ushort))
-            writer.Write(Convert.ToUInt16(value, NumberFormatInfo.InvariantInfo));
-        else if (underlyingType == typeof(ulong))
-            writer.Write(Convert.ToUInt64(value, NumberFormatInfo.InvariantInfo));
-        else if (underlyingType == typeof(uint))
-            writer.WritePacked(Convert.ToUInt32(value, NumberFormatInfo.InvariantInfo));
-        else if (underlyingType == typeof(int))
-            writer.WritePacked(Convert.ToInt32(value, NumberFormatInfo.InvariantInfo));
-        else if (underlyingType == typeof(long))
-            throw new NotSupportedException("long enum types are not supported at the moment.");
-        else
-            throw new ArgumentException("Unknown underlying type for " + enumType.Name);
-    }
+    public static void Write(this MessageWriter writer, Enum value) => writer.Serialize(Convert.ChangeType(value, Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture));
 
     /// <summary>
     /// Writes a generic Enum value to the <paramref name="writer"/>.
@@ -71,6 +49,14 @@ public static void Write(this MessageWriter writer, Enum value)
     /// <typeparam name="T">Enum type to write.</typeparam>
     public static void Write<T>(this MessageWriter writer, T value) where T : struct, Enum => writer.Write((Enum) value);
 
+    /// <summary>
+    /// Writes a long value to the <paramref name="writer"/>.
+    /// </summary>
+    /// <param name="writer">The <see cref="MessageWriter"/> to write to.</param>
+    /// <param name="value">The <see cref="long"/> to write.</param>
+    public static void Write(this MessageWriter writer, long value) => writer.Write(unchecked(value + long.MaxValue));
+    // Someone please give me a better way to do this that does not involve shifting values please
+
     /// <summary>
     /// Reads a <see cref="Vector2"/> from the <paramref name="reader"/>.
     /// </summary>
@@ -90,74 +76,22 @@ public static Vector2 ReadVector2(this MessageReader reader)
     /// <param name="reader">The <see cref="MessageReader"/> to read from.</param>
     /// <typeparam name="T">The <see cref="Enum"/> type to convert to.</typeparam>
     /// <returns>An <see cref="Enum"/> value from the <paramref name="reader"/>.</returns>
-    public static T ReadEnum<T>(this MessageReader reader) where T : struct, Enum
-    {
-        var enumType = typeof(T);
-        var underlyingType = enumType.GetEnumUnderlyingType();
-
-        if (underlyingType == typeof(byte))
-            return (T) (object) reader.ReadByte();
-
-        if (underlyingType == typeof(sbyte))
-            return (T) (object) reader.ReadSByte();
-
-        if (underlyingType == typeof(short))
-            return (T) (object) reader.ReadInt16();
-
-        if (underlyingType == typeof(ushort))
-            return (T) (object) reader.ReadUInt16();
-
-        if (underlyingType == typeof(ulong))
-            return (T) (object) reader.ReadUInt64();
-
-        if (underlyingType == typeof(uint))
-            return (T) (object) reader.ReadPackedUInt32();
-
-        if (underlyingType == typeof(int))
-            return (T) (object) reader.ReadPackedInt32();
-
-        if (underlyingType == typeof(long))
-            throw new NotSupportedException("long enum types are not supported at the moment.");
-
-        throw new ArgumentException("Unknown underlying type for " + enumType.Name);
-    }
+    public static T ReadEnum<T>(this MessageReader reader) where T : struct, Enum => (T) reader.ReadEnum(typeof(T));
 
     /// <summary>
     /// Reads an enum value from a network message.
     /// </summary>
     /// <param name="reader">The <see cref="MessageReader"/> to read from.</param>
     /// <param name="enumType">The type of the enum.</param>
     /// <returns>The resulting enum value from the <paramref name="reader"/>.</returns>
-    public static object ReadEnum(this MessageReader reader, Type enumType)
-    {
-        var underlyingType = enumType.GetEnumUnderlyingType();
-
-        if (underlyingType == typeof(byte))
-            return Enum.Parse(enumType, $"{reader.ReadByte()}");
-
-        if (underlyingType == typeof(sbyte))
-            return Enum.Parse(enumType, $"{reader.ReadSByte()}");
-
-        if (underlyingType == typeof(short))
-            return Enum.Parse(enumType, $"{reader.ReadInt16()}");
-
-        if (underlyingType == typeof(ushort))
-            return Enum.Parse(enumType, $"{reader.ReadUInt16()}");
-
-        if (underlyingType == typeof(ulong))
-            return Enum.Parse(enumType, $"{reader.ReadUInt64()}");
+    public static object ReadEnum(this MessageReader reader, Type enumType) => reader.Deserialize(Enum.GetUnderlyingType(enumType));
 
-        if (underlyingType == typeof(uint))
-            return Enum.Parse(enumType, $"{reader.ReadPackedUInt32()}");
-
-        if (underlyingType == typeof(int))
-            return Enum.Parse(enumType, $"{reader.ReadPackedInt32()}");
-
-        if (underlyingType == typeof(long))
-            throw new NotSupportedException("long enum types are not supported at the moment.");
-
-        throw new ArgumentException("Unknown underlying type for " + enumType.Name);
-    }
+    /// <summary>
+    /// Reads a long value from a network message.
+    /// </summary>
+    /// <param name="reader">The <see cref="MessageReader"/> to read from.</param>
+    /// <returns>The resulting long value from the <paramref name="reader"/>.</returns>
+    public static long ReadInt64(this MessageReader reader) => (long) unchecked(reader.ReadUInt64() - long.MaxValue);
 
     /// <summary>
     /// Sends a message on the <paramref name="connection"/> with an <paramref name="ackCallback"/>.

Reactor/Networking/Serialization/MessageSerializer.cs

@@ -90,6 +90,9 @@ public static void Serialize(this MessageWriter writer, object @object)
             case ulong i:
                 writer.Write(i);
                 break;
+            case long i:
+                ExtraMessageExtensions.Write(writer, i); // For some reason this insists on referring the to float write method, so this is me taking precautions
+                break;
             case Vector2 i:
                 writer.Write(i);
                 break;
@@ -169,6 +172,11 @@ public static object Deserialize(this MessageReader reader, Type objectType)
             return reader.ReadUInt64();
         }
 
+        if (objectType == typeof(long))
+        {
+            return reader.ReadInt64();
+        }
+
         if (objectType.IsEnum)
         {
             return reader.ReadEnum(objectType);