梦幻之旅2

如何寻路

这个是我最困扰的，也是我想了好久才想出来的。游戏中，你肯定要判断当前的路是不是可以走，当然在没有障碍物的情况下，你是可以随便走的，但是我的这个游戏里面有地图，有地图肯定就得有障碍物，我的想法是这样先把一张图片（320*240），按照1*1的大小拆分下来，用一个矩阵表示当前坐标的状态，例如(20,30,1)这三个参数分别表示X坐标，Y坐标，最后一个参数0表示可以到达，1表示不可到达。这样经过矩阵的初始化以后，就可以在逻辑上知道，当前玩家是否可以行走了。

下来就是寻路了，寻路是游戏开发中非常重要的一个元素，如何找到一条最短的路径是程序需要设计的算法，由于自己在算法上也有点研究，自己也想了好久，终于想出了一种办法。

在介绍我的办法之前，我先介绍两种常见的搜索算法，分别是深度优先和广度优先，广度优先是从初始状态一层一层的向下找，知道找到结果目标为止，深度优先是按照一定的顺序先查找完一个分支再查找另一个分支，知道找到目标结果为止。这两种搜索方法有的很大缺陷是它们都是在一个给定的状态空间中穷举。这在状态空间不大的情况下是很适合的算法，但是当空间很大并且不可预测的情况下就不可取。这个时候这两种算法的效率太低甚至有时是无法完成，所以当地图大时候，他们就变得很无力。

我们将以下图作为地图来进行讲解,图中对每一个方格都进行了编号,其中绿色的方格代表起点,红色的方格代表终点,蓝色的方格代表障碍,我们将用这种算法来寻找一条从起点到终点最优路径,为了方便讲解,本地图规定只能走上下左右4个方向,当你理解了我的想法后,8个方向也自然明白

 

图14

 

在地图中,每一个方格最基本也要具有两个属性值,一个是方格是通畅的还是障碍,另一个就是指向他父亲方格的指针(相当于双向链表结构中的父结点指针),我们假设方格值为0时为通畅,值为1时为障碍

在算法中,有4个相当重要的元素,第一个就是指向父亲结点的指针,第二个就是一个OPEN表,第三个就是CLOSE表,这两张表的具体作用我们在后面边用边介绍,第四个就是每个结点的F值(F值相当于图结构中的权值)

而F = H + G;其中H值为从网格上当前方格移动到终点的预估移动耗费。可能会让你有点迷惑。这样叫的原因是因为它只是个猜测。我们没办法事先知道路径的长度，因为路上可能存在各种障碍。我们定义H值为 “终点所在行”减去“当前格所在行”的绝对值 与 “终点所在列”减去“当前格所在列”的绝对值之和,而G值为从“当前格的父亲格”移动到当前格的预估移动耗费,假如当前格的父亲的移动耗费为2，那个当前格的G值就为2+1=3，在这里我们设定一个基数10,每个H和G都要乘以10,这样方便观察

好了,我们开始对地图进行搜索。

首先,我们将起点的父亲结点设置为NULL,然后将起点的G值设置为0,再装进open表里面,然后将起点作为父亲结点的周围4个点20,28,30,38(因为我们地图只能走4个方向,如果是8方向,则要加8个点进去)都加进open列表里面,并算去每个结点的H值,然后再将起点从open列表删除,放进close表中,我们将放进close表的所有方格都用浅蓝色线条进行框边处理,所以这次搜索以后,图片变为如下格式,其中箭头代表的是其父结点

图15

其中每个格子的左下方为G值,右下方为H值,左上方为F值,我们拿28号格子为例来讲解一写F值的算法,首先因为终点33在4行7列,而28在4行2列,则行数相差为0,列数相差为5,总和为5,再乘以我们先前定的基数10,所以H值为50,又因为从28的父结点29移动到28,长度为1格,而29号为起点，G值为0,所以在父亲结点29的基础上移动到28所消耗的G值为(0 + 1) *10 = 10,0为父亲结点的G值,1为从29到28的消耗。

当前OPEN表中的值: 20,28,30,38 当前CLOSE表中的值: 29。

现在我们开始寻找OPEN列表中F值最低的,得出结点30的F值最低,且为40,然后将结点30从OPEN表中删除,然后再加入到CLOSE表中,然后在判断结点30周围4个结点,因为结点31为障碍,结点29存在于CLOSE表中,我们将不处理这两点,只将21和39号结点加入OPEN表中,添加完后地图变为下图样式

当前OPEN表中的值: 20,28,38,21,39 当前CLOSE表中的值: 29,30

图16

接着我们重复上面的过程,寻找OPEN表中F值为低的值,我们发现OPEN表中所有结点的F值都为60,我们随即取一个结点,这里我们直接取最后添加进OPEN表中的结点,这样方便访问(因为存在这样的情况,所有从一个点到另外一个点的最短路径可能不只一条),我们取结点39,将他从OPEN表中删除,并添加进CLOSE表中,然后观察39号结点周围的4个结点,因为40号结点为障碍,所以我们不管它,而30号结点已经存在与OPEN表中了,所以我们要比较下假设39号结点为30号结点的父结点,30号结点的G值会不会更小,如果更小的话我们将30结点的父结点改为39号,这里我们以39号结点为父结点,得出30号结点的新G值为20,而30号结点原来的G值为10,并不比原来的小,所以我们不对30号进行任何操作,同样的对38号结点进行上述操作后我们也不对它进行任何操作,接着我们把48号结点添加进OPEN表中,添加完后地图变为下图样式。

当前OPEN表中的值: 20,28,38,21,48 当前CLOSE表中的值: 29,30,39。

图17

以后的过程中我们都重复这样的过程,一直到遍历到了最后终点,通过遍历父结点编号,我们能够得出一条最短路径,具体完整的推导过程我就不写出来了,因为和刚才那几步是一样的，这里我再讲出一个特例,然后基本上算法就没问题了

上面的最后一推导中,我们在观察39号结点时,发现他周围已经有结点在OPEN表中了,我说"比较下假设39号结点为30号结点的父结点,30号结点的G值会不会更小,如果更小的话我们将30结点的父结点改为39号",但是刚才没有遇到G值更小的情况，所以这里我假设出一种G值更小的情况,然后让大家知道该怎么操作,假设以39号为父结点,我们得出的30号的新G值为5(只是假设),比30号的原G值10还要小,所以我们要修改路径,改变30号的箭头,本来他是指向29号结点的，我们现在让他指向39号结点,38号结点的操作也一样

好了,算法的大体思路就是这样了，对于8方向的地图来说，唯一的改变就是G值方面,在上下左右,我们的G值是加10,但是在斜方向我们要加14(为什么是14，你可以想想勾股定理）。

下面上代码

 

 public class Stack
    {
        private Node node;
        private Stack next;
        public Node Node
        {
            get { return node; }
            set { node = value; }
        }
        public Stack Next
        {
            get { return next; }
            set { next = value; }
        }
        public Stack()
        { }
    }

 

 public class Node
    {
        private int f;
        private int h;
        private int g;
        private int x;
        private int y;
        private int index;//对应节点编号索引
        private Node parent;
        private Node[] child;
        private Node next;

        public int F
        {
            get { return f; }
            set { f = value; }
        }
        public int H
        {
            get { return h; }
            set { h = value; }
        }
        public int G
        {
            get { return g; }
            set { g = value; }
        }
        public int X
        {
            get { return x; }
            set { x = value; }
        }
        public int Y
        {
            get { return y; }
            set { y = value; }
        }
        public int Index
        {
            get { return index; }
            set { index = value; }
        }
        public Node Parent
        {
            get { return parent; }
            set { parent = value; }
        }
        public Node[] Child
        {
            get { return child; }
            set { child = value; }
        }
        public Node Next
        {
            get { return next; }
            set { next = value; }
        }


        public Node(int x, int y)
        {
            this.x = x;
            this.y = y;
            this.child = new Node[8];
        }
        public Node()
        {
            this.child = new Node[8];
        }
    }

 public class MapTerrain
    {
        private int _mapPositionX;
        public int MapPositionX
        {
            get
            {
                return (this._mapPositionX);
            }
            set
            {
                this._mapPositionX = value;
            }
        }

        private int _mapPositionY;
        public int MapPositionY
        {
            get
            {
                return (this._mapPositionY);
            }
            set
            {
                this._mapPositionY = value;
            }
        }

        private int _terrain;
        public int Terrain
        {
            get
            {
                return (this._terrain);
            }
            set
            {
                this._terrain = value;
            }
        }

        public MapTerrain()
        { }
    }

  public class AStart
    {
        private Node open;
        private Node close;
        private Stack stack;
        public int[] indexs = new int[30 * 30];
        public Point ScreenCenter;
        public AStart()
        {
            this.Inivate();
        }

        public void SetScreenCenter(Point Point)
        {
            ScreenCenter = Point;
        }


        public void SetBlock(List<MapTerrain> MapTerrainList, Point Point)
        {
            ScreenCenter = Point;
            List<MapTerrain> NowMapTerrainList = new List<MapTerrain>();
            foreach (MapTerrain MapTerrain in MapTerrainList)
            {
                if (MapTerrain.MapPositionX >= Point.X / 320 * 10 - 10 && MapTerrain.MapPositionX < Point.X / 320 * 10 + 20
                    && MapTerrain.MapPositionY >= Point.Y / 240 * 10 - 10 && MapTerrain.MapPositionY < Point.Y / 240 * 10 + 20)
                {
                    indexs[(MapTerrain.MapPositionY - Point.Y / 240 * 10 + 10) * 30 + MapTerrain.MapPositionX - Point.X / 320 * 10 + 10] = MapTerrain.Terrain;
                }
            }
        }

        /// <summary>
        /// 初始化，默认为0，表示边界不可行走
        /// </summary>
        private void Inivate()
        {
            int c, index = 0;//设置边界
            for (c = 0; c < 30; c++)
            {
                indexs[c] = 0;//初始化 正方形的上边 30个
            }
            for (c = 1; c < 29; c++)
            {
                index += 30;//换行 加等30 即换行
                indexs[index] = 0;//初始化 正方形的左边 28个
                indexs[index + 29] = 0; //初始化 正方形的右边 28个
            }
            index += 29;
            for (c = index; c < 30 * 30; c++)
            {
                indexs[c] = 0; //初始化 正方形的下边 30个
            }

            open = new Node();
            close = new Node();
            stack = new Stack();
        }

        public List<Node> FindPath(Point StarPoint, Point EndPoint)
        {
            Inivate();//初始化，设置边界
            StarPoint = new Point(StarPoint.X - StarPoint.X % 32, StarPoint.Y - StarPoint.Y % 24);
            EndPoint = new Point(EndPoint.X - EndPoint.X % 32, EndPoint.Y - EndPoint.Y % 24);
            List<Node> path = new List<Node>();
            if (indexs[GetIndex(EndPoint.X, EndPoint.Y)] == 0)
                return path;
            Node node, bestnode = null;
            int bestIndex = this.GetIndex(EndPoint.X, EndPoint.Y);
            node = new Node(StarPoint.X, StarPoint.Y);
            node.G = 0;
            node.H = (StarPoint.X - EndPoint.X) * (StarPoint.X - EndPoint.X) + (StarPoint.Y - EndPoint.Y) * (StarPoint.Y - EndPoint.Y);//如果开平方就不精确了
            node.F = node.H + node.G;
            node.Index = this.GetIndex(StarPoint.X, StarPoint.Y);
            open.Next = node;
            while (true)
            {
                bestnode = this.GetBestNode();
                if (bestnode != null)
                {
                    if (bestnode.Index.Equals(bestIndex))
                        break;
                    this.GenerateSuccessors(bestnode, EndPoint);
                }
                else
                    break;
            }
            this.ShowPath(path, bestnode);
            return path;
        }

        private void ShowPath(List<Node> list, Node bestnode)
        {
            if (bestnode != null)
            {
                if (bestnode.Parent != null)
                {
                    this.ShowPath(list, bestnode.Parent);
                }
                list.Add(bestnode);
            }
        }

        private void GenerateSuccessors(Node bestnode, Point EndPoint)
        {
            int x, y = 0;
            for (int i = 0; i < 8; i++)
            {
                switch (i)
                {
                    case 0://东
                        x = bestnode.X + 32;
                        y = bestnode.Y;
                        if (HasIndex(x, y))
                            this.GenerateSucc(bestnode, x, y, EndPoint, 10);
                        break;
                    case 1://南
                        x = bestnode.X;
                        y = bestnode.Y + 24;
                        if (HasIndex(x, y))
                            this.GenerateSucc(bestnode, x, y, EndPoint, 10);
                        break;
                    case 2://西
                        x = bestnode.X - 32;
                        y = bestnode.Y;
                        if (HasIndex(x, y))
                            this.GenerateSucc(bestnode, x, y, EndPoint, 10);
                        break;
                    case 3://北
                        x = bestnode.X;
                        y = bestnode.Y - 24;
                        if (HasIndex(x, y))
                            this.GenerateSucc(bestnode, x, y, EndPoint, 10);
                        break;
                    case 4://东北
                        x = bestnode.X + 32;
                        y = bestnode.Y - 24;
                        if (HasIndex(x, y))
                            this.GenerateSucc(bestnode, x, y, EndPoint, 14);
                        break;
                    case 5://东南
                        x = bestnode.X + 32;
                        y = bestnode.Y + 24;
                        if (HasIndex(x, y))
                            this.GenerateSucc(bestnode, x, y, EndPoint, 14);
                        break;
                    case 6://西南
                        x = bestnode.X - 32;
                        y = bestnode.Y + 24;
                        if (HasIndex(x, y))
                            this.GenerateSucc(bestnode, x, y, EndPoint, 14);
                        break;
                    case 7://西北
                        x = bestnode.X - 32;
                        y = bestnode.Y - 24;
                        if (HasIndex(x, y))
                            this.GenerateSucc(bestnode, x, y, EndPoint, 14);
                        break;
                }
            }
        }

        private void GenerateSucc(Node bestnode, int x, int y, Point EndPoint, int step)
        {
            int g, index, c = 0;
            g = bestnode.G + step;
            index = this.GetIndex(x, y);
            Node old, successor = null;
            if ((old = CheckOpen(index)) != null)
            {
                for (c = 0; c < 8; c++)
                    if (bestnode.Child[c] == null)
                        break;
                bestnode.Child[c] = old;
                if (g < old.G)
                {
                    old.Parent = bestnode; ;
                    old.G = g;
                    old.F = g + old.H;
                }
            }
            else if ((old = CheckClose(index)) != null)
            {
                for (c = 0; c < 8; c++)
                    if (bestnode.Child[c] == null)
                        break;
                bestnode.Child[c] = old;
                if (g < old.G)
                {
                    old.Parent = bestnode;
                    old.G = g;
                    old.F = g + old.H;
                    this.PropagateDown(old, step);
                }
            }
            else
            {
                successor = new Node(x, y);
                successor.Parent = bestnode;
                successor.G = g;
                successor.H = (x - EndPoint.X) * (x - EndPoint.X) + (y - EndPoint.Y) * (y - EndPoint.Y);
                successor.F = g + successor.H;
                successor.Index = index;
                this.Insert(successor);
                for (c = 0; c < 8; c++)
                    if (bestnode.Child[c] == null)
                        break;
                bestnode.Child[c] = successor;
            }
        }

        private void PropagateDown(Node old, int step)
        {
            int c, g = 0;
            Node child, father = null;
            g = old.G;
            for (c = 0; c < 8; c++)
            {
                if ((child = old.Child[c]) == null)
                    break;
                if (g + step < child.G)
                {
                    child.G = g + step;
                    child.F = child.G + child.H;
                    child.Parent = old;
                    this.Push(child);
                }
            }
            while (stack.Next != null)
            {
                father = this.Pop();
                for (c = 0; c < 8; c++)
                {
                    if ((child = father.Child[c]) == null)
                        break;
                    if (father.G + step < child.G)
                    {
                        child.G = father.G + step;
                        child.F = child.G + child.H;
                        child.Parent = father;
                        this.Push(child);
                    }
                }
            }
        }

        private void Insert(Node successor)
        {
            Node tmp1, tmp2 = null;
            int f = 0;
            if (open.Next == null)
            {
                open.Next = successor;
                return;
            }
            f = successor.F;
            tmp1 = open;
            tmp2 = open.Next;
            while ((tmp2 != null) && (tmp2.F < f))
            {
                tmp1 = tmp2;
                tmp2 = tmp2.Next;
            }
            successor.Next = tmp2;
            tmp1.Next = successor;
        }

        private Node CheckOpen(int index)
        {
            Node temp = null;
            temp = open.Next;
            while (temp != null)
            {
                if (temp.Index.Equals(index))
                    return temp;
                else
                    temp = temp.Next;
            }
            return temp;
        }

        private Node CheckClose(int index)
        {
            Node temp = null;
            temp = close.Next;
            while (temp != null)
            {
                if (temp.Index.Equals(index))
                    return temp;
                else
                    temp = temp.Next;
            }
            return temp;
        }

        private bool HasIndex(int x, int y)
        {
            try
            {
                if (!indexs[GetIndex(x, y)].Equals(0))//该节点不是障碍物
                    return true;
                else
                    return false;
            }
            catch (Exception)
            {

                return false;
            }
        }
        /// <summary>
        /// 寻找最优点
        /// </summary>
        /// <returns></returns>
        private Node GetBestNode()
        {
            Node temp = null;
            if (open.Next != null)
            {
                temp = open.Next;
                open.Next = temp.Next;
                temp.Next = close.Next;
                close.Next = temp;
            }
            return temp;
        }

        public int GetIndex(int x, int y)
        {
            return (y - ScreenCenter.Y + ScreenCenter.Y % 240 + 240) / 24 * 30 + (x - ScreenCenter.X + ScreenCenter.X % 320 + 320) / 32;
        }


        private void Push(Node node)
        {
            Stack temp = new Stack();
            temp.Node = node;
            temp.Next = stack.Next;
            stack.Next = temp;
        }

        private Node Pop()
        {
            Node tempNode = null;
            Stack tempStack = null;
            tempStack = stack.Next;
            tempNode = tempStack.Node;
            stack.Next = tempStack.Next;
            return tempNode;
        }
    }