//Collision Detection
//True = collision, false = geen collision
public bool collisionDetection(Airplane airplane, Way way, Node targetNode)
{
foreach (Airplane collisionAirplane in airplanes)
{
collisionAirplane.hasCollision = false;
if (!collisionAirplane.Equals(airplane) && collisionAirplane.isOnAirport()) // Eigen vliegtuig niet meerekenen & vliegtuig moet in bereik van Airport zijn.
{
if (collisionAirplane.navigator.currentWay.Equals(way)) // Een ander vliegtuig rijdt op dit moment op de weg
{
if (collisionAirplane.navigator.currentWay.direction == 0)
{
if (targetNode == collisionAirplane.navigator.getTargetNode())
{
if (airplane.navigator.getDistanceToTargetNode(airplane.location) > collisionAirplane.navigator.getDistanceToTargetNode(collisionAirplane.location) && airplane.navigator.getDistanceToTargetNode(airplane.location) - collisionAirplane.navigator.getDistanceToTargetNode(collisionAirplane.location) < 150)
{
airplane.hasCollision = true;
return true;
}
}
}
if (collisionAirplane.navigator.currentWay.direction != 0)
{
if (airplane.navigator.getDistanceToTargetNode(airplane.location) > collisionAirplane.navigator.getDistanceToTargetNode(collisionAirplane.location) && airplane.navigator.getDistanceToTargetNode(airplane.location) - collisionAirplane.navigator.getDistanceToTargetNode(collisionAirplane.location) < 150)
{
airplane.hasCollision = true;
return true;
}
}
}
}
}
return false;
}
public bool isDirectionAllowed(Way w)
{
//Geeft aan of je een way langs mag. this zit op de way.
if (w.direction == 0) return true;
if (w.direction == 1 && w.nodeConnections[0] == this) return true;
if (w.direction == -1 && w.nodeConnections[1] == this) return true;
return false;
}
public bool checkConnection(Way checkWay)
{
foreach (Way w in this.connections)
{
if (w == checkWay) return true;
}
return false;
}
public static bool isBetweenNodes(Way way, Node node1, Node node2)
{
//Als node 1 en 2 de way bevatten, dan is way een verbinding tussen de twee nodes
if (node1.checkConnection(way) && node2.checkConnection(way))
{
return true;
}
return false;
}
public Node getConnectedNode(Way currentWay)
{
foreach (Node node in currentWay.nodeConnections)
{
if (node != this)
{
return node;
}
}
return null;
}
public static bool isPointInWay(double[] planeLoc, Way way)
{
//Kijk of een vliegtuig zich bevindt tussen twee punten (van een way)
//http://stackoverflow.com/questions/7050186/find-if-point-lay-on-line-segment
//(x-x1)/(x2-x1)==(y-y1)/(y2-y1) voor (x,y) op lijn (x1,y1),(x2,y2)
//Equivalent aan (x-x1)*(y2-y1)==(y-y1)*(x2-x1)
if (planeLoc[0] <= Math.Max(way.nodeConnections[0].location[0], way.nodeConnections[1].location[0]) &&
planeLoc[0] >= Math.Min(way.nodeConnections[0].location[0], way.nodeConnections[1].location[0]) &&
planeLoc[1] <= Math.Max(way.nodeConnections[0].location[1], way.nodeConnections[1].location[1]) &&
planeLoc[1] >= Math.Min(way.nodeConnections[0].location[1], way.nodeConnections[1].location[1])) // Kijken of de locatie van het vliegtuig tussen de nodes zit
{
return (double)((planeLoc[0] - way.nodeConnections[0].location[0]) * (way.nodeConnections[1].location[1] - way.nodeConnections[0].location[1]))
== (double)((planeLoc[1] - way.nodeConnections[0].location[1]) * (way.nodeConnections[1].location[0] - way.nodeConnections[0].location[0]));
}
return false;
}
public List<Airplane> planesOnWayInDirection(Way targetway, Node startnode, Airplane source)
{
//Maakt een lijst aan met alle vliegtuigen die op een bepaalde weg gaan rijden, en waarbij ze in de richting rijden van startnode > andere node
List<Airplane> returnlist = new List<Airplane>();
foreach (Airplane airplane in airplanes)
{
if (source != airplane && airplane.navigator != null)
{
if (airplane.navigator.hasWay(targetway))
{
Node othernode;
if (targetway.nodeConnections[0] == startnode)
othernode = targetway.nodeConnections[1];
else othernode = targetway.nodeConnections[0];
if (airplane.navigator.nodes.IndexOf(startnode) < airplane.navigator.nodes.IndexOf(othernode))
returnlist.Add(airplane);
}
}
}
return returnlist;
}
public void drawWay(Graphics g, Color color, Way way)
{
int x1 = (int)(way.nodeConnections[0].location[0] * drawingScale + 10);
int y1 = (int)(way.nodeConnections[0].location[1] * drawingScale + 10);
int y2 = (int)(way.nodeConnections[1].location[1] * drawingScale + 10);
int x2 = (int)(way.nodeConnections[1].location[0] * drawingScale + 10);
if (showLabels && !(way is Gateway))
{
int textYPos;
int textXPos;
int minY = Math.Min(y1, y2);
int maxY = Math.Max(y1, y2);
if (y1 >= y2)
{
textYPos = (int)(y1 + 0.5 * (y2 - y1));
textXPos = (int)(x1 + 0.5 * (x2 - x1) + 3);
}
else
{
textYPos = (int)(y1 + 0.5 * (y2 - y1));
textXPos = (int)(x1 + 0.5 * (x2 - x1) + 12);
}
g.DrawString(way.name, SystemFonts.DefaultFont, Brushes.Black, textXPos, textYPos);
}
Pen pen = new Pen(color, 2);
switch (showEfficiency)
{
case -1:
g.DrawLine(pen, x1, y1, x2, y2);
break;
case 0:
double occupancy = way.Occupancy;
Color efficiencyColor = Color.FromArgb((int) (occupancy * 255), 255 - (int) (occupancy * 255), 0);
Pen efficiencyPen = new Pen(efficiencyColor, (float) 2);
g.DrawLine(efficiencyPen, x1, y1, x2, y2);
break;
case 1:
occupancy = way.Occupancy;
efficiencyColor = Color.FromArgb((int) (occupancy * 255), 255 - (int) (occupancy * 255), 0);
efficiencyPen = new Pen(efficiencyColor, (float) 0.01);
g.DrawLine(pen, x1, y1, x2, y2);
g.DrawLine(efficiencyPen, x1 - 3, y1, x2 - 3, y2);
g.DrawLine(efficiencyPen, x1 + 3, y1, x2 + 3, y2);
break;
}
if(!(way is Gateway))
{
g.FillEllipse(Brushes.Black, x1 - 5, y1- 5, 10, 10);
g.FillEllipse(Brushes.Black, x2 - 5, y2 - 5, 10, 10);
}
}
/*
* Permission requesters
*/
public bool requestWayAccess(Airplane airplane, Way way, Node targetNode)
{
if (way != null)
{
List<Airplane> currentAirplaneList = new List<Airplane>();
foreach (Airplane currentAirplane in airplanes) // Alle vliegtuigen bekijken
{
if (!currentAirplane.Equals(airplane) && currentAirplane.isOnAirport()) // Eigen vliegtuig niet meerekenen & vliegtuig moet in bereik van Airport zijn.
{
if (currentAirplane.navigator.currentWay.Equals(way)) // Een ander vliegtuig rijdt op dit moment op de weg
{
currentAirplaneList.Add(currentAirplane);
}
}
}
if (way.direction != 0)
{
if (currentAirplaneList.Count == 0)
{
return true;
}
if (currentAirplaneList.Count == 1)
if (currentAirplaneList[0].navigator.getDistanceToTargetNode(currentAirplaneList[0].location) < 700)
return true; // Ruw, maar het werkt net zoals hiervoor
if (currentAirplaneList.Count == 2)
if (Math.Max(currentAirplaneList[0].navigator.getDistanceToTargetNode(currentAirplaneList[0].location), currentAirplaneList[0].navigator.getDistanceToTargetNode(currentAirplaneList[0].location)) < 700)
return true;
return false;
}
else if (!(way is Gate))
{
if (!(way is Runway))
{
List<Airplane> sameNodeList = new List<Airplane>();
foreach (Airplane currentAirplaneListAirplane in currentAirplaneList)
{
if (currentAirplaneListAirplane.navigator.getTargetNode() != targetNode)
sameNodeList.Add(currentAirplaneListAirplane);
}
if (sameNodeList.Count == 0)
return true;
if (sameNodeList.Count == 1)
if (sameNodeList[0].navigator.getDistanceToTargetNode(sameNodeList[0].location) < 700)
return true;
if (sameNodeList.Count == 2)
if (Math.Max(sameNodeList[0].navigator.getDistanceToTargetNode(sameNodeList[0].location), sameNodeList[1].navigator.getDistanceToTargetNode(sameNodeList[1].location)) < 700)
return true;
}
else if (way is Runway)
{
if (currentAirplaneList.Count == 0)
return true;
return false;
}
}
else if (way is Gate)
{
if (currentAirplaneList.Count == 0)
return true;
}
return false;
}
return false;
}
public bool requestWayAccess(Airport.Airport airport, Way targetWay, Node targetNode)
{
if (airport.requestWayAccess(this, targetWay, targetNode))
{
navigator.permissions[navigator.targetNodeNumber] = Navigator.PermissionStatus.GRANTED;
navigator.permissionCounter++;
return true;
}
else
{
navigator.permissions[navigator.targetNodeNumber] = Navigator.PermissionStatus.REQUESTED;
navigator.permissionCounter++;
return false;
}
}
private Node findStartNode(Way w, Airplane a)
{
if (w.direction == 1) return w.nodeConnections[1]; //Als richting 1, dan de Node waar de baan eindigt is beginpunt
if (w.direction == -1) return w.nodeConnections[0]; //Andersom voor richting -1
if (w.direction == 0) //Dichtstbijzijnde op dubbelbaansweg
{
double d = 1000000; double temp;
foreach (Node n in w.nodeConnections)
{
temp = Utils.getDistanceBetweenPoints(a.location, n.location);
if (temp < d) d = temp;
}
foreach (Node n in w.nodeConnections) if (Utils.getDistanceBetweenPoints(a.location, n.location) == d) return n;
}
return null;
}
public void newRoute(Airplane airplane, List<Way> ways, Airport.Airport airport)
{
/*
Routeplanner zelf
Om aan te roepen, geef een vliegtuig mee. Vliegtuig weet huidige coordinaten
Stap 1, waar is het vliegtuig nu?
*/
Way startWay = null;
foreach (Way w in ways)
{
if (Utils.isPointInWay(airplane.location, w))
{
//Kijkt of het vliegtuig zich op een weg bevindt en als dat zo is zet de startWay als die weg
startWay = w;
break;
}
}
if (startWay == null)
startWay = Utils.getClosestWay(airplane.location, ways);
if (startWay != null) //Om zeker te weten dat een beginlocatie bepaald is
{
Way endWay = null;
//Stap 2, waar moet het vliegtuig heen? Zoek een vrije gate als start een runway is, en vice versa
if (!airplane.hasDocked)
{
//Utils.getClosestWay(airplane.location, airplane.gate);
/*Check de gates - open gate. Als geen gates open, zoek 1: dichtstbijzijnde gate of 2: langst bezette gate.
* Optie 1 heeft waarschijnlijk iets kleinere kans op file voor 1 gate, vanwege meerdere Runways en vertraging tussen vliegtuigen landen op zelfde Runway.
* Optie 2 leidt vrijwel altijd tot alle nieuwe vliegtuigen naar dezelfde gate -> file.
* IList<Gate> availableGates = new List<Gate>();
* IList<Gate> occupiedGates = new List<Gate>();
* IList<Gate> reservedGates = new List<Gate>();
* occupiedGates = airport.occupiedGates();
*/
foreach (Way w in ways)
{
if (w is Gate)
{
if (w.name == airplane.gate)
{
endWay = (Gate)w;
break;
}
}
}
}
else if (airplane.hasDocked)
{
IList<Way> runways = new List<Way>();
foreach(Way w in ways)
{
if(w is Runway)
runways.Add(w);
}
endWay = Utils.getClosestWay(airplane.location, runways);
}
Node startNode = findStartNode(startWay, airplane);
Node endNode = endWay.nodeConnections[1]; //De endNode is de beginNode van een Way want: vliegtuig moet naar begin runway of gate
Route bestRoute = findRoute(startNode, endNode, airplane, airport);
this.nodes = bestRoute.RouteList();
wayPoints = convertNodesToWaypoints(bestRoute.RouteList()); // Geef de lijst met Ways door aan het vliegtuig. (Hier gekozen voor lijst van Ways, lijkt handiger ivm toestemming)
for (int i = 0; i <= wayPoints.Count; i++)
{
permissions.Add(PermissionStatus.NONE);
}
// Ways initten
currentWay = startWay;
getTargetWay();
}
}
public bool hasWay(Way way)
{
//Methode om te kijken of een navigator een weg nog niet heeft afgelegd
if (wayPoints.Contains(way))
{
int target = wayPoints.IndexOf(currentWay);
for (int t = 0; t < wayPoints.Count; t++)
{
if (t >= target)
if (wayPoints[t] == way)
return true;
}
}
return false;
}
public Way getTargetWay()
{
if (targetNodeNumber >= nodes.Count - 1) // Targetway is de huidige weg
{
return currentWay;
}
Node targetNode = nodes[targetNodeNumber];
Node nextTargetNode = nodes[targetNodeNumber + 1]; ;
foreach (Way targetConnectedWay in targetNode.connections)
{
foreach (Way previousConnectedWay in nextTargetNode.connections)
{
if (targetConnectedWay.Equals(previousConnectedWay))
{
targetWay = targetConnectedWay;
return targetWay;
}
}
}
return targetWay;
}
public void getCurrentWay()
{
if (targetNodeNumber == 0 || targetNodeNumber >= nodes.Count) // als 0, dan staat de huidige weg al goed vanuit newRoute()
{
return;
}
Node targetNode = nodes[targetNodeNumber];
Node previousNode = nodes[targetNodeNumber - 1]; ;
foreach (Way targetConnectedWay in targetNode.connections)
{
foreach (Way previousConnectedWay in previousNode.connections)
{
if (targetConnectedWay.Equals(previousConnectedWay))
{
currentWay = targetConnectedWay;
return;
}
}
}
}
