//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;
 }
示例#2
0
 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;
 }
示例#3
0
 public bool checkConnection(Way checkWay)
 {
     foreach (Way w in this.connections)
     {
         if (w == checkWay) return true;
     }
     return false;
 }
示例#4
0
 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;
 }
示例#5
0
 public Node getConnectedNode(Way currentWay)
 {
     foreach (Node node in currentWay.nodeConnections)
     {
         if (node != this)
         {
             return node;
         }
     }
     return null;
 }
示例#6
0
 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;
                    }
                }
            }
        }