| | | 1 | | using UnityEngine; |
| | | 2 | | |
| | | 3 | | // Missile movement. |
| | | 4 | | // |
| | | 5 | | // A missile is defined by having multiple phases during its flight: ready phases (before it is |
| | | 6 | | // launched), boost phases (when its burner is on), midcourse phases (after the burner has completed |
| | | 7 | | // burning), and terminal phases (when the agent is homing in on the target). |
| | | 8 | | // |
| | | 9 | | // We define three additional states for our simulator: initialized state (when the missile has been |
| | | 10 | | // created), ballistic state (when the missile is subject to only drag and gravity), and terminated |
| | | 11 | | // state (when the missile has finished its flight). |
| | | 12 | | // |
| | | 13 | | // The missile is responsible for determining when it enters the boost phase. |
| | | 14 | | public class MissileMovement : AerialMovement { |
| | | 15 | | // Flight phase of the agent. |
| | | 16 | | private Simulation.FlightPhase _flightPhase; |
| | | 17 | | |
| | | 18 | | // Boost time in seconds relative to the agent's creation time. |
| | | 19 | | private float _boostTime; |
| | | 20 | | |
| | | 21 | | public Simulation.FlightPhase FlightPhase { |
| | 153 | 22 | | get { return _flightPhase; } |
| | 25 | 23 | | set { |
| | 25 | 24 | | _flightPhase = value; |
| | 28 | 25 | | if (FlightPhase == Simulation.FlightPhase.Boost) { |
| | 3 | 26 | | _boostTime = Agent.ElapsedTime; |
| | 3 | 27 | | } |
| | 25 | 28 | | } |
| | | 29 | | } |
| | | 30 | | |
| | 24 | 31 | | public MissileMovement(IAgent agent) : base(agent) { |
| | 12 | 32 | | FlightPhase = Simulation.FlightPhase.Initialized; |
| | 12 | 33 | | } |
| | | 34 | | |
| | | 35 | | // Determine the agent's actual acceleration input given its intended acceleration input by |
| | | 36 | | // applying physics and other constraints. |
| | 12 | 37 | | public override Vector3 Act(in Vector3 accelerationInput) { |
| | | 38 | | // Step through the flight phases. |
| | 12 | 39 | | if (FlightPhase == Simulation.FlightPhase.Boost && |
| | 1 | 40 | | Agent.ElapsedTime > _boostTime + (Agent.StaticConfig?.BoostConfig?.BoostTime ?? 0)) { |
| | 1 | 41 | | FlightPhase = Simulation.FlightPhase.Midcourse; |
| | 1 | 42 | | } |
| | | 43 | | |
| | | 44 | | // Act according to the flight phase. |
| | 12 | 45 | | switch (FlightPhase) { |
| | 1 | 46 | | case Simulation.FlightPhase.Initialized: { |
| | | 47 | | // In the initialized phase, the agent is not subject to any acceleration. |
| | 1 | 48 | | return Vector3.zero; |
| | | 49 | | } |
| | 3 | 50 | | case Simulation.FlightPhase.Ready: { |
| | 3 | 51 | | return ActReady(accelerationInput); |
| | | 52 | | } |
| | 2 | 53 | | case Simulation.FlightPhase.Boost: { |
| | 2 | 54 | | return ActBoost(accelerationInput); |
| | | 55 | | } |
| | 5 | 56 | | case Simulation.FlightPhase.Midcourse: { |
| | 5 | 57 | | return ActMidCourse(accelerationInput); |
| | | 58 | | } |
| | 0 | 59 | | case Simulation.FlightPhase.Terminal: { |
| | 0 | 60 | | return ActTerminal(accelerationInput); |
| | | 61 | | } |
| | 0 | 62 | | case Simulation.FlightPhase.Ballistic: { |
| | 0 | 63 | | return ActBallistic(accelerationInput); |
| | | 64 | | } |
| | 1 | 65 | | case Simulation.FlightPhase.Terminated: { |
| | | 66 | | // In the terminated phase, the agent is not subject to any acceleration. |
| | 1 | 67 | | return Vector3.zero; |
| | | 68 | | } |
| | 0 | 69 | | default: { |
| | 0 | 70 | | return Vector3.zero; |
| | | 71 | | } |
| | | 72 | | } |
| | 12 | 73 | | } |
| | | 74 | | |
| | | 75 | | // In the ready phase, the agent is subject to drag and gravity but has not boosted yet. |
| | 3 | 76 | | private Vector3 ActReady(in Vector3 accelerationInput) { |
| | 3 | 77 | | Vector3 limitedAccelerationInput = LimitAccelerationInput(accelerationInput); |
| | 3 | 78 | | return CalculateNetAccelerationInput(limitedAccelerationInput); |
| | 3 | 79 | | } |
| | | 80 | | |
| | | 81 | | // In the boost phase, the boost acceleration is added to the control acceleration input. |
| | 2 | 82 | | private Vector3 ActBoost(in Vector3 accelerationInput) { |
| | 2 | 83 | | Vector3 accelerationInputWithGroundAvoidance = AvoidGround(accelerationInput); |
| | 2 | 84 | | Vector3 limitedAccelerationInput = LimitAccelerationInput(accelerationInputWithGroundAvoidance); |
| | | 85 | | |
| | | 86 | | // Determine the boost acceleration. |
| | 2 | 87 | | float boostAcceleration = |
| | | 88 | | (Agent.StaticConfig?.BoostConfig?.BoostAcceleration ?? 0) * Constants.kGravity; |
| | 2 | 89 | | Vector3 totalAccelerationInput = boostAcceleration * Agent.Forward + limitedAccelerationInput; |
| | 2 | 90 | | return CalculateNetAccelerationInput(totalAccelerationInput); |
| | 2 | 91 | | } |
| | | 92 | | |
| | | 93 | | // In the midcourse phase, the agent accelerates according to the control acceleration input but |
| | | 94 | | // is subject to drag and gravity. |
| | 5 | 95 | | private Vector3 ActMidCourse(in Vector3 accelerationInput) { |
| | 5 | 96 | | Vector3 accelerationInputWithGroundAvoidance = AvoidGround(accelerationInput); |
| | 5 | 97 | | Vector3 limitedAccelerationInput = LimitAccelerationInput(accelerationInputWithGroundAvoidance); |
| | 5 | 98 | | return CalculateNetAccelerationInput(limitedAccelerationInput); |
| | 5 | 99 | | } |
| | | 100 | | |
| | | 101 | | // In the terminal phase, the agent is homing in on the target and is still subject to drag and |
| | | 102 | | // gravity. |
| | 0 | 103 | | private Vector3 ActTerminal(in Vector3 accelerationInput) { |
| | | 104 | | // Currently, the agent acts the same in the terminal phase as in the midcourse phase. |
| | 0 | 105 | | return ActMidCourse(accelerationInput); |
| | 0 | 106 | | } |
| | | 107 | | |
| | | 108 | | // In the ballistic phase, the agent is subject to only drag and gravity. |
| | 0 | 109 | | private Vector3 ActBallistic(in Vector3 accelerationInput) { |
| | 0 | 110 | | return ActMidCourse(accelerationInput: Vector3.zero); |
| | 0 | 111 | | } |
| | | 112 | | |
| | | 113 | | // Adjust the acceleration input to avoid the ground. |
| | 7 | 114 | | private Vector3 AvoidGround(in Vector3 accelerationInput) { |
| | | 115 | | const float groundProximityThresholdFactor = 5f; |
| | | 116 | | |
| | 7 | 117 | | Vector3 agentPosition = Agent.Position; |
| | 7 | 118 | | Vector3 agentVelocity = Agent.Velocity; |
| | 7 | 119 | | float altitude = agentPosition.y; |
| | 7 | 120 | | float groundProximityThreshold = |
| | | 121 | | Mathf.Abs(agentVelocity.y) * groundProximityThresholdFactor + |
| | | 122 | | 0.5f * Constants.kGravity * groundProximityThresholdFactor * groundProximityThresholdFactor; |
| | 7 | 123 | | if (agentVelocity.y < 0 && altitude < groundProximityThreshold) { |
| | | 124 | | // Add some upward acceleration to avoid the ground. |
| | 0 | 125 | | float blendFactor = 1 - (altitude / groundProximityThreshold); |
| | 0 | 126 | | return accelerationInput + blendFactor * Agent.MaxNormalAcceleration() * Agent.Up; |
| | | 127 | | } |
| | 7 | 128 | | return accelerationInput; |
| | 7 | 129 | | } |
| | | 130 | | |
| | | 131 | | // Calculate the acceleration input with drag and gravity. |
| | 10 | 132 | | private Vector3 CalculateNetAccelerationInput(in Vector3 accelerationInput) { |
| | 10 | 133 | | Vector3 gravity = Physics.gravity; |
| | 10 | 134 | | float airDrag = CalculateDrag(); |
| | 10 | 135 | | float liftInducedDrag = CalculateLiftInducedDrag(accelerationInput + gravity); |
| | 10 | 136 | | float dragAcceleration = -(airDrag + liftInducedDrag); |
| | 10 | 137 | | return accelerationInput + gravity + dragAcceleration * Agent.Forward; |
| | 10 | 138 | | } |
| | | 139 | | } |