lua的A星

A星原理到处都有，网络上的luaA星，不是写的看不懂，就是全局变量乱用（讨厌全局变量），项目中用到，简单记录下

-- 简单说明一下
-- 注意：1是可以走,其他是不能走
-- 采用4格走法（上下左右），
-- 采用的移动公式是 "manhattan":曼哈顿估价法，几何估价法，对角线估价法
-- 可以改8格走法，1. math_list 哪里改下，2.根据斜走和直的权值，再去改下移动公式（几何估价法，对角线估价法）

local M = {}
local world  = {}--地图格子列表
local open   = {}--开放列表
local closed = {}--闭合列表
local path   = {}--路径列表
local closedIndex = 0--闭合列表的下标
local targetX = 0--目标节点的坐标
local targetY = 0--目标节点的坐标
local maxCheckTime  = 100  --最大检索步数
-- local isTargetFound = false -- 是否找到目标

-- 初始化
function M:init(worldMap)
	--  
	world = worldMap
	-- worldInit = clone(worldMap)
end

-- 寻路定义
function M:pathfindInit(route, targetX, targetY)
	-- world  = clone(worldInit)
	-- -- 走过的路，设置成不能走
	-- for i = 1, #route - 1 do
	-- 	local item = route[i]	
	-- 	world[item.indexY][item.indexX] = 0
	-- end

	open   = {}--开放列表
	closed = {}--闭合列表
	path   = {}--路径列表
	closedIndex = 0--闭合列表的下标

	-- --定义起点信息
	self:defineStart(route[#route].indexY, route[#route].indexX)
	-- -- 目标点信息
	return self:placeTarget(targetY, targetX)
end

--定义起点信息
function M:defineStart(x,y )
	--定义起点信息
	open[1] = {}
	open[1].x = x
	open[1].y = y
	open[1].parent = 0
	open[1].g = 0--从初始节点到当前节点的移动距离
	open[1].h = 0--从这个节点到目标节点的预测距离
end

-- 目标点信息
function M:placeTarget(x, y)
	--  记录目标信息
	targetX = x
	targetY = y

	local isTargetFound = false

	-- if (myX < maxX-1) and (myX > 1) and (myY < maxY-1) and (myY > 1) then

	if world[x][y] == 1 then
		local time = 0
		repeat
			isTargetFound = self:findPath()
			time = time + 1
		until (isTargetFound or time >= maxCheckTime)

		--获得路线图
		if isTargetFound then
			self:buildPath()
			return path
		else
			return false
		end
	else
		-- print("目标是个障碍")
		return false
	end
end

-- 寻找最低F
function M:findLowestF( nodeTable )
	--从开放列表里寻找F（参考值）最小的节点
	local count = #(nodeTable)
	local minF = 1000000
	local minFIndex = 0
	if count > 0 then
		for index = 1,count do
			local curF = nodeTable[index].g + nodeTable[index].h
			if curF <= minF then
				minF = curF
				minFIndex = index
			end
		end
	end
	return minFIndex
end

-- 过程节点
function M:processNode( newX,newY )
	--对节点进行检查
	local targetFound = false
	local exists = self:alreadyExists(newX,newY)--检测节点是否存在于开放列表

	if exists == -1 then
		--不在开放列表中
		if (newX == targetX) and (newY == targetY) then
			--找到目标点
			targetFound = true
		else
			--填入开放列表
			self:newOpenEntry(newX,newY)
		end
	else
		--在开放列表中，那么重新定义父节点
		--G的计算是将父节点的G值与当前节点到父节点的距离相加，这里只做简单计算
		local existingG = open[exists].g
		local curValue = 10
		local parentG = closed[closedIndex].g

		local newG = parentG + curValue
		if newG < existingG then
			open[exists].parent = closedIndex
		end
	end

	return targetFound
end


-- 找到路径
function M:findPath( )
	--针对当前位置进行检索周边处理
	local isTargetFound = false

	local openIndex = self:findLowestF(open)
	if not open[openIndex] then
		return isTargetFound
	end
	closedIndex = #(closed) + 1

	closed[closedIndex] = {}
	closed[closedIndex].x = open[openIndex].x
	closed[closedIndex].y = open[openIndex].y
	closed[closedIndex].parent = open[openIndex].parent
	closed[closedIndex].g = open[openIndex].g
	closed[closedIndex].h = open[openIndex].h

	local curX = closed[closedIndex].x
	local curY = closed[closedIndex].y

	local math_list = {
		--遍历周边4个格子，试图寻找目标节点
		[1] = {-1,0},
		[2] = {0,-1},
		[3] = {0,1},
		[4] = {1,0},
	}

	for k,v in pairs(math_list) do
		if not isTargetFound then
			local myX = curX + v[1]
			local myY = curY + v[2]
			if (myX > 0) and (myY > 0) and world[myX] and world[myX][myY] and world[myX][myY]==1 then
				isTargetFound = self:processNode(myX,myY)
			end
		else
			break
		end
	end
	table.remove(open,openIndex)
	-- print("数量", #open)
	-- dump(open)
	return isTargetFound
end

--检测节点是否存在于开放列表
function M:alreadyExists( newX,newY )
	for k,v in pairs(open) do
		if v.x == newX and v.y == newY then
			return k
		end
	end
	return -1
end

--添加节点到开放列表
function M:newOpenEntry(newX, newY )
	local myIndex = #(open) + 1
	open[myIndex] = {}
	open[myIndex].x = newX
	open[myIndex].y = newY
	open[myIndex].parent = closedIndex
	open[myIndex].g = self:findG(open,myIndex)
	open[myIndex].h = self:findH(open[myIndex].x,open[myIndex].y,targetX,targetY)
end

--G的计算是将父节点的G值与当前节点到父节点的距离相加，这里只做简单计算
function M:findG(nodeTable, node )
	--从初始节点到当前节点的移动距离
	local parentG  = closed[nodeTable[node].parent].g
	local curValue = 10
	return parentG + curValue
end

--计算H值(两坐标之间的 曼哈顿距离 )
function M:findH( curX,curY,tarX,tarY )
	return 10*(math.abs(curX-tarX) + math.abs(curY-tarY))	
end


--节点检索结束后，构建路径列表
function M:buildPath( )
	local count = 1
	path[count] = {}
	path[count].x = targetX
	path[count].y = targetY
	count = count + 1
	path[count] = {}
	local pathIndex = #(closed)
	path[count].x = closed[pathIndex].x
	path[count].y = closed[pathIndex].y
	local newPathIndex = closed[pathIndex].parent
	while newPathIndex > 1 do	
		count = count + 1
		path[count] = {}
		path[count].x = closed[newPathIndex].x
		path[count].y = closed[newPathIndex].y
		local oldPathIndex = newPathIndex
		newPathIndex = closed[oldPathIndex].parent
		-- print(newPathIndex)
	end

	path = self:reverseTable(path)--得到倒序表需要反序

	return path
end

function M:reverseTable( data )
	--表反序
	local temp = {}
	local endCount = #(data)
	for index = 1,#(data) do
		temp[index] = data[endCount]
		endCount = endCount - 1
	end
	return temp
end

return M