unity战棋类游戏移动范围搜索算法设计（未优化）

    SLG战棋类游戏有很多细分类，本次博文讲解的是军事型的，类似高级战争2，有很多军事单位，建筑，同时还有多种地形，例如坦克不能爬山，步兵不能下海，树林的移动力消耗要远大于平原，公路最快.....等等一系列复杂设定。

 

这里我们设，平原移动力消耗为2，建筑为1，公路为1，基础步兵的移动力为5（不考虑油量，每回合移动力都是5）

基础的二维坐标类为Point

 

大约需要三个类

    1.GridContainer类，里面核心是两个字典，分别存储着地形格子和部队格子

    2.Node类，独立于地形和部队格子存在，只用于寻路计算

    3.PathNav类，负责计算路径和移动范围

 

下面是移动范围算法简述

    不同于A*算法的三个估价值，这里只需要一个，即油量消耗oilCost，用一个gCost{get.......}的属性来管理，存在Node类中

    PathNav类中存三个容器

    1.HashSet ReachableNodeSet    //用来存可以到达的格子

    2.List UnknownList           //用来存准备往周围四个点检测的格子

    3.Dictionary MapDic      //用来检测的地图，其实可以不用，但是为了不增大GridContainer的复杂度，还是将Node地图独立出来比较好

算法开始，点击步兵

    先得到步兵的移动力oilTotal=5，所以计算步兵右上右下左上左下最远移动到的距离，因为最低的公路油量消耗是1，所以步兵最远移动5，四个点组成的一个10*10（注意可能超出地图，多加一个坐标值的判断，而且不需要TryGet）矩阵

    遍历这个10*10矩阵，将每个点用Node存到MapDic中，MapDic[point]=new Node(point,地形的移动力消耗常数，地形的类型(树林高山还是公路)),point是当前位置的坐标

    至此，地图就算计算完了，然后开始根据这个地图计算移动范围

        算法思想，从出发点向周围扩散，分别计算到达每个点时的油量剩余，有剩余时则继续向四个方向扩散

        所以，下面给出Node定义，有些可以暂时忽略，是用来计算寻路的

 

public class Node
{
    private static int OilCostMax = 999;   //最大耗油量

    public static Unit startUnit;     //开始地点
    public static Point targetPos;    //目标地点

    //当前位置的地形类型
    public GridType terrainType;

    //当前Node坐标
    public Point pos;

    //三个用来计算贪心的属性
    public int fCost  //
    {
        get
        {
            return gCost + hCost;
        }
    }
    public int gCost  //当前格子的oilCost
    {
        get
        {
            if (GridContainer.Instance.UnitDic.ContainsKey(pos)&&pos!=startUnit.gridID)   //这里有一个单位，堵着路
            {
                return OilCostMax;
            }
            else if (startUnit.isInfantry()
            && (terrainType == GridType.Sea || terrainType == GridType.Reef))   //人不能下海
            {
                return OilCostMax;
            }
            else if (startUnit.isPlane())    //飞机固定消耗2
            {
                return 2;
            }
            else if (startUnit.isShip()
                && terrainType != GridType.Sea)    //船不能上岸
            {
                return OilCostMax;
            }
            else if (startUnit.isVehicle()
                && (terrainType == GridType.Mountain || terrainType == GridType.Sea || terrainType == GridType.Reef))   //车不能上山下海
            {
                return OilCostMax;
            }
            else
            {
                return oilCost;       //其他一概返回默认油量消耗
            }
        }
    }
    public int oilCost;
    public int hCost  //与目标点的距离
    {
        get
        {
			return Math.Abs(pos.X - targetPos.X)
                + Math.Abs(pos.Z - targetPos.Z);
        }
    }

    //移动到这里时还剩下的油量
    public int oilLeft;

    //父格子
    public Node parent;

    public Node(Point pos, int oilCost, GridType type)
    {
        this.pos = pos;
        this.oilCost = oilCost;
        terrainType = type;
    }
}

    从这里可以看出油量消耗oilCost分实际消耗和理想消耗，所谓理想消耗就是格子的默认消耗，实际消耗就是考虑到实际情况后的油量消耗（其实就是否是路障）
    根据自己点击的是什么格子，分别计算什么是路障，这里可以优化。

 

    

    下面开始计算移动范围 

     初始化起始点，设置下油量，父节点，注意初始点的oilCost为0，这里有些细节，注意别出bug

     然后将初始点加入要探索的列表UnknownList

     开始循环，只要要探索的列表不为空，则继续探索

     从列表中取出一个节点，设置父节点为之前探索的节点，计算下油量消耗，如果油量剩余不为0，则将该节点周围的四个节点全部加入探索列表，继续探索（注意TryGet），最后将之前探索完了的格子从探索列表中删除

    注意检查下不要重复探索

 

private static void AStarCheckRange(Point startPos,int oilTotal,ref Dictionary mapDic)
    {

        Node startNode = mapDic[startPos];

        startNode.oilLeft = oilTotal;
        startNode.parent = startNode;
        startNode.oilCost = 0;
        UnknownList.Add(startNode);

        startNode.oilLeft = startNode.parent.oilLeft - startNode.oilCost;   //求出油量剩余 ，循环（这句可以省略，只是方便理解）

        while (UnknownList.Count != 0)
        {
            Node reachableNode = UnknownList[0];
            Node parent = UnknownList[0].parent;
            reachableNode.oilLeft = parent.oilLeft - reachableNode.gCost;

            if (reachableNode.oilLeft >= 0)  //如果可以到达
            {
                ReachableNodeSet.Add(reachableNode);  //放到可以消除的列表中

                #region 找到周围四个点并加入判断列表
                Node upNode;
                if (mapDic.TryGetValue(reachableNode.pos.Up(), out upNode))
                {
                    if (!ReachableNodeSet.Contains(upNode)&&!UnknownList.Contains(upNode))
                    {
                        upNode.parent = reachableNode;
                        UnknownList.Add(upNode);
                    }
                }

                Node rightNode;
                if (mapDic.TryGetValue(reachableNode.pos.Right(), out rightNode))
                {
                    if (!ReachableNodeSet.Contains(rightNode)&&!UnknownList.Contains(rightNode))
                    {
                        rightNode.parent = reachableNode;
                        UnknownList.Add(rightNode);
                    }
                }

                Node downNode;
                if (mapDic.TryGetValue(reachableNode.pos.Down(), out downNode))
                {
                    if (!ReachableNodeSet.Contains(downNode)&&!UnknownList.Contains(downNode))
                    {
                        downNode.parent = reachableNode;
                        UnknownList.Add(downNode);
                    }
                }

                Node leftNode;
                if (mapDic.TryGetValue(reachableNode.pos.Left(), out leftNode))
                {
                    if (!ReachableNodeSet.Contains(leftNode)&&!UnknownList.Contains(leftNode))
                    {
                        leftNode.parent = reachableNode;
                        UnknownList.Add(leftNode);
                    }
                        
                }
                #endregion    //其实可以用循环啦，只是懒得破坏库设计
            }

            UnknownList.RemoveAt(0);
        }
        foreach (Node node in ReachableNodeSet)
        {
            GridContainer.Instance.TerrainDic[node.pos].SetHighLight();   //设置高亮显示

            ReachablePointSet.Add(node.pos);
        }
    }

     至此，ReachableNodeSet中存的就是所有的移动范围内的格子了，显示高亮即可