789 lines
22 KiB
Lua
789 lines
22 KiB
Lua
local term_stack = require("term-stack")
|
|
local ensure_width = require("cc.strings").ensure_width
|
|
local ui = require("ui")
|
|
local main_view = {}
|
|
|
|
local nbt_sensitive_names = {
|
|
"minecraft:potion", "minecraft:enchanted_book"
|
|
}
|
|
|
|
local display_name_transformers = {
|
|
["minecraft:enchanted_book"] = function(detail)
|
|
local enchantments = {}
|
|
for _, enchant in ipairs(detail.enchantments) do
|
|
table.insert(enchantments, enchant.displayName)
|
|
end
|
|
return table.concat(enchantments, ", ") .. " Book"
|
|
end
|
|
}
|
|
|
|
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 is_integer(num)
|
|
return num % 1 == 0
|
|
end
|
|
|
|
local function does_array_contain(array, value)
|
|
for _, v in ipairs(array) do
|
|
if v == value then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
local function add_item_detail(item_details, name, detail)
|
|
if item_details[name] then return end
|
|
|
|
local display_name
|
|
if not display_name_transformers[detail.name] then
|
|
display_name = detail.displayName
|
|
else
|
|
display_name = display_name_transformers[detail.name](detail)
|
|
end
|
|
|
|
item_details[name] = {
|
|
display_name = display_name,
|
|
stack_size = detail.maxCount
|
|
}
|
|
end
|
|
|
|
local function list_items(inventories, item_details)
|
|
local item_registry = {}
|
|
for _, name in ipairs(inventories) do
|
|
for slot, item in pairs(peripheral.call(name, "list")) do
|
|
local item_name = item.name
|
|
if does_array_contain(nbt_sensitive_names, item_name) then
|
|
local detail = peripheral.call(name, "getItemDetail", slot)
|
|
item_name = item_name .. "#" .. item.nbt
|
|
add_item_detail(item_details, item_name, detail)
|
|
end
|
|
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)
|
|
add_item_detail(item_details, name, detail)
|
|
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
|
|
|
|
local function do_bundles_contain_cycle(bundles)
|
|
local visited = {}
|
|
local stack = {}
|
|
|
|
local function is_cyclic_util(bundle_name)
|
|
if not visited[bundle_name] then
|
|
visited[bundle_name] = true
|
|
stack[bundle_name] = true
|
|
|
|
for dep_name in pairs(bundles[bundle_name]) do
|
|
if is_bundle_name(dep_name) then
|
|
dep_name = dep_name:sub(2)
|
|
if not visited[dep_name] and is_cyclic_util(dep_name) then
|
|
return true
|
|
elseif stack[dep_name] then
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
stack[bundle_name] = false
|
|
return false
|
|
end
|
|
|
|
for bundle_name in pairs(bundles) do
|
|
if not visited[bundle_name] and is_cyclic_util(bundle_name) then
|
|
return true
|
|
end
|
|
end
|
|
|
|
return false
|
|
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_details = {}
|
|
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:save_to_file(filename)
|
|
local f, err = io.open(filename, "w")
|
|
if not f then return nil, err end
|
|
|
|
f:write(textutils.serialise{
|
|
inventories = self.inventories,
|
|
bundles = self.bundles,
|
|
result_inventory = self.result_inventory
|
|
})
|
|
|
|
f:close()
|
|
end
|
|
|
|
function main_view:load_from_file(filename)
|
|
local f, err = io.open(filename, "r")
|
|
if not f then return nil, err end
|
|
|
|
local data = textutils.unserialise(f:read("a"))
|
|
|
|
main_view:prepare(data.inventories, data.bundles, data.result_inventory)
|
|
|
|
f:close()
|
|
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
|
|
local transferred = math.min(lstore.bundles[bundle_name], 1)
|
|
for item, count in pairs(bundle) do
|
|
lstore.items[item] = lstore.items[item] - math.floor(count * transferred)
|
|
end
|
|
rstore.bundles[bundle_name] = (rstore.bundles[bundle_name] or 0) + transferred
|
|
elseif self.left_pressed and rstore.bundles[bundle_name] > 0 then
|
|
local transferred
|
|
if is_integer(rstore.bundles[bundle_name]) then
|
|
transferred = math.min(rstore.bundles[bundle_name], 1)
|
|
else
|
|
transferred = rstore.bundles[bundle_name] % 1
|
|
end
|
|
for item, count in pairs(bundle) do
|
|
lstore.items[item] = lstore.items[item] + math.floor(count * transferred)
|
|
end
|
|
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 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, self.item_details)
|
|
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, bundles)
|
|
local bundle = {}
|
|
for item, count in pairs(items) do
|
|
if count > 0 then
|
|
bundle[item] = count
|
|
end
|
|
end
|
|
for bundle_name, count in pairs(bundles) do
|
|
if count > 0 then
|
|
bundle[bundle_name] = count
|
|
end
|
|
end
|
|
self.bundles[name] = bundle
|
|
if do_bundles_contain_cycle(self.bundles) then
|
|
self.bundles[name] = nil
|
|
return false
|
|
end
|
|
|
|
populate_bundle_details(self.bundle_details, self.bundles)
|
|
self.left_store.bundles = derive_available_bundles(self.left_store.items, self.bundle_details)
|
|
self:refresh_filtered_names(self.left_store, self.left_area)
|
|
|
|
if self.save_file then
|
|
self:save_to_file(self.save_file)
|
|
end
|
|
|
|
return true
|
|
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
|
|
local success = self:save_bundle(self.bundle_name, self.right_store.items, self.right_store.bundles)
|
|
if success then
|
|
self.bundle_name = ""
|
|
end
|
|
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 amount = math.floor(count*bundle_count)
|
|
local transferred = self:move_item(item, amount, self.result_inventory)
|
|
lstore.items[item] = lstore.items[item] + (amount - 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
|
|
local bundle_count = math.min(lstore.bundles[bundle_name], 1)
|
|
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] - math.floor(transferred * bundle_count)
|
|
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 self.ctrl_down and 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
|