< Summary

Class:IADS
Assembly:bamlab.micromissiles
File(s):/github/workspace/Assets/Scripts/IADS/IADS.cs
Covered lines:0
Uncovered lines:259
Coverable lines:259
Total lines:424
Line coverage:0% (0 of 259)
Covered branches:0
Total branches:0
Covered methods:0
Total methods:28
Method coverage:0% (0 of 28)

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
IADS()0%2100%
Awake()0%6200%
OnDestroy()0%20400%
Start()0%2100%
LateUpdate()0%12300%
RegisterSimulationStarted()0%2100%
LaunchInterceptorsManager()0%12300%
CheckAndLaunchInterceptors()0%42600%
ShouldLaunchSubmunitions(...)0%30500%
AssignSubmunitionsToThreats(...)0%30500%
RequestAssignInterceptorToThreat(...)0%2100%
AssignInterceptorToThreat(...)0%56700%
RequestClusterThreat(...)0%2100%
CheckForEscapingThreatsManager()0%12300%
CheckForEscapingThreats()0%42600%
ClusterThreatsManager()0%12300%
ClusterThreats()0%30500%
RegisterNewThreat(...)0%2100%
RegisterNewInterceptor(...)0%2100%
RegisterInterceptorHit(...)0%30500%
RegisterInterceptorMiss(...)0%20400%
RegisterThreatHit(...)0%12300%
RegisterThreatMiss(...)0%12300%
GetThreatTracks()0%2100%
GetInterceptorTracks()0%2100%
RegisterSimulationEnded()0%2100%

File(s)

/github/workspace/Assets/Scripts/IADS/IADS.cs

#LineLine coverage
 1using System;
 2using System.Collections;
 3using System.Collections.Generic;
 4using System.IO;
 5using System.Linq;
 6using UnityEngine;
 7
 8// Integrated Air Defense System.
 9public class IADS : MonoBehaviour {
 010  public static IADS Instance { get; private set; }
 11
 12  private const float LaunchInterceptorsPeriod = 0.4f;
 13  private const float CheckForEscapingThreatsPeriod = 5.0f;
 14  private const float ClusterThreatsPeriod = 2.0f;
 15
 16  // TODO(titan): Choose the CSV file based on the interceptor type.
 017  private ILaunchAnglePlanner _launchAnglePlanner =
 18      new LaunchAngleCsvInterpolator(Path.Combine("Planning", "hydra70_launch_angle.csv"));
 019  private IAssignment _assignmentScheme = new MaxSpeedAssignment();
 20  private Coroutine _launchInterceptorsCoroutine;
 21
 22  [SerializeField]
 023  private List<TrackFileData> _trackFiles = new List<TrackFileData>();
 024  private Dictionary<Agent, TrackFileData> _trackFileMap = new Dictionary<Agent, TrackFileData>();
 25
 026  private List<Interceptor> _assignmentQueue = new List<Interceptor>();
 027  private List<Cluster> _threatClusters = new List<Cluster>();
 028  private Dictionary<Cluster, ThreatClusterData> _threatClusterMap =
 29      new Dictionary<Cluster, ThreatClusterData>();
 030  private Dictionary<Interceptor, Cluster> _interceptorClusterMap =
 31      new Dictionary<Interceptor, Cluster>();
 032  private HashSet<Interceptor> _assignableInterceptors = new HashSet<Interceptor>();
 33
 034  private HashSet<Threat> _threatsToCluster = new HashSet<Threat>();
 35  private Coroutine _checkForEscapingThreatsCoroutine;
 36  private Coroutine _clusterThreatsCoroutine;
 37
 038  private int _trackFileIdTicker = 0;
 39
 040  private void Awake() {
 041    if (Instance == null) {
 042      Instance = this;
 043    } else {
 044      Destroy(gameObject);
 045    }
 046  }
 47
 048  private void OnDestroy() {
 049    if (_launchInterceptorsCoroutine != null) {
 050      StopCoroutine(_launchInterceptorsCoroutine);
 051    }
 052    if (_checkForEscapingThreatsCoroutine != null) {
 053      StopCoroutine(_checkForEscapingThreatsCoroutine);
 054    }
 055    if (_clusterThreatsCoroutine != null) {
 056      StopCoroutine(_clusterThreatsCoroutine);
 057    }
 058  }
 59
 060  public void Start() {
 061    SimManager.Instance.OnSimulationStarted += RegisterSimulationStarted;
 062    SimManager.Instance.OnSimulationEnded += RegisterSimulationEnded;
 063    SimManager.Instance.OnNewThreat += RegisterNewThreat;
 064    SimManager.Instance.OnNewInterceptor += RegisterNewInterceptor;
 065  }
 66
 067  public void LateUpdate() {
 68    // Update the cluster centroids.
 069    foreach (var cluster in _threatClusters) {
 070      cluster.Recenter();
 071      _threatClusterMap[cluster].UpdateCentroid();
 072    }
 73
 74    // Assign any interceptors that are no longer assigned to any threat.
 075    AssignInterceptorToThreat(
 076        _assignableInterceptors.Where(interceptor => !interceptor.HasTerminated()).ToList());
 077  }
 78
 079  private void RegisterSimulationStarted() {
 080    _launchInterceptorsCoroutine =
 81        StartCoroutine(LaunchInterceptorsManager(LaunchInterceptorsPeriod));
 082    _checkForEscapingThreatsCoroutine =
 83        StartCoroutine(CheckForEscapingThreatsManager(CheckForEscapingThreatsPeriod));
 084    _clusterThreatsCoroutine = StartCoroutine(ClusterThreatsManager(ClusterThreatsPeriod));
 085  }
 86
 087  private IEnumerator LaunchInterceptorsManager(float period) {
 088    while (true) {
 89      // Check whether an interceptor should be launched at a cluster and launch it.
 090      CheckAndLaunchInterceptors();
 091      yield return new WaitForSeconds(period);
 092    }
 93  }
 94
 095  private void CheckAndLaunchInterceptors() {
 096    foreach (var cluster in _threatClusters) {
 97      // Check whether an interceptor has already been assigned to the cluster.
 098      if (_threatClusterMap[cluster].Status != ThreatClusterStatus.UNASSIGNED) {
 099        continue;
 100      }
 101
 102      // Check whether all threats in the cluster have terminated.
 0103      bool allTerminated = cluster.Threats.All(threat => threat.IsTerminated());
 0104      if (allTerminated) {
 0105        continue;
 106      }
 107
 108      // Create a predictor to track the cluster's centroid.
 0109      IPredictor predictor = new LinearExtrapolator(_threatClusterMap[cluster].Centroid);
 110
 111      // Create a launch planner.
 0112      ILaunchPlanner planner = new IterativeLaunchPlanner(_launchAnglePlanner, predictor);
 0113      LaunchPlan plan = planner.Plan();
 114
 115      // Check whether an interceptor should be launched.
 0116      if (plan.ShouldLaunch) {
 0117        Debug.Log(
 118            $"Launching a carrier interceptor at an elevation of {plan.LaunchAngle} degrees to position {plan.InterceptP
 0119        UIManager.Instance.LogActionMessage(
 120            $"[IADS] Launching a carrier interceptor at an elevation of {plan.LaunchAngle} degrees to position {plan.Int
 121
 122        // Create a new interceptor.
 0123        DynamicAgentConfig config =
 124            SimManager.Instance.SimulationConfig.interceptor_swarm_configs[0].dynamic_agent_config;
 0125        InitialState initialState = new InitialState();
 126
 127        // Set the initial position, which defaults to the origin.
 0128        initialState.position = Vector3.zero;
 129
 130        // Set the initial velocity.
 0131        Vector3 interceptDirection =
 132            Coordinates3.ConvertCartesianToSpherical(plan.InterceptPosition);
 0133        initialState.velocity = Coordinates3.ConvertSphericalToCartesian(
 134            r: 1e-3f, azimuth: interceptDirection[1], elevation: plan.LaunchAngle);
 0135        Interceptor interceptor = SimManager.Instance.CreateInterceptor(config, initialState);
 136
 137        // Assign the interceptor to the cluster.
 0138        _interceptorClusterMap[interceptor] = cluster;
 0139        interceptor.AssignTarget(_threatClusterMap[cluster].Centroid);
 0140        _threatClusterMap[cluster].AssignInterceptor(interceptor);
 141
 142        // Create an interceptor swarm.
 0143        SimManager.Instance.AddInterceptorSwarm(new List<Agent> { interceptor as Agent });
 0144      }
 0145    }
 0146  }
 147
 0148  public bool ShouldLaunchSubmunitions(Interceptor carrier) {
 149    // The carrier interceptor will spawn submunitions when any target is greater than 30 degrees
 150    // away from the carrier interceptor's current velocity or when any threat is within 500 meters
 151    // of the interceptor.
 152    const float SubmunitionSpawnMaxAngularDeviation = 30.0f;
 153    const float SubmunitionSpawnMinDistanceToThreat = 500.0f;
 154    const float SubmunitionSpawnMaxDistanceToThreat = 2000.0f;
 155    // TODO(titan): The prediction time should be a function of the submunition characteristic, such
 156    // as the boost time.
 157    const float SubmunitionSpawnPredictionTime = 0.6f;
 158
 0159    Cluster cluster = _interceptorClusterMap[carrier];
 0160    List<Threat> threats = cluster.Threats.ToList();
 0161    Vector3 carrierPosition = carrier.GetPosition();
 0162    Vector3 carrierVelocity = carrier.GetVelocity();
 0163    foreach (var threat in threats) {
 0164      IPredictor predictor = new LinearExtrapolator(threat);
 0165      PredictorState predictedState = predictor.Predict(SubmunitionSpawnPredictionTime);
 0166      Vector3 positionToPredictedThreat = predictedState.Position - carrierPosition;
 0167      float predictedDistanceToThreat = positionToPredictedThreat.magnitude;
 168
 169      // Check whether the distance to the threat is less than the minimum distance.
 0170      if (predictedDistanceToThreat < SubmunitionSpawnMinDistanceToThreat) {
 0171        return true;
 172      }
 173
 174      // Check whether the angular deviation exceeds the maximum angular deviation.
 0175      float distanceDeviation =
 176          (Vector3.ProjectOnPlane(positionToPredictedThreat, carrierVelocity)).magnitude;
 0177      float angularDeviation =
 178          Mathf.Asin(distanceDeviation / predictedDistanceToThreat) * Mathf.Rad2Deg;
 0179      if (angularDeviation > SubmunitionSpawnMaxAngularDeviation &&
 0180          predictedDistanceToThreat < SubmunitionSpawnMaxDistanceToThreat) {
 0181        return true;
 182      }
 0183    }
 0184    return false;
 0185  }
 186
 0187  public void AssignSubmunitionsToThreats(Interceptor carrier, List<Interceptor> interceptors) {
 188    // Assign threats to the submunitions.
 0189    Cluster cluster = _interceptorClusterMap[carrier];
 0190    List<Threat> threats = cluster.Threats.ToList();
 0191    IEnumerable<IAssignment.AssignmentItem> assignments =
 192        _assignmentScheme.Assign(interceptors, threats);
 193
 194    // Mark the cluster as delegated to submunitions.
 0195    _threatClusterMap[cluster].RemoveInterceptor(carrier, delegated: true);
 196
 197    // Apply the assignments to the submunitions.
 0198    foreach (var assignment in assignments) {
 0199      assignment.Interceptor.AssignTarget(assignment.Threat);
 0200    }
 201
 202    // Check whether any submunitions were not assigned to a threat.
 0203    foreach (var interceptor in interceptors) {
 0204      if (!interceptor.HasAssignedTarget()) {
 0205        RequestAssignInterceptorToThreat(interceptor);
 0206      }
 0207    }
 0208  }
 209
 0210  public void RequestAssignInterceptorToThreat(Interceptor interceptor) {
 0211    interceptor.UnassignTarget();
 0212    _assignableInterceptors.Add(interceptor);
 0213  }
 214
 0215  private void AssignInterceptorToThreat(in IReadOnlyList<Interceptor> interceptors) {
 0216    if (interceptors.Count == 0) {
 0217      return;
 218    }
 219
 220    // The threat originally assigned to the interceptor has been terminated, so assign another
 221    // threat to the interceptor.
 222
 223    // This pulls from all available track files, not from our previously assigned cluster.
 0224    List<Threat> threats = _trackFiles.Where(trackFile => trackFile.Agent is Threat)
 0225                               .Select(trackFile => trackFile.Agent as Threat)
 226                               .ToList();
 0227    if (threats.Count == 0) {
 0228      return;
 229    }
 230
 0231    IEnumerable<IAssignment.AssignmentItem> assignments =
 232        _assignmentScheme.Assign(interceptors, threats);
 233
 234    // Apply the assignments to the submunitions.
 0235    foreach (var assignment in assignments) {
 0236      assignment.Interceptor.AssignTarget(assignment.Threat);
 0237      _assignableInterceptors.Remove(assignment.Interceptor);
 0238    }
 0239  }
 240
 0241  public void RequestClusterThreat(Threat threat) {
 0242    _threatsToCluster.Add(threat);
 0243  }
 244
 0245  private IEnumerator CheckForEscapingThreatsManager(float period) {
 0246    while (true) {
 0247      yield return new WaitForSeconds(period);
 0248      CheckForEscapingThreats();
 0249    }
 250  }
 251
 0252  private void CheckForEscapingThreats() {
 0253    List<Threat> threats = _trackFiles
 0254                               .Where(trackFile => trackFile.Status == TrackStatus.ASSIGNED &&
 255                                                   trackFile.Agent is Threat)
 0256                               .Select(trackFile => trackFile.Agent as Threat)
 257                               .ToList();
 0258    if (threats.Count == 0) {
 0259      return;
 260    }
 261
 262    // Check whether the threats are escaping the pursuing interceptors.
 0263    foreach (var threat in threats) {
 0264      bool isEscaping = threat.AssignedInterceptors.All(interceptor => {
 0265        Vector3 interceptorPosition = interceptor.GetPosition();
 0266        Vector3 threatPosition = threat.GetPosition();
 267
 0268        float threatTimeToHit = (float)(threatPosition.magnitude / threat.GetSpeed());
 0269        float interceptorTimeToHit =
 270            (float)((threatPosition - interceptorPosition).magnitude / interceptor.GetSpeed());
 0271        return interceptorPosition.magnitude > threatPosition.magnitude ||
 272               threatTimeToHit < interceptorTimeToHit;
 0273      });
 0274      if (isEscaping) {
 0275        RequestClusterThreat(threat);
 0276      }
 0277    }
 0278  }
 279
 0280  private IEnumerator ClusterThreatsManager(float period) {
 0281    while (true) {
 0282      ClusterThreats();
 0283      yield return new WaitForSeconds(period);
 0284    }
 285  }
 286
 0287  private void ClusterThreats() {
 288    // Maximum number of threats per cluster.
 289    const int MaxSize = 7;
 290    // Maximum cluster radius in meters.
 291    const float MaxRadius = 500;
 292
 293    // Filter the threats.
 0294    List<Threat> threats =
 295        _threatsToCluster
 0296            .Where(threat => !threat.IsTerminated() && threat.AssignedInterceptors.Count == 0)
 297            .ToList();
 0298    if (threats.Count == 0) {
 0299      return;
 300    }
 301
 302    // Cluster threats.
 0303    IClusterer clusterer = new AgglomerativeClusterer(new List<Agent>(threats), MaxSize, MaxRadius);
 0304    clusterer.Cluster();
 0305    var clusters = clusterer.Clusters;
 0306    Debug.Log($"Clustered {threats.Count} threats into {clusters.Count} clusters.");
 0307    UIManager.Instance.LogActionMessage(
 308        $"[IADS] Clustered {threats.Count} threats into {clusters.Count} clusters.");
 309
 0310    _threatClusters = clusters.ToList();
 0311    foreach (var cluster in clusters) {
 0312      _threatClusterMap.Add(cluster, new ThreatClusterData(cluster));
 0313    }
 314
 0315    _threatsToCluster.Clear();
 0316  }
 317
 0318  public void RegisterNewThreat(Threat threat) {
 0319    string trackID = $"T{1000 + ++_trackFileIdTicker}";
 0320    ThreatData trackFile = new ThreatData(threat, trackID);
 0321    _trackFiles.Add(trackFile);
 0322    _trackFileMap.Add(threat, trackFile);
 0323    RequestClusterThreat(threat);
 324
 0325    threat.OnThreatHit += RegisterThreatHit;
 0326    threat.OnThreatMiss += RegisterThreatMiss;
 0327  }
 328
 0329  public void RegisterNewInterceptor(Interceptor interceptor) {
 0330    string trackID = $"I{2000 + ++_trackFileIdTicker}";
 0331    InterceptorData trackFile = new InterceptorData(interceptor, trackID);
 0332    _trackFiles.Add(trackFile);
 0333    _trackFileMap.Add(interceptor, trackFile);
 334
 0335    interceptor.OnInterceptMiss += RegisterInterceptorMiss;
 0336    interceptor.OnInterceptHit += RegisterInterceptorHit;
 0337  }
 338
 0339  private void RegisterInterceptorHit(Interceptor interceptor, Threat threat) {
 0340    var threatTrack = _trackFileMap[threat] as ThreatData;
 0341    var interceptorTrack = _trackFileMap[interceptor] as InterceptorData;
 342
 0343    if (threatTrack != null) {
 0344      threatTrack.RemoveInterceptor(interceptor);
 0345      threatTrack.MarkDestroyed();
 0346    }
 347
 0348    if (interceptorTrack != null) {
 0349      interceptorTrack.RemoveThreat(threat);
 0350      interceptorTrack.MarkDestroyed();
 0351    }
 352
 353    // Assign the interceptors to other threats.
 0354    foreach (var assignedInterceptor in threat.AssignedInterceptors.ToList()) {
 0355      if (assignedInterceptor is not CarrierInterceptor) {
 0356        RequestAssignInterceptorToThreat(assignedInterceptor as Interceptor);
 0357      }
 0358    }
 0359  }
 360
 0361  private void RegisterInterceptorMiss(Interceptor interceptor, Threat threat) {
 362    // Assign the interceptor to another threat.
 0363    RequestAssignInterceptorToThreat(interceptor);
 364
 0365    var threatTrack = _trackFileMap[threat] as ThreatData;
 0366    var interceptorTrack = _trackFileMap[interceptor] as InterceptorData;
 367
 0368    if (threatTrack != null) {
 0369      threatTrack.RemoveInterceptor(interceptor);
 370
 371      // Check if the threat is being targeted by at least one interceptor.
 0372      if (threatTrack.AssignedInterceptorCount == 0) {
 0373        RequestClusterThreat(threat);
 0374      }
 0375    }
 376
 0377    if (interceptorTrack != null) {
 0378      interceptorTrack.RemoveThreat(threat);
 0379      interceptorTrack.MarkDestroyed();
 0380    }
 0381  }
 382
 0383  private void RegisterThreatHit(Threat threat) {
 0384    var threatTrack = _trackFileMap[threat] as ThreatData;
 0385    if (threatTrack != null) {
 0386      threatTrack.MarkDestroyed();
 0387    }
 388
 389    // Re-assign the assigned interceptors to other threats.
 0390    foreach (var interceptor in threat.AssignedInterceptors.ToList()) {
 0391      RequestAssignInterceptorToThreat(interceptor as Interceptor);
 0392    }
 0393  }
 394
 0395  private void RegisterThreatMiss(Threat threat) {
 396    // The threat missed (e.g., it hit the floor).
 397    // Re-assign the assigned interceptors to other threats.
 0398    foreach (var interceptor in threat.AssignedInterceptors.ToList()) {
 0399      RequestAssignInterceptorToThreat(interceptor as Interceptor);
 0400    }
 401
 0402    var threatTrack = _trackFileMap[threat] as ThreatData;
 0403    if (threatTrack != null) {
 0404      threatTrack.MarkDestroyed();
 0405    }
 0406  }
 407
 0408  public List<ThreatData> GetThreatTracks() => _trackFiles.OfType<ThreatData>().ToList();
 409
 410  public List<InterceptorData> GetInterceptorTracks() =>
 0411      _trackFiles.OfType<InterceptorData>().ToList();
 412
 0413  private void RegisterSimulationEnded() {
 0414    _trackFiles.Clear();
 0415    _trackFileMap.Clear();
 0416    _assignmentQueue.Clear();
 0417    _threatClusters.Clear();
 0418    _threatClusterMap.Clear();
 0419    _interceptorClusterMap.Clear();
 0420    _assignableInterceptors.Clear();
 0421    _threatsToCluster.Clear();
 0422    _trackFileIdTicker = 0;
 0423  }
 424}
Generated by: ReportGenerator 5.0.4.0
07/03/2025 - 03:27:14
GitHub | www.palmmedia.de

Methods/Properties

Instance()
Instance(IADS)
IADS()
Awake()
OnDestroy()
Start()
LateUpdate()
RegisterSimulationStarted()
LaunchInterceptorsManager()
CheckAndLaunchInterceptors()
ShouldLaunchSubmunitions(Interceptor)
AssignSubmunitionsToThreats(Interceptor, System.Collections.Generic.List[Interceptor])
RequestAssignInterceptorToThreat(Interceptor)
AssignInterceptorToThreat(System.Collections.Generic.IReadOnlyList`1[[Interceptor, bamlab.micromissiles, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null]]&)
RequestClusterThreat(Threat)
CheckForEscapingThreatsManager()
CheckForEscapingThreats()
ClusterThreatsManager()
ClusterThreats()
RegisterNewThreat(Threat)
RegisterNewInterceptor(Interceptor)
RegisterInterceptorHit(Interceptor, Threat)
RegisterInterceptorMiss(Interceptor, Threat)
RegisterThreatHit(Threat)
RegisterThreatMiss(Threat)
GetThreatTracks()
GetInterceptorTracks()
RegisterSimulationEnded()