| | | 1 | | using UnityEngine; |
| | | 2 | | |
| | | 3 | | // Base implementation of an agent. |
| | | 4 | | // |
| | | 5 | | // See the agent interface for property and method documentation. |
| | | 6 | | public class AgentBase : MonoBehaviour, IAgent { |
| | | 7 | | public event AgentTerminatedEventHandler OnTerminated; |
| | | 8 | | |
| | | 9 | | private const float _epsilon = 1e-12f; |
| | | 10 | | |
| | | 11 | | // Rigid body component. |
| | | 12 | | protected Rigidbody _rigidbody; |
| | | 13 | | |
| | | 14 | | // The position field is cached and is updated before every fixed update. |
| | | 15 | | [SerializeField] |
| | | 16 | | private Vector3 _position; |
| | | 17 | | |
| | | 18 | | // The acceleration field is not part of the rigid body component, so it is tracked separately. |
| | | 19 | | // The acceleration is applied as a force during each frame update. |
| | | 20 | | [SerializeField] |
| | | 21 | | private Vector3 _acceleration; |
| | | 22 | | |
| | | 23 | | // The acceleration input is calculated by the controller and provided to the movement behavior. |
| | | 24 | | [SerializeField] |
| | | 25 | | private Vector3 _accelerationInput; |
| | | 26 | | |
| | | 27 | | // The agent's position within the hierarchical strategy is given by the hierarchical agent. |
| | | 28 | | [SerializeReference] |
| | | 29 | | private HierarchicalAgent _hierarchicalAgent; |
| | | 30 | | |
| | | 31 | | // Static configuration of the agent, including agent type, unit cost, acceleration configuration, |
| | | 32 | | // aerodynamics parameters, power table, and visualization configuration. |
| | | 33 | | private Configs.StaticConfig _staticConfig; |
| | | 34 | | |
| | | 35 | | // Agent configuration, including initial state, attack behavior configuration (for threats), |
| | | 36 | | // dynamic configuration, and sub-agent configuration (for interceptors). |
| | | 37 | | private Configs.AgentConfig _agentConfig; |
| | | 38 | | |
| | | 39 | | // Last sensing time. |
| | | 40 | | [SerializeField] |
| | 171 | 41 | | private float _lastSensingTime = Mathf.NegativeInfinity; |
| | | 42 | | |
| | | 43 | | public HierarchicalAgent HierarchicalAgent { |
| | 0 | 44 | | get => _hierarchicalAgent; |
| | 0 | 45 | | set => _hierarchicalAgent = value; |
| | | 46 | | } |
| | | 47 | | public Configs.StaticConfig StaticConfig { |
| | 405 | 48 | | get => _staticConfig; |
| | 64 | 49 | | set { |
| | 64 | 50 | | _staticConfig = value; |
| | 64 | 51 | | _rigidbody.mass = StaticConfig.BodyConfig?.Mass ?? 1; |
| | 64 | 52 | | } |
| | | 53 | | } |
| | | 54 | | public Configs.AgentConfig AgentConfig { |
| | 13 | 55 | | get => _agentConfig; |
| | 7 | 56 | | set { |
| | 7 | 57 | | _agentConfig = value; |
| | 7 | 58 | | UpdateAgentConfig(); |
| | 7 | 59 | | } |
| | | 60 | | } |
| | | 61 | | |
| | 0 | 62 | | public IMovement Movement { get; set; } |
| | 0 | 63 | | public IController Controller { get; set; } |
| | 16 | 64 | | public ISensor Sensor { get; set; } |
| | 67 | 65 | | public IAgent TargetModel { get; set; } |
| | | 66 | | |
| | | 67 | | public Vector3 Position { |
| | 272 | 68 | | get => _position; |
| | 89 | 69 | | set { |
| | 89 | 70 | | Transform.position = value; |
| | 89 | 71 | | _position = value; |
| | 89 | 72 | | } |
| | | 73 | | } |
| | | 74 | | public Vector3 Velocity { |
| | 338 | 75 | | get => _rigidbody.linearVelocity; |
| | 120 | 76 | | set => _rigidbody.linearVelocity = value; |
| | | 77 | | } |
| | 117 | 78 | | public float Speed => Velocity.magnitude; |
| | | 79 | | public Vector3 Acceleration { |
| | 24 | 80 | | get => _acceleration; |
| | 9 | 81 | | set => _acceleration = value; |
| | | 82 | | } |
| | | 83 | | public Vector3 AccelerationInput { |
| | 0 | 84 | | get => _accelerationInput; |
| | 0 | 85 | | set => _accelerationInput = value; |
| | | 86 | | } |
| | | 87 | | |
| | | 88 | | // If true, the agent is able to pursue targets. |
| | 0 | 89 | | public virtual bool IsPursuer => true; |
| | | 90 | | |
| | | 91 | | // Elapsed time since the creation of the agent. |
| | 179 | 92 | | public float ElapsedTime { get; private set; } = 0f; |
| | | 93 | | |
| | | 94 | | // If true, the agent is terminated. |
| | 171 | 95 | | public bool IsTerminated { get; private set; } = false; |
| | | 96 | | |
| | | 97 | | // The agent transform is cached. |
| | 1169 | 98 | | public Transform Transform { get; private set; } |
| | | 99 | | |
| | | 100 | | // The up direction is cached and updated before every fixed update. |
| | 171 | 101 | | public Vector3 Up { get; private set; } |
| | | 102 | | |
| | | 103 | | // The forward direction is cached and updated before every fixed update. |
| | 242 | 104 | | public Vector3 Forward { get; private set; } |
| | | 105 | | |
| | | 106 | | // The right direction is cached and updated before every fixed update. |
| | 172 | 107 | | public Vector3 Right { get; private set; } |
| | | 108 | | |
| | | 109 | | // The inverse rotation is cached and updated before every fixed update. |
| | 287 | 110 | | public Quaternion InverseRotation { get; private set; } |
| | | 111 | | |
| | 26 | 112 | | public float MaxForwardAcceleration() { |
| | 26 | 113 | | return StaticConfig.AccelerationConfig?.MaxForwardAcceleration ?? 0; |
| | 26 | 114 | | } |
| | | 115 | | |
| | 65 | 116 | | public float MaxNormalAcceleration() { |
| | 65 | 117 | | float maxReferenceNormalAcceleration = |
| | | 118 | | (StaticConfig.AccelerationConfig?.MaxReferenceNormalAcceleration ?? |
| | | 119 | | float.PositiveInfinity) * |
| | | 120 | | Constants.kGravity; |
| | 65 | 121 | | float referenceSpeed = StaticConfig.AccelerationConfig?.ReferenceSpeed ?? 1; |
| | 65 | 122 | | return Mathf.Pow(Speed / referenceSpeed, 2) * maxReferenceNormalAcceleration; |
| | 65 | 123 | | } |
| | | 124 | | |
| | 0 | 125 | | public void CreateTargetModel(IHierarchical target) { |
| | 0 | 126 | | TargetModel = SimManager.Instance.CreateDummyAgent(target.Position, target.Velocity); |
| | 0 | 127 | | } |
| | | 128 | | |
| | 0 | 129 | | public void DestroyTargetModel() { |
| | 0 | 130 | | if (TargetModel != null) { |
| | 0 | 131 | | SimManager.Instance.DestroyDummyAgent(TargetModel); |
| | 0 | 132 | | TargetModel = null; |
| | 0 | 133 | | } |
| | 0 | 134 | | } |
| | | 135 | | |
| | 0 | 136 | | public void UpdateTargetModel() { |
| | 0 | 137 | | if (HierarchicalAgent == null || HierarchicalAgent.Target == null || Sensor == null) { |
| | 0 | 138 | | return; |
| | | 139 | | } |
| | 0 | 140 | | if (HierarchicalAgent.Target.IsTerminated) { |
| | 0 | 141 | | HierarchicalAgent.Target = null; |
| | 0 | 142 | | return; |
| | | 143 | | } |
| | | 144 | | |
| | | 145 | | // Check whether the sensing period has elapsed. |
| | 0 | 146 | | float sensingFrequency = AgentConfig?.DynamicConfig?.SensorConfig?.Frequency ?? Mathf.Infinity; |
| | 0 | 147 | | float sensingPeriod = 1f / sensingFrequency; |
| | 0 | 148 | | if (ElapsedTime - _lastSensingTime >= sensingPeriod) { |
| | | 149 | | // Sense the target. |
| | 0 | 150 | | SensorOutput sensorOutput = Sensor.Sense(HierarchicalAgent.Target); |
| | 0 | 151 | | TargetModel.Position = Position + sensorOutput.Position.Cartesian; |
| | 0 | 152 | | TargetModel.Velocity = Velocity + sensorOutput.Velocity.Cartesian; |
| | 0 | 153 | | TargetModel.Acceleration = Acceleration + sensorOutput.Acceleration.Cartesian; |
| | 0 | 154 | | _lastSensingTime = ElapsedTime; |
| | 0 | 155 | | } |
| | 0 | 156 | | } |
| | | 157 | | |
| | 24 | 158 | | public Transformation GetRelativeTransformation(IAgent target) { |
| | 24 | 159 | | return GetRelativeTransformation(target.Position, target.Velocity, target.Acceleration); |
| | 24 | 160 | | } |
| | | 161 | | |
| | 32 | 162 | | public Transformation GetRelativeTransformation(IHierarchical target) { |
| | 32 | 163 | | return GetRelativeTransformation(target.Position, target.Velocity, target.Acceleration); |
| | 32 | 164 | | } |
| | | 165 | | |
| | 2 | 166 | | public Transformation GetRelativeTransformation(in Vector3 waypoint) { |
| | 2 | 167 | | return GetRelativeTransformation(waypoint, velocity: Vector3.zero, acceleration: Vector3.zero); |
| | 2 | 168 | | } |
| | | 169 | | |
| | 0 | 170 | | public void Terminate() { |
| | 0 | 171 | | if (HierarchicalAgent != null) { |
| | 0 | 172 | | HierarchicalAgent.Target = null; |
| | 0 | 173 | | } |
| | 0 | 174 | | if (Movement is MissileMovement movement) { |
| | 0 | 175 | | movement.FlightPhase = Simulation.FlightPhase.Terminated; |
| | 0 | 176 | | } |
| | 0 | 177 | | IsTerminated = true; |
| | 0 | 178 | | OnTerminated?.Invoke(this); |
| | 0 | 179 | | Destroy(gameObject); |
| | 0 | 180 | | } |
| | | 181 | | |
| | | 182 | | // Awake is called before Start and right after a prefab is instantiated. |
| | 171 | 183 | | protected virtual void Awake() { |
| | 171 | 184 | | Transform = transform; |
| | 171 | 185 | | _rigidbody = GetComponent<Rigidbody>(); |
| | | 186 | | |
| | 171 | 187 | | UpdateTransformData(); |
| | 171 | 188 | | if (EarlyFixedUpdateManager.Instance != null) { |
| | 0 | 189 | | EarlyFixedUpdateManager.Instance.OnEarlyFixedUpdate += UpdateTransformData; |
| | 0 | 190 | | } |
| | 171 | 191 | | } |
| | | 192 | | |
| | | 193 | | // Start is called before the first frame update. |
| | 0 | 194 | | protected virtual void Start() {} |
| | | 195 | | |
| | | 196 | | // FixedUpdate is called multiple times per frame. All physics calculations and updates occur |
| | | 197 | | // immediately after FixedUpdate, and all movement values are multiplied by Time.deltaTime. |
| | 0 | 198 | | protected virtual void FixedUpdate() { |
| | 0 | 199 | | ElapsedTime += Time.fixedDeltaTime; |
| | | 200 | | |
| | 0 | 201 | | UpdateTargetModel(); |
| | 0 | 202 | | AlignWithVelocity(); |
| | 0 | 203 | | } |
| | | 204 | | |
| | | 205 | | // Update is called every frame. |
| | 0 | 206 | | protected virtual void Update() {} |
| | | 207 | | |
| | | 208 | | // LateUpdate is called every frame after all Update functions have been called. |
| | 0 | 209 | | protected virtual void LateUpdate() {} |
| | | 210 | | |
| | | 211 | | // OnDestroy is called when the object is being destroyed. |
| | 0 | 212 | | protected virtual void OnDestroy() { |
| | 0 | 213 | | if (EarlyFixedUpdateManager.Instance != null) { |
| | 0 | 214 | | EarlyFixedUpdateManager.Instance.OnEarlyFixedUpdate -= UpdateTransformData; |
| | 0 | 215 | | } |
| | 0 | 216 | | } |
| | | 217 | | |
| | | 218 | | // UpdateAgentConfig is called whenever the agent configuration is changed. |
| | 7 | 219 | | protected virtual void UpdateAgentConfig() { |
| | | 220 | | // Set the sensor. |
| | 7 | 221 | | switch (AgentConfig.DynamicConfig?.SensorConfig?.Type) { |
| | 7 | 222 | | case Simulation.SensorType.Ideal: { |
| | 7 | 223 | | Sensor = new IdealSensor(this); |
| | 7 | 224 | | break; |
| | | 225 | | } |
| | 0 | 226 | | default: { |
| | 0 | 227 | | Debug.LogWarning($"Sensor type {AgentConfig.DynamicConfig?.SensorConfig?.Type} not found."); |
| | 0 | 228 | | break; |
| | | 229 | | } |
| | | 230 | | } |
| | 7 | 231 | | } |
| | | 232 | | |
| | 0 | 233 | | protected virtual void OnDrawGizmos() { |
| | 0 | 234 | | if (Application.isPlaying) { |
| | 0 | 235 | | Gizmos.color = Color.green; |
| | 0 | 236 | | Gizmos.DrawRay(Position, _accelerationInput); |
| | 0 | 237 | | } |
| | 0 | 238 | | } |
| | | 239 | | |
| | 0 | 240 | | protected bool CheckGroundCollision(Collider other) { |
| | | 241 | | // Check if the agent hit the ground with a negative vertical speed. |
| | 0 | 242 | | return other.gameObject.name == "Floor" && Vector3.Dot(Velocity, Vector3.up) < 0; |
| | 0 | 243 | | } |
| | | 244 | | |
| | 0 | 245 | | protected bool ShouldIgnoreCollision(IAgent otherAgent) { |
| | | 246 | | // Dummy agents are virtual targets and should not trigger collisions. |
| | 0 | 247 | | return otherAgent == null || otherAgent is DummyAgent || otherAgent.IsTerminated; |
| | 0 | 248 | | } |
| | | 249 | | |
| | 171 | 250 | | private void UpdateTransformData() { |
| | 171 | 251 | | _position = Transform.position; |
| | 171 | 252 | | Up = Transform.up; |
| | 171 | 253 | | Forward = Transform.forward; |
| | 171 | 254 | | Right = Transform.right; |
| | 171 | 255 | | InverseRotation = Quaternion.Inverse(Transform.rotation); |
| | 171 | 256 | | } |
| | | 257 | | |
| | 0 | 258 | | private void AlignWithVelocity() { |
| | | 259 | | const float speedThreshold = 0.1f; |
| | | 260 | | const float rotationSpeedDegreesPerSecond = 10000f; |
| | | 261 | | |
| | | 262 | | // Only align if the velocity is significant. |
| | 0 | 263 | | if (Speed > speedThreshold) { |
| | | 264 | | // Create a rotation with the forward direction along the velocity vector and the up direction |
| | | 265 | | // along world up. |
| | 0 | 266 | | Quaternion targetRotation = Quaternion.LookRotation(Velocity, Vector3.up); |
| | | 267 | | |
| | | 268 | | // Smoothly rotate towards the target rotation. |
| | 0 | 269 | | Transform.rotation = Quaternion.RotateTowards( |
| | | 270 | | Transform.rotation, targetRotation, |
| | | 271 | | maxDegreesDelta: rotationSpeedDegreesPerSecond * Time.fixedDeltaTime); |
| | 0 | 272 | | } |
| | 0 | 273 | | } |
| | | 274 | | |
| | | 275 | | private Transformation GetRelativeTransformation(in Vector3 position, in Vector3 velocity, |
| | 58 | 276 | | in Vector3 acceleration) { |
| | 58 | 277 | | Vector3 relativePosition = position - Position; |
| | 58 | 278 | | Vector3 relativeLocalPosition = InverseRotation * relativePosition; |
| | 58 | 279 | | Vector3 relativeVelocity = velocity - Velocity; |
| | 58 | 280 | | Vector3 relativeLocalVelocity = InverseRotation * relativeVelocity; |
| | | 281 | | |
| | 58 | 282 | | float x = relativeLocalPosition.x; |
| | 58 | 283 | | float y = relativeLocalPosition.y; |
| | 58 | 284 | | float z = relativeLocalPosition.z; |
| | | 285 | | |
| | 58 | 286 | | float horizontalSqr = x * x + z * z; |
| | 58 | 287 | | float horizontal = Mathf.Sqrt(horizontalSqr); |
| | 58 | 288 | | float rangeSqr = horizontalSqr + y * y; |
| | 58 | 289 | | float range = Mathf.Sqrt(rangeSqr); |
| | | 290 | | |
| | 58 | 291 | | float azimuth = Mathf.Atan2(x, z); |
| | 58 | 292 | | float elevation = Mathf.Atan2(y, horizontal); |
| | 58 | 293 | | var positionTransformation = new PositionTransformation { |
| | | 294 | | Cartesian = relativePosition, |
| | | 295 | | Range = range, |
| | | 296 | | Azimuth = azimuth, |
| | | 297 | | Elevation = elevation, |
| | | 298 | | }; |
| | | 299 | | |
| | 58 | 300 | | float rangeRate = |
| | | 301 | | range > _epsilon ? Vector3.Dot(relativeLocalVelocity, relativeLocalPosition) / range : 0f; |
| | 58 | 302 | | float azimuthRate = 0f; |
| | 58 | 303 | | float elevationRate = 0f; |
| | 103 | 304 | | if (horizontal > _epsilon) { |
| | 45 | 305 | | azimuthRate = -(x * relativeLocalVelocity.z - z * relativeLocalVelocity.x) / horizontalSqr; |
| | 45 | 306 | | elevationRate = |
| | | 307 | | (relativeLocalVelocity.y * horizontal - |
| | | 308 | | y * (x * relativeLocalVelocity.x + z * relativeLocalVelocity.z) / horizontal) / |
| | | 309 | | rangeSqr; |
| | 58 | 310 | | } else { |
| | | 311 | | // The other agent is exactly above or below. |
| | 13 | 312 | | azimuthRate = 0f; |
| | 13 | 313 | | float horizontalSpeed = Mathf.Sqrt(relativeLocalVelocity.x * relativeLocalVelocity.x + |
| | | 314 | | relativeLocalVelocity.z * relativeLocalVelocity.z); |
| | 13 | 315 | | elevationRate = -horizontalSpeed / (Mathf.Abs(y) > _epsilon ? y : Mathf.Sign(y) * _epsilon); |
| | 13 | 316 | | } |
| | 58 | 317 | | var velocityTransformation = new VelocityTransformation { |
| | | 318 | | Cartesian = relativeVelocity, |
| | | 319 | | Range = rangeRate, |
| | | 320 | | Azimuth = azimuthRate, |
| | | 321 | | Elevation = elevationRate, |
| | | 322 | | }; |
| | | 323 | | |
| | 58 | 324 | | var accelerationTransformation = new AccelerationTransformation { |
| | | 325 | | Cartesian = acceleration, |
| | | 326 | | }; |
| | 58 | 327 | | return new Transformation { |
| | | 328 | | Position = positionTransformation, |
| | | 329 | | Velocity = velocityTransformation, |
| | | 330 | | Acceleration = accelerationTransformation, |
| | | 331 | | }; |
| | 58 | 332 | | } |
| | | 333 | | } |