diff --git a/compacting-storage.lua b/compacting-storage.lua index 9390591..8fdd2dd 100644 --- a/compacting-storage.lua +++ b/compacting-storage.lua @@ -8,46 +8,106 @@ local MAIN_TICKER = "" local REQUEST_TICKER = "" -local STORAGE_ADDRESS = "" +local CRAFTING_REQUESTER = "" +local STORAGE_ADDR = "" +local COMPACTING_ADDR = "" +local UNPACKING_ADDR = "" local SLEEP_TIME = 30 local NUGGET_RATIO = 63 -- amount of nuggets per craft local BLOCK_RATIO = 7 -- amount of blocks per craft -local ITEM_TYPES = { "iron", "copper", "zinc", "gold", "electrum" } +local ITEM_TYPES = { + iron = { + nugget = "minecraft", + ingot = "minecraft", + block = "minecraft", + }, + copper = { + nugget = "create", + ingot = "minecraft", + block = "minecraft", + }, + zinc = { + nugget = "create", + ingot = "create", + block = "create", + }, + gold = { + nugget = "minecraft", + ingot = "minecraft", + block = "minecraft", + }, + electrum = { + nugget = "createaddition", + ingot = "createaddition", + block = "createaddition", + }, +} local STACKS = 64 local NUGGETS = 1 local INGOTS = 9 local BLOCKS = 81 --- V2!! what am i working on? --- TODO new oregen interop: request from REQUEST_TICKER to get new ore --- TODO new way to keep items stocked: request from MAIN_TICKER --- do I even need a specific inventory anymore? I could maybe move metals --- into the sophisticated storage setup. --- TODO new way to craft between states: make requests with MAIN_TICKER --- (could maybe add a redstone requester if desired) - -- Levels local MIN_NUM = (4 * STACKS * NUGGETS) + (4 * STACKS * INGOTS) local MAX_NUM = (8 * STACKS * NUGGETS) + (8 * STACKS * INGOTS) +local getName = { + nugget = function (item_type) + return ("%s:%s_nugget"):format( + ITEM_TYPES[item_type].nugget, + item_type, + ) + end, + ingot = function (item_type) + return ("%s:%s_ingot"):format( + ITEM_TYPES[item_type].ingot, + item_type, + ) + end, + block = function (item_type) + return ("%s:%s_block"):format( + ITEM_TYPES[item_type].block, + item_type, + ) + end, +} + -- basic actions -function craft (item_type, conversion_type) - -- TODO rework +function craft (requester, item_type, conversion_type) + -- conversion_type key: 1, nuggets to ingots; 2, ingots to blocks; + -- 3, blocks to ingots; 4, ingots to nuggets + local convert = { + getName.nugget, + getName.ingot, + getName.block, + getName.ingot, + } + local name = convert[conversion_type](item_type) + local compacting = conversion_type <= 2 + local count, address + if compacting then + count = NUGGET_RATIO + address = COMPACTING_ADDR + else + count = BLOCK_RATIO end + address = UNPACKING_ADDR + end + requester.setRequest({ name, count }) end -function craft_multiple (item_type, conversion_type, count) +function craft_multiple (requester, item_type, conversion_type, count) if count < 1 then return else - craft(item_type, conversion_type) + craft(requester, item_type, conversion_type) os.sleep(1) - return craft_multiple(item_type, conversion_type, count - 1) + return craft_multiple(requester, item_type, conversion_type, count - 1) end end -function execute_crafts (item_type, crafts) - local num_crafts = crafts.nuggets +function execute_crafts (requester, item_type, crafts) + local num_crafts = crafts.nugget if num_crafts > 0 then print(("Crafting %s nuggets"):format(item_type)) craft_multiple(item_type, 4, num_crafts) @@ -55,10 +115,10 @@ function execute_crafts (item_type, crafts) print(("Crafting %s ingots"):format(item_type)) craft_multiple(item_type, 1, -num_crafts) end - num_crafts = crafts.blocks + num_crafts = crafts.block if num_crafts > 0 then print(("Crafting %s blocks"):format(item_type)) - craft_multiple(item_type, 2, num_crafts) + craft_multiple(requester, item_type, 2, num_crafts) elseif num_crafts < 0 then print(("Crafting %s ingots"):format(item_type)) craft_multiple(item_type, 3, -num_crafts) @@ -66,13 +126,7 @@ function execute_crafts (item_type, crafts) end function request_more (ticker, item_type) - local request = { - name = { - _op = "regex", - value = ".*:" .. item_type .. "_nugget" - } - } - ticker.requestFiltered(STORAGE_ADDRESS, request) + ticker.requestFiltered(STORAGE_ADDR, { name = getName.nugget(item_type) }) end -- logic @@ -87,12 +141,12 @@ function sum_items (inv_f) end function dist_to_num (dist) - return dist.nuggets + dist.ingots * INGOTS + dist.blocks * BLOCKS + return dist.nugget + dist.ingot * INGOTS + dist.block * BLOCKS end function get_dist (item_type, items) -- TODO change plurals to singulars to match mc - local dist = { nuggets = 0, ingots = 0, blocks = 0 } + local dist = { nugget = 0, ingot = 0, block = 0 } for item, count in pairs(items) do local type, form = item:match":(%l-)_(%l*)" form = string.format("%ss", form) @@ -104,42 +158,42 @@ function get_dist (item_type, items) end function decide_dist (num) - local dist = { nuggets = 0, ingots = 0, blocks = 0 } + local dist = { nugget = 0, ingot = 0, block = 0 } if num > MAX_NUM then local excess = num - MAX_NUM - dist.blocks = math.floor(excess / BLOCKS) - num = num - (dist.blocks * BLOCKS) + dist.block = math.floor(excess / BLOCKS) + num = num - (dist.block * BLOCKS) end local balance = math.floor(num / 10) - dist.nuggets, dist.ingots = balance, balance + dist.nugget, dist.ingot = balance, balance num = num - (balance * 10) - dist.nuggets = dist.nuggets + num + dist.nugget = dist.nugget + num return dist end function get_diff (dist1, dist2) return { - nuggets = dist1.nuggets - dist2.nuggets, - ingots = dist1.ingots - dist2.ingots, - blocks = dist1.blocks - dist2.blocks + nugget = dist1.nugget - dist2.nugget, + ingot = dist1.ingot - dist2.ingot, + block = dist1.block - dist2.block } end function filter_clamp (diff, current_dist) -- reduce diff numbers to what can be crafted using current resources - if diff.blocks > 0 then - diff.blocks = math.min( - diff.blocks - (diff.blocks % BLOCK_RATIO), - math.floor(current_dist.ingots / 9) + if diff.block > 0 then + diff.block = math.min( + diff.block - (diff.block % BLOCK_RATIO), + math.floor(current_dist.ingot / 9) ) end - if diff.nuggets > 0 then - diff.nuggets = math.min( - diff.nuggets - (diff.nuggets % NUGGET_RATIO), - current_dist.ingots * 9 + if diff.nugget > 0 then + diff.nugget = math.min( + diff.nugget - (diff.nugget % NUGGET_RATIO), + current_dist.ingot * 9 ) end - diff.ingots = (-diff.nuggets / 9) + (-diff.blocks * 9) + diff.ingot = (-diff.nugget / 9) + (-diff.block * 9) return diff end @@ -147,8 +201,8 @@ function diff_to_crafts (diff) -- go from one end e.g. nuggets to the other e.g. blocks, removing -- from the diff to create crafts until the diff is empty local crafts = {} - crafts.nuggets = math.floor(diff.nuggets / NUGGET_RATIO) - crafts.blocks = math.floor(diff.blocks / BLOCK_RATIO) + crafts.nugget = math.floor(diff.nugget / NUGGET_RATIO) + crafts.block = math.floor(diff.block / BLOCK_RATIO) return crafts end @@ -163,13 +217,16 @@ end local main_t = peripheral.wrap(MAIN_TICKER) local request_t = peripheral.wrap(REQUEST_TICKER) +local craft_requester = peripheral.wrap(CRAFTING_REQUESTER) +craft_requester.setConfiguration("strict") +local requesting = {} while true do -- 1. Sum items in inventory and organize by item type local items = sum_items(main_t.stock) -- print_counts(items) -- 2. either work towards a desired distribution or create more resources - for _, item_type in ipairs(ITEM_TYPES) do + for item_type, _ in pairs(ITEM_TYPES) do local current_dist = get_dist(item_type, items) local num = dist_to_num(current_dist) if num > MIN_NUM then @@ -177,10 +234,14 @@ while true do local diff = get_diff(desired_dist, current_dist) diff = filter_clamp(diff, current_dist) local crafts = diff_to_crafts(diff) - execute_crafts(item_type, crafts) + execute_crafts(craft_requester, item_type, crafts) + elseif num > MAX_NUM then + -- keep requesting until above MAX_NUM + requesting[item_type] = nil else - -- TODO - -- TODO potentially keep requesting until above MAX_NUM + requesting[item_type] = true + end + if requesting[item_type] then request_more(request_t, item_type) end end