forked from VoxeLibre/VoxeLibre
596 lines
18 KiB
Lua
596 lines
18 KiB
Lua
local S = minetest.get_translator(minetest.get_current_modname())
|
|
local F = minetest.formspec_escape
|
|
local C = minetest.colorize
|
|
|
|
local MAX_NAME_LENGTH = 35
|
|
local MAX_WEAR = 65535
|
|
local SAME_TOOL_REPAIR_BOOST = math.ceil(MAX_WEAR * 0.12) -- 12%
|
|
local MATERIAL_TOOL_REPAIR_BOOST = {
|
|
math.ceil(MAX_WEAR * 0.25), -- 25%
|
|
math.ceil(MAX_WEAR * 0.5), -- 50%
|
|
math.ceil(MAX_WEAR * 0.75), -- 75%
|
|
MAX_WEAR, -- 100%
|
|
}
|
|
|
|
---@param set_name? string
|
|
local function get_anvil_formspec(set_name)
|
|
if not set_name then
|
|
set_name = ""
|
|
end
|
|
|
|
return table.concat({
|
|
"formspec_version[4]",
|
|
"size[11.75,10.425]",
|
|
|
|
"label[4.125,0.375;" .. F(C(mcl_formspec.label_color, S("Repair and Name"))) .. "]",
|
|
|
|
"image[0.875,0.375;1.75,1.75;mcl_anvils_inventory_hammer.png]",
|
|
|
|
"field[4.125,0.75;7.25,1;name;;" .. F(set_name) .. "]",
|
|
"field_close_on_enter[name;false]",
|
|
"set_focus[name;true]",
|
|
|
|
mcl_formspec.get_itemslot_bg_v4(1.625, 2.6, 1, 1),
|
|
"list[context;input;1.625,2.6;1,1;]",
|
|
|
|
"image[3.5,2.6;1,1;mcl_anvils_inventory_cross.png]",
|
|
|
|
mcl_formspec.get_itemslot_bg_v4(5.375, 2.6, 1, 1),
|
|
"list[context;input;5.375,2.6;1,1;1]",
|
|
|
|
"image[6.75,2.6;2,1;mcl_anvils_inventory_arrow.png]",
|
|
|
|
mcl_formspec.get_itemslot_bg_v4(9.125, 2.6, 1, 1),
|
|
"list[context;output;9.125,2.6;1,1;]",
|
|
|
|
-- Player Inventory
|
|
|
|
mcl_formspec.get_itemslot_bg_v4(0.375, 5.1, 9, 3),
|
|
"list[current_player;main;0.375,5.1;9,3;9]",
|
|
|
|
mcl_formspec.get_itemslot_bg_v4(0.375, 9.05, 9, 1),
|
|
"list[current_player;main;0.375,9.05;9,1;]",
|
|
|
|
-- Listrings
|
|
|
|
"listring[context;output]",
|
|
"listring[current_player;main]",
|
|
"listring[context;input]",
|
|
"listring[current_player;main]",
|
|
})
|
|
end
|
|
|
|
-- Given a tool and material stack, returns how many items of the material stack
|
|
-- needs to be used up to repair the tool.
|
|
---@param tool ItemStack
|
|
---@param material ItemStack
|
|
---@return integer
|
|
local function get_consumed_materials(tool, material)
|
|
local wear = tool:get_wear()
|
|
--local health = (MAX_WEAR - wear)
|
|
local matsize = material:get_count()
|
|
local materials_used = 0
|
|
for m = 1, math.min(4, matsize) do
|
|
materials_used = materials_used + 1
|
|
if (wear - MATERIAL_TOOL_REPAIR_BOOST[m]) <= 0 then
|
|
break
|
|
end
|
|
end
|
|
return materials_used
|
|
end
|
|
|
|
-- Given 2 input stacks, tells you which is the tool and which is the material.
|
|
-- Returns ("tool", input1, input2) if input1 is tool and input2 is material.
|
|
-- Returns ("material", input2, input1) if input1 is material and input2 is tool.
|
|
-- Returns nil otherwise.
|
|
---@param input1 ItemStack
|
|
---@param input2 ItemStack
|
|
local function distinguish_tool_and_material(input1, input2)
|
|
local def1 = input1:get_definition()
|
|
local def2 = input2:get_definition()
|
|
local r1 = def1._repair_material
|
|
local r2 = def2._repair_material
|
|
if def1.type == "tool" and r1 and type(r1) == "table" and table.indexof(r1, input2) ~= -1 then
|
|
return "tool", input1, input2
|
|
elseif def2.type == "tool" and r2 and type(r2) == "table" and table.indexof(r1, input1) ~= -1 then
|
|
return "material", input2, input1
|
|
elseif def1.type == "tool" and r1 then
|
|
return "tool", input1, input2
|
|
elseif def2.type == "tool" and r2 then
|
|
return "material", input2, input1
|
|
else
|
|
return nil
|
|
end
|
|
end
|
|
|
|
---Helper function to make sure update_anvil_slots NEVER overstacks the output slot
|
|
---@param stack ItemStack
|
|
local function fix_stack_size(stack)
|
|
if not stack or stack == "" then return "" end
|
|
local count = stack:get_count()
|
|
local max_count = stack:get_stack_max()
|
|
|
|
if count > max_count then
|
|
stack:set_count(max_count)
|
|
count = max_count
|
|
end
|
|
return count
|
|
end
|
|
|
|
-- Update the inventory slots of an anvil node.
|
|
-- meta: Metadata of anvil node
|
|
---@param meta NodeMetaRef
|
|
local function update_anvil_slots(meta)
|
|
local inv = meta:get_inventory()
|
|
local new_name = meta:get_string("set_name")
|
|
local input1 = inv:get_stack("input", 1)
|
|
local input2 = inv:get_stack("input", 2)
|
|
--local output = inv:get_stack("output", 1)
|
|
local new_output, name_item
|
|
local just_rename = false
|
|
|
|
-- Both input slots occupied
|
|
if (not input1:is_empty() and not input2:is_empty()) then
|
|
-- Repair, if tool
|
|
local def1 = input1:get_definition()
|
|
local def2 = input2:get_definition()
|
|
|
|
-- Repair calculation helper.
|
|
-- Adds the “inverse” values of wear1 and wear2.
|
|
-- Then adds a boost health value directly.
|
|
-- Returns the resulting (capped) wear.
|
|
local function calculate_repair(wear1, wear2, boost)
|
|
local new_health = (MAX_WEAR - wear1) + (MAX_WEAR - wear2)
|
|
if boost then
|
|
new_health = new_health + boost
|
|
end
|
|
return math.max(0, math.min(MAX_WEAR, MAX_WEAR - new_health))
|
|
end
|
|
|
|
local can_combine = mcl_enchanting.combine(input1, input2)
|
|
|
|
if can_combine then
|
|
-- Add tool health together plus a small bonus
|
|
if def1.type == "tool" and def2.type == "tool" then
|
|
local new_wear = calculate_repair(input1:get_wear(), input2:get_wear(), SAME_TOOL_REPAIR_BOOST)
|
|
input1:set_wear(new_wear)
|
|
end
|
|
|
|
name_item = input1
|
|
new_output = name_item
|
|
-- Tool + repair item
|
|
else
|
|
-- Any tool can have a repair item. This may be defined in the tool's item definition
|
|
-- as an itemstring in the field `_repair_material`. Only if this field is set, the
|
|
-- tool can be repaired with a material item.
|
|
-- Example: Iron Pickaxe + Iron Ingot. `_repair_material = mcl_core:iron_ingot`
|
|
|
|
-- Big repair bonus
|
|
-- TODO: Combine tool enchantments
|
|
local distinguished, tool, material = distinguish_tool_and_material(input1, input2)
|
|
if distinguished then
|
|
local tooldef = tool:get_definition()
|
|
local repair = tooldef._repair_material
|
|
local has_correct_material = false
|
|
local material_name = material:get_name()
|
|
if type(repair) == "string" then
|
|
if string.sub(repair, 1, 6) == "group:" then
|
|
has_correct_material = minetest.get_item_group(material_name, string.sub(repair, 7)) ~= 0
|
|
elseif material_name == repair then
|
|
has_correct_material = true
|
|
end
|
|
else
|
|
if table.indexof(repair, material_name) ~= -1 then
|
|
has_correct_material = true
|
|
else
|
|
for _, r in pairs(repair) do
|
|
if string.sub(r, 1, 6) == "group:" then
|
|
if minetest.get_item_group(material_name, string.sub(r, 7)) ~= 0 then
|
|
has_correct_material = true
|
|
end
|
|
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if has_correct_material and tool:get_wear() > 0 then
|
|
local materials_used = get_consumed_materials(tool, material)
|
|
local new_wear = calculate_repair(tool:get_wear(), MAX_WEAR, MATERIAL_TOOL_REPAIR_BOOST[materials_used])
|
|
tool:set_wear(new_wear)
|
|
name_item = tool
|
|
new_output = name_item
|
|
else
|
|
new_output = ""
|
|
end
|
|
else
|
|
new_output = ""
|
|
end
|
|
end
|
|
-- Exactly 1 input slot occupied
|
|
elseif (not input1:is_empty() and input2:is_empty()) or (input1:is_empty() and not input2:is_empty()) then
|
|
-- Just rename item
|
|
if input1:is_empty() then
|
|
name_item = input2
|
|
else
|
|
name_item = input1
|
|
end
|
|
just_rename = true
|
|
else
|
|
new_output = ""
|
|
end
|
|
|
|
-- Rename handling
|
|
if name_item then
|
|
-- No renaming allowed with group no_rename=1
|
|
if minetest.get_item_group(name_item:get_name(), "no_rename") == 1 then
|
|
new_output = ""
|
|
else
|
|
if new_name == nil then
|
|
new_name = ""
|
|
end
|
|
local meta = name_item:get_meta()
|
|
local old_name = meta:get_string("name")
|
|
-- Limit name length
|
|
new_name = string.sub(new_name, 1, MAX_NAME_LENGTH)
|
|
-- Don't rename if names are identical
|
|
if new_name ~= old_name then
|
|
-- Save the raw name internally
|
|
meta:set_string("name", new_name)
|
|
-- Rename item handled by tt
|
|
tt.reload_itemstack_description(name_item)
|
|
new_output = name_item
|
|
elseif just_rename then
|
|
new_output = ""
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Set the new output slot
|
|
if new_output then
|
|
fix_stack_size(new_output)
|
|
inv:set_stack("output", 1, new_output)
|
|
end
|
|
end
|
|
|
|
---Drop input items of anvil at pos with metadata meta
|
|
---@param pos Vector
|
|
---@param meta NodeMetaRef
|
|
local function drop_anvil_items(pos, meta)
|
|
local inv = meta:get_inventory()
|
|
for i = 1, inv:get_size("input") do
|
|
local stack = inv:get_stack("input", i)
|
|
if not stack:is_empty() then
|
|
local p = vector.offset(pos, math.random(0, 10) / 10 - 0.5, 0, math.random(0, 10) / 10 - 0.5)
|
|
minetest.add_item(p, stack)
|
|
end
|
|
end
|
|
end
|
|
|
|
---@param pos Vector
|
|
---@param node node
|
|
local function damage_particles(pos, node)
|
|
minetest.add_particlespawner({
|
|
amount = 30,
|
|
time = 0.1,
|
|
minpos = vector.offset(pos, -0.5, -0.5, -0.5),
|
|
maxpos = vector.offset(pos, 0.5, -0.25, 0.5),
|
|
minvel = vector.new(-0.5, 0.05, -0.5),
|
|
maxvel = vector.new(0.5, 0.3, 0.5),
|
|
minacc = vector.new(0, -9.81, 0),
|
|
maxacc = vector.new(0, -9.81, 0),
|
|
minexptime = 0.1,
|
|
maxexptime = 0.5,
|
|
minsize = 0.4,
|
|
maxsize = 0.5,
|
|
collisiondetection = true,
|
|
vertical = false,
|
|
node = node,
|
|
})
|
|
end
|
|
|
|
local function destroy_particles(pos, node)
|
|
minetest.add_particlespawner({
|
|
amount = math.random(20, 30),
|
|
time = 0.1,
|
|
minpos = vector.offset(pos, -0.4, -0.4, -0.4),
|
|
maxpos = vector.offset(pos, 0.4, 0.4, 0.4),
|
|
minvel = vector.new(-0.5, -0.1, -0.5),
|
|
maxvel = vector.new(0.5, 0.2, 0.5),
|
|
minacc = vector.new(0, -9.81, 0),
|
|
maxacc = vector.new(0, -9.81, 0),
|
|
minexptime = 0.2,
|
|
maxexptime = 0.65,
|
|
minsize = 0.8,
|
|
maxsize = 1.2,
|
|
collisiondetection = true,
|
|
vertical = false,
|
|
node = node,
|
|
})
|
|
end
|
|
|
|
-- Damage the anvil by 1 level.
|
|
-- Destroy anvil when at highest damage level.
|
|
-- Returns true if anvil was destroyed.
|
|
local function damage_anvil(pos)
|
|
local node = minetest.get_node(pos)
|
|
if node.name == "mcl_anvils:anvil" then
|
|
minetest.swap_node(pos, { name = "mcl_anvils:anvil_damage_1", param2 = node.param2 })
|
|
damage_particles(pos, node)
|
|
minetest.sound_play(mcl_sounds.node_sound_metal_defaults().dig, { pos = pos, max_hear_distance = 16 }, true)
|
|
return false
|
|
elseif node.name == "mcl_anvils:anvil_damage_1" then
|
|
minetest.swap_node(pos, { name = "mcl_anvils:anvil_damage_2", param2 = node.param2 })
|
|
damage_particles(pos, node)
|
|
minetest.sound_play(mcl_sounds.node_sound_metal_defaults().dig, { pos = pos, max_hear_distance = 16 }, true)
|
|
return false
|
|
elseif node.name == "mcl_anvils:anvil_damage_2" then
|
|
-- Destroy anvil
|
|
local meta = minetest.get_meta(pos)
|
|
drop_anvil_items(pos, meta)
|
|
minetest.sound_play(mcl_sounds.node_sound_metal_defaults().dug, { pos = pos, max_hear_distance = 16 }, true)
|
|
minetest.remove_node(pos)
|
|
destroy_particles(pos, node)
|
|
minetest.check_single_for_falling(vector.offset(pos, 0, 1, 0))
|
|
return true
|
|
end
|
|
end
|
|
|
|
---Roll a virtual dice and damage anvil at a low chance.
|
|
---@param pos Vector
|
|
local function damage_anvil_by_using(pos)
|
|
local r = math.random(1, 100)
|
|
-- 12% chance
|
|
if r <= 12 then
|
|
return damage_anvil(pos)
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
---@param pos Vector
|
|
---@param distance number
|
|
local function damage_anvil_by_falling(pos, distance)
|
|
local r = math.random(1, 100)
|
|
if distance > 1 then
|
|
if r <= (5 * distance) then
|
|
damage_anvil(pos)
|
|
end
|
|
end
|
|
end
|
|
|
|
---@type nodebox
|
|
local anvilbox = {
|
|
type = "fixed",
|
|
fixed = {
|
|
{ -8 / 16, -8 / 16, -6 / 16, 8 / 16, 8 / 16, 6 / 16 },
|
|
},
|
|
}
|
|
|
|
---@type node_definition
|
|
local anvildef = {
|
|
groups = { pickaxey = 1, falling_node = 1, falling_node_damage = 1, crush_after_fall = 1, deco_block = 1, anvil = 1 },
|
|
tiles = { "mcl_anvils_anvil_top_damaged_0.png^[transformR90", "mcl_anvils_anvil_base.png", "mcl_anvils_anvil_side.png" },
|
|
use_texture_alpha = "opaque",
|
|
paramtype = "light",
|
|
sunlight_propagates = true,
|
|
is_ground_content = false,
|
|
paramtype2 = "facedir",
|
|
drawtype = "nodebox",
|
|
node_box = {
|
|
type = "fixed",
|
|
fixed = {
|
|
{ -6 / 16, -8 / 16, -6 / 16, 6 / 16, -4 / 16, 6 / 16 },
|
|
{ -5 / 16, -4 / 16, -4 / 16, 5 / 16, -3 / 16, 4 / 16 },
|
|
{ -4 / 16, -3 / 16, -2 / 16, 4 / 16, 2 / 16, 2 / 16 },
|
|
{ -8 / 16, 2 / 16, -5 / 16, 8 / 16, 8 / 16, 5 / 16 },
|
|
},
|
|
},
|
|
selection_box = anvilbox,
|
|
collision_box = anvilbox,
|
|
sounds = mcl_sounds.node_sound_metal_defaults(),
|
|
_mcl_blast_resistance = 1200,
|
|
_mcl_hardness = 5,
|
|
_mcl_after_falling = damage_anvil_by_falling,
|
|
|
|
after_dig_node = function(pos, oldnode, oldmetadata, digger)
|
|
local meta = minetest.get_meta(pos)
|
|
local meta2 = meta:to_table()
|
|
meta:from_table(oldmetadata)
|
|
drop_anvil_items(pos, meta)
|
|
meta:from_table(meta2)
|
|
end,
|
|
allow_metadata_inventory_take = function(pos, listname, index, stack, player)
|
|
local name = player:get_player_name()
|
|
if minetest.is_protected(pos, name) then
|
|
minetest.record_protection_violation(pos, name)
|
|
return 0
|
|
else
|
|
return stack:get_count()
|
|
end
|
|
end,
|
|
allow_metadata_inventory_put = function(pos, listname, index, stack, player)
|
|
local name = player:get_player_name()
|
|
if minetest.is_protected(pos, name) then
|
|
minetest.record_protection_violation(pos, name)
|
|
return 0
|
|
elseif listname == "output" then
|
|
return 0
|
|
else
|
|
return stack:get_count()
|
|
end
|
|
end,
|
|
allow_metadata_inventory_move = function(pos, from_list, from_index, to_list, to_index, count, player)
|
|
local name = player:get_player_name()
|
|
if minetest.is_protected(pos, name) then
|
|
minetest.record_protection_violation(pos, name)
|
|
return 0
|
|
elseif to_list == "output" then
|
|
return 0
|
|
elseif from_list == "output" and to_list == "input" then
|
|
local meta = minetest.get_meta(pos)
|
|
local inv = meta:get_inventory()
|
|
if inv:get_stack(to_list, to_index):is_empty() then
|
|
return count
|
|
else
|
|
return 0
|
|
end
|
|
else
|
|
return count
|
|
end
|
|
end,
|
|
on_metadata_inventory_put = function(pos, listname, index, stack, player)
|
|
local meta = minetest.get_meta(pos)
|
|
update_anvil_slots(meta)
|
|
end,
|
|
on_metadata_inventory_move = function(pos, from_list, from_index, to_list, to_index, count, player)
|
|
local meta = minetest.get_meta(pos)
|
|
if from_list == "output" and to_list == "input" then
|
|
local inv = meta:get_inventory()
|
|
for i = 1, inv:get_size("input") do
|
|
if i ~= to_index then
|
|
local istack = inv:get_stack("input", i)
|
|
istack:set_count(math.max(0, istack:get_count() - count))
|
|
inv:set_stack("input", i, istack)
|
|
end
|
|
end
|
|
end
|
|
update_anvil_slots(meta)
|
|
|
|
if from_list == "output" then
|
|
local destroyed = damage_anvil_by_using(pos)
|
|
-- Close formspec if anvil was destroyed
|
|
if destroyed then
|
|
--[[ Closing the formspec w/ emptyformname is discouraged. But this is justified
|
|
because node formspecs seem to only have an empty formname in MT 0.4.16.
|
|
Also, sice this is on_metadata_inventory_take, we KNOW which formspec has
|
|
been opened by the player. So this should be safe nonetheless.
|
|
TODO: Update this line when node formspecs get proper identifiers in Minetest. ]]
|
|
minetest.close_formspec(player:get_player_name(), "")
|
|
end
|
|
end
|
|
end,
|
|
on_metadata_inventory_take = function(pos, listname, index, stack, player)
|
|
local meta = minetest.get_meta(pos)
|
|
if listname == "output" then
|
|
local inv = meta:get_inventory()
|
|
local input1 = inv:get_stack("input", 1)
|
|
local input2 = inv:get_stack("input", 2)
|
|
-- Both slots occupied?
|
|
if not input1:is_empty() and not input2:is_empty() then
|
|
-- Take as many items as needed
|
|
local distinguished, tool, material = distinguish_tool_and_material(input1, input2)
|
|
if distinguished then
|
|
-- Tool + material: Take tool and as many materials as needed
|
|
local materials_used = get_consumed_materials(tool, material)
|
|
material:set_count(material:get_count() - materials_used)
|
|
tool:take_item()
|
|
if distinguished == "tool" then
|
|
input1, input2 = tool, material
|
|
else
|
|
input1, input2 = material, tool
|
|
end
|
|
inv:set_stack("input", 1, input1)
|
|
inv:set_stack("input", 2, input2)
|
|
else
|
|
-- Else take 1 item from each stack
|
|
input1:take_item()
|
|
input2:take_item()
|
|
inv:set_stack("input", 1, input1)
|
|
inv:set_stack("input", 2, input2)
|
|
end
|
|
else
|
|
-- Otherwise: Rename mode. Remove the same amount of items from input
|
|
-- as has been taken from output
|
|
if not input1:is_empty() then
|
|
input1:set_count(math.max(0, input1:get_count() - stack:get_count()))
|
|
inv:set_stack("input", 1, input1)
|
|
end
|
|
if not input2:is_empty() then
|
|
input2:set_count(math.max(0, input2:get_count() - stack:get_count()))
|
|
inv:set_stack("input", 2, input2)
|
|
end
|
|
end
|
|
local destroyed = damage_anvil_by_using(pos)
|
|
-- Close formspec if anvil was destroyed
|
|
if destroyed then
|
|
-- See above for justification.
|
|
minetest.close_formspec(player:get_player_name(), "")
|
|
end
|
|
elseif listname == "input" then
|
|
update_anvil_slots(meta)
|
|
end
|
|
end,
|
|
on_construct = function(pos)
|
|
local meta = minetest.get_meta(pos)
|
|
local inv = meta:get_inventory()
|
|
inv:set_size("input", 2)
|
|
inv:set_size("output", 1)
|
|
local form = get_anvil_formspec()
|
|
meta:set_string("formspec", form)
|
|
end,
|
|
on_receive_fields = function(pos, formname, fields, sender)
|
|
local sender_name = sender:get_player_name()
|
|
if minetest.is_protected(pos, sender_name) then
|
|
minetest.record_protection_violation(pos, sender_name)
|
|
return
|
|
end
|
|
|
|
if fields.name then
|
|
local meta = minetest.get_meta(pos)
|
|
|
|
-- Limit name length
|
|
local set_name = string.sub(fields.name, 1, MAX_NAME_LENGTH)
|
|
|
|
meta:set_string("set_name", set_name)
|
|
update_anvil_slots(meta)
|
|
meta:set_string("formspec", get_anvil_formspec(set_name))
|
|
end
|
|
end,
|
|
}
|
|
|
|
if minetest.get_modpath("screwdriver") then
|
|
anvildef.on_rotate = screwdriver.rotate_simple
|
|
end
|
|
|
|
local anvildef0 = table.copy(anvildef)
|
|
anvildef0.description = S("Anvil")
|
|
local anvildef1 = table.copy(anvildef)
|
|
anvildef1.description = S("Slightly Damaged Anvil")
|
|
anvildef1.groups.anvil = 2
|
|
anvildef1.tiles = { "mcl_anvils_anvil_top_damaged_1.png^[transformR90", "mcl_anvils_anvil_base.png",
|
|
"mcl_anvils_anvil_side.png" }
|
|
|
|
local anvildef2 = table.copy(anvildef)
|
|
anvildef2.description = S("Very Damaged Anvil")
|
|
anvildef2.groups.anvil = 3
|
|
anvildef2.tiles = { "mcl_anvils_anvil_top_damaged_2.png^[transformR90", "mcl_anvils_anvil_base.png",
|
|
"mcl_anvils_anvil_side.png" }
|
|
|
|
minetest.register_node("mcl_anvils:anvil", anvildef0)
|
|
minetest.register_node("mcl_anvils:anvil_damage_1", anvildef1)
|
|
minetest.register_node("mcl_anvils:anvil_damage_2", anvildef2)
|
|
|
|
if minetest.get_modpath("mcl_core") then
|
|
minetest.register_craft({
|
|
output = "mcl_anvils:anvil",
|
|
recipe = {
|
|
{ "mcl_core:ironblock", "mcl_core:ironblock", "mcl_core:ironblock" },
|
|
{ "", "mcl_core:iron_ingot", "" },
|
|
{ "mcl_core:iron_ingot", "mcl_core:iron_ingot", "mcl_core:iron_ingot" },
|
|
},
|
|
})
|
|
end
|
|
|
|
-- Legacy
|
|
minetest.register_lbm({
|
|
label = "Update anvil formspecs (0.60.0)",
|
|
name = "mcl_anvils:update_formspec_0_60_0",
|
|
nodenames = { "group:anvil" },
|
|
run_at_every_load = false,
|
|
action = function(pos, node)
|
|
local meta = minetest.get_meta(pos)
|
|
local set_name = meta:get_string("set_name")
|
|
meta:set_string("formspec", get_anvil_formspec(set_name))
|
|
end,
|
|
})
|