Question

我目前正在2D侧卷轴中实现A *寻路算法，但我遇到了一些困难。

我思考我正确地实现了它，但显然没有，因为它不起作用。

我正在使用优先级队列来提高效率，并遵循此处讨论的算法：

http://www.codeproject.com/Articles/5758/Path-finding-in-C

然而，我没有使用他们的优先级队列，因为许多评论指出它存在一些问题。相反，我使用以下优先级队列：

https://bitbucket.org/BlueRaja/high-speed-priority-queue-for-c/src

这是我的功能，然后我将讨论这个问题：

List<Waypoint> FindPathTo(Waypoint Goal)
{
    TileMath goalMath = TileMath.GetTileMath((int)Goal.x, (int)Goal.y);

    Waypoint startPt = new Waypoint((Vector2)this.transform.position);
    HeapPriorityQueue<Waypoint> OpenList = new HeapPriorityQueue<Waypoint>(MAX_NODES);
    HeapPriorityQueue<Waypoint> ClosedList = new HeapPriorityQueue<Waypoint>(MAX_NODES);

    List<Waypoint> Solution = new List<Waypoint>();

    OpenList.Enqueue(startPt, openPriority);
    openPriority--;

    print(Goal.GetPoint()); //testing
    print(OpenList.Count); //testing

    while (OpenList.Count > 0)
    {
        Waypoint CurrNode = OpenList.Dequeue();

        TileMath currMath = TileMath.GetTileMath((int)CurrNode.x, (int)CurrNode.y);

        if (currMath.GetXY() == goalMath.GetXY() && currMath.GetBlockID() == goalMath.GetBlockID()) // checks if the current node is the goal
        {
            while (CurrNode != null)
            {
                Solution.Insert(0, CurrNode);

                CurrNode = CurrNode.prev;

            }
            break;
        }

        List<Waypoint> successors = CurrNode.GetSuccessors();

        print(successors.Count);

        foreach (Waypoint w in successors)
        {
            Waypoint OpenWp = null;
            Waypoint ClosedWp = null;
            if(OpenList.Contains(w))
            {

                IEnumerator<Waypoint> ie = OpenList.GetEnumerator();

                while((int)ie.Current.x != (int)w.x && (int)ie.Current.y != (int)w.y && ie.Current != null)
                {
                    ie.MoveNext();
                }

                if (ie.Current == null)
                    print("IE ERROR. CHECK CONTAINS IN OPENLIST.");
                else
                    OpenWp = ie.Current;



                if (OpenWp != null && w.totalCost > OpenWp.totalCost)
                    continue;



            }
            if(ClosedList.Contains(w))
            {

                IEnumerator<Waypoint> ie = ClosedList.GetEnumerator();

                while ((int)ie.Current.x != (int)w.x && (int)ie.Current.y != (int)w.y && ie.Current != null)
                {
                    ie.MoveNext();
                }

                if (ie.Current == null)
                    print("IE ERROR. CHECK CONTAINS IN CLOSEDLIST.");
                else
                    ClosedWp = ie.Current;



                if (ClosedWp != null && w.totalCost > ClosedWp.totalCost)
                    continue;
            }

            if (OpenWp != null)
                OpenList.Remove(OpenWp);
            if (ClosedWp != null)
                ClosedList.Remove(ClosedWp);

            OpenList.Enqueue(w, openPriority);
            openPriority--;
            ClosedList.Enqueue(w, closedPriority);
            closedPriority--;


        }
    }

    return Solution;

}

基本上，我有方法返回一个Waypoint List（非常简单的类，如果你感兴趣，这里是它的一个pastebin：http://pastebin.com/Sch5vRY3），但是在我的函数中，List在返回时的Count为0 ，因此（错误地）表示没有通往该点的路径。

我已经完成了通常的调试，但是A *对我来说有点混乱，所以如果有人能帮我解决常见的陷阱，我会很感激。

我绝对是人工智能和路径寻找的新手，所以如果你有任何其他的指针，我都是耳朵！

感谢。

Answer 1

好吧，我不会告诉确切的代码，但是我会说出什么是A *算法，以及你的情况是什么：
在A *中我们定义了两个状态函数：成本和启发式，成本意味着＆＃34;从当前状态转移到另一个状态的成本是多少？＃34;在你的情况下它应该是距离当前点和点I之间的路径尝试。
启发式意味着＆＃34;我离目标有多远＆＃34;，在你的情况下，从我的位置到目标的距离可能很大。
在编写了这两个函数之后，你编写了一个函数，让我们把它称为＆＃34; f＆＃34;这两者相加。
A *算法实际上是一种贪婪的回溯算法，你可以在其中尝试最少的＆＃34; f＆＃34;。

无法弄清楚我的A *算法有什么问题

1 个答案: