Project-M/Assets/_Project/Tests/EditMode/EnemyAIMathTests.cs

using NUnit.Framework;
using ProjectM.Simulation;
using Unity.Mathematics;
using Unity.Collections;

namespace ProjectM.Tests
{
    /// <summary>
    /// Pure-function tests for <see cref="EnemyAIMath"/> (no ECS world), mirroring PlayerSpawnRingTests /
    /// StatMathTests. Pins the deterministic Husk seek / strike / spawn-ring math the server AI relies on.
    /// </summary>
    public class EnemyAIMathTests
    {
        const float Eps = 1e-4f;

        [Test]
        public void SeekVelocity_MovesTowardTarget_AtSpeed()
        {
            var v = EnemyAIMath.SeekVelocity(new float3(0, 1, 0), new float3(10, 1, 0), 4f, 0.5f);
            Assert.AreEqual(4f, math.length(v), Eps);
            Assert.Greater(v.x, 0f);
            Assert.AreEqual(0f, v.y, Eps);
            Assert.AreEqual(0f, v.z, Eps);
        }

        [Test]
        public void SeekVelocity_IgnoresVerticalSeparation()
        {
            // Target directly above (same XZ) is within stop distance on the plane -> no movement.
            var v = EnemyAIMath.SeekVelocity(new float3(0, 0, 0), new float3(0, 50, 0), 4f, 0.5f);
            Assert.AreEqual(0f, math.length(v), Eps);
        }

        [Test]
        public void SeekVelocity_ZeroWithinStopDistance()
        {
            var v = EnemyAIMath.SeekVelocity(new float3(0, 1, 0), new float3(0.3f, 1, 0), 4f, 0.5f);
            Assert.AreEqual(0f, math.length(v), Eps);
        }

        [Test]
        public void InAttackRange_TrueInside_FalseOutside()
        {
            Assert.IsTrue(EnemyAIMath.InAttackRange(new float3(0, 1, 0), new float3(1.0f, 1, 0), 1.5f));
            Assert.IsFalse(EnemyAIMath.InAttackRange(new float3(0, 1, 0), new float3(2.0f, 1, 0), 1.5f));
        }

        [Test]
        public void InAttackRange_IgnoresVertical()
        {
            // Same XZ, large Y gap -> still in range on the plane.
            Assert.IsTrue(EnemyAIMath.InAttackRange(new float3(0, 0, 0), new float3(0, 99, 0), 1.5f));
        }

        [Test]
        public void RingPosition_OnRadius_AroundCenter()
        {
            var center = new float3(5, 1, -3);
            var p = EnemyAIMath.RingPosition(center, 0, 8, 6f);
            var d = p - center;
            Assert.AreEqual(6f, math.length(new float2(d.x, d.z)), Eps); // planar distance == radius
            Assert.AreEqual(center.y, p.y, Eps);                          // stays on the plane
            // index 0, slots 8 -> angle 0 -> offset (+radius, 0, 0)
            Assert.AreEqual(center.x + 6f, p.x, Eps);
            Assert.AreEqual(center.z, p.z, Eps);
        }

        [Test]
        public void RingPosition_Deterministic_And_Distinct()
        {
            var c = float3.zero;
            var a = EnemyAIMath.RingPosition(c, 1, 8, 4f);
            var b = EnemyAIMath.RingPosition(c, 1, 8, 4f);
            Assert.AreEqual(a.x, b.x, Eps);
            Assert.AreEqual(a.z, b.z, Eps);
            var other = EnemyAIMath.RingPosition(c, 2, 8, 4f);
            Assert.Greater(math.distance(a, other), 1e-3f);
        }

        [Test]
        public void SlideVelocity_RemovesIntoWallComponent()
        {
            // Moving +X into a wall whose normal is -X (facing the mover): the into-wall component is removed.
            var slid = EnemyAIMath.SlideVelocity(new float3(4, 0, 0), new float3(-1, 0, 0));
            Assert.AreEqual(0f, math.length(slid), Eps);
        }

        [Test]
        public void SlideVelocity_KeepsParallelComponent()
        {
            // Moving diagonally into a wall with normal -X: the +X part is clipped, the +Z part survives.
            var slid = EnemyAIMath.SlideVelocity(new float3(3, 0, 5), new float3(-1, 0, 0));
            Assert.AreEqual(0f, slid.x, Eps);
            Assert.AreEqual(5f, slid.z, Eps);
            Assert.AreEqual(0f, slid.y, Eps);
        }

        [Test]
        public void SlideVelocity_FlattensNormalToPlane()
        {
            // A normal with a Y tilt is flattened to XZ before projecting, so vertical tilt never leaks in.
            var slid = EnemyAIMath.SlideVelocity(new float3(2, 0, 0), new float3(-1, 5, 0));
            Assert.AreEqual(0f, slid.x, Eps);
            Assert.AreEqual(0f, slid.y, Eps);
        }

        [Test]
        public void SlideVelocity_DegenerateNormal_ReturnsInput()
        {
            var v = new float3(2, 0, 3);
            var slid = EnemyAIMath.SlideVelocity(v, float3.zero);
            Assert.AreEqual(v.x, slid.x, Eps);
            Assert.AreEqual(v.z, slid.z, Eps);
        }
        // ---- EB-1 fortress aggro: PickWeightedNearest ----

        [Test]
        public void PickWeightedNearest_NoStructures_PicksNearestPlayer()
        {
            using var players = new NativeList<float3>(Allocator.Temp);
            using var structs = new NativeList<float3>(Allocator.Temp);
            players.Add(new float3(10, 0, 0));
            players.Add(new float3(3, 0, 0));
            EnemyAIMath.PickWeightedNearest(float3.zero, players, structs, 0.7f, out bool isStruct, out int idx);
            Assert.IsFalse(isStruct);
            Assert.AreEqual(1, idx, "nearest player is index 1 (dist 3)");
        }

        [Test]
        public void PickWeightedNearest_PrefersStructure_WhenWeightShrinksItsDistance()
        {
            using var players = new NativeList<float3>(Allocator.Temp);
            using var structs = new NativeList<float3>(Allocator.Temp);
            players.Add(new float3(8, 0, 0));   // effective 8
            structs.Add(new float3(10, 0, 0));  // 10 * weight 0.5 = effective 5 < 8
            EnemyAIMath.PickWeightedNearest(float3.zero, players, structs, 0.5f, out bool isStruct, out int idx);
            Assert.IsTrue(isStruct, "a weighted structure (10*0.5=5) beats a player at 8 -> Husks push for structures");
            Assert.AreEqual(0, idx);
        }

        [Test]
        public void PickWeightedNearest_PlayerInTheWay_WinsOverWeightedStructure()
        {
            using var players = new NativeList<float3>(Allocator.Temp);
            using var structs = new NativeList<float3>(Allocator.Temp);
            players.Add(new float3(2, 0, 0));   // a player right in the way (dist 2)
            structs.Add(new float3(10, 0, 0));  // 10 * 0.7 = effective 7 > 2
            EnemyAIMath.PickWeightedNearest(float3.zero, players, structs, 0.7f, out bool isStruct, out int idx);
            Assert.IsFalse(isStruct, "a player closer than the weighted structure distance wins (attack the one in the way)");
            Assert.AreEqual(0, idx);
        }

        [Test]
        public void PickWeightedNearest_OnlyStructures_RazesTheUndefendedBase()
        {
            using var players = new NativeList<float3>(Allocator.Temp);
            using var structs = new NativeList<float3>(Allocator.Temp);
            structs.Add(new float3(0, 0, 12));
            EnemyAIMath.PickWeightedNearest(float3.zero, players, structs, 0.7f, out bool isStruct, out int idx);
            Assert.IsTrue(isStruct, "with no players, a Husk targets a structure (razes the undefended base)");
            Assert.AreEqual(0, idx);
        }

        [Test]
        public void PickWeightedNearest_NoTargets_ReturnsMinusOne()
        {
            using var players = new NativeList<float3>(Allocator.Temp);
            using var structs = new NativeList<float3>(Allocator.Temp);
            EnemyAIMath.PickWeightedNearest(float3.zero, players, structs, 0.7f, out bool isStruct, out int idx);
            Assert.AreEqual(-1, idx);
        }

    }
}