public bool Equals(Node node) { if (this.location[0] == node.location[0] && this.location[1] == node.location[1]) return true; else return false; }
//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 hasNode(Node checkNode) { //Kijk of een node al in de route zit, tegengaan van circulaire routes if (this.local == checkNode) return true; if (this.previous == null) return false; return previous.hasNode(checkNode); }
public Route previous; //De voorafgaande Route. Is null voor de eerste #endregion Fields #region Constructors public Route(Node newlocal, Route newPrevious, double newLength) { this.local = newlocal; this.previous = newPrevious; this.length = newLength; if (previous != null) this.length += previous.length; }
public Way(Node node1, Node node2, int dir, string name) { this.nodeConnections[0] = node1; this.nodeConnections[1] = node2; node1.connections.Add(this); node2.connections.Add(this); this.direction = dir; this.name = name; }
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 Route findRoute(Node startNode, Node endNode, Airplane airplane, Airport.Airport airport) { /* * Deze methode maakt een stapel aan met routes. Het pakt de bovenste route van deze stapel. Route heeft Node, vorige Route en lengte. * Zolang routes op stapel, blijf draaien. Voor iedere route check Node. Is Node endNode? Ja + lengte < kortste Route dan nieuwe kortste Route. * Anders kijk Ways bij Node. Als Node = Endnote of lengte Route > lengte beste Route niet opnieuw pushen. * Anders nieuwe Route maken met Node andere kant van Way. Resultaat is kortste Route van beginNode naar endNode. */ foreach (Way w in airport.ways) w.weightedLength = w.length; Stack<Route> routes = new Stack<Route>(); Route bestRoute = null; routes.Push(new Route(startNode, null, 0)); while (routes.Count > 0) { Route route = routes.Pop(); if (route.hasNode(endNode)) { if (bestRoute == null || route.length < bestRoute.length) { bestRoute = route; } } IList<Way> connections = route.local.connections; foreach (Way connection in connections) { if (!route.hasNode(endNode)) { if (route.local.isDirectionAllowed(connection)) { if (bestRoute == null || route.length <= bestRoute.length) { Node connectedNode = route.local.getConnectedNode(connection); if (!route.hasNode(connectedNode)) { Route newRoute = new Route(connectedNode, route, connection.weightedLength); routes.Push(newRoute); //Zet nieuwe Route op stack met Node andere kant connection } } connection.weightedLength = connection.length; } } } } return bestRoute; }
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 Runway(Node node1, Node node2, int dir, string name) : base(node1, node2, dir, name) { }
/* * 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 listContainsNode(List<Node> nodeList, Node node) { for (int i = 0; i < nodeList.Count; i++) { if (nodeList[i].Equals(node)) return true; } return false; }
public List<Node[]> getNodeMatch(string type, List<int> directions, XmlDocument xmlDocument, List<Node> nodeList, List<string> names) { List<Node[]> NodeMatch = new List<Node[]>(); XmlNodeList wayNodes = xmlDocument.SelectNodes("//" + type); int i = 0; directions.Clear(); names.Clear(); foreach (XmlNode xmlNode in wayNodes) { Node[] matches = new Node[2]; int nodeX1 = int.Parse(xmlNode.Attributes["X1"].Value); int nodeX2 = int.Parse(xmlNode.Attributes["X2"].Value); int nodeY1 = int.Parse(xmlNode.Attributes["Y1"].Value); int nodeY2 = int.Parse(xmlNode.Attributes["Y2"].Value); int nodedir = int.Parse(xmlNode.Attributes["dir"].Value); string name = xmlNode.Attributes["name"].Value; Node firstNode = new Node(nodeX1, nodeY1); Node secondNode = new Node(nodeX2, nodeY2); if (!listContainsNode(nodeList, firstNode)) { nodeList.Add(firstNode); matches[0] = firstNode; } else { foreach (Node node in nodeList) { if (firstNode.Equals(node)) matches[0] = node; } } if (!listContainsNode(nodeList, secondNode)) { nodeList.Add(secondNode); matches[1] = secondNode; } else { foreach (Node node in nodeList) { if (secondNode.Equals(node)) matches[1] = node; } } if (matches.Count() == 2) { NodeMatch.Add(matches); directions.Add(nodedir); names.Add(name); i++; } } return NodeMatch; }
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; } }
public Gate(Node node1, Node node2, int dir, string name) : base(node1, node2, dir, name) { }