rectangles have height, did you know that?

anim-web.lua

@@ -1,41 +0,0 @@
-local ccpi = require("ccpi")
-local args = { ... }
-
-local terminal = term.current()
-if args[1] == "-m" then
-    table.remove(args, 1)
-    print("Using monitor: " .. args[1])
-    terminal = peripheral.wrap(table.remove(args, 1))
-end
-
-local frames = {}
-local n_frames = tonumber(args[1])
-local base_path = args[2]
-
-for i = 1, n_frames do
-  local url = string.format(base_path, i)
-  print("GET " .. url)
-  local req, err = http.get(url, nil, true)
-  if not req then
-    printError(err)
-    return
-  end
-  local img, err = ccpi.parse(req)
-  if not img then
-    printError(err)
-    return
-  else
-    print(img.w .. "x" .. img.h)
-  end
-  table.insert(frames, img)
-  req.close()
-end
-
-local frame_no = 0
-while true do
-  local frame = frames[(frame_no % #frames) + 1]
-  ccpi.draw(frame, 1, 1, terminal)
-  os.sleep(0.0)
-  frame_no = frame_no + 1
-end
-

augment/files.json

@@ -1,12 +1,8 @@
 {
-    "repository": "https://git.salushnes.solutions/hkc/cc-stuff/raw/branch/master/augment",
+    "repository": "https://git.salushnes.solutions/hkc/cc-stuff/raw/branch/augment/dev/augment",
     "files": [
         {
-            "path": "wsvpn.lua",
+            "path": "startup",
-            "src": "wsvpn.lua"
-        },
-        {
-            "path": "startup.lua",
             "src": "startup.lua"
         },
         {

augment/main.lua

@@ -8,8 +8,35 @@ _G.canvas3d_src.clear()
 _G.canvas3d = canvas3d_src.create()
 
 _G.player = nil
-_G.nearbyEntities = {}
+_G.surroundings = {
-_G.nearbyEntitiesByUUID = {}
+    entities = {},
+    entitiesByUUID = {}
+}
+
+table.contains = function(tbl, value)
+    for k, v in pairs(tbl) do
+        if v == value then return true, k end
+    end
+    return false, nil
+end
+
+table.keys = function(tbl)
+    local gen = pairs(tbl)
+    local k = nil
+    return function()
+        k = gen(tbl, k)
+        return k
+    end
+end
+
+table.values = function(tbl)
+    local gen = pairs(tbl)
+    local k, v
+    return function()
+        k, v = gen(tbl, k)
+        return v
+    end
+end
 
 local function run_wrapped(func, filename)
     return function()
@@ -41,16 +68,16 @@ end
 
 print("Loaded " .. #modules .. " modules")
 
-local function safeset(func, name, old)
+local function safeget(func, name, fallback, ...)
     if func then
-        local s, res = pcall(func)
+        local s, res = pcall(func, ...)
         if not s then
-            printError("ERR: " .. name .. " failed: " .. res)
+            printError(name .. " failed: " .. res)
         else
             return res
         end
     end
-    return old
+    return fallback
 end
 
 print("Running...")
@@ -68,15 +95,28 @@ end,
 function() -- Neural Interface coroutine
     print("NI routine started")
     while _G._running do
-        _G.player = safeset(NI.getMetaOwner, "getMetaOwner()", _G.player)
+        _G.player = safeget(NI.getMetaOwner, "getMetaOwner()", _G.player)
-        _G.nearbyEntities = safeset(NI.sense, "sense()", _G.nearbyEntities or {})
+
-        _G.nearbyEntitiesByUUID = {}
+        surroundings.entities = safeget(NI.sense, "sense()", surroundings.entities)
-        for i = 1, #_G.nearbyEntities do
+
-            _G.nearbyEntitiesByUUID[_G.nearbyEntities[i].id] = _G.nearbyEntities[i]
+        local knownUUIDs = {}
+        for entity in table.values(surroundings.entities) do
+            local s, res = pcall(NI.getMetaByID, entity.id)
+            surroundings.entitiesByUUID[entity.id] = s and res or entity
+            table.insert(knownUUIDs, entity.id)
         end
+
+        for uuid in table.keys(surroundings.entitiesByUUID) do
+            if not table.contains(knownUUIDs, uuid) then
+                surroundings.entitiesByUUID[uuid] = nil
+            end
+        end
+
         _G.canvas3d.recenter()
+
         os.sleep(0.05)
     end
+
     _G.canvas3d_src.clear()
     _G.canvas2d.clear()
 end, table.unpack(modules))

augment/modules/event.lua

@@ -1,7 +1,7 @@
 return function()
     while _G._running do
         local ev = { os.pullEvent() }
-        if ev[1] == "key" and ev[2] == keys.f4 then
+        if ev[1] == "key" and ev[2] == keys.q then
             os.queueEvent("exit")
             break
         elseif ev[1] == "timer" or ev[1] == "plethora_task" then

augment/modules/wh.lua

@@ -1,34 +1,72 @@
+
+local options = {
+    reverse_projection = false,
+    hpbar = {
+        bg = 0x13131355,
+        fg = 0xef787878,
+        txt = 0xffffffff
+    }
+}
+
+local function entityBox(ent)
+    local cube = canvas3d.addBox(ent.x - 0.25, ent.y - 0.25, ent.z - 0.25)
+    local hpbar = canvas3d.addFrame({ ent.x - 0.25, ent.y + 0.25, ent.z - 0.25 })
+
+    cube.setAlpha(0x20)
+    cube.setDepthTested(false)
+    hpbar.setDepthTested(false)
+
+    local hp_rect_bg = hpbar.addRectangle(0, 0, 100, 15, options.hpbar.bg)
+    local hp_rect_fg = hpbar.addRectangle(0, 0, 0, 15, options.hpbar.fg)
+    local hp_txt = hpbar.addText({ 0, 2 }, ent.name, options.hpbar.txt)
+
+    return {
+        _cube = cube,
+        _hpbar = hpbar,
+        _hp_rect_bg = hp_rect_bg,
+        _hp_rect_fg = hp_rect_fg,
+        _hp_txt = hp_txt,
+        update = function(self, entity)
+            self._cube.setPosition(entity.x - 0.25, entity.y - 0.25, entity.z - 0.25)
+            self._hpbar.setPosition(entity.x, entity.y + 0.5, entity.z)
+            if entity.health ~= nil and entity.maxHealth ~= nil then
+                self._hp_txt.setText(string.format("%s (%.1f/%.1f)", entity.name, entity.health, entity.maxHealth))
+                self._hp_rect_fg.setSize(100 * entity.health / entity.maxHealth, 15)
+            else
+                self._hp_txt.setText(string.format("%s", entity.name))
+                self._hp_rect_fg.setSize(0, 0)
+            end
+        end,
+        destroy = function(self)
+            self._cube.remove()
+            self._hpbar.remove()
+        end
+    }
+end
+
 return function()
     local cache = {}
     while _G._running do
-        for id, entry in pairs(cache) do
+        for uuid in table.keys(cache) do
-            if nearbyEntitiesByUUID[id] == nil then
+            if surroundings.entitiesByUUID[uuid] == nil then
-                entry.cube.remove()
+                cache[uuid]:destroy()
-                entry.frame.remove()
+                cache[uuid] = nil
-                cache[id] = nil
             end
         end
 
-        for id, entity in pairs(nearbyEntitiesByUUID) do
+        for uuid, entity in pairs(surroundings.entitiesByUUID) do
-            if id ~= player.id then
+            if uuid == player.id then
-                if cache[id] == nil then
+                -- nothing
-                    cache[id] = {}
+            elseif cache[uuid] == nil then
-                    cache[id].cube = canvas3d.addBox(0, 0, 0)
+                cache[uuid] = entityBox(entity)
-                    cache[id].cube.setSize(0.5, 0.5, 0.5)
+            else
-                    cache[id].frame = canvas3d.addFrame({ 0, 0, 0 })
+                cache[uuid]:update(entity)
-                    cache[id].text = cache[id].frame.addText({ 0, 0 }, "")
-                end
-                cache[id].cube.setAlpha(0x20)
-                cache[id].cube.setDepthTested(false)
-                cache[id].frame.setDepthTested(false)
-
-                cache[id].cube.setPosition(entity.x - 0.25, entity.y - 0.25, entity.z - 0.25)
-                cache[id].frame.setPosition(entity.x, entity.y, entity.z)
-                cache[id].text.setAlpha(0xFF)
-                cache[id].text.setText(entity.name .. "\n" .. textutils.serialize(entity))
-                cache[id].text.setColor(0xFF0000FF)
             end
         end
         os.sleep(0.05)
     end
+
+    for uuid in table.keys(cache) do
+        cache[uuid]:destroy()
+    end
 end

augment/startup.lua

@@ -1,4 +1,4 @@
-local repository = "https://git.salushnes.solutions/hkc/cc-stuff/raw/branch/master/augment/files.json"
+local repository = "https://git.salushnes.solutions/hkc/cc-stuff/raw/branch/augment/dev/augment/files.json"
 local files = textutils.unserializeJSON(http.get(repository).readAll())
 
 local function getFile(url, path)

augment/wsvpn.lua

@@ -1,154 +0,0 @@
-local expect = require("cc.expect")
-
-local WSModem = {
-  open = function(self, channel)
-    expect.expect(1, channel, "number")
-    expect.range(channel, 0, 65535)
-    self._request(0x4f, {
-        bit.band(0xFF, bit.brshift(channel, 8)),
-        bit.band(0xFF, channel)
-      })
-  end,
-  isOpen = function(self, channel)
-    expect.expect(1, channel, "number")
-    expect.range(channel, 0, 65535)
-    return self._request(0x6f, {
-        bit.band(0xFF, bit.brshift(channel, 8)),
-        bit.band(0xFF, channel)
-      })[1] ~= 0
-  end,
-  close = function(self, channel)
-    expect.expect(1, channel, "number")
-    expect.range(channel, 0, 65535)
-    self._request(0x63, {
-        bit.band(0xFF, bit.brshift(channel, 8)),
-        bit.band(0xFF, channel)
-      })
-  end,
-  closeAll = function(self)
-    self._request(0x43)
-  end,
-  transmit = function(self, channel, replyChannel, data)
-    expect.expect(1, channel, "number")
-    expect.expect(2, replyChannel, "number")
-    expect.expect(3, data, "nil", "string", "number", "table")
-    expect.range(channel, 0, 65535)
-    expect.range(replyChannel, 0, 65535)
-
-    local serialized = textutils.serializeJSON(data)
-    expect.range(#serialized, 0, 65535)
-    serialized = { serialized:byte(1, 65536) }
-    self._request(0x54, {
-        bit.band(0xFF, bit.brshift(channel, 8)),
-        bit.band(0xFF, channel),
-        bit.band(0xFF, bit.brshift(replyChannel, 8)),
-        bit.band(0xFF, replyChannel),
-        bit.band(0xFF, bit.brshift(#serialized, 8)),
-        bit.band(0xFF, #serialized),
-        table.unpack(serialized, 1, #serialized)
-      })
-  end,
-  isWireless = function(self) return true end,
-  run = function(self)
-    while true do
-      local data, binary = self._socket.receive()
-      if not data then return true end
-      if binary == false then return false, "Not a binary message" end
-      data = { string.byte(data, 1, #data) }
-      local opcode = table.remove(data, 1)
-      if opcode == 0x49 then -- info
-        local len, msg = self._read_u16ne(data)
-        msg = string.char(table.unpack(msg))
-        os.queueEvent("wsvpn:info", msg)
-      elseif opcode == 0x41 then -- Set address/side
-        local len = table.remove(data, 1)
-        self.side = string.char(table.unpack(data, 1, len))
-      elseif opcode == 0x45 then -- Error
-        local request_id, error_length
-        request_id, data = self._read_u16ne(data)
-        error_length, data = self._read_u16ne(data)
-        local message = string.char(table.unpack(data, 1, error_length))
-        os.queueEvent("wsvpn:response", false, request_id, message)
-      elseif opcode == 0x52 then -- Response
-        local request_id, response = self._read_u16ne(data)
-        os.queueEvent("wsvpn:response", true, request_id, response)
-      elseif opcode == 0x54 then -- Transmission
-        local channel, replyChannel, dataSize, packet
-        channel, data = self._read_u16ne(data)
-        replyChannel, data = self._read_u16ne(data)
-        dataSize, packet = self._read_u16ne(data)
-        os.queueEvent("modem_message", self.side or "wsmodem_0", channel, replyChannel, textutils.unserializeJSON(string.char(table.unpack(data, 1, dataSize))), nil)
-      else
-        return false, string.format("Invalid opcode 0x%02x", opcode)
-      end
-      os.sleep(0)
-    end
-  end,
-
-  -- low-level part
-
-  _read_u16ne = function(self, data)
-    local v = bit.blshift(table.remove(data, 1), 8)
-    v = bit.bor(v, table.remove(data, 1))
-    return v, data
-  end,
-
-  _wait_response = function(self, request_id)
-    while true do
-      local ev, status, id, data = os.pullEvent("wsvpn:response")
-      if ev == "wsvpn:response" and id == request_id then
-        return status, data
-      end
-    end
-  end,
-
-  _request = function(self, opcode, data)
-    local request_id = self._get_id()
-    self._socket.send(
-      string.char(
-        opcode,
-        bit.band(0xFF, bit.brshift(request_id, 8)),
-        bit.band(0xFF, request_id),
-        table.unpack(data or {})
-        ),
-      true
-      )
-    local status, response = self._wait_response(request_id)
-    if not status then
-      error(response)
-    end
-    return response
-  end,
-
-  _get_id = function(self)
-    self._req_id = bit.band(0xFFFF, self._req_id + 1)
-    return self._req_id
-  end,
-
-  _send_text = function(self, code, fmt, ...)
-    local msg = { fmt:format(...):byte(1, 1020) }
-    self._socket.send(
-      string.char(
-        code,
-        bit.band(0xFF, bit.brshift(#msg, 8)),
-        bit.band(0xFF, #msg),
-        table.unpack(msg, 1, #msg)
-      ),
-      true
-    )
-  end,
-
-  _init = function(self)
-    self._send_text(0x49, "Hello! I'm computer %d", os.getComputerID())
-  end,
-}
-
-return function(addr)
-  local ws = assert(http.websocket(addr))
-  local sock = setmetatable({ _socket = ws, _req_id = 0, side = "wsmodem_unknown" }, { __index = WSModem })
-  for name, method in pairs(WSModem) do
-    sock[name] = function(...) return method(sock, ...) end
-  end
-  sock._init()
-  return sock
-end

badapple-tape.py

@@ -1,28 +0,0 @@
-#!/usr/bin/env python3
-# x-run: python3 % badapple.bin ~/videos/badapple/frame*.png
-
-from sys import argv
-from PIL import Image
-
-w, h = 82, 40
-
-bits = [[1,2],[4,8],[16,0]]
-
-with open(argv[1], "wb") as fp:
-    fp.write(bytes([w, h]))
-    for i, f in enumerate(argv[2:]):
-        with Image.open(f) as im:
-            img = im.resize((w * 2, h * 3)).convert("1")
-            for y in range(h):
-                line = bytearray()
-                for x in range(w):
-                    val = 0
-                    for oy, l in enumerate(bits):
-                        for ox, bi in enumerate(l):
-                            if img.getpixel((x * 2 + ox, y * 3 + oy)):
-                                val |= bi
-                    # if img.getpixel((x * 2 + 1, y * 3 + 2)):
-                    #     val ^= 0x9f
-                    line.append(val)
-                fp.write(line)
-        print(f"wrote {i + 1} / {len(argv) - 2}")

bigterm-hello.lua

@@ -1,99 +0,0 @@
-local bigterm = require("bigterm")({
-    { p = peripheral.wrap("monitor_1"), x = 1, y = 1 },
-    { p = peripheral.wrap("monitor_2"), x = 2, y = 1 },
-    { p = peripheral.wrap("monitor_3"), x = 1, y = 2 },
-    { p = peripheral.wrap("monitor_4"), x = 2, y = 2 },
-    { p = peripheral.wrap("monitor_5"), x = 1, y = 3 },
-    { p = peripheral.wrap("monitor_6"), x = 2, y = 3 },
-}, {
-    palette = {
-        [colors.white] =     0xEFEFEF,
-        [colors.orange] =    0xEF712A,
-        [colors.magenta] =   0xCF43EA,
-        [colors.lightBlue] = 0x5643EF,
-        [colors.yellow] =    0xEFCF42,
-        [colors.lime] =      0x43FA99,
-        [colors.pink] =      0xEF7192,
-        [colors.gray] =      0x676767,
-        [colors.lightGray] = 0xAAAAAA,
-        [colors.cyan] =      0x42DFFA,
-        [colors.blue] =      0x7853FF,
-        [colors.brown] =     0xb18624,
-        [colors.green] =     0x00FF00,
-        [colors.red] =       0xFF0000,
-        [colors.black] =     0x000000
-    },
-    scale = 0.5
-})
-
-bigterm._forEachMonitor(function(mon, i)
-    print(mon.x, mon.y, mon.p.getSize())
-end)
-
---bigterm._blitpixel(1, 21, "A")
-
-local w, h = bigterm.getSize()
-print(w, h)
-
---for y = 1, h do
---    for x = 1, w do
---        bigterm._blitpixel(
---            x,
---            y,
---            string.char((x + y * 16 - 16) % 256),
---            string.format("%x", (x - y) % 16),
---            string.format("%x", (x + y) % 16)
---        )
---    end
---end
-
-bigterm.setTextColor(colors.white)
-bigterm.setBackgroundColor(colors.black)
-
-bigterm.clear()
-
-if false then
-    local lines = require("cc.strings").wrap(io.lines("cc-stuff/beemovie.txt")(), w)
-    for i, line in ipairs(lines) do
-        bigterm.setCursorPos(1, i)
-        bigterm.setTextColor(2 ^ (i % 2))
-        bigterm.write(line)
-        if i == h then break end
-    end
-end
-
-for t = 0, 31 do
-    for y = 1, h do
-        local res = {}
-        for x = 0, w do
-            table.insert(res, string.format("%x", bit.bxor(x, y * t + 1) % 16))
-        end
-        res = table.concat(res)
-        bigterm.setCursorPos(1, y)
-        bigterm.blit(res, res, string.rep("f", #res))
-    end
-    os.sleep(0.05)
-end
-
-local ccpi = require("ccpi")
-local img = ccpi.load("cc-stuff/cpi-images/cute.cpi")
-
-local ys = {}
-for y = 1, img.h do table.insert(ys, y) end
-
-for i = 1, #ys do
-    local a, b = math.random(1, #ys), math.random(1, #ys)
-    ys[a], ys[b] = ys[b], ys[a]
-end
-
-for i, y in ipairs(ys) do
-    bigterm.setCursorPos(1, y)
-    bigterm.blit(img.lines[y].s, img.lines[y].fg, img.lines[y].bg)
-    os.sleep(0.05)
-end
-
-for i = 1, 16 do
-    bigterm.setPaletteColor(bit.blshift(1, i - 1), img.palette[i])
-    os.sleep(0.10)
-end
-

bigterm.lua

@@ -1,231 +0,0 @@
-local expect = require("cc.expect").expect
-local function todo() error("todo!") end
-local pretty = require "cc.pretty"
-
-local BigTerm = {
-    write = function(self, text)
-        local w = self.getSize()
-        for i = 1, #text do
-            if self._pos.x <= w then
-                self._blitpixel(
-                    self._pos.x,
-                    self._pos.y,
-                    text:sub(i, i),
-                    self._colorChar(self._colorForeground),
-                    self._colorChar(self._colorBackground)
-                    )
-                self._pos.x = self._pos.x + 1
-            end
-        end
-    end,
-    blit = function(self, text, foreground, background)
-        local x, y = self._pos.x, self._pos.y
-        local w = #text
-        local LIMIT = 0
-        local ox = 1
-        while w > 0 and LIMIT < 20 do
-            local mon, i, lx, ly = self._getMonitorForScreenPos(x, y)
-            if not mon then break end
-            local remaining = mon._w - lx
-            mon.p.setCursorPos(lx + 1, ly + 1)
-            mon.p.blit(
-                text:sub(ox, ox + w),
-                foreground:sub(ox, ox + w - 1),
-                background:sub(ox, ox + w - 1)
-            )
-            w = w - remaining
-            x = x + remaining
-            ox = ox + remaining
-        end
-    end,
-    clear = function(self)
-        self._forEachMonitor(function(mon)
-            mon.p.clear()
-        end)
-    end,
-    clearLine = function(self) todo() end,
-    scroll = function(self, n)
-        -- TODO: NOPE! store framebuffer and write lines onto other screens
-        self._forEachMonitor(function(mon)
-            mon.p.scroll(n)
-        end)
-    end,
-
-    getCursorPos = function(self) return self._pos.x, self._pos.y end,
-    setCursorPos = function(self, x, y)
-        self._pos.x = x
-        self._pos.y = y
-        -- TODO: move cursor to the correct monitor and hide it from others
-    end,
-
-    setCursorBlink = function(self, state) todo() end,
-    getCursorBlink = function(self) todo() end,
-
-    isColor = function(self) return true end,
-    getSize = function(self)
-        local w, h = 0, 0
-        for ix = 1, self._w do
-            local mon = self._findMonitor(ix, 1)
-            w = w + mon._w
-        end
-        for iy = 1, self._h do
-            local mon = self._findMonitor(1, iy)
-            h = h + mon._h
-        end
-        return w, h
-    end,
-
-    setTextColor = function(self, fg)
-        self._forEachMonitor(function(mon)
-            mon.p.setTextColor(fg)
-        end)
-        self._colorForeground = fg
-    end,
-    getTextColor = function(self) todo() end,
-
-    setBackgroundColor = function(self, bg)
-        self._forEachMonitor(function(mon)
-            mon.p.setBackgroundColor(bg)
-        end)
-        self._colorBackground = bg
-    end,
-    getBackgroundColor = function(self) todo() end,
-
-    setTextScale = function(self, scale)
-        self._scale = scale
-        self._reset()
-    end,
-    getTextScale = function(self)
-        return self._scale
-    end,
-
-    setPaletteColor = function(self, index, color, g, b)
-        expect(1, index, "number")
-        expect(2, color, "number")
-        expect(3, g, "number", "nil")
-        expect(4, b, "number", "nil")
-        if index < 0 or index > 32768 or math.log(index, 2) % 1 ~= 0 then
-            error("index out of range")
-        end
-
-        local r = color
-        if g == nil or b == nil then
-            if color < 0 or color > 0xFFFFFF then
-                error("color out of range")
-            end
-            r = bit.band(0xFF, bit.brshift(color, 16)) / 255
-            g = bit.band(0xFF, bit.brshift(color, 8)) / 255
-            b = bit.band(0xFF, bit.brshift(color, 0)) / 255
-        else
-            if r < 0 or r > 1.0 then error("red channel out of range") end
-            if g < 0 or g > 1.0 then error("green channel out of range") end
-            if b < 0 or b > 1.0 then error("blue channel out of range") end
-        end
-
-        self._palette[index] = bit.bor(
-            bit.blshift(math.floor(r * 255), 16),
-            bit.blshift(math.floor(g * 255), 8),
-            bit.blshift(math.floor(b * 255), 0)
-        )
-        self._forEachMonitor(function(mon)
-            mon.p.setPaletteColor(index, r, g, b)
-        end)
-    end,
-    getPaletteColor = function(self, index) todo() end,
-
-    -- internals
-
-    _colorChar = function(self, v)
-        return string.format("%x", math.floor(math.log(v, 2)))
-    end,
-
-    _reset = function(self)
-        self._w = 1
-        self._h = 1
-        self._forEachMonitor(function(mon, i)
-            mon.p.setTextScale(self._scale)
-            local w, h = mon.p.getSize()
-            self._monitors[i]._w = w
-            self._monitors[i]._h = h
-            if mon.x > self._w then self._w = mon.x end
-            if mon.y > self._h then self._h = mon.y end
-            for id, color in pairs(self._palette) do
-                mon.p.setPaletteColor(id, color)
-            end
-        end)
-    end,
-
-    _blitpixel = function(self, x, y, c, bg, fg)
-        bg = bg or "0"
-        fg = fg or "f"
-        local mon = self._getMonitorForScreenPos(x, y)
-        mon.p.setCursorPos(((x - 1) % mon._w) + 1, ((y - 1) % mon._h) + 1)
-        mon.p.blit(c, bg, fg)
-    end,
-
-    _findMonitor = function(self, x, y)
-        for i = 1, #self._monitors do
-            local mon = self._monitors[i]
-            if mon.x == x and mon.y == y then
-                return mon, i
-            end
-        end
-    end,
-
-    _getMonitorForScreenPos = function(self, x, y)
-        local oy = 1
-        for iy = 1, self._h do
-            local ox = 1
-            for ix = 1, self._w do
-                local mon, i = self._findMonitor(ix, iy)
-                if x >= ox and x < (ox + mon._w) and y >= oy and y < (oy + mon._h) then
-                    return mon, i, x - ox, y - oy
-                end
-                ox = ox + mon._w
-            end
-            local mon, i = self._findMonitor(1, iy)
-            oy = oy + mon._h
-        end
-    end,
-
-    _forEachMonitor = function(self, fun)
-        for i = 1, #self._monitors do
-            fun(self._monitors[i], i)
-        end
-    end,
-
-}
-
-local lib = {}
-function lib.fromFile(conf)
-    local fp = assert(io.open(conf, "r"))
-    local conf = textutils.unserializeJSON(fp:read("a"))
-    fp:close()
-    local monitors = {}
-    for addr, pos in pairs(conf.monitors) do
-        local p = assert(peripheral.wrap(addr))
-        table.insert(monitors, { p = p, x = pos.x, y = pos.y })
-    end
-    return lib.new(monitors, { palette = conf.palette, scale = conf.scale })
-end
-function lib.new(monitors, args)
-    args = args or {}
-    local mon = setmetatable({
-            _monitors = monitors,
-            _pos = { x = 1, y = 1 },
-            _blink = false,
-            _colorForeground = colors.white,
-            _colorBackground = colors.black,
-            _scale = args.scale or 1.0,
-            _palette = args.palette or {},
-        }, { __index = BigTerm })
-    for name, method in pairs(BigTerm) do
-        if type(method) == "function" then
-            mon[name] = function(...) return method(mon, ...) end
-        end
-    end
-    mon._reset()
-    return mon
-end
-
-return lib

btccshow.lua

@@ -1,26 +0,0 @@
-local args = { ... }
-local ccpi = require("ccpi")
-local bigterm = require("bigterm").fromFile("/bigterm.json")
-
-local img, err = ccpi.load(args[1])
-if not img then
-    printError(err)
-    return
-end
-
-local ys = {}
-for y = 1, img.h do table.insert(ys, y) end
-
-for i = 1, math.floor((#ys) / 2), 2 do
-    local a, b = i, (#ys - 1) - i + 1
-    ys[a], ys[b] = ys[b], ys[a]
-end
-
-for i, y in ipairs(ys) do
-    bigterm.setCursorPos(1, y)
-    bigterm.blit(img.lines[y].s, img.lines[y].fg, img.lines[y].bg)
-end
-
-for i = 1, 16 do
-    bigterm.setPaletteColor(bit.blshift(1, i - 1), img.palette[i])
-end

btccslideshow.lua

@@ -1,47 +0,0 @@
-local args = { ... }
-local ccpi = require("ccpi")
-local bigterm = require("bigterm")
-
-local conf_path = "/bigterm.json"
-if args[1] == "-c" then
-    table.remove(args, 1)
-    conf_path = table.remove(args, 1)
-end
-local screen = bigterm.fromFile(conf_path)
-
-local time = 10
-if args[1] == "-t" then
-    table.remove(args, 1)
-    time = tonumber(table.remove(args, 1))
-end
-
-local files = fs.list(args[1])
-
-while true do
-    local img, err = ccpi.load(fs.combine(args[1], files[math.random(1, #files)]))
-    if not img then
-        printError(err)
-        return
-    else
-        local ys = {}
-        for y = 1, img.h do table.insert(ys, y) end
-
-        for i = 1, math.floor((#ys) / 2), 2 do
-            local a, b = i, (#ys - 1) - i + 1
-            ys[a], ys[b] = ys[b], ys[a]
-        end
-
-        for i, y in ipairs(ys) do
-            screen.setCursorPos(1, y)
-            screen.blit(img.lines[y].s, img.lines[y].fg, img.lines[y].bg)
-            if (i % 10) == 0 then
-                os.sleep(0)
-            end
-        end
-
-        for i = 1, 16 do
-            screen.setPaletteColor(bit.blshift(1, i - 1), img.palette[i])
-        end
-    end
-    os.sleep(time)
-end

cc-pic.py

@@ -1,412 +0,0 @@
-#!/usr/bin/env python3
-
-from typing import BinaryIO, TextIO
-from PIL import Image, ImageColor
-from argparse import ArgumentParser, RawTextHelpFormatter
-from textwrap import dedent
-from functools import lru_cache
-
-try:
-    PALETTE_ADAPTIVE = Image.Palette.ADAPTIVE
-except Exception:
-    PALETTE_ADAPTIVE = Image.ADAPTIVE
-
-
-class Converter:
-    CC_COLORS = [
-        ("0", "colors.white"),
-        ("1", "colors.orange"),
-        ("2", "colors.magenta"),
-        ("3", "colors.lightBlue"),
-        ("4", "colors.yellow"),
-        ("5", "colors.lime"),
-        ("6", "colors.pink"),
-        ("7", "colors.gray"),
-        ("8", "colors.lightGray"),
-        ("9", "colors.cyan"),
-        ("a", "colors.purple"),
-        ("b", "colors.blue"),
-        ("c", "colors.brown"),
-        ("d", "colors.green"),
-        ("e", "colors.red"),
-        ("f", "colors.black"),
-    ]
-
-    DEFAULT_PALETTE = [
-        240, 240, 240,
-        242, 178, 51,
-        229, 127, 216,
-        153, 178, 242,
-        222, 222, 108,
-        127, 204, 25,
-        242, 178, 204,
-        76, 76, 76,
-        153, 153, 153,
-        76, 153, 178,
-        178, 102, 229,
-        51, 102, 204,
-        127, 102, 76,
-        87, 166, 78,
-        204, 76, 76,
-        17, 17, 17
-    ]
-
-    DEFAULT_GRAYSCALE_PALETTE = [
-        0xf0, 0xf0, 0xf0,
-        0x9d, 0x9d, 0x9d,
-        0xbe, 0xbe, 0xbe,
-        0xbf, 0xbf, 0xbf,
-        0xb8, 0xb8, 0xb8,
-        0x76, 0x76, 0x76,
-        0xd0, 0xd0, 0xd0,
-        0x4c, 0x4c, 0x4c,
-        0x99, 0x99, 0x99,
-        0x87, 0x87, 0x87,
-        0xa9, 0xa9, 0xa9,
-        0x77, 0x77, 0x77,
-        0x65, 0x65, 0x65,
-        0x6e, 0x6e, 0x6e,
-        0x76, 0x76, 0x76,
-        0x11, 0x11, 0x11
-    ]
-
-    PIX_BITS = [[1, 2], [4, 8], [16, 0]]
-
-    MAX_DIFF = 3 * 255
-
-    def __init__(self, image: Image.Image, palette: list[int] | int = PALETTE_ADAPTIVE, dither: bool = True):
-        dither_mode = Image.Dither.FLOYDSTEINBERG if dither else Image.Dither.NONE
-        if isinstance(palette, list):
-            img_pal = Image.new("P", (1, 1))
-            img_pal.putpalette(palette)
-            self._img = image.quantize(len(palette) // 3, palette=img_pal, dither=dither_mode)
-        else:
-            self._img = image.convert("P", palette=palette, colors=16, dither=dither_mode)
-
-        self._imgdata = self._img.load()
-        self._palette: list[int] = self._img.getpalette() or []
-        if len(self._palette) < 16 * 3:
-            self._palette += [0] * ((16 * 3) - len(self._palette))
-
-    @lru_cache
-    def _brightness(self, i: int) -> float:
-        r, g, b = self._palette[i * 3 : (i + 1) * 3]
-        return (r + g + b) / 768
-
-    @lru_cache
-    def _distance(self, a: int, b: int) -> float:
-        r1, g1, b1 = self._palette[a * 3 : (a + 1) * 3]
-        r2, g2, b2 = self._palette[b * 3 : (b + 1) * 3]
-        rd, gd, bd = r1 - r2, g1 - g2, b1 - b2
-        return (rd * rd + gd * gd + bd * bd) / self.MAX_DIFF
-
-    @lru_cache
-    def _get_colors(self, x: int, y: int) -> tuple[int, int]:
-        brightest_i, brightest_l = 0, 0
-        darkest_i, darkest_l = 0, 768
-        for oy, line in enumerate(self.PIX_BITS):
-            for ox in range(len(line)):
-                pix = self._imgdata[x + ox, y + oy]
-                assert pix < 16, f"{pix} is too big at {x+ox}:{y+oy}"
-                brightness = self._brightness(pix)
-                if brightness > brightest_l:
-                    brightest_l, brightest_i = brightness, pix
-                if brightness < darkest_l:
-                    darkest_l, darkest_i = brightness, pix
-        return darkest_i, brightest_i
-
-    @lru_cache()
-    def _is_darker(self, bg: int, fg: int, c: int) -> bool:
-        return self._distance(bg, c) < self._distance(fg, c)
-
-    def _get_block(self, x: int, y: int) -> tuple[int, int, int]:
-        dark_i, bri_i = self._get_colors(x, y)
-        assert dark_i < 16, f"{dark_i} is too big"
-        assert bri_i < 16, f"{bri_i} is too big"
-        out: int = 0
-        for oy, line in enumerate(self.PIX_BITS):
-            for ox, bit in enumerate(line):
-                if not self._is_darker(
-                    dark_i, bri_i, self._imgdata[x + ox, y + oy]
-                ):
-                    out |= bit
-        # bottom right pixel fix?
-        if not self._is_darker(dark_i, bri_i, self._imgdata[x + 1, y + 2]):
-            out ^= 31
-            dark_i, bri_i = bri_i, dark_i
-        return out, dark_i, bri_i
-
-    @staticmethod
-    def _write_varint(fp: BinaryIO, value: int):
-        value &= 0xFFFFFFFF
-        mask: int = 0xFFFFFF80
-        while True:
-            if (value & mask) == 0:
-                fp.write(bytes([value & 0xFF]))
-                return
-            fp.write(bytes([(value & 0x7F) | 0x80]))
-            value >>= 7
-
-    def export_binary(self, io: BinaryIO, version: int = -1):
-        if version == -2:
-            for y in range(0, self._img.height - 2, 3):
-                line: bytearray = bytearray()
-                for x in range(0, self._img.width - 1, 2):
-                    ch, bg, fg = self._get_block(x, y)
-                    line.extend([(ch + 0x80) & 0xFF, fg << 4 | bg])
-                io.write(line)
-            return
-        if version == -1:
-            if self._img.width <= 255 * 2 and self._img.height < 255 * 3:
-                version = 0
-            else:
-                version = 1
-
-        if version == 0:
-            io.write(b"CCPI")  # old format
-            io.write(bytes([self._img.width // 2, self._img.height // 3, 0]))
-            io.write(bytes(self._palette[: 16 * 3]))
-        elif version == 1:
-            io.write(b"CPI\x01")  # CPIv1
-            self._write_varint(io, self._img.width // 2)
-            self._write_varint(io, self._img.height // 3)
-            io.write(bytes(self._palette[: 16 * 3]))
-        else:
-            raise ValueError(f"invalid version {version}")
-
-        for y in range(0, self._img.height - 2, 3):
-            line: bytearray = bytearray()
-            for x in range(0, self._img.width - 1, 2):
-                ch, bg, fg = self._get_block(x, y)
-                line.extend([(ch + 0x80) & 0xFF, fg << 4 | bg])
-            io.write(line)
-
-    def export(self, io: TextIO):
-        io.write("local m = peripheral.find('monitor')\n")
-        io.write("m.setTextScale(0.5)\n")
-        io.write(f"-- image: {self._img.width}x{self._img.height}\n")
-        io.write("\n")
-        io.write("-- configuring palette\n")
-        for i in range(16):
-            r, g, b = self._palette[i * 3 : (i + 1) * 3]
-            io.write(
-                f"m.setPaletteColor({self.CC_COLORS[i][1]}, 0x{r:02x}{g:02x}{b:02x})\n"
-            )
-        io.write("\n")
-        io.write("-- writing pixels\n")
-
-        for i, y in enumerate(range(0, self._img.height - 2, 3), 1):
-            s = []
-            bgs = ""
-            fgs = ""
-            io.write(f"m.setCursorPos(1, {i}); ")
-            for x in range(0, self._img.width - 1, 2):
-                ch, bg, fg = self._get_block(x, y)
-                s.append(ch + 0x80)
-                bgs += self.CC_COLORS[bg][0]
-                fgs += self.CC_COLORS[fg][0]
-            io.write(
-                "m.blit(string.char(%s), '%s', '%s')\n"
-                % (str.join(", ", map(str, s)), fgs, bgs)
-            )
-
-
-def main():
-    parser = ArgumentParser(
-        description="ComputerCraft Palette Image converter",
-        formatter_class=RawTextHelpFormatter,
-    )
-    parser.add_argument(
-        "-t",
-        dest="textmode",
-        action="store_true",
-        help="Output a Lua script instead of binary image",
-    )
-    parser.add_argument(
-        "-D",
-        dest="nodither",
-        action="store_true",
-        help="Disable dithering"
-    )
-    parser.add_argument(
-        "-W",
-        dest="width",
-        default=4 * 8 - 1,
-        type=int,
-        help="Width in characters",
-    )
-    parser.add_argument(
-        "-H",
-        dest="height",
-        default=3 * 6 - 2,
-        type=int,
-        help="Height in characters",
-    )
-    parser.add_argument(
-        "-V",
-        dest="cpi_version",
-        type=int,
-        default=-1,
-        choices=(-2, -1, 0, 1),
-        help=dedent(
-            """\
-            Force specific CPI version to be used.
-            Only applies to binary format.
-            Valid versions:
-                -V -2       Uses raw format. No headers, default palette.
-                            Used for OBCB-CC project.
-                -V -1       Choose any fitting one
-                            For images smaller than 255x255, uses CPIv0
-                -V 0        OG CPI, 255x255 maximum, uncompressed
-                -V 1        CPIv1, huge images, uncompressed"""
-        ),
-    )
-    parser.add_argument(
-        "-p",
-        dest="placement",
-        choices=("center", "cover", "tile", "full", "extend", "fill"),
-        default="full",
-        help=dedent(
-            """\
-            Image placement mode (same as in hsetroot)
-                -p center       Render image centered on screen
-                -p cover        Centered on screen, scaled to fill fully
-                -p tile         Render image tiles
-                -p full         Maximum aspect ratio
-                -p extend       Same as "full" but filling borders
-                -p fill         Stretch to fill"""
-        ),
-    )
-    parser.add_argument(
-        "-P",
-        dest="palette",
-        default="auto",
-        help=dedent(
-            """\
-            Palette to be used for that conversion.
-            Should be 16 colors or less
-            Valid options are:
-                -P auto         Determine palette automatically
-                -P default      Use default CC:Tweaked color palette
-                -P defaultgray  Use default CC:Tweaked grayscale palette
-                -P "list:#RRGGBB,#RRGGBB,..."   Use a set list of colors
-                -P "cpi:path"   Load palette from a CCPI file
-                -P "gpl:path"   Parse GIMP palette file and use first 16 colors
-                -P "txt:path"   Load palette from a list of hex values
-            """
-        )
-    )
-    parser.add_argument("image_path")
-    parser.add_argument("output_path")
-
-    args = parser.parse_args()
-
-    with Image.new("RGB", (args.width * 2, args.height * 3)) as canv:
-        with Image.open(args.image_path).convert("RGB") as img:
-            if args.placement == "fill":
-                canv.paste(img.resize(canv.size), (0, 0))
-            elif args.placement in ("full", "extend", "cover"):
-                aspect = canv.width / img.width
-                if (img.height * aspect > canv.height) != (
-                    args.placement == "cover"
-                ):
-                    aspect = canv.height / img.height
-                new_w, new_h = int(img.width * aspect), int(
-                    img.height * aspect
-                )
-                top = int((canv.height - new_h) / 2)
-                left = int((canv.width - new_w) / 2)
-                resized_img = img.resize((new_w, new_h))
-                canv.paste(resized_img, (left, top))
-                if args.placement == "extend":
-                    if left > 0:
-                        right = left - 1 + new_w
-                        w = 1
-                        while right + w < canv.width:
-                            canv.paste(
-                                canv.crop(
-                                    (left + 1 - w, 0, left + 1, canv.height)
-                                ),
-                                (left + 1 - w * 2, 0),
-                            )
-                            canv.paste(
-                                canv.crop((right, 0, right + w, canv.height)),
-                                (right + w, 0),
-                            )
-                            w *= 2
-                    if top > 0:
-                        bottom = top - 1 + new_h
-                        h = 1
-                        while bottom + h < canv.height:
-                            canv.paste(
-                                canv.crop(
-                                    (0, top + 1 - h, canv.width, top + 1)
-                                ),
-                                (top + 1 - h * 2, 0),
-                            )
-                            canv.paste(
-                                canv.crop((0, bottom, canv.width, bottom + h)),
-                                (0, bottom + h),
-                            )
-                            h *= 2
-
-            elif args.placement in ("center", "tile"):
-                left = int((canv.width - img.width) / 2)
-                top = int((canv.height - img.height) / 2)
-                if args.placement == "tile":
-                    while left > 0:
-                        left -= img.width
-                    while top > 0:
-                        top -= img.height
-                    x = left
-                    while x < canv.width:
-                        y = top
-                        while y < canv.height:
-                            canv.paste(img, (x, y))
-                            y += img.height
-                        x += img.width
-                else:
-                    canv.paste(img, (left, top))
-            else:
-                pass
-
-            palette = PALETTE_ADAPTIVE
-            if args.cpi_version == -2:
-                args.palette = "default"
-
-            if args.palette == "auto":
-                palette = PALETTE_ADAPTIVE
-            elif args.palette == "default":
-                palette = Converter.DEFAULT_PALETTE
-            elif args.palette == "defaultgray":
-                palette = Converter.DEFAULT_GRAYSCALE_PALETTE
-            elif args.palette.startswith("txt:"):
-                with open(args.palette[4:], "r") as fp:
-                    palette = []
-                    for line in fp:
-                        palette += ImageColor.getcolor(line.strip(), "RGB")  # type: ignore
-                        assert len(palette) <= 16 * 3
-            elif args.palette.startswith("list:"):
-                palette = []
-                for c in args.palette[5:].split(","):
-                    palette += ImageColor.getcolor(c, "RGB")  # type: ignore
-                    assert len(palette) <= 16 * 3
-            elif args.palette.startswith("cpi:"):
-                raise ValueError("not implemented yet")
-            elif args.palette.startswith("gpl:"):
-                raise ValueError("not implemented yet")
-            else:
-                raise ValueError(f"invalid palette identifier: {args.palette!r}")
-
-            converter = Converter(canv, palette, dither=not args.nodither)
-            converter._img.save("/tmp/_ccpictmp.png")
-            if args.textmode:
-                with open(args.output_path, "w") as fp:
-                    converter.export(fp)
-            else:
-                with open(args.output_path, "wb") as fp:
-                    converter.export_binary(fp, args.cpi_version)
-
-
-if __name__ == "__main__":
-    main()

ccpi.lua

@@ -1,129 +0,0 @@
-
-local decoders = {}
-
-local function read_palette_full(palette, fp)
-    for i = 1, 16 do
-        palette[i] = bit.blshift(string.byte(fp.read(1)), 16)
-        palette[i] = bit.bor(palette[i], bit.blshift(string.byte(fp.read(1)), 8))
-        palette[i] = bit.bor(palette[i], string.byte(fp.read(1)))
-    end
-end
-
-local function read_pixeldata_v0(image, fp)
-    for y = 1, image.h do
-        local line = { s = "", bg = "", fg = "" }
-        for x = 1, image.w do
-            local data = fp.read(2)
-            if data == nil or #data == 0 then
-                return nil, string.format("Failed to read character at x=%d y=%d", x, y)
-            end
-
-            line.s = line.s .. data:sub(1, 1)
-            local color = string.byte(data, 2, 2)
-
-            if color == nil then
-                return nil, string.format("Failed to read color data for x=%d y=%d", x, y)
-            end
-            line.bg = line.bg .. string.format("%x", bit.band(0xF, color))
-            line.fg = line.fg .. string.format("%x", bit.band(0xF, bit.brshift(color, 4)))
-        end
-        table.insert(image.lines, line)
-    end
-    return true
-end
-
-local function read_varint(fp)
-    local value = 0
-    local current = 0
-    local offset = 0
-    repeat
-        if offset >= 5 then return nil, "varint too long" end
-        current = string.byte(fp.read(1))
-        value = bit.bor(value, bit.blshift(bit.band(current, 0x7f), offset * 7))
-        offset = offset + 1
-    until bit.band(current, 0x80) == 0
-    return value
-end
-
-decoders[0] = function(image, fp)
-    image.w, image.h = string.byte(fp.read(1)), string.byte(fp.read(1))
-    image.scale = 0.5 + string.byte(fp.read(1)) * 5 / 255
-    read_palette_full(image.palette, fp)
-    local success, err = read_pixeldata_v0(image, fp)
-    if not success then return false, err end
-    return true
-end
-
-decoders[1] = function(image, fp)
-    image.w = read_varint(fp)
-    image.h = read_varint(fp)
-    image.scale = 0.5 -- CPIv1 doesn't have a scale property
-    read_palette_full(image.palette, fp)
-    local success, err = read_pixeldata_v0(image, fp)
-    if not success then return false, err end
-    return true
-end
-
-local function parse(fp)
-    local res
-    local image = { w = 0, h = 0, scale = 1.0, palette = {}, lines = {} }
-
-    local magic = fp.read(4)
-    if magic == "CCPI" then
-        res, err = decoders[0](image, fp)
-    elseif magic:sub(1, 3) == "CPI" then
-        local version = magic:byte(4, 4)
-        if decoders[version] == nil then
-            return nil, string.format("Invalid CPI version 0x%02x", version)
-        end
-        res, err = decoders[version](image, fp)
-    else
-        return nil, "Invalid header: expected CCPI got " .. magic
-    end
-
-    if not res then return false, err end
-    return image
-end
-
-local function load(path)
-    local fp, err = io.open(path, "rb")
-    if not fp then return nil, err end
-    local img
-    img, err = parse(fp._handle)
-    fp:close()
-    return img, err
-end
-
-local function draw(img, ox, oy, monitor)
-    -- todo: add expect()
-    local t = monitor or term.current()
-    ox = ox or 1
-    oy = oy or 1
-
-    if not t.setPaletteColor then
-        return nil, "setPaletteColor is not supported on this term"
-    end
-
-    if not t.setTextScale and img.scale ~= 1 then
-        return nil, "setTextScale is not supported on this term"
-    end
-
-    for i = 1, 16 do
-        t.setPaletteColor(bit.blshift(1, i - 1), img.palette[i])
-    end
-
-    if img.scale ~= 1 then
-        t.setTextScale(img.scale)
-    end
-
-    for y = 1, img.h do
-        t.setCursorPos(ox, oy + y - 1)
-        t.blit(img.lines[y].s, img.lines[y].fg, img.lines[y].bg)
-    end
-end
-
-return {
-    load = load,
-    draw = draw,
-    parse = parse
-}

ccshow.lua

@@ -1,17 +0,0 @@
-local ccpi = require("ccpi")
-local args = { ... }
-
-local terminal = term.current()
-if args[1] == "-m" then
-    table.remove(args, 1)
-    terminal = peripheral.wrap(table.remove(args, 1))
-end
-
-local img, err = ccpi.load(args[1])
-if not img then
-    printError(err)
-    return
-end
-
-terminal.clear()
-ccpi.draw(img, 1, 1, terminal)

convert-video.sh

@@ -1,58 +0,0 @@
-#!/usr/bin/bash
-
-set -e
-export TMP_DIR="$(mktemp -d)";
-
-cleanup() {
-    rm -fr "${TMP_DIR}";
-}
-
-trap cleanup EXIT
-
-
-export INPUT="$1";
-export OUTPUT="$(realpath "$2")";
-export BASE_URL="$3"
-
-if [ -z "${BASE_URL}" ]; then
-    export BASE_URL="CHANGEME";
-fi
-
-
-mkdir -p "${OUTPUT}"
-
-export ORIG="$(pwd)";
-
-cd "${TMP_DIR}"
-
-<<<<<<< HEAD
-ffmpeg -i "${INPUT}" -filter_complex "[0:a]channelsplit=channel_layout=stereo[left][right]" -map '[left]' -f s8 -ac 1 -ar 48k "${OUTPUT}/left.s8" -map '[right]' -f s8 -ac 1 -ar 48k "${OUTPUT}/right.s8"
-ffmpeg -i "${INPUT}" -vf fps=20 frame%04d.png
-
-<<<<<<< HEAD
-ls frame*.png | parallel 'echo {}; python3 ${ORIG}/cc-pic.py -W 164 -H 81 -p cover {} ${OUTPUT}/{.}.cpi'
-=======
-ffmpeg -i $2.* -filter_complex "[0:a]channelsplit=channel_layout=stereo[left][right]" -map '[left]' -f s8 -ac 1 -ar 48k "${ORIG}/${NAME}/left.s8" -map '[right]' -f s8 -ac 1 -ar 48k "${ORIG}/${NAME}/right.s8"
-=======
-yt-dlp "${URL}" -S "+height:720" -f "b" -o "${NAME}"
-
-ffmpeg -i $2* -filter_complex "[0:a]channelsplit=channel_layout=stereo[left][right]" -map '[left]' -f s8 -ac 1 -ar 48k "${ORIG}/${NAME}/left.s8" -map '[right]' -f s8 -ac 1 -ar 48k "${ORIG}/${NAME}/right.s8"
->>>>>>> fb01265 (Decrease max video download quality to 720p. Larger downloads were causing errors, slower to process, and unnecessary.)
-
-ffmpeg -i $2* -vf fps=20 frame%04d.png
-rm $2*
-ls frame*.png | parallel 'echo {}; python3 ${ORIG}/cc-pic.py -W 164 -H 81 -p full {} ${ORIG}/${NAME}/{.}.cpi'
->>>>>>> 544c8a9 (Swap to -p full.)
-rm frame*.png
-
-cd "${ORIG}"
-
-export FRAME_COUNT="$(ls ${OUTPUT}/*.cpi | wc -l)";
-
-printf '{"frame_time": 0.05, "frame_count": %d, "video": "%s", "audio": {"l": "%s", "r": "%s"}}\n' "${FRAME_COUNT}" "${BASE_URL}/frame%04d.cpi" "${BASE_URL}/left.s8" "${BASE_URL}/right.s8" > "${OUTPUT}/info.json"
-
-<<<<<<< HEAD
-=======
-#'{"frame_time": 0.05,"frame_count": ${FRAME_COUNT},"video": "${BASE_URL}/${NAME}/frame%04d.cpi","audio": {"l": "${BASE_URL}/${NAME}/left.s8", "r": "${BASE_URL}/${NAME}/right.s8"}}' > "${NAME}/${NAME}.json"
-printf '{"frame_time": 0.05, "frame_count": %d, "video": "%s", "audio": {"l": "%s", "r": "%s"}}\n' "${FRAME_COUNT}" "${BASE_URL}/${NAME}/frame%04d.cpi" "${BASE_URL}/${NAME}/left.s8" "${BASE_URL}/${NAME}/right.s8" > "${NAME}/${NAME}.json"
->>>>>>> 544c8a9 (Swap to -p full.)

custom-colors.lua

@@ -1,21 +0,0 @@
-local customColors = {
-    [colors.white] =     0xEFEFEF,
-    [colors.orange] =    0xD99F82,
-    [colors.magenta] =   0x464A73,
-    [colors.lightBlue] = 0xA1D5E6,
-    [colors.yellow] =    0xE6CCA1,
-    [colors.lime] =      0x86BF8F,
-    [colors.pink] =      0xC98F8F,
-    [colors.gray] =      0x515151,
-    [colors.lightGray] = 0xA3A3A3,
-    [colors.cyan] =      0xC2F2F2,
-    [colors.blue] =      0x6699CC,
-    [colors.brown] =     0x735F4B,
-    [colors.green] =     0x6DA18A,
-    [colors.red] =       0xBD555F,
-    [colors.black] =     0x131313
-}
-
-for id, color in pairs(customColors) do
-    term.setPaletteColor(id, color)
-end

dh/dh.lua

@@ -1,71 +0,0 @@
-local ecc = require("ecc")
-
-string.toHex = function(str)
-    return str:gsub(".", function(ch) return string.format("%02x", ch:byte()) end)
-end
-string.fromHex = function(hex)
-    return hex:gsub("%x%x", function(d) return string.char(tonumber(d, 16)) end)
-end
-
-local keypair = {}
-if fs.exists("/.id_dh.json") then
-    local fp = io.open("/.id_dh.json", "r")
-    local d = textutils.unserializeJSON(fp:read())
-    keypair.sk = string.fromHex(d.secret)
-    keypair.pk = string.fromHex(d.public)
-    fp:close()
-else
-    printError("no identity found, generating...")
-    local sk, pk = ecc.keypair(ecc.random.random())
-    io.open("/.id_dh.json", "w"):write(textutils.serializeJSON({
-        secret = string.toHex(sk),
-        public = string.toHex(pk)
-    })):close()
-    keypair.sk = string.char(table.unpack(sk))
-    keypair.pk = string.char(table.unpack(pk))
-end
-
-print("pubkey: "..string.toHex(keypair.pk))
-
-local running = true
-
-local known_hosts = {}
-
-parallel.waitForAll(function() while running do -- dh:discover sender
-    rednet.broadcast(keypair.pk, "dh:discover")
-    os.sleep(10)
-end end,
-function() while running do -- dh:discover handler
-    local id, pk, proto = rednet.receive("dh:discover")
-    if proto == "dh:discover" then
-        print("DH discover from "..id.." with key "..pk)
-        local nonce = string.toHex(ecc.random.random())
-        local key = ecc.exchange(keypair.sk, pk)
-        known_hosts[id] = {
-            id = id,
-            pk = pk,
-            sk = key,
-            verified = false,
-            nonce = nonce,
-            t = os.clock()
-        }
-        known_hosts[pk] = known_hosts[id]
-        rednet.send(id, {
-            pk = keypair.pk,
-            msg = ecc.encrypt(nonce, key)
-        }, "dh:pair")
-    end
-end end,
-function() while running do -- dh:pair handler
-    local id, msg, proto = rednet.receive("dh:pair")
-    if proto == "dh:pair" then
-        local key = ecc.exchange(keypair.sk, msg.pk)
-        known_hosts[id] = {
-            id = id,
-            pk = msg.pk,
-            sk = key,
-            verified = false,
-            nonce = ecc.decrypt(msg.msg, msg.msg)
-        }
-    end
-end end)

events.lua

@@ -1,15 +0,0 @@
-local pretty = require("cc.pretty")
-
-while true do
-    local evd = { os.pullEvent() }
-    local ev, evd = table.remove(evd, 1), evd
-    if ev == "key_up" and evd[1] == keys.q then
-        break
-    elseif ev == "term_resize" then
-        local w, h = term.getSize()
-        print("term_resize", w, h)
-    else
-        io.write(ev.." ")
-        pretty.print(pretty.pretty(evd))
-    end
-end

gitea-clone.lua

@@ -1,75 +0,0 @@
-local pretty = require("cc.pretty")
-
-local args = { ... }
-
-local instance, user, repo = args[1]:match("https?://([^/]+)/([^/]+)/([^/]+)")
-
-local function getContents(path)
-    local url = "https://" .. instance .. "/api/v1/repos/" .. user .. "/" .. repo .. "/contents" .. (path and ("/" .. path) or "")
-    local res, err = http.get(url)
-    if not res then
-        printError(err)
-        return nil, err
-    end
-    return textutils.unserializeJSON(res:readAll())
-end
-
-local function walkRepository(basedir, callback)
-    local res, err = getContents(basedir)
-    if not res then
-        return nil, err
-    end
-    for _, elem in ipairs(res) do
-        if elem.type == "file" then
-            callback(elem.path, elem)
-        elseif elem.type == "dir" then
-            walkRepository(elem.path, callback)
-        else
-            printError("unknown type: " .. elem.type)
-        end
-    end
-end
-
-local function downloadFile(url, path)
-    local fp, err = io.open(path, "wb")
-    if not fp then
-        return nil, err
-    end
-
-    local rq
-    rq, err = http.get(url, nil, true)
-    if not rq then
-        return nil, err
-    end
-
-    local headers = rq.getResponseHeaders()
-    local length = tonumber(headers["Content-Length"]) or 1
-
-    local written = 0
-    local i = 0
-    local _, y = term.getCursorPos()
-    while true do
-        local chunk = rq.read(100)
-        if not chunk then break end
-        fp:write(chunk)
-        written = written + #chunk
-
-        term.setCursorPos(1, y)
-        term.clearLine()
-
-        local w = math.min(25, math.floor(written * 25 / length))
-        term.write("["..string.rep("=", w)..string.rep(" ", 25-w).."] ")
-        term.write(string.format("%7.3f%% %s", 100 * written / length, path))
-        i = i + 1
-        if (i % 20) == 0 then
-            sleep(0.1)
-        end
-    end
-    fp:close()
-    print()
-end
-
-
-walkRepository(nil, function(path, file)
-    downloadFile(file.download_url, repo.."-clone/"..path)
-end)

img2cpi.c

@@ -1,906 +0,0 @@
-// x-run: ~/scripts/runc.sh % -Wall -Wextra -lm --- ~/images/boykisser.png cpi-images/boykisser.cpi
-#define STB_IMAGE_IMPLEMENTATION
-#include <stb/stb_image.h>
-#define STB_IMAGE_RESIZE_IMPLEMENTATION
-#include <stb/stb_image_resize2.h>
-#include <argp.h>
-#include <stdio.h>
-#include <getopt.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-#include <strings.h>
-#include <stdbool.h>
-
-#define MAX_COLOR_DIFFERENCE 768
-
-struct rgba { uint8_t r, g, b, a; };
-union color {
-  struct rgba rgba;
-  uint32_t v;
-};
-struct cc_char {
-  unsigned char character;
-  unsigned char bg, fg;
-};
-
-const extern char font_atlas[256][11];
-const extern union color DEFAULT_PALETTE[16], DEFAULT_GRAY_PALETTE[16];
-
-struct arguments {
-  bool fast_mode;
-  int width, height;
-  enum cpi_version {
-    CPI_VERSION_AUTO,
-    CPI_VERSION_RAW,
-    CPI_VERSION_0,
-    CPI_VERSION_1,
-    CPI_VERSION_2,
-  } cpi_version;
-  enum placement {
-    PLACEMENT_CENTER,
-    PLACEMENT_COVER,
-    PLACEMENT_TILE,
-    PLACEMENT_FULL,
-    PLACEMENT_EXTEND,
-    PLACEMENT_FILL
-  } placement;
-  enum palette_type {
-    PALETTE_DEFAULT,
-    PALETTE_DEFAULT_GRAY,
-    PALETTE_AUTO,
-    PALETTE_PATH,
-    PALETTE_LIST
-  } palette_type;
-  char *palette;
-  char *input_path;
-  char *output_path;
-} args = {
-  .fast_mode = false,
-  .width = 4 * 8 - 1, // 4x3 blocks screen
-  .height = 3 * 6 - 2,
-  .cpi_version = CPI_VERSION_AUTO,
-  .placement = PLACEMENT_FULL,
-  .input_path = NULL,
-  .output_path = NULL,
-  .palette = NULL,
-  .palette_type = PALETTE_DEFAULT // TODO(kc): change to PALETTE_AUTO when
-                                  // k-means is implemented
-};
-
-struct image {
-  int w, h;
-  union color *pixels;
-};
-
-struct image_pal {
-  int w, h;
-  uint8_t *pixels;
-};
-
-bool parse_cmdline(int argc, char **argv);
-void show_help(const char *progname, bool show_all, FILE *fp);
-struct image *image_load(const char *fp);
-struct image *image_new(int w, int h);
-struct image *image_resize(struct image *original, int new_w, int new_h);
-struct image_pal *image_quantize(struct image *original, const union color *colors, size_t n_colors);
-float get_color_difference(union color a, union color b);
-float get_color_brightness(union color clr);
-void image_unload(struct image *img);
-void get_size_keep_aspect(int w, int h, int dw, int dh, int *ow, int *oh);
-
-const char *known_file_extensions[] = {
-  ".png", ".jpg", ".jpeg", ".jfif", ".jpg", ".gif",
-  ".tga", ".bmp", ".hdr", ".pnm", 0
-};
-
-static const struct optiondocs {
-  char shortopt;
-  char *longopt;
-  char *target;
-  char *doc;
-  struct optiondocs_choice { char *value; char *doc; } *choices;
-} optiondocs[] = {
-  { 'h', "help",        0,            "Show help", 0 },
-  { 'f', "fast",        0,            "Use fast (old) method for picking characters and colors", 0 },
-  { 'W', "width",       "width",      "Width in characters", 0 },
-  { 'h', "height",      "height",     "Height in characters", 0 },
-  { 'P', "palette",     "palette",    "Use specific palette.\n"
-             "                        `auto` uses automatic selection\n"
-             "                        `default` uses default palette\n"
-             "                        `defaultgray` uses default grayscale palette\n"
-             "                        `list:#RRGGBB,#RRGGBB,...` uses hard-coded one\n"
-             "                        `txt:PATH` reads hex colors from each line in a file\n", 0 },
-  { 'V', "cpi_version", "version",    "Force specific version of CPI",
-    (struct optiondocs_choice[]) {
-      { "-2,raw", "Use raw format. No headers, no palette, just characters and colors" },
-      { "-1,auto", "Choose best available" },
-      { "0", "OG CPI, 255x255, uncompressed" },
-      { "1", "CPIv1, huge images, uncompressed" },
-      { "255", "In-dev version, may not work" },
-      { 0, 0 } } },
-  { 'p', "placement",   "placement",  "Image placement mode (same as in hsetroot)",
-    (struct optiondocs_choice[]){
-      { "center", "Render image centered on the canvas" },
-      { "cover",  "Centered on screen, scaled to fill fully" },
-      { "tile",   "Render image tiled" },
-      { "full",   "Use maximum aspect ratio" },
-      { "extend", "Same as \"full\", but filling borders" },
-      { "fill",   "Stretch to fill" },
-      { 0, 0 } } },
-  { 0,   0,             "input.*",    "Input file path", 0 },
-  { 0,   0,             "output.cpi", "Output file path", 0 },
-  { 0 }
-};
-
-int main(int argc, char **argv) {
-  if (!parse_cmdline(argc, argv)) {
-    show_help(argv[0], false, stderr);
-    fprintf(stderr, "Fatal error occurred, exiting.\n");
-    return EXIT_FAILURE;
-  }
-  struct image *src_image = image_load(args.input_path);
-  if (!src_image) {
-    fprintf(stderr, "Error: failed to open the file\n");
-    return EXIT_FAILURE;
-  }
-
-  struct image *canvas;
-  if (args.fast_mode) {
-    canvas = image_new(args.width * 2, args.height * 3);
-  } else {
-    canvas = image_new(args.width * 8, args.height * 11);
-  }
-
-  if (!canvas) {
-    fprintf(stderr, "Error: failed to allocate second image buffer\n");
-    return EXIT_FAILURE;
-  }
-
-  // TODO: load palette, maybe calculate it too? k-means?
-  const union color *palette = DEFAULT_PALETTE;
-  switch (args.palette_type) {
-    case PALETTE_DEFAULT: palette = DEFAULT_PALETTE; break;
-    case PALETTE_DEFAULT_GRAY: palette = DEFAULT_GRAY_PALETTE; break;
-    case PALETTE_AUTO: assert(0 && "Not implemented"); break;
-    case PALETTE_LIST: assert(0 && "Not implemented"); break;
-    case PALETTE_PATH: assert(0 && "Not implemented"); break;
-    default: assert(0 && "Unreachable");
-  }
-
-  // TODO: properly scale
-  struct image *scaled_image;
-  {
-    int new_w, new_h;
-    get_size_keep_aspect(src_image->w, src_image->h, canvas->w, canvas->h, &new_w, &new_h);
-
-    scaled_image = image_resize(src_image, new_w, new_h);
-    if (!scaled_image) {
-      fprintf(stderr, "Error: failed to open the file\n");
-      return EXIT_FAILURE;
-    }
-  }
-
-  // TODO: position image properly
-  int small_w = scaled_image->w < canvas->w ? scaled_image->w : canvas->w;
-  int small_h = scaled_image->h < canvas->h ? scaled_image->h : canvas->h;
-  for (int y = 0; y < small_h; y++) {
-    memcpy(&canvas->pixels[y * canvas->w],
-           &scaled_image->pixels[y * scaled_image->w],
-           small_w * sizeof(union color));
-  }
-
-
-  // TODO: actually do stuff
-  struct cc_char *characters = calloc(args.width * args.height, sizeof(struct cc_char));
-
-  struct image_pal *quantized_image = image_quantize(canvas, palette, 16);
-  if (!quantized_image) {
-    fprintf(stderr, "Error: failed to open the file\n");
-    return EXIT_FAILURE;
-  }
-
-  FILE *tmp = fopen("/tmp/img.raw", "wb");
-  for (int i = 0; i < quantized_image->w * quantized_image->h; i++) {
-    union color pix = palette[quantized_image->pixels[i]];
-    fputc(pix.rgba.r, tmp);
-    fputc(pix.rgba.g, tmp);
-    fputc(pix.rgba.b, tmp);
-  }
-  fclose(tmp);
-
-  if (args.fast_mode) {
-    // use old 2x3
-    for (int y = 0; y < args.height; y++) {
-      for (int x = 0; x < args.width; x++) {
-        unsigned char darkest_i = 0, brightest_i = 0;
-        float darkest_diff = 0xffffff, brightest_diff = 0;
-
-        for (int oy = 0; oy < 3; oy++) {
-          for (int ox = 0; ox < 2; ox++) {
-            unsigned char pix = quantized_image->pixels[ox + (x + (y * 3 + oy) * args.width) * 2];
-            float brightness = get_color_brightness(palette[pix]);
-            if (brightness >= brightest_diff) {
-              brightest_i = pix;
-              brightest_diff = brightness;
-            }
-            if (brightness <= darkest_diff) {
-              darkest_i = pix;
-              darkest_diff = brightness;
-            }
-          }
-        }
-
-        unsigned char bitmap = 0;
-        const static unsigned char pixel_bits[3][2] = { { 1, 2}, { 4, 8 }, { 16, 0 } };
-        for (int oy = 0; oy < 3; oy++) {
-          for (int ox = 0; ox < 2; ox++) {
-            if (ox == 1 && oy == 2) continue;
-            unsigned char pix = quantized_image->pixels[ox + (x + (y * 3 + oy) * args.width) * 2];
-            float diff_bg = get_color_difference(palette[darkest_i], palette[pix]);
-            float diff_fg = get_color_difference(palette[brightest_i], palette[pix]);
-            if (diff_fg < diff_bg) {
-              bitmap |= pixel_bits[oy][ox];
-            }
-          }
-        }
-
-        {
-          unsigned char pix = quantized_image->pixels[1 + (x + (y * 3 + 2) * args.width) * 2];
-          float diff_bg = get_color_difference(palette[darkest_i], palette[pix]);
-          float diff_fg = get_color_difference(palette[brightest_i], palette[pix]);
-          if (diff_fg < diff_bg) {
-            bitmap ^= 31;
-            unsigned char tmp = darkest_i;
-            darkest_i = brightest_i;
-            brightest_i = tmp;
-          }
-        }
-
-        characters[x + y * args.width].character = 0x80 + bitmap;
-        characters[x + y * args.width].bg = darkest_i;
-        characters[x + y * args.width].fg = brightest_i;
-      }
-    }
-  } else {
-    // use new 8x11 character matching
-    for (int y = 0; y < args.height; y++) {
-      for (int x = 0; x < args.width; x++) {
-        // Oh boy...
-        float min_diff = 0xffffff;
-        char closest_sym = 0x00, closest_color = 0xae;
-        for (int sym = 0x01; sym <= 0xFF; sym++) {
-          if (sym == '\t' || sym == '\n' || sym == '\r' || sym == '\x0e') {
-            continue;
-          }
-          for (int color = 0x00; color <= 0xff; color++) {
-            union color cell_bg = palette[color & 0xF],
-                        cell_fg = palette[color >> 4];
-            float difference = 0;
-            for (int oy = 0; oy < 11; oy++) {
-              unsigned char sym_line = font_atlas[sym][oy];
-              for (int ox = 0; ox < 8; ox++) {
-                bool lit = sym_line & (0x80 >> ox);
-                union color pixel = palette[quantized_image->pixels[
-                   ox + (x + (y * 11 + oy) * args.width) * 8
-                ]];
-                difference += get_color_difference(pixel, lit ? cell_fg : cell_bg);
-              }
-            }
-            if (difference <= min_diff) {
-              min_diff = difference;
-              closest_sym = sym;
-              closest_color = color;
-            }
-          }
-        }
-        characters[x + y * args.width].character = closest_sym;
-        characters[x + y * args.width].bg = closest_color & 0xF;
-        characters[x + y * args.width].fg = closest_color >> 4;
-      }
-    }
-  }
-
-  // TODO: implement something other than CPIv0
-  FILE *fp = fopen(args.output_path, "wb");
-  fwrite("CCPI", 1, 4, fp);
-  fputc(args.width, fp);
-  fputc(args.height, fp);
-  fputc(0x00, fp);
-  for (int i = 0; i < 16; i++) {
-    fputc(palette[i].rgba.r, fp);
-    fputc(palette[i].rgba.g, fp);
-    fputc(palette[i].rgba.b, fp);
-  }
-  for (int i = 0; i < args.width * args.height; i++) {
-    fputc(characters[i].character, fp);
-    fputc(characters[i].bg | (characters[i].fg << 4), fp);
-  }
-  fclose(fp);
-
-  image_unload(src_image);
-  image_unload(canvas);
-  return EXIT_SUCCESS;
-}
-
-bool parse_cmdline(int argc, char **argv) {
-  static struct option options[] = {
-    { "help",         no_argument,        0, 'h' },
-    { "fast",         no_argument,        0, 'f' },
-    { "width",        required_argument,  0, 'W' },
-    { "height",       required_argument,  0, 'H' },
-    { "cpi_version",  required_argument,  0, 'V' },
-    { "placement",    required_argument,  0, 'p' },
-    { "palette",      required_argument,  0, 'P' },
-    { 0,              0,                  0,  0  }
-  };
-
-  while (true) {
-    int option_index = 0;
-    int c = getopt_long(argc, argv, "hfW:H:V:p:P:", options, &option_index);
-    if (c == -1) break;
-    if (c == 0) c = options[option_index].val;
-    if (c == '?') break;
-
-    switch (c) {
-      case 'h': // --help
-        show_help(argv[0], true, stdout);
-        exit(EXIT_SUCCESS);
-        break;
-      case 'f': // --fast
-        args.fast_mode = true;
-        if (args.cpi_version != CPI_VERSION_AUTO) {
-          fprintf(stderr, "Warning: text mode ignores version\n");
-        }
-        break;
-      case 'W': // --width
-        args.width = atoi(optarg);
-        break;
-      case 'H': // --height
-        args.height = atoi(optarg);
-        break;
-      case 'V': // --cpi_version
-        {
-          if (0 == strcmp(optarg, "auto") || 0 == strcmp(optarg, "-1")) {
-            args.cpi_version = CPI_VERSION_AUTO;
-          } else if (0 == strcmp(optarg, "raw") || 0 == strcmp(optarg, "-2")) {
-            args.cpi_version = CPI_VERSION_RAW;
-          } else if (0 == strcmp(optarg, "0")) {
-            args.cpi_version = CPI_VERSION_0;
-          } else if (0 == strcmp(optarg, "1")) {
-            args.cpi_version = CPI_VERSION_1;
-          } else if (0 == strcmp(optarg, "2")) {
-            args.cpi_version = CPI_VERSION_2;
-          }
-        }
-        break;
-      case 'p': // --placement
-        if (0 == strcmp(optarg, "center")) {
-          args.placement = PLACEMENT_CENTER;
-        } else if (0 == strcmp(optarg, "cover")) {
-          args.placement = PLACEMENT_COVER;
-        } else if (0 == strcmp(optarg, "tile")) {
-          args.placement = PLACEMENT_TILE;
-        } else if (0 == strcmp(optarg, "full")) {
-          args.placement = PLACEMENT_FULL; }
-        else if (0 == strcmp(optarg, "extend")) {
-          args.placement = PLACEMENT_EXTEND;
-        } else if (0 == strcmp(optarg, "fill")) {
-          args.placement = PLACEMENT_FILL;
-        } else {
-          fprintf(stderr, "Error: invaild placement %s\n", optarg);
-          return false;
-        }
-        break;
-      case 'P': // --palette
-        if (0 == strcmp(optarg, "default")) {
-          args.palette_type = PALETTE_DEFAULT;
-        } else if (0 == strcmp(optarg, "defaultgray")) {
-          args.palette_type = PALETTE_DEFAULT_GRAY;
-        } else if (0 == strcmp(optarg, "auto")) {
-          args.palette_type = PALETTE_AUTO;
-        } else if (0 == strncmp(optarg, "list:", 5)) {
-          args.palette_type = PALETTE_LIST;
-          args.palette = &optarg[5];
-        } else {
-          fprintf(stderr, "Error: invaild palette %s\n", optarg);
-          return false;
-        }
-        break;
-    }
-  }
-
-  if (optind == argc) {
-    fprintf(stderr, "Error: no input file provided\n");
-    return false;
-  } else if (optind + 1 == argc) {
-    fprintf(stderr, "Error: no output file provided\n");
-    return false;
-  } else if ((argc - optind) != 2) {
-    fprintf(stderr, "Error: too many arguments\n");
-    return false;
-  }
-
-  args.input_path = argv[optind];
-  args.output_path = argv[optind + 1];
-
-  const char *extension = strrchr(args.input_path, '.');
-  if (!extension) {
-    fprintf(stderr, "Warning: no file extension, reading may fail!\n");
-  } else {
-    bool known = false;
-    for (int i = 0; known_file_extensions[i] != 0; i++) {
-      if (0 == strcasecmp(known_file_extensions[i], extension)) {
-        known = true;
-        break;
-      }
-    }
-    if (!known) {
-      fprintf(stderr, "Warning: unknown file extension %s, reading may fail!\n", extension);
-    }
-  }
-
-  return true;
-}
-
-void show_help(const char *progname, bool show_all, FILE *fp) {
-  fprintf(fp, "usage: %s", progname);
-  for (int i = 0; optiondocs[i].doc != 0; i++) {
-    struct optiondocs doc = optiondocs[i];
-    fprintf(fp, " [");
-    if (doc.shortopt) fprintf(fp, "-%c", doc.shortopt);
-    if (doc.shortopt && doc.longopt) fprintf(fp, "|");
-    if (doc.longopt) fprintf(fp, "--%s", doc.longopt);
-    if (doc.target) {
-      if (doc.shortopt || doc.longopt) fprintf(fp, " ");
-      fprintf(fp, "%s", doc.target);
-    }
-    fprintf(fp, "]");
-  }
-  fprintf(fp, "\n");
-
-  if (!show_all) return;
-
-  fprintf(fp, "\n");
-  fprintf(fp, "ComputerCraft Palette Image converter\n");
-  fprintf(fp, "\n");
-  fprintf(fp, "positional arguments:\n");
-  for (int i = 0; optiondocs[i].doc != 0; i++) {
-    struct optiondocs doc = optiondocs[i];
-    if (!doc.shortopt && !doc.longopt) {
-      fprintf(fp, "  %s\t%s\n", doc.target, doc.doc);
-    }
-  }
-  fprintf(fp, "\n");
-  fprintf(fp, "options:\n");
-  for (int i = 0; optiondocs[i].doc != 0; i++) {
-    struct optiondocs doc = optiondocs[i];
-    if (!doc.shortopt && !doc.longopt) { continue; }
-    fprintf(fp, "  ");
-    int x = 2;
-    if (doc.shortopt) { fprintf(fp, "-%c", doc.shortopt); x += 2; }
-    if (doc.shortopt && doc.longopt) { fprintf(fp, ", "); x += 2; }
-    if (doc.longopt) { fprintf(fp, "--%s", doc.longopt); x += strlen(doc.longopt) + 2; }
-    if (doc.choices) {
-      fprintf(fp, " {");
-      for (int j = 0; doc.choices[j].value != 0; j++) {
-        if (j > 0) { fprintf(fp, ","); x += 1; }
-        fprintf(fp, "%s", doc.choices[j].value);
-        x += strlen(doc.choices[j].value);
-      }
-      fprintf(fp, "}");
-      x += 3;
-    } else if (doc.target) {
-      fprintf(fp, " ");
-      fprintf(fp, "%s", doc.target);
-      x += strlen(doc.target) + 1;
-    }
-    if (x > 24) fprintf(fp, "\n%24c", ' ');
-    else fprintf(fp, "%*c", 24 - x, ' ');
-
-    fprintf(fp, "%s\n", doc.doc);
-
-    if (doc.choices) {
-      for (int j = 0; doc.choices[j].value != 0; j++) {
-        fprintf(fp, "%26c", ' ');
-        if (doc.shortopt) fprintf(fp, "-%c ", doc.shortopt);
-        else if (doc.longopt) fprintf(fp, "--%s", doc.longopt);
-        fprintf(fp, "%-12s %s\n", doc.choices[j].value, doc.choices[j].doc);
-      }
-    }
-  }
-}
-
-struct image *image_load(const char *fp) {
-  struct image *img = calloc(1, sizeof(struct image));
-  if (!img) return NULL;
-  img->pixels = (union color*)stbi_load(fp, &img->w, &img->h, 0, 4);
-  if (!img->pixels) {
-    free(img);
-    return NULL;
-  }
-  return img;
-}
-
-struct image *image_new(int w, int h) {
-  struct image *img = calloc(1, sizeof(struct image));
-  if (!img) return NULL;
-  img->pixels = calloc(h, sizeof(union color) * w);
-  img->w = w;
-  img->h = h;
-  if (!img->pixels) {
-    free(img);
-    return NULL;
-  }
-  return img;
-}
-
-struct image *image_resize(struct image *original, int new_w, int new_h) {
-  struct image *resized = image_new(new_w, new_h);
-  if (!resized) return NULL;
-  stbir_resize_uint8_srgb((unsigned char *)original->pixels, original->w, original->h, 0,
-                          (unsigned char *)resized->pixels, resized->w, resized->h, 0,
-                          STBIR_RGBA);
-  return resized;
-}
-
-void image_unload(struct image *img) {
-  free(img->pixels);
-  free(img);
-}
-
-void get_size_keep_aspect(int w, int h, int dw, int dh, int *ow, int *oh)
-{
-  *ow = dw;
-  *oh = dh;
-  float ratio = (float)w / (float)h;
-  float ratio_dst = (float)dw / (float)dh;
-  int tmp_1, tmp_2;
-  if (ratio_dst >= ratio)
-  {
-    tmp_1 = floor(dh * ratio);
-    tmp_2 = ceil(dh * ratio);
-    if (fabsf(ratio - (float)tmp_1 / dh) < fabsf(ratio - (float)tmp_2 / dh))
-      *ow = tmp_1 < 1 ? 1 : tmp_1;
-    else
-      *ow = tmp_2 < 1 ? 1 : tmp_2;
-  }
-  else
-  {
-    tmp_1 = floor(dw / ratio);
-    tmp_2 = ceil(dw / ratio);
-    if (tmp_2 == 0 ||
-        fabs(ratio - (float)dw / tmp_1) < fabs(ratio - (float)dw / tmp_2))
-      (*oh) = tmp_1 < 1 ? 1 : tmp_1;
-    else
-      (*oh) = tmp_2 < 1 ? 1 : tmp_2;
-  }
-}
-
-struct image_pal *image_quantize(struct image *original, const union color *colors, size_t n_colors) {
-  struct image_pal *out = calloc(1, sizeof(struct image_pal));
-  out->w = original->w;
-  out->h = original->h;
-  out->pixels = calloc(original->w, original->h);
-
-  for (int i = 0; i < out->w * out->h; i++) {
-    int closest_color = 0;
-    float closest_distance = 1e20;
-    for (int color = 0; color < n_colors; color++) {
-      float dist = get_color_difference(colors[color], original->pixels[i]);
-      if (dist <= closest_distance) {
-        closest_distance = dist;
-        closest_color = color;
-      }
-    }
-    out->pixels[i] = closest_color;
-  }
-
-  return out;
-}
-
-float get_color_difference(union color a, union color b) {
-  int dr = a.rgba.r - b.rgba.r,
-      dg = a.rgba.g - b.rgba.g,
-      db = a.rgba.b - b.rgba.b;
-  return dr * dr + dg * dg + db * db;
-}
-
-float get_color_brightness(union color clr) {
-  return get_color_difference(clr, (union color){ .v = 0 });
-}
-
-const union color DEFAULT_PALETTE[16] = {
-  { 0xf0, 0xf0, 0xf0, 0xff },
-  { 0xf2, 0xb2, 0x33, 0xff },
-  { 0xe5, 0x7f, 0xd8, 0xff },
-  { 0x99, 0xb2, 0xf2, 0xff },
-  { 0xde, 0xde, 0x6c, 0xff },
-  { 0x7f, 0xcc, 0x19, 0xff },
-  { 0xf2, 0xb2, 0xcc, 0xff },
-  { 0x4c, 0x4c, 0x4c, 0xff },
-  { 0x99, 0x99, 0x99, 0xff },
-  { 0x4c, 0x99, 0xb2, 0xff },
-  { 0xb2, 0x66, 0xe5, 0xff },
-  { 0x33, 0x66, 0xcc, 0xff },
-  { 0x7f, 0x66, 0x4c, 0xff },
-  { 0x57, 0xa6, 0x4e, 0xff },
-  { 0xcc, 0x4c, 0x4c, 0xff },
-  { 0x11, 0x11, 0x11, 0xff }
-}, DEFAULT_GRAY_PALETTE[16] = {
-  { 0xf0, 0xf0, 0xf0, 0xff },
-  { 0x9d, 0x9d, 0x9d, 0xff },
-  { 0xbe, 0xbe, 0xbe, 0xff },
-  { 0xbf, 0xbf, 0xbf, 0xff },
-  { 0xb8, 0xb8, 0xb8, 0xff },
-  { 0x76, 0x76, 0x76, 0xff },
-  { 0xd0, 0xd0, 0xd0, 0xff },
-  { 0x4c, 0x4c, 0x4c, 0xff },
-  { 0x99, 0x99, 0x99, 0xff },
-  { 0x87, 0x87, 0x87, 0xff },
-  { 0xa9, 0xa9, 0xa9, 0xff },
-  { 0x77, 0x77, 0x77, 0xff },
-  { 0x65, 0x65, 0x65, 0xff },
-  { 0x6e, 0x6e, 0x6e, 0xff },
-  { 0x76, 0x76, 0x76, 0xff },
-  { 0x11, 0x11, 0x11, 0xff }
-};
-
-const char font_atlas[256][11] = {
-  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x6c, 0x44, 0x54, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x7c, 0x54, 0x7c, 0x44, 0x6c, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x28, 0x7c, 0x7c, 0x7c, 0x38, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x10, 0x38, 0x7c, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x38, 0x10, 0x7c, 0x7c, 0x10, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x10, 0x38, 0x7c, 0x7c, 0x10, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x18, 0x3c, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x7e, 0x7e, 0x66, 0x42, 0x42, 0x66, 0x7e, 0x7e, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x1c, 0x0c, 0x34, 0x48, 0x48, 0x30, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x44, 0x44, 0x38, 0x10, 0x38, 0x10, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x3c, 0x24, 0x3c, 0x20, 0x60, 0x60, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x3e, 0x22, 0x3e, 0x22, 0x66, 0x66, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x40, 0x70, 0x7c, 0x70, 0x40, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x04, 0x1c, 0x7c, 0x1c, 0x04, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x38, 0x7c, 0x10, 0x10, 0x7c, 0x38, 0x10, 0x00, 0x00, },
-  { 0x00, 0x24, 0x24, 0x24, 0x24, 0x24, 0x00, 0x24, 0x00, 0x00, 0x00, },
-  { 0x00, 0x3c, 0x54, 0x54, 0x34, 0x14, 0x14, 0x14, 0x00, 0x00, 0x00, },
-  { 0x00, 0x3c, 0x60, 0x58, 0x44, 0x34, 0x0c, 0x78, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x38, 0x7c, 0x10, 0x7c, 0x38, 0x10, 0x7c, 0x00, 0x00, },
-  { 0x00, 0x10, 0x38, 0x7c, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x10, 0x10, 0x10, 0x7c, 0x38, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x10, 0x18, 0x7c, 0x18, 0x10, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x10, 0x30, 0x7c, 0x30, 0x10, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x7c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x24, 0x7e, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x10, 0x10, 0x38, 0x38, 0x7c, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x7c, 0x38, 0x38, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x14, 0x14, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x28, 0x7c, 0x28, 0x7c, 0x28, 0x28, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x3c, 0x40, 0x38, 0x04, 0x78, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x44, 0x48, 0x08, 0x10, 0x20, 0x24, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x28, 0x10, 0x34, 0x58, 0x48, 0x34, 0x00, 0x00, 0x00, },
-  { 0x00, 0x08, 0x08, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x0c, 0x10, 0x20, 0x20, 0x20, 0x10, 0x0c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x30, 0x08, 0x04, 0x04, 0x04, 0x08, 0x30, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x24, 0x18, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x10, 0x10, 0x7c, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x04, 0x08, 0x08, 0x10, 0x20, 0x20, 0x40, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x4c, 0x54, 0x64, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x30, 0x10, 0x10, 0x10, 0x10, 0x7c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x04, 0x18, 0x20, 0x44, 0x7c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x04, 0x18, 0x04, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x0c, 0x14, 0x24, 0x44, 0x7c, 0x04, 0x04, 0x00, 0x00, 0x00, },
-  { 0x00, 0x7c, 0x40, 0x78, 0x04, 0x04, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x18, 0x20, 0x40, 0x78, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x7c, 0x44, 0x04, 0x08, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x44, 0x38, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x44, 0x3c, 0x04, 0x08, 0x30, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 0x10, 0x00, 0x00, },
-  { 0x00, 0x04, 0x08, 0x10, 0x20, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x20, 0x10, 0x08, 0x04, 0x08, 0x10, 0x20, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x04, 0x08, 0x10, 0x00, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x3c, 0x42, 0x5a, 0x5a, 0x5e, 0x40, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x7c, 0x44, 0x44, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x78, 0x44, 0x78, 0x44, 0x44, 0x44, 0x78, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x40, 0x40, 0x40, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x78, 0x44, 0x44, 0x44, 0x44, 0x44, 0x78, 0x00, 0x00, 0x00, },
-  { 0x00, 0x7c, 0x40, 0x70, 0x40, 0x40, 0x40, 0x7c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x7c, 0x40, 0x70, 0x40, 0x40, 0x40, 0x40, 0x00, 0x00, 0x00, },
-  { 0x00, 0x3c, 0x40, 0x4c, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x44, 0x44, 0x7c, 0x44, 0x44, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x10, 0x10, 0x10, 0x10, 0x10, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x44, 0x48, 0x70, 0x48, 0x44, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x7c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x44, 0x6c, 0x54, 0x44, 0x44, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x44, 0x64, 0x54, 0x4c, 0x44, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x44, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x78, 0x44, 0x78, 0x40, 0x40, 0x40, 0x40, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x44, 0x44, 0x44, 0x48, 0x34, 0x00, 0x00, 0x00, },
-  { 0x00, 0x78, 0x44, 0x78, 0x44, 0x44, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x3c, 0x40, 0x38, 0x04, 0x04, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x7c, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x44, 0x44, 0x44, 0x44, 0x28, 0x28, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x44, 0x44, 0x44, 0x44, 0x54, 0x6c, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x44, 0x28, 0x10, 0x28, 0x44, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x44, 0x28, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x7c, 0x04, 0x08, 0x10, 0x20, 0x40, 0x7c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x20, 0x20, 0x20, 0x20, 0x20, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x40, 0x20, 0x20, 0x10, 0x08, 0x08, 0x04, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x08, 0x08, 0x08, 0x08, 0x08, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x28, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, },
-  { 0x00, 0x10, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x38, 0x04, 0x3c, 0x44, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x40, 0x40, 0x58, 0x64, 0x44, 0x44, 0x78, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x38, 0x44, 0x40, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x04, 0x04, 0x34, 0x4c, 0x44, 0x44, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x38, 0x44, 0x7c, 0x40, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x0c, 0x10, 0x3c, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x3c, 0x44, 0x44, 0x3c, 0x04, 0x78, 0x00, 0x00, },
-  { 0x00, 0x40, 0x40, 0x58, 0x64, 0x44, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x04, 0x00, 0x04, 0x04, 0x04, 0x44, 0x44, 0x38, 0x00, 0x00, },
-  { 0x00, 0x20, 0x20, 0x24, 0x28, 0x30, 0x28, 0x24, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x68, 0x54, 0x54, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x78, 0x44, 0x44, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x38, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x58, 0x64, 0x44, 0x78, 0x40, 0x40, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x34, 0x4c, 0x44, 0x3c, 0x04, 0x04, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x58, 0x64, 0x40, 0x40, 0x40, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x3c, 0x40, 0x38, 0x04, 0x78, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x10, 0x38, 0x10, 0x10, 0x10, 0x08, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x44, 0x44, 0x44, 0x44, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x44, 0x44, 0x44, 0x28, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x44, 0x44, 0x54, 0x54, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x44, 0x28, 0x10, 0x28, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x44, 0x44, 0x44, 0x3c, 0x04, 0x78, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x7c, 0x08, 0x10, 0x20, 0x7c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x0c, 0x10, 0x10, 0x20, 0x10, 0x10, 0x0c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x30, 0x08, 0x08, 0x04, 0x08, 0x08, 0x30, 0x00, 0x00, 0x00, },
-  { 0x00, 0x32, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x24, 0x48, 0x12, 0x24, 0x48, 0x12, 0x24, 0x48, 0x12, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0xf0, 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, },
-  { 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, },
-  { 0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, },
-  { 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, },
-  { 0xf0, 0xf0, 0xf0, 0xf0, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, },
-  { 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, },
-  { 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, },
-  { 0xf0, 0xf0, 0xf0, 0xf0, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, },
-  { 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, },
-  { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, },
-  { 0xf0, 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, },
-  { 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, },
-  { 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, },
-  { 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, },
-  { 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, },
-  { 0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, },
-  { 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, },
-  { 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, },
-  { 0xf0, 0xf0, 0xf0, 0xf0, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, },
-  { 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, },
-  { 0x7f, 0x7f, 0x7f, 0x7f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, },
-  { 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, },
-  { 0xf0, 0xf0, 0xf0, 0xf0, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, },
-  { 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, },
-  { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, },
-  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x10, 0x38, 0x44, 0x40, 0x44, 0x38, 0x10, 0x00, 0x00, },
-  { 0x00, 0x18, 0x24, 0x20, 0x78, 0x20, 0x20, 0x7c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x44, 0x38, 0x44, 0x44, 0x44, 0x38, 0x44, 0x00, 0x00, },
-  { 0x00, 0x44, 0x28, 0x7c, 0x10, 0x7c, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x10, 0x10, 0x00, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x3c, 0x60, 0x58, 0x44, 0x34, 0x0c, 0x78, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x3c, 0x4a, 0x52, 0x52, 0x4a, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x30, 0x08, 0x38, 0x48, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x14, 0x28, 0x50, 0x28, 0x14, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x7c, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x3c, 0x5a, 0x5a, 0x56, 0x42, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x30, 0x48, 0x48, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x10, 0x10, 0x7c, 0x10, 0x10, 0x00, 0x7c, 0x00, 0x00, },
-  { 0x00, 0x40, 0x20, 0x60, 0x40, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x60, 0x20, 0x60, 0x20, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x44, 0x44, 0x44, 0x44, 0x7a, 0x40, 0x40, 0x00, },
-  { 0x00, 0x3c, 0x54, 0x54, 0x34, 0x14, 0x14, 0x14, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, },
-  { 0x00, 0x20, 0x60, 0x20, 0x20, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x38, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x50, 0x28, 0x14, 0x28, 0x50, 0x00, 0x00, 0x00, },
-  { 0x00, 0x44, 0x48, 0x08, 0x10, 0x2c, 0x2c, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x44, 0x48, 0x08, 0x10, 0x24, 0x28, 0x4c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x64, 0x28, 0x68, 0x10, 0x2c, 0x2c, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x00, 0x10, 0x20, 0x40, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x60, 0x00, 0x38, 0x44, 0x7c, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x0c, 0x00, 0x38, 0x44, 0x7c, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x38, 0x44, 0x7c, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x50, 0x38, 0x44, 0x7c, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x00, 0x38, 0x44, 0x7c, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x00, 0x38, 0x44, 0x7c, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x3c, 0x50, 0x50, 0x78, 0x50, 0x50, 0x5c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x40, 0x40, 0x44, 0x38, 0x08, 0x10, 0x00, 0x00, },
-  { 0x00, 0x60, 0x00, 0x7c, 0x40, 0x78, 0x40, 0x7c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x0c, 0x00, 0x7c, 0x40, 0x78, 0x40, 0x7c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x7c, 0x40, 0x78, 0x40, 0x7c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x00, 0x7c, 0x40, 0x78, 0x40, 0x7c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x30, 0x00, 0x38, 0x10, 0x10, 0x10, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x18, 0x00, 0x38, 0x10, 0x10, 0x10, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x28, 0x38, 0x10, 0x10, 0x10, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x00, 0x38, 0x10, 0x10, 0x10, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x78, 0x44, 0x44, 0x64, 0x44, 0x44, 0x78, 0x00, 0x00, 0x00, },
-  { 0x00, 0x14, 0x28, 0x44, 0x64, 0x54, 0x4c, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x60, 0x38, 0x44, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x0c, 0x38, 0x44, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x38, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x50, 0x38, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x38, 0x44, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x44, 0x28, 0x10, 0x28, 0x44, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x4c, 0x54, 0x64, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x60, 0x00, 0x44, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x0c, 0x00, 0x44, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x28, 0x00, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x00, 0x44, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x0c, 0x00, 0x44, 0x28, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x10, 0x18, 0x14, 0x18, 0x10, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x78, 0x44, 0x58, 0x44, 0x44, 0x44, 0x58, 0x40, 0x00, 0x00, },
-  { 0x00, 0x60, 0x00, 0x38, 0x04, 0x3c, 0x44, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x0c, 0x00, 0x38, 0x04, 0x3c, 0x44, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x38, 0x04, 0x3c, 0x44, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x50, 0x38, 0x04, 0x3c, 0x44, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x00, 0x38, 0x04, 0x3c, 0x44, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x00, 0x38, 0x04, 0x3c, 0x44, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x2c, 0x52, 0x7c, 0x50, 0x2e, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x38, 0x44, 0x40, 0x44, 0x38, 0x08, 0x10, 0x00, 0x00, },
-  { 0x00, 0x60, 0x00, 0x38, 0x44, 0x7c, 0x40, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x0c, 0x00, 0x38, 0x44, 0x7c, 0x40, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x38, 0x44, 0x7c, 0x40, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x00, 0x38, 0x44, 0x7c, 0x40, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x30, 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x18, 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x28, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x08, 0x3c, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x50, 0x78, 0x44, 0x44, 0x44, 0x44, 0x00, 0x00, 0x00, },
-  { 0x00, 0x60, 0x00, 0x38, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x0c, 0x00, 0x38, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x38, 0x44, 0x38, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x50, 0x38, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x00, 0x38, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x10, 0x00, 0x7c, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, },
-  { 0x00, 0x00, 0x00, 0x38, 0x4c, 0x54, 0x64, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x60, 0x00, 0x44, 0x44, 0x44, 0x44, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x0c, 0x00, 0x44, 0x44, 0x44, 0x44, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x10, 0x28, 0x00, 0x44, 0x44, 0x44, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x00, 0x44, 0x44, 0x44, 0x44, 0x3c, 0x00, 0x00, 0x00, },
-  { 0x00, 0x0c, 0x00, 0x44, 0x44, 0x44, 0x3c, 0x04, 0x78, 0x00, 0x00, },
-  { 0x00, 0x30, 0x10, 0x18, 0x14, 0x18, 0x10, 0x38, 0x00, 0x00, 0x00, },
-  { 0x00, 0x28, 0x00, 0x44, 0x44, 0x44, 0x3c, 0x04, 0x78, 0x00, 0x00, },
-};

mess/progress-text.lua

@@ -1,43 +0,0 @@
-term.clear()
-term.setCursorPos(1, 1)
-term.setTextColor(colors.white)
-
-local tw, th = term.getSize()
-print(string.format("Terminal: %dx%d", tw, th))
-local function printScale(c1, c2, p, fmt, ...)
-    local str = string.format(fmt, ...)
-    local w1 = math.ceil(p * tw)
-    local w2 = tw - w1
-
-    local bg = term.getBackgroundColor()
-    term.setBackgroundColor(c1)
-    term.write(str:sub(1, w1))
-    local rem = w1 - #str
-    if rem > 0 then
-        term.write(string.rep(" ", rem))
-    end
-
-    term.setBackgroundColor(c2)
-    term.write(str:sub(w1 + 1, w1 + w2))
-
-    rem = math.min(tw - #str, w2)
-    if rem > 0 then
-        term.write(string.rep(" ", rem))
-    end
-
-    term.setBackgroundColor(bg)
-    print()
-end
-
-
-term.setBackgroundColor(colors.black)
-local t = 0
-while true do
-    for i = 1, th do
-        local p = 0.5 + 0.5 * math.sin((i + t) * math.pi / 25)
-        term.setCursorPos(1, i)
-        printScale(colors.red, colors.gray, p, "%7.3f%%", p * 100)
-    end
-    os.sleep(0.05)
-    t = t + 1
-end

mess/scrolling-text.lua

@@ -1,42 +0,0 @@
-
-local lines = { "owo" }
-for line in io.lines("cc-stuff/mess/scrolling-text.lua") do
-    table.insert(lines, line)
-end
-
-local function drawScrollingText(x, y, w, time, t)
-    term.setCursorPos(x, y)
-    if #t <= w then
-        term.write(t)
-        return
-    end
-    time = (time % (#t + 5)) + 1
-    term.write((t .. " ::: " .. t):sub(time, time + w - 1))
-end
-
-term.clear()
-term.setCursorPos(1, 1)
-term.setCursorBlink(false)
-
-parallel.waitForAny(
-function()
-    local time = 0
-    while true do
-        local tw, th = term.getSize()
-        for i = 1, th do
-            local txt = lines[((#lines - th + i - 1) % #lines) + 1]
-            drawScrollingText(math.floor(tw / 2) - i, i, i * 2, time, txt)
-            drawScrollingText(math.floor(tw / 2) - i, i, i * 2, time, txt)
-        end
-        time = time + 1
-        os.sleep(0.05)
-    end
-end,
-function()
-    os.pullEvent("key")
-end,
-function()
-    os.sleep(10)
-end)
-
-print("exited")

mess/tmpc.lua

@@ -1,637 +0,0 @@
-settings.define("mplayer.colors.bg", {
-    description = "Background color in media player",
-    default = 0x131313, -- #131313
-    type = number
-})
-
-settings.define("mplayer.colors.fg", {
-    description = "Text color in media player",
-    default = 0xEFEFEF, -- #EFEFEF
-    type = number
-})
-
-settings.define("mplayer.colors.cursor", {
-    description = "Color of the cursor",
-    default = 0x8080EF, -- #8080EF
-    type = number
-})
-
-settings.define("mplayer.colors.current", {
-    description = "Color of the currently playing song",
-    default = 0xEFEF80, -- #EFEF80
-    type = number
-})
-
-settings.define("mplayer.colors.status", {
-    description = "Color of the statusbar",
-    default = 0x80EF80, -- #80EF80
-    type = number
-})
-
-local tw, th = term.getSize()
-
-os.queueEvent("dummy")
-while tw < 25 or th < 10 do
-    local ev = { os.pullEvent() }
-    term.clear()
-    term.setCursorPos(1, 1)
-    printError("Too small: " .. tw .. "x" .. th .. " < 25x10")
-    printError("Q to exit")
-    printError("Y to ignore")
-
-    local setTextScale = term.current().setTextScale
-    if setTextScale ~= nil then
-        printError("S to try rescaling")
-    end
-    printError("I'll wait while you're adding more")
-
-    if ev[1] == "term_resize" then
-        tw, th = term.getSize()
-    elseif ev[1] == "key" and ev[2] == keys.s and setTextScale ~= nil then
-        setTextScale(0.5)
-    elseif ev[1] == "key" and ev[2] == keys.y then
-        break
-    elseif ev[1] == "key" and ev[2] == keys.q then
-        return
-    end
-end
-
-
-local drive = peripheral.find("tape_drive")
-if not drive then
-    printError("No drive found, starting in dummy mode")
-    local fp = io.open("noita.dfpwm", "rb")
-    if fp == nil then
-        printError("No sample file found, are you running it on a real computer without a tape drive?")
-        return
-    end
-    local size = fp:seek("end", 0)
-    fp:seek("set", 0)
-    drive = {
-        _pos = 0,
-        _fp = fp,
-        _state = "STOPPED",
-        isDummy = true,
-        seek = function(howMuch)
-            drive._pos = math.min(drive.getSize(), math.max(0, drive._pos + howMuch))
-        end,
-        getPosition = function()
-            return drive._pos
-        end,
-        read = function(n)
-            local out = { drive._fp:read(n) }
-            drive.seek(n or 1)
-            return table.unpack(out)
-        end,
-        getSize = function()
-            return size
-        end,
-        getState = function()
-            return drive._state
-        end,
-        play = function()
-            drive._state = "PLAYING"
-        end,
-        stop = function()
-            drive._state = "STOPPED"
-        end,
-        isReady = function()
-            return true
-        end,
-        getLabel = function()
-            return "Dummy drive tape"
-        end,
-        _tick = function()
-            if drive._state == "PLAYING" then
-                drive.read(600)
-            end
-        end,
-    }
-    os.sleep(1)
-end
-
-local function time2str(ti)
-    ti = math.floor(ti)
-    local m, s = math.floor(ti / 60), ti % 60
-    return string.format("%02d:%02d", m, s)
-end
-
-local function read32()
-    local v = 0
-    for i = 1, 4 do
-        local b = string.byte(drive.read(1), 1)
-        v = bit32.bor(bit32.lshift(v, 8), b)
-    end
-    return v
-end
-
-local help = {}
-
-for line in ([[# Movement:
---
-Up k  : Move cursor up
-Dn j  : Move cursor down
-   H  : Jump to top
-   L  : Jump down
-PgUp  : Page up
-PgDn  : Page down
-
-  Tab : Next screen
-S+Tab : Prev. screen
-
-1 F1  : Help screen
-2 F2  : Songs list
-3 F3  : Settings
- 
-# Global:
---
-  s : Stop, jump to start
-  p : Pause/resume
-  < : Next track
-  > : Previous track
-  f : Seek forward
-  b : Seek backward
-\x1b - : Lower volume
-\x1a + : Higher volume
- 
-# List screen:
---
- Enter : Play
-Ctrl+l : Center
-     l : Jump to current
-
-]]):gsub("\\x(..)", function(m)
-    return string.char(tonumber(m, 16))
-end):gmatch("[^\n]+") do
-    table.insert(help, line)
-end
-
-local statusText, statusTicks = nil, 0
-local function setStatus(txt, ticks)
-    statusText, statusTicks = txt, ticks or 10
-end
-
-local mplayer = {
-    colors = {
-        bg = colors.black,
-        fg = colors.white,
-        cursor = colors.blue,
-        current = colors.yellow,
-        status = colors.lime
-    },
-    heldKeys = {},
-    screens = {
-        {
-            title = "Help",
-            scroll = 0,
-            render = function(self)
-                for i = 1, th - 3 do
-                    local line = help[i + self.screens[1].scroll] or "~"
-                    term.setCursorPos(1, i + 1)
-                    term.clearLine()
-                    if line:sub(1, 1) == "~" then
-                        term.setTextColor(self.colors.cursor)
-                    elseif line:sub(1, 1) == "#" then
-                        term.setTextColor(self.colors.current)
-                    elseif line:sub(1, 2) == "--" then
-                        term.setTextColor(self.colors.status)
-                        term.write(("-"):rep(tw - 2))
-                    else
-                        term.setTextColor(self.colors.fg)
-                    end
-                    term.write(line)
-                end
-            end,
-            handleKey = function(self, key, repeating)
-                if key == keys.down or key == keys.j then
-                    self.screens[1].handleScroll(self, 1)
-                elseif key == keys.up or key == keys.k then
-                    self.screens[1].handleScroll(self, -1)
-                elseif key == keys.pageDown then
-                    self.screens[1].handleScroll(self, th - 3)
-                elseif key == keys.pageUp then
-                    self.screens[1].handleScroll(self, -(th - 3))
-                end
-            end,
-            handleScroll = function(self, direction, x, y)
-                self.screens[1].scroll = math.max(0, math.min(th - 1, self.screens[1].scroll + direction))
-            end,
-        },
-        {
-            title = "List",
-            scroll = 0,
-            cursor = 1,
-            textScroll = 0,
-            render = function(self)
-                for i = 1, th - 3 do
-                    local song = self.songs[i + self.screens[2].scroll]
-                    local isCurrent = (i + self.screens[2].scroll) == self.currentSong
-                    local isHovered = (i + self.screens[2].scroll) == self.screens[2].cursor
-                    term.setCursorPos(1, i + 1)
-                    local bg, fg = self.colors.bg, (isCurrent and self.colors.current or self.colors.fg)
-                    if isHovered then bg, fg = fg, bg end
-                    term.setBackgroundColor(bg)
-                    term.setTextColor(fg)
-                    term.clearLine()
-                    if song then
-                        local timeString = " ["..time2str(song.length / 6000) .. "]"
-                        local w = tw - #timeString
-                        if #song.title <= w then
-                            term.write(song.title)
-                        else
-                            local off = isHovered and ((self.screens[2].textScroll % (#song.title + 5)) + 1) or 1
-                            local txt = song.title .. " ::: " .. song.title
-                            term.write(txt:sub(off, off + w - 1))
-                        end
-                        term.setCursorPos(tw - #timeString + 1, i + 1)
-                        term.write(timeString)
-                    end
-                end
-            end,
-            handleKey = function(self, key, repeating)
-                local shiftHeld = self.heldKeys[keys.leftShift] ~= nil or self.heldKeys[keys.rightShift] ~= nil
-                local ctrlHeld = self.heldKeys[keys.leftCtrl] ~= nil or self.heldKeys[keys.rightCtrl] ~= nil
-
-                if key == keys.down or key == keys.j then
-                    self.screens[2].handleScroll(self, 1, 1, 1)
-                elseif key == keys.up or key == keys.k then
-                    self.screens[2].handleScroll(self, -1, 1, 1)
-                elseif key == keys.pageDown then
-                    self.screens[2].handleScroll(self, th - 3, 1, 1)
-                elseif key == keys.pageUp then
-                    self.screens[2].handleScroll(self, -(th - 3), 1, 1)
-                elseif key == keys.h and shiftHeld then
-                    self.screens[2].handleScroll(self, -#self.songs, 1, 1)
-                elseif key == keys.l and shiftHeld then
-                    self.screens[2].handleScroll(self, #self.songs, 1, 1)
-                elseif key == keys.l then
-                    self.screens[2].cursor = self.currentSong or 1
-                    if ctrlHeld then
-                        self.screens[2].scroll = self.screens[2].scroll - math.floor((th - 3) / 2)
-                    end
-                    self.screens[2].handleScroll(self, 0, 1, 1)
-                elseif key == keys.enter then
-                    drive.seek(-drive.getSize())
-                    drive.seek(self.songs[self.screens[2].cursor].offset)
-                    drive.play()
-                    self.currentSong = self.screens[2].cursor
-                end
-            end,
-            handleScroll = function(self, direction, x, y)
-                self.screens[2].cursor = math.max(1, math.min(#self.songs, self.screens[2].cursor + direction))
-                if self.screens[2].scroll + 1 > self.screens[2].cursor then
-                    self.screens[2].scroll = self.screens[2].cursor - 1
-                end
-                local maxi = self.screens[2].scroll + th - 3
-                if self.screens[2].cursor > maxi then
-                    self.screens[2].scroll = self.screens[2].cursor - (th - 3)
-                end
-                if self.screens[2].scroll > #self.songs - (th - 3) then
-                    self.screens[2].scroll = #self.songs - (th - 3)
-                end
-                if self.screens[2].scroll < 0 then
-                    self.screens[2].scroll = 0
-                end
-                self.screens[2].textScroll = 0
-            end,
-            handleClick = function(self, x, y)
-                local i = self.screens[2].scroll + y - 1
-                if i == self.screens[2].cursor then
-                    self.screens[2].handleKey(self, keys.enter, false)
-                elseif i <= #self.songs then
-                    self.screens[2].cursor = i
-                end
-            end,
-        },
-        {
-            title = "Settings",
-            scroll = 0,
-            cursor = 1,
-            render = function(self)
-                term.clear()
-                term.write(string.format("opt = %d, scroll = %d", self.screens[3].cursor, self.screens[3].scroll))
-                term.write(" // TODO")
-            end,
-            handleKey = function(self, key, repeating)
-                if key == keys.down or key == keys.j then
-                    self.screens[3].handleScroll(self, 1)
-                elseif key == keys.up or key == keys.k then
-                    self.screens[3].handleScroll(self, -1)
-                elseif key == keys.pageDown then
-                    self.screens[3].handleScroll(self, th - 3)
-                elseif key == keys.pageUp then
-                    self.screens[3].handleScroll(self, -(th - 3))
-                end
-            end,
-            handleScroll = function(self, direction, x, y)
-                self.screens[3].cursor = math.max(1, math.min(20, self.screens[3].cursor + direction))
-                if self.screens[3].scroll + 1 > self.screens[3].cursor then
-                    self.screens[3].scroll = self.screens[3].cursor - 1
-                end
-                local maxi = self.screens[3].scroll + th - 3
-                if self.screens[3].cursor > maxi then
-                    self.screens[3].scroll = self.screens[3].cursor - (th - 3)
-                end
-            end
-        }
-    },
-    songs = {},
-    currentSong = 0,
-    statusLineScroll = 0,
-    currentScreen = 2,
-}
-
-for k, v in pairs(mplayer.colors) do
-    term.setPaletteColor(v, settings.get("mplayer.colors." .. k))
-end
-term.setCursorPos(1, 1)
-term.setBackgroundColor(mplayer.colors.bg)
-term.setTextColor(mplayer.colors.fg)
-term.clear()
-
-
-local spinner = {
-    "\x81", "\x83", "\x82",
-    "\x8a", "\x88", "\x8c",
-    "\x84", "\x85"
-}
-
-parallel.waitForAny(
-function()
-    while true do
-        -- Current screen
-        term.setCursorPos(1, 2)
-        mplayer.screens[mplayer.currentScreen].render(mplayer)
-
-        -- Top bar
-        term.setCursorPos(1, 1)
-        for i, screen in ipairs(mplayer.screens) do
-            term.setTextColor(mplayer.colors[i == mplayer.currentScreen and "bg" or "fg"])
-            term.setBackgroundColor(mplayer.colors[i == mplayer.currentScreen and "fg" or "bg"])
-            term.write(" "..i..":"..screen.title.." ")
-        end
-
-        term.setBackgroundColor(mplayer.colors.bg)
-
-        local title, time, duration = "Whatever is on the tape", drive.getPosition() / 6000, drive.getSize() / 6000
-        if mplayer.currentSong ~= 0 then
-            local song = mplayer.songs[mplayer.currentSong]
-            time = (drive.getPosition() - song.offset) / 6000
-            duration = song.length / 6000
-            title = song.title
-        end
-
-        -- Progressbar
-        local lw = math.floor(tw * time / duration)
-        term.setCursorPos(1, th - 1)
-        term.setTextColor(mplayer.colors.current)
-        term.clearLine()
-        term.write(string.rep("=", lw))
-        term.write("\x10")
-        term.setTextColor(mplayer.colors.cursor)
-        term.write(string.rep("\xad", tw - lw - 1))
-
-        local timeString = string.format("[%s:%s]", time2str(time), time2str(duration))
-
-        term.setCursorPos(1, th)
-        term.clearLine()
-        if statusTicks > 0 then
-            term.setTextColor(colors.red)
-            term.write(statusText)
-            statusTicks = statusTicks - 1
-        end
-
-        if drive.getState() ~= "STOPPED" then
-            term.setTextColor(mplayer.colors.status)
-
-            if statusTicks <= 0 then
-                local speen = spinner[(math.floor(drive.getPosition() / 3000) % #spinner) + 1]
-                local action = ""
-                if drive.getState() == "PLAYING" then action = "Playing:"
-                elseif drive.getState() == "REWINDING" then action = "Rewinding"
-                elseif drive.getState() == "FORWARDING" then action = "Forwarding"
-                else
-                    printError("Unknown drive state: "..tostring(drive.getState()))
-                    return
-                end
-                action = speen .. " " .. action
-
-                term.write(action)
-
-                -- Statusline text
-                term.setCursorPos(#action + 2, th)
-                local w = tw - #timeString - #action - 2 -- "Playing: ", spinner plus spacing
-
-                term.setTextColor(mplayer.colors.current)
-                if #title <= w then
-                    term.write(title)
-                else
-                    local off = (mplayer.statusLineScroll % (#title + 5)) + 1
-                    local txt = title .. " ::: " .. title
-                    term.write(txt:sub(off, off + w - 1))
-                end
-            end
-        end
-        if statusTicks <= 0 then
-            term.setTextColor(mplayer.colors.status)
-            term.setCursorPos(tw - #timeString + 1, th)
-            term.write(timeString)
-        end
-        os.sleep(0.1)
-    end
-end,
-function()
-    local pretty = require("cc.pretty")
-    while true do
-        local _evd = { os.pullEvent() }
-        local ev, evd = table.remove(_evd, 1), _evd
-        if ev == "key" then
-            mplayer.heldKeys[evd[1]] = evd[2]
-        elseif ev == "key_up" then
-            mplayer.heldKeys[evd[1]] = nil
-        end
-
-        local shiftHeld = mplayer.heldKeys[keys.leftShift] ~= nil or mplayer.heldKeys[keys.rightShift] ~= nil
-        local ctrlHeld = mplayer.heldKeys[keys.leftCtrl] ~= nil or mplayer.heldKeys[keys.rightCtrl] ~= nil
-
-        if ev == "key_up" and evd[1] == keys.q then
-            break
-        elseif ev == "key" and (evd[1] == keys.one or evd[1] == keys.f1) then
-            mplayer.currentScreen = 1
-        elseif ev == "key" and (evd[1] == keys.two or evd[1] == keys.f2) then
-            mplayer.currentScreen = 2
-        elseif ev == "key" and (evd[1] == keys.three or evd[1] == keys.f3) then
-            mplayer.currentScreen = 3
-        elseif ev == "key" and evd[1] == keys.f then
-            drive.seek(3000)
-        elseif ev == "key" and evd[1] == keys.b then
-            drive.seek(-3000)
-        elseif ev == "key" and (evd[1] == keys.comma or evd[1] == keys.period) and shiftHeld then
-            setStatus("Not implemented yet!", 20)
-        elseif ev == "key" and evd[1] == keys.left or evd[1] == keys.right or evd[1] == keys.minus or (evd[1] == keys.equals and shiftHeld) then
-            setStatus("Not implemented yet!", 20)
-        elseif ev == "key" and evd[1] == keys.s then
-            drive.stop()
-            drive.seek(-drive.getSize())
-            drive.seek(6000)
-        elseif ev == "key" and (evd[1] == keys.p or evd[1] == keys.space) then
-            if drive.getState() ~= "STOPPED" then
-                drive.stop()
-            else
-                drive.play()
-            end
-        elseif ev == "key" and evd[1] == keys.tab then
-            local dir = ((mplayer.heldKeys[keys.leftShift] ~= nil) or (mplayer.heldKeys[keys.rightShift] ~= nil)) and -1 or 1
-            mplayer.currentScreen = ((mplayer.currentScreen - 1 + #mplayer.screens + dir)) % #mplayer.screens + 1
-        elseif ev == "key" then
-            mplayer.screens[mplayer.currentScreen].handleKey(mplayer, evd[1], evd[2])
-        elseif ev == "mouse_scroll" then
-            local dir, x, y = table.unpack(evd)
-            mplayer.screens[mplayer.currentScreen].handleScroll(mplayer, dir, x, y)
-        elseif ev == "song_change" then
-            mplayer.statusLineScroll = 0
-        elseif (ev == "mouse_click" or ev == "mouse_drag") and evd[3] == th - 1 then
-            local p = (evd[2] - 1) / tw
-            local song = mplayer.songs[mplayer.currentSong]
-            drive.seek(-drive.getSize())
-            if song ~= nil then
-                drive.seek(song.offset + math.floor(song.length * p))
-            else
-                drive.seek(math.floor(p * drive.getSize()))
-            end
-        elseif (ev == "mouse_click" or ev == "mouse_drag") and evd[3] == 1 then
-            local cx, x = 1, evd[2]
-            for i, screen in ipairs(mplayer.screens) do
-                local caption = " "..i..""..screen.title.." "
-                if x >= cx and x <= (cx + #caption) then
-                    mplayer.currentScreen = i
-                    break
-                end
-                cx = cx + #caption
-            end
-        elseif ev == "mouse_click" or ev == "mouse_drag" then
-            if mplayer.screens[mplayer.currentScreen].handleClick then
-                local butt, x, y = table.unpack(evd)
-                mplayer.screens[mplayer.currentScreen].handleClick(mplayer, x, y)
-            end
-        elseif ev == "term_resize" then
-            tw, th = term.getSize()
-        elseif ev == "tape_removed" then
-            mplayer.songs = {}
-            mplayer.currentSong = 0
-        elseif ev == "tape_inserted" then
-            local seekToAndPlay = nil
-            if drive.getState() == "PLAYING" then
-                seekToAndPlay = drive.getPosition()
-            end
-
-            drive.stop()
-            drive.seek(-drive.getSize())
-            for i = 1, 48 do
-                local offset = read32()
-                local length = read32()
-                local title = drive.read(117)
-                if offset > drive.getSize() or length > drive.getSize() then
-                    mplayer.songs = {
-                        {
-                            title = "NOTE: It's just a regular tape",
-                            offset = drive.getSize() - 10,
-                            length = 10
-                        },
-                        {
-                            title = drive.getLabel(),
-                            offset = 0,
-                            length = drive.getSize() - 10
-                        }
-                    }
-                    for t = 1, drive.getSize(), 6000 * 60 * 5 do
-                        table.insert(mplayer.songs, {
-                            title = "Skip to " .. time2str(t / 6000),
-                            offset = t,
-                            length = 6000 * 60 * 5
-                        })
-                    end
-                    break
-                end
-                title = title:sub(1, title:find("\x00"))
-                if length > 0 and offset > 0 then
-                    mplayer.songs[i] = {
-                        title = title,
-                        offset = offset,
-                        length = length
-                    }
-                end
-            end
-
-            if seekToAndPlay ~= nil then
-                drive.seek(-drive.getSize())
-                drive.seek(seekToAndPlay)
-                drive.play()
-            end
-        elseif ev ~= "timer" then
-            if drive.isDummy then
-                local m = term.redirect(peripheral.wrap("right"))
-                io.write(ev .. " ")
-                pretty.print(pretty.pretty(evd))
-                term.redirect(m)
-            end
-        end
-    end
-end,
-function()
-    while true do
-        mplayer.statusLineScroll = mplayer.statusLineScroll + 1
-        mplayer.screens[2].textScroll = mplayer.screens[2].textScroll + 1
-        os.sleep(0.25)
-    end
-end,
-function()
-    local oldSong = nil
-    local oldDriveState = nil
-    local oldTapeState = nil
-    while true do
-        mplayer.currentSong = 0
-        if drive._tick then drive._tick() end -- dummy mode
-
-        local tapeState = drive.isReady()
-        if tapeState ~= oldTapeState then
-            os.queueEvent(tapeState and "tape_inserted" or "tape_removed")
-            oldTapeState = tapeState
-        end
-
-        local driveState = drive.getState()
-        if driveState ~= oldDriveState then
-            os.queueEvent("drive_state", driveState)
-            oldDriveState = driveState
-        end
-
-        local pos = drive.getPosition()
-        for i, song in ipairs(mplayer.songs) do
-            if pos >= song.offset and pos < (song.offset + song.length) then
-                mplayer.currentSong = i
-            end
-        end
-
-        if oldSong ~= mplayer.currentSong then
-            os.queueEvent("song_change")
-            oldSong = mplayer.currentSong
-        end
-
-        os.sleep(0.1)
-    end
-end
-)
-
--- cleanup
-term.clear()
-term.setCursorPos(1, 1)
-for i = 1, 16 do
-    local c = math.pow(2, i - 1)
-    term.setPaletteColor(c, term.nativePaletteColor(c))
-end
-term.setBackgroundColor(colors.black)
-term.setTextColor(colors.white)
-if term.current().setTextScale then
-    term.current().setTextScale(1.0)
-end
-print("<tmpc> Goodbye!")

nfpview.py

@@ -1,62 +0,0 @@
-#!/usr/bin/env python3
-from argparse import ArgumentParser
-
-colors = {
-  "0": (240, 240, 240),
-  "1": (242, 178,  51),
-  "2": (229, 127, 216),
-  "3": (153, 178, 242),
-  "4": (222, 222, 108),
-  "5": (127, 204,  25),
-  "6": (242, 178, 204),
-  "7": ( 76,  76,  76),
-  "8": (153, 153, 153),
-  "9": ( 76, 153, 178),
-  "a": (178, 102, 229),
-  "b": ( 51, 102, 204),
-  "c": (127, 102,  76),
-  "d": ( 87, 166,  78),
-  "e": (204,  76,  76),
-  "f": ( 17,  17,  17),
-}
-
-color_names = {
-  "0": "white",
-  "1": "orange",
-  "2": "magenta",
-  "3": "lightBlue",
-  "4": "yellow",
-  "5": "lime",
-  "6": "pink",
-  "7": "gray",
-  "8": "lightGray",
-  "9": "cyan",
-  "a": "purple",
-  "b": "blue",
-  "c": "brown",
-  "d": "green",
-  "e": "red",
-  "f": "black",
-}
-
-parser = ArgumentParser(description="CC default image viewer")
-parser.add_argument("filename")
-
-def color(v: str):
-    return tuple(bytes.fromhex(v.lstrip('#')))
-
-
-for k, (r, g, b) in colors.items():
-    parser.add_argument(f"-{k}", type=color, default=(r, g, b),
-                        help="Set color %s" % color_names[k])
-
-args = parser.parse_args()
-
-with open(args.filename, "r") as fp:
-    for line in fp:
-        for char in line.rstrip():
-            if char in colors:
-                print("\x1b[48;2;%d;%d;%dm \x1b[0m" % colors[char], end="")
-            else:
-                print(" ", end="")
-        print()

obcb-cc.lua

@@ -1,99 +0,0 @@
-
-local ws = assert(http.websocket("wss://bitmap-ws.alula.me/"))
-
-function parse_u16(data)
-    local v = table.remove(data, 1)
-    v = bit.bor(v, bit.blshift(table.remove(data, 1), 8))
-    return v, data
-end
-
-function parse_u32(data)
-    local v = table.remove(data, 1)
-    v = bit.bor(v, bit.blshift(table.remove(data, 1), 8))
-    v = bit.bor(v, bit.blshift(table.remove(data, 1), 16))
-    v = bit.bor(v, bit.blshift(table.remove(data, 1), 24))
-    return v, data
-end
-
-local chunk_id = 421
-local chunk_state = { 0x48, 0x65, 0x6c, 0x6c, 0x6f }
-
-local function send_chunk_request(chunk)
-    ws.send(string.char(0x10, bit.band(chunk, 0xFF), bit.band(bit.brshift(chunk, 8), 0xFF)), true)
-end
-
-local function send_chunk_subscribe_request(chunk)
-    ws.send(string.char(0x14, bit.band(chunk, 0xFF), bit.band(bit.brshift(chunk, 8), 0xFF)), true)
-end
-
-parallel.waitForAll(function()
-    while true do
-        local data, is_binary = ws.receive()
-        data = { string.byte(data, 1, #data) }
-        local opcode = table.remove(data, 1)
-        if opcode == 0x00 then -- hello
-            ver_major, data = parse_u16(data)
-            ver_minor, data = parse_u16(data)
-            os.queueEvent("obcb:hello", ver_major, ver_minor)
-        elseif opcode == 0x01 then
-            local clients = parse_u32(data)
-            -- TODO: show them somewhere
-            os.queueEvent("obcb:clients", clients)
-        elseif opcode == 0x11 then
-            chunk_index, data = parse_u16(data)
-            if chunk_index == chunk_id then
-                chunk_state = data
-            end
-            os.queueEvent("obcb:update")
-        elseif opcode == 0x12 then
-            offset, chunk = parse_u32(data)
-            local c_id = math.floor(offset / 32768)
-            local b_off = offset % 32768
-            for i = 1, 32 do
-                chunk_state[i + b_off] = chunk[i]
-            end
-            os.queueEvent("obcb:update")
-        else
-            print(table.unpack(data))
-        end
-    end
-end,
-function()
-    local mon = peripheral.wrap("monitor_0")
-    mon.setTextScale(0.5)
-    mon.clear()
-    local tw, th = term.getSize()
-    send_chunk_request(chunk_id)
-    send_chunk_subscribe_request(chunk_id)
-    term.setCursorPos(1, 3)
-    print("Showing chunk " .. chunk_id)
-    print(string.format("Screen: %dx%d", mon.getSize()))
-    while true do
-        local ev = { os.pullEvent() }
-        if ev[1] == "char" and ev[2] == "q" then
-            break
-        elseif ev[1] == "obcb:hello" then
-            term.setCursorPos(1, 1)
-            print(string.format("Hello: obcb v%d.%d", ev[2], ev[3]))
-        elseif ev[1] == "obcb:clients" then
-            term.setCursorPos(1, 2)
-            print("Clients: " .. ev[2])
-        elseif ev[1] == "obcb:update" then
-            for y = 1, 81 do
-                mon.setCursorPos(1, y)
-                local tx = {}
-                local bg = {}
-                local fg = {}
-                for x = 1, 164 do
-                    local i = (y - 1) * 164 + (x - 1)
-                    tx[x] = chunk_state[i * 2 + 1]
-                    fg[x] = string.format("%x", bit.band(chunk_state[i * 2 + 2], 0xF))
-                    bg[x] = string.format("%x", bit.band(bit.brshift(chunk_state[i * 2 + 2], 4), 0xF))
-                end
-                mon.blit(string.char(table.unpack(tx)), table.concat(bg), table.concat(fg))
-            end
-        end
-    end
-end)
-
-ws.close()

runonchange.lua

@@ -1,43 +0,0 @@
-local args = { ... }
-
-local modtimes = {}
-
-if #args == 0 then
-    print("usage: runonchange [files to watch ...] -- program [args...]")
-    return
-end
-
-while #args > 0 do
-    local name = table.remove(args, 1)
-    if name == "--" then break end
-    modtimes[name] = -1
-end
-
-if #args == 0 then
-    printError("No executable was given")
-    return
-end
-
-local curdir = shell.dir()
-
-while true do
-    local shall_run = false
-    for name, modtime in pairs(modtimes) do
-        local path = name:sub(1,1) == "/" and name or (curdir .. "/" .. name)
-        local modtime_new = fs.attributes(path).modified
-        if modtime_new ~= modtime then
-            shall_run = true
-            modtimes[name] = modtime_new
-            print(name .. " was modified")
-        end
-    end
-    if shall_run then
-        local succ, err = pcall(shell.run, table.unpack(args))
-        if succ then
-            print("Process finished successfully")
-        else
-            printError("Process crashed: " .. err)
-        end
-    end
-    os.sleep(0.5)
-end

stream.lua

@@ -1,6 +1,6 @@
 local args = { ... }
 
-local dfpwm = require("cc.audio.dfpwm")
+local buffer_size = 8192
 
 if not http then
     print("no http, check config")
@@ -21,35 +21,21 @@ if not req then
     return
 end
 
-local headers = req.getResponseHeaders()
+local buffer = { }
-local length = tonumber(headers["Content-Length"]) or 0
+for i = 1, buffer_size do
-
+    buffer[i] = 0
-local function decode_s8(data)
-    local buffer = {}
-    for i = 1, #data do
-        local v = string.byte(data, i)
-        if bit32.band(v, 0x80) then
-            v = bit32.bxor(v, 0x7F) - 128
-        end
-        buffer[i] = v
-    end
-    return buffer
 end
 
-local use_dfpwm = ({ args[1]:find("%.dfpwm") })[2] == #args[1]
-
-local decode = use_dfpwm and dfpwm.make_decoder() or decode_s8
-local read_bytes = 0
 while true do
-    local chunk = req.read(16384)
+    local chunk = req.read(buffer_size)
     if not chunk then
         break
     end
-
+    buffer = {}
-    local buffer = decode(chunk)
+    for i = 1, #chunk do
+        buffer[i] = string.byte(chunk, i) - 128
+    end
     while not speaker.playAudio(buffer) do
         os.pullEvent("speaker_audio_empty")
     end
 end
-
-print()

tape-playlist.lua

@@ -1,143 +0,0 @@
-local drive = peripheral.find("tape_drive")
-if not drive then
-    printError("no tape drive found")
-    printError("it's kinda required to play tapes, you know?")
-    return
-end
-
-local running = true
-
-term.setBackgroundColor(colors.black)
-term.clear()
-local screen_w, screen_h = term.getSize()
-local table_of_contents = {}
-
-
-local function read32()
-    local v = 0
-    for i = 1, 4 do
-        local b = drive.read()
-        v = bit32.bor(bit32.lshift(v, 8), b)
-    end
-    return v
-end
-
-local function bytes2time(b)
-    local s = math.floor(b / 6000)
-    if s < 60 then return string.format("%ds", s) end
-    return string.format("%dm, %ds", math.floor(s / 60), s % 60)
-end
-
-local function textProgress(p, c1, c2, fmt, ...)
-    local tw = term.getSize()
-    local str = string.format(fmt, ...)
-    local w1 = math.ceil(p * tw)
-    local w2 = tw - w1
-
-    local bg = term.getBackgroundColor()
-
-    term.setBackgroundColor(c1)
-    term.write(str:sub(1, w1))
-    local rem = w1 - #str
-    if rem > 0 then
-        term.write(string.rep(" ", rem))
-    end
-
-    term.setBackgroundColor(c2)
-    term.write(str:sub(w1 + 1, w1 + w2))
-
-    rem = math.min(tw - #str, w2)
-    if rem > 0 then
-        term.write(string.rep(" ", rem))
-    end
-
-    term.setBackgroundColor(bg)
-end
-
-
-parallel.waitForAll(
-function()
-    while running do
-        if drive.isReady() then
-            local pos, size = drive.getPosition(), drive.getSize()
-            for i = 1, math.min(screen_h - 2, 48) do
-                term.setCursorPos(1, i)
-                local song = table_of_contents[i]
-                if song then
-                    local is_playing = pos >= song.offset and pos < song.ending
-                    local s = string.format("#%2d %9s %s", i, bytes2time(song.length), song.title)
-                    if is_playing then
-                        local p = (pos - song.offset) / song.length
-                        textProgress(p, colors.lime, colors.lightGray, s)
-                    else
-                        term.setBackgroundColor(i % 2 == 0 and colors.gray or colors.black)
-                        term.clearLine()
-                        term.write(s)
-                    end
-                end
-            end
-
-            term.setCursorPos(1, screen_h)
-            textProgress(pos / size, colors.red, colors.gray, "%8d / %8d [%s]", pos, size, drive.getState())
-        end
-        os.sleep(0.1)
-    end
-end,
-function()
-    while running do
-        local evd = { os.pullEvent() }
-        local ev, evd = table.remove(evd, 1), evd
-
-        if ev == "mouse_click" then
-            local x, y = table.unpack(evd, 2)
-            if drive.isReady() and y <= #table_of_contents then
-                drive.seek(-drive.getSize())
-                drive.seek(table_of_contents[y].offset)
-                drive.play()
-            end
-        elseif ev == "term_resize" then
-            term.setBackgroundColor(colors.black)
-            term.clear()
-            screen_w, screen_h = term.getSize()
-        elseif ev == "tape_present" then
-            table_of_contents = {}
-            term.clear()
-            if evd[1] then
-                drive.stop()
-                drive.seek(-drive.getSize())
-                for i = 1, 48 do
-                    local offset = read32()
-                    local length = read32()
-                    local title = drive.read(117):gsub("\x00", "")
-                    if length > 0 then
-                        table.insert(table_of_contents, {
-                            title = title,
-                            offset = offset,
-                            length = length,
-                            ending = offset + length
-                        })
-                    end
-                end
-            end
-        end
-    end
-end,
-function()
-    local tape_was_present = nil
-    local drive_old_state = nil
-    while running do
-        local tape_present = drive.isReady()
-        if tape_present ~= tape_was_present then
-            os.queueEvent("tape_present", tape_present)
-            tape_was_present = tape_present
-        end
-
-        local drive_state = drive.getState()
-        if drive_old_state ~= drive_state then
-            os.queueEvent("drive_state", drive_state)
-            drive_old_state = drive_state
-        end
-
-        os.sleep(0.25)
-    end
-end)

tape-playlist.py

@@ -1,82 +0,0 @@
-#!/usr/bin/env python3
-# x-run: python3 % /mnt/windows/Users/user/Music/vgm/night-in-the-woods/2014-lost-constellation /tmp/lost-constellation.dfpwm
-
-from tempfile import TemporaryDirectory
-from subprocess import Popen, PIPE
-from sys import argv
-from pathlib import Path
-from os.path import splitext
-from math import ceil
-from re import search
-
-DFPWM_ENCODER_EXECUTABLE = "aucmp"
-FFMPEG_EXECUTABLE = "ffmpeg"
-FFPROBE_EXECUTABLE = "ffprobe"
-
-DFPWM_SAMPLE_RATE = 6000
-
-TAPE_SIZES = [ 2, 4, 8, 16, 32, 64, 128 ]
-
-input_folder = Path(argv[1])
-output_file = Path(argv[2])
-
-with TemporaryDirectory(prefix="tapedrive") as tmpdir_str:
-    tmpdir = Path(tmpdir_str)
-
-    filelist: list[Path] = []
-    titles: list[bytes] = []
-    for i, name in enumerate(input_folder.rglob("*.mp3")):
-        if i >= 48:
-            print(f"more than 48 tracks, skipping {name}")
-            continue
-        encoded_file = tmpdir / (splitext(name.name)[0] + ".dfpwm")
-        filelist.append(encoded_file)
-        with encoded_file.open("wb") as fout:
-            with Popen([ FFPROBE_EXECUTABLE, name ], stderr=PIPE) as ffprobe:
-                metadata: str = ffprobe.stderr.read().decode()  # type: ignore
-                if (match := search(r"title\s+: (.*)", metadata)):
-                    titles.append(match.groups()[0].encode("ascii", errors="ignore"))
-                else:
-                    titles.append(splitext(name.name)[0].encode("ascii", errors="ignore"))
-            with Popen([ DFPWM_ENCODER_EXECUTABLE ], stdout=fout, stdin=PIPE) as dfpwm:
-                with Popen([ FFMPEG_EXECUTABLE, "-i", name, "-f", "s8", "-ac", "1",
-                            "-ar", "48k", "-" ], stdout=dfpwm.stdin) as ffmpeg:
-                    ffmpeg.wait()
-
-    offset: int = 6000
-    positions: list[tuple[int, int]] = []
-    for file in filelist:
-        size = ceil(file.stat().st_size / DFPWM_SAMPLE_RATE) * DFPWM_SAMPLE_RATE
-        positions.append((offset, size))
-        offset += size
-
-    with output_file.open("wb") as fout:
-        print("Writing header...")
-        written_bytes: int = 0
-        for i in range(48):
-            name = (titles[i] if i < len(titles) else b"")[:117]
-            pos = positions[i] if i < len(titles) else (0, 0)
-            if i < len(titles):
-                print(f"{i:2d} {pos[0]} + {pos[1]} {name}")
-            written_bytes += fout.write(pos[0].to_bytes(4, "big"))
-            written_bytes += fout.write(pos[1].to_bytes(4, "big"))
-            written_bytes += fout.write(name)
-            written_bytes += fout.write(b"\x00" * (117 - len(name)))
-        if written_bytes != 6000:
-            print(f"!!! expected 6000 bytes to be written in header, but it's {written_bytes}")
-
-        print("Writing files...")
-        for i, (pos, file) in enumerate(zip(positions, filelist)):
-            print(f"Writing {file.name}")
-            if written_bytes != pos[0]:
-                print(f"!!! expected to be at {pos[0]}, rn at {written_bytes}")
-            with file.open("rb") as fin:
-                file_size: int = 0
-                while (chunk := fin.read(DFPWM_SAMPLE_RATE)):
-                    file_size += fout.write(chunk)
-                written_bytes += file_size
-                padding_size = DFPWM_SAMPLE_RATE - (written_bytes % DFPWM_SAMPLE_RATE)
-                written_bytes += fout.write(b"\x00" * padding_size)
-        print("Use any of those tapes to store properly:")
-        for size in filter(lambda sz: sz * DFPWM_SAMPLE_RATE * 60 >= written_bytes, TAPE_SIZES):
-            print(f"{size} minutes ({size * DFPWM_SAMPLE_RATE * 60} bytes, {written_bytes * 100 / (size * DFPWM_SAMPLE_RATE * 60):7.3f}% used)")

tape-rip.lua

@@ -1,91 +0,0 @@
-local args = { ... }
-
-if #args == 0 then
-    print("Usage: tape-rip [-S] [source-drive] [dst-drive]")
-    print("  -S    don't seek to the beginning of destination drive")
-end
-
-local seekToStart = true
-if args[1] == "-S" then
-    seekToStart= false
-    table.remove(args, 1)
-end
-
-local function textProgress(p, c1, c2, fmt, ...)
-    p = math.min(p, 1)
-    local tw = term.getSize()
-    local str = string.format(fmt, ...)
-    local w1 = math.ceil(p * tw)
-    local w2 = tw - w1
-
-    local bg = term.getBackgroundColor()
-
-    term.setBackgroundColor(c1)
-    term.write(str:sub(1, w1))
-    local rem = w1 - #str
-    if rem > 0 then
-        term.write(string.rep(" ", rem))
-    end
-
-    term.setBackgroundColor(c2)
-    term.write(str:sub(w1 + 1, w1 + w2))
-
-    rem = math.min(tw - #str, w2)
-    if rem > 0 then
-        term.write(string.rep(" ", rem))
-    end
-
-    term.setBackgroundColor(bg)
-end
-
-local src = peripheral.wrap(args[1])
-local dst = peripheral.wrap(args[2])
-
-local failure = false
-if not src then
-    printError("Source drive not found")
-    failure = true
-end
-
-if not dst then
-    printError("Destination drive not found")
-    failure = true
-end
-
-if src and not src.isReady() then
-    printError("Source drive is empty")
-    failure = true
-end
-
-if dst and not dst.isReady() then
-    printError("Destination drive is empty")
-    failure = true
-end
-
-if failure then
-    printError("Some errors occurred, exiting")
-    return
-end
-
-src.seek(-src.getSize())
-if seekToStart then
-    dst.seek(-dst.getSize())
-end
-
-local _, y = term.getCursorPos()
-local i = 0
-while not src.isEnd() do
-    dst.write(src.read(6000 * 30))
-    local pos, sz = src.getPosition(), src.getSize()
-    term.setCursorPos(1, y)
-    term.clearLine()
-    if (i % 256) == 0 then
-        textProgress(pos / sz, colors.green, colors.gray, "%7.3f%% %8d / %8d", pos * 100 / sz, pos, sz)
-        os.sleep(0.01)
-    end
-    i = i + 1
-end
-
-local pos, sz = src.getPosition(), src.getSize()
-textProgress(pos / sz, colors.green, colors.gray, "%7.3f%% %8d / %8d", pos * 100 / sz, pos, sz)
-print()

tapeget.lua

@@ -1,70 +1,9 @@
 local args = { ... }
 
-local seekTo = 0
+local tape = peripheral.find("tape_drive")
-local driveName = nil
+if not tape then
-if args[1] == "-S" then
+    print("tape where")
-    table.remove(args, 1)
-    seekTo = tonumber(table.remove(args, 1))
-end
-if args[1] == "-D" then
-    table.remove(args, 1)
-    driveName = table.remove(args, 1)
-end
-
-local function n_to_kib(value)
-    return string.format("%6.1f kiB", value / 1024)
-end
-
-local function textProgress(p, c1, c2, fmt, ...)
-    p = math.min(p, 1)
-    local tw = term.getSize()
-    local str = string.format(fmt, ...)
-    local w1 = math.ceil(p * tw)
-    local w2 = tw - w1
-
-    local bg = term.getBackgroundColor()
-
-    term.setBackgroundColor(c1)
-    term.write(str:sub(1, w1))
-    local rem = w1 - #str
-    if rem > 0 then
-        term.write(string.rep(" ", rem))
-    end
-
-    term.setBackgroundColor(c2)
-    term.write(str:sub(w1 + 1, w1 + w2))
-
-    rem = math.min(tw - #str, w2)
-    if rem > 0 then
-        term.write(string.rep(" ", rem))
-    end
-
-    term.setBackgroundColor(bg)
-end
-
-local tape
-if driveName ~= nil then
-    tape = peripheral.wrap(driveName)
-else
-    local drives = { peripheral.find("tape_drive") }
-    if #drives == 0 then
-        print("Drive where")
     return
-    elseif #drives ~= 1 then
-        print("More than one drive found:")
-        for i = 1, #drives do
-            print(peripheral.getName(drives[i]))
-        end
-        print("Input drive name:")
-        io.write("> ")
-        tape = peripheral.wrap(read())
-        if not tape then
-            printError("wrong name")
-            return
-        end
-    else
-        tape = drives[1]
-    end
 end
 
 if not http then
@@ -72,52 +11,39 @@ if not http then
     return
 end
 
-local req, err = http.get(args[1], {}, true)
+tape.stop()
+tape.seek(-tape.getSize())
+tape.stop()
+
+local req = http.get(args[1], {}, true)
 if not req then
-    print("oopsie: "..err)
+    print("oopsie")
     return
 end
 
 local headers = req.getResponseHeaders()
-local length = tonumber(headers["content-length"]) or 1
+local length = headers["content-length"]
 
-if length > tape.getSize() then
+local function n_to_kib(value)
-    printError("Tape is smaller than the file you're trying to write")
+    return string.format("%6.1f kiB", value / 1024)
-    printError("Are you sure?")
-
-    io.write("Write anyways? [y/N]: ")
-    local r = read()
-    if r ~= "y" and r ~= "Y" then
-        return
-    end
 end
 
-tape.stop()
+local written = 1
-tape.seek(-tape.getSize())
-tape.seek(seekTo)
-tape.stop()
-
 local _, y = term.getCursorPos()
-local written = 0
-
-local i = 1
 while true do
-    local chunk = req.read(256)
+    local chunk = req.read()
     if not chunk then
+        print("EOF")
         break
     end
-    written = written + #chunk
     tape.write(chunk)
-    if i % 10 == 0 then
+    written = written + 1
-        term.setCursorPos(1, y)
+    if (written % 8192) == 0 then
-        term.clearLine()
-        textProgress(written / length, colors.green, colors.gray, "%s / %s", n_to_kib(written), n_to_kib(length))
         os.sleep(0.01)
+        term.setCursorPos(1, y)
+        term.write(n_to_kib(written) .. " / " .. n_to_kib(length) .. string.format(" %7.3f%%", 100 * written / length))
     end
 end
-term.setCursorPos(1, y)
-term.clearLine()
-print("Written "..n_to_kib(written))
 
 tape.stop()
 tape.seek(-tape.getSize())

turtos/ctrl.lua

@@ -1,71 +0,0 @@
-local wlan = peripheral.find("modem", function(addr, modem)
-    return modem.isWireless()
-end)
-
-if not wlan then error("no wireless interface") end
-
-wlan.open(9998)
-
-local respondedTurtles = {}
-local keyStates = {}
-
-parallel.waitForAny(
-function()
-    while true do
-        local ev, keycode, repeating = os.pullEvent()
-        if ev == "key" then keyStates[keycode] = true
-        elseif ev == "key_up" then keyStates[keycode] = false
-        end
-
-        if ev == "key" and not repeating then
-            if keycode == keys.up then
-                wlan.transmit(9999, 9998, { _ = "move", dir = "fwd", dig = keyStates[keys.leftShift] })
-            elseif keycode == keys.down then
-                wlan.transmit(9999, 9998, { _ = "move", dir = "bck" })
-            elseif keycode == keys.left then
-                wlan.transmit(9999, 9998, { _ = "move", dir = "rotl" })
-            elseif keycode == keys.right then
-                wlan.transmit(9999, 9998, { _ = "move", dir = "rotr" })
-            elseif keycode == keys.pageUp then
-                wlan.transmit(9999, 9998, { _ = "move", dir = "up", dig = keyStates[keys.leftShift] })
-            elseif keycode == keys.pageDown then
-                wlan.transmit(9999, 9998, { _ = "move", dir = "down", dig = keyStates[keys.leftShift] })
-            end
-        end
-    end
-end,
-
-function()
-    while true do
-        local _, side, chan, rchan, data, dist = os.pullEvent("modem_message")
-        if chan == 9998 and rchan == 9999 then
-            if data._ == "WakeUp" then
-                respondedTurtles[data.from] = { true, "Hello!" }
-            elseif data._ == "Ack" then
-                respondedTurtles[data.from] = { true, "Got it" }
-            elseif data._ == "Error" then
-                respondedTurtles[data.from] = { false, data.error }
-            elseif data._ == "Result" then
-                respondedTurtles[data.from] = { true, data.out}
-            end
-        end
-    end
-end,
-
-function()
-    while true do
-        os.pullEvent()
-        term.clear()
-        local i = 1
-        for id, res in pairs(respondedTurtles) do
-            term.setCursorPos(1, i)
-            term.write(string.format("%5d => ", id))
-            term.setTextColor(res[1] and colors.green or colors.red)
-            term.write(res[1] and "OK " or "ER ")
-            term.write(tostring(res[2]))
-            term.setTextColor(colors.white)
-            i = i + 1
-        end
-    end
-end
-)

turtos/main.lua

@@ -1,60 +0,0 @@
-local wlan = peripheral.find("modem", function(addr, modem)
-    return modem.isWireless()
-end)
-
-if not wlan then error("no wireless interface") end
-
-wlan.open(9999)
-
-local ID = os.getComputerID()
-
-wlan.transmit(9998, 9999, {
-    ["_"] = "WakeUp",
-    ["from"] = ID
-})
-
-parallel.waitForAll(function()
-    while true do
-        local _, side, chan, rchan, data, dist = os.pullEvent("modem_message")
-        if chan == 9999 and rchan == 9998 then
-            if data._ == "move" then
-                wlan.transmit(rchan, chan, { ["_"] = "Ack", ["from"] = ID })
-                if data.tgt == nil or data.tgt == ID then
-                    local out = { false, "Invalid direction: " .. data.dir }
-                    if data.dig then
-                        if data.dir == "fwd" and turtle.detect() then turtle.dig()
-                        elseif data.dir == "down" and turtle.detectDown() then turtle.digDown()
-                        elseif data.dir == "up" and turtle.detectUp() then turtle.digUp()
-                        end
-                    end
-                    if     data.dir == "fwd"  then out = { turtle.forward() }
-                    elseif data.dir == "bck"  then out = { turtle.back() }
-                    elseif data.dir == "up"   then out = { turtle.up() }
-                    elseif data.dir == "down" then out = { turtle.down() }
-                    elseif data.dir == "rotl" then out = { turtle.turnLeft() }
-                    elseif data.dir == "rotr" then out = { turtle.turnRight() }
-                    end
-                    if not out[1] then
-                        wlan.transmit(rchan, chan, {
-                            ["_"] = "Error",
-                            ["from"] = ID,
-                            ["error"] = out[2]
-                        })
-                    else
-                        wlan.transmit(rchan, chan, {
-                            ["_"] = "Result",
-                            ["from"] = ID,
-                            ["out"] = out
-                        })
-                    end
-                end
-            elseif data._ == "shutdown" then
-                wlan.transmit(rchan, chan, { ["_"] = "Ack", ["from"] = ID })
-                os.shutdown()
-            elseif data._ == "reboot" then
-                wlan.transmit(rchan, chan, { ["_"] = "Ack", ["from"] = ID })
-                os.reboot()
-            end
-        end
-    end
-end)

turtos/startup.lua

@@ -1,57 +0,0 @@
-if not turtle then
-    printError("not a turtle")
-    return
-end
-
-local base_path = "https://git.salushnes.solutions/hkc/cc-stuff/raw/branch/master/turtos"
-
-_G._TOS_VER = "N/A"
-local tos_ver_fp = io.open("/.tos-ver", "r")
-if tos_ver_fp then
-    _G._TOS_VER = tos_ver_fp:read("l")
-    tos_ver_fp:close()
-end
-
-local function getFile(url, path)
-    local r, err = http.get(url)
-    io.write("GET " .. path .. " ... ")
-    if not r then
-        print("FAIL: " .. err)
-        return false, err
-    end
-    io.open(path, "w"):write(r.readAll()):close()
-    io.write("OK\n")
-end
-
-
-local req, err = http.get(base_path .. "/update.json")
-if not req then
-    printError("Failed to get update info:", err)
-else
-    local info = textutils.unserializeJSON(req.readAll())
-    req.close()
-
-    print("OTP version: " .. info.ver)
-    print("H/W version: " .. _TOS_VER)
-
-    if info.ver == _TOS_VER then
-        print("Running on latest firmware")
-    else
-        print("Performing an update...")
-        for i = 1, #info.files do
-            local file = info.files[i]
-            term.write(file.dst, "...")
-            if fs.exists(file.dst) then
-                term.write(" [DEL] ...")
-                fs.delete(file.dst)
-            end
-            getFile(base_path .. file.src, file.dst)
-        end
-        print("Writing new version info")
-        io.open("/.tos-ver", "w"):write(info.ver):close()
-        print("Rebooting")
-        return os.reboot()
-    end
-end
-
-shell.run("fg", "main.lua")

turtos/update.json

@@ -1,7 +0,0 @@
-{
-  "ver": "0.0.3",
-  "files": [
-    { "src": "/startup.lua", "dst": "/startup.lua" },
-    { "src": "/main.lua", "dst": "/main.lua" }
-  ]
-}

video.lua

@@ -1,275 +0,0 @@
-local args = { ... }
-local dfpwm = require("cc.audio.dfpwm")
-local ccpi = require("ccpi")
-
-local EV_NONCE = math.floor(0xFFFFFFFF * math.random())
-
-settings.define("video.speaker.left", {
-  description = "Speaker ID for left audio channel",
-  default = peripheral.getName(peripheral.find("speaker")),
-  type = "string"
-})
-
-settings.define("video.speaker.right", {
-  description = "Speaker ID for right audio channel",
-  default = nil,
-  type = "string"
-})
-
-settings.define("video.monitor", {
-  description = "Monitor to draw frames on",
-  default = peripheral.getName(peripheral.find("monitor")),
-  type = "string"
-})
-
-local monitor = peripheral.wrap(settings.get("video.monitor"))
-local speakers = {
-  l = peripheral.wrap(settings.get("video.speaker.left")),
-  r = nil
-}
-local r_spk_id = settings.get("video.speaker.right")
-if r_spk_id then
-  speakers.r = peripheral.wrap(r_spk_id)
-end
-
-local delay = 0
-local loading_concurrency = 8
-local buffer_size = 8192
-local wait_until_input = false
-local n_frames, video_url, audio_url_l, audio_url_r
-
-while args[1] ~= nil and string.sub(args[1], 1, 1) == "-" do
-  local k = table.remove(args, 1):sub(2)
-  if k == "m" or k == "monitor" then
-    monitor = peripheral.wrap(table.remove(args, 1))
-  elseif k == "l" or k == "speaker-left" then
-    speakers.l = peripheral.wrap(table.remove(args, 1))
-  elseif k == "r" or k == "speaker-right" then
-    speakers.r = peripheral.wrap(table.remove(args, 1))
-  elseif k == "d" or k == "delay" then
-    delay = tonumber(table.remove(args, 1))
-  elseif k == "t" or k == "threads" then
-    loading_concurrency = tonumber(table.remove(args, 1))
-  elseif k == "b" or k == "buffer-size" then
-    buffer_size = tonumber(table.remove(args, 1))
-  elseif k == "w" or k == "wait" then
-    wait_until_input = true
-  elseif k == "J" or k == "info-json" then
-    local req = assert(http.get(table.remove(args, 1)))
-    local info = textutils.unserializeJSON(req.readAll())
-    delay = info.frame_time
-    n_frames = info.frame_count
-    video_url = info.video
-    audio_url_l = info.audio.l
-    audio_url_r = info.audio.r
-    req.close()
-  end
-end
-
-if not monitor then
-  printError("No monitor connected or invalid one specified")
-  return
-end
-
-if not speakers.l then
-  printError("No speaker connected or invalid one specified")
-  return
-end
-
-if not n_frames and not video_url and not audio_url_l then
-  if #args < 3 then
-    printError("Usage: video [-w] [-b BUFSZ] [-t THREADS] [-J URL] [-m MONITOR] [-l SPK_L] [-r SPK_R] [-d FRAME_T] <N_FRAMES> <VIDEO_TEMPLATE> <LEFT_CHANNEL> [RIGHT_CHANNEL]")
-    return
-  else
-    n_frames = tonumber(table.remove(args, 1))
-    video_url = table.remove(args, 1)
-    audio_url_l = table.remove(args, 1)
-    audio_url_r = #args > 0 and table.remove(args, 1) or nil
-  end
-end
-
-local mon_w, mon_h = monitor.getSize()
-print(string.format("Using monitor %s (%dx%d)", peripheral.getName(monitor), mon_w, mon_h))
-if speakers.r then
-  print(string.format("Stereo sound: L=%s R=%s", peripheral.getName(speakers.l), peripheral.getName(speakers.r)))
-else
-  print("Mono sound: " .. peripheral.getName(speakers.l))
-end
-
-if not speakers.r and audio_url_r then
-  printError("No right speaker found but right audio channel was specified")
-  printError("Right channel will not be played")
-elseif speakers.r and not audio_url_r then
-  printError("No URL for right channel was specified but right speaker is set")
-  printError("Right speaker will remain silent")
-end
-
-print("\n\n")
-local _, ty = term.getCursorPos()
-local tw, _ = term.getSize()
-
-local function draw_bar(y, c1, c2, p, fmt, ...)
-    local str = string.format(fmt, ...)
-    local w1 = math.ceil(p * tw)
-    local w2 = tw - w1
-
-    term.setCursorPos(1, y)
-    term.setBackgroundColor(c1)
-    term.write(str:sub(1, w1))
-    local rem = w1 - #str
-    if rem > 0 then
-        term.write(string.rep(" ", rem))
-    end
-
-    term.setBackgroundColor(c2)
-    term.write(str:sub(w1 + 1, w1 + w2))
-
-    rem = math.min(tw - #str, w2)
-    if rem > 0 then
-        term.write(string.rep(" ", rem))
-    end
-end
-
-local function decode_s8(data)
-    local buffer = {}
-    for i = 1, #data do
-        local v = string.byte(data, i)
-        if bit32.band(v, 0x80) then
-            v = bit32.bxor(v, 0x7F) - 128
-        end
-        buffer[i] = v
-    end
-    return buffer
-end
-
-local frames = {}
-local audio_frames = { l = {}, r = {} }
-
-local subthreads = {}
-local dl_channels = {
-  l = assert(http.get(audio_url_l, nil, true)),
-  r = audio_url_r and assert(http.get(audio_url_r, nil, true)) or nil,
-}
-
-local n_audio_samples = math.ceil(dl_channels.l.seek("end") / buffer_size)
-dl_channels.l.seek("set", 0)
-
-table.insert(subthreads, function()
-  local chunk
-  repeat
-    chunk = dl_channels.l.read(buffer_size)
-    table.insert(audio_frames.l, chunk or {})
-    if (#audio_frames.l % 8) == 0 then os.sleep(0) end
-  until not chunk or  #chunk == 0
-end)
-
-if dl_channels.r then
-  table.insert(subthreads, function()
-    local chunk
-    repeat
-      chunk = dl_channels.r.read(buffer_size)
-      table.insert(audio_frames.r, chunk or {})
-      if (#audio_frames.r % 8) == 0 then os.sleep(0) end
-    until not chunk or  #chunk == 0
-  end)
-end
-
-for i = 1, loading_concurrency do
-  table.insert(subthreads, function()
-    for ndx = i, n_frames, loading_concurrency do
-      local req = assert(http.get(string.format(video_url, ndx), nil, true))
-      local img = assert(ccpi.parse(req))
-      frames[ndx] = img
-      req.close()
-    end
-  end)
-end
-
-table.insert(subthreads, function()
-  repeat
-    draw_bar(ty - 3, colors.blue, colors.gray, #frames / n_frames, "Loading video [%5d / %5d]", #frames, n_frames)
-    draw_bar(ty - 2, colors.red, colors.gray, #audio_frames.l / n_audio_samples, "Loading audio [%5d / %5d]", #audio_frames.l, n_audio_samples)
-    os.sleep(0.25)
-  until #frames >= n_frames and #audio_frames.l >= n_audio_samples
-  print()
-end)
-
-local playback_done = false
-
-table.insert(subthreads, function()
-  local tmr = os.startTimer(0.25)
-  while true do
-    local ev = { os.pullEvent() }
-    if ev[1] == "key" and ev[2] == keys.enter then
-      break
-    end
-    term.setCursorPos(1, ty - 1)
-    term.setBackgroundColor(colors.gray)
-    term.clearLine()
-    term.write(string.format("Waiting for frames... (V:%d, A:%d)", #frames, #audio_frames.l))
-    if #frames > 60 and #audio_frames.l >= n_audio_samples and not wait_until_input then
-      break
-    end
-  end
-  os.queueEvent("playback_ready", EV_NONCE)
-end)
-
-table.insert(subthreads, function()
-  local is_dfpwm = ({ audio_url_l:find("%.dfpwm") })[2] == #audio_url_l
-  local decode = use_dfpwm and dfpwm.make_decoder() or decode_s8
-
-  repeat 
-    local _, nonce = os.pullEvent("playback_ready")
-  until nonce == EV_NONCE
-
-  for i = 1, n_audio_samples do
-    local buffer = decode(audio_frames.l[i])
-    while not speakers.l.playAudio(buffer) do
-      os.pullEvent("speaker_audio_empty")
-    end
-  end
-
-  playback_done = true
-end)
-
-table.insert(subthreads, function()
-  if not audio_url_r then return end
-  local is_dfpwm = ({ audio_url_r:find("%.dfpwm") })[2] == #audio_url_r
-  local decode = use_dfpwm and dfpwm.make_decoder() or decode_s8
-
-  repeat 
-    local _, nonce = os.pullEvent("playback_ready")
-  until nonce == EV_NONCE
-
-  for i = 1, n_audio_samples do
-    local buffer = decode(audio_frames.r[i])
-    while not speakers.r.playAudio(buffer) do
-      os.pullEvent("speaker_audio_empty")
-    end
-  end
-  playback_done = true
-end)
-
-table.insert(subthreads, function()
-  repeat 
-    local _, nonce = os.pullEvent("playback_ready")
-  until nonce == EV_NONCE
-  local start_t = os.clock()
-  while not playback_done do
-    local frame = math.floor((os.clock() - start_t) / math.max(0.05, delay))
-    term.setCursorPos(1, ty - 1)
-    term.setBackgroundColor(frame >= #frames and colors.red or colors.gray)
-    term.clearLine()
-    term.write(string.format("Playing frame: %d/%d", frame + 1, #frames))
-    local img = frames[frame + 1]
-    if img ~= nil then
-      local x = math.max(math.floor((mon_w - img.w) / 2), 1)
-      local y = math.max(math.floor((mon_h - img.h) / 2), 1)
-      ccpi.draw(img, x, y, monitor)
-    end
-    os.sleep(delay)
-  end
-end)
-
-parallel.waitForAll(table.unpack(subthreads))
-

videotape.lua

@@ -1,27 +0,0 @@
-local tape = peripheral.find("tape_drive")
-local mon = peripheral.find("monitor")
-
-tape.seek(-tape.getSize())
-mon.setTextScale(1)
-
-local w, h = string.byte(tape.read(2), 1, 2)
-
-local b = ""
-for _ = 1, w do b = b .. "0" end
-local f = b
-
-repeat
-    for y = 1, h do
-        mon.setCursorPos(1, y)
-        local buf = { string.byte(tape.read(w), 1, -1) }
-        local s = "" -- , f, b = "", "", ""
-        for x = 1, w do
-            s = s .. string.char(0x80 + bit32.band(0x7F, buf[x]))
-            -- local inv = bit32.band(0x80, buf[x])
-            -- f = f .. (inv and "f" or "0")
-            -- b = b .. (inv and "0" or "f")
-        end
-        mon.blit(s, f, b)
-    end
-    os.sleep(0.01)
-until tape.isEnd()

wsvpn.c

@@ -1,385 +0,0 @@
-// x-run: ~/scripts/runc.sh % -lmongoose -Wall -Wextra
-#include <mongoose.h>
-#include <netinet/in.h>
-#include <stdarg.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-
-#define MAX_CLIENTS 256
-#define MAX_OPEN_CHANNELS 128
-#define MAX_PACKET_SIZE 32767
-
-/*
-```c
-// ALL integers are network-endian
-
-struct msg_info { // side: both. safe to ignore
-    uint8_t code; // 0x49, 'I'
-    uint16_t len;
-    char msg[1024]; // $.len bytes sent
-};
-
-struct msg_res_error {
-    uint8_t code; // 0x45, 'E'
-    uint16_t req_id; // request ID that caused that error
-    uint16_t len;
-    char msg[1024]; // $.len bytes sent
-};
-
-struct msg_address { // side: server
-    uint8_t code; // 0x41, 'A'
-    uint8_t size;
-    char name[256]; // $.size long
-};
-
-struct msg_res_success { // side: server
-    uint8_t code; // 0x52, 'R'
-    uint16_t req_id; // request ID we're replying to
-    void *data; // packet-specific
-};
-
-struct msg_transmission { // side: server
-    uint8_t code; // 0x54, 'T'
-    uint16_t channel;
-    uint16_t replyChannel;
-    uint16_t size;
-    void *data;
-};
-
-struct msg_req_open { // side: client
-    uint8_t code; // 0x4f, 'O'
-    uint16_t req_id; // incremental request ID
-    uint16_t channel; // channel to be open
-};
-
-```
-*/
-
-struct client {
-  struct mg_connection *connection;
-  uint16_t open_channels[MAX_OPEN_CHANNELS];
-  int next_open_channel_index;
-  bool receive_all;
-};
-
-struct client clients[MAX_CLIENTS] = { 0 };
-
-static void handle_client(struct mg_connection *connection, int event_type, void *ev_data, void *fn_data);
-static void on_ws_connect(struct mg_connection *connection, struct mg_http_message *message, void *data);
-static void on_ws_message(struct mg_connection *connection, struct mg_ws_message *message, void *data);
-static void on_ws_disconnect(struct mg_connection *connection, void *data);
-
-bool client_is_open(struct client *client, uint16_t channel);
-static void modem_open(struct client *client, uint16_t request_id, uint16_t channel);
-static void modem_isOpen(struct client *client, uint16_t request_id, uint16_t channel);
-static void modem_close(struct client *client, uint16_t request_id, uint16_t channel);
-static void modem_closeAll(struct client *client, uint16_t request_id);
-static void modem_transmit(struct client *client, uint16_t request_id, uint16_t channel, uint16_t reply_channel, void *data, uint16_t size);
-
-struct metrics {
-  uint64_t sent_bytes;
-  uint64_t sent_messages;
-  uint64_t received_bytes;
-  uint64_t received_messages;
-  uint64_t errors;
-
-  uint64_t method_calls[5];
-} metrics = { 0 };
-
-const char method_names[5][8] = {
-  "open", "isOpen", "close", "closeAll", "transmit"
-};
-
-int main(void) {
-  const char *address = "ws://0.0.0.0:8667";
-  struct mg_mgr manager;
-  mg_mgr_init(&manager);
-  mg_http_listen(&manager, address, handle_client, NULL);
-  printf("Listening on %s\n", address);
-  while (1) mg_mgr_poll(&manager, 1000);
-  mg_mgr_free(&manager);
-}
-
-static void handle_client(struct mg_connection *connection, int event_type, void *event_data, void *fn_data) {
-  if (event_type == MG_EV_OPEN) {
-    if (connection->rem.port == 0) return;
-    memset(connection->data, 0, 32);
-  } else if (event_type == MG_EV_HTTP_MSG) {
-    struct mg_http_message *http_message = (struct mg_http_message *) event_data;
-    if (mg_http_match_uri(http_message, "/open")) {
-      mg_ws_upgrade(connection, http_message, NULL);
-    } else if (mg_http_match_uri(http_message, "/metrics")) {
-      mg_printf(connection, "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n");
-      mg_http_printf_chunk(connection, "# HELP ws_bytes_sent_total Number of bytes sent to clients\n");
-      mg_http_printf_chunk(connection, "# TYPE ws_bytes_sent_total counter\n");
-      mg_http_printf_chunk(connection, "ws_bytes_sent_total %ld\n", metrics.sent_bytes);
-      mg_http_printf_chunk(connection, "# HELP ws_bytes_received_total Number of bytes received to clients\n");
-      mg_http_printf_chunk(connection, "# TYPE ws_bytes_received_total counter\n");
-      mg_http_printf_chunk(connection, "ws_bytes_received_total %ld\n", metrics.received_bytes);
-
-      mg_http_printf_chunk(connection, "# HELP ws_messages_sent_total Number of messages sent to clients\n");
-      mg_http_printf_chunk(connection, "# TYPE ws_messages_sent_total counter\n");
-      mg_http_printf_chunk(connection, "ws_messages_sent_total %ld\n", metrics.sent_messages);
-      mg_http_printf_chunk(connection, "# HELP ws_messages_received_total Number of messages received to clients\n");
-      mg_http_printf_chunk(connection, "# TYPE ws_messages_received_total counter\n");
-      mg_http_printf_chunk(connection, "ws_messages_received_total %ld\n", metrics.received_messages);
-
-      mg_http_printf_chunk(connection, "# HELP ws_clients Number of active websocket clients\n");
-      mg_http_printf_chunk(connection, "# TYPE ws_clients gauge\n");
-      {
-        int n = 0;
-        for (struct mg_connection *conn = connection->mgr->conns; conn != NULL; conn = conn->next) {
-          if (conn->is_websocket) { n++; }
-        }
-        mg_http_printf_chunk(connection, "ws_clients %d\n", n);
-      }
-
-      mg_http_printf_chunk(connection, "# HELP method_calls Times each method was called\n");
-      mg_http_printf_chunk(connection, "# TYPE method_calls counter\n");
-      for (int i = 0; i < 5; i++) {
-        mg_http_printf_chunk(connection, "method_calls{method=\"%s\"} %ld\n", method_names[i], metrics.method_calls[i]);
-      }
-
-      mg_http_printf_chunk(connection, "");
-    } else {
-      mg_http_reply(connection, 404, "", "uwu");
-    }
-  } else if (event_type == MG_EV_WS_OPEN) {
-    struct mg_http_message *http_message = (struct mg_http_message *) event_data;
-    on_ws_connect(connection, http_message, fn_data);
-  } else if (event_type == MG_EV_WS_MSG) {
-    struct mg_ws_message *ws_message = (struct mg_ws_message *)event_data;
-    on_ws_message(connection, ws_message, fn_data);
-  } else if (event_type == MG_EV_CLOSE) {
-    if (connection->is_websocket) {
-      on_ws_disconnect(connection, fn_data);
-    }
-  }
-}
-
-void ws_send_error(struct client *client, uint16_t request_id, const char *fmt, ...) {
-  static char buffer[1024];
-  memset(buffer, 0, 1024);
-
-  va_list args;
-  va_start(args, fmt);
-  int text_size = vsnprintf(&buffer[5], 1019, fmt, args);
-  va_end(args);
-  if (text_size < 0) return;
-
-  buffer[0] = 'E';
-  buffer[1] = (request_id >> 8) & 0xFF;
-  buffer[2] = request_id & 0xFF;
-  buffer[3] = (text_size >> 8) & 0xFF;
-  buffer[4] = text_size & 0xFF;
-
-  metrics.sent_bytes += 5 + text_size;
-  metrics.sent_messages++;
-  metrics.errors++;
-  mg_ws_send(client->connection, buffer, 5 + text_size, WEBSOCKET_OP_BINARY);
-}
-
-void ws_send_info(struct client *client, const char *fmt, ...) {
-  static char buffer[1024];
-  memset(buffer, 0, 1024);
-
-  va_list args;
-  va_start(args, fmt);
-  int text_size = vsnprintf(&buffer[3], 1021, fmt, args);
-  va_end(args);
-  if (text_size < 0) return;
-
-  buffer[0] = 'I';
-  buffer[1] = (text_size >> 8) & 0xFF;
-  buffer[2] = text_size & 0xFF;
-
-  metrics.sent_bytes += 3 + text_size;
-  metrics.sent_messages++;
-  mg_ws_send(client->connection, buffer, 3 + text_size, WEBSOCKET_OP_BINARY);
-}
-
-void ws_respond(struct client *client, uint16_t request_id, void *data, uint32_t size) {
-  static char buffer[MAX_PACKET_SIZE];
-  assert(size < MAX_PACKET_SIZE);
-  buffer[0] = 'R';
-  buffer[1] = (request_id >> 8) & 0xFF;
-  buffer[2] = request_id & 0xFF;
-  if (size != 0) memcpy(&buffer[3], data, size);
-  metrics.sent_bytes += 3 + size;
-  metrics.sent_messages++;
-  mg_ws_send(client->connection, buffer, size + 3, WEBSOCKET_OP_BINARY);
-}
-
-static void on_ws_connect(struct mg_connection *connection, struct mg_http_message *message, void *data) {
-  (void)message;
-  (void)data;
-  struct client *client = malloc(sizeof(struct client));
-  memcpy(&connection->data[0], &client, sizeof(struct client *));
-  client->connection = connection;
-
-  static char buffer[256];
-  buffer[0] = 'A';
-  buffer[1] = snprintf(&buffer[2], 250, "wsvpn_%ld", connection->id);
-  metrics.sent_bytes += 2 + buffer[1];
-  metrics.sent_messages++;
-  mg_ws_send(connection, buffer, 2 + buffer[1], WEBSOCKET_OP_BINARY);
-}
-
-static void on_ws_message(struct mg_connection *connection, struct mg_ws_message *message, void *data) {
-  (void)data;
-
-  if ((message->flags & 15) != WEBSOCKET_OP_BINARY) {
-    const char *err_str = "This server only works in binary mode. Sorry!";
-    mg_ws_send(connection, err_str, strlen(err_str), WEBSOCKET_OP_TEXT);
-    connection->is_draining = 1;
-    return;
-  }
-
-  struct client *client = *(struct client **)&connection->data[0];
-  assert(client->connection == connection);
-
-  metrics.received_bytes += message->data.len;
-  metrics.received_messages++;
-
-  if (message->data.len == 0) return;
-
-  uint16_t request_id = ntohs(*(uint16_t*)&message->data.ptr[1]);
-
-  switch (message->data.ptr[0]) {
-    case 'I': // info. We can safely ignore that message
-      break;
-    case 'O': // open
-      {
-        metrics.method_calls[0]++;
-        uint16_t channel = ntohs(*(uint16_t*)&message->data.ptr[3]);
-        printf("%p[%04x] modem.open(%d)\n", (void*)client, request_id, channel);
-        modem_open(client, request_id, channel);
-      }
-      return;
-    case 'o': // isOpen
-      {
-        metrics.method_calls[1]++;
-        uint16_t channel = ntohs(*(uint16_t*)&message->data.ptr[3]);
-        printf("%p[%04x] modem.isOpen(%d)\n", (void*)client, request_id, channel);
-        modem_isOpen(client, request_id, channel);
-      }
-      return;
-    case 'c': // close
-      {
-        metrics.method_calls[2]++;
-        uint16_t channel = ntohs(*(uint16_t*)&message->data.ptr[3]);
-        printf("%p[%04x] modem.close(%d)\n", (void*)client, request_id, channel);
-        modem_close(client, request_id, channel);
-      }
-      return;
-    case 'C': // closeAll
-      {
-        metrics.method_calls[3]++;
-        printf("%p[%04x] modem.closeAll()\n", (void*)client, request_id);
-        modem_closeAll(client, request_id);
-      }
-      return;
-    case 'T': // transmit
-      {
-        metrics.method_calls[4]++;
-        uint16_t channel = ntohs(*(uint16_t*)&message->data.ptr[3]);
-        uint16_t reply_channel = ntohs(*(uint16_t*)&message->data.ptr[5]);
-        uint16_t data_length = ntohs(*(uint16_t*)&message->data.ptr[7]);
-        modem_transmit(client, request_id, channel, reply_channel, (void*)&message->data.ptr[9], data_length);
-      }
-      return;
-    default:
-      ws_send_error(client, request_id, "Unknown opcode: 0x%02x", message->data.ptr[0]);
-      connection->is_draining = 1;
-      return;
-  }
-}
-
-static void on_ws_disconnect(struct mg_connection *connection, void *data) {
-  (void)data;
-
-  struct client *client = *(struct client **)&connection->data[0];
-  if (client->connection == connection) {
-    free(client);
-  }
-}
-
-
-static void modem_open(struct client *client, uint16_t request_id, uint16_t channel) {
-  if (client_is_open(client, channel)) {
-    ws_respond(client, request_id, NULL, 0);
-  }
-
-  if (client->next_open_channel_index == MAX_OPEN_CHANNELS) {
-    ws_send_error(client, request_id, "Too many open channels");
-    return;
-  }
-
-  client->open_channels[client->next_open_channel_index] = channel;
-  client->next_open_channel_index++;
-  ws_respond(client, request_id, NULL, 0);
-}
-
-static void modem_isOpen(struct client *client, uint16_t request_id, uint16_t channel) {
-  unsigned char is_open = client_is_open(client, channel) ? 42 : 0;
-  ws_respond(client, request_id, &is_open, 1);
-}
-
-static void modem_close(struct client *client, uint16_t request_id, uint16_t channel) {
-  for (int i = 0; i < client->next_open_channel_index; i++) {
-    if (client->open_channels[i] == channel) {
-      client->open_channels[i] = client->open_channels[client->next_open_channel_index - 1];
-      client->next_open_channel_index--;
-      break;
-    }
-  }
-  ws_respond(client, request_id, NULL, 0);
-}
-
-static void modem_closeAll(struct client *client, uint16_t request_id) {
-  client->next_open_channel_index = 0;
-  memset(client->open_channels, 0, sizeof(uint16_t) * MAX_OPEN_CHANNELS);
-  ws_respond(client, request_id, NULL, 0);
-}
-
-static void modem_transmit(struct client *client, uint16_t request_id, uint16_t channel, uint16_t reply_channel, void *data, uint16_t size) {
-  static uint8_t buffer[MAX_PACKET_SIZE + 7];
-
-  if (size > MAX_PACKET_SIZE) {
-    ws_send_error(client, request_id, "Packet too big: %d > %d", size, MAX_PACKET_SIZE);
-    return;
-  }
-
-  buffer[0] = 'T';
-  buffer[1] = (channel >> 8) & 0xFF;
-  buffer[2] = channel & 0xFF;
-  buffer[3] = (reply_channel >> 8) & 0xFF;
-  buffer[4] = reply_channel & 0xFF;
-  buffer[5] = (size >> 8) & 0xFF;
-  buffer[6] = size & 0xFF;
-  memcpy(&buffer[7], data, size);
-
-  for (struct mg_connection *conn = client->connection->mgr->conns; conn != NULL; conn = conn->next) {
-    if (conn->is_websocket) {
-      struct client *other_client = *(struct client **)&conn->data[0];
-      if (other_client->connection == conn && other_client->connection != client->connection) {
-        if (client_is_open(other_client, channel)) {
-          metrics.sent_bytes += size + 7;
-          metrics.sent_messages++;
-          mg_ws_send(other_client->connection, buffer, size + 7, WEBSOCKET_OP_BINARY);
-        }
-      }
-    }
-  }
-  ws_respond(client, request_id, NULL, 0);
-}
-
-bool client_is_open(struct client *client, uint16_t channel) {
-  for (int i = 0; i < client->next_open_channel_index; i++) {
-    if (client->open_channels[i] == channel) {
-      return true;
-    }
-  }
-  return false;
-}

wsvpn.lua

@@ -1,154 +0,0 @@
-local expect = require("cc.expect")
-
-local WSModem = {
-  open = function(self, channel)
-    expect.expect(1, channel, "number")
-    expect.range(channel, 0, 65535)
-    self._request(0x4f, {
-        bit.band(0xFF, bit.brshift(channel, 8)),
-        bit.band(0xFF, channel)
-      })
-  end,
-  isOpen = function(self, channel)
-    expect.expect(1, channel, "number")
-    expect.range(channel, 0, 65535)
-    return self._request(0x6f, {
-        bit.band(0xFF, bit.brshift(channel, 8)),
-        bit.band(0xFF, channel)
-      })[1] ~= 0
-  end,
-  close = function(self, channel)
-    expect.expect(1, channel, "number")
-    expect.range(channel, 0, 65535)
-    self._request(0x63, {
-        bit.band(0xFF, bit.brshift(channel, 8)),
-        bit.band(0xFF, channel)
-      })
-  end,
-  closeAll = function(self)
-    self._request(0x43)
-  end,
-  transmit = function(self, channel, replyChannel, data)
-    expect.expect(1, channel, "number")
-    expect.expect(2, replyChannel, "number")
-    expect.expect(3, data, "nil", "string", "number", "table")
-    expect.range(channel, 0, 65535)
-    expect.range(replyChannel, 0, 65535)
-
-    local serialized = textutils.serializeJSON(data)
-    expect.range(#serialized, 0, 65535)
-    serialized = { serialized:byte(1, 65536) }
-    self._request(0x54, {
-        bit.band(0xFF, bit.brshift(channel, 8)),
-        bit.band(0xFF, channel),
-        bit.band(0xFF, bit.brshift(replyChannel, 8)),
-        bit.band(0xFF, replyChannel),
-        bit.band(0xFF, bit.brshift(#serialized, 8)),
-        bit.band(0xFF, #serialized),
-        table.unpack(serialized, 1, #serialized)
-      })
-  end,
-  isWireless = function(self) return true end,
-  run = function(self)
-    while true do
-      local data, binary = self._socket.receive()
-      if not data then return true end
-      if binary == false then return false, "Not a binary message" end
-      data = { string.byte(data, 1, #data) }
-      local opcode = table.remove(data, 1)
-      if opcode == 0x49 then -- info
-        local len, msg = self._read_u16ne(data)
-        msg = string.char(table.unpack(msg))
-        os.queueEvent("wsvpn:info", msg)
-      elseif opcode == 0x41 then -- Set address/side
-        local len = table.remove(data, 1)
-        self.side = string.char(table.unpack(data, 1, len))
-      elseif opcode == 0x45 then -- Error
-        local request_id, error_length
-        request_id, data = self._read_u16ne(data)
-        error_length, data = self._read_u16ne(data)
-        local message = string.char(table.unpack(data, 1, error_length))
-        os.queueEvent("wsvpn:response", false, request_id, message)
-      elseif opcode == 0x52 then -- Response
-        local request_id, response = self._read_u16ne(data)
-        os.queueEvent("wsvpn:response", true, request_id, response)
-      elseif opcode == 0x54 then -- Transmission
-        local channel, replyChannel, dataSize, packet
-        channel, data = self._read_u16ne(data)
-        replyChannel, data = self._read_u16ne(data)
-        dataSize, packet = self._read_u16ne(data)
-        os.queueEvent("modem_message", self.side or "wsmodem_0", channel, replyChannel, textutils.unserializeJSON(string.char(table.unpack(data, 1, dataSize))), nil)
-      else
-        return false, string.format("Invalid opcode 0x%02x", opcode)
-      end
-      os.sleep(0)
-    end
-  end,
-
-  -- low-level part
-
-  _read_u16ne = function(self, data)
-    local v = bit.blshift(table.remove(data, 1), 8)
-    v = bit.bor(v, table.remove(data, 1))
-    return v, data
-  end,
-
-  _wait_response = function(self, request_id)
-    while true do
-      local ev, status, id, data = os.pullEvent("wsvpn:response")
-      if ev == "wsvpn:response" and id == request_id then
-        return status, data
-      end
-    end
-  end,
-
-  _request = function(self, opcode, data)
-    local request_id = self._get_id()
-    self._socket.send(
-      string.char(
-        opcode,
-        bit.band(0xFF, bit.brshift(request_id, 8)),
-        bit.band(0xFF, request_id),
-        table.unpack(data or {})
-        ),
-      true
-      )
-    local status, response = self._wait_response(request_id)
-    if not status then
-      error(response)
-    end
-    return response
-  end,
-
-  _get_id = function(self)
-    self._req_id = bit.band(0xFFFF, self._req_id + 1)
-    return self._req_id
-  end,
-
-  _send_text = function(self, code, fmt, ...)
-    local msg = { fmt:format(...):byte(1, 1020) }
-    self._socket.send(
-      string.char(
-        code,
-        bit.band(0xFF, bit.brshift(#msg, 8)),
-        bit.band(0xFF, #msg),
-        table.unpack(msg, 1, #msg)
-      ),
-      true
-    )
-  end,
-
-  _init = function(self)
-    self._send_text(0x49, "Hello! I'm computer %d", os.getComputerID())
-  end,
-}
-
-return function(addr)
-  local ws = assert(http.websocket(addr))
-  local sock = setmetatable({ _socket = ws, _req_id = 0, side = "wsmodem_unknown" }, { __index = WSModem })
-  for name, method in pairs(WSModem) do
-    sock[name] = function(...) return method(sock, ...) end
-  end
-  sock._init()
-  return sock
-end