| | | 1 | | using System; |
| | | 2 | | using NUnit.Framework; |
| | | 3 | | using UnityEngine; |
| | | 4 | | using System.Collections.Generic; |
| | | 5 | | using System.Linq; |
| | | 6 | | using System.IO; |
| | | 7 | | |
| | | 8 | | public class ThreatTests : AgentTestBase { |
| | | 9 | | private FixedWingThreat _fixedWingThreat; |
| | | 10 | | private RotaryWingThreat _rotaryWingThreat; |
| | | 11 | | |
| | | 12 | | private const string TestDirectAttackPbtxt = |
| | | 13 | | @" |
| | | 14 | | name: ""Test Direct Attack"" |
| | | 15 | | type: DIRECT_ATTACK |
| | | 16 | | flight_plan { |
| | | 17 | | type: DISTANCE_TO_TARGET |
| | | 18 | | waypoints { |
| | | 19 | | distance: 10000 |
| | | 20 | | altitude: 500 |
| | | 21 | | power: MIL |
| | | 22 | | } |
| | | 23 | | waypoints { |
| | | 24 | | distance: 5000 |
| | | 25 | | altitude: 100 |
| | | 26 | | power: MAX |
| | | 27 | | } |
| | | 28 | | } |
| | | 29 | | "; |
| | | 30 | | |
| | 7 | 31 | | public override void Setup() { |
| | 7 | 32 | | base.Setup(); |
| | | 33 | | // Write the hard-coded attack behavior to a file. |
| | 7 | 34 | | string attackConfigPath = |
| | | 35 | | ConfigLoader.GetStreamingAssetsFilePath("Configs/Attacks/test_direct_attack.pbtxt"); |
| | 7 | 36 | | Directory.CreateDirectory(Path.GetDirectoryName(attackConfigPath)); |
| | 7 | 37 | | File.WriteAllText(attackConfigPath, TestDirectAttackPbtxt); |
| | | 38 | | |
| | 7 | 39 | | var ucavConfig = new Configs.AgentConfig() { |
| | | 40 | | ConfigFile = "ucav.pbtxt", AttackBehaviorConfigFile = "test_direct_attack.pbtxt", |
| | | 41 | | InitialState = |
| | | 42 | | new Simulation.State() { |
| | | 43 | | Position = new Simulation.CartesianCoordinates() { X = 2000, Y = 100, Z = 4000 }, |
| | | 44 | | Velocity = new Simulation.CartesianCoordinates() { X = -50, Y = 0, Z = -100 }, |
| | | 45 | | }, |
| | | 46 | | StandardDeviation = |
| | | 47 | | new Simulation.State() { |
| | | 48 | | Position = new Simulation.CartesianCoordinates() { X = 400, Y = 300, Z = 400 }, |
| | | 49 | | Velocity = new Simulation.CartesianCoordinates() { X = 0, Y = 0, Z = 15 }, |
| | | 50 | | }, |
| | | 51 | | DynamicConfig = |
| | | 52 | | new Configs.DynamicConfig() { |
| | | 53 | | SensorConfig = |
| | | 54 | | new Simulation.SensorConfig { |
| | | 55 | | Type = Simulation.SensorType.Ideal, |
| | | 56 | | Frequency = 100, |
| | | 57 | | }, |
| | | 58 | | } |
| | | 59 | | }; |
| | | 60 | | |
| | 7 | 61 | | var quadcopterConfig = new Configs.AgentConfig() { |
| | | 62 | | ConfigFile = "quadcopter.pbtxt", AttackBehaviorConfigFile = "test_direct_attack.pbtxt", |
| | | 63 | | InitialState = |
| | | 64 | | new Simulation.State() { |
| | | 65 | | Position = new Simulation.CartesianCoordinates() { X = 0, Y = 600, Z = 6000 }, |
| | | 66 | | Velocity = new Simulation.CartesianCoordinates() { X = 0, Y = 0, Z = -50 }, |
| | | 67 | | }, |
| | | 68 | | StandardDeviation = |
| | | 69 | | new Simulation.State() { |
| | | 70 | | Position = new Simulation.CartesianCoordinates() { X = 100, Y = 200, Z = 100 }, |
| | | 71 | | Velocity = new Simulation.CartesianCoordinates() { X = 0, Y = 0, Z = 25 }, |
| | | 72 | | }, |
| | | 73 | | DynamicConfig = |
| | | 74 | | new Configs.DynamicConfig() { |
| | | 75 | | SensorConfig = |
| | | 76 | | new Simulation.SensorConfig { |
| | | 77 | | Type = Simulation.SensorType.Ideal, |
| | | 78 | | Frequency = 100, |
| | | 79 | | }, |
| | | 80 | | } |
| | | 81 | | }; |
| | | 82 | | |
| | 7 | 83 | | Agent threatAgent = CreateTestThreat(ucavConfig); |
| | 7 | 84 | | Assert.IsNotNull(threatAgent); |
| | 7 | 85 | | Assert.IsTrue(threatAgent is FixedWingThreat); |
| | 7 | 86 | | _fixedWingThreat = (FixedWingThreat)threatAgent; |
| | 7 | 87 | | Assert.IsNotNull(_fixedWingThreat); |
| | | 88 | | |
| | 7 | 89 | | threatAgent = CreateTestThreat(quadcopterConfig); |
| | 7 | 90 | | Assert.IsNotNull(threatAgent); |
| | 7 | 91 | | Assert.IsTrue(threatAgent is RotaryWingThreat); |
| | 7 | 92 | | _rotaryWingThreat = (RotaryWingThreat)threatAgent; |
| | 7 | 93 | | Assert.IsNotNull(_rotaryWingThreat); |
| | 7 | 94 | | } |
| | | 95 | | |
| | 7 | 96 | | public override void Teardown() { |
| | 7 | 97 | | base.Teardown(); |
| | | 98 | | // Delete the attack configuration file. |
| | 7 | 99 | | string attackConfigPath = |
| | | 100 | | ConfigLoader.GetStreamingAssetsFilePath("Configs/Attacks/test_direct_attack.pbtxt"); |
| | 14 | 101 | | if (File.Exists(attackConfigPath)) { |
| | 7 | 102 | | File.Delete(attackConfigPath); |
| | 7 | 103 | | } |
| | | 104 | | |
| | 14 | 105 | | if (_fixedWingThreat != null) { |
| | 7 | 106 | | GameObject.DestroyImmediate(_fixedWingThreat.gameObject); |
| | 7 | 107 | | } |
| | | 108 | | |
| | 14 | 109 | | if (_rotaryWingThreat != null) { |
| | 7 | 110 | | GameObject.DestroyImmediate(_rotaryWingThreat.gameObject); |
| | 7 | 111 | | } |
| | 7 | 112 | | } |
| | | 113 | | |
| | | 114 | | [Test] |
| | 1 | 115 | | public void Threat_IsNotAssignable() { |
| | 1 | 116 | | Assert.IsFalse(_fixedWingThreat.IsAssignable()); |
| | 1 | 117 | | Assert.IsFalse(_rotaryWingThreat.IsAssignable()); |
| | 1 | 118 | | } |
| | | 119 | | |
| | | 120 | | [Test] |
| | 1 | 121 | | public void FixedWingThreat_CalculateAccelerationInput_RespectsMaxForwardAcceleration() { |
| | 1 | 122 | | SetPrivateField(_fixedWingThreat, "_currentWaypoint", Vector3.one * 1000f); |
| | 1 | 123 | | Vector3 acceleration = |
| | | 124 | | InvokePrivateMethod<Vector3>(_fixedWingThreat, "CalculateAccelerationInput"); |
| | 1 | 125 | | float maxForwardAcceleration = _fixedWingThreat.CalculateMaxForwardAcceleration(); |
| | | 126 | | const float epsilon = 1e-5f; |
| | 1 | 127 | | Assert.LessOrEqual(Vector3.Project(acceleration, _fixedWingThreat.transform.forward).magnitude, |
| | | 128 | | maxForwardAcceleration + epsilon); |
| | 1 | 129 | | } |
| | | 130 | | |
| | | 131 | | [Test] |
| | 1 | 132 | | public void FixedWingThreat_CalculateAccelerationInput_RespectsMaxNormalAcceleration() { |
| | 1 | 133 | | SetPrivateField(_fixedWingThreat, "_currentWaypoint", Vector3.one * 1000f); |
| | 1 | 134 | | Vector3 acceleration = |
| | | 135 | | InvokePrivateMethod<Vector3>(_fixedWingThreat, "CalculateAccelerationInput"); |
| | 1 | 136 | | float maxNormalAcceleration = _fixedWingThreat.CalculateMaxNormalAcceleration(); |
| | | 137 | | const float epsilon = 1e-5f; |
| | 1 | 138 | | Assert.LessOrEqual( |
| | | 139 | | acceleration.magnitude, maxNormalAcceleration + epsilon, |
| | | 140 | | $"Acceleration magnitude {acceleration.magnitude} should be less than or equal to the maximum normal acceleratio |
| | 1 | 141 | | } |
| | | 142 | | |
| | | 143 | | [Test] |
| | 1 | 144 | | public void RotaryWingThreat_CalculateAccelerationToWaypoint_RespectsMaxForwardAcceleration() { |
| | 1 | 145 | | SetPrivateField(_rotaryWingThreat, "_currentWaypoint", Vector3.one * 1000f); |
| | 1 | 146 | | Vector3 acceleration = |
| | | 147 | | InvokePrivateMethod<Vector3>(_rotaryWingThreat, "CalculateAccelerationToWaypoint"); |
| | 1 | 148 | | float maxForwardAcceleration = _rotaryWingThreat.CalculateMaxForwardAcceleration(); |
| | | 149 | | const float epsilon = 1e-5f; |
| | 1 | 150 | | Assert.LessOrEqual(Vector3.Project(acceleration, _fixedWingThreat.transform.forward).magnitude, |
| | | 151 | | maxForwardAcceleration + epsilon); |
| | 1 | 152 | | } |
| | | 153 | | |
| | | 154 | | [Test] |
| | 1 | 155 | | public void RotaryWingThreat_CalculateAccelerationToWaypoint_RespectsMaxNormalAcceleration() { |
| | 1 | 156 | | SetPrivateField(_rotaryWingThreat, "_currentWaypoint", Vector3.one * 1000f); |
| | 1 | 157 | | Vector3 acceleration = |
| | | 158 | | InvokePrivateMethod<Vector3>(_rotaryWingThreat, "CalculateAccelerationToWaypoint"); |
| | 1 | 159 | | float maxNormalAcceleration = _rotaryWingThreat.CalculateMaxNormalAcceleration(); |
| | | 160 | | const float epsilon = 1e-5f; |
| | | 161 | | // Calculate the normal acceleration. |
| | 1 | 162 | | Vector3 forwardComponent = Vector3.Project(acceleration, _rotaryWingThreat.transform.forward); |
| | 1 | 163 | | Vector3 normalComponent = acceleration - forwardComponent; |
| | | 164 | | |
| | 1 | 165 | | Assert.LessOrEqual( |
| | | 166 | | normalComponent.magnitude, maxNormalAcceleration + epsilon, |
| | | 167 | | $"Normal acceleration magnitude {normalComponent.magnitude} should be less than or equal to the maximum normal a |
| | 1 | 168 | | } |
| | | 169 | | |
| | | 170 | | [Test] |
| | 1 | 171 | | public void RotaryWingThreat_CalculateAccelerationToWaypoint_ComputesCorrectly() { |
| | 1 | 172 | | Vector3 initialPosition = new Vector3(0, 0, 0); |
| | 1 | 173 | | Vector3 waypoint = new Vector3(1000, 0, 0); |
| | 1 | 174 | | Vector3 initialVelocity = new Vector3(0, 0, 0); |
| | 1 | 175 | | float desiredSpeed = 50f; |
| | | 176 | | |
| | 1 | 177 | | _rotaryWingThreat.SetPosition(initialPosition); |
| | 1 | 178 | | SetPrivateField(_rotaryWingThreat, "_currentWaypoint", waypoint); |
| | 1 | 179 | | _rotaryWingThreat.SetVelocity(initialVelocity); |
| | 1 | 180 | | SetPrivateField(_rotaryWingThreat, "_currentPower", Configs.Power.Mil); |
| | | 181 | | |
| | | 182 | | // Assume that the lookup power table returns 50 for MIL. |
| | 1 | 183 | | float power = |
| | | 184 | | InvokePrivateMethod<float>(_rotaryWingThreat, "LookupPowerTable", Configs.Power.Mil); |
| | 1 | 185 | | Assert.AreEqual(desiredSpeed, power); |
| | | 186 | | |
| | 1 | 187 | | Vector3 accelerationInput = |
| | | 188 | | InvokePrivateMethod<Vector3>(_rotaryWingThreat, "CalculateAccelerationToWaypoint"); |
| | | 189 | | |
| | 1 | 190 | | Vector3 toWaypoint = waypoint - initialPosition; |
| | 1 | 191 | | Vector3 expectedAccelerationDir = toWaypoint.normalized; |
| | 1 | 192 | | float expectedAccelerationMag = desiredSpeed / (float)Time.fixedDeltaTime; |
| | 1 | 193 | | Vector3 expectedAcceleration = expectedAccelerationDir * expectedAccelerationMag; |
| | | 194 | | |
| | | 195 | | // Decompose acceleration into forward and normal components. |
| | 1 | 196 | | Vector3 forwardAcceleration = |
| | | 197 | | Vector3.Project(expectedAcceleration, _rotaryWingThreat.transform.forward); |
| | 1 | 198 | | Vector3 normalAcceleration = expectedAcceleration - forwardAcceleration; |
| | | 199 | | |
| | | 200 | | // Limit the acceleration magnitude. |
| | 1 | 201 | | float maxForwardAcceleration = _rotaryWingThreat.CalculateMaxNormalAcceleration(); |
| | 1 | 202 | | forwardAcceleration = Vector3.ClampMagnitude(forwardAcceleration, maxForwardAcceleration); |
| | 1 | 203 | | float maxNormalAcceleration = _rotaryWingThreat.CalculateMaxNormalAcceleration(); |
| | 1 | 204 | | normalAcceleration = Vector3.ClampMagnitude(normalAcceleration, maxNormalAcceleration); |
| | 1 | 205 | | expectedAcceleration = forwardAcceleration + normalAcceleration; |
| | | 206 | | |
| | 1 | 207 | | Assert.AreEqual(expectedAcceleration.magnitude, accelerationInput.magnitude, 0.1f, |
| | | 208 | | "Acceleration magnitude should match expected."); |
| | 1 | 209 | | Assert.AreEqual(expectedAcceleration.normalized, accelerationInput.normalized, |
| | | 210 | | "Acceleration direction should be towards waypoint."); |
| | 1 | 211 | | } |
| | | 212 | | |
| | | 213 | | [Test] |
| | 1 | 214 | | public void AttackBehavior_LoadedCorrectly() { |
| | 1 | 215 | | try { |
| | 1 | 216 | | AttackBehavior attackBehavior = |
| | | 217 | | GetPrivateField<AttackBehavior>(_fixedWingThreat, "_attackBehavior"); |
| | 1 | 218 | | Assert.IsNotNull(attackBehavior, "Attack behavior should not be null."); |
| | 1 | 219 | | Assert.AreEqual("Test Direct Attack", attackBehavior.Name); |
| | 1 | 220 | | Assert.AreEqual(Configs.AttackType.DirectAttack, attackBehavior.Type); |
| | | 221 | | |
| | 1 | 222 | | Assert.IsTrue(attackBehavior is DirectAttackBehavior, |
| | | 223 | | "Attack behavior should be a DirectAttackBehavior."); |
| | 1 | 224 | | DirectAttackBehavior directAttackBehavior = (DirectAttackBehavior)attackBehavior; |
| | | 225 | | |
| | 1 | 226 | | Assert.IsNotNull(attackBehavior.FlightPlan, "Flight plan should not be null."); |
| | 1 | 227 | | Assert.AreEqual(Configs.AttackBehaviorConfig.Types.FlightPlanType.DistanceToTarget, |
| | | 228 | | attackBehavior.FlightPlan.Type); |
| | | 229 | | |
| | 1 | 230 | | List<Waypoint> waypoints = attackBehavior.FlightPlan.Waypoints; |
| | 1 | 231 | | Assert.IsNotNull(waypoints, "Waypoints should not be null."); |
| | 1 | 232 | | Assert.AreEqual(2, waypoints.Count, "There should be 2 waypoints."); |
| | | 233 | | |
| | 1 | 234 | | Assert.AreEqual(10000f, waypoints[0].Distance); |
| | 1 | 235 | | Assert.AreEqual(500f, waypoints[0].Altitude); |
| | 1 | 236 | | Assert.AreEqual(Configs.Power.Mil, waypoints[0].Power); |
| | | 237 | | |
| | 1 | 238 | | Assert.AreEqual(5000f, waypoints[1].Distance); |
| | 1 | 239 | | Assert.AreEqual(100f, waypoints[1].Altitude); |
| | 1 | 240 | | Assert.AreEqual(Configs.Power.Max, waypoints[1].Power); |
| | | 241 | | |
| | 1 | 242 | | GameObject.DestroyImmediate(_simManager.gameObject); |
| | 1 | 243 | | } catch (AssertionException e) { |
| | 0 | 244 | | throw new AssertionException( |
| | | 245 | | e.Message + "\n" + "This test likely failed because you have edited " + |
| | | 246 | | "the test string at the top of the test. Please update the test with the new values.\n" + |
| | | 247 | | "If you need to change the test values, please update the test string at the top of the test."); |
| | | 248 | | } |
| | 1 | 249 | | } |
| | | 250 | | } |