diff --git a/mods/CORE/_mcl_autogroup/depends.txt b/mods/CORE/_mcl_autogroup/depends.txt index e69de29bb2..2c9bbaec72 100644 --- a/mods/CORE/_mcl_autogroup/depends.txt +++ b/mods/CORE/_mcl_autogroup/depends.txt @@ -0,0 +1 @@ +mcl_autogroup diff --git a/mods/CORE/_mcl_autogroup/init.lua b/mods/CORE/_mcl_autogroup/init.lua index aabfa5906e..7c1deecf48 100644 --- a/mods/CORE/_mcl_autogroup/init.lua +++ b/mods/CORE/_mcl_autogroup/init.lua @@ -1,169 +1,273 @@ ---[[ Mining times. Yeah, mining times … Alright, this is going to be FUN! +--[[ +This mod implements a HACK to make 100% sure the digging times of all tools +match Minecraft's perfectly. The digging times system of Minetest is very +different, so this weird group trickery has to be used. In Minecraft, each +block has a hardness and the actual Minecraft digging time is determined by +this: -This mod does include a HACK to make 100% sure the digging times of all tools match Minecraft's perfectly. -The digging times system of Minetest is very different, so this weird group trickery has to be used. -In Minecraft, each block has a hardness and the actual Minecraft digging time is determined by this: 1) The block's hardness -2) The tool being used -3) Whether the tool is considered as “eligible” for the block +2) The tool being used (the tool_multiplier and its efficiency level) +3) Whether the tool is considered as "eligible" for the block (e.g. only diamond pick eligible for obsidian) -See Minecraft Wiki for more information. -In MineClone 2, all diggable node have the hardness set in the custom field “_mcl_hardness” (0 by default). -The nodes are also required to specify the “eligible” tools in groups like “pickaxey”, “shovely”, etc. -This mod then calculates the real digging time based on the node meta data. The real digging times -are then added into mcl_autogroup.digtimes where the table indices are group rating and the values are the -digging times in seconds. These digging times can be then added verbatim into the tool definitions. +See Minecraft Wiki for more +information. -Example: -mcl_autogroup.digtimes.pickaxey_dig_diamond[1] = 0.2 +How the mod is used +=================== -→ This means that when a node has been assigned the group “pickaxey_dig_diamond=1”, it can be dug by the -diamond pickaxe in 0.2 seconds. +In MineClone 2, all diggable node have the hardness set in the custom field +"_mcl_hardness" (0 by default). Digging groups are registered using the +following code: + mcl_autogroup.register_digtime_group("pickaxey", { levels = 5 }) + mcl_autogroup.register_digtime_group("shovely") + mcl_autogroup.register_digtime_group("shovely") +The first line registers "pickaxey" as a digging group. The "levels" field +indicates that the digging group have 5 levels (in this case one for each +material of a pickaxe). The second line registers "shovely" as a digging group +which does not have separate levels (if the "levels" field is not set it +defaults to 0). -This strange setup with mcl_autogroup has been done to minimize the amount of required digging times -a single tool needs to use. If this is not being done, the loading time will increase considerably -(>10s). +Nodes indicate that they belong to a particular digging group by being member of +the digging group in their node definition. "mcl_core:dirt" for example has +shovely=1 in its groups. If the digging group has multiple levels the value of +the group indicates which digging level the node requires. +"mcl_core:stone_with_gold" for example has pickaxey=3 because it requires a +pickaxe of level 3 to be mined. -]] +For tools to be able to dig nodes of the digging groups they need to use the +"mcl_autogroups.get_groupcaps" function to get the groupcaps. See +"mcl_tools/init.lua" for examples of this. -local materials = { "wood", "gold", "stone", "iron", "diamond" } -local basegroups = { "pickaxey", "axey", "shovely" } -local minigroups = { "handy", "shearsy", "swordy", "shearsy_wool", "swordy_cobweb" } -local divisors = { - ["wood"] = 2, - ["gold"] = 12, - ["stone"] = 4, - ["iron"] = 6, - ["diamond"] = 8, - ["handy"] = 1, - ["shearsy"] = 15, - ["swordy"] = 1.5, - ["shearsy_wool"] = 5, - ["swordy_cobweb"] = 15, -} -local max_efficiency_level = 5 +Information about the mod +========================= -mcl_autogroup = {} -mcl_autogroup.digtimes = {} -mcl_autogroup.creativetimes = {} -- Copy of digtimes, except that all values are 0. Used for creative mode +The mod is also split up into two mods, mcl_autogroups and _mcl_autogroups. +mcl_autogroups contains the API functions used to register custom digging +groups. _mcl_autogroups contains parts of the mod which need to be executed +after loading all other mods. +--]] -for m=1, #materials do - for g=1, #basegroups do - mcl_autogroup.digtimes[basegroups[g].."_dig_"..materials[m]] = {} - mcl_autogroup.creativetimes[basegroups[g].."_dig_"..materials[m]] = {} - for e=1, max_efficiency_level do - mcl_autogroup.digtimes[basegroups[g].."_dig_"..materials[m].."_efficiency_"..e] = {} +-- The groups which affect dig times +local basegroups = {} +for group, _ in pairs(mcl_autogroup.registered_digtime_groups) do + table.insert(basegroups, group) +end + +-- Returns a table containing the unique "_mcl_hardness" for nodes belonging to +-- each basegroup. +local function get_hardness_values_for_groups() + local maps = {} + local values = {} + for _, g in pairs(basegroups) do + maps[g] = {} + values[g] = {} + end + + for _, ndef in pairs(minetest.registered_nodes) do + for _, g in pairs(basegroups) do + if ndef.groups[g] ~= nil then + maps[g][ndef._mcl_hardness or 0] = true + end end end -end -for g=1, #minigroups do - mcl_autogroup.digtimes[minigroups[g].."_dig"] = {} - mcl_autogroup.creativetimes[minigroups[g].."_dig"] = {} - for e=1, max_efficiency_level do - mcl_autogroup.digtimes[minigroups[g].."_dig_efficiency_"..e] = {} - mcl_autogroup.creativetimes[minigroups[g].."_dig_efficiency_"..e] = {} + + for g, map in pairs(maps) do + for k, _ in pairs(map) do + table.insert(values[g], k) + end end + + for _, g in pairs(basegroups) do + table.sort(values[g]) + end + return values end +-- Returns a table containing a table indexed by "_mcl_hardness_value" to get +-- its index in the list of unique hardnesses for each basegroup. +local function get_hardness_lookup_for_groups(hardness_values) + map = {} + for g, values in pairs(hardness_values) do + map[g] = {} + for k, v in pairs(values) do + map[g][v] = k + end + end + return map +end + +-- Array of unique hardness values for each group which affects dig time. +local hardness_values = get_hardness_values_for_groups() + +-- Map indexed by hardness values which return the index of that value in +-- hardness_value. Used for quick lookup. +local hardness_lookup = get_hardness_lookup_for_groups(hardness_values) + +local function compute_creativetimes(group) + local creativetimes = {} + + for index, hardness in pairs(hardness_values[group]) do + table.insert(creativetimes, 0) + end + + return creativetimes +end + +-- Get the list of digging times for using a specific tool on a specific group. +-- +-- Parameters: +-- group - the group which it is digging +-- can_harvest - if the tool can harvest the block +-- tool_multiplier - dig speed multiplier for tool (default 1) +-- efficiency - efficiency level for the tool (default 0) +local function get_digtimes(group, can_harvest, tool_multiplier, efficiency) + efficiency = efficiency or 0 + tool_multiplier = tool_multiplier or 1 + speed_multiplier = tool_multiplier + if efficiency > 0 then + speed_multiplier = speed_multiplier + efficiency * efficiency + 1 + end + + local digtimes = {} + + for index, hardness in pairs(hardness_values[group]) do + local digtime = (hardness or 0) / speed_multiplier + if can_harvest then + digtime = digtime * 1.5 + else + digtime = digtime * 5 + end + + if digtime <= 0.05 then + digtime = 0 + else + digtime = math.ceil(digtime * 20) / 20 + end + table.insert(digtimes, digtime) + end + + return digtimes +end + +-- Get one groupcap field for using a specific tool on a specific group. +local function get_groupcap(group, can_harvest, multiplier, efficiency, uses) + return { + times = get_digtimes(group, can_harvest, multiplier, efficiency), + uses = uses, + maxlevel = 0, + } +end + +-- Get the groupcaps for a tool on the specified digging groups. groupcaps_def +-- contains a table with keys being the digging group and values being the tools +-- properties for that digging group. +-- +-- The tool properties can have the following values: +-- +-- tool_multiplier - the digging speed multiplier for this tool (default 1) +-- efficiency - the efficiency level for this tool (default 0) +-- level - the maximum level of the group the tool can harvest (default 1) +-- uses - the number of uses the tool has for this group +-- +-- A level of 0 means that the tool will be able to dig that group but will +-- never be able to harvest the nodes of that group and will always get a +-- digging time penalty. This is useful for implementing the hand. +-- +-- Example usage: +-- +-- mcl_autogroup.get_groupcaps { +-- pickaxey = { tool_multiplier = 4, level = 3, uses = 132 } +-- } +-- +-- This computes the groupcaps for a tool mining "pickaxey" blocks. The tool +-- has a digging speed multiplier of 4, can mine nodes of level >= 3 and has 132 +-- uses. +function mcl_autogroup.get_groupcaps(groupcaps_def) + local groupcaps = {} + + for g, capsdef in pairs(groupcaps_def) do + local mult = capsdef.tool_multiplier or 1 + local eff = capsdef.efficiency or 0 + local def = mcl_autogroup.registered_digtime_groups[g] + local level = capsdef.level or 1 + local max_level = def.levels or 0 + + if max_level > 0 then + level = math.min(level, max_level) + groupcaps[g .. "_0_dig"] = get_groupcap(g, false, mult, eff) + groupcaps[g .. "_" .. level .. "_dig"] = get_groupcap(g, true, mult, eff) + else + groupcaps[g .. "_dig"] = get_groupcap(g, true, mult, eff) + end + end + + return groupcaps +end + +-- Checks if the given node would drop its useful drop if dug by a tool with the +-- given tool capabilities. Returns true if it will yield its useful drop, false +-- otherwise. +function mcl_autogroup.can_harvest(nodename, tool_capabilities) + local ndef = minetest.registered_nodes[nodename] + local groupcaps = tool_capabilities.groupcaps + + local handy = minetest.get_item_group(nodename, "handy") + local dig_immediate = minetest.get_item_group(nodename, "handy") + if handy > 0 or dig_immediate >= 2 then + return true + end + + for g, _ in pairs(groupcaps) do + if ndef.groups[g] then + if not string.find(g, "_0_dig$") and string.find(g, "_dig$") then + return true + end + end + end + return false +end + +-- This function automatically assigns the "solid" and "opaque" groups to all +-- registered nodes and assigns groups to get the correct digging times for +-- groups registered with "mcl_autogroup.register_digtime_group". local overwrite = function() for nname, ndef in pairs(minetest.registered_nodes) do - local groups_changed = false local newgroups = table.copy(ndef.groups) if (nname ~= "ignore" and ndef.diggable) then - -- Automatically assign the “solid” group for solid nodes + -- Automatically assign the "solid" group for solid nodes if (ndef.walkable == nil or ndef.walkable == true) and (ndef.collision_box == nil or ndef.collision_box.type == "regular") and (ndef.node_box == nil or ndef.node_box.type == "regular") and (ndef.groups.not_solid == 0 or ndef.groups.not_solid == nil) then newgroups.solid = 1 - groups_changed = true end - -- Automatically assign the “opaque” group for opaque nodes + -- Automatically assign the "opaque" group for opaque nodes if (not (ndef.paramtype == "light" or ndef.sunlight_propagates)) and (ndef.groups.not_opaque == 0 or ndef.groups.not_opaque == nil) then newgroups.opaque = 1 - groups_changed = true end - local function calculate_group(hardness, material, diggroup, newgroups, actual_rating, expected_rating, efficiency) - local time, validity_factor - if actual_rating >= expected_rating then - -- Valid tool - validity_factor = 1.5 - else - -- Wrong tool (higher digging time) - validity_factor = 5 - end - local speed_multiplier = divisors[material] - if efficiency then - speed_multiplier = speed_multiplier + efficiency * efficiency + 1 - end - time = (hardness * validity_factor) / speed_multiplier - if time <= 0.05 then - time = 0 - else - time = math.ceil(time * 20) / 20 - end - table.insert(mcl_autogroup.digtimes[diggroup], time) - if not efficiency then - table.insert(mcl_autogroup.creativetimes[diggroup], 0) - end - newgroups[diggroup] = #mcl_autogroup.digtimes[diggroup] - return newgroups - end - - -- Hack in digging times - local hardness = ndef._mcl_hardness - if not hardness then - hardness = 0 - end - - -- Handle pickaxey, axey and shovely - for _, basegroup in pairs(basegroups) do - if (hardness ~= -1 and ndef.groups[basegroup]) then - for g=1,#materials do - local diggroup = basegroup.."_dig_"..materials[g] - newgroups = calculate_group(hardness, materials[g], diggroup, newgroups, g, ndef.groups[basegroup]) - for e=1,max_efficiency_level do - newgroups = calculate_group(hardness, materials[g], diggroup .. "_efficiency_" .. e, newgroups, g, ndef.groups[basegroup], e) + for g, gdef in pairs(mcl_autogroup.registered_digtime_groups) do + local index = hardness_lookup[g][ndef._mcl_hardness] + if ndef.groups[g] then + if gdef.levels then + newgroups[g .. "_0_dig"] = index + for i = ndef.groups.pickaxey, gdef.levels do + newgroups[g .. "_" .. i .. "_dig"] = index end - groups_changed = true - end - end - end - for m=1, #minigroups do - local minigroup = minigroups[m] - if hardness ~= -1 then - local diggroup = minigroup.."_dig" - -- actual rating - local ar = ndef.groups[minigroup] - if ar == nil then - ar = 0 - end - if (minigroup == "handy") - or - (ndef.groups.shearsy_wool and minigroup == "shearsy_wool" and ndef.groups.wool) - or - (ndef.groups.swordy_cobweb and minigroup == "swordy_cobweb" and nname == "mcl_core:cobweb") - or - (ndef.groups[minigroup] and minigroup ~= "swordy_cobweb" and minigroup ~= "shearsy_wool") then - newgroups = calculate_group(hardness, minigroup, diggroup, newgroups, ar, 1) - for e=1,max_efficiency_level do - newgroups = calculate_group(hardness, minigroup, diggroup .. "_efficiency_" .. e, newgroups, ar, 1, e) - end - groups_changed = true + else + local index = hardness_lookup[g][ndef._mcl_hardness] + newgroups[g .. "_dig"] = index end end end - if groups_changed then - minetest.override_item(nname, { - groups = newgroups - }) - end + minetest.override_item(nname, { + groups = newgroups + }) end end end diff --git a/mods/CORE/mcl_autogroup/init.lua b/mods/CORE/mcl_autogroup/init.lua new file mode 100644 index 0000000000..ff1c90cd00 --- /dev/null +++ b/mods/CORE/mcl_autogroup/init.lua @@ -0,0 +1,15 @@ +--[[ +This mod implements the API to register digging groups for mcl_autogroups. The +rest of the mod is implemented and documented in the mod "_mcl_autogroup". + +The mcl_autogroups mod is split up into two mods, mcl_autogroups and +_mcl_autogroups. mcl_autogroups contains the API functions used to register +custom digging groups. _mcl_autogroups contains parts of the mod which need to +be executed after loading all other mods. +--]] +mcl_autogroup = {} +mcl_autogroup.registered_digtime_groups = {} + +function mcl_autogroup.register_digtime_group(group, def) + mcl_autogroup.registered_digtime_groups[group] = def or {} +end diff --git a/mods/ENTITIES/mcl_item_entity/init.lua b/mods/ENTITIES/mcl_item_entity/init.lua index e5863abbc7..f0aa289f23 100644 --- a/mods/ENTITIES/mcl_item_entity/init.lua +++ b/mods/ENTITIES/mcl_item_entity/init.lua @@ -169,62 +169,6 @@ local minigroups = { "shearsy", "swordy", "shearsy_wool", "swordy_cobweb" } local basegroups = { "pickaxey", "axey", "shovely" } local materials = { "wood", "gold", "stone", "iron", "diamond" } --- Checks if the given node would drop its useful drop if dug by a tool --- with the given tool capabilities. Returns true if it will yield its useful --- drop, false otherwise. -local check_can_drop = function(node_name, tool_capabilities) - local handy = minetest.get_item_group(node_name, "handy") - local dig_immediate = minetest.get_item_group(node_name, "dig_immediate") - if handy == 1 or dig_immediate == 2 or dig_immediate == 3 then - return true - else - local toolgroupcaps - if tool_capabilities then - toolgroupcaps = tool_capabilities.groupcaps - else - return false - end - - -- Compare node groups with tool capabilities - for m=1, #minigroups do - local minigroup = minigroups[m] - local g = minetest.get_item_group(node_name, minigroup) - if g ~= 0 then - local plus = minigroup .. "_dig" - if toolgroupcaps[plus] then - return true - end - for e=1,5 do - local effplus = plus .. "_efficiency_" .. e - if toolgroupcaps[effplus] then - return true - end - end - end - end - for b=1, #basegroups do - local basegroup = basegroups[b] - local g = minetest.get_item_group(node_name, basegroup) - if g ~= 0 then - for m=g, #materials do - local plus = basegroup .. "_dig_"..materials[m] - if toolgroupcaps[plus] then - return true - end - for e=1,5 do - local effplus = plus .. "_efficiency_" .. e - if toolgroupcaps[effplus] then - return true - end - end - end - end - end - - return false - end -end - -- Stupid workaround to get drops from a drop table: -- Create a temporary table in minetest.registered_nodes that contains the proper drops, -- because unfortunately minetest.get_node_drops needs the drop table to be inside a registered node definition @@ -287,7 +231,7 @@ function minetest.handle_node_drops(pos, drops, digger) tool = digger:get_wielded_item() toolcaps = tool:get_tool_capabilities() - if not check_can_drop(dug_node.name, toolcaps) then + if not mcl_autogroup.can_harvest(dug_node.name, toolcaps) then return end end diff --git a/mods/ITEMS/mcl_core/depends.txt b/mods/ITEMS/mcl_core/depends.txt index fb9861814b..4e3912e1dd 100644 --- a/mods/ITEMS/mcl_core/depends.txt +++ b/mods/ITEMS/mcl_core/depends.txt @@ -1,3 +1,4 @@ +mcl_autogroup mcl_init mcl_sounds mcl_particles diff --git a/mods/ITEMS/mcl_core/init.lua b/mods/ITEMS/mcl_core/init.lua index 520f158bdc..91e82be6ea 100644 --- a/mods/ITEMS/mcl_core/init.lua +++ b/mods/ITEMS/mcl_core/init.lua @@ -3,6 +3,17 @@ mcl_core = {} -- Repair percentage for toolrepair mcl_core.repair = 0.05 +mcl_autogroup.register_digtime_group("handy") +mcl_autogroup.register_digtime_group("pickaxey", { levels = 5 }) +mcl_autogroup.register_digtime_group("axey") +mcl_autogroup.register_digtime_group("shovely") +mcl_autogroup.register_digtime_group("shearsy") +mcl_autogroup.register_digtime_group("shearsy_wool") +mcl_autogroup.register_digtime_group("shearsy_cobweb") +mcl_autogroup.register_digtime_group("swordy") +mcl_autogroup.register_digtime_group("swordy_cobweb") +mcl_autogroup.register_digtime_group("creative_breakable") + -- Load files local modpath = minetest.get_modpath("mcl_core") dofile(modpath.."/functions.lua") diff --git a/mods/ITEMS/mcl_core/nodes_misc.lua b/mods/ITEMS/mcl_core/nodes_misc.lua index 3056822449..083aa0b85c 100644 --- a/mods/ITEMS/mcl_core/nodes_misc.lua +++ b/mods/ITEMS/mcl_core/nodes_misc.lua @@ -108,7 +108,7 @@ minetest.register_node("mcl_core:cobweb", { liquid_renewable = false, liquid_range = 0, walkable = false, - groups = {swordy_cobweb=1,shearsy=1, fake_liquid=1, disable_jump=1, deco_block=1, dig_by_piston=1, dig_by_water=1,destroy_by_lava_flow=1,}, + groups = {swordy_cobweb=1, shearsy_cobweb=1, fake_liquid=1, disable_jump=1, deco_block=1, dig_by_piston=1, dig_by_water=1,destroy_by_lava_flow=1,}, drop = "mcl_mobitems:string", _mcl_shears_drop = true, sounds = mcl_sounds.node_sound_leaves_defaults(), diff --git a/mods/ITEMS/mcl_tools/init.lua b/mods/ITEMS/mcl_tools/init.lua index d40b8e01b0..c8263ef73e 100644 --- a/mods/ITEMS/mcl_tools/init.lua +++ b/mods/ITEMS/mcl_tools/init.lua @@ -28,18 +28,17 @@ dig_speed_class group: local groupcaps, hand_range, hand_groups if minetest.is_creative_enabled("") then -- Instant breaking in creative mode - groupcaps = { - creative_breakable = {times={[1]=0}, uses=0}, + groupcaps = mcl_autogroup.get_groupcaps { + creative_breakable = { tool_multiplier = 1000000, level = 0, uses = 0 }, + handy = { tool_multiplier = 1000000, level = 0, uses = 0 }, + pickaxey = { tool_multiplier = 1000000, level = 0, uses = 0 } } - -- mcl_autogroup provides the creative digging times for all digging groups - for k,v in pairs(mcl_autogroup.creativetimes) do - groupcaps[k] = { times = v, uses = 0 } - end hand_range = 10 hand_groups = { dig_speed_class = 7 } else - groupcaps = { - handy_dig = {times=mcl_autogroup.digtimes.handy_dig, uses=0}, + groupcaps = mcl_autogroup.get_groupcaps { + handy = { tool_multiplier = 1, level = 0, uses = 0 }, + pickaxey = { tool_multiplier = 1, level = 0, uses = 0 } } hand_range = 4 hand_groups = { dig_speed_class = 1 } @@ -86,8 +85,8 @@ minetest.register_tool("mcl_tools:pick_wood", { -- 1/1.2 full_punch_interval = 0.83333333, max_drop_level=1, - groupcaps={ - pickaxey_dig_wood = {times=mcl_autogroup.digtimes.pickaxey_dig_wood, uses=60, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + pickaxey = { tool_multiplier = 2, level = 1, uses = 60 } }, damage_groups = {fleshy=2}, punch_attack_uses = 30, @@ -106,8 +105,8 @@ minetest.register_tool("mcl_tools:pick_stone", { -- 1/1.2 full_punch_interval = 0.83333333, max_drop_level=3, - groupcaps={ - pickaxey_dig_stone = {times=mcl_autogroup.digtimes.pickaxey_dig_stone, uses=132, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + pickaxey = { tool_multiplier = 4, level = 3, uses = 132 } }, damage_groups = {fleshy=3}, punch_attack_uses = 66, @@ -126,8 +125,8 @@ minetest.register_tool("mcl_tools:pick_iron", { -- 1/1.2 full_punch_interval = 0.83333333, max_drop_level=4, - groupcaps={ - pickaxey_dig_iron = {times=mcl_autogroup.digtimes.pickaxey_dig_iron , uses=251, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + pickaxey = { tool_multiplier = 6, level = 4, uses = 251 } }, damage_groups = {fleshy=4}, punch_attack_uses = 126, @@ -146,8 +145,8 @@ minetest.register_tool("mcl_tools:pick_gold", { -- 1/1.2 full_punch_interval = 0.83333333, max_drop_level=2, - groupcaps={ - pickaxey_dig_gold = {times=mcl_autogroup.digtimes.pickaxey_dig_gold , uses=33, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + pickaxey = { tool_multiplier = 12, level = 2, uses = 33 } }, damage_groups = {fleshy=2}, punch_attack_uses = 17, @@ -166,8 +165,8 @@ minetest.register_tool("mcl_tools:pick_diamond", { -- 1/1.2 full_punch_interval = 0.83333333, max_drop_level=5, - groupcaps={ - pickaxey_dig_diamond = {times=mcl_autogroup.digtimes.pickaxey_dig_diamond, uses=1562, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + pickaxey = { tool_multiplier = 8, level = 5, uses = 1562 } }, damage_groups = {fleshy=5}, punch_attack_uses = 781, @@ -288,8 +287,8 @@ minetest.register_tool("mcl_tools:shovel_wood", { tool_capabilities = { full_punch_interval = 1, max_drop_level=1, - groupcaps={ - shovely_dig_wood = {times=mcl_autogroup.digtimes.shovely_dig_wood, uses=60, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + shovely = { tool_multiplier = 2, level = 1, uses = 60 } }, damage_groups = {fleshy=2}, punch_attack_uses = 30, @@ -309,8 +308,8 @@ minetest.register_tool("mcl_tools:shovel_stone", { tool_capabilities = { full_punch_interval = 1, max_drop_level=3, - groupcaps={ - shovely_dig_stone = {times=mcl_autogroup.digtimes.shovely_dig_stone, uses=132, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + shovely = { tool_multiplier = 4, level = 3, uses = 132 } }, damage_groups = {fleshy=3}, punch_attack_uses = 66, @@ -330,8 +329,8 @@ minetest.register_tool("mcl_tools:shovel_iron", { tool_capabilities = { full_punch_interval = 1, max_drop_level=4, - groupcaps={ - shovely_dig_iron = {times=mcl_autogroup.digtimes.shovely_dig_iron, uses=251, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + shovely = { tool_multiplier = 6, level = 4, uses = 251 } }, damage_groups = {fleshy=4}, punch_attack_uses = 126, @@ -351,8 +350,8 @@ minetest.register_tool("mcl_tools:shovel_gold", { tool_capabilities = { full_punch_interval = 1, max_drop_level=2, - groupcaps={ - shovely_dig_gold = {times=mcl_autogroup.digtimes.shovely_dig_gold, uses=33, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + shovely = { tool_multiplier = 12, level = 2, uses = 33 } }, damage_groups = {fleshy=2}, punch_attack_uses = 17, @@ -372,8 +371,8 @@ minetest.register_tool("mcl_tools:shovel_diamond", { tool_capabilities = { full_punch_interval = 1, max_drop_level=5, - groupcaps={ - shovely_dig_diamond = {times=mcl_autogroup.digtimes.shovely_dig_diamond, uses=1562, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + shovely = { tool_multiplier = 8, level = 5, uses = 1562 } }, damage_groups = {fleshy=5}, punch_attack_uses = 781, @@ -395,8 +394,8 @@ minetest.register_tool("mcl_tools:axe_wood", { tool_capabilities = { full_punch_interval = 1.25, max_drop_level=1, - groupcaps={ - axey_dig_wood = {times=mcl_autogroup.digtimes.axey_dig_wood, uses=60, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + axey = { tool_multiplier = 2, level = 1, uses = 60 } }, damage_groups = {fleshy=7}, punch_attack_uses = 30, @@ -414,8 +413,8 @@ minetest.register_tool("mcl_tools:axe_stone", { tool_capabilities = { full_punch_interval = 1.25, max_drop_level=3, - groupcaps={ - axey_dig_stone = {times=mcl_autogroup.digtimes.axey_dig_stone, uses=132, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + axey = { tool_multiplier = 4, level = 3, uses = 132 } }, damage_groups = {fleshy=9}, punch_attack_uses = 66, @@ -434,8 +433,8 @@ minetest.register_tool("mcl_tools:axe_iron", { -- 1/0.9 full_punch_interval = 1.11111111, max_drop_level=4, - groupcaps={ - axey_dig_iron = {times=mcl_autogroup.digtimes.axey_dig_iron, uses=251, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + axey = { tool_multiplier = 6, level = 4, uses = 251 } }, damage_groups = {fleshy=9}, punch_attack_uses = 126, @@ -453,8 +452,8 @@ minetest.register_tool("mcl_tools:axe_gold", { tool_capabilities = { full_punch_interval = 1.0, max_drop_level=2, - groupcaps={ - axey_dig_gold= {times=mcl_autogroup.digtimes.axey_dig_gold, uses=33, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + axey = { tool_multiplier = 12, level = 2, uses = 33 } }, damage_groups = {fleshy=7}, punch_attack_uses = 17, @@ -472,8 +471,8 @@ minetest.register_tool("mcl_tools:axe_diamond", { tool_capabilities = { full_punch_interval = 1.0, max_drop_level=5, - groupcaps={ - axey_dig_diamond = {times=mcl_autogroup.digtimes.axey_dig_diamond, uses=1562, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + axey = { tool_multiplier = 8, level = 5, uses = 1562 } }, damage_groups = {fleshy=9}, punch_attack_uses = 781, @@ -494,9 +493,9 @@ minetest.register_tool("mcl_tools:sword_wood", { tool_capabilities = { full_punch_interval = 0.625, max_drop_level=1, - groupcaps={ - swordy_dig = {times=mcl_autogroup.digtimes.swordy_dig , uses=60, maxlevel=0}, - swordy_cobweb_dig = {times=mcl_autogroup.digtimes.swordy_cobweb_dig , uses=60, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + swordy = { tool_multiplier = 2, level = 1, uses = 60 }, + swordy_cobweb = { tool_multiplier = 2, level = 1, uses = 60 } }, damage_groups = {fleshy=4}, punch_attack_uses = 60, @@ -514,9 +513,9 @@ minetest.register_tool("mcl_tools:sword_stone", { tool_capabilities = { full_punch_interval = 0.625, max_drop_level=3, - groupcaps={ - swordy_dig = {times=mcl_autogroup.digtimes.swordy_dig , uses=132, maxlevel=0}, - swordy_cobweb_dig = {times=mcl_autogroup.digtimes.swordy_cobweb_dig , uses=132, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + swordy = { tool_multiplier = 4, level = 3, uses = 132 }, + swordy_cobweb = { tool_multiplier = 4, level = 3, uses = 132 } }, damage_groups = {fleshy=5}, punch_attack_uses = 132, @@ -534,9 +533,9 @@ minetest.register_tool("mcl_tools:sword_iron", { tool_capabilities = { full_punch_interval = 0.625, max_drop_level=4, - groupcaps={ - swordy_dig = {times=mcl_autogroup.digtimes.swordy_dig, uses=251, maxlevel=0}, - swordy_cobweb_dig = {times=mcl_autogroup.digtimes.swordy_cobweb_dig , uses=251, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + swordy = { tool_multiplier = 6, level = 4, uses = 251 }, + swordy_cobweb = { tool_multiplier = 6, level = 4, uses = 251 } }, damage_groups = {fleshy=6}, punch_attack_uses = 251, @@ -554,9 +553,9 @@ minetest.register_tool("mcl_tools:sword_gold", { tool_capabilities = { full_punch_interval = 0.625, max_drop_level=2, - groupcaps={ - swordy_dig = {times=mcl_autogroup.digtimes.swordy_dig, uses=33, maxlevel=0}, - swordy_cobweb_dig = {times=mcl_autogroup.digtimes.swordy_cobweb_dig, uses=33, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + swordy = { tool_multiplier = 12, level = 2, uses = 33 }, + swordy_cobweb = { tool_multiplier = 12, level = 2, uses = 33 } }, damage_groups = {fleshy=4}, punch_attack_uses = 33, @@ -574,9 +573,9 @@ minetest.register_tool("mcl_tools:sword_diamond", { tool_capabilities = { full_punch_interval = 0.625, max_drop_level=5, - groupcaps={ - swordy_dig = {times=mcl_autogroup.digtimes.swordy_dig, uses=1562, maxlevel=0}, - swordy_cobweb_dig = {times=mcl_autogroup.digtimes.swordy_cobweb_dig, uses=1562, maxlevel=0}, + groupcaps = mcl_autogroup.get_groupcaps { + swordy = { tool_multiplier = 8, level = 5, uses = 1562 }, + swordy_cobweb = { tool_multiplier = 8, level = 5, uses = 1562 } }, damage_groups = {fleshy=7}, punch_attack_uses = 1562, @@ -598,10 +597,11 @@ minetest.register_tool("mcl_tools:shears", { tool_capabilities = { full_punch_interval = 0.5, max_drop_level=1, - groupcaps={ - shearsy_dig = {times=mcl_autogroup.digtimes.shearsy_dig, uses=238, maxlevel=0}, - shearsy_wool_dig = {times=mcl_autogroup.digtimes.shearsy_wool_dig, uses=238, maxlevel=0}, - } + groupcaps = mcl_autogroup.get_groupcaps { + shearsy = { tool_multiplier = 1.5, level = 1, uses = 238 }, + shearsy_wool = { tool_multiplier = 5, level = 1, uses = 238 }, + shearsy_cobweb = { tool_multiplier = 15, level = 1, uses = 238 } + }, }, on_place = carve_pumpkin, sound = { breaks = "default_tool_breaks" },