More fixes

space-wizards · Sep 25, 2024 · 13ed9c9 · 13ed9c9
1 parent fecfaf4
commit 13ed9c9
Show file tree

Hide file tree

Showing 7 changed files with 66 additions and 44 deletions.
diff --git a/Robust.Shared.Maths/Matrix3Helpers.cs b/Robust.Shared.Maths/Matrix3Helpers.cs
@@ -67,22 +67,13 @@ public static Box2 TransformBox(this Matrix3x2 refFromBox, in Box2 box)
         return Unsafe.As<Vector128<float>, Box2>(ref lbrt);
     }
 
-    /// <summary>
-    /// Gets the position of the Matrix. Will have some precision loss.
-    /// </summary>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector2 Position(this Matrix3x2 t)
-    {
-        return new Vector2(t.M31, t.M32);
-    }
-
     /// <summary>
     /// Gets the rotation of the Matrix. Will have some precision loss.
     /// </summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static Angle Rotation(this Matrix3x2 t)
     {
-        return new Vector2(t.M11, t.M12).ToAngle();
+        return new Angle(Math.Atan2(t.M12, t.M11));
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]

diff --git a/Robust.Shared/Physics/B2DynamicTree.cs b/Robust.Shared/Physics/B2DynamicTree.cs
@@ -969,15 +969,13 @@ internal void RayCastNew(RayCastInput input, long mask, ref WorldRayCastContext
 
 	        var stack = new GrowableStack<Proxy>(stackalloc Proxy[256]);
             ref var baseRef = ref _nodes[0];
-            var stackCount = 1;
 	        stack.Push(_root);
 
 	        var subInput = input;
 
-	        while (stackCount > 0)
+	        while (stack.GetCount() > 0)
             {
                 var nodeId = stack.Pop();
-                stackCount = stack.GetCount();
 
 		        if (nodeId == Proxy.Free)
 		        {
@@ -1025,7 +1023,8 @@ internal void RayCastNew(RayCastInput input, long mask, ref WorldRayCastContext
 			        }
 		        }
 		        else
-		        {
+                {
+                    var stackCount = stack.GetCount();
 			        Assert( stackCount < 256 - 1 );
 			        if (stackCount < 256 - 1 )
 			        {
@@ -1090,13 +1089,11 @@ internal void ShapeCast(ShapeCastInput input, long maskBits, TreeShapeCastCallba
 
             ref var baseRef = ref _nodes[0];
             var stack = new GrowableStack<Proxy>(stackalloc Proxy[256]);
-	        var stackCount = 1;
 	        stack.Push(_root);
 
-	        while (stackCount > 0)
+	        while (stack.GetCount() > 0)
             {
 		        var nodeId = stack.Pop();
-                stackCount = stack.GetCount();
 
 		        if (nodeId == Proxy.Free)
 		        {
@@ -1144,6 +1141,7 @@ internal void ShapeCast(ShapeCastInput input, long maskBits, TreeShapeCastCallba
 		        }
 		        else
 		        {
+                    var stackCount = stack.GetCount();
 			        Assert(stackCount < 256 - 1);
 
 			        if (stackCount < 255)

diff --git a/Robust.Shared/Physics/Systems/RayCastSystem.Geometry.cs b/Robust.Shared/Physics/Systems/RayCastSystem.Geometry.cs
@@ -111,6 +111,11 @@ private static float RayCastCallback(RayCastInput input, FixtureProxy proxy, ref
             return input.MaxFraction;
         }
 
+        if (worldContext.Filter.IsIgnored?.Invoke(proxy.Entity) == true)
+        {
+            return input.MaxFraction;
+        }
+
         var transform = worldContext.Physics.GetLocalPhysicsTransform(proxy.Entity);
         var output = worldContext.System.RayCastShape(input, proxy.Fixture.Shape, transform);
 
@@ -402,6 +407,11 @@ private float ShapeCastCallback(ShapeCastInput input, FixtureProxy proxy, ref Wo
             return input.MaxFraction;
         }
 
+        if (worldContext.Filter.IsIgnored?.Invoke(proxy.Entity) == true)
+        {
+            return input.MaxFraction;
+        }
+
         var transform = worldContext.Physics.GetLocalPhysicsTransform(proxy.Entity);
         var output = ShapeCastShape(input, proxy.Fixture.Shape, transform);
 

diff --git a/Robust.Shared/Physics/Systems/RayCastSystem.cs b/Robust.Shared/Physics/Systems/RayCastSystem.cs
@@ -401,6 +401,11 @@ public record struct QueryFilter
     /// query would accept for collision.
     /// </summary>
     public long MaskBits;
+
+    /// <summary>
+    /// Return whether to ignore an entity.
+    /// </summary>
+    public Func<EntityUid, bool>? IsIgnored;
 }
 
 /// Prototype callback for ray casts.

diff --git a/Robust.UnitTesting/Shared/Maths/Angle_Test.cs b/Robust.UnitTesting/Shared/Maths/Angle_Test.cs
@@ -27,6 +27,14 @@ public sealed class Angle_Test
             (0.92387953251128674f, -0.38268343236508978f, Direction.East, -System.Math.PI / 8.0)
         };
 
+        [Test]
+        public void TestAngleDegrees()
+        {
+            const double degrees = 75d;
+            var angle = Angle.FromDegrees(degrees);
+            Assert.That(angle.Degrees, Is.EqualTo(degrees));
+        }
+
         [Test]
         public void TestAngleZero()
         {

diff --git a/Robust.UnitTesting/Shared/Maths/Matrix3_Test.cs b/Robust.UnitTesting/Shared/Maths/Matrix3_Test.cs
@@ -12,30 +12,17 @@ namespace Robust.UnitTesting.Shared.Maths
     [TestOf(typeof(Matrix3x2))]
     public sealed class Matrix3_Test
     {
-        private static readonly TestCaseData[] Positions = new TestCaseData[]
-        {
-            new(Matrix3x2.Identity, Vector2.Zero),
-            new(Matrix3x2.CreateTranslation(Vector2.One), Vector2.One),
-            new(Matrix3x2.CreateTranslation(new Vector2(1f, 0f)), new Vector2(1f, 0f)),
-        };
-
         private static readonly TestCaseData[] Rotations = new TestCaseData[]
         {
             new(Matrix3x2.Identity, Angle.Zero),
-            new(Matrix3x2.CreateRotation(MathF.PI / 2), new Angle(MathF.PI / 2)),
-            new(Matrix3x2.CreateRotation(MathF.PI), Math.PI),
+            new(Matrix3x2.CreateRotation(MathF.PI / 2f), new Angle(Math.PI / 2)),
+            new(Matrix3x2.CreateRotation(MathF.PI), new Angle(Math.PI)),
         };
 
-        [Test, TestCaseSource(nameof(Positions))]
-        public void GetPositionTest(Matrix3x2 matrix, Vector2 vec)
-        {
-            Assert.That(matrix.Position(), Is.EqualTo(vec));
-        }
-
         [Test, TestCaseSource(nameof(Rotations))]
         public void GetRotationTest(Matrix3x2 matrix, Angle angle)
         {
-            Assert.That(matrix.Rotation(), Is.EqualTo(angle));
+            Assert.That(angle, Is.EqualTo(matrix.Rotation()));
         }
 
         [Test]
@@ -47,7 +34,7 @@ public void TranslationTest()
             var origin = new Vector2(0, 0);
             var result = Vector2.Transform(origin, matrix);
 
-            Assert.That(control == result, Is.True, result.ToString);
+            Assert.That(control, Is.EqualTo(result), result.ToString);
         }
 
         private static readonly IEnumerable<(Vector2, double)> _rotationTests = new[]

diff --git a/Robust.UnitTesting/Shared/Serialization/TypeSerializers/AngleSerializerTest.cs b/Robust.UnitTesting/Shared/Serialization/TypeSerializers/AngleSerializerTest.cs
@@ -1,4 +1,5 @@
-using System.Globalization;
+using System;
+using System.Globalization;
 using NUnit.Framework;
 using Robust.Shared.Maths;
 using Robust.Shared.Serialization.Manager;
@@ -11,24 +12,46 @@ namespace Robust.UnitTesting.Shared.Serialization.TypeSerializers
     [TestOf(typeof(AngleSerializer))]
     public sealed class AngleSerializerTest : SerializationTest
     {
-        [Test]
-        public void SerializationTest()
+        private static readonly TestCaseData[] _source = new[]
         {
-            var degrees = 75d;
-            var angle = Angle.FromDegrees(degrees);
+            new TestCaseData(Math.PI),
+            new TestCaseData(Math.PI / 2),
+            new TestCaseData(Math.PI / 4),
+            new TestCaseData(0.515),
+            new TestCaseData(75),
+        };
+
+        [Test, TestCaseSource(nameof(_source))]
+        public void SerializationRadsTest(double radians)
+        {
+            var angle = new Angle(radians);
             var node = Serialization.WriteValueAs<ValueDataNode>(angle);
-            var serializedValue = $"{MathHelper.DegreesToRadians(degrees).ToString(CultureInfo.InvariantCulture)} rad";
+            var serializedValue = $"{radians.ToString(CultureInfo.InvariantCulture)} rad";
 
             Assert.That(node.Value, Is.EqualTo(serializedValue));
         }
 
-        [Test]
-        public void DeserializationTest()
+        [Test, TestCaseSource(nameof(_source))]
+        public void DeserializationRadsTest(double radians)
         {
-            var degrees = 75;
-            var node = new ValueDataNode(degrees.ToString());
+            var angle = new Angle(radians);
+            var node = new ValueDataNode($"{radians.ToString(CultureInfo.InvariantCulture)} rad");
             var deserializedAngle = Serialization.Read<Angle>(node);
+
+            Assert.That(deserializedAngle, Is.EqualTo(angle));
+        }
+
+        /*
+         * Serialization of degrees test won't work because it's comparing degrees to radians.
+         */
+
+        [Test, TestCaseSource(nameof(_source))]
+        public void DeserializationDegreesTest(double radians)
+        {
+            var degrees = MathHelper.RadiansToDegrees(radians);
             var angle = Angle.FromDegrees(degrees);
+            var node = new ValueDataNode($"{degrees.ToString(CultureInfo.InvariantCulture)}");
+            var deserializedAngle = Serialization.Read<Angle>(node);
 
             Assert.That(deserializedAngle, Is.EqualTo(angle));
         }