ActiveProtect/Models/MillimeterWaveGuidanceSystem.cs

using System;
using ActiveProtect.SimulationEnvironment;

namespace ActiveProtect.Models
{
    /// <summary>
    /// 毫米波导引头系统
    /// </summary>
    public class MillimeterWaveGuidanceSystem : BasicGuidanceSystem
    {
        private const double MAX_DETECTION_RANGE = 8000; // 最大探测范围(米)
        private const double FIELD_OF_VIEW = Math.PI / 4; // 视场角(弧度)
        private const double TARGET_RECOGNITION_PROBABILITY = 0.95; // 目标识别概率
        private const double WAVE_FREQUENCY = 94e9; // 毫米波频率(Hz), 94GHz
        private const double PULSE_DURATION = 1e-6; // 脉冲持续时间(秒)

        private readonly Random random = new Random();
        public ISimulationManager SimulationManager { get; set; }

        public MillimeterWaveGuidanceSystem(ISimulationManager simulationManager) : base()
        {
            SimulationManager = simulationManager;
        }

        /// <summary>
        /// 更新引导系统
        /// </summary>
        public override void Update(double deltaTime, Vector3D missilePosition, Vector3D missileVelocity)
        {
            base.Update(deltaTime, missilePosition, missileVelocity);

            if (TryDetectTarget(missilePosition, missileVelocity, out Vector3D targetPosition))
            {
                Vector3D toTarget = targetPosition - missilePosition;
                Vector3D desiredVelocity = toTarget.Normalize() * missileVelocity.Magnitude();
                GuidanceAcceleration = (desiredVelocity - missileVelocity) / deltaTime;

                // 限制最大加速度
                double maxAcceleration = 30; // 30 m/s²
                if (GuidanceAcceleration.Magnitude() > maxAcceleration)
                {
                    GuidanceAcceleration = GuidanceAcceleration.Normalize() * maxAcceleration;
                }

                HasGuidance = true;
            }
            else
            {
                HasGuidance = false;
            }
        }

        /// <summary>
        /// 尝试探测目标
        /// </summary>
        private bool TryDetectTarget(Vector3D missilePosition, Vector3D missileVelocity, out Vector3D targetPosition)
        {
            targetPosition = Vector3D.Zero;

            foreach (var element in SimulationManager.GetElements())
            {
                if (element is Tank tank)
                {
                    Vector3D toTarget = tank.Position - missilePosition;
                    double distance = toTarget.Magnitude();

                    if (distance <= MAX_DETECTION_RANGE)
                    {
                        double angle = Math.Acos(Vector3D.DotProduct(toTarget.Normalize(), missileVelocity.Normalize()));

                        if (angle <= FIELD_OF_VIEW / 2)
                        {
                            // 模拟毫米波探测
                            double signalStrength = CalculateSignalStrength(distance);
                            double detectionProbability = signalStrength * TARGET_RECOGNITION_PROBABILITY;

                            if (random.NextDouble() < detectionProbability)
                            {
                                targetPosition = tank.Position;
                                return true;
                            }
                        }
                    }
                }
            }

            return false;
        }

        /// <summary>
        /// 计算信号强度
        /// </summary>
        private double CalculateSignalStrength(double distance)
        {
            // 简化的雷达方程
            double transmitPower = 100; // 发射功率(W)
            double antennaGain = 30; // 天线增益(dB)
            double wavelength = 3e8 / WAVE_FREQUENCY; // 波长(m)
            double radarCrossSection = 10; // 目标雷达截面积(m^2)

            double signalStrength = (transmitPower * Math.Pow(10, antennaGain/10) * Math.Pow(wavelength, 2) * radarCrossSection) 
                                    / (Math.Pow(4 * Math.PI, 3) * Math.Pow(distance, 4));

            return Math.Min(1, signalStrength); // 归一化到[0, 1]范围
        }
    }
}