< Summary

Class:SimManager
Assembly:bamlab.micromissiles
File(s):/github/workspace/Assets/Scripts/SimManager.cs
Covered lines:78
Uncovered lines:299
Coverable lines:377
Total lines:607
Line coverage:20.6% (78 of 377)
Covered branches:0
Total branches:0
Covered methods:8
Total methods:48
Method coverage:16.6% (8 of 48)

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
SimManager()0%110100%
GetElapsedSimulationTime()0%2100%
GetCostLaunchedInterceptors()0%2100%
GetCostDestroyedThreats()0%2100%
GetActiveInterceptors()0%2100%
GetActiveThreats()0%6200%
GetActiveAgents()0%12300%
GenerateSwarmTitle(...)0%2100%
GenerateInterceptorSwarmTitle(...)0%2100%
GenerateSubmunitionsSwarmTitle(...)0%2100%
GenerateThreatSwarmTitle(...)0%2100%
Awake()0%6200%
Start()0%6200%
Update()0%2100%
SetTimeScale(...)0%2100%
StartSimulation()0%6200%
PauseSimulation()0%2100%
ResumeSimulation()0%2100%
IsSimulationPaused()0%2100%
InitializeSimulation()0%20400%
AddInterceptorSwarm(...)0%20400%
AddSubmunitionsSwarm(...)0%20400%
LookupSubmunitionSwarmIndexInInterceptorSwarm(...)0%6200%
AddThreatSwarm(...)0%20400%
GetAllAgentsCenter()0%12300%
GetSwarmCenter(...)0%30500%
GetInterceptorSwarms()0%2100%
GetSubmunitionsSwarms()0%2100%
GetThreatSwarms()0%2100%
DestroyInterceptorInSwarm(...)0%56700%
DestroySubmunitionInSwarm(...)0%12300%
DestroyThreatInSwarm(...)0%42600%
RegisterInterceptorHit(...)0%20400%
RegisterInterceptorMiss(...)0%20400%
RegisterThreatHit(...)0%2100%
RegisterThreatMiss(...)0%2100%
LoadAttackBehavior(...)0%2.062075%
CreateDummyAgent(...)0%330100%
CreateInterceptor(...)0%20400%
CreateThreat(...)0%33095%
CreateAgent(...)0%2.042078.57%
CreateRandomAgent(...)0%2.052076.92%
LoadNewConfig(...)0%6200%
RestartSimulation()0%1321100%
FixedUpdate()0%20400%
QuitSimulation()0%2100%

File(s)

/github/workspace/Assets/Scripts/SimManager.cs

#LineLine coverage
 1using System.Collections;
 2using System.Collections.Generic;
 3using System.Linq;
 4using UnityEngine;
 5
 6/// <summary>
 7/// Manages the simulation by handling missiles, targets, and their assignments.
 8/// Implements the Singleton pattern to ensure only one instance exists.
 9/// </summary>
 10public class SimManager : MonoBehaviour {
 11  public SimulatorConfig simulatorConfig;
 12
 13  /// <summary>
 14  /// Singleton instance of SimManager.
 15  /// </summary>
 2516  public static SimManager Instance { get; set; }
 17
 18  /// <summary>
 19  /// Configuration settings for the simulation.
 20  /// </summary>
 21  [SerializeField]
 22  public SimulationConfig SimulationConfig;
 23
 1024  private string _defaultConfig = "7_quadcopters.json";
 25
 1026  private List<Interceptor> _activeInterceptors = new List<Interceptor>();
 27
 1028  private List<Interceptor> _interceptorObjects = new List<Interceptor>();
 1029  private List<Threat> _threatObjects = new List<Threat>();
 30
 1031  private List<GameObject> _dummyAgentObjects = new List<GameObject>();
 1032  private Dictionary<(Vector3, Vector3), GameObject> _dummyAgentTable =
 33      new Dictionary<(Vector3, Vector3), GameObject>();
 34
 35  // Inclusive of all, including submunitions swarms.
 36  // The boolean indicates whether the agent is active (true) or inactive (false).
 1037  private List<List<(Agent, bool)>> _interceptorSwarms = new List<List<(Agent, bool)>>();
 1038  private List<List<(Agent, bool)>> _submunitionsSwarms = new List<List<(Agent, bool)>>();
 1039  private List<List<(Agent, bool)>> _threatSwarms = new List<List<(Agent, bool)>>();
 40
 1041  private Dictionary<Agent, List<(Agent, bool)>> _interceptorSwarmMap =
 42      new Dictionary<Agent, List<(Agent, bool)>>();
 43
 1044  private Dictionary<Agent, List<(Agent, bool)>> _submunitionsSwarmMap =
 45      new Dictionary<Agent, List<(Agent, bool)>>();
 1046  private Dictionary<Agent, List<(Agent, bool)>> _threatSwarmMap =
 47      new Dictionary<Agent, List<(Agent, bool)>>();
 48
 49  // Maps a submunition swarm to its corresponding interceptor swarm.
 1050  private Dictionary<List<(Agent, bool)>, List<(Agent, bool)>> _submunitionInterceptorSwarmMap =
 51      new Dictionary<List<(Agent, bool)>, List<(Agent, bool)>>();
 52
 53  // Events to subscribe to for changes in each of the swarm tables.
 54  public delegate void SwarmEventHandler(List<List<(Agent, bool)>> swarm);
 55  public event SwarmEventHandler OnInterceptorSwarmChanged;
 56  public event SwarmEventHandler OnSubmunitionsSwarmChanged;
 57  public event SwarmEventHandler OnThreatSwarmChanged;
 58  //////////////////////////////////////////////////////////////////////
 59
 1060  private float _elapsedSimulationTime = 0f;
 1061  private bool _isSimulationPaused = false;
 62
 1063  private float _costLaunchedInterceptors = 0f;
 1064  private float _costDestroyedThreats = 0f;
 65
 66  public delegate void SimulationEventHandler();
 67  public event SimulationEventHandler OnSimulationEnded;
 68  public event SimulationEventHandler OnSimulationStarted;
 69
 70  public delegate void NewThreatEventHandler(Threat threat);
 71  public event NewThreatEventHandler OnNewThreat;
 72
 73  public delegate void NewInterceptorEventHandler(Interceptor interceptor);
 74  public event NewInterceptorEventHandler OnNewInterceptor;
 75
 76  /// <summary>
 77  /// Gets the elapsed simulation time.
 78  /// </summary>
 79  /// <returns>The elapsed time in seconds.</returns>
 080  public double GetElapsedSimulationTime() {
 081    return _elapsedSimulationTime;
 082  }
 83
 84  /// <summary>
 85  /// Gets the total cost of launched interceptors.
 86  /// </summary>
 87  /// <returns>The total cost of launched interceptors.</returns>
 088  public double GetCostLaunchedInterceptors() {
 089    return _costLaunchedInterceptors;
 090  }
 91
 92  /// <summary>
 93  /// Gets the total cost of destroyed threats.
 94  /// </summary>
 95  /// <returns>The total cost of destroyed threats.</returns>
 096  public double GetCostDestroyedThreats() {
 097    return _costDestroyedThreats;
 098  }
 99
 0100  public List<Interceptor> GetActiveInterceptors() {
 0101    return _activeInterceptors;
 0102  }
 103
 0104  public List<Threat> GetActiveThreats() {
 0105    return _threatObjects.Where(threat => !threat.IsTerminated()).ToList();
 0106  }
 107
 0108  public List<Agent> GetActiveAgents() {
 0109    return _activeInterceptors.ConvertAll(interceptor => interceptor as Agent)
 0110        .Concat(GetActiveThreats().ConvertAll(threat => threat as Agent))
 111        .ToList();
 0112  }
 113
 0114  public string GenerateSwarmTitle(List<(Agent, bool)> swarm, int index) {
 0115    string swarmTitle = swarm[0].Item1.name;
 0116    swarmTitle = swarmTitle.Split('_')[0];
 0117    swarmTitle += $"_{index}";
 0118    return swarmTitle;
 0119  }
 120
 0121  public string GenerateInterceptorSwarmTitle(List<(Agent, bool)> swarm) {
 0122    return GenerateSwarmTitle(swarm, _interceptorSwarms.IndexOf(swarm));
 0123  }
 124
 0125  public string GenerateSubmunitionsSwarmTitle(List<(Agent, bool)> swarm) {
 0126    return GenerateSwarmTitle(swarm, LookupSubmunitionSwarmIndexInInterceptorSwarm(swarm));
 0127  }
 128
 0129  public string GenerateThreatSwarmTitle(List<(Agent, bool)> swarm) {
 0130    return GenerateSwarmTitle(swarm, _threatSwarms.IndexOf(swarm));
 0131  }
 132
 0133  void Awake() {
 134    // Ensure only one instance of SimManager exists
 0135    if (Instance == null) {
 0136      Instance = this;
 0137      DontDestroyOnLoad(gameObject);
 0138    } else {
 0139      Destroy(gameObject);
 0140    }
 0141    SimulationConfig = ConfigLoader.LoadSimulationConfig(_defaultConfig);
 0142    simulatorConfig = ConfigLoader.LoadSimulatorConfig();
 0143    Debug.Log(SimulationConfig);
 0144  }
 145
 0146  void Start() {
 0147    if (Instance == this) {
 0148      _isSimulationPaused = false;
 0149      StartSimulation();
 0150      ResumeSimulation();
 0151    }
 0152  }
 153
 0154  void Update() {}
 155
 0156  public void SetTimeScale(float timeScale) {
 0157    Time.timeScale = timeScale;
 158    // Time.fixedDeltaTime is derived from simulator.json.
 0159    Time.maximumDeltaTime = Time.fixedDeltaTime * 3;
 0160  }
 161
 0162  public void StartSimulation() {
 0163    InitializeSimulation();
 164
 165    // Invoke the simulation started event to let listeners know to invoke their own handler
 166    // behavior.
 0167    UIManager.Instance.LogActionMessage("[SIM] Simulation started.");
 0168    OnSimulationStarted?.Invoke();
 0169  }
 170
 0171  public void PauseSimulation() {
 0172    SetTimeScale(0);
 0173    Time.fixedDeltaTime = 0;
 0174    _isSimulationPaused = true;
 0175  }
 176
 0177  public void ResumeSimulation() {
 0178    Time.fixedDeltaTime = (float)(1.0f / simulatorConfig.physicsUpdateRate);
 0179    SetTimeScale(SimulationConfig.timeScale);
 0180    _isSimulationPaused = false;
 0181  }
 182
 0183  public bool IsSimulationPaused() {
 0184    return _isSimulationPaused;
 0185  }
 186
 0187  private void InitializeSimulation() {
 0188    if (!IsSimulationPaused()) {
 189      // If the simulation was not paused, we need to update the time scale.
 0190      SetTimeScale(SimulationConfig.timeScale);
 0191      Time.fixedDeltaTime = (float)(1.0f / simulatorConfig.physicsUpdateRate);
 192      // If the simulation WAS paused, then ResumeSimulation will handle updating the time scale and
 193      // fixed delta time from the newly loaded config files.
 0194    }
 195    // Create targets based on the configuration.
 0196    List<Agent> targets = new List<Agent>();
 0197    foreach (var swarmConfig in SimulationConfig.threat_swarm_configs) {
 0198      List<Agent> swarm = new List<Agent>();
 0199      for (int i = 0; i < swarmConfig.num_agents; ++i) {
 0200        Threat threat = CreateThreat(swarmConfig.dynamic_agent_config);
 0201        swarm.Add(threat);
 0202      }
 0203      AddThreatSwarm(swarm);
 0204    }
 0205  }
 206
 0207  public void AddInterceptorSwarm(List<Agent> swarm) {
 0208    List<(Agent, bool)> swarmTuple = swarm.ConvertAll(agent => (agent, true));
 0209    _interceptorSwarms.Add(swarmTuple);
 0210    foreach (var interceptor in swarm) {
 0211      _interceptorSwarmMap[interceptor] = swarmTuple;
 0212    }
 0213    OnInterceptorSwarmChanged?.Invoke(_interceptorSwarms);
 0214  }
 215
 0216  public void AddSubmunitionsSwarm(List<Agent> swarm) {
 0217    List<(Agent, bool)> swarmTuple = swarm.ConvertAll(agent => (agent, true));
 0218    _submunitionsSwarms.Add(swarmTuple);
 0219    foreach (var submunition in swarm) {
 0220      _submunitionsSwarmMap[submunition] = swarmTuple;
 0221    }
 0222    AddInterceptorSwarm(swarm);
 0223    _submunitionInterceptorSwarmMap[swarmTuple] = _interceptorSwarms[_interceptorSwarms.Count - 1];
 0224    OnSubmunitionsSwarmChanged?.Invoke(_submunitionsSwarms);
 0225  }
 226
 0227  public int LookupSubmunitionSwarmIndexInInterceptorSwarm(List<(Agent, bool)> swarm) {
 0228    if (_submunitionInterceptorSwarmMap.TryGetValue(swarm, out var interceptorSwarm)) {
 0229      return _interceptorSwarms.IndexOf(interceptorSwarm);
 230    }
 231    // Return -1 if the swarm is not found.
 0232    return -1;
 0233  }
 234
 0235  public void AddThreatSwarm(List<Agent> swarm) {
 0236    List<(Agent, bool)> swarmTuple = swarm.ConvertAll(agent => (agent, true));
 0237    _threatSwarms.Add(swarmTuple);
 0238    foreach (var threat in swarm) {
 0239      _threatSwarmMap[threat] = swarmTuple;
 0240    }
 0241    OnThreatSwarmChanged?.Invoke(_threatSwarms);
 0242  }
 243
 0244  public Vector3 GetAllAgentsCenter() {
 0245    List<Agent> allAgents = _interceptorObjects.ConvertAll(interceptor => interceptor as Agent)
 0246                                .Concat(_threatObjects.ConvertAll(threat => threat as Agent))
 247                                .ToList();
 0248    return GetSwarmCenter(allAgents);
 0249  }
 250
 0251  public Vector3 GetSwarmCenter(List<Agent> swarm) {
 0252    if (swarm.Count == 0) {
 0253      return Vector3.zero;
 254    }
 255
 0256    Vector3 sum = Vector3.zero;
 0257    int count = 0;
 0258    int swarmCount = swarm.Count;
 259
 0260    for (int i = 0; i < swarmCount; ++i) {
 0261      Agent agent = swarm[i];
 0262      if (!agent.IsTerminated()) {
 0263        sum += agent.transform.position;
 0264        ++count;
 0265      }
 0266    }
 267
 0268    return count > 0 ? sum / count : Vector3.zero;
 0269  }
 270
 0271  public List<List<(Agent, bool)>> GetInterceptorSwarms() {
 0272    return _interceptorSwarms;
 0273  }
 274
 0275  public List<List<(Agent, bool)>> GetSubmunitionsSwarms() {
 0276    return _submunitionsSwarms;
 0277  }
 278
 0279  public List<List<(Agent, bool)>> GetThreatSwarms() {
 0280    return _threatSwarms;
 0281  }
 282
 0283  public void DestroyInterceptorInSwarm(Interceptor interceptor) {
 0284    var swarm = _interceptorSwarmMap[interceptor];
 0285    int index = swarm.FindIndex(tuple => tuple.Item1 == interceptor);
 0286    if (index != -1) {
 0287      swarm[index] = (swarm[index].Item1, false);
 0288      OnInterceptorSwarmChanged?.Invoke(_interceptorSwarms);
 0289    } else {
 0290      Debug.LogError("Interceptor not found in swarm.");
 0291    }
 0292    if (swarm.All(tuple => !tuple.Item2)) {
 293      // Need to give the camera controller a way to update to the next swarm if it exists.
 0294      if (CameraController.Instance.cameraMode == CameraMode.FOLLOW_INTERCEPTOR_SWARM) {
 0295        CameraController.Instance.FollowNextInterceptorSwarm();
 0296      }
 0297    }
 298
 299    // If this also happens to be a submunition, destroy it in the submunition swarm.
 0300    if (_submunitionsSwarmMap.ContainsKey(interceptor)) {
 0301      DestroySubmunitionInSwarm(interceptor);
 0302    }
 0303  }
 304
 0305  public void DestroySubmunitionInSwarm(Interceptor submunition) {
 0306    var swarm = _submunitionsSwarmMap[submunition];
 0307    int index = swarm.FindIndex(tuple => tuple.Item1 == submunition);
 0308    if (index != -1) {
 0309      swarm[index] = (swarm[index].Item1, false);
 0310      OnSubmunitionsSwarmChanged?.Invoke(_submunitionsSwarms);
 0311    }
 0312  }
 313
 0314  public void DestroyThreatInSwarm(Threat threat) {
 0315    var swarm = _threatSwarmMap[threat];
 0316    int index = swarm.FindIndex(tuple => tuple.Item1 == threat);
 0317    if (index != -1) {
 0318      swarm[index] = (swarm[index].Item1, false);
 0319      OnThreatSwarmChanged?.Invoke(_threatSwarms);
 0320    }
 0321    if (swarm.All(tuple => !tuple.Item2)) {
 0322      _threatSwarms.Remove(swarm);
 0323      if (CameraController.Instance.cameraMode == CameraMode.FOLLOW_THREAT_SWARM) {
 0324        CameraController.Instance.FollowNextThreatSwarm();
 0325      }
 0326    }
 0327  }
 328
 0329  public void RegisterInterceptorHit(Interceptor interceptor, Threat threat) {
 0330    _costDestroyedThreats += threat.staticAgentConfig.unitCost;
 0331    if (interceptor is Interceptor missileComponent) {
 0332      _activeInterceptors.Remove(missileComponent);
 0333    }
 0334    DestroyInterceptorInSwarm(interceptor);
 0335    DestroyThreatInSwarm(threat);
 0336  }
 337
 0338  public void RegisterInterceptorMiss(Interceptor interceptor, Threat threat) {
 0339    if (interceptor is Interceptor missileComponent) {
 0340      _activeInterceptors.Remove(missileComponent);
 0341    }
 0342    DestroyInterceptorInSwarm(interceptor);
 0343  }
 344
 0345  public void RegisterThreatHit(Threat threat) {
 0346    DestroyThreatInSwarm(threat);
 0347  }
 348
 0349  public void RegisterThreatMiss(Threat threat) {
 0350    DestroyThreatInSwarm(threat);
 0351  }
 352
 15353  private AttackBehavior LoadAttackBehavior(DynamicAgentConfig config) {
 15354    string threatBehaviorFile = config.attack_behavior;
 15355    AttackBehavior attackBehavior = AttackBehavior.FromJson(threatBehaviorFile);
 15356    switch (attackBehavior.attackBehaviorType) {
 357      case AttackBehavior.AttackBehaviorType.DIRECT_ATTACK:
 15358        return DirectAttackBehavior.FromJson(threatBehaviorFile);
 359      default:
 0360        Debug.LogError($"Attack behavior type '{attackBehavior.attackBehaviorType}' not found.");
 0361        return null;
 362    }
 15363  }
 364
 15365  public Agent CreateDummyAgent(Vector3 position, Vector3 velocity) {
 23366    if (_dummyAgentTable.ContainsKey((position, velocity))) {
 8367      return _dummyAgentTable[(position, velocity)].GetComponent<Agent>();
 368    }
 7369    GameObject dummyAgentPrefab = Resources.Load<GameObject>($"Prefabs/DummyAgent");
 7370    GameObject dummyAgentObject = Instantiate(dummyAgentPrefab, position, Quaternion.identity);
 14371    if (!dummyAgentObject.TryGetComponent<Agent>(out _)) {
 7372      dummyAgentObject.AddComponent<DummyAgent>();
 7373    }
 7374    Rigidbody dummyRigidbody = dummyAgentObject.GetComponent<Rigidbody>();
 7375    dummyRigidbody.linearVelocity = velocity;
 7376    _dummyAgentObjects.Add(dummyAgentObject);
 7377    _dummyAgentTable[(position, velocity)] = dummyAgentObject;
 7378    return dummyAgentObject.GetComponent<Agent>();
 15379  }
 380
 381  /// <summary>
 382  /// Creates a interceptor based on the provided configuration.
 383  /// </summary>
 384  /// <param name="config">Configuration settings for the interceptor.</param>
 385  /// <param name="initialState">Initial state of the interceptor.</param>
 386  /// <returns>The created Interceptor instance, or null if creation failed.</returns>
 0387  public Interceptor CreateInterceptor(DynamicAgentConfig config, InitialState initialState) {
 0388    string interceptorModelFile = config.agent_model;
 0389    interceptorModelFile = "Interceptors/" + interceptorModelFile;
 0390    StaticAgentConfig interceptorStaticAgentConfig =
 391        ConfigLoader.LoadStaticAgentConfig(interceptorModelFile);
 0392    string agentClass = interceptorStaticAgentConfig.agentClass;
 393    // The interceptor class corresponds to the Prefab that must exist in the Resources/Prefabs
 394    // folder.
 0395    GameObject interceptorObject = CreateAgent(config, initialState, agentClass);
 396
 0397    if (interceptorObject == null)
 0398      return null;
 399
 400    // Interceptor-specific logic.
 0401    switch (config.dynamic_config.sensor_config.type) {
 402      case SensorType.IDEAL:
 0403        interceptorObject.AddComponent<IdealSensor>();
 0404        break;
 405      default:
 0406        Debug.LogError($"Sensor type '{config.dynamic_config.sensor_config.type}' not found.");
 0407        break;
 408    }
 409
 0410    Interceptor interceptor = interceptorObject.GetComponent<Interceptor>();
 0411    _interceptorObjects.Add(interceptor);
 0412    _activeInterceptors.Add(interceptor);
 413
 414    // Set the static agent config.
 0415    interceptor.SetStaticAgentConfig(interceptorStaticAgentConfig);
 416
 417    // Subscribe events.
 0418    interceptor.OnInterceptHit += RegisterInterceptorHit;
 0419    interceptor.OnInterceptMiss += RegisterInterceptorMiss;
 420
 421    // Assign a unique and simple ID.
 0422    int interceptorId = _interceptorObjects.Count;
 0423    interceptorObject.name = $"{interceptorStaticAgentConfig.name}_Interceptor_{interceptorId}";
 424
 425    // Add the interceptor's unit cost to the total cost.
 0426    _costLaunchedInterceptors += interceptorStaticAgentConfig.unitCost;
 427
 428    // Let listeners know a new interceptor has been created.
 0429    OnNewInterceptor?.Invoke(interceptor);
 430
 0431    return interceptor;
 0432  }
 433
 434  /// <summary>
 435  /// Creates a threat based on the provided configuration.
 436  /// </summary>
 437  /// <param name="config">Configuration settings for the threat.</param>
 438  /// <returns>The created Threat instance, or null if creation failed.</returns>
 15439  private Threat CreateThreat(DynamicAgentConfig config) {
 15440    string threatModelFile = config.agent_model;
 15441    threatModelFile = "Threats/" + threatModelFile;
 15442    StaticAgentConfig threatStaticAgentConfig = ConfigLoader.LoadStaticAgentConfig(threatModelFile);
 15443    string agentClass = threatStaticAgentConfig.agentClass;
 444    // The threat class corresponds to the Prefab that must exist in the Resources/Prefabs folder.
 15445    GameObject threatObject = CreateRandomAgent(config, agentClass);
 446
 15447    if (threatObject == null)
 0448      return null;
 449
 15450    Threat threat = threatObject.GetComponent<Threat>();
 15451    _threatObjects.Add(threat);
 452
 453    // Set the static agent config.
 15454    threat.SetStaticAgentConfig(threatStaticAgentConfig);
 455
 456    // Set the attack behavior.
 15457    AttackBehavior attackBehavior = LoadAttackBehavior(config);
 15458    threat.SetAttackBehavior(attackBehavior);
 459
 460    // Subscribe events.
 15461    threat.OnThreatHit += RegisterThreatHit;
 15462    threat.OnThreatMiss += RegisterThreatMiss;
 463
 464    // Assign a unique and simple ID.
 15465    int threatId = _threatObjects.Count;
 15466    threatObject.name = $"{threatStaticAgentConfig.name}_Threat_{threatId}";
 467
 468    // Let listeners know that a new threat has been created.
 15469    OnNewThreat?.Invoke(threat);
 470
 15471    return threatObject.GetComponent<Threat>();
 15472  }
 473
 474  /// <summary>
 475  /// Creates a agent based on the provided configuration and prefab name.
 476  /// </summary>
 477  /// <param name="config">Configuration settings for the agent.</param>
 478  /// <param name="initialState">Initial state of the agent.</param>
 479  /// <param name="prefabName">Name of the prefab to instantiate.</param>
 480  /// <returns>The created GameObject instance, or null if creation failed.</returns>
 481  public GameObject CreateAgent(DynamicAgentConfig config, InitialState initialState,
 15482                                string prefabName) {
 15483    GameObject prefab = Resources.Load<GameObject>($"Prefabs/{prefabName}");
 15484    if (prefab == null) {
 0485      Debug.LogError($"Prefab '{prefabName}' not found in Resources/Prefabs folder.");
 0486      return null;
 487    }
 488
 489    // Set the position.
 15490    GameObject agentObject = Instantiate(prefab, initialState.position, Quaternion.identity);
 491
 492    // Set the velocity. The rigid body is frozen while the agent is in the initialized phase.
 15493    agentObject.GetComponent<Agent>().SetInitialVelocity(initialState.velocity);
 494
 495    // Set the rotation to face the initial velocity.
 15496    Vector3 velocityDirection = initialState.velocity.normalized;
 15497    Quaternion targetRotation = Quaternion.LookRotation(velocityDirection, Vector3.up);
 15498    agentObject.transform.rotation = targetRotation;
 499
 15500    agentObject.GetComponent<Agent>().SetDynamicAgentConfig(config);
 15501    return agentObject;
 15502  }
 503
 504  /// <summary>
 505  /// Creates a random agent based on the provided configuration and prefab name.
 506  /// </summary>
 507  /// <param name="config">Configuration settings for the agent.</param>
 508  /// <param name="prefabName">Name of the prefab to instantiate.</param>
 509  /// <returns>The created GameObject instance, or null if creation failed.</returns>
 15510  public GameObject CreateRandomAgent(DynamicAgentConfig config, string prefabName) {
 15511    GameObject prefab = Resources.Load<GameObject>($"Prefabs/{prefabName}");
 15512    if (prefab == null) {
 0513      Debug.LogError($"Prefab '{prefabName}' not found in Resources/Prefabs folder.");
 0514      return null;
 515    }
 516
 517    // Randomize the initial state.
 15518    InitialState initialState = new InitialState();
 519
 520    // Randomize the position.
 15521    Vector3 positionNoise = Utilities.GenerateRandomNoise(config.standard_deviation.position);
 15522    initialState.position = config.initial_state.position + positionNoise;
 523
 524    // Randomize the velocity.
 15525    Vector3 velocityNoise = Utilities.GenerateRandomNoise(config.standard_deviation.velocity);
 15526    initialState.velocity = config.initial_state.velocity + velocityNoise;
 15527    return CreateAgent(config, initialState, prefabName);
 15528  }
 529
 0530  public void LoadNewConfig(string configFileName) {
 0531    this.SimulationConfig = ConfigLoader.LoadSimulationConfig(configFileName);
 532    // Reload the simulator config
 0533    this.simulatorConfig = ConfigLoader.LoadSimulatorConfig();
 0534    if (SimulationConfig != null) {
 0535      Debug.Log($"Loaded new configuration: {configFileName}.");
 0536      RestartSimulation();
 0537    } else {
 0538      Debug.LogError($"Failed to load configuration: {configFileName}.");
 0539    }
 0540  }
 541
 0542  public void RestartSimulation() {
 0543    OnSimulationEnded?.Invoke();
 0544    Debug.Log("Simulation ended");
 0545    UIManager.Instance.LogActionMessage("[SIM] Simulation restarted.");
 546    // Reset the simulation time.
 0547    _elapsedSimulationTime = 0f;
 0548    _isSimulationPaused = IsSimulationPaused();
 0549    _costLaunchedInterceptors = 0f;
 0550    _costDestroyedThreats = 0f;
 551
 552    // Clear existing interceptors and threats.
 0553    foreach (var interceptor in _interceptorObjects) {
 0554      if (interceptor != null) {
 0555        Destroy(interceptor.gameObject);
 0556      }
 0557    }
 558
 0559    foreach (var threat in _threatObjects) {
 0560      if (threat != null) {
 0561        Destroy(threat.gameObject);
 0562      }
 0563    }
 564
 0565    foreach (var dummyAgent in _dummyAgentObjects) {
 0566      if (dummyAgent != null) {
 0567        Destroy(dummyAgent);
 0568      }
 0569    }
 570
 0571    _interceptorObjects.Clear();
 0572    _activeInterceptors.Clear();
 0573    _threatObjects.Clear();
 0574    _dummyAgentObjects.Clear();
 0575    _dummyAgentTable.Clear();
 0576    _interceptorSwarms.Clear();
 0577    _submunitionsSwarms.Clear();
 0578    _threatSwarms.Clear();
 0579    OnInterceptorSwarmChanged?.Invoke(_interceptorSwarms);
 0580    OnSubmunitionsSwarmChanged?.Invoke(_submunitionsSwarms);
 0581    OnThreatSwarmChanged?.Invoke(_threatSwarms);
 0582    StartSimulation();
 0583  }
 584
 0585  void FixedUpdate() {
 0586    if (!_isSimulationPaused && _elapsedSimulationTime < SimulationConfig.endTime) {
 0587      _elapsedSimulationTime += Time.deltaTime;
 0588    } else if (_elapsedSimulationTime >= SimulationConfig.endTime) {
 0589      RestartSimulation();
 0590      Debug.Log("Simulation completed.");
 0591    }
 0592  }
 593
 0594  public void QuitSimulation() {
 0595    Application.Quit();
 0596  }
 597}
 598
 599[System.Serializable]
 600public class SimulatorConfig {
 601  public bool enableTelemetryLogging;
 602  public bool enableEventLogging;
 603  public bool enableMissileTrailEffect;
 604  public bool enableExplosionEffect;
 605  public int physicsUpdateRate;
 606  public bool persistentFlightTrails;
 607}
Generated by: ReportGenerator 5.0.4.0
04/03/2025 - 03:03:49
GitHub | www.palmmedia.de

Methods/Properties

Instance()
Instance(SimManager)
SimManager()
GetElapsedSimulationTime()
GetCostLaunchedInterceptors()
GetCostDestroyedThreats()
GetActiveInterceptors()
GetActiveThreats()
GetActiveAgents()
GenerateSwarmTitle(System.Collections.Generic.List[ValueTuple`2], System.Int32)
GenerateInterceptorSwarmTitle(System.Collections.Generic.List[ValueTuple`2])
GenerateSubmunitionsSwarmTitle(System.Collections.Generic.List[ValueTuple`2])
GenerateThreatSwarmTitle(System.Collections.Generic.List[ValueTuple`2])
Awake()
Start()
Update()
SetTimeScale(System.Single)
StartSimulation()
PauseSimulation()
ResumeSimulation()
IsSimulationPaused()
InitializeSimulation()
AddInterceptorSwarm(System.Collections.Generic.List[Agent])
AddSubmunitionsSwarm(System.Collections.Generic.List[Agent])
LookupSubmunitionSwarmIndexInInterceptorSwarm(System.Collections.Generic.List[ValueTuple`2])
AddThreatSwarm(System.Collections.Generic.List[Agent])
GetAllAgentsCenter()
GetSwarmCenter(System.Collections.Generic.List[Agent])
GetInterceptorSwarms()
GetSubmunitionsSwarms()
GetThreatSwarms()
DestroyInterceptorInSwarm(Interceptor)
DestroySubmunitionInSwarm(Interceptor)
DestroyThreatInSwarm(Threat)
RegisterInterceptorHit(Interceptor, Threat)
RegisterInterceptorMiss(Interceptor, Threat)
RegisterThreatHit(Threat)
RegisterThreatMiss(Threat)
LoadAttackBehavior(DynamicAgentConfig)
CreateDummyAgent(UnityEngine.Vector3, UnityEngine.Vector3)
CreateInterceptor(DynamicAgentConfig, InitialState)
CreateThreat(DynamicAgentConfig)
CreateAgent(DynamicAgentConfig, InitialState, System.String)
CreateRandomAgent(DynamicAgentConfig, System.String)
LoadNewConfig(System.String)
RestartSimulation()
FixedUpdate()
QuitSimulation()