您的代码根本是错误的。在第一次检查中递归调用pathFinder时，它只会朝那个方向前进，直到出现任何障碍，然后才朝下一个方向前进，依此类推。

BFS实际上是一个非常简单的算法。可以轻松地在队列上迭代地实现它，而无需进行以下任何递归：

1. 将初始节点放入队列；
2. 从队列中弹出第一个节点并对其进行处理；
3. 将未处理的相邻节点推送到队列的末尾；
4. 如果队列不为空，请转到步骤2。

在Lua的矩形矩阵上，可以用大约两三行来实现：

function gradient(matrix,originX,originY)
    -- Create queue and put origin position and initial value to it.
    local queue = { { originX,originY,1 } }

    repeat
        -- Pop first position and value from the queue.
        local x,y,value = unpack(table.remove(queue,1))

        -- Mark this position in the matrix.
        matrix[y][x] = value

        -- Check position to the top.
        if y > 1 and matrix[y - 1][x] == 0 then
            -- If it is not already processed,push it to the queue.
            table.insert(queue,{ x,y - 1,value + 1 })
        end

        -- Check position on the left.
        if x > 1 and matrix[y][x - 1] == 0 then
            table.insert(queue,{ x - 1,value + 1 })
        end

        -- Check position to the bottom.
        if y < #matrix and matrix[y + 1][x] == 0 then
            table.insert(queue,y + 1,value + 1 })
        end

        -- Check position on the right.
        if x < #matrix[y] and matrix[y][x + 1] == 0 then
            table.insert(queue,{ x + 1,value + 1 })
        end

    -- Repeat,until queue is not empty.
    until #queue == 0
end

-- Just helper function to print a matrix.
function printMatrix(matrix)
    for _,row in pairs(matrix) do
        for _,value in pairs(row) do
            io.write(string.format("%2s",value))
        end
        io.write('\n')
    end
end

local mapMatrix = {
    {   0,},{   0,'N',{ 'N',}

gradient(mapMatrix,5,3)
printMatrix(mapMatrix)

--[[
Produces:
 7 6 5 4 3 4 5
 6 5 N 3 2 3 4
 5 4 3 2 1 2 3
 6 5 4 3 2 3 4
 7 N 5 4 N 4 N
 N N 6 5 N 5 6
 9 8 7 6 7 6 7
]]

这是一个完整的脚本，可以在控制台中运行。

但是，尽管出于说明目的，此代码非常简单，但效率不是很高。每次从队列中删除第一个项目都会导致其余项目的重新索引。对于生产代码，您应该为队列实现一个链表或类似的东西。