Пример #1
0
        static public MyStack FindPath(Node startNode, Node goalNode) //En bredden först sökning som öppnar alla noder som läggs i neighbour och om de inte redan är besökta och går att passeera läggs den i en separat lista.
                                                                      //Om den träffar målnoden går den tillbaka längs vägen genom att kolla på nodens förälder och hela tiden pusha den noden till stacken.
        {
            ResetNodes();
            Node        currentNode = startNode;
            List <Node> candidates  = new List <Node>();

            candidates.Add(currentNode);
            MyStack pathStack = new MyStack();

            for (int a = 0; a < 1000; a++)
            {
                if (currentNode == goalNode)
                {
                    List <Node> path = new List <Node>();

                    for (int i = 0; i < 500; i++)
                    {
                        if (currentNode == startNode)
                        {
                            break;
                        }
                        pathStack.Push(currentNode);
                        currentNode = currentNode.parent;
                    }
                    return(pathStack);
                }

                List <Node> neighbours = GetNeighbours(currentNode);
                for (int i = 0; i < neighbours.Count(); i++)
                {
                    if (!neighbours[i].visited && neighbours[i].passable)
                    {
                        candidates.Add(neighbours[i]);
                        neighbours[i].parent = currentNode;
                    }
                }

                currentNode.visited = true;
                candidates.Remove(currentNode);
                if (candidates.Count > 0)
                {
                    currentNode = candidates[0];
                }
            }
            return(null);
        }
Пример #2
0
        //En bredden först sökning som öppnar alla noder som läggs i neighbour och om de inte redan är besökta och går att passeera läggs den i en separat lista.
        //Om den träffar målnoden går den tillbaka längs vägen genom att kolla på nodens förälder och hela tiden pusha den noden till stacken.
        public static MyStack FindPath(Node startNode, Node goalNode)
        {
            ResetNodes();
            Node currentNode = startNode;
            List<Node> candidates = new List<Node>();
            candidates.Add(currentNode);
            MyStack pathStack = new MyStack();

            for (int a = 0; a < 1000; a++)
            {
                if (currentNode == goalNode)
                {
                    List<Node> path = new List<Node>();

                    for (int i = 0; i < 500; i++)
                    {
                        if (currentNode == startNode)
                            break;
                        pathStack.Push(currentNode);
                        currentNode = currentNode.parent;
                    }
                    return pathStack;
                }

                List<Node> neighbours = GetNeighbours(currentNode);
                for (int i = 0; i < neighbours.Count(); i++)
                {

                    if (!neighbours[i].visited && neighbours[i].passable)
                    {
                        candidates.Add(neighbours[i]);
                        neighbours[i].parent = currentNode;
                    }
                }

                currentNode.visited = true;
                candidates.Remove(currentNode);
                if(candidates.Count > 0)
                currentNode = candidates[0];
            }
            return null;
        }
Пример #3
0
        //Initierar en bredden först sökning som returnerar en stack. Hittar en riktning från noden i stacken. Normaliserar värdet sedan värdet och sätyter det till spökets riktning.
        public void FindPath()
        {
            if (target == null)
                return;

            Node n = getNode();
            Node m = target.getNode();
            pathStack = pathFinder.FindPath(n, target.getNode());
            //pathStack = pathFinder.FindPath(n, Map.nodeArray[2, 14]);

            if (pathStack == null || pathStack.Count() == 0)
                return;
            targetNode = (Node)pathStack.Pop();
            targetDirection = new Vector2(targetNode.X, targetNode.Y) - new Vector2(n.X, n.Y);

            if (targetDirection != Vector2.Zero)
                targetDirection.Normalize();
            else
                targetDirection = Vector2.Zero;
        }