| | | 1 | | using System.Collections; |
| | | 2 | | using System.Collections.Generic; |
| | | 3 | | using System.Linq; |
| | | 4 | | using UnityEngine; |
| | | 5 | | |
| | | 6 | | public class CameraController : MonoBehaviour { |
| | | 7 | | public enum TranslationInput { |
| | | 8 | | Forward, |
| | | 9 | | Left, |
| | | 10 | | Back, |
| | | 11 | | Right, |
| | | 12 | | Up, |
| | | 13 | | Down, |
| | | 14 | | } |
| | | 15 | | |
| | | 16 | | // Mapping of translation inputs to movement vectors. |
| | | 17 | | private Dictionary<TranslationInput, Vector3> _translationInputToVectorMap; |
| | | 18 | | |
| | 68 | 19 | | public static CameraController Instance { get; private set; } |
| | | 20 | | |
| | | 21 | | // Forward movement vector. |
| | 1 | 22 | | private readonly Vector3 _wVector = Vector3.forward; |
| | | 23 | | |
| | | 24 | | // Left movement vector. |
| | 1 | 25 | | private readonly Vector3 _aVector = Vector3.left; |
| | | 26 | | |
| | | 27 | | // Backward movement vector. |
| | 1 | 28 | | private readonly Vector3 _sVector = Vector3.back; |
| | | 29 | | |
| | | 30 | | // Right movement vector. |
| | 1 | 31 | | private readonly Vector3 _dVector = Vector3.right; |
| | | 32 | | |
| | | 33 | | // Normal speed of the camera movement. |
| | | 34 | | [SerializeField] |
| | 1 | 35 | | private float _cameraSpeedNormal = 100f; |
| | | 36 | | |
| | | 37 | | // Maximum speed of the camera movement. |
| | | 38 | | [SerializeField] |
| | 1 | 39 | | private float _cameraSpeedMax = 1000f; |
| | | 40 | | |
| | | 41 | | // Horizontal rotation speed. |
| | | 42 | | [SerializeField] |
| | 1 | 43 | | private float _speedH = 2f; |
| | | 44 | | |
| | | 45 | | // Vertical rotation speed. |
| | | 46 | | [SerializeField] |
| | 1 | 47 | | private float _speedV = 2f; |
| | | 48 | | |
| | | 49 | | // If true, the camera should auto-rotate. |
| | | 50 | | [SerializeField] |
| | 1 | 51 | | private bool _autoRotate = false; |
| | | 52 | | |
| | | 53 | | // Target transform for orbit rotation. |
| | | 54 | | [SerializeField] |
| | 1 | 55 | | private Transform _target = null!; |
| | | 56 | | |
| | | 57 | | // Distance from the camera to the orbit target. |
| | | 58 | | [SerializeField] |
| | 1 | 59 | | private float _orbitDistance = 5f; |
| | | 60 | | |
| | | 61 | | // Horizontal orbit rotation speed. |
| | | 62 | | [SerializeField] |
| | 1 | 63 | | private float _orbitXSpeed = 120f; |
| | | 64 | | |
| | | 65 | | // Vertical orbit rotation speed. |
| | | 66 | | [SerializeField] |
| | 1 | 67 | | private float _orbitYSpeed = 120f; |
| | | 68 | | |
| | | 69 | | // Minimum vertical angle limit for orbit. |
| | | 70 | | [SerializeField] |
| | 1 | 71 | | private float _orbitYMinLimit = -20f; |
| | | 72 | | |
| | | 73 | | // Maximum vertical angle limit for orbit. |
| | | 74 | | [SerializeField] |
| | 1 | 75 | | private float _orbitYMaxLimit = 80f; |
| | | 76 | | |
| | | 77 | | // Minimum distance for orbit. |
| | | 78 | | [SerializeField] |
| | 1 | 79 | | private float _orbitDistanceMin = 10f; |
| | | 80 | | |
| | | 81 | | // Maximum distance for orbit. |
| | | 82 | | [SerializeField] |
| | 1 | 83 | | private float _orbitDistanceMax = 20000f; |
| | | 84 | | |
| | | 85 | | // Speed of camera zoom. |
| | | 86 | | [SerializeField] |
| | 1 | 87 | | private float _zoomSpeed = 500f; |
| | | 88 | | |
| | | 89 | | // Renderer for the orbit target. |
| | | 90 | | [SerializeField] |
| | 1 | 91 | | private Renderer _targetRenderer = null!; |
| | | 92 | | |
| | | 93 | | // Speed of camera movement during autoplay. |
| | | 94 | | [SerializeField] |
| | 1 | 95 | | private float _autoplayCamSpeed = 0.02f; |
| | | 96 | | |
| | | 97 | | // Current horizontal orbit angle. |
| | 1 | 98 | | private float _orbitX = 0f; |
| | | 99 | | |
| | | 100 | | // Current vertical orbit angle. |
| | 1 | 101 | | private float _orbitY = 0f; |
| | | 102 | | |
| | | 103 | | // Current yaw angle of the camera. |
| | 1 | 104 | | private float _yaw = 0f; |
| | | 105 | | |
| | | 106 | | // Current pitch angle of the camera. |
| | 1 | 107 | | private float _pitch = 0f; |
| | | 108 | | |
| | | 109 | | // Coroutine for autoplay functionality. |
| | | 110 | | private Coroutine _autoplayRoutine; |
| | | 111 | | |
| | | 112 | | // Angle between forward vector and camera direction. |
| | | 113 | | [SerializeField] |
| | | 114 | | private float _forwardToCameraAngle; |
| | | 115 | | |
| | | 116 | | [SerializeField] |
| | 1 | 117 | | private CameraMode _cameraMode = CameraMode.FREE; |
| | | 118 | | |
| | | 119 | | [SerializeField] |
| | 1 | 120 | | private CameraFollowType _cameraFollowType = CameraFollowType.ALL_AGENTS; |
| | | 121 | | |
| | | 122 | | private Vector3 _lastCentroid; |
| | | 123 | | private Vector3 _currentCentroid; |
| | | 124 | | private Vector3 _targetCentroid; |
| | | 125 | | |
| | | 126 | | [SerializeField] |
| | 1 | 127 | | public float _centroidUpdateFrequency = 0.1f; |
| | | 128 | | [SerializeField] |
| | 1 | 129 | | public float _defaultInterpolationSpeed = 5f; |
| | | 130 | | [SerializeField] |
| | | 131 | | private float _currentInterpolationSpeed; |
| | | 132 | | |
| | | 133 | | [SerializeField] |
| | 1 | 134 | | private float _iirFilterCoefficient = 0.9f; |
| | | 135 | | |
| | | 136 | | private Coroutine _centroidUpdateCoroutine; |
| | | 137 | | |
| | 33 | 138 | | public float CameraSpeed { get; set; } |
| | | 139 | | |
| | 0 | 140 | | public float CameraSpeedMax => _cameraSpeedMax; |
| | | 141 | | |
| | 33 | 142 | | public float CameraSpeedNormal => _cameraSpeedNormal; |
| | | 143 | | |
| | | 144 | | public bool AutoRotate { |
| | 0 | 145 | | get => _autoRotate; |
| | 0 | 146 | | set { |
| | 0 | 147 | | if (value && !_autoRotate) { |
| | 0 | 148 | | _autoRotate = true; |
| | 0 | 149 | | _autoplayRoutine = StartCoroutine(AutoPlayRoutine()); |
| | 0 | 150 | | } else if (!value && _autoRotate) { |
| | 0 | 151 | | _autoRotate = false; |
| | 0 | 152 | | if (_autoplayRoutine != null) { |
| | 0 | 153 | | StopCoroutine(_autoplayRoutine); |
| | 0 | 154 | | _autoplayRoutine = null; |
| | 0 | 155 | | } |
| | 0 | 156 | | } |
| | 0 | 157 | | } |
| | | 158 | | } |
| | | 159 | | |
| | | 160 | | public CameraMode CameraMode { |
| | 33 | 161 | | get => _cameraMode; |
| | 1 | 162 | | set { |
| | 1 | 163 | | switch (value) { |
| | 1 | 164 | | case CameraMode.FREE: { |
| | 1 | 165 | | if (_centroidUpdateCoroutine != null) { |
| | 0 | 166 | | StopCoroutine(_centroidUpdateCoroutine); |
| | 0 | 167 | | _centroidUpdateCoroutine = null; |
| | 0 | 168 | | } |
| | 1 | 169 | | break; |
| | | 170 | | } |
| | 0 | 171 | | case CameraMode.FOLLOW: { |
| | 0 | 172 | | _currentCentroid = _target.position; |
| | 0 | 173 | | _targetCentroid = _target.position; |
| | 0 | 174 | | break; |
| | | 175 | | } |
| | 0 | 176 | | default: { |
| | 0 | 177 | | break; |
| | | 178 | | } |
| | | 179 | | } |
| | 1 | 180 | | _cameraMode = value; |
| | 1 | 181 | | } |
| | | 182 | | } |
| | | 183 | | |
| | | 184 | | public CameraFollowType CameraFollowType { |
| | 0 | 185 | | get => _cameraFollowType; |
| | 0 | 186 | | set { _cameraFollowType = value; } |
| | | 187 | | } |
| | | 188 | | |
| | 0 | 189 | | public void Follow(CameraFollowType type) { |
| | 0 | 190 | | var (agents, description) = GetAgentGroupInfo(type); |
| | 0 | 191 | | Vector3 centroid = FindCentroid(agents); |
| | 0 | 192 | | SetCameraTargetPosition(centroid); |
| | 0 | 193 | | CameraMode = CameraMode.FOLLOW; |
| | 0 | 194 | | CameraFollowType = type; |
| | 0 | 195 | | StartCentroidUpdateCoroutine(); |
| | 0 | 196 | | UIManager.Instance.LogActionMessage($"[CAM] Follow center of {description}."); |
| | 0 | 197 | | } |
| | | 198 | | |
| | 0 | 199 | | public void Snap(CameraFollowType type) { |
| | 0 | 200 | | var (agents, description) = GetAgentGroupInfo(type); |
| | 0 | 201 | | Vector3 centroid = FindCentroid(agents); |
| | 0 | 202 | | SetCameraTargetPosition(centroid); |
| | 0 | 203 | | UIManager.Instance.LogActionMessage($"[CAM] Snap to center of {description}."); |
| | 0 | 204 | | } |
| | | 205 | | |
| | 0 | 206 | | public void OrbitCamera(float xOrbit, float yOrbit) { |
| | 0 | 207 | | if (_target) { |
| | 0 | 208 | | _orbitX += xOrbit * _orbitXSpeed * _orbitDistance * 0.02f; |
| | 0 | 209 | | _orbitY -= yOrbit * _orbitYSpeed * _orbitDistance * 0.02f; |
| | | 210 | | |
| | 0 | 211 | | _orbitY = ClampAngle(_orbitY, _orbitYMinLimit, _orbitYMaxLimit); |
| | 0 | 212 | | UpdateCameraPosition(_orbitX, _orbitY); |
| | 0 | 213 | | } |
| | 0 | 214 | | } |
| | | 215 | | |
| | 0 | 216 | | public void RotateCamera(float xRotate, float yRotate) { |
| | 0 | 217 | | _yaw += xRotate * _speedH; |
| | 0 | 218 | | _pitch -= yRotate * _speedV; |
| | 0 | 219 | | transform.eulerAngles = new Vector3(_pitch, _yaw, 0f); |
| | 0 | 220 | | } |
| | | 221 | | |
| | 0 | 222 | | public void TranslateCamera(TranslationInput input) { |
| | 0 | 223 | | if (CameraMode != CameraMode.FREE) { |
| | 0 | 224 | | CameraMode = CameraMode.FREE; |
| | 0 | 225 | | } |
| | 0 | 226 | | UpdateDirectionVectors(); |
| | 0 | 227 | | _target.Translate(_translationInputToVectorMap[input] * Time.unscaledDeltaTime * CameraSpeed); |
| | 0 | 228 | | UpdateCameraPosition(_orbitX, _orbitY); |
| | 0 | 229 | | } |
| | | 230 | | |
| | 0 | 231 | | public void ZoomCamera(float zoom) { |
| | 0 | 232 | | _orbitDistance = |
| | | 233 | | Mathf.Clamp(_orbitDistance - zoom * _zoomSpeed, _orbitDistanceMin, _orbitDistanceMax); |
| | 0 | 234 | | UpdateCameraPosition(_orbitX, _orbitY); |
| | 0 | 235 | | } |
| | | 236 | | |
| | 1 | 237 | | private void Awake() { |
| | 1 | 238 | | if (Instance != null && Instance != this) { |
| | 0 | 239 | | Destroy(gameObject); |
| | 0 | 240 | | return; |
| | | 241 | | } |
| | 1 | 242 | | Instance = this; |
| | 1 | 243 | | DontDestroyOnLoad(gameObject); |
| | | 244 | | |
| | 1 | 245 | | _currentInterpolationSpeed = _defaultInterpolationSpeed; |
| | 1 | 246 | | } |
| | | 247 | | |
| | 1 | 248 | | private void Start() { |
| | 1 | 249 | | Vector3 angles = transform.eulerAngles; |
| | 1 | 250 | | _orbitX = angles.y; |
| | 1 | 251 | | _orbitY = angles.x; |
| | | 252 | | |
| | 1 | 253 | | UpdateTargetAlpha(); |
| | 1 | 254 | | ResetCameraTarget(); |
| | | 255 | | |
| | 1 | 256 | | _translationInputToVectorMap = new Dictionary<TranslationInput, Vector3> { |
| | | 257 | | { TranslationInput.Forward, _wVector }, { TranslationInput.Left, _aVector }, |
| | | 258 | | { TranslationInput.Back, _sVector }, { TranslationInput.Right, _dVector }, |
| | | 259 | | { TranslationInput.Up, Vector3.up }, { TranslationInput.Down, Vector3.down } |
| | | 260 | | }; |
| | 1 | 261 | | CameraMode = CameraMode.FREE; |
| | 1 | 262 | | } |
| | | 263 | | |
| | 33 | 264 | | private void Update() { |
| | 33 | 265 | | if (CameraMode != CameraMode.FREE) { |
| | | 266 | | // Use MoveTowards for smoother and more predictable movement. |
| | 0 | 267 | | _currentCentroid = Vector3.MoveTowards(_currentCentroid, _targetCentroid, |
| | | 268 | | _currentInterpolationSpeed * Time.unscaledDeltaTime); |
| | 0 | 269 | | SetCameraTargetPosition(_currentCentroid); |
| | 0 | 270 | | } |
| | 33 | 271 | | } |
| | | 272 | | |
| | 1 | 273 | | private void SetCameraRotation(in Quaternion rotation) { |
| | 1 | 274 | | transform.rotation = rotation; |
| | 1 | 275 | | _pitch = rotation.eulerAngles.x; |
| | 1 | 276 | | _yaw = rotation.eulerAngles.y; |
| | 1 | 277 | | } |
| | | 278 | | |
| | 1 | 279 | | private void UpdateCameraPosition(float x, float y) { |
| | 1 | 280 | | Quaternion rotation = Quaternion.Euler(y, x, 0); |
| | 1 | 281 | | if (Physics.Linecast(_target.position, transform.position, out RaycastHit hit, |
| | 0 | 282 | | ~LayerMask.GetMask("Floor"), QueryTriggerInteraction.Ignore)) { |
| | 0 | 283 | | _orbitDistance -= hit.distance; |
| | 0 | 284 | | } |
| | 1 | 285 | | Vector3 negDistance = new Vector3(0f, 0f, -_orbitDistance); |
| | 1 | 286 | | Vector3 position = rotation * negDistance + _target.position; |
| | 1 | 287 | | _orbitDistance = Mathf.Clamp(_orbitDistance, _orbitDistanceMin, _orbitDistanceMax); |
| | 1 | 288 | | UpdateTargetAlpha(); |
| | | 289 | | |
| | 1 | 290 | | SetCameraRotation(rotation); |
| | 1 | 291 | | transform.position = position; |
| | 1 | 292 | | } |
| | | 293 | | |
| | 0 | 294 | | private void SetCameraTargetPosition(in Vector3 position) { |
| | 0 | 295 | | _target.transform.position = position; |
| | 0 | 296 | | UpdateCameraPosition(_orbitX, _orbitY); |
| | 0 | 297 | | } |
| | | 298 | | |
| | 1 | 299 | | private void ResetCameraTarget() { |
| | | 300 | | RaycastHit hit; |
| | 1 | 301 | | if (Physics.Raycast(transform.position, transform.forward, out hit, float.MaxValue, |
| | 1 | 302 | | LayerMask.GetMask("Floor"), QueryTriggerInteraction.Ignore)) { |
| | 1 | 303 | | _target.transform.position = hit.point; |
| | 1 | 304 | | _orbitDistance = hit.distance; |
| | 1 | 305 | | Vector3 angles = transform.eulerAngles; |
| | 1 | 306 | | _orbitX = angles.y; |
| | 1 | 307 | | _orbitY = angles.x; |
| | 1 | 308 | | UpdateCameraPosition(_orbitX, _orbitY); |
| | 1 | 309 | | } else { |
| | 0 | 310 | | _target.transform.position = transform.position + (transform.forward * 100); |
| | 0 | 311 | | _orbitDistance = 100; |
| | 0 | 312 | | Vector3 angles = transform.eulerAngles; |
| | 0 | 313 | | _orbitX = angles.y; |
| | 0 | 314 | | _orbitY = angles.x; |
| | 0 | 315 | | } |
| | 1 | 316 | | } |
| | | 317 | | |
| | 2 | 318 | | private void UpdateTargetAlpha() { |
| | 2 | 319 | | float matAlpha = (_orbitDistance - _orbitDistanceMin) / (_orbitDistanceMax - _orbitDistanceMin); |
| | 2 | 320 | | matAlpha = Mathf.Max(Mathf.Sqrt(matAlpha) - 0.5f, 0); |
| | 2 | 321 | | Color matColor = _targetRenderer.material.color; |
| | 2 | 322 | | matColor.a = matAlpha; |
| | 2 | 323 | | _targetRenderer.material.color = matColor; |
| | 2 | 324 | | } |
| | | 325 | | |
| | 0 | 326 | | private static float ClampAngle(float angle, float min, float max) { |
| | 0 | 327 | | if (angle < -360f) |
| | 0 | 328 | | angle += 360f; |
| | 0 | 329 | | if (angle > 360f) |
| | 0 | 330 | | angle -= 360f; |
| | 0 | 331 | | return Mathf.Clamp(angle, min, max); |
| | 0 | 332 | | } |
| | | 333 | | |
| | 0 | 334 | | private void StartCentroidUpdateCoroutine() { |
| | 0 | 335 | | _centroidUpdateCoroutine ??= StartCoroutine(UpdateCentroidCoroutine()); |
| | 0 | 336 | | } |
| | | 337 | | |
| | 0 | 338 | | private IEnumerator UpdateCentroidCoroutine() { |
| | 0 | 339 | | while (true) { |
| | 0 | 340 | | UpdateTargetCentroid(); |
| | 0 | 341 | | yield return new WaitForSeconds(_centroidUpdateFrequency); |
| | 0 | 342 | | } |
| | | 343 | | } |
| | | 344 | | |
| | 0 | 345 | | private void UpdateTargetCentroid() { |
| | 0 | 346 | | _lastCentroid = _currentCentroid; |
| | 0 | 347 | | var (agents, _) = GetAgentGroupInfo(CameraFollowType); |
| | 0 | 348 | | _targetCentroid = FindCentroid(agents); |
| | | 349 | | |
| | | 350 | | // Apply IIR filter to adjust interpolation speed. |
| | 0 | 351 | | float distance = Mathf.Abs(Vector3.Distance(_lastCentroid, _targetCentroid)); |
| | 0 | 352 | | float targetSpeed = Mathf.Clamp(distance, 1f, 100000f); |
| | 0 | 353 | | _currentInterpolationSpeed = _iirFilterCoefficient * _currentInterpolationSpeed + |
| | | 354 | | (1 - _iirFilterCoefficient) * targetSpeed; |
| | 0 | 355 | | } |
| | | 356 | | |
| | 0 | 357 | | private IEnumerator AutoPlayRoutine() { |
| | 0 | 358 | | while (true) { |
| | 0 | 359 | | _orbitX += Time.unscaledDeltaTime * _autoplayCamSpeed * _orbitDistance * 0.02f; |
| | 0 | 360 | | UpdateCameraPosition(_orbitX, _orbitY); |
| | 0 | 361 | | yield return null; |
| | 0 | 362 | | } |
| | | 363 | | } |
| | | 364 | | |
| | 0 | 365 | | private void UpdateDirectionVectors() { |
| | 0 | 366 | | Vector3 cameraToTarget = _target.position - transform.position; |
| | 0 | 367 | | cameraToTarget.y = 0; |
| | 0 | 368 | | _forwardToCameraAngle = Vector3.SignedAngle(Vector3.forward, cameraToTarget, Vector3.down); |
| | | 369 | | |
| | 0 | 370 | | if (_forwardToCameraAngle > -45f && _forwardToCameraAngle <= 45f) { |
| | 0 | 371 | | _translationInputToVectorMap[TranslationInput.Forward] = Vector3.forward; |
| | 0 | 372 | | _translationInputToVectorMap[TranslationInput.Left] = Vector3.left; |
| | 0 | 373 | | _translationInputToVectorMap[TranslationInput.Back] = Vector3.back; |
| | 0 | 374 | | _translationInputToVectorMap[TranslationInput.Right] = Vector3.right; |
| | 0 | 375 | | } else if (_forwardToCameraAngle > 45f && _forwardToCameraAngle <= 135f) { |
| | 0 | 376 | | _translationInputToVectorMap[TranslationInput.Forward] = Vector3.left; |
| | 0 | 377 | | _translationInputToVectorMap[TranslationInput.Left] = Vector3.back; |
| | 0 | 378 | | _translationInputToVectorMap[TranslationInput.Back] = Vector3.right; |
| | 0 | 379 | | _translationInputToVectorMap[TranslationInput.Right] = Vector3.forward; |
| | 0 | 380 | | } else if (_forwardToCameraAngle > 135f || _forwardToCameraAngle <= -135f) { |
| | 0 | 381 | | _translationInputToVectorMap[TranslationInput.Forward] = Vector3.back; |
| | 0 | 382 | | _translationInputToVectorMap[TranslationInput.Left] = Vector3.right; |
| | 0 | 383 | | _translationInputToVectorMap[TranslationInput.Back] = Vector3.forward; |
| | 0 | 384 | | _translationInputToVectorMap[TranslationInput.Right] = Vector3.left; |
| | 0 | 385 | | } else if (_forwardToCameraAngle > -135f && _forwardToCameraAngle <= -45f) { |
| | 0 | 386 | | _translationInputToVectorMap[TranslationInput.Forward] = Vector3.right; |
| | 0 | 387 | | _translationInputToVectorMap[TranslationInput.Left] = Vector3.forward; |
| | 0 | 388 | | _translationInputToVectorMap[TranslationInput.Back] = Vector3.left; |
| | 0 | 389 | | _translationInputToVectorMap[TranslationInput.Right] = Vector3.back; |
| | 0 | 390 | | } |
| | 0 | 391 | | } |
| | | 392 | | |
| | | 393 | | private (IEnumerable<IAgent> agents, string description) |
| | 0 | 394 | | GetAgentGroupInfo(CameraFollowType type) { |
| | 0 | 395 | | switch (type) { |
| | | 396 | | case CameraFollowType.ALL_INTERCEPTORS: |
| | 0 | 397 | | return (SimManager.Instance.Interceptors, "all interceptors"); |
| | | 398 | | case CameraFollowType.ALL_THREATS: |
| | 0 | 399 | | return (SimManager.Instance.Threats, "all threats"); |
| | | 400 | | case CameraFollowType.ALL_AGENTS: |
| | | 401 | | default: |
| | 0 | 402 | | return (SimManager.Instance.Agents, "all agents"); |
| | | 403 | | } |
| | 0 | 404 | | } |
| | | 405 | | |
| | 0 | 406 | | private Vector3 FindCentroid(IEnumerable<IAgent> agents) { |
| | 0 | 407 | | var sum = Vector3.zero; |
| | 0 | 408 | | int count = 0; |
| | 0 | 409 | | foreach (var agent in agents) { |
| | 0 | 410 | | sum += agent.Position; |
| | 0 | 411 | | count++; |
| | 0 | 412 | | } |
| | 0 | 413 | | if (count == 0) { |
| | 0 | 414 | | return Vector3.zero; |
| | | 415 | | } |
| | 0 | 416 | | return sum / count; |
| | 0 | 417 | | } |
| | | 418 | | } |
| | | 419 | | |
| | | 420 | | public enum CameraMode { |
| | | 421 | | FREE, |
| | | 422 | | FOLLOW, |
| | | 423 | | } |
| | | 424 | | |
| | | 425 | | public enum CameraFollowType { |
| | | 426 | | ALL_AGENTS, |
| | | 427 | | ALL_INTERCEPTORS, |
| | | 428 | | ALL_THREATS, |
| | | 429 | | } |