melterns/tinkering/register.lua

374 lines
9.5 KiB
Lua

local tools = {
pick = {
name = "Pickaxe",
groups = {"cracky"},
fleshy_decrement = 1,
components = {
main = "pickaxe_head",
binding = "tool_binding",
rod = "tool_rod"
},
textures = {
main = "tinkering_pickaxe_head.png",
second = "tinkering_overlay_handle_pickaxe.png",
offset = "1,-1"
}
},
axe = {
name = "Axe",
groups = {"choppy"},
fleshy_increment = 1,
components = {
main = "axe_head",
binding = "tool_binding",
rod = "tool_rod"
},
textures = {
main = "tinkering_axe_head.png",
second = "tinkering_overlay_handle_axe.png",
offset = "1,-3"
}
},
sword = {
name = "Sword",
groups = {"snappy"},
fleshy_decrement = 0,
components = {
main = "sword_blade",
binding = "tool_binding",
rod = "tool_rod"
},
textures = {
main = "tinkering_sword_blade.png",
second = "tinkering_overlay_handle_sword.png",
offset = "0,0"
}
},
shovel = {
name = "Shovel",
groups = {"crumbly"},
fleshy_decrement = 1,
components = {
main = "shovel_head",
binding = "tool_binding",
rod = "tool_rod"
},
textures = {
main = "tinkering_shovel_head.png",
second = "tinkering_overlay_handle_shovel.png",
offset = "3,-3"
}
},
}
local components = {
pickaxe_head = {description = "%s Pickaxe Head", materials = 1, image = tools.pick.textures.main},
axe_head = {description = "%s Axe Head", materials = 1, image = tools.axe.textures.main},
sword_blade = {description = "%s Sword Blade", materials = 1, image = tools.sword.textures.main},
shovel_head = {description = "%s Shovel Head", materials = 1, image = tools.shovel.textures.main},
tool_rod = {description = "%s Tool Rod", materials = 1, image = "tinkering_tool_rod.png"},
tool_binding = {description = "%s Tool Binding", materials = 1, image = "tinkering_tool_binding.png"}
}
-- Register a tool component
function tinkering.register_component(data)
local desc = data.description
local name = data.name
local mod = data.mod_name or "tinkering"
minetest.register_craftitem(mod..":"..name, {
description = desc,
groups = {tinker_component = 1},
inventory_image = data.image
})
end
-- Register a tool type
--
-- name = "Pickaxe", -- Name (description) of the tool
-- groups = {"cracky"}, -- Group caps that apply
-- mod = "tinkering", -- The mod you're registering this tool from
-- fleshy_decrement = 1, -- Amount removed from base damage group "fleshy". Negative value adds.
-- components = {
-- main = "pickaxe_head", -- Name of the primary component
-- binding = "tool_binding", -- Second component
-- rod = "tool_rod" -- Mandatory rod component
-- },
-- textures = {
-- main = "tinkering_pickaxe_head.png", -- Head (main) Texture
-- second = "tinkering_overlay_handle_pickaxe.png", -- Overlay (typically a handle)
-- offset = "1,-1" -- Head's offset on the texture
-- }
--
function tinkering.register_tool_type(name, data)
tools[name] = data
end
-- Create groups based on materials
local function apply_modifiers(materials, basegroup, dgroup)
local tags = {}
local groups = {}
local incr = 0.00
local uses = 0
local dmg = {}
-- Apply material modifiers
for m, v in pairs(materials) do
local material = tinkering.materials[v]
local mod = material.modifier
if m ~= "main" then
if mod[m] then
local mp = mod[m]
if mp.increase then
incr = incr + mp.increase
end
if mp.uses then
uses = uses + mp.uses
end
if mp.damage then
for g,mod in pairs(mp.damage) do
if dmg[g] == nil or dmg[g] < mod then
dmg[g] = mod
end
end
end
end
end
-- Apply tags
if mod.tags then
for _,t in pairs(mod.tags) do
if tags[t.name] == nil then
tags[t.name] = t.description
end
end
end
end
-- Apply modified to base groups
for grp, d in pairs(basegroup) do
groups[grp] = d
for id,val in pairs(d.times) do
groups[grp].times[id] = val + (incr / id)
end
groups[grp].uses = d.uses + uses
end
-- Apply damage group modifications
for g,l in pairs(dgroup) do
if dmg[g] == nil or dmg[g] < l then
dmg[g] = l
end
end
return groups, dmg, tags
end
-- Generate a tool texture based on tool type, main material (head) and rod material (handle).
function tinkering.compose_tool_texture(tooltype, main, rod)
local mat_main = tinkering.materials[main]
local mat_rod = tinkering.materials[rod]
local tool_data = tools[tooltype]
local main_tex = tool_data.textures.main .."\\^[multiply\\:".. mat_main.color
local rod_tex = tool_data.textures.second .."\\^[multiply\\:".. mat_rod.color
local align = tool_data.textures.offset
return "[combine:16x16:"..align.."="..main_tex..":0,0="..rod_tex
end
local function quickcopy(t)
local res = {}
for i, v in pairs(t) do
res[i] = v
end
return res
end
-- Generate tool capabilities based on tool type and materials
function tinkering.get_tool_capabilities(tool_type, materials)
if not materials["main"] or not materials["rod"] then
return nil
end
-- Get main material
local main = tinkering.materials[materials.main]
if not main then return nil end
-- Tool data
local tool_data = tools[tool_type]
-- Name of the tool
local name = tool_data.name or "Tool"
-- Group copies
local groups = {}
local dgroups = {}
-- Copy the groups
for g,v in pairs(main.modifier.damagegroups) do
-- Decrement/increment damage group if tool wants it
if tool_data[g.."_decrement"] then
dgroups[g] = v - tool_data[g.."_decrement"]
elseif tool_data[g.."_increment"] then
dgroups[g] = v + tool_data[g.."_increment"]
else
dgroups[g] = v
end
end
-- Type specific groups and modifiers
for _,v in pairs(tool_data.groups) do
if main.modifier[v] then
groups[v] = quickcopy(main.modifier[v])
end
end
-- Apply all modifiers
local fg, fd, tags = apply_modifiers(materials, groups, dgroups)
local tool_caps = {
full_punch_interval = 1.0,
max_drop_level = 0,
groupcaps = fg,
damagegroups = fd,
}
-- Construct the name
name = main.name.." "..name
return tool_caps, name, tags
end
-- Return tool definition
function tinkering.tool_definition(tool_type, materials)
if not materials["main"] or not materials["rod"] then
return nil
end
local capabilities, name, tags = tinkering.get_tool_capabilities(tool_type, materials)
if not capabilities then return nil end
local tool_tree = {
description = name,
tool_capabilities = capabilities,
groups = {tinker_tool = 1},
inventory_image = tinkering.compose_tool_texture(tool_type, materials.main, materials.rod)
}
-- Store materials to use in metadata
local tink_mats = ""
for _,m in pairs(materials) do
tink_mats = tink_mats..","..m
end
return tool_tree, tink_mats, tags
end
-- Compare provided components to the required components of this tool
local function compare_components_required(tool_spec, materials)
local all_match = true
for i, v in pairs(tool_spec) do
if not materials[i] then
all_match = false
end
end
return all_match
end
-- Create a new tool based on parameters specified.
function tinkering.create_tool(tool_type, materials, want_tool, custom_name, overrides)
-- TODO: Apply tags
-- TODO: Add texture as metadata (https://github.com/minetest/minetest/issues/5686)
-- Not a valid tool type
if not tools[tool_type] then return false end
local tool_data = tools[tool_type]
-- Check if the components are correct
if not compare_components_required(tool_data.components, materials) then return false end
-- Get tool definition and other metadata
local tool_def, mat_names, tags = tinkering.tool_definition(tool_type, materials)
if not tool_def then return false end
local mod_name = tool_data.mod or "tinkering"
-- Apply overrides
if overrides then
for i, v in pairs(overrides) do
tool_def[i] = v
end
end
-- Use custom name
if custom_name ~= nil and custom_name ~= "" then
tool_def.description = custom_name
end
-- Create internal name
local internal_name = mod_name..":"..materials.main.."_"..tool_type
-- Register base tool if it doesnt exist already
if not minetest.registered_items[internal_name] then
minetest.register_tool(internal_name, tool_def)
end
if not want_tool then return true end
-- Create a new tool instance and apply metadata
local tool = ItemStack(internal_name)
local meta = tool:get_meta()
meta:set_string("description", tool_def.description)
meta:set_string("texture_string", tool_def.inventory_image) -- NOT IMPLEMENTED YET!
meta:set_tool_capabilities(tool_def.tool_capabilities)
meta:set_string("materials", mat_names)
return tool
end
-- Register components and base tools
local start_load = os.clock()
local tools = {"pick", "axe", "shovel", "sword"}
local num_components = 0
local num_tools = 0
for m, s in pairs(tinkering.materials) do
for i, v in pairs(components) do
if v.materials == 1 then
tinkering.register_component({
name = m.."_"..i,
description = v.description:format(s.name),
image = tinkering.color_filter(v.image, s.color)
})
num_components = num_components + 1
end
end
for _,t in pairs(tools) do
tinkering.create_tool(t, {main=m,binding="wood",rod="wood"}, false, nil, {groups={not_in_creative_inventory=1}})
num_tools = num_tools + 1
end
end
-- Add casts to metal_melter
for i,v in pairs(components) do
metal_caster.register_cast(i.."_cast", {
name = v.description:sub(4).." Cast",
mod = "tinkering",
result = "%s:%s_"..i,
cost = metal_caster.spec.cast,
typenames = {i}
})
end
print(("[tinkering] Added %d components and %d base tools in %f seconds."):format(num_components, num_tools, os.clock() - start_load))