243 lines
6.5 KiB
Lua
243 lines
6.5 KiB
Lua
local channel = 31415
|
|
|
|
local m = peripheral.find("modem", function(_, o) return o.isWireless() end)
|
|
if not m then error "Modem required!" end
|
|
|
|
local tele = peripheral.find "Teleporter"
|
|
if not tele then error "Teleporter (see Mekanism wiki) required!" end
|
|
|
|
local sign = peripheral.find "minecraft:sign"
|
|
|
|
local rift_ID = os.getComputerLabel():match "Rift:([A-Za-z0-9_-]+)"
|
|
|
|
if not rift_ID then error "Please relabel this computer `Rift:[unique rift identifier]`." end
|
|
|
|
m.open(channel)
|
|
|
|
local function display_status(...)
|
|
if sign then sign.setSignText(rift_ID, ...) end
|
|
end
|
|
|
|
local function split_at_spaces(s)
|
|
local t = {}
|
|
for i in string.gmatch(s, "%S+") do
|
|
table.insert(t, i)
|
|
end
|
|
return t
|
|
end
|
|
|
|
local function first_letter(s)
|
|
return string.sub(s, 1, 1)
|
|
end
|
|
|
|
local function update_self()
|
|
print "Downloading update."
|
|
local h = http.get "https://pastebin.com/raw/jta5puZL"
|
|
local t = h.readAll()
|
|
h.close()
|
|
|
|
local fn, err = load(t, "@rift")
|
|
if not fn then printError("Not updating: syntax error:\n" .. err) end
|
|
|
|
local f = fs.open("startup", "w")
|
|
f.write(t)
|
|
f.close()
|
|
os.reboot()
|
|
end
|
|
|
|
local teleporter_errors = {
|
|
[2] = "Frame invalid.",
|
|
[3] = "Pairing error.",
|
|
[4] = "Insufficient energy."
|
|
}
|
|
|
|
local function send_message(...)
|
|
m.transmit(channel, channel, { ... })
|
|
end
|
|
|
|
local function disconnect(remote)
|
|
display_status "Idle"
|
|
if not remote then send_message("command", "handle_disconnect", rift_ID) end
|
|
tele.setFrequency(("rift-%s-null"):format(rift_ID), true)
|
|
end
|
|
|
|
local connected_to = nil
|
|
|
|
local remote_commands = {
|
|
ping = function()
|
|
return { rift_ID }
|
|
end,
|
|
update = function()
|
|
update_self()
|
|
end,
|
|
dial = function(from, to)
|
|
if to ~= rift_ID then return end
|
|
if type(from) ~= "string" then error("Invalid or no originator specified!") end
|
|
local freq = ("rift-%s-%s"):format(from, to)
|
|
tele.setFrequency(freq, true)
|
|
local status = tele.canTeleport()
|
|
if status == 1 then
|
|
print(("Connection established from %s."):format(from))
|
|
display_status("Dialed from:", from)
|
|
connected_to = from
|
|
return { true }
|
|
else
|
|
local e = teleporter_errors[status] or "Unknown error."
|
|
display_status("Error:", e)
|
|
printError(("Error receiving connection from %s: %s"):format(from, e))
|
|
return { false, e }
|
|
end
|
|
end,
|
|
handle_disconnect = function(other_end)
|
|
if other_end == connected_to then disconnect(true) end
|
|
end
|
|
}
|
|
|
|
local function timeout(fn, time)
|
|
local timer = os.startTimer(time)
|
|
local co = coroutine.create(fn)
|
|
local filter
|
|
while true do
|
|
local ev = { os.pullEvent() }
|
|
if coroutine.status(co) == "dead" or ev[1] == "timer" and ev[2] == timer then return end
|
|
if not filter or filter == ev[1] then
|
|
local ok, res = coroutine.resume(co, unpack(ev))
|
|
if not ok then error(res)
|
|
else filter = res end
|
|
end
|
|
end
|
|
end
|
|
|
|
local usage =
|
|
[[Welcome to Rift. All listed commands are accessible by single-letter shortcuts.
|
|
dial [destination] - Open a connection to rift [destination].
|
|
scan - Scan for available rifts.
|
|
scan [filter] - Scan for available rifts whose names contain [filter].
|
|
help - Print this.
|
|
update - Update this.
|
|
disconnect - Disconnect from current paired rift.
|
|
id - Get the ID of the current rift.]]
|
|
|
|
local CLI_commands = {
|
|
help = function() textutils.pagedPrint(usage) end,
|
|
dial = function(dest)
|
|
if not dest then error "No destination rift specified." end
|
|
local freq = ("rift-%s-%s"):format(rift_ID, dest)
|
|
print(("Setting frequency to %s."):format(freq))
|
|
tele.setFrequency(freq, true)
|
|
print(("Sending dial request to %s."):format(dest))
|
|
send_message("command", "dial", rift_ID, dest)
|
|
|
|
local result
|
|
timeout(function()
|
|
while true do
|
|
local _, response_to, success, error_type = os.pullEvent "remote_result"
|
|
if response_to == "dial" then
|
|
if not success then
|
|
print(dest, "reports error:", error_type)
|
|
result = "remote_error"
|
|
else
|
|
print(dest, "reports success.")
|
|
local status = tele.canTeleport()
|
|
if status == 1 then
|
|
result = "success"
|
|
print "Link established."
|
|
display_status("Dialed to:", dest)
|
|
connected_to = dest
|
|
else
|
|
result = "local_error"
|
|
local e = teleporter_errors[status] or "Unknown error."
|
|
display_status("Error:", e)
|
|
print(e)
|
|
end
|
|
end
|
|
break
|
|
end
|
|
end
|
|
end, 1)
|
|
|
|
if result == nil then error(dest .. " is unreachable or nonexistent.", 0) end
|
|
end,
|
|
update = function(what)
|
|
if what == "all" then
|
|
send_message("command", "update")
|
|
print "Update command broadcast"
|
|
end
|
|
update_self()
|
|
end,
|
|
scan = function(filter)
|
|
send_message("command", "ping")
|
|
print "Scanning..."
|
|
timeout(function()
|
|
while true do
|
|
local _, resp_to, from = os.pullEvent "remote_result"
|
|
if resp_to == "ping" and from and (not filter or from:match(filter)) then
|
|
print("Found:", from)
|
|
end
|
|
end
|
|
end, 1)
|
|
end,
|
|
disconnect = disconnect,
|
|
id = function()
|
|
print("Rift ID:", rift_ID)
|
|
end
|
|
}
|
|
|
|
local function command_prompt()
|
|
print "Welcome to Rift!"
|
|
local history = {}
|
|
while true do
|
|
write "|> "
|
|
local text = read(nil, history)
|
|
|
|
if text ~= "" then table.insert(history, text) end
|
|
|
|
local tokens = split_at_spaces(text)
|
|
local command = table.remove(tokens, 1)
|
|
local args = tokens
|
|
local fn = CLI_commands[command]
|
|
|
|
if not fn then
|
|
for command_name, func in pairs(CLI_commands) do
|
|
if command and first_letter(command_name) == first_letter(command) then fn = func end
|
|
end
|
|
end
|
|
if not fn then
|
|
print("Command", command, "not found.")
|
|
else
|
|
local ok, err = pcall(fn, table.unpack(args))
|
|
if not ok then printError(err) end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function message_handler()
|
|
while true do
|
|
local _, _, _, _, message = os.pullEvent "modem_message"
|
|
if type(message) == "table" then
|
|
local mtype = table.remove(message, 1)
|
|
if mtype == "command" then
|
|
local cmd = table.remove(message, 1)
|
|
local cmd_fn = remote_commands[cmd]
|
|
if cmd_fn then
|
|
local ok, res = pcall(cmd_fn, unpack(message))
|
|
if ok then
|
|
if type(res) == "table" then
|
|
send_message("result", cmd, unpack(res))
|
|
end
|
|
else
|
|
printError(res)
|
|
send_message("error", res)
|
|
end
|
|
end
|
|
elseif mtype == "result" then os.queueEvent("remote_result", unpack(message))
|
|
elseif mtype == "error" then os.queueEvent("remote_error", unpack(message)) end
|
|
end
|
|
end
|
|
end
|
|
|
|
if ... == "update" then update_self() end
|
|
|
|
disconnect()
|
|
|
|
parallel.waitForAny(message_handler, command_prompt) |