fix: Adds ISpanFormattable to Geometry structs (#1231)

* Adds ISpanFormattable to geometry structs and makes ToString() near-zero-allocation.
* Adds IEquatable, and Parsable to Rectangle3D to get it in-line with the other structs.

Closes #1067

Projects/Server.Tests/Tests/Geometry/Point2DTests.cs

@@ -1,17 +1,68 @@
 using System;
 using Xunit;
 
-namespace Server.Tests
+namespace Server.Tests;
+
+public class Point2DTests
 {
-    public class Point2DTests
+    [Fact]
+    public void TestPoint2DToString()
     {
-        [Fact]
-        public void TestToString()
-        {
-            Assert.Equal("(0, 0)", new Point2D(0, 0).ToString());
-            Assert.Equal("(1, 1)", new Point2D(1, 1).ToString());
-            Assert.Equal($"({Int32.MaxValue}, {Int32.MaxValue})", new Point2D(Int32.MaxValue, Int32.MaxValue).ToString());
-            Assert.Equal($"({Int32.MinValue}, {Int32.MinValue})", new Point2D(Int32.MinValue, Int32.MinValue).ToString());
-        }
+        Assert.Equal("(0, 0)", new Point2D(0, 0).ToString());
+        Assert.Equal("(1, 1)", new Point2D(1, 1).ToString());
+        Assert.Equal($"({int.MaxValue}, {int.MaxValue})", new Point2D(int.MaxValue, int.MaxValue).ToString());
+        Assert.Equal($"({int.MinValue}, {int.MaxValue})", new Point2D(int.MinValue, int.MaxValue).ToString());
+        Assert.Equal($"({int.MinValue}, {int.MinValue})", new Point2D(int.MinValue, int.MinValue).ToString());
+        Assert.Equal($"({int.MaxValue}, {int.MinValue})", new Point2D(int.MaxValue, int.MinValue).ToString());
+    }
+
+    [Fact]
+    public void TestPoint2DTryFormatSucceeds()
+    {
+        char[] array = new char[128];
+
+        var p1 = new Point2D(0, 0);
+        Assert.True(p1.TryFormat(array, out var cp1, null, null));
+        Assert.Equal(6, cp1);
+        Array.Clear(array);
+
+        var p2 = new Point2D(1, 1);
+        Assert.True(p2.TryFormat(array, out var cp2, null, null));
+        Assert.Equal(6, cp2);
+        Array.Clear(array);
+
+        var p3 = new Point2D(int.MaxValue, int.MaxValue);
+        Assert.True(p3.TryFormat(array, out var cp3, null, null));
+        Assert.Equal(4 + 20, cp3);
+        Array.Clear(array);
+
+        var p4 = new Point2D(int.MinValue, int.MinValue);
+        Assert.True(p4.TryFormat(array, out var cp4, null, null));
+        Assert.Equal(4 + 22, cp4);
+    }
+
+    [Fact]
+    public void TestPoint2DTryFormatFails()
+    {
+        char[] array = new char[1];
+
+        var p1 = new Point2D(0, 0);
+        Assert.False(p1.TryFormat(array, out var cp1, null, null));
+        Assert.Equal(0, cp1);
+        Array.Clear(array);
+
+        var p2 = new Point2D(1, 1);
+        Assert.False(p2.TryFormat(array, out var cp2, null, null));
+        Assert.Equal(0, cp2);
+        Array.Clear(array);
+
+        var p3 = new Point2D(int.MaxValue, int.MaxValue);
+        Assert.False(p3.TryFormat(array, out var cp3, null, null));
+        Assert.Equal(0, cp3);
+        Array.Clear(array);
+
+        var p4 = new Point2D(int.MinValue, int.MinValue);
+        Assert.False(p4.TryFormat(array, out var cp4, null, null));
+        Assert.Equal(0, cp4);
     }
 }

Projects/Server.Tests/Tests/Geometry/Point3DTests.cs

@@ -0,0 +1,72 @@
+using System;
+using Xunit;
+
+namespace Server.Tests;
+
+public class Point3DTests
+{
+    [Fact]
+    public void TestPoint3DToString()
+    {
+        const int max = int.MaxValue;
+        const int min = int.MinValue;
+        Assert.Equal("(0, 0, 0)", new Point3D(0, 0, 0).ToString());
+        Assert.Equal("(1, 1, 1)", new Point3D(1, 1, 1).ToString());
+        Assert.Equal($"({max}, {max}, {max})", new Point3D(max, max, max).ToString());
+        Assert.Equal($"({min}, {min}, {min})", new Point3D(min, min, min).ToString());
+    }
+
+    [Fact]
+    public void TestPoint3DTryFormatSucceeds()
+    {
+        const int max = int.MaxValue;
+        const int min = int.MinValue;
+        char[] array = new char[128];
+
+        var p1 = new Point3D(0, 0, 0);
+        Assert.True(p1.TryFormat(array, out var cp1, null, null));
+        Assert.Equal(6 + 3, cp1);
+        Array.Clear(array);
+
+        var p2 = new Point3D(1, 1, 1);
+        Assert.True(p2.TryFormat(array, out var cp2, null, null));
+        Assert.Equal(6 + 3, cp2);
+        Array.Clear(array);
+
+        var p3 = new Point3D(max, max, max);
+        Assert.True(p3.TryFormat(array, out var cp3, null, null));
+        Assert.Equal(6 + 30, cp3);
+        Array.Clear(array);
+
+        var p4 = new Point3D(min, min, min);
+        Assert.True(p4.TryFormat(array, out var cp4, null, null));
+        Assert.Equal(6 + 33, cp4);
+    }
+
+    [Fact]
+    public void TestPoint3DTryFormatFails()
+    {
+        const int max = int.MaxValue;
+        const int min = int.MinValue;
+        char[] array = new char[1];
+
+        var p1 = new Point3D(0, 0, 0);
+        Assert.False(p1.TryFormat(array, out var cp1, null, null));
+        Assert.Equal(0, cp1);
+        Array.Clear(array);
+
+        var p2 = new Point3D(1, 1, 1);
+        Assert.False(p2.TryFormat(array, out var cp2, null, null));
+        Assert.Equal(0, cp2);
+        Array.Clear(array);
+
+        var p3 = new Point3D(max, max, max);
+        Assert.False(p3.TryFormat(array, out var cp3, null, null));
+        Assert.Equal(0, cp3);
+        Array.Clear(array);
+
+        var p4 = new Point3D(min, min, min);
+        Assert.False(p4.TryFormat(array, out var cp4, null, null));
+        Assert.Equal(0, cp4);
+    }
+}

Projects/Server.Tests/Tests/Geometry/Rectangle2DTests.cs

@@ -0,0 +1,72 @@
+using System;
+using Xunit;
+
+namespace Server.Tests;
+
+public class Rectangle2DTests
+{
+    [Fact]
+    public void TestRectangle2DToString()
+    {
+        const int max = int.MaxValue;
+        const int min = int.MinValue;
+        Assert.Equal("(0, 0)+(0, 0)", new Rectangle2D(0, 0, 0, 0).ToString());
+        Assert.Equal("(1, 1)+(1, 1)", new Rectangle2D(1, 1, 1, 1).ToString());
+        Assert.Equal($"({max}, {max})+({max}, {max})", new Rectangle2D(max, max, max, max).ToString());
+        Assert.Equal($"({min}, {min})+({min}, {min})", new Rectangle2D(min, min, min, min).ToString());
+    }
+
+    [Fact]
+    public void TestRectangle2DTryFormatSucceeds()
+    {
+        const int max = int.MaxValue;
+        const int min = int.MinValue;
+        char[] array = new char[128];
+
+        var p1 = new Rectangle2D(0, 0, 0, 0);
+        Assert.True(p1.TryFormat(array, out var cp1, null, null));
+        Assert.Equal(9 + 4, cp1);
+        Array.Clear(array);
+
+        var p2 = new Rectangle2D(1, 1, 1, 1);
+        Assert.True(p2.TryFormat(array, out var cp2, null, null));
+        Assert.Equal(9 + 4, cp2);
+        Array.Clear(array);
+
+        var p3 = new Rectangle2D(max, max, max, max);
+        Assert.True(p3.TryFormat(array, out var cp3, null, null));
+        Assert.Equal(9 + 4 * 10, cp3);
+        Array.Clear(array);
+
+        var p4 = new Rectangle2D(min, min, min, min);
+        Assert.True(p4.TryFormat(array, out var cp4, null, null));
+        Assert.Equal(9 + 4 * 11, cp4);
+    }
+
+    [Fact]
+    public void TestRectangle2DTryFormatFails()
+    {
+        const int max = int.MaxValue;
+        const int min = int.MinValue;
+        char[] array = new char[1];
+
+        var p1 = new Rectangle2D(0, 0, 0, 0);
+        Assert.False(p1.TryFormat(array, out var cp1, null, null));
+        Assert.Equal(0, cp1);
+        Array.Clear(array);
+
+        var p2 = new Rectangle2D(1, 1, 1, 1);
+        Assert.False(p2.TryFormat(array, out var cp2, null, null));
+        Assert.Equal(0, cp2);
+        Array.Clear(array);
+
+        var p3 = new Rectangle2D(max, max, max, max);
+        Assert.False(p3.TryFormat(array, out var cp3, null, null));
+        Assert.Equal(0, cp3);
+        Array.Clear(array);
+
+        var p4 = new Rectangle2D(min, min, min, min);
+        Assert.False(p4.TryFormat(array, out var cp4, null, null));
+        Assert.Equal(0, cp4);
+    }
+}

Projects/Server.Tests/Tests/Geometry/Rectangle3DTests.cs

@@ -0,0 +1,72 @@
+using System;
+using Xunit;
+
+namespace Server.Tests;
+
+public class Rectangle3DTests
+{
+    [Fact]
+    public void TestRectangle3DToString()
+    {
+        const int max = int.MaxValue;
+        const int min = int.MinValue;
+        Assert.Equal("(0, 0, 0)+(0, 0, 0)", new Rectangle3D(0, 0, 0, 0, 0, 0).ToString());
+        Assert.Equal("(1, 1, 1)+(1, 1, 1)", new Rectangle3D(1, 1, 1, 1, 1, 1).ToString());
+        Assert.Equal($"({max}, {max}, {max})+({max}, {max}, {max})", new Rectangle3D(max, max, max, max, max, max).ToString());
+        Assert.Equal($"({min}, {min}, {min})+({min}, {min}, {min})", new Rectangle3D(min, min, min, min, min, min).ToString());
+    }
+
+    [Fact]
+    public void TestRectangle3DTryFormatSucceeds()
+    {
+        const int max = int.MaxValue;
+        const int min = int.MinValue;
+        char[] array = new char[128];
+
+        var p1 = new Rectangle3D(0, 0, 0, 0, 0, 0);
+        Assert.True(p1.TryFormat(array, out var cp1, null, null));
+        Assert.Equal(13 + 6, cp1);
+        Array.Clear(array);
+
+        var p2 = new Rectangle3D(1, 1, 1, 1, 1, 1);
+        Assert.True(p2.TryFormat(array, out var cp2, null, null));
+        Assert.Equal(13 + 6, cp2);
+        Array.Clear(array);
+
+        var p3 = new Rectangle3D(max, max, max, max, max, max);
+        Assert.True(p3.TryFormat(array, out var cp3, null, null));
+        Assert.Equal(13 + 6 * 10, cp3);
+        Array.Clear(array);
+
+        var p4 = new Rectangle3D(min, min, min, min, min, min);
+        Assert.True(p4.TryFormat(array, out var cp4, null, null));
+        Assert.Equal(13 + 6 * 11, cp4);
+    }
+
+    [Fact]
+    public void TestRectangle3DTryFormatFails()
+    {
+        const int max = int.MaxValue;
+        const int min = int.MinValue;
+        char[] array = new char[1];
+
+        var p1 = new Rectangle3D(0, 0, 0, 0, 0, 0);
+        Assert.False(p1.TryFormat(array, out var cp1, null, null));
+        Assert.Equal(0, cp1);
+        Array.Clear(array);
+
+        var p2 = new Rectangle3D(1, 1, 1, 1, 1, 1);
+        Assert.False(p2.TryFormat(array, out var cp2, null, null));
+        Assert.Equal(0, cp2);
+        Array.Clear(array);
+
+        var p3 = new Rectangle3D(max, max, max, max, max, max);
+        Assert.False(p3.TryFormat(array, out var cp3, null, null));
+        Assert.Equal(0, cp3);
+        Array.Clear(array);
+
+        var p4 = new Rectangle3D(min, min, min, min, min, min);
+        Assert.False(p4.TryFormat(array, out var cp4, null, null));
+        Assert.Equal(0, cp4);
+    }
+}

Projects/Server.Tests/Tests/Geometry/WorldLocationTests.cs

@@ -0,0 +1,105 @@
+using System;
+using Xunit;
+
+namespace Server.Tests;
+
+public sealed class WorldLocationTests
+{
+    private static Map CreateMap(string name) => new(0, 0, 0, 1, 1, 0, name, MapRules.Internal);
+
+    private const string _nullMap = "(-null-)";
+
+    private const string _superLongMapName =
+        "Some super long map name that nobody should be using, but probably someone will just because you can!";
+
+    [Fact]
+    public void TestWorldLocationToString()
+    {
+        const string mapName = "Internal Map";
+        var map = CreateMap(mapName);
+
+        const int max = int.MaxValue;
+        const int min = int.MinValue;
+        Assert.Equal($"(0, 0, 0) [{mapName}]", new WorldLocation(0, 0, 0, map).ToString());
+        Assert.Equal($"(1, 1, 1) [{mapName}]", new WorldLocation(1, 1, 1, map).ToString());
+
+        Assert.Equal($"(0, 0, 0) [{_nullMap}]", new WorldLocation(0, 0, 0, null).ToString());
+        Assert.Equal($"(1, 1, 1) [{_nullMap}]", new WorldLocation(1, 1, 1, null).ToString());
+
+        Assert.Equal($"({max}, {max}, {max}) [{mapName}]", new WorldLocation(max, max, max, map).ToString());
+        Assert.Equal($"({min}, {min}, {min}) [{mapName}]", new WorldLocation(min, min, min, map).ToString());
+
+        Assert.Equal($"({max}, {max}, {max}) [{_nullMap}]", new WorldLocation(max, max, max, null).ToString());
+        Assert.Equal($"({min}, {min}, {min}) [{_nullMap}]", new WorldLocation(min, min, min, null).ToString());
+
+        map = CreateMap(_superLongMapName);
+
+        Assert.Equal($"({max}, {max}, {max}) [{_superLongMapName}]", new WorldLocation(max, max, max, map).ToString());
+        Assert.Equal($"({min}, {min}, {min}) [{_superLongMapName}]", new WorldLocation(min, min, min, map).ToString());
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("Internal Map")]
+    [InlineData(_superLongMapName)]
+    public void TestWorldLocationTryFormatSucceeds(string mapName)
+    {
+        var map = mapName != null ? CreateMap(mapName) : null;
+        var mapNameLength = mapName?.Length ?? _nullMap.Length;
+
+        const int max = int.MaxValue;
+        const int min = int.MinValue;
+        char[] array = new char[128];
+
+        var p1 = new WorldLocation(0, 0, 0, map);
+        Assert.True(p1.TryFormat(array, out var cp1, null, null));
+        Assert.Equal(9 + 3 + mapNameLength, cp1);
+        Array.Clear(array);
+
+        var p2 = new WorldLocation(1, 1, 1, map);
+        Assert.True(p2.TryFormat(array, out var cp2, null, null));
+        Assert.Equal(9 + 3 + mapNameLength, cp2);
+        Array.Clear(array);
+
+        array = new char[256]; // We need a bigger buffer!
+        var p3 = new WorldLocation(max, max, max, map);
+        Assert.True(p3.TryFormat(array, out var cp3, null, null));
+        Assert.Equal(9 + 30 + mapNameLength, cp3);
+        Array.Clear(array);
+
+        var p4 = new WorldLocation(min, min, min, map);
+        Assert.True(p4.TryFormat(array, out var cp4, null, null));
+        Assert.Equal(9 + 33 + mapNameLength, cp4);
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("Internal Map")]
+    public void TestWorldLocationTryFormatFails(string mapName)
+    {
+        var map = mapName != null ? CreateMap(mapName) : null;
+
+        const int max = int.MaxValue;
+        const int min = int.MinValue;
+        char[] array = new char[1];
+
+        var p1 = new WorldLocation(0, 0, 0, map);
+        Assert.False(p1.TryFormat(array, out var cp1, null, null));
+        Assert.Equal(0, cp1);
+        Array.Clear(array);
+
+        var p2 = new WorldLocation(1, 1, 1, map);
+        Assert.False(p2.TryFormat(array, out var cp2, null, null));
+        Assert.Equal(0, cp2);
+        Array.Clear(array);
+
+        var p3 = new WorldLocation(max, max, max, map);
+        Assert.False(p3.TryFormat(array, out var cp3, null, null));
+        Assert.Equal(0, cp3);
+        Array.Clear(array);
+
+        var p4 = new WorldLocation(min, min, min, map);
+        Assert.False(p4.TryFormat(array, out var cp4, null, null));
+        Assert.Equal(0, cp4);
+    }
+}