Project-M/Assets/_Project/Scripts/Simulation/Combat/EnemyAIMath.cs

using Unity.Collections;
using Unity.Mathematics;

namespace ProjectM.Simulation
{
    /// <summary>
    /// Pure, deterministic Husk AI math — no RNG, no wall-clock — so server simulation stays reproducible and
    /// the helpers are EditMode-unit-testable without an ECS world (mirrors <see cref="PlayerSpawnMath"/> /
    /// <c>StatMath</c>).
    /// </summary>
    public static class EnemyAIMath
    {
        /// <summary>
        /// Planar (XZ) seek velocity from <paramref name="from"/> toward <paramref name="to"/> at
        /// <paramref name="speed"/>. Y is forced to 0 (top-down plane). Returns zero once within
        /// <paramref name="stopDistance"/> (so the Husk halts at strike range instead of jittering through the
        /// target) or when the two points coincide.
        /// </summary>
        public static float3 SeekVelocity(float3 from, float3 to, float speed, float stopDistance)
        {
            float3 d = to - from;
            d.y = 0f;
            float distSq = math.lengthsq(d);
            if (distSq <= stopDistance * stopDistance || distSq < 1e-8f)
                return float3.zero;
            return math.normalize(d) * speed;
        }

        /// <summary>
        /// True when <paramref name="to"/> is within <paramref name="range"/> of <paramref name="from"/> on the
        /// XZ plane.
        /// </summary>
        public static bool InAttackRange(float3 from, float3 to, float range)
        {
            float3 d = to - from;
            d.y = 0f;
            return math.lengthsq(d) <= range * range;
        }
        /// <summary>
        /// Projects a planar movement <paramref name="vel"/> onto a wall plane defined by <paramref name="surfaceNormal"/>
        /// (collide-and-slide): removes the component of <paramref name="vel"/> that pushes into the surface so the
        /// mover glances along the wall instead of stopping dead. Both inputs are flattened to the XZ plane (top-down).
        /// Returns <paramref name="vel"/> unchanged when the normal is degenerate.
        /// </summary>
        public static float3 SlideVelocity(float3 vel, float3 surfaceNormal)
        {
            surfaceNormal.y = 0f;
            float len = math.length(surfaceNormal);
            if (len < 1e-6f)
                return vel;
            float3 n = surfaceNormal / len;
            float3 slid = vel - math.dot(vel, n) * n;
            slid.y = 0f;
            return slid;
        }


        /// <summary>
        /// Deterministic planar ring position around <paramref name="center"/> for spawn
        /// <paramref name="index"/>: evenly spaced over <paramref name="slots"/> angles at
        /// <paramref name="radius"/>. Stable per index so a replayed spawn lands identically.
        /// </summary>
        public static float3 RingPosition(float3 center, int index, int slots, float radius)
        {
            if (slots < 1)
                slots = 1;
            int slot = ((index % slots) + slots) % slots;
            float angle = (2f * math.PI * slot) / slots;
            math.sincos(angle, out float s, out float c);
            return center + new float3(c * radius, 0f, s * radius);
        }
        /// <summary>
        /// EB-1 fortress aggro: pick a Husk's target as the weighted-nearest of the living players (weight 1) and
        /// the live structures (a SQUARED <paramref name="structureWeight"/> applied to structure distance, so &lt;1
        /// makes structures preferred while a sufficiently-closer player 'in the way' still wins). Planar XZ,
        /// deterministic (no RNG/wall-clock). Sets <paramref name="index"/> = -1 when there are no targets. Pure so
        /// both the Grunt and Charger passes select IDENTICALLY and it is EditMode-unit-testable.
        /// </summary>
        public static void PickWeightedNearest(float3 from, NativeList<float3> playerPositions,
            NativeList<float3> structurePositions, float structureWeight, out bool isStructure, out int index)
        {
            isStructure = false;
            index = -1;
            float bestSq = float.MaxValue;
            for (int i = 0; i < playerPositions.Length; i++)
            {
                float sq = math.lengthsq(playerPositions[i].xz - from.xz);
                if (sq < bestSq) { bestSq = sq; index = i; isStructure = false; }
            }
            float w = math.max(0f, structureWeight);
            float wsq = w * w; // applied to SQUARED distance so the weight scales true distance
            for (int i = 0; i < structurePositions.Length; i++)
            {
                float sq = math.lengthsq(structurePositions[i].xz - from.xz) * wsq;
                if (sq < bestSq) { bestSq = sq; index = i; isStructure = true; }
            }
        }

        /// <summary>
        /// Region-scoped variant of <see cref="PickWeightedNearest(float3,NativeList{float3},NativeList{float3},float,out bool,out int)"/>:
        /// considers ONLY targets whose stored region byte equals <paramref name="region"/>, so a Husk seeks within
        /// its own region only (an expedition Husk never paths across the 1000-unit gap to a base player/structure,
        /// and a base Husk never to an expedition target). <paramref name="playerRegions"/> /
        /// <paramref name="structureRegions"/> are parallel to the position lists; the returned <paramref name="index"/>
        /// maps to the FULL list so the caller's by-index entity lookup stays valid. Pure, Burst-safe (byte compares).
        /// </summary>
        public static void PickWeightedNearest(float3 from, NativeList<float3> playerPositions,
            NativeList<byte> playerRegions, NativeList<float3> structurePositions, NativeList<byte> structureRegions,
            byte region, float structureWeight, out bool isStructure, out int index)
        {
            isStructure = false;
            index = -1;
            float bestSq = float.MaxValue;
            for (int i = 0; i < playerPositions.Length; i++)
            {
                if (playerRegions[i] != region) continue;
                float sq = math.lengthsq(playerPositions[i].xz - from.xz);
                if (sq < bestSq) { bestSq = sq; index = i; isStructure = false; }
            }
            float w = math.max(0f, structureWeight);
            float wsq = w * w; // applied to SQUARED distance so the weight scales true distance
            for (int i = 0; i < structurePositions.Length; i++)
            {
                if (structureRegions[i] != region) continue;
                float sq = math.lengthsq(structurePositions[i].xz - from.xz) * wsq;
                if (sq < bestSq) { bestSq = sq; index = i; isStructure = true; }
            }
        }
    }
}