Add more

minit.lua

@@ -0,0 +1,189 @@
+-- Minit Beta 1.0.0
+-- Copyright (C) 2023 AlexDevs
+-- This software is licensed under the MIT license.
+
+settings.define("minit.cycleSleep", {
+    description = "Sleep time between cycles",
+    type = "number",
+    default = 0.1,
+})
+
+settings.define("minit.cycleTimeout", {
+    description = "Cycles timeout",
+    type = "number",
+    default = 1,
+})
+
+settings.define("minit.modulesPath", {
+    description = "Path to modules",
+    type = "string",
+    default = "modules",
+})
+
+local modulesPath = settings.get("minit.modulesPath")
+local neuralInterface
+
+local expect = require("cc.expect").expect
+
+local logPrefix = "%s %s:"
+local function getTime()
+    return os.date("%H:%M:%S")
+end
+local function log(label, ...)
+    local time = getTime()
+    print(string.format(logPrefix, time, label), ...)
+end
+
+local function logError(label, ...)
+    local time = getTime()
+    printError(string.format(logPrefix, time, label), ...)
+end
+
+local modules = {}
+local function loadModules()
+    log("Minit", "Loading modules from /" .. modulesPath)
+    local files = fs.list(modulesPath)
+    for i = 1, #files do
+        local ok, par = pcall(require, fs.combine(modulesPath, files[i])
+            :gsub("/", ".")
+            :gsub("%.lua$", ""))
+        if ok then
+            par.name = par.name or files[i]:gsub("%.lua$", "")
+            table.insert(modules, par)
+            log("Minit", "Loaded module " .. par.name)
+        else
+            logError("Minit", "Could not load module " .. files[i] .. ": " .. par)
+        end
+    end
+end
+
+local function getCallbacks(name, ...)
+    local args = table.pack(...)
+    local callbacks = {}
+    for i = 1, #modules do
+        local module = modules[i]
+        if type(module[name]) == "function" then
+            table.insert(callbacks, function()
+                module[name](table.unpack(args))
+            end)
+        end
+    end
+    return table.unpack(callbacks)
+end
+
+local tasks = {}
+local function addTask(task)
+    expect(1, task, "function")
+    table.insert(tasks, coroutine.create(task))
+end
+
+local function initModules()
+    for i = 1, #modules do
+        local module = modules[i]
+        if type(module.init) == "function" then
+            module.init({
+                addTask = addTask,
+                log = function(...)
+                    log(module.name, ...)
+                end,
+                logError = function(...)
+                    logError(module.name, ...)
+                end,
+            })
+        end
+    end
+end
+
+local function setupNeuralInterface()
+    neuralInterface = peripheral.wrap("back")
+
+    if not neuralInterface then
+        error("No neural interface found")
+    end
+
+    -- Wait for owner to be alive
+    local function getOwner()
+        local meta
+        parallel.waitForAny(function()
+            meta = neuralInterface.getMetaOwner()
+        end, function()
+            sleep(1)
+        end)
+
+        return meta
+    end
+
+    local meta = getOwner()
+    if not meta or not meta.isAlive then
+        log("Minit", "Waiting for respawn...")
+    end
+    while not meta or not meta.isAlive do
+        sleep(0.2)
+        meta = getOwner()
+    end
+
+    parallel.waitForAll(getCallbacks("setup", neuralInterface))
+end
+
+local function cycleUpdate()
+    local metaOwner = neuralInterface.getMetaOwner()
+
+    parallel.waitForAll(getCallbacks("update", metaOwner))
+
+    sleep(settings.get("minit.cycleSleep"))
+end
+
+local function tasksHandler()
+    local ev = { n = 0 }
+    local filters = {}
+
+    while true do
+        for i, thread in pairs(tasks) do
+            if coroutine.status(thread) == "dead" then
+                tasks[i] = nil
+                filters[i] = nil
+            else
+                if filters[i] == nil or filters[i] == ev[1] or ev[1] == "terminate" then
+                    local ok, param = coroutine.resume(thread, table.unpack(ev, 1, ev.n))
+                    if not ok then
+                        logError("Task", param)
+                    else
+                        filters[i] = param
+                    end
+                end
+            end
+        end
+        ev = table.pack(coroutine.yield())
+    end
+end
+
+local function main()
+    setupNeuralInterface()
+    while true do
+        parallel.waitForAny(
+            cycleUpdate,
+            function()
+                sleep(settings.get("minit.cycleTimeout"))
+            end
+        )
+    end
+end
+
+loadModules()
+initModules()
+
+parallel.waitForAny(
+    function()
+        while true do
+            local ok, err = pcall(main)
+            if not ok then
+                if err == "Terminated" then
+                    break
+                end
+                logError("Minit", err)
+                sleep(1)
+            end
+        end
+    end,
+    tasksHandler
+)