657 lines
19 KiB
Lua
657 lines
19 KiB
Lua
local term_stack = require("term-stack")
|
|
local ensure_width = require("cc.strings").ensure_width
|
|
local ui = require("ui")
|
|
local main_view = {}
|
|
|
|
local function clamp(x, min, max)
|
|
return math.min(math.max(x, min), max)
|
|
end
|
|
|
|
local function rect(x, y, w, h)
|
|
return { x = x, y = y, w = w, h = h or w }
|
|
end
|
|
|
|
local function copy_table(t)
|
|
local t_copy = {}
|
|
for k, v in pairs(t) do
|
|
t_copy[k] = v
|
|
end
|
|
return t_copy
|
|
end
|
|
|
|
local function list_items(inventories)
|
|
local item_registry = {}
|
|
for _, name in ipairs(inventories) do
|
|
for slot, item in pairs(peripheral.call(name, "list")) do
|
|
item_registry[item.name] = item_registry[item.name] or {}
|
|
table.insert(item_registry[item.name], {
|
|
count = item.count,
|
|
slot = slot,
|
|
peripheral = name
|
|
})
|
|
end
|
|
end
|
|
|
|
for _, items in pairs(item_registry) do
|
|
items.count = 0
|
|
for _, slot in ipairs(items) do
|
|
items.count = items.count + slot.count
|
|
end
|
|
end
|
|
|
|
return item_registry
|
|
end
|
|
|
|
local function populate_item_details(item_details, item_registry)
|
|
for name, items in pairs(item_registry) do
|
|
local item = items[1]
|
|
if item and not item_details[name] then
|
|
local detail = peripheral.call(item.peripheral, "getItemDetail", item.slot)
|
|
item_details[name] = {
|
|
display_name = detail.displayName,
|
|
stack_size = detail.maxCount
|
|
}
|
|
end
|
|
end
|
|
end
|
|
|
|
local function remove_value(array, value)
|
|
for i, v in ipairs(array) do
|
|
if v == value then
|
|
table.remove(array, i)
|
|
return
|
|
end
|
|
end
|
|
end
|
|
|
|
local function vsplit(area, x)
|
|
local left_area = rect(area.x, area.y, x - area.x, area.h)
|
|
local right_area = rect(area.x + left_area.w+1, area.y, area.w - left_area.w-1, area.h)
|
|
return left_area, right_area
|
|
end
|
|
|
|
local function vline(x, y, height)
|
|
for i=1, height do
|
|
term.setCursorPos(x, y+i-1)
|
|
term.write("|")
|
|
end
|
|
end
|
|
|
|
local function hline(x, y, length)
|
|
for i=1, length do
|
|
term.setCursorPos(x+i-1, y)
|
|
term.write("-")
|
|
end
|
|
end
|
|
|
|
local function get_item_counts(items)
|
|
local item_counts = {}
|
|
for name, item_collection in pairs(items) do
|
|
item_counts[name] = item_collection.count
|
|
end
|
|
return item_counts
|
|
end
|
|
|
|
local function is_bundle_name(name)
|
|
return name:find("#") == 1
|
|
end
|
|
|
|
-- TODO: improve this function
|
|
local function resolve_bundle_items(bundles, bundle_name, seen_bundles)
|
|
seen_bundles = seen_bundles or {}
|
|
if seen_bundles[bundle_name] then return nil, "Circular dependency" end
|
|
|
|
local bundle = bundles[bundle_name]
|
|
if not bundle then return {} end
|
|
|
|
local items = {}
|
|
for dep_name, dep_count in pairs(bundle) do
|
|
if is_bundle_name(dep_name) then
|
|
seen_bundles[bundle_name] = true
|
|
local dep_items, err = resolve_bundle_items(bundles, dep_name:sub(2), seen_bundles)
|
|
if not dep_items then return nil, err end
|
|
for item_name, item_count in pairs(dep_items) do
|
|
items[item_name] = (items[item_name] or 0) + item_count * dep_count
|
|
end
|
|
seen_bundles[bundle_name] = nil
|
|
else
|
|
items[dep_name] = (items[dep_name] or 0) + dep_count
|
|
end
|
|
end
|
|
|
|
return items
|
|
end
|
|
|
|
-- TODO: improve this function
|
|
local function populate_bundle_details(bundle_details, bundles)
|
|
for bundle_name in pairs(bundles) do
|
|
local hash_name = "#"..bundle_name
|
|
if not bundle_details[hash_name] then
|
|
bundle_details[hash_name] = resolve_bundle_items(bundles, bundle_name)
|
|
end
|
|
end
|
|
end
|
|
|
|
local function derive_available_bundles(available_items, bundle_details)
|
|
local available_bundles = {}
|
|
for bundle_name, items in pairs(bundle_details) do
|
|
local bundle_count = math.huge
|
|
for item_name, item_count in pairs(items) do
|
|
local available_count = available_items[item_name] or 0
|
|
bundle_count = math.min(bundle_count, math.max(0, available_count / item_count))
|
|
end
|
|
if bundle_count ~= math.huge and bundle_count > 0 then
|
|
available_bundles[bundle_name] = bundle_count
|
|
end
|
|
end
|
|
return available_bundles
|
|
end
|
|
|
|
local function sort_names_by_counts(names, items, bundles)
|
|
table.sort(names, function(a, b)
|
|
local count_a = items[a] or bundles[a]
|
|
local count_b = items[b] or bundles[b]
|
|
if count_a == count_b then
|
|
return a:gsub("^#", "") < b:gsub("^#", "")
|
|
else
|
|
return count_a > count_b
|
|
end
|
|
end)
|
|
end
|
|
|
|
function main_view:prepare(inventories, bundles, result_inventory)
|
|
self.event = {}
|
|
|
|
self.main_area = rect(1, 1, term.getSize())
|
|
self.split_x = math.floor(self.main_area.w*0.5)
|
|
self.left_area, self.right_area = vsplit(self.main_area, self.split_x)
|
|
self.is_left_active = true
|
|
self.bundle_name = ""
|
|
|
|
self.result_inventory = result_inventory
|
|
self.inventories = inventories
|
|
remove_value(self.inventories, result_inventory)
|
|
|
|
self.item_registry = list_items(self.inventories)
|
|
self.item_details = {}
|
|
populate_item_details(self.item_details, self.item_registry)
|
|
|
|
self.bundles = bundles or {}
|
|
self.bundle_details = {}
|
|
populate_bundle_details(self.bundle_details, self.bundles)
|
|
|
|
do
|
|
local available_items = get_item_counts(self.item_registry)
|
|
local available_bundles = derive_available_bundles(available_items, self.bundle_details)
|
|
|
|
local filtered_names = {}
|
|
do
|
|
for name, _ in pairs(available_items) do
|
|
table.insert(filtered_names, name)
|
|
end
|
|
for name, _ in pairs(available_bundles) do
|
|
table.insert(filtered_names, name)
|
|
end
|
|
sort_names_by_counts(filtered_names, available_items, available_bundles)
|
|
end
|
|
|
|
self.left_store = {
|
|
items = available_items,
|
|
bundles = available_bundles,
|
|
|
|
filtered_names = filtered_names,
|
|
selected_idx = 1,
|
|
search_bar = "",
|
|
scroll = 0
|
|
}
|
|
self.right_store = {
|
|
total_items = {},
|
|
items = {},
|
|
bundles = {},
|
|
|
|
filtered_names = {},
|
|
selected_idx = 1,
|
|
search_bar = "",
|
|
scroll = 0
|
|
}
|
|
end
|
|
end
|
|
|
|
|
|
function main_view:list_filtered_names(items, bundles, name_filter)
|
|
name_filter = name_filter:lower()
|
|
|
|
local names = {}
|
|
for name, count in pairs(items) do
|
|
local display_name = self.item_details[name].display_name:lower()
|
|
if display_name:find(name_filter) and count > 0 then
|
|
table.insert(names, name)
|
|
end
|
|
end
|
|
|
|
for name, count in pairs(bundles) do
|
|
if name:find(name_filter) and count > 0 then
|
|
table.insert(names, name)
|
|
end
|
|
end
|
|
|
|
sort_names_by_counts(names, items, bundles)
|
|
|
|
return names
|
|
end
|
|
|
|
function main_view:refresh_filtered_names(store, area)
|
|
store.filtered_names = main_view:list_filtered_names(store.items, store.bundles, store.search_bar or "")
|
|
self:set_selected_option(store, area, store.selected_idx)
|
|
end
|
|
|
|
function main_view:set_selected_option(store, area, idx)
|
|
local filtered_count = #store.filtered_names
|
|
store.selected_idx = clamp(idx, 1, filtered_count)
|
|
|
|
local item_list_height = area.h-1
|
|
|
|
if store.scroll+item_list_height > filtered_count and filtered_count > item_list_height then
|
|
store.scroll = filtered_count-item_list_height
|
|
end
|
|
|
|
local margin = 2
|
|
if store.selected_idx > store.scroll+item_list_height-margin then
|
|
local max_scroll = math.max(filtered_count - item_list_height, 0)
|
|
store.scroll = math.min(store.selected_idx-item_list_height+margin, max_scroll)
|
|
elseif store.selected_idx <= store.scroll+margin then
|
|
store.scroll = math.max(store.selected_idx-1-margin, 0)
|
|
end
|
|
end
|
|
|
|
function main_view:select_option(store, area, item_name)
|
|
for i, name in ipairs(store.filtered_names) do
|
|
if name == item_name then
|
|
self:set_selected_option(store, area, i)
|
|
return
|
|
end
|
|
end
|
|
end
|
|
|
|
function main_view:process_movement_keys(store, area)
|
|
if self.down_pressed then
|
|
self:set_selected_option(store, area, store.selected_idx + 1)
|
|
elseif self.up_pressed then
|
|
self:set_selected_option(store, area, store.selected_idx - 1)
|
|
end
|
|
|
|
local lstore = self.left_store
|
|
local rstore = self.right_store
|
|
|
|
local left_selected = lstore.filtered_names[lstore.selected_idx]
|
|
local right_selected = rstore.filtered_names[rstore.selected_idx]
|
|
local selected_option = self.is_left_active and left_selected or right_selected
|
|
|
|
if selected_option and (self.right_pressed or self.left_pressed) then
|
|
if is_bundle_name(selected_option) then
|
|
local bundle_name = selected_option
|
|
local bundle = self.bundle_details[bundle_name]
|
|
|
|
if self.right_pressed and lstore.bundles[bundle_name] > 0 then
|
|
for item, count in pairs(bundle) do
|
|
lstore.items[item] = lstore.items[item] - count
|
|
end
|
|
local transferred = math.min(lstore.bundles[bundle_name], 1)
|
|
rstore.bundles[bundle_name] = (rstore.bundles[bundle_name] or 0) + transferred
|
|
|
|
elseif self.left_pressed and rstore.bundles[bundle_name] > 0 then
|
|
for item, count in pairs(bundle) do
|
|
lstore.items[item] = lstore.items[item] + count
|
|
end
|
|
local transferred = math.min(rstore.bundles[bundle_name], 1)
|
|
rstore.bundles[bundle_name] = rstore.bundles[bundle_name] - transferred
|
|
end
|
|
else
|
|
local item = selected_option
|
|
local stack_size = self.item_details[item].stack_size
|
|
|
|
local src_items, dest_items
|
|
if self.right_pressed then
|
|
src_items, dest_items = lstore.items, rstore.items
|
|
elseif self.left_pressed then
|
|
src_items, dest_items = rstore.items, lstore.items
|
|
end
|
|
|
|
local transferred = math.min(src_items[item] or 0, stack_size)
|
|
src_items[item] = (src_items[item] or 0) - transferred
|
|
dest_items[item] = (dest_items[item] or 0) + transferred
|
|
end
|
|
|
|
lstore.bundles = derive_available_bundles(lstore.items, self.bundle_details)
|
|
self:refresh_filtered_names(lstore, self.left_area)
|
|
self:refresh_filtered_names(rstore, self.right_area)
|
|
self:select_option(store, area, selected_option)
|
|
end
|
|
end
|
|
|
|
function main_view:display_list(store, area, selected_idx)
|
|
term_stack.push_cursor(area.x, area.y)
|
|
|
|
local filtered_count = #store.filtered_names
|
|
|
|
local function get_number_width(num)
|
|
return math.floor(math.log(num, 10) + 1)
|
|
end
|
|
local function is_integer(num)
|
|
return num % 1 == 0
|
|
end
|
|
|
|
local count_collumn_width
|
|
do -- Figure out how wide does the count column need to be
|
|
local max_count = 0
|
|
for row=1, math.min(area.h, filtered_count) do
|
|
local name = store.filtered_names[row + store.scroll]
|
|
if name then
|
|
if is_bundle_name(name) then
|
|
max_count = math.max(max_count, store.bundles[name])
|
|
else
|
|
max_count = math.max(max_count, store.items[name])
|
|
end
|
|
end
|
|
end
|
|
|
|
count_collumn_width = get_number_width(max_count)
|
|
if not is_integer(max_count) then
|
|
count_collumn_width = count_collumn_width + 1
|
|
end
|
|
end
|
|
|
|
do -- Display the options
|
|
for row=1, math.min(area.h, filtered_count) do
|
|
local i = row + store.scroll
|
|
local name = store.filtered_names[i]
|
|
if name then
|
|
local count, display_name
|
|
|
|
if is_bundle_name(name) then
|
|
count, display_name = store.bundles[name], name
|
|
else
|
|
count, display_name = store.items[name], self.item_details[name].display_name
|
|
end
|
|
|
|
local count_width = math.floor(math.log(count, 10) + 1)
|
|
if i == selected_idx then
|
|
term.setTextColor(colors.yellow)
|
|
else
|
|
term.setTextColor(colors.white)
|
|
end
|
|
if is_integer(count) then
|
|
term.setCursorPos((count_collumn_width+1 - count_width), row)
|
|
term.write(count)
|
|
else
|
|
term.setCursorPos((count_collumn_width+1 - count_width - 1), row)
|
|
if count >= 1 then
|
|
term.write(math.floor(count))
|
|
end
|
|
term.write("*")
|
|
end
|
|
term.setCursorPos(count_collumn_width+2, row)
|
|
term.write(ensure_width(display_name, area.w-count_collumn_width-1))
|
|
end
|
|
end
|
|
end
|
|
|
|
do -- Display the scrollbar on the right
|
|
if filtered_count > area.h then
|
|
local total_height = math.max(filtered_count)
|
|
local scroll_height = math.max(1, area.h/total_height*area.h)
|
|
local y = 1+store.scroll/filtered_count*area.h
|
|
paintutils.drawLine(area.w, y, area.w, y+scroll_height-1, colors.lightGray)
|
|
end
|
|
end
|
|
|
|
term_stack.pop_cursor()
|
|
end
|
|
|
|
function main_view:display_list_with_search(store, area, active)
|
|
term_stack.push_cursor(area.x, area.y)
|
|
|
|
local new_search_bar = ui:textbox(area.w, active, "Search", store.search_bar)
|
|
if new_search_bar ~= store.search_bar then
|
|
store.search_bar = new_search_bar
|
|
self:refresh_filtered_names(store, area)
|
|
end
|
|
|
|
if active then
|
|
self:process_movement_keys(store, area)
|
|
end
|
|
|
|
term.setBackgroundColor(colors.black)
|
|
main_view:display_list(store, rect(1, 2, area.w, area.h-1), active and store.selected_idx)
|
|
|
|
term_stack.pop_cursor()
|
|
end
|
|
|
|
|
|
|
|
|
|
function main_view:move_item(item_name, amount, destination)
|
|
local item_collection = self.item_registry[item_name]
|
|
|
|
local moved_amount = 0
|
|
while moved_amount < amount and item_collection.count > 0 do
|
|
local slot_details = item_collection[#item_collection]
|
|
|
|
local needed_amount = amount - moved_amount
|
|
local transferred_amount = peripheral.call(slot_details.peripheral, "pushItems", destination, slot_details.slot, needed_amount)
|
|
if transferred_amount == 0 then break end
|
|
|
|
moved_amount = moved_amount + transferred_amount
|
|
slot_details.count = slot_details.count - transferred_amount
|
|
item_collection.count = item_collection.count - transferred_amount
|
|
if slot_details.count == 0 then
|
|
table.remove(item_collection)
|
|
end
|
|
end
|
|
|
|
return moved_amount
|
|
end
|
|
|
|
function main_view:has_selected_items()
|
|
for _, count in pairs(main_view.right_store.items) do
|
|
if count > 0 then return true end
|
|
end
|
|
for _, count in pairs(main_view.right_store.bundles) do
|
|
if count > 0 then return true end
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
function main_view:refresh_items()
|
|
self.item_registry = list_items(self.inventories)
|
|
populate_item_details(self.item_details, self.item_registry)
|
|
|
|
self.right_store.items = {}
|
|
self.right_store.bundles = {}
|
|
self.left_store.items = get_item_counts(self.item_registry)
|
|
self.left_store.bundles = derive_available_bundles(self.left_store.items, self.bundle_details)
|
|
self:refresh_filtered_names(self.left_store, self.left_area)
|
|
self:refresh_filtered_names(self.right_store, self.right_area)
|
|
end
|
|
|
|
function main_view:deposit_items()
|
|
for slot, item in pairs(peripheral.call(self.result_inventory, "list")) do
|
|
local total_transferred = 0
|
|
for _, inventory in ipairs(self.inventories) do
|
|
local transferred = peripheral.call(self.result_inventory, "pushItems", inventory, slot)
|
|
total_transferred = total_transferred + transferred
|
|
|
|
if total_transferred == item.count then break end
|
|
end
|
|
end
|
|
self:refresh_items()
|
|
end
|
|
|
|
function main_view:save_bundle(name, items)
|
|
self.bundles[name] = items
|
|
end
|
|
|
|
function main_view:display_bundle_popup(area)
|
|
term_stack.push_cursor(area.x, area.y)
|
|
-- Draw ascii box around textbox
|
|
term.setBackgroundColor(colors.black)
|
|
term.setTextColor(colors.lightGray)
|
|
term.write("+")
|
|
hline(2, 1, area.w-2)
|
|
term.write("+")
|
|
term.setCursorPos(1, 2)
|
|
term.write("|")
|
|
term.setCursorPos(area.w, 2)
|
|
term.write("|")
|
|
term.setCursorPos(1, 3)
|
|
term.write("+")
|
|
hline(2, 3, area.w-2)
|
|
term.write("+")
|
|
|
|
term_stack.push_cursor(2, 2)
|
|
self.bundle_name = ui:textbox(area.w-2, true, "Name", self.bundle_name)
|
|
term_stack.pop_cursor()
|
|
term_stack.pop_cursor()
|
|
|
|
if self.tab_pressed then
|
|
self.bundle_popup = false
|
|
elseif self.submit_pressed and #self.bundle_name > 0 then
|
|
self.bundle_popup = false
|
|
self:save_bundle(self.bundle_name, self.right_store.items)
|
|
end
|
|
end
|
|
|
|
function main_view:request_items()
|
|
local lstore = self.left_store
|
|
local rstore = self.right_store
|
|
|
|
if self:has_selected_items() then
|
|
for name, count in pairs(rstore.items) do
|
|
local transferred = self:move_item(name, count, self.result_inventory)
|
|
lstore.items[name] = lstore.items[name] + (count - transferred)
|
|
end
|
|
for bundle_name, bundle_count in pairs(rstore.bundles) do
|
|
bundle_count = math.max(bundle_count, 1)
|
|
for item, count in pairs(self.bundle_details[bundle_name]) do
|
|
local transferred = self:move_item(item, count*bundle_count, self.result_inventory)
|
|
lstore.items[item] = lstore.items[item] + (count*bundle_count - transferred)
|
|
end
|
|
end
|
|
|
|
rstore.items = {}
|
|
rstore.bundles = {}
|
|
lstore.bundles = derive_available_bundles(lstore.items, self.bundle_details)
|
|
self:refresh_filtered_names(lstore, self.left_area)
|
|
self:refresh_filtered_names(rstore, self.right_area)
|
|
else
|
|
local selected_option = lstore.filtered_names[lstore.selected_idx]
|
|
if is_bundle_name(selected_option) then
|
|
local bundle_name = selected_option
|
|
for item, count in pairs(self.bundle_details[bundle_name]) do
|
|
local transferred = self:move_item(item, count, self.result_inventory)
|
|
lstore.items[item] = lstore.items[item] - transferred
|
|
end
|
|
else
|
|
local item = selected_option
|
|
local stack_size = self.item_details[item].stack_size
|
|
local transferred_count = self:move_item(item, stack_size, self.result_inventory)
|
|
lstore.items[item] = lstore.items[item] - transferred_count
|
|
end
|
|
|
|
lstore.bundles = derive_available_bundles(lstore.items, self.bundle_details)
|
|
self:refresh_filtered_names(lstore, self.left_area)
|
|
self:select_option(lstore, self.left_area, selected_option)
|
|
end
|
|
end
|
|
|
|
function main_view:run()
|
|
term.setBackgroundColor(colors.black)
|
|
term.clear()
|
|
|
|
local has_selected_items = self:has_selected_items()
|
|
if has_selected_items then
|
|
term.setTextColor(colors.lightGray)
|
|
vline(self.split_x, self.main_area.y, self.main_area.h)
|
|
|
|
main_view:display_list_with_search(self.left_store, self.left_area, self.is_left_active and not self.bundle_popup)
|
|
main_view:display_list_with_search(self.right_store, self.right_area, not self.is_left_active and not self.bundle_popup)
|
|
else
|
|
main_view:display_list_with_search(self.left_store, self.main_area, not self.bundle_popup)
|
|
end
|
|
|
|
if self.bundle_popup then
|
|
local w = self.main_area.w - 4
|
|
local h = 3
|
|
local area = rect(
|
|
1+math.floor((self.main_area.w-w)/2),
|
|
1+math.floor((self.main_area.h-h)/2),
|
|
w, h
|
|
)
|
|
self:display_bundle_popup(area)
|
|
end
|
|
|
|
self.up_pressed = false
|
|
self.down_pressed = false
|
|
self.left_pressed = false
|
|
self.right_pressed = false
|
|
self.tab_pressed = false
|
|
end
|
|
|
|
function main_view:on_event(event, ...)
|
|
local has_selected_items = self:has_selected_items()
|
|
if not has_selected_items and not self.is_left_active then
|
|
self.is_left_active = true
|
|
end
|
|
|
|
if event == "key" then
|
|
self:on_key(...)
|
|
elseif event == "key_up" then
|
|
self:on_key_up(...)
|
|
end
|
|
end
|
|
|
|
function main_view:on_key(key)
|
|
self.up_pressed = key == keys.up or (self.ctrl_down and key == keys.k)
|
|
self.down_pressed = key == keys.down or (self.ctrl_down and key == keys.j)
|
|
self.left_pressed = key == keys.left or (self.ctrl_down and key == keys.h)
|
|
self.right_pressed = key == keys.right or (self.ctrl_down and key == keys.l)
|
|
self.submit_pressed = key == keys.enter or (self.ctrl_down and key == keys.space)
|
|
self.tab_pressed = key == keys.tab
|
|
|
|
if key == keys.rightCtrl or key == keys.leftCtrl then
|
|
self.ctrl_down = true
|
|
elseif key == keys.rightAlt or key == keys.leftAlt then
|
|
self.alt_down = true
|
|
end
|
|
|
|
if not self.bundle_popup then
|
|
if key == keys.n and self:has_selected_items() then
|
|
self.bundle_popup = true
|
|
|
|
elseif key == keys.tab then
|
|
self.is_left_active = not self.is_left_active
|
|
|
|
elseif key == keys.f5 then
|
|
self:refresh_items()
|
|
|
|
elseif self.submit_pressed then
|
|
self:request_items()
|
|
|
|
elseif self.ctrl_down and key == keys.d then
|
|
self:deposit_items()
|
|
|
|
end
|
|
end
|
|
end
|
|
|
|
function main_view:on_key_up(key)
|
|
if key == keys.rightCtrl or key == keys.leftCtrl then
|
|
self.ctrl_down = false
|
|
elseif key == keys.rightAlt or key == keys.leftAlt then
|
|
self.alt_down = false
|
|
end
|
|
end
|
|
|
|
return main_view
|