forked from thunderdog1138/star_wars
Delete 'mods/unified_inventory/match_craft.lua'
This commit is contained in:
parent
d33dfa13a0
commit
d55198584c
|
|
@ -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
|
||||
Loading…
Reference in New Issue