A*寻路算法

实现原理

算法名称：A*算法

应用场景：游戏里的自动寻路

原理：

1，从起点开始找它周围可以走的格子，算出可走格子中F值最小的格子，再就以这个格子作为新的中心点，又同样找其周围可以走的格子，以此类推，直至找到目的点。

2，确定最优格子是取F值最小为依据，那么F值怎么算？F = G + H，G：表示从起点移动到指定格子的耗费(一般横竖着的格子耗费为10(or 1)，斜着的格子耗费为14(or 1.4)，等于其父节点G + 自己的G的和)。H：表示从指定格子移动到终点的预计耗费(一般就是指定点到终点相差的X,Y绝对值的和)。

3，每次找的周围格子都会放入到“开放列表”中，如果下次周围点某几个“开放列表”中已经存在，是否修改这些存在的点属性，是看新计算的G值，如果G值 > 原来的G值，则什么也不做，否则，就以新的G值替换，同时改变其父节点。

4，每个格子都以其中心点作为父节点，这样链接起来，就像一个链表结构，这样直到找到目的点后，就可以通过目的点的父节点这样一级级还原出路径了。

5，每个格子的属性：x坐标，y坐标，G值，H值，F值(F=G + H)，父格子。(这种结构类似链表)

寻路步骤

1，从起点A开始, 把它作为待处理的方格存入一个”开启列表”, 开启列表就是一个等待检查方格的列表.

2，寻找起点A周围可以到达的方格, 将它们放入”开启列表”, 并设置它们的”父方格”为A.

3，从”开启列表”中删除起点 A, 并将起点 A 加入”关闭列表”, “关闭列表”中存放的都是不需要再次检查的方格.

4， 从 “开启列表” 中选择 F 值最低的方格C.

5，把它从 “开启列表” 中删除, 并放到 “关闭列表” 中.

6，检查它所有相邻并且可以到达 (障碍物和 “关闭列表” 的方格都不考虑) 的方格. 如果这些方格还不在 “开启列表” 里的话, 将它们加入 “开启列表”, 计算这些方格的 G, H 和 F 值各是多少, 并设置它们的 “父方格”为C .

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

8，然后继续找F值最小的，如此循环下去…

下面是一张寻路的示例图：绿块是起点，蓝块是障碍，红块是终点，天蓝框是中心点，绿框是检测过的点，框左上角F值，框左下角是G值，框右下角是H值，红线是寻路过程。



最终通过父节点还原路径，如下图：(红点表示最终路径)

示例代码(Lua)

这个是项目中的源码，寻路核心就是用的上面讲的A*算法。

1，格子点结构定义(Node)

local Point                         = class("Point")

function Point:ctor(pos)
self.parentPoint                = nil
self.F                          = 0
self.G                          = 0
self.H                          = 0
self.x                          = pos.x
self.y                          = pos.y
end

--计算F值
function Point:CalcF( point )
self.F                          = self.G + self.H
end

return Point

2，A*寻路类

local FindPath                      = class("FindPath")

function FindPath:ctor()
--路径列表
self.pathArry                   = {}
end

--获取列表中F值最小的点
function FindPath:getMinPoint(pointList)
local minPoint                  = pointList[1]
for i = 1, table.getn(pointList) do
if minPoint.F > pointList[i].F then
minPoint                = pointList[i]
end
end
return minPoint
end

--从开启列表移除点
function FindPath:removePoint(point, pointList)
if table.getn(pointList) <= 0 then
return
end

for i=table.getn(pointList), 1, -1 do
if pointList[i].x == point.x and pointList[i].y == point.y then
table.remove(pointList, i)
end
end
end

--列表中是否包含点
function FindPath:existPoint(pointList, point)
for i, p in pairs(pointList) do
if (p.x == point.x) and (p.y == point.y) then
return i
end
end
return false
end

--获取相邻的点
function FindPath:getSurroundPoints(point)
local surroundPoints            = {}
for i=point.x - 1, point.x + 1 do

for j=point.y - 1, point.y + 1 do
if i == point.x and j == point.y then
--点自己
elseif not self:existPoint(self.closeList, cc.p(i, j)) then
if mapLayer:isObstacleByTile(cc.p(i, j)) then
--障碍
else
local tPos  = require("app.control.Point").new(cc.p(i, j))
local dPos  = self.endPos
if i == point.x or j == point.y then
tPos.G  = 1
else
tPos.G  = 1.4
end
tPos.H  = math.abs(dPos.x-tPos.x) + math.abs(dPos.y-tPos.y)
tPos.parentPoint    = point
table.insert(surroundPoints, tPos)
end
end
end

end

return surroundPoints   --返回point点的集合
end

--计算G值
function FindPath:CalcG(point)
local G                         = point.G
local parentG                   = 0
if point.parentPoint then
parentG                     = point.parentPoint.G
end
return G + parentG
end

function FindPath:foundPoint(tempStart, point, idx)
local lastP                     = self.openList[idx]
local G                         = self:CalcG(point)
if G < lastP.G then
point.parentPoint           = tempStart
point.G                     = G
point:CalcF()
self.openList[idx]          = point
end
end

function FindPath:notFoundPoint(tempStart, point)
point.parentPoint               = tempStart
point.G                         = self:CalcG(point)
point:CalcF()
table.insert(self.openList, point)
end

--获得角色真实位置（移动一格完成后的位置）
function FindPath:getRoleRealPos()
local curPos                    = nil
if self.roleTgtPos then
curPos                      = self.roleTgtPos
else
--角色位置
local x, y                  = myRole:getPosition()
curPos                      = cc.p(x, y)
end

return mapLayer:tileCoordForPos(curPos)
end

--开始寻找路径
function FindPath:startFindPath(endPos)
local startPos                  = self:getRoleRealPos()
if endPos.x == startPos.x and endPos.y == startPos.y then
printInfo("click same point")
return false
end
--print("startPos:", startPos.x, startPos.y)
--print("endPos:", endPos.x, endPos.y)

--初始化值
self.openList                   = {}
self.closeList                  = {}
self.pathArry                   = {}
local findPos                   = nil
local isFind                    = true
startPos                        = require("app.control.Point").new(startPos)
self.endPos                     = require("app.control.Point").new(endPos)

table.insert(self.openList, startPos)
--寻路逻辑
while table.getn(self.openList) > 0 do
--找出F的最小值
local tempStart             = self:getMinPoint(self.openList)
self:removePoint(tempStart, self.openList)
table.insert(self.closeList, tempStart)

--找出它相邻的点
local surroundPoints        = self:getSurroundPoints(tempStart)
for i,point in pairs(surroundPoints) do
local idx               = self:existPoint(self.openList, point)
if idx then
--计算G值,如果比原来大,就什么都不做,否则设置他的父节点为当前节点,并更新G和F
self:foundPoint(tempStart, point, idx)
else
--如果他们不再开始列表里面,就加入,并设置父节点,并计算GHF
self:notFoundPoint(tempStart, point)
end
end

--如果最后一个存在则返回
local idx                   = self:existPoint(self.openList, self.endPos)
if idx then
findPos                 = self.openList[idx]
break
end
end

--添加路径
--printInfo("find path")
while findPos do
--转换为地图坐标
--printInfo("%d, %d", findPos.x, findPos.y)
local tempPos               = mapLayer:posForTileGood(findPos)
--printInfo("%d, %d", tempPos.x, tempPos.y)
table.insert(self.pathArry, tempPos)
findPos                     = findPos.parentPoint
end

if table.getn(self.pathArry) < 2 then
isFind                      = false
end

--重置
self.openList                   = {}
self.closeList                  = {}
self.endPos                     = nil
findPos                         = nil
return isFind
end

--获取移动的偏移
function FindPath:getMoveOffset()
local num                       = table.getn(self.pathArry)
if num < 2 then
self:removePath()
return false
end

local curPos                    = self.pathArry[num]
local targetPos                 = self.pathArry[num - 1]
table.remove(self.pathArry, num)

local sPos                      = cc.pSub(curPos, targetPos)
local angle                     = math.atan2(sPos.y, sPos.x) * 180 / math.pi + 180

local direct                    = camera:getDirectionByAngle(angle)
myRole:changeAction(actionList.run, direct)

return cc.pMul(sPos, -1)
end

--移除路径
function FindPath:removePath()
self.pathArry                   = {}
end

--设置角色目标位置
function FindPath:setRolePos(pos)
self.roleTgtPos                 = pos
end

--获取当前路径
function FindPath:getCurPath()
return self.pathArry
end

return FindPath

项目运行示例图：