oc_ia.lua

local component = require("component")
local sides = require("sides")
local thread = require("thread")
local os = require("os")

local rc_in = sides.north
local prim_in = sides.west
local prim_out = sides.down
local auxl_in = sides.east
local auxl_out = sides.south
local out = sides.north
local rc_tp_addr = "6063f7a8-61d8-49b9-94ff-2356535d4b13"
local rc_tp = component.proxy(rc_tp_addr)
local sleep_t = 0.1

local function is_empty(tp, side)
    local max = tp.getInventorySize(side)
    for idx = 1, max do
        if tp.getStackInSlot(side, idx) ~= nil then return false end
    end
    return true
end

local function transfer_single(tp, in_side, in_slot, out_side, out_slot)
    tp.transferItem(in_side, out_side, tp.getStackInSlot(in_side, in_slot).count, in_side, out_side)
end

local function transfer_all(tp, in_side, out_side)
    local out_slot = 1
    local max = tp.getInventorySize(in_side)
    for idx = 1, max do
        while tp.getStackInSlot(out_side, out_slot) ~= nil do out_slot = out_slot + 1 end
        transfer_single(tp, in_side, idx, out_side, out_slot)
    end
end

local function wait_for_rc_items()
    while is_empty(rc_tp, rc_in) do os.sleep(sleep_t) end
end

local function wait_for_free_slave()
    while true do
        for addr, type in component.list() do
            if type == "transposer" and addr ~= rc_tp_addr then
                local slave_tp = component.proxy(addr)
                if is_empty(slave_tp, prim_out) then return slave_tp end
            end
        end
    end
end

local function split_rc_items()
    local function get_slot_of_prim()
        local recipes = {
            { items = { "Dragonstone" }, prim = "Dragonstone" },
            { items = { "Nether Star" }, prim = "Nether Star" },
            { items = { "Mirrored Glass" }, prim = "Mirrored Glass" },
            { items = { "Magic Mirror" }, prim = "Magic Mirror" },
            { items = { "ME Interface" }, prim = "ME Interface" },
            { items = { "Thaumonomicon" }, prim = "Thaumonomicon" },
            { items = { "Alchemical Furnace" }, prim = "Alchemical Furnace" },
            { items = { "Witches Oven" }, prim = "Witches Oven" },
            { items = { "Draconic Core"}, prim = "Draconic Core" },
            { items = { "Draconium Infused Obsidian" }, prim = "Draconium Infused Obsidian" },
            { items = { "Thaumium Pickaxe" }, prim = "Thaumium Pickaxe" },
            { items = { "Block of Terrasteel" }, prim = "Block of Terrasteel" },
            { items = { "Primal Charm" }, prim = "Primal Charm" }
        }
        local function get_slot_of(label)
            local max = rc_tp.getInventorySize(rc_in)
            for idx = 1, max do
                local stack = rc_tp.getStackInSlot(rc_in, idx)
                if stack ~= nil and stack.label == label then return idx end
            end
            return nil
        end
        local function for_all(pred, table)
            for _, value in pairs(table) do
                if not pred(value) then return false end
            end
            return true
        end
        local function pred(label) return get_slot_of(label) ~= nil end
        for _, recipe in pairs(recipes) do
            if for_all(pred, recipe.items) then return get_slot_of(recipe.prim) end
        end
        return nil
    end
    local prim_slot = get_slot_of_prim()
    transfer_single(rc_tp, rc_in, prim_slot, prim_in, 1)
    transfer_all(rc_tp, rc_in, auxl_in)
end

local function setup_watchdog(slave_tp, original)
    local function watchdog_fn()
        local function is_same(lstack, rstack)
            return lstack.label == rstack.label and lstack.count == rstack.count
        end
        while is_same(slave_tp.getStackInSlot(prim_out, 1), original) do os.sleep(sleep_t) end
        transfer_single(slave_tp, prim_out, 1, out, slave_tp.getInventorySize(out))
    end
    thread.create(watchdog_fn)
end

local function main()
    while true do
        wait_for_rc_items()
        local free_slave_tp = wait_for_free_slave()
        split_rc_items()
        local original_prim = rc_tp.getStackInSlot(prim_in, 1)
        transfer_all(free_slave_tp, auxl_in, auxl_out)
        transfer_single(free_slave_tp, prim_in, 1, prim_out, 1)
        setup_watchdog(free_slave_tp, original)
    end
end

main()