Un petit Labyrinthe

function love.update(dt)
    local mc = maze[playerCell]
    if love.keyboard.isDown('left') and x==xT and yT==y
        and ((not onVbridge and mc.linked.left) or onHbridge) then
        xT=xT-dx
        playerCell = playerCell - 1
        onHbridge = (mc.linked.left ~= mc.left) and (not onHbridge)
    elseif love.keyboard.isDown('right') and x==xT and yT==y 
        and ((not onVbridge and mc.linked.right) or onHbridge) then
        xT=xT+dx
        playerCell = playerCell + 1
        onHbridge = (mc.linked.right ~= mc.right) and (not onHbridge)
    elseif love.keyboard.isDown('up') and y==yT and xT==x 
        and ((not onHbridge and mc.linked.up) or onVbridge) then
        yT=yT-dy
        playerCell = playerCell - nx
        onVbridge = (mc.linked.up ~= mc.up) and (not onVbridge)
    elseif love.keyboard.isDown('down') and y==yT and xT==x 
        and ((not onHbridge and mc.linked.down) or onVbridge) then
        yT=yT+dy
        playerCell = playerCell + nx
        onVbridge = (mc.linked.down ~= mc.down) and (not onVbridge)
    end

    if math.abs(x-xT)<1 and math.abs(y-yT)<1 then
        x=xT
        y=yT
    else
        x=x+(xT-x)*30*dt
        y=y+(yT-y)*30*dt
    end
    if onVbridge or onHbridge then
        plate:set(idh, hero, 0, 0, 0, 0, 0)
        plate:set(idhb, hero, x, y)
    else
        plate:set(idhb, hero, 0, 0, 0, 0, 0)
        plate:set(idh, hero, x, y)
    end
    if playerCell == nx * nz then finished = true end
end

function love.load()
    require('Maze')
    love.window.setTitle('Amazing maze')
    love.mouse.setVisible(false)
    local sprites = love.graphics.newImage('sprites/digital.png')
    local spSize = sprites:getDimensions() / 5

    local sp = {}
    for x = 0, 4 do
        for y = 0, 2 do
            sp[(x+1)+y*5] = love.graphics.newQuad(x*spSize, y*spSize, 
                spSize, spSize, sprites:getDimensions())
        end
    end
    hero = love.graphics.newQuad(2*spSize, 3*spSize, spSize, spSize,
        sprites:getDimensions())
    local bridgeH = love.graphics.newQuad(0, 3*spSize, spSize, spSize,
        sprites:getDimensions())
    local bridgeV = love.graphics.newQuad(spSize, 3*spSize, spSize, spSize,
        sprites:getDimensions())

    local width = 10
    local height = 10
    function initMaze(w, h)
        nx = w or 10
        nz = h or 10
        love.window.setMode(nx*spSize, nz*spSize)
        maze = Maze:new(nx,nz)
        finished = false
        tLastVisit = {}
        for i = 1, nx*nz do
            tLastVisit[i]=0
        end
        x=0
        y=0
        xT=0
        yT=0
        dx=spSize
        dy=spSize
        playerCell = 1
        plate = love.graphics.newSpriteBatch(sprites)
        plate:setBufferSize(2*nx*nz)
        for cell = 1, nx * nz do
            local cellScore = 0
            local mc = maze[cell]

            if mc.linked.left then
                cellScore = 1 end
            if mc.linked.down then
                cellScore = cellScore + 2 end
            if mc.linked.right then
                cellScore = cellScore + 4 end
            if mc.linked.up then
                cellScore = cellScore + 8 end

            local x = (cell - 1) % nx
            local y = (cell - x - 1) / nx
            plate:add(sp[cellScore], x*spSize, y*spSize)
        end

        idh = plate:add(hero, 0, 0)

        for cell = 1, nx * nz do
            local mc = maze[cell]
            local x = (cell - 1) % nx
            local y = (cell - x - 1) / nx
            if mc.up and mc.down and mc.up.linked.down == mc.down then
                plate:add(bridgeV, x*spSize, y*spSize)
            elseif mc.left and mc.right and mc.left.linked.right == mc.right then
                plate:add(bridgeH, x*spSize, y*spSize)
            end
        end

        idhb = plate:add(hero, 0, 0)

        onVbridge = false
        onHbridge = false
    end

    function love.resize(w, h)
        love.window.setMode(nx*spSize, nz*spSize, {resizable=false})
    end

    function love.keyreleased(key)
        if key=='h' and width>10 then
            width = width-5
            initMaze(width, height)
        elseif key=='l' and width<50 then
            width = width+5
            initMaze(width, height)
        elseif key=='k' and height>10 then
            height = height-5
            initMaze(width, height)
        elseif key=='j' and height<50 then
            height = height+5
            initMaze(width, height)
        end
        if key=='right' and finished then initMaze(width, height) end
    end

    function mask(x, y, trsp)
        love.graphics.setColor(0, 0, 0, trsp)
        love.graphics.rectangle('fill', x*spSize, y*spSize, spSize, spSize)
        love.graphics.setColor(255, 255, 255, 255)
    end

    initMaze(width, height)
end

function love.draw()
    love.graphics.draw(plate) 
    time = love.timer.getTime()
    tLastVisit[playerCell] = time
    for i = 1, nx*nz do
        local x = (i - 1) % nx
        local y = (i - x - 1) / nx
        etrsp = (time-tLastVisit[i])*255/10
        mask(x, y, (etrsp < 255 and etrsp or 255 ))
    end
end

Maze = {}
function Maze:new(nx, nz)
    local maze = {}
    maze.nx = nx or 10
    maze.nz = nz or 10
    setmetatable(maze, self)
    self.__index = self
    maze:compute()
    return maze
end

function Maze:compute()
    --[[
    Maze generation with a backtracking
    depth-first search algorithm, but
    using a FIFO stack instead of a
    LIFO one. Bridge over existing
    corridors are allowed.
    --]]

    local freeCells = self.nx*self.nz
    math.randomseed(os.time())
    local otherDir = {up='down', down='up', right='left', left='right'}

    for i = 1, freeCells do
        self[i] = {}
        self[i].free = true
        self[i].linked = {}
    end

    for i = 1, freeCells do
        self[i].up    = self[i-self.nx]
        self[i].down  = self[i+self.nx]
        if (i-1)%self.nx ~= 0 then
            self[i].left  = self[i-1]
        end
        if i%self.nx ~= 0 then
            self[i].right = self[i+1]
        end
    end
    self[freeCells].up.down = nil
    self[freeCells].up = nil

    local stackCells = {first=0,last=-1} -- definition of the FIFO stack
    function stackCells.push(val)
        stackCells.last = stackCells.last+1
        stackCells[stackCells.last] = val
    end
    function stackCells.pop()
        val = stackCells[stackCells.first]
        stackCells[stackCells.first] = nil
        stackCells.first = stackCells.first+1
        return val
    end

    local neighbor = {} -- contains reachable neighbors
    function neighbor.append(cell)
        neighbor[#neighbor+1] = cell
    end
    function neighbor.pick()
        return neighbor[math.random(#neighbor)]
    end
    function neighbor.clear()
        for ind = 1, #neighbor do
            neighbor[ind] = nil
        end
    end
    function neighbor.isFilled()
        return #neighbor ~= 0
    end

    -- here begins the serious stuff
    local currentCell = self[1]
    currentCell.free = false
    freeCells = freeCells-1
    while freeCells~=0 do
        -- make a list of accessible neighbors
        neighbor.clear()
        for direc, other in pairs(otherDir) do
            -- close neighbors
            local cell = currentCell[direc]
            if cell and cell.free then
                neighbor.append{direc, cell}
            end
            -- neighbors which are reachable with a bridge
            local cell2 = cell and cell[direc]
            if cell2 and not cell.free and cell2.free and
                not cell.linked[direc] and
                not cell.linked[other] then
                neighbor.append{direc, cell2}
            end
        end

        if neighbor.isFilled() then
            -- choose a neighbor
            local nb = neighbor.pick()
            local dir = nb[1]
            local nbCell = nb[2]
            -- make the link
            currentCell.linked[dir] = nbCell
            nbCell.linked[otherDir[dir]] = currentCell
            -- chosen neighbor become current cell
            stackCells.push(currentCell)
            currentCell = nb[2]
            currentCell.free = false
            freeCells = freeCells-1
        else
            -- if no reachable neighbor,
            -- go open a new way
            -- from a previous cell
            currentCell = stackCells.pop()
        end
    end
end