scripts/lua/CC Tweaked/tutel/tutel-host.lua

--[[
    tutel host

                    __
         .,-;-;-,. /'_\
       _/_/_/_|_\_\) /
     '-<_><_><_><_>=/\
       `/_/====/_/-'\_\
        ""     ""    ""
]]

--[[
    network variables
]]
local HOST_CHANNEL = 1337
local TURTLE_CHANNEL_BASE = 1338

local MSG_HEADER = 0x747574656C

local modem = peripheral.find("modem") or error("No modems found", 0)
modem.open(HOST_CHANNEL)

--[[
    logging
]]
local logTypes = {
    ["general"] = {
        ["BG"] = colours.green,
        ["FG"] = colours.white
    },

    ["info"] = {
        ["BG"] = colours.blue,
        ["FG"] = colours.white
    },

    ["warning"] = {
        ["BG"] = colours.orange,
        ["FG"] = colours.black,
        ["AffectContent"] = true
    },

    ["error"] = {
        ["BG"] = colours.red,
        ["FG"] = colours.black,
        ["AffectContent"] = true
    }
}
local log = {}
log.buffer = {}

for typeName, format in pairs(logTypes) do
    log[typeName] = function(fmt, ...)
        local entry = {
            message = string.format(fmt, ...),
            type = typeName
        }

        table.insert(log.buffer, entry)
    end
end

--[[
    turtle tracking
]]
local turtles = {}

function registerTurtle(pos, fuel, id)
    local channel = TURTLE_CHANNEL_BASE + #turtles

    local turt = {
        ["channel"] = channel,
        ["index"] = #turtles,
        ["position"] = pos,
        ["fuel"] = fuel,
        ["status"] = "IDLE",
        ["id"] = id
    }

    table.insert(turtles, turt)

    return turt
end

--[[
    helper networking functions
]]
function sendToAll(name, msgData)
    local message = {
        ["header"] = MSG_HEADER,
        ["name"] = name,
        ["data"] = msgData or {}
    }

    modem.transmit(0, 0, message)
end

--[[
    command handling
]]
local commands = {}
function declareCommandHandler(name, handler, requiredKeys)
    commands[name] = {
        ["keys"] = requiredKeys or {},
        ["handler"] = handler
    }
end

-- scan
function handleScan(keys, id)
    local turt = registerTurtle({ keys.positionX, keys.positionY, keys.positionZ }, keys.fuel, id)

    log.info("Received turtle info (pos: %d, %d, %d - fuel: %d - channel: %d - id: %d)", turt.position[1],
        turt.position[2], turt.position[3], turt.fuel, turt.channel, id)

    sendToAll("REGISTER", { ["id"] = id, ["turtleChannel"] = turt.channel })
end

declareCommandHandler("SCAN", handleScan,
    {
        ["positionX"] = "number",
        ["positionY"] = "number",
        ["positionZ"] = "number",
        ["fuel"] = "number"
    })

--[[
    event handling
]]
local eventListeners = {}
function registerEventListener(name, listener)
    if not eventListeners[name] then eventListeners[name] = {} end
    table.insert(eventListeners[name], listener)
end

function dispatchEvents(event, ...)
    local eventTbl = eventListeners[event]
    if not eventTbl then return end

    for i = 1, #eventTbl, 1 do
        eventTbl[i](...)
    end
end

function handleMessages(side, channel, replyChannel, message, dist)
    if channel ~= HOST_CHANNEL then return end

    -- msg validation
    if type(message) ~= "table" then return end
    if not message.header or message.header ~= MSG_HEADER then return end
    if not message.data then message.data = {} end

    -- cmd validation
    if not message.name then
        log.warning("received nameless command?")
        return
    end

    if not commands[message.name] then
        log.error("unhandled command (%s)", message.name)
        return
    end

    local cmd = commands[message.name]
    for i, v in pairs(cmd.keys) do
        if type(message.data[i]) ~= v and v ~= "optional" then
            log.error("command %s requires key %s of type %s (was %s)", message.name, i, v, type(message[i]))
            return
        end
    end

    -- cmd execution
    local success, err = pcall(cmd.handler, message.data, message.id)
    if not success then
        log.error("error occurred while executing command %s: %s", message.name, err)
    end

    log.info("processed command (%s)", message.name)
end
registerEventListener("modem_message", handleMessages)

local logOffset = 0

-- to-do: add key handlers

--[[
    key handling
]]
local keyListeners = {}
function registerKeyListener(id, listener)
    if not keyListeners[id] then keyListeners[id] = {} end
    table.insert(keyListeners[id], listener)

end

function dispatchKey(key, isHeld)
    local keyTbl = eventListeners[key]
    if not keyTbl then return end

    for i = 1, #keyTbl, 1 do
        keyTbl[i](isHeld)
    end
end
registerEventListener("key", dispatchKey)

function scrollLogsUp(isHeld)
    logOffset = logOffset - 1
    if logOffset < 0 then logOffset = 0 end
end
registerKeyListener(265, scrollLogsUp)

function scrollLogsDown(isHeld)
    logOffset = logOffset + 1
    if logOffset >= #log.buffer then  logOffset = #log.buffer - 1 end
end
registerKeyListener(264, scrollLogsUp)


--[[
    main
]]
log.general("tutel host init")

-- transmit scan
-- log.info("broadcasting SCAN")

--[[
    screen drawing
]]
function updateScreen()
    local w, h = term.getSize()

    local function drawTextCentered(text)
        local x = (w / 2) - (text:len() / 2)
        local _, curY = term.getCursorPos()
        term.setCursorPos(x, curY)
        term.write(text)
    end

    -- reset state and clear screen
    term.setBackgroundColor(colors.black)
    term.clear()
    
    -- -- title bar
    term.setCursorPos(1, 1)

    term.setBackgroundColor(colors.lightGray)
    term.setTextColour(colors.black)
    
    term.clearLine()
    drawTextCentered("tutel host controller")
    
    term.setBackgroundColor(colors.black)
    term.setTextColour(colors.white)

    -- logs
    local function drawLogs(startY, endY)
        local drawnLines = 0
        for i = #log.buffer - logOffset, 1, -1 do
            if drawnLines > endY - startY then break end

            local entry = log.buffer[i]
            local format = logTypes[entry.type]

            term.setCursorPos(0, endY - drawnLines)

            local prevColourBg = term.getBackgroundColour()
            local prevColourFg = term.getTextColour()

            term.setBackgroundColour(format["BG"])
            term.setTextColour(format["FG"])
            term.write(("[%s]"):format(entry.type))

            if format["AffectContent"] then
                term.write((" %s\n"):format(entry.message))
                term.setBackgroundColour(prevColourBg)
                term.setTextColour(prevColourFg)
            else
                term.setBackgroundColour(prevColourBg)
                term.setTextColour(prevColourFg)
                term.write((" %s\n"):format(entry.message))
            end

            drawnLines = drawnLines + 1
        end
    end

    drawLogs(2, h - 1)
end

--[[
    event polling
]]
function pollEvents()
    local eventData = { os.pullEvent() }

    local eventName = eventData[1]
    table.remove(eventData, 1)

    dispatchEvents(eventName, table.unpack(eventData))
end

--[[
    main loop
]]
for i=0, 15, 1 do
    log.info("some log %d", i)
    log.warning("some warning %d", i)
end

sendToAll("SCAN", { ["hostChannel"] = HOST_CHANNEL })
while true do
    updateScreen()
    pollEvents()
end