Exemple #1
0
        IEnumerator Search(List <Node> nodes, List <Edge> edges, Node startNode, Node endNode)
        {
            float waitTime = 0.1f;

            Stack <Node> stack = new Stack <Node>();

            stack.Push(startNode);

            List <Node> visitedNodes = new List <Node>();

            while (stack.Count > 0)
            {
                Node n = stack.Pop();
                visitedNodes.Add(n);

                n.color = Color.red;
                yield return(new WaitForSeconds(waitTime));

                if (n == endNode)
                {
                    Debug.Log("We found the end node!");
                    break;
                }

                List <Node> neighs = graphMaker.GetNeighbours(n);
                foreach (var neigh in neighs)
                {
                    if (!visitedNodes.Contains(neigh) && !stack.Contains(neigh))
                    {
                        Edge e = graphMaker.GetEdge(n, neigh);
                        e.color = Color.green;
                        yield return(new WaitForSeconds(waitTime));

                        stack.Push(neigh);
                    }
                }
            }

            yield return(null);
        }
Exemple #2
0
        private IEnumerator Search(List <Node> nodes, List <Edge> edges, Node startNode, Node endNode)
        {
            Queue <Node> queue = new Queue <Node>();

            queue.Enqueue(startNode);

            List <Node> visitedNodes = new List <Node>();

            while (queue.Count > 0)
            {
                Node n = queue.Dequeue();
                visitedNodes.Add(n);

                n.color = Color.red;
                yield return(new WaitForSeconds(drawDelay));

                if (n == endNode)
                {
                    Debug.Log("Found!");
                    break;
                }

                List <Node> neighs = graphMaker.GetNeighbours(n);

                foreach (Node neigh in neighs)
                {
                    if (!queue.Contains(neigh) && !visitedNodes.Contains(neigh))
                    {
                        queue.Enqueue(neigh);

                        Edge e = graphMaker.GetEdge(n, neigh);
                        e.color = Color.green;
                        yield return(new WaitForSeconds(drawDelay));
                    }
                }
            }

            yield return(null);
        }
Exemple #3
0
        public IEnumerator Search(List <Node> nodes, List <Edge> edges, Node startNode, Node endNode, List <Node> bestPath)
        {
            float waitTime = 0.01f;

            List <Node> openSet   = new List <Node>();
            List <Node> closedSet = new List <Node>();

            startNode.cost      = 0;
            startNode.heuristic = Vector2.Distance(startNode.transform.position, endNode.transform.position);

            openSet.Add(startNode);

            while (openSet.Count > 0)
            {
                Node n = GetBestNode(openSet, true);
                openSet.Remove(n);
                closedSet.Add(n);

                n.color = Color.red;
                yield return(new WaitForSeconds(waitTime));

                if (n == endNode)
                {
                    Debug.Log("We found the end node!");
                    break;
                }

                List <Node> neighs = graphMaker.GetNeighbours(n);
                foreach (var neigh in neighs)
                {
                    if (!closedSet.Contains(neigh) && !openSet.Contains(neigh))
                    {
                        Edge e = graphMaker.GetEdge(n, neigh);
                        e.color = Color.red;
                        yield return(new WaitForSeconds(waitTime));

                        neigh.cost      = n.cost + Vector2.Distance(neigh.transform.position, n.transform.position);
                        neigh.heuristic = Vector2.Distance(neigh.transform.position, endNode.transform.position);

                        openSet.Add(neigh);
                    }
                }
            }

            Debug.Log("SEARCH FINISHED");

            bestPath.Add(endNode);
            var currentNode = endNode;

            while (currentNode != startNode)
            {
                // Get the neighbours of the current node
                List <Node> neighs = graphMaker.GetNeighbours(currentNode);

                //Find shortest path
                Node bestNeigh = GetBestNode(neighs, false);

                Edge e = graphMaker.GetEdge(currentNode, bestNeigh);

                bestPath.Add(bestNeigh);
                currentNode = bestNeigh;

                currentNode.color = Color.green;
                e.color           = Color.green;

                yield return(new WaitForSeconds(waitTime));
            }

            bestPath.Reverse();

            yield return(null);
        }
        public IEnumerator Search(List <Node> nodes, List <Edge> edges, Node startNode, Node endNode, List <Node> bestPath)
        {
            List <Node> openSet   = new List <Node>();
            List <Node> closedSet = new List <Node>();

            startNode.cost      = 0;
            startNode.heutistic = Vector2.Distance(startNode.transform.position, endNode.transform.position) * heuristicMultiplier;

            openSet.Add(startNode);

            while (openSet.Count > 0)
            {
                Node n = GetBestNode(openSet, true);
                openSet.Remove(n);
                closedSet.Add(n);

                n.color = Color.red;
                yield return(new WaitForSeconds(drawDelay));

                if (n == endNode)
                {
                    Debug.Log("Found!");
                    break;
                }

                List <Node> neighs = graphMaker.GetNeighbours(n);

                foreach (Node neigh in neighs)
                {
                    if (!closedSet.Contains(neigh) && !openSet.Contains(neigh))
                    {
                        Edge e = graphMaker.GetEdge(n, neigh);
                        e.color = Color.green;
                        yield return(new WaitForSeconds(drawDelay));

                        neigh.cost      = n.cost + Vector2.Distance(neigh.transform.position, n.transform.position);
                        neigh.heutistic = Vector2.Distance(neigh.transform.position, endNode.transform.position) * heuristicMultiplier;

                        openSet.Add(neigh);
                    }
                }
            }

            // Find best path
            bestPath.Add(endNode);
            var currentNode = endNode;

            while (currentNode != startNode)
            {
                // Get the neighbours of the current node
                List <Node> neighs = graphMaker.GetNeighbours(currentNode);

                // Find the best neighbour
                Node bestNeigh = GetBestNode(neighs, false);

                Edge e = graphMaker.GetEdge(currentNode, bestNeigh);

                bestPath.Add(bestNeigh);
                currentNode = bestNeigh;

                bestNeigh.color = Color.cyan;
                e.color         = Color.yellow;
                yield return(new WaitForSeconds(drawDelay));
            }

            yield return(null);
        }