Example #1
0
        public MapPath FindPath(int startX, int startY, int endX, int endY, bool useHeuristic = true)
        {
            if (field == null)
                return null;

             UseHeuristic = useHeuristic;

             List<AStarNode> Closed = new List<AStarNode>();
             BinaryHeap<AStarNode> OpenHeap = new BinaryHeap<AStarNode>(fieldWidth * fieldHeight);
             AStarNode Root;

            Root = new AStarNode();
            Root.parent = null;
            Root.X = startX;
            Root.Y = startY;
            Root.G = 0;
            int offX = Math.Abs(Root.X - endX);
            int offY = Math.Abs(Root.Y - endY);
             if (UseHeuristic == false)
             {
            Root.H = 0;
             }
             else
             {
            if (offX > offY)
               Root.H = 14 * offY + 10 * (offX - offY);
            else
               Root.H = 14 * offX + 10 * (offY - offX);
             }
            OpenHeap.Add(Root.F, Root);

             int res = ProcessLowestNode (endX, endY, Closed, OpenHeap);
            while (res == 0)
            {
                res = ProcessLowestNode(endX, endY, Closed, OpenHeap);
            }

            if (res == -1)
                return null;

             AStarNode node = null;
             if (res == 1)
            node = GetClosedNode(endX, endY, Closed);
             else if (res == 2)
            node = Closed[Closed.Count - 1];

             MapPath result = new MapPath ();
             result.BuildFromFinalAStarNode (node);

             return result;
        }
Example #2
0
        public MapPath FindPath(int startX, int startY, int endX, int endY, bool useHeuristic = true)
        {
            if (field == null)
            {
                return(null);
            }

            UseHeuristic = useHeuristic;

            List <AStarNode>       Closed   = new List <AStarNode>();
            BinaryHeap <AStarNode> OpenHeap = new BinaryHeap <AStarNode>(fieldWidth * fieldHeight);
            AStarNode Root;

            Root        = new AStarNode();
            Root.parent = null;
            Root.X      = startX;
            Root.Y      = startY;
            Root.G      = 0;
            int offX = Math.Abs(Root.X - endX);
            int offY = Math.Abs(Root.Y - endY);

            if (UseHeuristic == false)
            {
                Root.H = 0;
            }
            else
            {
                if (offX > offY)
                {
                    Root.H = 14 * offY + 10 * (offX - offY);
                }
                else
                {
                    Root.H = 14 * offX + 10 * (offY - offX);
                }
            }
            OpenHeap.Add(Root.F, Root);

            int res = ProcessLowestNode(endX, endY, Closed, OpenHeap);

            while (res == 0)
            {
                res = ProcessLowestNode(endX, endY, Closed, OpenHeap);
            }

            if (res == -1)
            {
                return(null);
            }

            AStarNode node = null;

            if (res == 1)
            {
                node = GetClosedNode(endX, endY, Closed);
            }
            else if (res == 2)
            {
                node = Closed[Closed.Count - 1];
            }

            MapPath result = new MapPath();

            result.BuildFromFinalAStarNode(node);

            return(result);
        }