feat: add RcVec2i and RcVec3i structs with unit tests

- Added integer-based 2D and 3D vector types.
- Implemented operator overloading and equality members.
- Included comprehensive unit tests for both types.

Author: ikpil

src/DotRecast.Core/Numerics/RcVec2i.cs

@@ -0,0 +1,64 @@
+using System;
+
+namespace DotRecast.Core.Numerics
+{
+    public struct RcVec2i : IEquatable<RcVec2i>
+    {
+        public int X;
+        public int Y;
+
+        public static RcVec2i Zero => new RcVec2i(0, 0);
+        public static RcVec2i UnitX => new RcVec2i(1, 0);
+        public static RcVec2i UnitY => new RcVec2i(0, 1);
+
+        // Comparison Operators
+        public static bool operator ==(RcVec2i left, RcVec2i right) => left.Equals(right);
+        public static bool operator !=(RcVec2i left, RcVec2i right) => !left.Equals(right);
+
+        // Arithmetic Operators
+        public static RcVec2i operator +(RcVec2i a, RcVec2i b) => new RcVec2i(a.X + b.X, a.Y + b.Y);
+        public static RcVec2i operator -(RcVec2i a, RcVec2i b) => new RcVec2i(a.X - b.X, a.Y - b.Y);
+        public static RcVec2i operator *(RcVec2i a, int scalar) => new RcVec2i(a.X * scalar, a.Y * scalar);
+
+        public RcVec2i(int x, int y)
+        {
+            X = x;
+            Y = y;
+        }
+
+        public int this[int index]
+        {
+            get
+            {
+                return index switch
+                {
+                    0 => X,
+                    1 => Y,
+                    _ => throw new IndexOutOfRangeException()
+                };
+            }
+        }
+
+
+        public bool Equals(RcVec2i other)
+        {
+            return X == other.X && Y == other.Y;
+        }
+
+        public override bool Equals(object? obj)
+        {
+            return obj is RcVec2i other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(X, Y);
+        }
+
+        public override string ToString()
+        {
+            return $"({X}, {Y})";
+        }
+    }
+
+}

src/DotRecast.Core/Numerics/RcVec3i.cs

@@ -1,9 +1,67 @@
-namespace DotRecast.Core.Numerics
+using System;
+
+namespace DotRecast.Core.Numerics
 {
-    public struct RcVec3i
+    public struct RcVec3i : IEquatable<RcVec3i>
     {
         public int X;
         public int Y;
         public int Z;
+
+        public static RcVec3i Zero => new RcVec3i(0, 0, 0);
+        public static RcVec3i UnitX => new RcVec3i(1, 0, 0);
+        public static RcVec3i UnitY => new RcVec3i(0, 1, 0);
+        public static RcVec3i UnitZ => new RcVec3i(0, 1, 1);
+
+        // Comparison Operators
+        public static bool operator ==(RcVec3i left, RcVec3i right) => left.Equals(right);
+        public static bool operator !=(RcVec3i left, RcVec3i right) => !left.Equals(right);
+
+        // Arithmetic Operators
+        public static RcVec3i operator +(RcVec3i a, RcVec3i b) => new RcVec3i(a.X + b.X, a.Y + b.Y, a.Z + b.Z);
+        public static RcVec3i operator -(RcVec3i a, RcVec3i b) => new RcVec3i(a.X - b.X, a.Y - b.Y, a.Z - b.Z);
+        public static RcVec3i operator *(RcVec3i a, int scalar) => new RcVec3i(a.X * scalar, a.Y * scalar, a.Z * scalar);
+
+        public RcVec3i(int x, int y, int z)
+        {
+            X = x;
+            Y = y;
+            Z = z;
+        }
+
+        public int this[int index]
+        {
+            get
+            {
+                return index switch
+                {
+                    0 => X,
+                    1 => Y,
+                    2 => Z,
+                    _ => throw new IndexOutOfRangeException()
+                };
+            }
+        }
+
+
+        public bool Equals(RcVec3i other)
+        {
+            return X == other.X && Y == other.Y && Z == other.Z;
+        }
+
+        public override bool Equals(object? obj) // null 허용 확인
+        {
+            return obj is RcVec3i other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(X, Y, Z);
+        }
+
+        public override string ToString()
+        {
+            return $"({X}, {Y}, {Z})";
+        }
     }
 }

test/DotRecast.Core.Test/RcVec2iTest.cs

@@ -0,0 +1,75 @@
+using System;
+using DotRecast.Core.Numerics;
+using NUnit.Framework;
+
+namespace DotRecast.Core.Test;
+
+public class RcVec2iTest
+{
+    [Test]
+    [Repeat(100000)]
+    public void TestEquals()
+    {
+        var x = Random.Shared.Next();
+        var y = Random.Shared.Next();
+
+        var v1 = new RcVec2i(x, y);
+        var v2 = new RcVec2i(x, y);
+        var v3 = new RcVec2i(x + 1, y);
+
+        Assert.That(v1, Is.EqualTo(v2));
+        Assert.That(v1 == v2, Is.True);
+        Assert.That(v1 != v3, Is.True);
+        Assert.That(v1.Equals(v2), Is.True);
+        Assert.That(v1.Equals((object)v2), Is.True);
+        Assert.That(v1.GetHashCode(), Is.EqualTo(v2.GetHashCode()));
+    }
+
+    [Test]
+    [Repeat(100000)]
+    public void TestArithmetic()
+    {
+        var v1 = new RcVec2i(Random.Shared.Next(1000), Random.Shared.Next(1000));
+        var v2 = new RcVec2i(Random.Shared.Next(1000), Random.Shared.Next(1000));
+        var scalar = Random.Shared.Next(100);
+
+        // Add
+        var vAdd = v1 + v2;
+        Assert.That(vAdd.X, Is.EqualTo(v1.X + v2.X));
+        Assert.That(vAdd.Y, Is.EqualTo(v1.Y + v2.Y));
+
+        // Subtract
+        var vSub = v1 - v2;
+        Assert.That(vSub.X, Is.EqualTo(v1.X - v2.X));
+        Assert.That(vSub.Y, Is.EqualTo(v1.Y - v2.Y));
+
+        // Multiply
+        var vMul = v1 * scalar;
+        Assert.That(vMul.X, Is.EqualTo(v1.X * scalar));
+        Assert.That(vMul.Y, Is.EqualTo(v1.Y * scalar));
+    }
+
+    [Test]
+    public void TestIndexer()
+    {
+        var v = new RcVec2i(1, 2);
+        Assert.That(v[0], Is.EqualTo(1));
+        Assert.That(v[1], Is.EqualTo(2));
+        Assert.Throws<IndexOutOfRangeException>(() => { var _ = v[2]; });
+    }
+
+    [Test]
+    public void TestToString()
+    {
+        var v = new RcVec2i(1, 2);
+        Assert.That(v.ToString(), Is.EqualTo("(1, 2)"));
+    }
+
+    [Test]
+    public void TestStaticProperties()
+    {
+        Assert.That(RcVec2i.Zero, Is.EqualTo(new RcVec2i(0, 0)));
+        Assert.That(RcVec2i.UnitX, Is.EqualTo(new RcVec2i(1, 0)));
+        Assert.That(RcVec2i.UnitY, Is.EqualTo(new RcVec2i(0, 1)));
+    }
+}

test/DotRecast.Core.Test/RcVec3iTest.cs

@@ -0,0 +1,81 @@
+using System;
+using DotRecast.Core.Numerics;
+using NUnit.Framework;
+
+namespace DotRecast.Core.Test;
+
+public class RcVec3iTest
+{
+    [Test]
+    [Repeat(100000)]
+    public void TestEquals()
+    {
+        var x = Random.Shared.Next();
+        var y = Random.Shared.Next();
+        var z = Random.Shared.Next();
+
+        var v1 = new RcVec3i(x, y, z);
+        var v2 = new RcVec3i(x, y, z);
+        var v3 = new RcVec3i(x + 1, y, z);
+
+        Assert.That(v1, Is.EqualTo(v2));
+        Assert.That(v1 == v2, Is.True);
+        Assert.That(v1 != v3, Is.True);
+        Assert.That(v1.Equals(v2), Is.True);
+        Assert.That(v1.Equals((object)v2), Is.True);
+        Assert.That(v1.GetHashCode(), Is.EqualTo(v2.GetHashCode()));
+    }
+
+    [Test]
+    [Repeat(100000)]
+    public void TestArithmetic()
+    {
+        var v1 = new RcVec3i(Random.Shared.Next(1000), Random.Shared.Next(1000), Random.Shared.Next(1000));
+        var v2 = new RcVec3i(Random.Shared.Next(1000), Random.Shared.Next(1000), Random.Shared.Next(1000));
+        var scalar = Random.Shared.Next(100);
+
+        // Add
+        var vAdd = v1 + v2;
+        Assert.That(vAdd.X, Is.EqualTo(v1.X + v2.X));
+        Assert.That(vAdd.Y, Is.EqualTo(v1.Y + v2.Y));
+        Assert.That(vAdd.Z, Is.EqualTo(v1.Z + v2.Z));
+
+        // Subtract
+        var vSub = v1 - v2;
+        Assert.That(vSub.X, Is.EqualTo(v1.X - v2.X));
+        Assert.That(vSub.Y, Is.EqualTo(v1.Y - v2.Y));
+        Assert.That(vSub.Z, Is.EqualTo(v1.Z - v2.Z));
+
+        // Multiply
+        var vMul = v1 * scalar;
+        Assert.That(vMul.X, Is.EqualTo(v1.X * scalar));
+        Assert.That(vMul.Y, Is.EqualTo(v1.Y * scalar));
+        Assert.That(vMul.Z, Is.EqualTo(v1.Z * scalar));
+    }
+
+    [Test]
+    public void TestIndexer()
+    {
+        var v = new RcVec3i(1, 2, 3);
+        Assert.That(v[0], Is.EqualTo(1));
+        Assert.That(v[1], Is.EqualTo(2));
+        Assert.That(v[2], Is.EqualTo(3));
+        Assert.Throws<IndexOutOfRangeException>(() => { var _ = v[3]; });
+    }
+
+    [Test]
+    public void TestToString()
+    {
+        var v = new RcVec3i(1, 2, 3);
+        Assert.That(v.ToString(), Is.EqualTo("(1, 2, 3)"));
+    }
+
+    [Test]
+    public void TestStaticProperties()
+    {
+        Assert.That(RcVec3i.Zero, Is.EqualTo(new RcVec3i(0, 0, 0)));
+        Assert.That(RcVec3i.UnitX, Is.EqualTo(new RcVec3i(1, 0, 0)));
+        Assert.That(RcVec3i.UnitY, Is.EqualTo(new RcVec3i(0, 1, 0)));
+        Assert.That(RcVec3i.UnitZ, Is.EqualTo(new RcVec3i(0, 1, 1)));
+    }
+}