Asset Dump

Assets/_Project/Tests/EditMode/AimMathTests.cs

@@ -0,0 +1,129 @@
+using NUnit.Framework;
+using ProjectM.Simulation;
+using Unity.Mathematics;
+
+namespace ProjectM.Tests
+{
+    /// <summary>
+    /// Pure unit tests for <see cref="AimMath"/>, the Burst-safe cursor-&gt;ground projection used by the client
+    /// input gather (facing) and the aim-reticle presentation (world point). No camera or ECS world is needed:
+    /// the methods are deterministic functions of a ray, the player position, a plane Y, and a dead-zone, so
+    /// each case constructs a ray and asserts the hit point / normalized planar direction (or that the fallback
+    /// is held on a degenerate ray or inside the dead-zone). Mirrors AutoTargetTests / PlayerSpawnMathTests.
+    /// </summary>
+    public class AimMathTests
+    {
+        const float Tol = 1e-4f;
+        static readonly float2 Fallback = new float2(0f, 1f);
+
+        static void AssertDirEqual(float2 expected, float2 actual, string message)
+        {
+            Assert.AreEqual(expected.x, actual.x, Tol, message + " (x)");
+            Assert.AreEqual(expected.y, actual.y, Tol, message + " (y)");
+        }
+
+        // ---- PlanarAimFromRay (facing direction) ----
+
+        [Test]
+        public void StraightDownRay_AimsFromPlayerToCursorGroundPoint()
+        {
+            var aim = AimMath.PlanarAimFromRay(new float3(5f, 10f, 5f), new float3(0f, -1f, 0f),
+                float3.zero, 0f, Fallback);
+            AssertDirEqual(math.normalize(new float2(5f, 5f)), aim, "down ray");
+        }
+
+        [Test]
+        public void DiagonalNonNormalizedRay_ProjectsToPlaneAndNormalizes()
+        {
+            var aim = AimMath.PlanarAimFromRay(new float3(0f, 10f, 0f), new float3(0.5f, -1f, 0.5f),
+                float3.zero, 0f, Fallback);
+            AssertDirEqual(math.normalize(new float2(5f, 5f)), aim, "diagonal ray");
+        }
+
+        [Test]
+        public void RayParallelToPlane_ReturnsFallback()
+        {
+            var aim = AimMath.PlanarAimFromRay(new float3(0f, 10f, 0f), new float3(1f, 0f, 0f),
+                float3.zero, 0f, Fallback);
+            AssertDirEqual(Fallback, aim, "parallel ray");
+        }
+
+        [Test]
+        public void RayPointingAwayFromPlane_ReturnsFallback()
+        {
+            var aim = AimMath.PlanarAimFromRay(new float3(0f, 10f, 0f), new float3(0f, 1f, 0f),
+                float3.zero, 0f, Fallback);
+            AssertDirEqual(Fallback, aim, "upward ray");
+        }
+
+        [Test]
+        public void CursorOverPlayer_ReturnsFallback()
+        {
+            var aim = AimMath.PlanarAimFromRay(new float3(0f, 10f, 0f), new float3(0f, -1f, 0f),
+                float3.zero, 0f, Fallback);
+            AssertDirEqual(Fallback, aim, "cursor over player");
+        }
+
+        [Test]
+        public void ValidHit_ResultIsUnitLength()
+        {
+            var aim = AimMath.PlanarAimFromRay(new float3(-3f, 8f, 2f), new float3(0.2f, -1f, -0.4f),
+                new float3(1f, 0f, 1f), 0f, Fallback);
+            Assert.AreEqual(1f, math.length(aim), Tol, "unit length");
+        }
+
+        [Test]
+        public void NonZeroPlaneY_UsesPlayerPlane()
+        {
+            var aim = AimMath.PlanarAimFromRay(new float3(2f, 11f, 0f), new float3(0f, -1f, 0f),
+                new float3(0f, 1f, 0f), 1f, Fallback);
+            AssertDirEqual(new float2(1f, 0f), aim, "plane y=1");
+        }
+
+        // ---- dead-zone (hold facing when the cursor is near the player) ----
+
+        [Test]
+        public void HitWithinDeadZone_HoldsFallback()
+        {
+            // Cursor ground point 0.4u from the player; dead-zone 0.6u => facing is held (fallback).
+            var aim = AimMath.PlanarAimFromRay(new float3(0.4f, 10f, 0f), new float3(0f, -1f, 0f),
+                float3.zero, 0f, Fallback, 0.6f);
+            AssertDirEqual(Fallback, aim, "inside dead-zone");
+        }
+
+        [Test]
+        public void HitOutsideDeadZone_PointsAtCursor()
+        {
+            // Cursor ground point 2u along +X; dead-zone 0.6u => faces +X (distinct from the +Z fallback).
+            var aim = AimMath.PlanarAimFromRay(new float3(2f, 10f, 0f), new float3(0f, -1f, 0f),
+                float3.zero, 0f, Fallback, 0.6f);
+            AssertDirEqual(new float2(1f, 0f), aim, "outside dead-zone");
+        }
+
+        // ---- TryGroundHit (world ground point) ----
+
+        [Test]
+        public void TryGroundHit_StraightDownRay_ReturnsPlanePoint()
+        {
+            bool ok = AimMath.TryGroundHit(new float3(5f, 10f, 5f), new float3(0f, -1f, 0f), 0f, out var hit);
+            Assert.IsTrue(ok, "should hit");
+            Assert.AreEqual(5f, hit.x, Tol, "hit.x");
+            Assert.AreEqual(0f, hit.y, Tol, "hit.y");
+            Assert.AreEqual(5f, hit.z, Tol, "hit.z");
+        }
+
+        [Test]
+        public void TryGroundHit_ParallelRay_ReturnsFalse()
+        {
+            bool ok = AimMath.TryGroundHit(new float3(0f, 10f, 0f), new float3(1f, 0f, 0f), 0f, out _);
+            Assert.IsFalse(ok, "parallel never hits");
+        }
+
+        [Test]
+        public void TryGroundHit_RayAwayFromPlane_ReturnsFalse()
+        {
+            bool ok = AimMath.TryGroundHit(new float3(0f, 10f, 0f), new float3(0f, 1f, 0f), 0f, out _);
+            Assert.IsFalse(ok, "t<0 behind ray");
+        }
+    }
+}

Assets/_Project/Tests/EditMode/AimMathTests.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 0959dfbb85b08464e8e8c83730b5d74a