tool_station = {} local tool_list_cache = nil function tool_station.get_tool_type_list(ix, iy, mx) local formspec = "" local x = 0 local y = 0 formspec = formspec..("button[%d,%d;1,1;anvil;Anvil]"):format(x + ix, y + iy) x = x + 1 for t, tool in pairs(tinkering.tools) do local toolmod = tool.mod_name or "tinkering" formspec = formspec.. ("item_image_button[%d,%d;1,1;%s;%s;]"):format(x + ix, y + iy, toolmod..":steel_"..t, t) formspec = formspec.. ("tooltip[%s;%s]"):format(t, tool.description) x = x + 1 if x >= mx then y = y + 1 x = 0 end end return formspec end function tool_station.get_formspec(comp_list) if not tool_list_cache then tool_list_cache = tool_station.get_tool_type_list(8, 0, 5) end local x = 1 local y = 0 local til = "" for _,comp in pairs(comp_list) do local img = tinkering.components[comp].image .. "^[colorize:#1e1e1e:255" til = til .. "image[" .. (x * 1) .. "," .. (y + 0.8) .. ";1,1;".. img .. "]" y = y + 1 if y > 2 then y = 0 x = x + 1 end end return "size[13,8.5]".. default.gui_bg.. default.gui_bg_img.. default.gui_slots.. "label[0,0;Tool Station]".. til.. "list[context;input;1,0.8;3,3;]".. "list[context;output;5,1.8;1,1;]".. "image[4,1.8;1,1;gui_furnace_arrow_bg.png^[transformR270]".. "list[current_player;main;0,4.25;8,1;]".. "list[current_player;main;0,5.5;8,3;8]".. tool_list_cache.. "listring[context;input]".. "listring[context;output]".. "listring[current_player;main]".. default.get_hotbar_bg(0, 4.25) end local function get_metalgroup(groups) if not groups then return nil end for g,i in pairs(groups) do if g:find("material_") == 1 then return g:gsub("^material_", "") end end return nil end -- Get tool components from specified stacks function tool_station.get_types(list, tool_type) local tool = tinkering.tools[tool_type] if not tool then return nil end local result = {} local items_required = {} local components = {} for _,stack in pairs(list) do if not result then break end local stack_name = stack:get_name() for tt, ty in pairs(tool.components) do if not result then break end local in_grp = minetest.get_item_group(stack_name, "tc_"..ty) > 0 if in_grp then if components[tt] == nil then local mtg = get_metalgroup(minetest.registered_items[stack_name].groups) if mtg ~= nil then result[tt] = mtg if not items_required[stack_name] then items_required[stack_name] = 0 end items_required[stack_name] = items_required[stack_name] + 1 components[tt] = true end else -- Don't allow multiple components of the same type to avoid confusion result = nil items_required = nil components = {} break end end end end return result, items_required end function tool_station.get_tool(list) local tool_fnd = nil local tool_type = nil for _,stack in pairs(list) do local stack_name = stack:get_name() if minetest.get_item_group(stack_name, "tinker_tool") > 0 then if tool_fnd == nil then for t in pairs(tinkering.tools) do if minetest.get_item_group(stack_name, "tinker_"..t) > 0 then tool_type = t break end end tool_fnd = stack else -- Don't allow multiple tools in the repair grid at the same time to avoid confusion tool_fnd = nil break end end end return tool_fnd, tool_type end local function decode_meta(s) local t = {} for k, v in string.gmatch(s, "(%w+)=(%w+)") do t[k] = v end return t end local function find_material(stack) -- Meltables for metal,list in pairs(metal_melter.melts) do for type,stacks in pairs(list) do for _,st in pairs(stacks) do if st == stack then return metal, type end end end end -- Grouped for mat,iv in pairs(tinkering.materials) do if iv.base == "group" and minetest.get_item_group(stack, iv.default) > 0 then return mat, "block" elseif stack == iv.default then return mat, "ingot" end end return nil end local function get_materials_in_list(list, skip) local result = {} for _,stack in pairs(list) do local stack_name = stack:get_name() if stack_name ~= "" and stack_name ~= skip then local material, type = find_material(stack_name) if material then if result[material] then result[material].count = result[material].count + stack:get_count() else result[material] = {stack = stack_name, type = type, count = stack:get_count()} end end end end return result end local function match_materials(list1, materials) local matches = {} for name,type in pairs(materials) do if list1[type] then matches[type] = list1[type] end end -- Return nothing if there are materials not suitable for name in pairs(list1) do if not matches[name] then matches = {} break end end return matches end local function take_from_list(list, item, list2) for _,stack in pairs(list) do local stack_name = stack:get_name() if stack_name == item then stack:clear() elseif list2[stack_name] then if list2[stack_name] > stack:get_count() then list2[stack_name] = list2[stack_name] - stack:get_count() stack:clear() else stack:set_count(stack:get_count() - list2[stack_name]) list2[stack_name] = 0 end end end return list end local function handle_take_output(pos, listname) local meta = minetest.get_meta(pos) local inv = meta:get_inventory() local tooltype = meta:get_string("tool_type") local list = inv:get_list(listname) if tooltype ~= "" then local types, items = tool_station.get_types(list, tooltype) if not types then return end local res = {} for _,stack in pairs(list) do local stack_name = stack:get_name() if items[stack_name] then if not res[stack_name] then res[stack_name] = items[stack_name] end if res[stack_name] > 0 then if stack:get_count() > res[stack_name] then stack:set_count(stack:get_count() - res[stack_name]) res[stack_name] = 0 else res[stack_name] = res[stack_name] - stack:get_count() stack:clear() end end end end inv:set_list(listname, list) else local tool, tool_type_ = tool_station.get_tool(list) if tool then local comp_mats = tool:get_meta():get_string("materials") if comp_mats and comp_mats ~= "" then local materials = decode_meta(comp_mats) -- Material list found, now we can start doing repair work or replacing a component local mat_grid = get_materials_in_list(list, tool:get_name()) -- Find components to remove local for_removal = {} local removed_types = {} local repair = true local tool_comps = tinkering.tools[tool_type_].components for mat, stat in pairs(mat_grid) do for name, comp in pairs(tool_comps) do if stat.type == comp and not removed_types[comp] then for_removal[stat.stack] = 1 removed_types[comp] = true repair = false end end end if not repair then inv:set_list(listname, take_from_list(list, tool:get_name(), for_removal)) end if tool:get_wear() ~= 0 and repair then local matches = match_materials(mat_grid, materials) local repair_cap = 0 for mat, stat in pairs(matches) do repair_cap = repair_cap + math.min(stat.count, 3) end if repair_cap > 0 then local _take = 1 for i = 1, repair_cap do local tool_wear = 65535 - tool:get_wear() local repair_cnt = (0.33 * 65535) * i local new_wear = 65535 - (tool_wear + repair_cnt) if new_wear > 0 then _take = _take + 1 end end local to_take = {} local exch = _take for type, c in pairs(matches) do if not to_take[c.stack] then to_take[c.stack] = 0 end if c.count < exch then to_take[c.stack] = to_take[c.stack] + c.count exch = exch - 1 else to_take[c.stack] = to_take[c.stack] + exch break end end inv:set_list(listname, take_from_list(list, tool:get_name(), to_take)) end end end end end end local function on_timer(pos, elapsed) local meta = minetest.get_meta(pos) local inv = meta:get_inventory() local refresh = false local output = nil -- Get selected tool type local tool_type = meta:get_string("tool_type") local list = inv:get_list("input") if tool_type ~= "" then local results = tool_station.get_types(list, tool_type) if results then -- Attempt to create the tool with the provided materials local tool_res = tinkering.create_tool(tool_type, results, true) if tool_res then output = tool_res end end meta:set_string("formspec", tool_station.get_formspec(tinkering.tools[tool_type].components)) else local tool, tool_type_ = tool_station.get_tool(list) if tool then local comp_mats = tool:get_meta():get_string("materials") if comp_mats and comp_mats ~= "" then local materials = decode_meta(comp_mats) -- Material list found, now we can start doing repair work or replacing a component local mat_grid = get_materials_in_list(list, tool:get_name()) -- Find components to replace local comp_repl = {} local repair = true local tool_comps = tinkering.tools[tool_type_].components for mat, stat in pairs(mat_grid) do if comp_repl == nil then break end for name, comp in pairs(tool_comps) do if stat.type == comp then if comp_repl[name] then -- Dont allow multiple of the same component to avoid confusion comp_repl = nil break else comp_repl[name] = mat end repair = false end end end if not repair and comp_repl then -- Add non-replacement materials back for i,v in pairs(materials) do if not comp_repl[i] then comp_repl[i] = v end end local tool_res = tinkering.create_tool(tool_type_, comp_repl, true, nil, {wear = tool:get_wear()}) if tool_res then output = tool_res end end -- Attempt to repair tool with provided items if tool:get_wear() ~= 0 and repair then local matches = match_materials(mat_grid, materials) local repair_cap = 0 for mat, stat in pairs(matches) do repair_cap = repair_cap + math.min(stat.count, 3) end if repair_cap > 0 then local tool_wear = 65535 - tool:get_wear() local repair_cnt = (0.33 * 65535) * repair_cap local new_wear = 65535 - (tool_wear + repair_cnt) if new_wear < 0 then new_wear = 0 end local tool_res = tinkering.create_tool(tool_type_, materials, true, nil, {wear = new_wear}) if tool_res then output = tool_res end end end end end meta:set_string("formspec", tool_station.get_formspec({})) end if output then inv:set_list("output", {output}) else inv:set_list("output", {}) end return refresh end local function allow_metadata_inventory_put (pos, listname, index, stack, player) if minetest.is_protected(pos, player:get_player_name()) then return 0 end if listname == "output" then return 0 end return stack:get_count() end local function allow_metadata_inventory_move (pos, from_list, from_index, to_list, to_index, count, player) local meta = minetest.get_meta(pos) local inv = meta:get_inventory() local stack = inv:get_stack(from_list, from_index) return allow_metadata_inventory_put(pos, to_list, to_index, stack, player) end local function allow_metadata_inventory_take (pos, listname, index, stack, player) if minetest.is_protected(pos, player:get_player_name()) then return 0 end return stack:get_count() end local function on_construct(pos) local meta = minetest.get_meta(pos) meta:set_string("formspec", tool_station.get_formspec({})) -- Create inventory local inv = meta:get_inventory() inv:set_size('input', 9) inv:set_size('output', 1) -- Set tool type meta meta:set_string("tool_type", "") end local function on_take(pos, listname, index, stack, player) local inv = minetest.get_meta(pos):get_inventory() if listname == "output" then handle_take_output(pos, "input") end minetest.get_node_timer(pos):start(0.02) end local function can_dig(pos, player) local meta = minetest.get_meta(pos) local inv = meta:get_inventory() return inv:is_empty("input") and inv:is_empty("output") end local function on_receive_fields(pos, formname, fields, sender) if sender and minetest.is_protected(pos, sender:get_player_name()) then return 0 end local meta = minetest.get_meta(pos) if fields["anvil"] then meta:set_string("tool_type", "") else for name,_ in pairs(fields) do if tinkering.tools[name] then meta:set_string("tool_type", name) break end end end minetest.get_node_timer(pos):start(0.02) end minetest.register_node("tinkering:tool_station", { description = "Tool Station", tiles = { "tinkering_workbench_top.png", "tinkering_bench_bottom.png", "tinkering_bench_side.png", "tinkering_bench_side.png", "tinkering_bench_side.png", "tinkering_bench_side.png" }, drawtype = "nodebox", paramtype = "light", node_box = tinkering.bench, on_construct = on_construct, legacy_facedir_simple = true, is_ground_content = false, sounds = default.node_sound_wood_defaults(), can_dig = can_dig, on_timer = on_timer, on_construct = on_construct, on_receive_fields = on_receive_fields, on_metadata_inventory_move = function(pos) minetest.get_node_timer(pos):start(0.05) end, on_metadata_inventory_put = function(pos) minetest.get_node_timer(pos):start(0.05) end, on_metadata_inventory_take = on_take, allow_metadata_inventory_put = allow_metadata_inventory_put, allow_metadata_inventory_take = allow_metadata_inventory_take, allow_metadata_inventory_move = allow_metadata_inventory_move, groups = {choppy = 2, oddly_breakable_by_hand = 2} })