一、问题概述

游戏中有敌我双方，有四十个方格，当轮到我方武将行动的时候，要先显示出我方武将可以行动的方位，这个就涉及到我方武将的行动力的大小来决定，预先做出路径的预算。这里还要考虑敌方以及地标(例如:炸弹、势头)的阻挡，以及特殊方格对武将行动力的消耗以及敌方的间隔阻挡规则。

当碰到这个问题的时候，问老大选择用什么寻路算法，他推荐的是Dijstra算法，但我看了之后感觉还不是很适合我的需求，第一：我觉得Dijstra算法是有向图的最佳路径选择，节点之间路径长度必须先知晓，但我这里四十个方格如果要两两制定感觉稍微复杂，而且随着武将的移动，地图还是时时变化的，感觉更复杂。第二：Distra算法没有阻挡考虑，当然也可以记录若干路径然后考虑阻挡选择最优路径，我感觉也稍复杂。

然而我的第一反应该需求A*算法挺接近的，然后咨询老大，老大说A*方格之间距离必须要均等不然比较复杂。然后再咨询公司其他稍有经验同事，当然各有个的说法，什么深度、广度遍历，感觉没一个确定的说法。让我选择就纠结了一天，不敢轻易选择，如果稍有考虑不慎，说不定就要做几天白用工，但最后我还是坚持自己的想法用A*来实现。

二、关于A*

A*通用的计算公式F=G+H

G:表示从起点A移动到网格上指定方格的移动耗费(我这里没考虑斜方向移动),也可理解为节点的权重

H:表示从制定方格移动到终点B的预计耗费,这里一般就是计算距离*系数

三、寻路思想

1.从起点A开始，把它添加到"开启列表"

2.寻找A点可到到的周围四个点，这里可到达是指没有阻挡并且已经不再关闭列表中的节点，并把他们添加进开启列表，并设置他们的父节点为A

3.从开启列表中删除A点并添加进关闭列表中，关闭列表就是存放的不需要检测的方格节点

4.检查它所有相邻并且合一到达的方格，如果这些方格还不再开启列表里的话就把他们加入开启列表，计算这些方格的GHF值并设置它的父节点

5.如果某个相邻方格 D 已经在 "开启列表" 里了, 检查如果用新的路径 (就是经过C 的路径) 到达它的话, G值是否会更低一些, 如果新的G值更低, 那就把它的 "父方格" 改为目前选中的方格 C, 然后重新计算它的 F 值和 G 值 (H 值不需要重新计算, 因为对于每个方块, H 值是不变的). 如果新的 G 值比较高, 就说明经过 C 再到达 D 不是一个明智的选择, 因为它需要更远的路, 这时我们什么也不做

6.当发现开启列表中有终点目标方格的时候则说明路径已经找到。

关于详细的图解可以参考其他网友的详解，我这里就不详细写了。

四、找回路径

我们找到最后一个点的时候然后层层往之前找到他的父节点迭代到最后不为空结束

五、数据结构

Point类

[plain] view plaincopyprint?

1. module(‘Point‘, package.seeall)
2. -- require("script/battle/BattleCommon")
3. --计算F值
4. function CalcF( point )
5. point.F = point.G + point.H
6. end
7. function create( posId )
8. local point = {}
9. point.parentPoint = {}
10. point.step = 1 --用于计算h值
11. local x,y = BattleCommon.convertPosIdToCoord(posId)
12. point.F = 0
13. point.G = 0
14. point.H = 0
15. point.X = y            --point.X范围[1,5]
16. point.Y = x            --point.Y范围[1,8]
17. point.posId = posId
18. point.CalcF = CalcF
19. return point
20. end
21. return Point

地形(Maze)结构

[plain] view plaincopyprint?

1. --根据一个table创建一个地形
2. function create( tb )
3. local maze = {}
4. maze.step = 1 --格子与格子的基本距离,用于计算H值
5. maze.mazeArray = tb
6. maze.openList = TabledArray.create() --开启列表
7. maze.closeList = TabledArray.create() --关闭列表
8. maze.findPath = findPath
9. return maze
10. end

六、主要代码

[plain] view plaincopyprint?

1. module(‘Maze‘, package.seeall)
2. require("script/battle/TabledArray")
3. require("script/battle/BattleCommon")
4. require ("script/battle/Point")
5. -- --获取列表中F值最小的点
6. function getMinPoint( pointsList )
7. local minPoint = pointsList.tbl[1]
8. for i = 1,pointsList:getSize() do
9. if minPoint.F > pointsList.tbl[i].F then
10. minPoint = pointsList.tbl[i]
11. end
12. end
13. return minPoint
14. end
15. -- --检测是否有阻挡,没有阻挡为true
16. function checkBlock( maze,x,y,roleFlag)              --x范围[1,5]  y范围[1,8]
17. if roleFlag == BattleCommon.BATTLE_GROUP_ALLIES then --我方阵营
18. if maze.mazeArray[x][y][1] == 0 or maze.mazeArray[x][y][1] == 1 then
19. return true  --没有阻挡
20. else
21. return false
22. end
23. elseif roleFlag == BattleCommon.BATTLE_GROUP_ENEMY then
24. if maze.mazeArray[x][y][1] == 0 or maze.mazeArray[x][y][1] == 2 then
25. return true  --没有阻挡
26. else
27. return false
28. end
29. end
30. end
31. -- --列表中是否包含x,y的点
32. function existsXY( list,x,y )
33. if list:getSize()>0 then
34. for i,point in pairs(list.tbl) do
35. if point.X == x and point.Y == y then
36. return true
37. end
38. end
39. end
40. return false
41. end
42. --列表中是否包含某个点
43. function existsPoint( list,point )
44. for i, p in pairs(list.tbl) do
45. if (p.X == point.X) and (p.Y == point.Y) then
46. return true
47. end
48. end
49. return false
50. end
51. -- --检测能达到的点
52. function canReach( maze,startPoint,x,y,roleFlag)
53. if (not checkBlock(maze,x,y,roleFlag)) or  existsXY(maze.closeList,x,y) then --关闭列表中包含这个点或者有阻挡
54. return false
55. else
56. if (math.abs(x-startPoint.X)+math.abs(y-startPoint.Y) == 1 ) then
57. return true
58. end
59. end
60. end
61. -- --获取相邻的点
62. function getSurroundPoints( maze,point,roleFlag )
63. local surroundPoints = TabledArray.create()
64. for i = point.X - 1 ,point.X + 1 do
65. for j=point.Y - 1,point.Y + 1 do
66. if i>0 and i<6 and j > 0 and j < 9 then  --排除超过表姐
67. if BattleCommon.distanceFromTo(point.posId,BattleCommon.convertToPositionId(j-1,i-1)) < 2 then
68. if canReach(maze,point,i,j,roleFlag) then
69. surroundPoints:append(maze.mazeArray[i][j][2])
70. end
71. end
72. end
73. end
74. end
75. return surroundPoints   --返回point点的集合
76. end
77. -- --计算G值
78. function CalcG( point )
79. local G = point.G
80. local parentG = 0
81. if point.parentPoint then
82. parentG = point.parentPoint.G
83. end
84. return G + parentG
85. end
86. function foundPoint( tempStart,point )
87. local G = CalcG(point)
88. if G < point.G then
89. point.parentPoint = tempStart
90. point.G = G
91. point:CalcF()
92. end
93. end
94. function notFoundPoint( maze,tempStart,point )
95. point.parentPoint = tempStart
96. point.G = CalcG(point)
97. point:CalcF()
98. maze.openList:append(point)
99. end
100. function getPoint( list,data )
101. for i,point in pairs(list.tbl) do
102. if point.posId == data.posId then
103. return point
104. end
105. end
106. return nil
107. end
108. -- --寻找路径(起始路径)
109. local function findPath( maze,startPoint,endPoint,roleFlag)
110. maze.openList:append(startPoint)
111. while maze.openList:getSize() ~= 0 do
112. --找出F的最小值
113. local tempStart = getMinPoint(maze.openList)
114. maze.openList:removeById(1)
115. maze.closeList:append(tempStart)
116. --找出它相邻的点
117. local surroundPoints = getSurroundPoints(maze,tempStart,roleFlag)
118. for i,point in pairs(surroundPoints.tbl) do
119. if existsPoint(maze.openList,point) then
120. --计算G值,如果比原来大,就什么都不做,否则设置他的父节点为当前节点,并更新G和F
121. foundPoint(tempStart,point)
122. else
123. --如果他们不再开始列表里面,就加入,并设置父节点,并计算GHF
124. notFoundPoint(maze,tempStart,point)
125. end
126. end
127. --如果最后一个存在则返回
128. if getPoint(maze.openList,endPoint) then
129. return getPoint(maze.openList,endPoint)
130. end
131. end
132. return getPoint(maze.openList,endPoint)
133. end
134. --根据一个table创建一个地形
135. function create( tb )
136. local maze = {}
137. maze.step = 1 --格子与格子的基本距离,用于计算H值
138. maze.mazeArray = tb
139. maze.openList = TabledArray.create() --开启列表
140. maze.closeList = TabledArray.create() --关闭列表
141. maze.findPath = findPath
142. return maze
143. end
144. return Maze

调用方法

[plain] view plaincopyprint?

1. function printPath( presentPoint )
2. local pathArray = TabledArray.create()
3. while presentPoint do
4. pathArray:preppend(presentPoint.posId)
5. presentPoint = presentPoint.parentPoint
6. end
7. local startPoint = pathArray:get(2)
8. local endPoint = pathArray:getLast()
9. cclog(startPoint)
10. cclog(endPoint)
11. cclog("从"..startPoint.."到"..endPoint.."的路径是:")
12. for i,p in pairs(pathArray.tbl) do
13. cclog(p)
14. end
15. end

[plain] view plaincopyprint?

1. local array = battleBoard:createBoxPoints(cRole:getFlag(),40)
2. local maze = Maze.create(array)
3. local startPoint = Point.create(cRole:getPositionId())
4. local endPoint = Point.create(40)
5. local presentPoint = maze:findPath(startPoint,endPoint,cRole:getFlag())
6. printPath(presentPoint)

七、运行效果

手机测试效果还可以，貌似在255*255规模的方格规模上采用A*还是不会有太大的效率影响。如果需要交流欢迎联系。