ControlMode GetControlModeForCollision(PossibleCollision collision)
{
// If collision is not already in TCAS mode and time limit exceeds, then switch to TCAS mode
if (collision.controlMode != ControlMode.TCAS && ShouldSwitchToTCAS(collision))
{
return(ControlMode.TCAS);
}
return(collision.controlMode);
}
private PossibleCollision getExistingCollision(PossibleCollision collision)
{
foreach (var c in _possibleCollisions)
{
if (c.first == collision.first && c.second == collision.second)
{
return(c);
}
}
return(null);
}
public void TakeControlOfCollision(PlaneController plane)
{
// Find collision by plane and get control by collission
PossibleCollision collision = _collisionDetector.FindCollision(plane);
if (collision == null)
{
return;
}
TakeControlOfCollision(collision);
}
public void ClearSelection()
{
// For clearing, remove STCA mode from collision
if (_possibleCollision == null)
{
return;
}
_collisionDetector.RemoveSTCAMode(_possibleCollision);
_possibleCollision = null;
_firstPlaneController.Plane = null;
_secondPlaneController.Plane = null;
}
private void UpdateCollisionsList(List <PossibleCollision> collisions)
{
List <PossibleCollision> newCollisionsList = new List <PossibleCollision>();
// For every collision
foreach (var collision in collisions)
{
// Check if it is already in collection
PossibleCollision match = getExistingCollision(collision);
newCollisionsList.Add(match != null ? match : collision);
}
SetCollisionsList(newCollisionsList, true);
}
public PossibleCollision FindAndSetToSCTAMode(PossibleCollision collision)
{
// Iterate over all collisions, if there is collision between presented planes
// Set mode to STCA and return the result
for (int i = 0; i < _possibleCollisions.Count; i++)
{
if (_possibleCollisions[i].first == collision.first &&
_possibleCollisions[i].second == collision.second)
{
_possibleCollisions[i].SetControlMode(ControlMode.STCA);
UpdatePlaneStates(_possibleCollisions[i]);
return(_possibleCollisions[i]);
}
}
return(null);
}
public bool IsCollisionValid(PossibleCollision collision)
{
if (collision == null)
{
return(false);
}
// Check if collision exists in collection
foreach (var c in _possibleCollisions)
{
// If exists, check the validity of presented mode
if (c.first == collision.first && c.second == collision.second)
{
return(c.controlMode == collision.controlMode);
}
}
return(false);
}
private void PerformTCASStep(PossibleCollision collision)
{
PlaneController first = collision.first;
PlaneController second = collision.second;
// It is height adjust
if (first.Height > second.Height)
{
// If first is flying higher, then it should fly higher
// And the second one should fly lower
first.mDesiredHeight = Mathf.Min(first.mDesiredHeight + _heightStep, Globals.maxHeight);
second.mDesiredHeight = Mathf.Max(second.mDesiredHeight - _heightStep, Globals.minHeight);
}
else
{
// Otherwise the second should fly higher
second.mDesiredHeight = Mathf.Min(second.mDesiredHeight + _heightStep, Globals.maxHeight);
first.mDesiredHeight = Mathf.Max(first.mDesiredHeight - _heightStep, Globals.minHeight);
}
}
public PossibleCollision RemoveSTCAMode(PossibleCollision collision)
{
if (collision == null)
{
return(null);
}
// Check if there is collision with the presented planes and in STCA mode
// And return it no None mode
for (int i = 0; i < _possibleCollisions.Count; i++)
{
if (_possibleCollisions[i].first == collision.first &&
_possibleCollisions[i].second == collision.second &&
_possibleCollisions[i].controlMode == ControlMode.STCA
)
{
_possibleCollisions[i].SetControlMode(ControlMode.None);
UpdatePlaneStates(_possibleCollisions[i]);
return(_possibleCollisions[i]);
}
}
return(null);
}
public void TakeControlOfCollision(PossibleCollision collision)
{
// If collision is null or on TCAS control, then do nothing
if (collision == null || collision.controlMode == ControlMode.TCAS)
{
return;
}
ClearSelection();
// If control mode is None, then go to SCTA mode
PossibleCollision collisionToSave = collision.controlMode == ControlMode.None ?
_collisionDetector.FindAndSetToSCTAMode(collision) : collision;
if (collisionToSave == null)
{
return;
}
_firstPlaneController.Plane = collision.first;
_secondPlaneController.Plane = collision.second;
_possibleCollision = collision;
}
//todo this can be cached / debounced to a few times a second instead of every frame. this would mean PotentialCollisions would need to be cached / updated
public List<PossibleCollision> QueryPossibleCollisions(float detectionRange, float collisionHorizon)
{
Collider[] colliders = Physics.OverlapSphere(transform.position, detectionRange);
List<PossibleCollision> possibleCollisions = new List<PossibleCollision>(colliders.Length);
for (var i = 0; i < colliders.Length; i++) {
Collider collider = colliders[i];
Transform otherTransform = collider.transform;
if (collider.transform.IsChildOf(transform)) continue;
Vector3 otherVelocity = Vector3.zero;
Vector3 otherPosition = otherTransform.position;
Vector3 size = collider.bounds.size;
float otherRadius = Mathf.Max(size.x, Mathf.Max(size.y, size.z));// * t.localScale.x;
Rigidbody otherRb = collider.attachedRigidbody;
if (otherRb) {
otherVelocity = otherRb.velocity;
}
float timeToCollision = TimeToCollision(otherPosition, otherVelocity, otherRadius);
PossibleCollision pc = new PossibleCollision();
pc.radius = otherRadius;
pc.timeToImpact = timeToCollision;
pc.transform = otherTransform;
pc.velocity = otherVelocity;
pc.strengthModifier = 1f;
pc.horizon = collisionHorizon;
if (timeToCollision < 0f || timeToCollision >= collisionHorizon) {
continue;
}
else if(InFormation) {
Pilot pilot = otherTransform.GetComponentInParent<Pilot>();
if(pilot != null && pilot.formation != null) {
bool sameFormation = pilot.formation == formation;
if(sameFormation) {
Vector3 toOther = (pilot.transform.position - transform.position).normalized;
bool isOtherIsBehind = Vector3.Dot(transform.forward, toOther) < 0;
if (FormationLeader && isOtherIsBehind) {
continue;
}
else if(pilot.FormationLeader && !isOtherIsBehind) {
continue;
}
else {
pc.strengthModifier = 0.1f;
pc.horizon = 0.001f;
}
}
}
}
Debug.DrawLine(transform.position, otherTransform.position, Color.red);
possibleCollisions.Add(pc);
}
return possibleCollisions;
}
bool ShouldSwitchToTCAS(PossibleCollision collision)
{
return((Time.time - collision.startTime) >= Globals.TCASSwitchTime);
}
private void UpdatePlaneStates(PossibleCollision c)
{
PlaneController.Status status = c.ControlModeToStatus();
c.first.currentStatus = status;
c.second.currentStatus = status;
}
