대한민국 육군 차세대 드론봇 전투단 군집(Swarm) 자폭/정찰 드론 비행 및 1,000Hz 0-Alloc C# 보이드(Boids) 분산 충돌 회피 알고리즘

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

namespace ZeliDesk.Defense.Army.DroneSwarm
{
    public readonly record struct DroneSwarmAgent(
        Vector3 Position,
        Vector3 Velocity,
        float AgentRadiusMeters
    );

    public ref struct SwarmControlOutput
    {
        public Vector3 CommandedAcceleration;
        public float TargetPitchDeg;
        public float TargetRollDeg;
        public bool SafeSeparationMaintained;
    }

    public static class DroneSwarmBoidsCore
    {
        private const float SafeDistanceMeters = 4.0f;
        private const float MaxAccelerationMps2 = 18.0f;
        private const float WeightSeparation = 3.5f;
        private const float WeightAlignment = 1.2f;
        private const float WeightCohesion = 0.8f;
        private const float WeightGoal = 2.0f;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void ComputeSwarmVector(
            ref readonly DroneSwarmAgent self,
            ReadOnlySpan neighbors,
            Vector3 targetPosition,
            ref SwarmControlOutput output)
        {
            Vector3 vSep = Vector3.Zero;
            Vector3 vAlign = Vector3.Zero;
            Vector3 centerOfMass = Vector3.Zero;
            int neighborCount = 0;
            bool safe = true;

            for (int i = 0; i < neighbors.Length; i++)
            {
                ref readonly var other = ref neighbors[i];
                Vector3 diff = self.Position - other.Position;
                float distSq = diff.LengthSquared();

                if (distSq > 0.0001f && distSq < 400.0f) // 통신 반경 20m
                {
                    float dist = (float)Math.Sqrt(distSq);
                    if (dist < SafeDistanceMeters)
                    {
                        safe = false;
                        vSep += (diff / (distSq + 0.1f));
                    }

                    vAlign += other.Velocity;
                    centerOfMass += other.Position;
                    neighborCount++;
                }
            }

            Vector3 accelCmd = Vector3.Zero;
            if (neighborCount > 0)
            {
                vAlign = (vAlign / neighborCount) - self.Velocity;
                Vector3 vCoh = (centerOfMass / neighborCount) - self.Position;
                accelCmd = (WeightSeparation * vSep) + (WeightAlignment * vAlign) + (WeightCohesion * vCoh);
            }

            Vector3 toGoal = targetPosition - self.Position;
            if (toGoal.LengthSquared() > 1.0f)
            {
                accelCmd += WeightGoal * Vector3.Normalize(toGoal);
            }

            // 가속도 제한
            if (accelCmd.Length() > MaxAccelerationMps2)
            {
                accelCmd = Vector3.Normalize(accelCmd) * MaxAccelerationMps2;
            }

            output.CommandedAcceleration = accelCmd;
            output.SafeSeparationMaintained = safe;
            output.TargetPitchDeg = Math.Clamp(-accelCmd.X * 3.0f, -30.0f, 30.0f);
            output.TargetRollDeg = Math.Clamp(accelCmd.Y * 3.0f, -30.0f, 30.0f);
        }
    }
}