대한민국 육군 AH-64E 아파치 가디언 롱보우 레이더(FCR) 128개 표적 분류 및 1,000Hz 0-Alloc C# 헬파이어 우선순위 큐 분배 엔진

using System;
using System.Numerics;
using System.Runtime.CompilerServices;

namespace ZeliDesk.Defense.Army.Aviation
{
    public enum TargetClass : byte
    {
        Unknown = 0,
        WheeledVehicle = 1,
        ArmoredCarrier = 2,
        MainBattleTank = 3,
        AirDefenseThreat = 4 // 최우선 교전
    }

    public readonly record struct FcrRawTrack(
        int TrackId,
        Vector3 RelPositionMeters,
        Vector3 VelocityMps,
        TargetClass Classification
    );

    public ref struct HellfireTargetAssignment
    {
        public int TrackId;
        public float ThreatScore;
        public byte MissileBayIndex; // 0 ~ 15
        public bool FireConsentReady;
    }

    public static class Ah64eLongbowRadarTargetQueuingEngine
    {
        private const float MaxRadarRange = 8000.0f; // 8km
        private const float MaxClosingSpeed = 50.0f;  // 50 m/s

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static int PrioritizeAndAssignHellfire(
            ReadOnlySpan<FcrRawTrack> tracks,
            Span<HellfireTargetAssignment> assignments)
        {
            int trackCount = Math.Min(tracks.Length, 128);
            Span<float> scores = stackalloc float[trackCount];
            Span<int> indices = stackalloc int[trackCount];

            // 1. 위협도 점수 일괄 계산 (0-Alloc)
            for (int i = 0; i < trackCount; i++)
            {
                ref readonly var trk = ref tracks[i];
                float dist = trk.RelPositionMeters.Length();
                float distFactor = Math.Clamp((MaxRadarRange - dist) / MaxRadarRange, 0.0f, 1.0f);

                // 접근 속도 계산: Vc = - (r dot v) / dist
                float vClosing = dist > 1.0f ? -Vector3.Dot(trk.RelPositionMeters, trk.VelocityMps) / dist : 0.0f;
                float speedFactor = Math.Clamp(vClosing / MaxClosingSpeed, 0.0f, 1.0f);

                float classScore = trk.Classification switch
                {
                    TargetClass.AirDefenseThreat => 1.0f,
                    TargetClass.MainBattleTank => 0.85f,
                    TargetClass.ArmoredCarrier => 0.65f,
                    TargetClass.WheeledVehicle => 0.35f,
                    _ => 0.1f
                };

                scores[i] = (0.35f * distFactor) + (0.25f * speedFactor) + (0.40f * classScore);
                indices[i] = i;
            }

            // 2. 부분 선택 정렬을 통한 상위 M개 선별 (최대 16개)
            int assignCount = Math.Min(assignments.Length, Math.Min(trackCount, 16));
            for (int i = 0; i < assignCount; i++)
            {
                int maxIdx = i;
                for (int j = i + 1; j < trackCount; j++)
                {
                    if (scores[indices[j]] > scores[indices[maxIdx]])
                    {
                        maxIdx = j;
                    }
                }

                // 스왑
                int temp = indices[i];
                indices[i] = indices[maxIdx];
                indices[maxIdx] = temp;

                int selectedTrackIndex = indices[i];
                ref readonly var chosen = ref tracks[selectedTrackIndex];

                assignments[i] = new HellfireTargetAssignment
                {
                    TrackId = chosen.TrackId,
                    ThreatScore = scores[selectedTrackIndex],
                    MissileBayIndex = (byte)i,
                    FireConsentReady = true
                };
            }

            return assignCount;
        }
    }
}