From d55198584caa89944bf2ae38dd5f70447c249527 Mon Sep 17 00:00:00 2001 From: thunderdog1138 Date: Sat, 12 Sep 2020 16:21:02 +0000 Subject: [PATCH] Delete 'mods/unified_inventory/match_craft.lua' --- mods/unified_inventory/match_craft.lua | 409 ------------------------- 1 file changed, 409 deletions(-) delete mode 100644 mods/unified_inventory/match_craft.lua diff --git a/mods/unified_inventory/match_craft.lua b/mods/unified_inventory/match_craft.lua deleted file mode 100644 index 2dd40b04..00000000 --- a/mods/unified_inventory/match_craft.lua +++ /dev/null @@ -1,409 +0,0 @@ --- match_craft.lua --- Find and automatically move inventory items to the crafting grid --- according to the recipe. - ---[[ -Retrieve items from inventory lists and calculate their total count. -Return a table of "item name" - "total count" pairs. - -Arguments: - inv: minetest inventory reference - lists: names of inventory lists to use - -Example usage: - -- Count items in "main" and "craft" lists of player inventory - unified_inventory.count_items(player_inv_ref, {"main", "craft"}) - -Example output: - { - ["default:pine_wood"] = 2, - ["default:acacia_wood"] = 4, - ["default:chest"] = 3, - ["default:axe_diamond"] = 2, -- unstackable item are counted too - ["wool:white"] = 6 - } -]]-- -function unified_inventory.count_items(inv, lists) - local counts = {} - - for i = 1, #lists do - local name = lists[i] - local size = inv:get_size(name) - local list = inv:get_list(name) - - for j = 1, size do - local stack = list[j] - - if not stack:is_empty() then - local item = stack:get_name() - local count = stack:get_count() - - counts[item] = (counts[item] or 0) + count - end - end - end - - return counts -end - ---[[ -Retrieve craft recipe items and their positions in the crafting grid. -Return a table of "craft item name" - "set of positions" pairs. - -Note that if craft width is not 3 then positions are recalculated as -if items were placed on a 3x3 grid. Also note that craft can contain -groups of items with "group:" prefix. - -Arguments: - craft: minetest craft recipe - -Example output: - -- Bed recipe - { - ["wool:white"] = {[1] = true, [2] = true, [3] = true} - ["group:wood"] = {[4] = true, [5] = true, [6] = true} - } ---]] -function unified_inventory.count_craft_positions(craft) - local positions = {} - local craft_items = craft.items - local craft_type = unified_inventory.registered_craft_types[craft.type] - or unified_inventory.craft_type_defaults(craft.type, {}) - local display_width = craft_type.dynamic_display_size - and craft_type.dynamic_display_size(craft).width - or craft_type.width - local craft_width = craft_type.get_shaped_craft_width - and craft_type.get_shaped_craft_width(craft) - or display_width - local i = 0 - - for y = 1, 3 do - for x = 1, craft_width do - i = i + 1 - local item = craft_items[i] - - if item ~= nil then - local pos = 3 * (y - 1) + x - local set = positions[item] - - if set ~= nil then - set[pos] = true - else - positions[item] = {[pos] = true} - end - end - end - end - - return positions -end - ---[[ -For every craft item find all matching inventory items. -- If craft item is a group then find all inventory items that matches - this group. -- If craft item is not a group (regular item) then find only this item. - -If inventory doesn't contain needed item then found set is empty for -this item. - -Return a table of "craft item name" - "set of matching inventory items" -pairs. - -Arguments: - inv_items: table with items names as keys - craft_items: table with items names or groups as keys - -Example output: - { - ["group:wood"] = { - ["default:pine_wood"] = true, - ["default:acacia_wood"] = true - }, - ["wool:white"] = { - ["wool:white"] = true - } - } ---]] -function unified_inventory.find_usable_items(inv_items, craft_items) - local get_group = minetest.get_item_group - local result = {} - - for craft_item in pairs(craft_items) do - local group = craft_item:match("^group:(.+)") - local found = {} - - if group ~= nil then - for inv_item in pairs(inv_items) do - if get_group(inv_item, group) > 0 then - found[inv_item] = true - end - end - else - if inv_items[craft_item] ~= nil then - found[craft_item] = true - end - end - - result[craft_item] = found - end - - return result -end - ---[[ -Match inventory items with craft grid positions. -For every position select the matching inventory item with maximum -(total_count / (times_matched + 1)) value. - -If for some position matching item cannot be found or match count is 0 -then return nil. - -Return a table of "matched item name" - "set of craft positions" pairs -and overall match count. - -Arguments: - inv_counts: table of inventory items counts from "count_items" - craft_positions: table of craft positions from "count_craft_positions" - -Example output: - match_table = { - ["wool:white"] = {[1] = true, [2] = true, [3] = true} - ["default:acacia_wood"] = {[4] = true, [6] = true} - ["default:pine_wood"] = {[5] = true} - } - match_count = 2 ---]] -function unified_inventory.match_items(inv_counts, craft_positions) - local usable = unified_inventory.find_usable_items(inv_counts, craft_positions) - local match_table = {} - local match_count - local matches = {} - - for craft_item, pos_set in pairs(craft_positions) do - local use_set = usable[craft_item] - - for pos in pairs(pos_set) do - local pos_item - local pos_count - - for use_item in pairs(use_set) do - local count = inv_counts[use_item] - local times_matched = matches[use_item] or 0 - local new_pos_count = math.floor(count / (times_matched + 1)) - - if pos_count == nil or pos_count < new_pos_count then - pos_item = use_item - pos_count = new_pos_count - end - end - - if pos_item == nil or pos_count == 0 then - return nil - end - - local set = match_table[pos_item] - - if set ~= nil then - set[pos] = true - else - match_table[pos_item] = {[pos] = true} - end - - matches[pos_item] = (matches[pos_item] or 0) + 1 - end - end - - for match_item, times_matched in pairs(matches) do - local count = inv_counts[match_item] - local item_count = math.floor(count / times_matched) - - if match_count == nil or item_count < match_count then - match_count = item_count - end - end - - return match_table, match_count -end - ---[[ -Remove item from inventory lists. -Return stack of actually removed items. - -This function replicates the inv:remove_item function but can accept -multiple lists. - -Arguments: - inv: minetest inventory reference - lists: names of inventory lists - stack: minetest item stack ---]] -function unified_inventory.remove_item(inv, lists, stack) - local removed = ItemStack(nil) - local leftover = ItemStack(stack) - - for i = 1, #lists do - if leftover:is_empty() then - break - end - - local cur_removed = inv:remove_item(lists[i], leftover) - removed:add_item(cur_removed) - leftover:take_item(cur_removed:get_count()) - end - - return removed -end - ---[[ -Add item to inventory lists. -Return leftover stack. - -This function replicates the inv:add_item function but can accept -multiple lists. - -Arguments: - inv: minetest inventory reference - lists: names of inventory lists - stack: minetest item stack ---]] -function unified_inventory.add_item(inv, lists, stack) - local leftover = ItemStack(stack) - - for i = 1, #lists do - if leftover:is_empty() then - break - end - - leftover = inv:add_item(lists[i], leftover) - end - - return leftover -end - ---[[ -Move items from source list to destination list if possible. -Skip positions specified in exclude set. - -Arguments: - inv: minetest inventory reference - src_list: name of source list - dst_list: name of destination list - exclude: set of positions to skip ---]] -function unified_inventory.swap_items(inv, src_list, dst_list, exclude) - local size = inv:get_size(src_list) - local empty = ItemStack(nil) - - for i = 1, size do - if exclude == nil or exclude[i] == nil then - local stack = inv:get_stack(src_list, i) - - if not stack:is_empty() then - inv:set_stack(src_list, i, empty) - local leftover = inv:add_item(dst_list, stack) - - if not leftover:is_empty() then - inv:set_stack(src_list, i, leftover) - end - end - end - end -end - ---[[ -Move matched items to the destination list. - -If destination list position is already occupied with some other item -then function tries to (in that order): -1. Move it to the source list -2. Move it to some other unused position in destination list itself -3. Drop it to the ground if nothing else is possible. - -Arguments: - player: minetest player object - src_list: name of source list - dst_list: name of destination list - match_table: table of matched items - amount: amount of items per every position ---]] -function unified_inventory.move_match(player, src_list, dst_list, match_table, amount) - local inv = player:get_inventory() - local item_drop = minetest.item_drop - local src_dst_list = {src_list, dst_list} - local dst_src_list = {dst_list, src_list} - - local needed = {} - local moved = {} - - -- Remove stacks needed for craft - for item, pos_set in pairs(match_table) do - local stack = ItemStack(item) - local stack_max = stack:get_stack_max() - local bounded_amount = math.min(stack_max, amount) - stack:set_count(bounded_amount) - - for pos in pairs(pos_set) do - needed[pos] = unified_inventory.remove_item(inv, dst_src_list, stack) - end - end - - -- Add already removed stacks - for pos, stack in pairs(needed) do - local occupied = inv:get_stack(dst_list, pos) - inv:set_stack(dst_list, pos, stack) - - if not occupied:is_empty() then - local leftover = unified_inventory.add_item(inv, src_dst_list, occupied) - - if not leftover:is_empty() then - inv:set_stack(dst_list, pos, leftover) - local oversize = unified_inventory.add_item(inv, src_dst_list, stack) - - if not oversize:is_empty() then - item_drop(oversize, player, player:get_pos()) - end - end - end - - moved[pos] = true - end - - -- Swap items from unused positions to src (moved positions excluded) - unified_inventory.swap_items(inv, dst_list, src_list, moved) -end - ---[[ -Find craft match and move matched items to the destination list. - -If match cannot be found or match count is smaller than the desired -amount then do nothing. - -If amount passed is -1 then amount is defined by match count itself. -This is used to indicate "craft All" case. - -Arguments: - player: minetest player object - src_list: name of source list - dst_list: name of destination list - craft: minetest craft recipe - amount: desired amount of output items ---]] -function unified_inventory.craftguide_match_craft(player, src_list, dst_list, craft, amount) - local inv = player:get_inventory() - local src_dst_list = {src_list, dst_list} - - local counts = unified_inventory.count_items(inv, src_dst_list) - local positions = unified_inventory.count_craft_positions(craft) - local match_table, match_count = unified_inventory.match_items(counts, positions) - - if match_table == nil or match_count < amount then - return - end - - if amount == -1 then - amount = match_count - end - - unified_inventory.move_match(player, src_list, dst_list, match_table, amount) -end