LÖVE

Code: Select all

function pathfind:calculate(goal)
    
    -- 1) Add the starting square (or node) to the open list.
    for i=1,#nodes do
        for j=1,#nodes[i] do
            if nodes[i][j].x <= player.x and player.x < nodes[i][j].x + 16 and
                nodes[i][j].y <= player.y and player.y < nodes[i][j].y + 16 then
                
                nodes[i][j].cost = 0 -- because we start on this one
                table.insert(pathfind.open, nodes[i][j])
                i = #nodes + 1
                break
            end
        end
    end
    
    --2) Repeat the following:
    while #pathfind.open > 0 do
        
        -- a) Look for the lowest F cost square on the open list. We refer to this as the current square.
        local currentNodeId = 1
        for i=1,#pathfind.open do
            if pathfind.open[i].cost < pathfind.open[currentNodeId].cost then
                currentNodeId = i
            end
        end
        
        -- b) Switch it to the closed list.
        local currentNode = table.remove(pathfind.open, currentNodeId)
        table.insert(pathfind.closed, currentNode)
        
        -- c) For each of the 8 squares adjacent to this current square …
        
        ...
    end

end

Code: Select all

for i=1, #nodes do
		for j=1, #nodes[i] do
			if boxCollision(player.x, player.y, player.w, player.h, nodes[i][j].x, nodes[i][j].y, 16, 16) then
				nodes[i][j].gcost = 0 -- because we start on this one
				nodes[i][j].hcost = pathfind:h_cost(nodes[i][j], goal)
				nodes[i][j].fcost = nodes[i][j].gcost + nodes[i][j].hcost
				table.insert(pathfind.open, nodes[i][j])
				i = #nodes + 1 <-------------- this thing, what is it doing?
				break
			end
		end
	end

Code: Select all

pathfind= {}
pathfind.open = {}
pathfind.closed = {}
local nodes = {}

function pathfind:generateNodes()
	for i = 1, #nodes do
		table.remove(nodes)
	end
	for i = 1, #map do
		nodes[i] = {}
		for j = 1, #map[i] do
			if not map[i][j].collide then
				nodes[i][j] = {
					x = map[i][j].x + 16,
					y = map[i][j].y + 16
				}
			end
		end
	end
end

function pathfind:drawNodes()
	gr.setColor(0, 0, 255, 255)
	for i = 1, #nodes do
		for j = 1, #nodes[i] do
			if nodes[i][j] then
				gr.point(nodes[i][j].x, nodes[i][j].y)
			end
		end
	end
end

function pathfind:drawPath()
end

function pathfind:calculate(goal)
    
	-- 1) Add the starting square (or node) to the open list.
	for i=1, #nodes do
		for j=1, #nodes[i] do
			if boxCollision(player.x, player.y, player.w, player.h, nodes[i][j].x, nodes[i][j].y, 16, 16) then
				
				nodes[i][j].gcost = 0 -- because we start on this one
				nodes[i][j].hcost = pathfind:h_cost(nodes[i][j], goal)
				nodes[i][j].fcost = nodes[i][j].gcost + nodes[i][j].hcost
				table.insert(pathfind.open, nodes[i][j])
				i = #nodes + 1
				break
			end
		end
	end
	
    --2) Repeat the following:
	while #pathfind.open > 0 do
        
		-- a) Look for the lowest F cost square on the open list. We refer to this as the current square.
		local currentNodeId = 1
		
		for i = 1, #pathfind.open do
          if pathfind.open[i].fcost < pathfind.open[currentNodeId].fcost then
				currentNodeId = i
          end
		end
        
       -- b) Switch it to the closed list.
       local currentNode = table.remove(pathfind.open, currentNodeId)
       table.insert(pathfind.closed, currentNode)
        
        -- c) For each of the 8 squares adjacent to this current square …
	end
end

function pathfind:h_cost(current, goal)
	return distV(current, goal)
end

function pathfind:g_cost(current, parent)
	return current.gcost + parent.gcost
end

function pathfind:keypressed(key, uni)

end

function pathfind:debuger()
	print("Closed List:")
	for k, v in ipairs(pathfind.closed) do
		for i, j in pairs(v) do
			print(i, j)
		end
	end
	print("Open List:")
	for k, v in ipairs(pathfind.open) do
		for i, j in pairs(v) do
			print(i, j)
		end
	end
end