< Summary

Class:Agent
Assembly:bamlab.micromissiles
File(s):/github/workspace/Assets/Scripts/Agent.cs
Covered lines:160
Uncovered lines:100
Coverable lines:260
Total lines:465
Line coverage:61.5% (160 of 260)
Covered branches:0
Total branches:0
Covered methods:27
Total methods:46
Method coverage:58.6% (27 of 46)

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
Agent()0%110100%
SetFlightPhase(...)0%440100%
GetFlightPhase()0%110100%
HasLaunched()0%2100%
HasTerminated()0%2100%
SetDynamicAgentConfig(...)0%110100%
SetStaticAgentConfig(...)0%110100%
IsAssignable()0%2100%
AssignTarget(...)0%2100%
GetAssignedTarget()0%2100%
HasAssignedTarget()0%110100%
GetTargetModel()0%2100%
UnassignTarget()0%6200%
IsTerminated()0%110100%
AddInterceptor(...)0%2100%
RemoveInterceptor(...)0%2100%
TerminateAgent()0%12300%
HandleInterceptHit(...)0%20400%
HandleInterceptMiss()0%20400%
HandleTargetIntercepted()0%6200%
HandleThreatHit()0%12300%
HandleHitGround()0%42600%
SetInitialVelocity(...)0%110100%
GetPosition()0%110100%
SetPosition(...)0%110100%
GetSpeed()0%110100%
GetVelocity()0%110100%
SetVelocity(...)0%110100%
GetAcceleration()0%2100%
SetAcceleration(...)0%2100%
GetRelativeTransformation(...)0%2100%
GetRelativeTransformationToWaypoint(...)0%110100%
GetRelativePositionTransformation(...)0%2.032081.25%
GetRelativeVelocityTransformation(...)0%5.225079.31%
GetRelativeAccelerationTransformation(...)0%2100%
GetDynamicPressure()0%110100%
Awake()0%110100%
Start()0%110100%
FixedUpdate()0%14.0213081.82%
AlignWithVelocity()0%220100%
CalculateAcceleration(...)0%110100%
CalculateMaxForwardAcceleration()0%110100%
CalculateMaxNormalAcceleration()0%110100%
CalculateDrag()0%110100%
CalculateLiftInducedDrag(...)0%110100%

File(s)

/github/workspace/Assets/Scripts/Agent.cs

#LineLine coverage
 1using System.Collections;
 2using System.Collections.Generic;
 3using UnityEngine;
 4
 5public abstract class Agent : MonoBehaviour {
 6  // In the initialized phase, the agent is subject to no forces.
 7  // In the ready phase, the agent is subject to gravity and drag with zero input acceleration.
 8  public enum FlightPhase { INITIALIZED, READY, BOOST, MIDCOURSE, TERMINAL, TERMINATED }
 9
 10  [SerializeField]
 94411  private FlightPhase _flightPhase = FlightPhase.INITIALIZED;
 12
 13  [SerializeField]
 14  protected Vector3 _velocity;
 15
 16  [SerializeField]
 17  protected Vector3 _acceleration;
 18
 19  [SerializeField]
 20  protected Vector3 _dragAcceleration;
 21
 22  [SerializeField]
 23  protected float _speed;
 24
 25  [SerializeField]
 94426  protected List<Agent> _interceptors = new List<Agent>();
 27  [SerializeField]
 28  protected Agent _target;
 29  [SerializeField]
 30  protected Agent _targetModel;
 31
 32  [SerializeField]
 94433  protected double _timeSinceBoost = 0;
 34  [SerializeField]
 94435  protected double _timeInPhase = 0;
 36
 37  public StaticAgentConfig staticAgentConfig;
 38  public DynamicAgentConfig dynamicAgentConfig;
 39
 40  // Define delegates.
 41  public delegate void TerminatedEventHandler(Agent agent);
 42  public event TerminatedEventHandler OnTerminated;
 43
 44  public delegate void InterceptHitEventHandler(Interceptor interceptor, Threat target);
 45  public delegate void InterceptMissEventHandler(Interceptor interceptor, Threat target);
 46  public delegate void ThreatHitEventHandler(Threat threat);
 47  public delegate void ThreatMissEventHandler(Threat threat);
 48
 49  // Define events.
 50  public event InterceptHitEventHandler OnInterceptHit;
 51  public event InterceptMissEventHandler OnInterceptMiss;
 52  public event ThreatHitEventHandler OnThreatHit;
 53  public event ThreatMissEventHandler OnThreatMiss;
 54
 55  private Vector3 _initialVelocity;
 56
 226557  public void SetFlightPhase(FlightPhase flightPhase) {
 226558    _timeInPhase = 0;
 226559    _flightPhase = flightPhase;
 302060    if (flightPhase == FlightPhase.INITIALIZED || flightPhase == FlightPhase.TERMINATED) {
 75561      GetComponent<Rigidbody>().constraints = RigidbodyConstraints.FreezeAll;
 226562    } else {
 151063      GetComponent<Rigidbody>().constraints = RigidbodyConstraints.None;
 151064    }
 302065    if (flightPhase == FlightPhase.BOOST) {
 75566      SetVelocity(GetVelocity() + _initialVelocity);
 75567    }
 226568  }
 69
 56470  public FlightPhase GetFlightPhase() {
 56471    return _flightPhase;
 56472  }
 73
 074  public bool HasLaunched() {
 075    return _flightPhase != FlightPhase.INITIALIZED;
 076  }
 77
 078  public bool HasTerminated() {
 079    return _flightPhase == FlightPhase.TERMINATED;
 080  }
 81
 75582  public virtual void SetDynamicAgentConfig(DynamicAgentConfig config) {
 75583    dynamicAgentConfig = config;
 75584  }
 85
 75586  public virtual void SetStaticAgentConfig(StaticAgentConfig config) {
 75587    staticAgentConfig = config;
 75588    GetComponent<Rigidbody>().mass = staticAgentConfig.bodyConfig.mass;
 75589  }
 90
 091  public virtual bool IsAssignable() {
 092    return true;
 093  }
 94
 095  public virtual void AssignTarget(Agent target) {
 096    _target = target;
 097    _target.AddInterceptor(this);
 098    _targetModel = SimManager.Instance.CreateDummyAgent(target.GetPosition(), target.GetVelocity());
 099  }
 100
 0101  public Agent GetAssignedTarget() {
 0102    return _target;
 0103  }
 104
 5590105  public bool HasAssignedTarget() {
 5590106    return _target != null;
 5590107  }
 108
 0109  public Agent GetTargetModel() {
 0110    return _targetModel;
 0111  }
 112
 0113  public virtual void UnassignTarget() {
 0114    if (HasAssignedTarget()) {
 0115      _target.RemoveInterceptor(this);
 0116    }
 0117    _target = null;
 0118    _targetModel = null;
 0119  }
 120
 1319121  public bool IsTerminated() {
 1319122    return _flightPhase == FlightPhase.TERMINATED;
 1319123  }
 124
 0125  public void AddInterceptor(Agent interceptor) {
 0126    _interceptors.Add(interceptor);
 0127  }
 128
 0129  public void RemoveInterceptor(Agent interceptor) {
 0130    _interceptors.Remove(interceptor);
 0131  }
 132
 133  public IReadOnlyList<Agent> AssignedInterceptors {
 2265134    get { return _interceptors; }
 135  }
 136
 0137  public virtual void TerminateAgent() {
 0138    UnassignTarget();
 0139    if (_flightPhase != FlightPhase.TERMINATED) {
 0140      OnTerminated?.Invoke(this);
 0141    }
 0142    _flightPhase = FlightPhase.TERMINATED;
 0143    SetPosition(Vector3.zero);
 0144    gameObject.SetActive(false);
 0145  }
 146
 0147  public void HandleInterceptHit(Agent agent) {
 0148    if (this is Interceptor interceptor && agent is Threat threat) {
 0149      OnInterceptHit?.Invoke(interceptor, threat);
 0150      TerminateAgent();
 0151    }
 0152  }
 153
 0154  public void HandleInterceptMiss() {
 0155    if (this is Interceptor interceptor && _target is Threat threat) {
 0156      OnInterceptMiss?.Invoke(interceptor, threat);
 0157    }
 0158  }
 159
 0160  public void HandleTargetIntercepted() {
 0161    if (this is Threat threat) {
 0162      TerminateAgent();
 0163    }
 0164  }
 165
 0166  public void HandleThreatHit() {
 0167    if (this is Threat threat) {
 0168      OnThreatHit?.Invoke(threat);
 0169      TerminateAgent();
 0170    }
 0171  }
 172
 0173  public void HandleHitGround() {
 0174    if (this is Interceptor interceptor && _target is Threat target) {
 0175      OnInterceptMiss?.Invoke(interceptor, target);
 0176    }
 0177    if (this is Threat threat) {
 0178      OnThreatMiss?.Invoke(threat);
 0179    }
 0180    TerminateAgent();
 0181  }
 182
 755183  public void SetInitialVelocity(Vector3 velocity) {
 755184    _initialVelocity = velocity;
 755185  }
 186
 11180187  public Vector3 GetPosition() {
 11180188    return transform.position;
 11180189  }
 190
 476191  public void SetPosition(Vector3 position) {
 476192    transform.position = position;
 476193  }
 194
 16783195  public double GetSpeed() {
 16783196    return GetComponent<Rigidbody>().linearVelocity.magnitude;
 16783197  }
 198
 34321199  public Vector3 GetVelocity() {
 34321200    return GetComponent<Rigidbody>().linearVelocity;
 34321201  }
 202
 1231203  public void SetVelocity(Vector3 velocity) {
 1231204    GetComponent<Rigidbody>().linearVelocity = velocity;
 1231205  }
 206
 0207  public Vector3 GetAcceleration() {
 0208    return _acceleration;
 0209  }
 210
 0211  public void SetAcceleration(Vector3 acceleration) {
 0212    _acceleration = acceleration;
 0213  }
 214
 0215  public Transformation GetRelativeTransformation(Agent target) {
 0216    Transformation transformation = new Transformation();
 217
 218    // Get the relative position transformation.
 0219    transformation.position =
 220        GetRelativePositionTransformation(target.GetPosition() - GetPosition());
 221
 222    // Get the relative velocity transformation.
 0223    transformation.velocity = GetRelativeVelocityTransformation(
 224        target.GetPosition() - GetPosition(), target.GetVelocity() - GetVelocity());
 225
 226    // Get the relative acceleration transformation.
 0227    transformation.acceleration = GetRelativeAccelerationTransformation(target);
 0228    return transformation;
 0229  }
 230
 5590231  public Transformation GetRelativeTransformationToWaypoint(Vector3 waypoint) {
 5590232    Transformation transformation = new Transformation();
 233
 234    // Get the relative position transformation.
 5590235    transformation.position = GetRelativePositionTransformation(waypoint - GetPosition());
 236
 237    // Get the relative velocity transformation.
 5590238    transformation.velocity =
 239        GetRelativeVelocityTransformation(waypoint - GetPosition(), -GetVelocity());
 240
 5590241    return transformation;
 5590242  }
 243
 5590244  private PositionTransformation GetRelativePositionTransformation(Vector3 relativePosition) {
 5590245    PositionTransformation positionTransformation = new PositionTransformation();
 246
 247    // Set the relative position in Cartesian coordinates.
 5590248    positionTransformation.cartesian = relativePosition;
 249
 250    // Calculate the distance (range) to the target.
 5590251    positionTransformation.range = relativePosition.magnitude;
 252
 5590253    Vector3 flatRelativePosition = Vector3.ProjectOnPlane(relativePosition, transform.up);
 5590254    Vector3 verticalRelativePosition = relativePosition - flatRelativePosition;
 255
 256    // Calculate the elevation (vertical angle relative to forward).
 5590257    positionTransformation.elevation =
 258        Mathf.Atan(verticalRelativePosition.magnitude / flatRelativePosition.magnitude);
 259
 260    // Calculate the azimuth (horizontal angle relative to forward).
 5590261    if (flatRelativePosition.magnitude == 0) {
 0262      positionTransformation.azimuth = 0;
 5590263    } else {
 5590264      positionTransformation.azimuth =
 265          Vector3.SignedAngle(transform.forward, flatRelativePosition, transform.up) * Mathf.PI /
 266          180;
 5590267    }
 268
 5590269    return positionTransformation;
 5590270  }
 271
 272  private VelocityTransformation GetRelativeVelocityTransformation(Vector3 relativePosition,
 5590273                                                                   Vector3 relativeVelocity) {
 5590274    VelocityTransformation velocityTransformation = new VelocityTransformation();
 275
 276    // Set the relative velocity in Cartesian coordinates.
 5590277    velocityTransformation.cartesian = relativeVelocity;
 278
 279    // Calculate range rate (radial velocity).
 5590280    velocityTransformation.range = Vector3.Dot(relativeVelocity, relativePosition.normalized);
 281
 282    // Project relative velocity onto the sphere passing through the target.
 5590283    Vector3 tangentialVelocity = Vector3.ProjectOnPlane(relativeVelocity, relativePosition);
 284
 285    // The target azimuth vector is orthogonal to the relative position vector and
 286    // points to the starboard of the target along the azimuth-elevation sphere.
 5590287    Vector3 targetAzimuth = Vector3.Cross(transform.up, relativePosition);
 288    // The target elevation vector is orthogonal to the relative position vector
 289    // and points upwards from the target along the azimuth-elevation sphere.
 5590290    Vector3 targetElevation = Vector3.Cross(relativePosition, transform.right);
 291    // If the relative position vector is parallel to the yaw or pitch axis, the
 292    // target azimuth vector or the target elevation vector will be undefined.
 5590293    if (targetAzimuth.magnitude == 0) {
 0294      targetAzimuth = Vector3.Cross(targetElevation, relativePosition);
 5590295    } else if (targetElevation.magnitude == 0) {
 0296      targetElevation = Vector3.Cross(relativePosition, targetAzimuth);
 0297    }
 298
 299    // Project the relative velocity vector on the azimuth-elevation sphere onto
 300    // the target azimuth vector.
 5590301    Vector3 tangentialVelocityOnAzimuth = Vector3.Project(tangentialVelocity, targetAzimuth);
 302
 303    // Calculate the time derivative of the azimuth to the target.
 5590304    velocityTransformation.azimuth =
 305        tangentialVelocityOnAzimuth.magnitude / relativePosition.magnitude;
 8527306    if (Vector3.Dot(tangentialVelocityOnAzimuth, targetAzimuth) < 0) {
 2937307      velocityTransformation.azimuth *= -1;
 2937308    }
 309
 310    // Project the velocity vector on the azimuth-elevation sphere onto the target
 311    // elevation vector.
 5590312    Vector3 tangentialVelocityOnElevation = Vector3.Project(tangentialVelocity, targetElevation);
 313
 314    // Calculate the time derivative of the elevation to the target.
 5590315    velocityTransformation.elevation =
 316        tangentialVelocityOnElevation.magnitude / relativePosition.magnitude;
 11061317    if (Vector3.Dot(tangentialVelocityOnElevation, targetElevation) < 0) {
 5471318      velocityTransformation.elevation *= -1;
 5471319    }
 320
 5590321    return velocityTransformation;
 5590322  }
 323
 0324  private AccelerationTransformation GetRelativeAccelerationTransformation(Agent agent) {
 325    // Since the agent's acceleration is an input, the relative acceleration is just the agent's
 326    // acceleration.
 0327    AccelerationTransformation accelerationTransformation = new AccelerationTransformation();
 0328    accelerationTransformation.cartesian = agent.GetAcceleration();
 0329    return accelerationTransformation;
 0330  }
 331
 4848332  public double GetDynamicPressure() {
 4848333    var airDensity = Constants.CalculateAirDensityAtAltitude(transform.position.y);
 4848334    var flowSpeed = GetSpeed();
 4848335    return 0.5 * airDensity * (flowSpeed * flowSpeed);
 4848336  }
 337
 338  protected abstract void UpdateReady(double deltaTime);
 339  protected abstract void UpdateBoost(double deltaTime);
 340  protected abstract void UpdateMidCourse(double deltaTime);
 341
 1884342  protected virtual void Awake() {}
 343
 344  // Start is called before the first frame update
 1884345  protected virtual void Start() {}
 346
 347  // Update is called once per frame
 6345348  protected virtual void FixedUpdate() {
 6345349    _speed = (float)GetSpeed();
 11935350    if (_flightPhase != FlightPhase.INITIALIZED && _flightPhase != FlightPhase.READY) {
 5590351      _timeSinceBoost += Time.fixedDeltaTime;
 5590352    }
 6345353    _timeInPhase += Time.fixedDeltaTime;
 354
 6345355    var boost_time = staticAgentConfig.boostConfig.boostTime;
 6345356    double elapsedSimulationTime = SimManager.Instance.GetElapsedSimulationTime();
 357
 6345358    if (_flightPhase == FlightPhase.TERMINATED) {
 0359      return;
 360    }
 7100361    if (_flightPhase == FlightPhase.INITIALIZED || _flightPhase == FlightPhase.READY) {
 755362      SetFlightPhase(FlightPhase.BOOST);
 755363    }
 7100364    if (_timeSinceBoost > boost_time && _flightPhase == FlightPhase.BOOST) {
 755365      SetFlightPhase(FlightPhase.MIDCOURSE);
 755366    }
 6345367    AlignWithVelocity();
 6345368    switch (_flightPhase) {
 369      case FlightPhase.INITIALIZED:
 0370        break;
 371      case FlightPhase.READY:
 0372        UpdateReady(Time.fixedDeltaTime);
 0373        break;
 374      case FlightPhase.BOOST:
 755375        UpdateBoost(Time.fixedDeltaTime);
 755376        break;
 377      case FlightPhase.MIDCOURSE:
 378      case FlightPhase.TERMINAL:
 5590379        UpdateMidCourse(Time.fixedDeltaTime);
 5590380        break;
 381      case FlightPhase.TERMINATED:
 0382        break;
 383    }
 384
 6345385    _velocity = GetVelocity();
 386    // Store the acceleration because it is set to zero after each simulation step
 6345387    _acceleration =
 388        GetComponent<Rigidbody>().GetAccumulatedForce() / GetComponent<Rigidbody>().mass;
 6345389  }
 390
 6345391  protected virtual void AlignWithVelocity() {
 6345392    Vector3 velocity = GetVelocity();
 6345393    if (velocity.magnitude > 0.1f)  // Only align if we have significant velocity
 6345394    {
 395      // Create a rotation with forward along velocity and up along world up
 6345396      Quaternion targetRotation = Quaternion.LookRotation(velocity, Vector3.up);
 397
 398      // Smoothly rotate towards the target rotation
 6345399      transform.rotation = Quaternion.RotateTowards(transform.rotation, targetRotation,
 400                                                    10000f * Time.fixedDeltaTime);
 6345401    }
 6345402  }
 403
 4848404  protected Vector3 CalculateAcceleration(Vector3 accelerationInput) {
 4848405    Vector3 gravity = Physics.gravity;
 4848406    float airDrag = CalculateDrag();
 4848407    float liftInducedDrag = CalculateLiftInducedDrag(accelerationInput + gravity);
 4848408    float dragAcceleration = -(airDrag + liftInducedDrag);
 409
 410    // Project the drag acceleration onto the forward direction
 4848411    Vector3 dragAccelerationAlongRoll = dragAcceleration * transform.forward;
 4848412    _dragAcceleration = dragAccelerationAlongRoll;
 413
 4848414    return accelerationInput + gravity + dragAccelerationAlongRoll;
 4848415  }
 416
 5590417  public float CalculateMaxForwardAcceleration() {
 5590418    return staticAgentConfig.accelerationConfig.maxForwardAcceleration;
 5590419  }
 420
 5590421  public float CalculateMaxNormalAcceleration() {
 5590422    float maxReferenceNormalAcceleration =
 423        (float)(staticAgentConfig.accelerationConfig.maxReferenceNormalAcceleration *
 424                Constants.kGravity);
 5590425    float referenceSpeed = staticAgentConfig.accelerationConfig.referenceSpeed;
 5590426    return Mathf.Pow((float)GetSpeed() / referenceSpeed, 2) * maxReferenceNormalAcceleration;
 5590427  }
 428
 4848429  private float CalculateDrag() {
 4848430    float dragCoefficient = staticAgentConfig.liftDragConfig.dragCoefficient;
 4848431    float crossSectionalArea = staticAgentConfig.bodyConfig.crossSectionalArea;
 4848432    float mass = staticAgentConfig.bodyConfig.mass;
 4848433    float dynamicPressure = (float)GetDynamicPressure();
 4848434    float dragForce = dragCoefficient * dynamicPressure * crossSectionalArea;
 4848435    return dragForce / mass;
 4848436  }
 437
 4848438  private float CalculateLiftInducedDrag(Vector3 accelerationInput) {
 4848439    float liftAcceleration = Vector3.ProjectOnPlane(accelerationInput, transform.up).magnitude;
 4848440    float liftDragRatio = staticAgentConfig.liftDragConfig.liftDragRatio;
 4848441    return Mathf.Abs(liftAcceleration / liftDragRatio);
 4848442  }
 443}
 444
 445public class DummyAgent : Agent {
 446  protected override void Start() {
 447    base.Start();
 448  }
 449
 450  protected override void FixedUpdate() {
 451    GetComponent<Rigidbody>().AddForce(_acceleration, ForceMode.Acceleration);
 452  }
 453
 454  protected override void UpdateReady(double deltaTime) {
 455    // Do nothing.
 456  }
 457
 458  protected override void UpdateBoost(double deltaTime) {
 459    // Do nothing.
 460  }
 461
 462  protected override void UpdateMidCourse(double deltaTime) {
 463    // Do nothing.
 464  }
 465}
Generated by: ReportGenerator 5.0.4.0
04/03/2025 - 03:06:43
GitHub | www.palmmedia.de

Methods/Properties

Agent()
SetFlightPhase(Agent/FlightPhase)
GetFlightPhase()
HasLaunched()
HasTerminated()
SetDynamicAgentConfig(DynamicAgentConfig)
SetStaticAgentConfig(StaticAgentConfig)
IsAssignable()
AssignTarget(Agent)
GetAssignedTarget()
HasAssignedTarget()
GetTargetModel()
UnassignTarget()
IsTerminated()
AddInterceptor(Agent)
RemoveInterceptor(Agent)
AssignedInterceptors()
TerminateAgent()
HandleInterceptHit(Agent)
HandleInterceptMiss()
HandleTargetIntercepted()
HandleThreatHit()
HandleHitGround()
SetInitialVelocity(UnityEngine.Vector3)
GetPosition()
SetPosition(UnityEngine.Vector3)
GetSpeed()
GetVelocity()
SetVelocity(UnityEngine.Vector3)
GetAcceleration()
SetAcceleration(UnityEngine.Vector3)
GetRelativeTransformation(Agent)
GetRelativeTransformationToWaypoint(UnityEngine.Vector3)
GetRelativePositionTransformation(UnityEngine.Vector3)
GetRelativeVelocityTransformation(UnityEngine.Vector3, UnityEngine.Vector3)
GetRelativeAccelerationTransformation(Agent)
GetDynamicPressure()
Awake()
Start()
FixedUpdate()
AlignWithVelocity()
CalculateAcceleration(UnityEngine.Vector3)
CalculateMaxForwardAcceleration()
CalculateMaxNormalAcceleration()
CalculateDrag()
CalculateLiftInducedDrag(UnityEngine.Vector3)