SimulationServerYL/SimulationServer/Entity/AircraftYLZY.cs

using KYFramework;
using MathNet.Numerics.Distributions;
using Model;
using MongoDB.Bson;
using SimulationCommon;
using SimulationServer.Utils;

namespace SimulationServer;

public class AircraftYLZY : AircraftEntity
{
    public YLZYTask taskContent;
    public MissionEndPoint MissionEndPoint;
    public bool IsOver;
    public bool Success;
    public TaskParameter taskParameter;

    public MissionEndPoint hospitalPoint;

    public override void End()
    {
        TotalFuelConsumption = TurningPoints[0].RemainingFuel - TurningPoints[^1].RemainingFuel;
    }

    public override void Reset()
    {
        base.Reset();
        IsOver = false;
        Success = false;
        TotalTime = 0;
    }

    public override void Start()
    {
        FlightPlanEditor.missionpoint.MissionPointLatitude = FlightPlanEditor.medicalTargetPoint[0].TargetPointLatitude;
        FlightPlanEditor.missionpoint.MissionPointLongitude = FlightPlanEditor.medicalTargetPoint[0].TargetPointLongitude;
        FlightPlanEditor.missionpoint.MissionPointHeight = FlightPlanEditor.medicalTargetPoint[0].TargetPointHeight;
        Console.WriteLine("Latitude:" + FlightPlanEditor.missionpoint.MissionPointLatitude + "_" + "Longitude:" + FlightPlanEditor.missionpoint.MissionPointLongitude + "_" + "Height:" + FlightPlanEditor.missionpoint.MissionPointHeight);

        int patientCount = FlightPlanEditor.medicalTargetPoint[0].TargetType.Count; // 伤患人数
        List<string> diseaseTypes = new List<string>();
        for (int i = 0; i < FlightPlanEditor.medicalTargetPoint[0].TargetType.diseaseTypes.Length; i++)
        {
            diseaseTypes.Add(FlightPlanEditor.medicalTargetPoint[0].TargetType.diseaseTypes[i]);
        }
        int medicCount = taskParameter.doctorPersonnel + taskParameter.nursePersonnel + taskParameter.nurseSeverePersonnel; // 医护人员数量  

        // 交接时间为5分钟  
        double handoverTime = 5;

        // 计算总急救时间  
        double totalEmergencyTime = CalculateTotalEmergencyTime(diseaseTypes);

        // 计算平均急救时间（每个医护人员分担的时间）  
        double averageEmergencyTimePerMedic = totalEmergencyTime / medicCount;

        // 计算总时间（平均急救时间 + 交接时间）  
        double totalTime = averageEmergencyTimePerMedic + handoverTime;

        Console.WriteLine($"总急救时间（平均每个医护人员）: {averageEmergencyTimePerMedic} 分钟");
        Console.WriteLine($"总时间（包括交接时间）: {totalTime} 分钟");

        Random rand = new Random();
        List<Patient> patients = new List<Patient>();
        for (int i = 0; i < patientCount; i++)
        {
            patients.Add(new Patient()
            {
                Id = i + 1,
                DiseaseType = diseaseTypes[i],
                GoldenHour = 0
            });
        }

        patients = MedicalRescue.ProcessPatients(patients, rand);

        // 对患者进行排序  
        var sortedPatients = patients.OrderBy(p => DiseasePriorityService.GetPriority(p.DiseaseType))
                                    .ThenBy(p => p.GoldenHour)
                                    .ToList();

        // 输出排序后的患者列表    // 从是事故点到医院的飞行时间 + 5分钟的交接时间 < 黄金时间 ? 成功:失败
        foreach (var patient in sortedPatients)
        {
            Console.WriteLine($"sortedPatients ID: {patient.Id}, Disease: {patient.DiseaseType}, Golden Hour: {patient.GoldenHour:F2}");
        }

        // 注意：实际项目中，每次转运一名伤员的操作可能涉及更多的逻辑，比如更新数据库中的转运状态等。  


        FXJHGenerate.FromStartToMission(FlightPlanEditor, ref TurningPoints);//生成从起点到任务段起点的航路点

        for (int i = 0; i < FlightPlanEditor.medicalTargetPoint[0].TargetType.Count; i++)
        {
            FXJHGenerate.JIJIU(5 * 60, FlightPlanEditor, ref TurningPoints);
            FXJHGenerate.JIJIU1(5 * 60, hospitalPoint, ref TurningPoints);
        }

        FXJHGenerate.FromMissionToEnd(FlightPlanEditor, hospitalPoint, ref TurningPoints);
        FXJHGenerate.FXJHTPDiedai(FlightPlanEditor, ref TurningPoints, Velocitys, FuelConsumptions);


        for (int i = 0; i < TurningPoints.Count; i++) // 总飞行时间
        {
            TotalTime += TurningPoints[i].SegmentFlightTime; // 总时间   //仿真轮次1 数值1
        }
        Console.WriteLine("TotalTime:" + TotalTime);

        IsOver = true;
        End();
    }

    static double CalculateTotalEmergencyTime(List<string> diseaseTypes)
    {
        double totalTime = 0;

        // 这里假设有一个方法GetEmergencyTimeFromDatabase，它根据疾病类型从数据库获取急救时间，此处应为从数据库中读取
        foreach (var diseaseType in diseaseTypes)
        {
            double emergencyTime = GetEmergencyTimeFromDatabase(diseaseType);
            totalTime += emergencyTime;
        }

        return totalTime;
    }

    // 模拟从数据库获取急救时间的方法  
    static double GetEmergencyTimeFromDatabase(string diseaseType)
    {
        // 这里应该是实际的数据库查询逻辑  
        // 但为了示例，我们直接返回一个模拟值  
        switch (diseaseType)
        {
            case "aa": //HeartAttack
                return 2; // 心脏病急救时间为2分钟  
            case "bb": //Stroke
                return 5; // 中风急救时间为5分钟  
            case "cc": //Trauma
                return 10; // 创伤急救时间为10分钟  
            case "dd":
                return 15;
            case "ee":
                return 20;
            default:
                return 0;
        }
    }

    // 假设从前端接收到的数据结构  
    public class Patient
    {
        public int Id { get; set; }
        public string DiseaseType { get; set; }
        public double GoldenHour { get; set; } // 患者的黄金救援时间应由黄金救援时间程序获得
    }

    public class DiseaseInfo
    {
        public string DiseaseType { get; set; }
        public double MinGoldenHour { get; set; }
        public double MaxGoldenHour { get; set; }
    }

    public class MedicalRescue
    {
        private static Dictionary<string, DiseaseInfo> diseaseDatabase = new Dictionary<string, DiseaseInfo>
        {
            { "aa", new DiseaseInfo { DiseaseType = "aa", MinGoldenHour = 1, MaxGoldenHour = 3 } },
            { "bb", new DiseaseInfo { DiseaseType = "bb", MinGoldenHour = 2, MaxGoldenHour = 4 } },
            { "cc", new DiseaseInfo { DiseaseType = "cc", MinGoldenHour = 3, MaxGoldenHour = 5 } },
            { "dd", new DiseaseInfo { DiseaseType = "dd", MinGoldenHour = 4, MaxGoldenHour = 6 } },
            { "ee", new DiseaseInfo { DiseaseType = "ee", MinGoldenHour = 5, MaxGoldenHour = 7 } },  
        // 添加更多疾病类型
        };

        public static List<Patient> ProcessPatients(List<Patient> patients, Random rand)
        {
            foreach (var patient in patients)
            {
                var diseaseInfo = GetDiseaseInfo(patient.DiseaseType); // MinGoldenHour MaxGoldenHour 数据库读取
                double goldenHour = GenerateRandomGoldenHour(rand, diseaseInfo.MinGoldenHour, diseaseInfo.MaxGoldenHour);
                Console.WriteLine($"Patient ID: {patient.Id}, Disease: {patient.DiseaseType}, Golden Hour: {goldenHour:F2}");
                patient.GoldenHour = goldenHour;
            }
            return patients;
        }

        public static DiseaseInfo GetDiseaseInfo(string diseaseType)
        {
            if (diseaseDatabase.ContainsKey(diseaseType))
            {
                return diseaseDatabase[diseaseType];
            }
            throw new ArgumentException("Unknown disease type.");
        }

        public static double GenerateRandomGoldenHour(Random rand, double min, double max)
        {
            double mu = (max + min) / 2;
            double sigma = (max - min) / 6;
            var normal = new Normal(mu, sigma);
            return normal.Sample();
        }
    }

    // 假设数据库中的疾病优先级信息  
    public class DiseasePriority
    {
        public string DiseaseType { get; set; }
        public int Priority { get; set; } // 优先级，数字越小优先级越高  
    }

    // 静态类，包含与疾病优先级相关的静态方法  
    public static class DiseasePriorityService
    {
        // 数据库查询（实际项目中应该是从数据库读取）  
        public static List<DiseasePriority> GetDiseasePriorities()
        {
            return new List<DiseasePriority>
            {
                new DiseasePriority { DiseaseType = "aa", Priority = 5 },
                new DiseasePriority { DiseaseType = "bb", Priority = 4 },
                new DiseasePriority { DiseaseType = "cc", Priority = 3 },
                new DiseasePriority { DiseaseType = "dd", Priority = 2 },
                new DiseasePriority { DiseaseType = "ee", Priority = 5 },
            };
        }

        // 根据疾病类型获取优先级  
        public static int GetPriority(string diseaseType)
        {
            var priorities = GetDiseasePriorities().ToDictionary(dp => dp.DiseaseType, dp => dp.Priority);
            if (priorities.TryGetValue(diseaseType, out int priority))
            {
                return priority;
            }
            return int.MaxValue; // 如果没有找到，返回一个很大的数作为默认优先级  
        }
    }

    public string TargetQiXiangInfoSave(string s, int hour)
    {
        string result = hour.ToString() + "-" + s;
        for (int i = 0; i < FlightPlanEditor.medicalTargetPoint[0].TargetQiXiangInfos.Length; i++)
        {

        }
        switch (s)
        {
            case "温度":

                break;
            case "湿度":

                break;
            case "能见度":

                break;
            case "风速":

                break;
            case "风向":

                break;
            case "天气":

                break;
        }
        return result;
    }
}

[ObjectSystem]
public class AircraftYLZYAwakeSystem : AwakeSystem<AircraftYLZY, FlightPlanEditor>
{
    public override void Awake(AircraftYLZY self, FlightPlanEditor flightPlanEditor)
    {
        self.FlightPlanEditor = flightPlanEditor;
        self.Awake();
    }
}