魔兽世界 python 寻路采药 魔兽世界寻路写法

NPC寻路也是个老生常谈的

话题

了，但是一说到NPC寻路，可能就有人迷茫了：哥们儿你说的寻路是什么

意思？怎么个寻法？举个例子好不好？寻路这个词是游戏开发中专用的，映射到大家课本上学到的知识点，就是图(数据结构中的图结构)中两点之间的路径。这个路径不是特指最短路径，但它就专门指的就是图中两点之间的路径。

1.NPC有聪明也有笨的，

聪明的NPC 在玩家放大招的冷却时间内会找到一个 最短路径 直冲玩家去攻击。 一个有心计的NPC 就门绕到玩家后面去包抄或者 偷袭 ，而 胆小的NPC 就 到处乱跑乱跳 了。下面图示表示我能想到的寻路方式。

上面示意图中的图结构，每个网格的十字交叉点是图的节点，连接节点的线就是和节点就是该节点的出度或入度。从上图中可以看出，从A到B，我们给出了四条线。黄线是哪个胆小如鼠的NLC的路线，它左右乱窜，最后终于下定决心去攻击目标。红线和蓝线均是最短路径，同样的速度，NPC可以同时到达目标。绿色的线是那个心机婊，绕到目标后边搞偷袭去了。

2.分析。

蓝线 和 红线 不用说，是我们根据算法能找到的最短路径，可能找到红线，也可能找到蓝线，根据算法不同而不同，我们 总能找到一个最短路径 ， 后边会附上 一个最短路径的实现 算法 ，对算法感兴趣的可以参考一下。 黄线 ，是个到处乱攒的路径，到达目标之前一直让这个NPC瞎跑就行了，然后播放对应的动画（胆小的NPC播放瑟瑟发抖，极度聪明的NPC播放故作深沉的动画）。在时间基本上可以了之后，再给这个NPC找个最短路径让它去攻击目标哇。这样看起来这个NPC就有看头了。跑来跑去，有时候还思考，掐指一算，呵呵呵呵呵呵呵呵呵。而 绿线 就现在是重点了。它是要抽空绕到目标背后的，尽量偷袭目标。算是最聪明的一个NPC。

3.分析绿线，这个

NPC要绕到目标 后面去，我们的寻路系统要做哪些工作。首先，这个NPC能走过的通路要发生变化，普通的NPC是哪里都可以走的，横着 一个格子，竖着一个格子，有格子就能走。但是这个不一样。这个要绕道，不能随便走，要绕到目标后边去。这个NPC的可走的通路并不是想象中的格子，而是下面这样的：

比如上面的绿色绕行路线和红色

绕行路线 。这个时候无视之前我们定义的图的节点的邻接点的组合。把图中出现的这几个点看成相邻节点来找最短路径，这个需要重新为这个NPC定义一个邻接表了。 邻接表就是表示相邻两个节点的列表。 我们定义几条类似于绿色和红色的可以绕行到目标后面的数个路径，在邻接表表示的图中， 这些路径是通的。比如绿色和红色的这条线 ，包括类似的一些可以绕到目标后面的一些路径。根据需求， 邻接表是可以动态修改的 ，修改后需要重新计算路径。

4.实现。热气球来了，马上就能上天！

以上寻路设计的基础都是最短路径算法。为什么要最短路径？答：因为不管你怎么走，到最后的目标都是要找到一个目的地，最后一步总是要来个最短路径算法的，所以这个最短路径的算法是基础了。

接第三步来的，我们把绕行

简化 一下有心机的NPC的走法。首先它在一定单位内是走S形状的路线的。

 

对角线是绿色的线。每一步走一个对角，但是每一个对角有分成了三个小步，这三小步怎么走就随意了，现在我们求这个绿色的对角线连接起来的路径。算法的原理是最短路径算法，地杰斯特拉最短路径。在定义邻接表时候，斜对角为日字的定义为相邻连通节点即可。具体算法如下，可以找这条绿色的通往目标的路径。然后再补充两个绿色节点之间的路径就可以啦！代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
 
namespace ShortPathTest
{
    class GenShortPath
    {
        public int GenTargetPath(int tableWidth, int x1, int y1, int x2, int y2)
        {
            if (tableWidth <= 0) return -1;
 
            int retValue = -1;
            //初始化一个图
            Element[,] map = new Element[tableWidth, tableWidth];
            int[,] distance = new int[tableWidth * tableWidth, tableWidth * tableWidth];
            List<Element> pointsInMap = new List<Element>();
            for (int i = 0; i < tableWidth; i++)
            {
                for (int j = 0; j < tableWidth; j++)
                {
                    Element e = new Element() { posX = i, posY = j };
                    map[i, j] = e;
                    pointsInMap.Add(e);
                }   
            }
 
            for (int i = 0; i < tableWidth * tableWidth; i++)
            {
                for (int j = 0; j < tableWidth * tableWidth; j++)
                            {
                    if (i == j)
                    {
                        distance[i, j] = 0;
                    }
                    else
                    {
                        int posX_1 = pointsInMap.posX;
                        int posY_1 = pointsInMap.posY;
 
                        int posX_2 = pointsInMap[j].posX;
                        int posY_2 = pointsInMap[j].posY;
 
                        //判断两个点的相对位置
                        if (Math.Abs(posX_1 - posX_2) == 1 && Math.Abs(posY_1 - posY_2) == 2)
                        {
                            distance[i, j] = 1;
                        }
                        else if (Math.Abs(posX_1 - posX_2) == 2 && Math.Abs(posY_1 - posY_2) == 1)
                        {
                            distance[i, j] = 1;
                        }
                        else
                        {
                            distance[i, j] = int.MaxValue;
                        }
                    }
                            }
            }
 
            //寻找路点
            int pointStartIndex = tableWidth * x1 + y1;
            Dictionary<int, int> dist = new Dictionary<int,int>();
            Dictionary<int, List<Element>> path = new Dictionary<int, List<Element>>();
            for (int i = 0; i < tableWidth * tableWidth; i++)
            {
                path = new List<Element>();
                dist  = distance[i,pointStartIndex];
                if (dist < int.MaxValue)
                {
                    path.Add(pointsInMap[pointStartIndex]);
                    path.Add(pointsInMap);
                }
            }
 
            List<Element> s = new List<Element>();
            s.Add(pointsInMap[pointStartIndex]);
 
            for (int t = 0; t <= tableWidth *  tableWidth - 1; t++)
            {
                int min = int.MaxValue;
                int k = -1;
                for (int i = 0; i < tableWidth * tableWidth; i++)
                {
                    if (!s.Contains(pointsInMap) && dist < min) {
                        k = i;
                        min = dist;
                    }
                }
 
                if (min == int.MaxValue) break;
 
                s.Add(pointsInMap[k]);
 
                for (int i = 0; i < tableWidth * tableWidth; i++)
                {
                    if (!s.Contains(pointsInMap) && distance[k, i] != int.MaxValue && (dist[k] + distance[k, i]) < dist)
                    {
                        dist = dist[k] + distance[k, i];
                        path = new List<Element>(path[k]);
                        path.Add(pointsInMap);
                    }
                }
            }
            foreach (int k in path.Keys)
            {
                List<Element> curPath = path[k];
                Element ele = curPath[curPath.Count - 1];
 
                if (ele.posX == x2 && ele.posY == y2)
                {
                    string str = "Path to::========>>>" + curPath[curPath.Count - 1].ToString() + "\n";
                    for (int i = 0; i < curPath.Count; i++)
                    {
                        str += curPath.ToString() + "-->";
                    }
                    Console.WriteLine(str);
                }
            }
 
            return retValue;
        }
    }
}