tntta

local running    = true
local gravity    = true

local level_dir  = "/levels" --relative to game file
local level      = nil       --set on load.
local currentLvl = nil       --set on load.

local lvlXOffset = 1
local lvlYOffset = 2

local w, h       = term.getSize()

local player     = {
    ["draw"]  = "\2";
    ["color"] = colors.orange;
    ["x"]     = 0;
    ["y"]     = 0;
}

local function split(str, splitter)
    local t = {}
    local function helper(line) table.insert(t, line) return "" end
    helper((str:gsub("(.-)" .. splitter, helper)))
    return t
end

local function center(txt, hOffset, isError)
    if not hOffset then hOffset = 0 end

    term.setCursorPos((w - #txt) / 2, (h - hOffset) / 2)
    if isError then printError(txt) else print(txt) end
end

local function clear(bgC, fgC)
    term.setBackgroundColor(bgC or colors.black)
    term.setTextColor(fgC or colors.white)
    term.setCursorPos(1, 1)
    term.clear()
end

local function level_getFile(fname)
    if fs.getDir(shell.getRunningProgram()) == "usr/bin" then --We're running on packman
        return fs.combine("/etc/tntta/levels", fname) .. ".lvl"
    end

    return shell.resolve(fs.combine(level_dir, fname)) .. ".lvl"
end

local draw_once = function() end --to not get nil errors
local function level_load(levele)
    level = level_getFile(levele)

    if fs.exists(level) then
        level = dofile(level)

        player["x"] = level["spawn"][1]
        player["y"] = level["spawn"][2]

        currentLvl  = levele

        draw_once()
        return
    end

    error("Level " .. level_getFile(levele) .. " doesn't exist!", 999)
end

local function player_move(xDif, yDif)
    if not (player["x"] + xDif <= 0) and not (player["x"] + xDif >= w) and
    not (player["y"] + yDif <= 0) and not (player["y"] + yDif >= h) and
    level["level"][player["y"] + yDif]                     ~= nil and
    level["level"][player["y"] + yDif][player["x"] + xDif] ~= nil then
        if not level["walls"][level["level"][player["y"] + yDif][player["x"] + xDif]]  then
            player["x"] = player["x"] + xDif
            player["y"] = player["y"] + yDif

            if player["x"] == level["finish"][1] and player["y"] == level["finish"][2] then
                if level["nextlevel"] ~= "" then
                    level_load(level["nextlevel"])
                    return
                end

                clear()
                center("The maps end here! Thanks for playing!")
                center("(any key to exit)", -2)
                os.pullEvent("key")
                running = false
            else
                for i = 1, #level["toggles"] do
                    if player["x"] == level["toggles"][i][1] and player["y"] == level["toggles"][i][2] then
                        level["toggles"][i][4] = not level["toggles"][i][4]

                        --just to make sure the toggles don't toggle unexpectedly
                        if     xDif >=  1 then player["x"] = player["x"] + 1
                        elseif xDif <= -1 then player["x"] = player["x"] - 1
                        elseif yDif >=  1 then player["y"] = player["y"] + 1
                        elseif yDif <= -1 then player["y"] = player["y"] - 1
                        end
                        break
                    end
                end
            end
        else
            for i = 1, #level["toggles"] do
                if level["toggles"][i][3] == level["level"][player["y"] + yDif][player["x"] + xDif] and
                   level["toggles"][i][4] then
                    player["x"] = player["x"] + xDif
                    player["y"] = player["y"] + yDif

                    return
                end
            end

            level_load(currentLvl)
        end
    end
end

local function player_gravity()
    while running do
        sleep(.15)
        if gravity then
            player_move(0, 1)
        else
            gravity = true
        end
    end
end

draw_once = function()
    clear(colors.gray, colors.white)

    paintutils.drawLine(1, 1, w, 1, colors.blue)
    term.setTextColor(colors.white)
    term.setCursorPos(1, 1)
    write("Level: " .. level["name"])
    term.setCursorPos(w - #"Q to Quit" + 1, 1)
    write("Q to Quit")
end

local function draw()
    if #level["level"] > h then error("Level too big for screen!", 999) end
    for y = 1, #level["level"] do

        if #level["level"][y] > w then error("Level too big for screen!", 999) end
        for x = 1, #level["level"][y] do
            term.setBackgroundColor(level["level"][y][x])
            term.setCursorPos(lvlXOffset + x, lvlYOffset + y)

            for i = 1, #level["toggles"] do
                if level["toggles"][i][1] == x and level["toggles"][i][2] == y then
                    term.setBackgroundColor(level["toggles"][i][4] and level["toggles"][i][3] or colors.white)
                    term.setTextColor(not level["toggles"][i][4] and level["toggles"][i][3] or colors.white)
                    write("T")
                    break
                end
            end

            if x == player["x"] and y == player["y"] then
                if player["color"] == level["level"][y][x] then
                    term.setTextColor(colors.white)
                else
                    term.setTextColor(player["color"])
                end
                write(player["draw"])
                term.setTextColor(colors.white)
            elseif x == level["finish"][1] and y == level["finish"][2] then
                term.setBackgroundColor(colors.black ~= level["level"][y][x] and colors.black or colors.white)
                term.setTextColor(colors.black ~= level["level"][y][x] and colors.white or colors.black)
                write("\153")
            else
                write(" ")
            end
        end
    end
end

local function event()
    local e = {os.pullEvent()}

    if e[1] == "key" then
        if     e[2] == keys.q     then running = false sleep(.001)
        elseif e[2] == keys.up    then player_move(0, -1) gravity = (e[3] and not gravity)
        elseif e[2] == keys.right then player_move( 1, 0)
        elseif e[2] == keys.left  then player_move(-1, 0)
        end
    end
end

local function main(args)
    level_load(args[1] or "level1")

    parallel.waitForAny(function()
        while running do
            draw()
            event()
        end
    end, player_gravity)

    clear()
end

local err = {pcall(main, {...})}
if not err[1] then
    local errThing = split(err[2], ":")
    local programp = split(shell.getRunningProgram(), "/")

    clear(colors.blue, colors.white)
    if errThing ~= 3 and errThing[1] == programp[#programp] then
        center("Game Error at line " .. errThing[2])
        center(errThing[3], -2, true)
    else
        center("Error!")
        center(err[2], -2, true)
    end

    paintutils.drawLine(1, h, w, h, colors.black)
    term.setCursorPos(1, h)
end