Merge pull request 'Rewrite mcl_autogroup to reduce metadata for enchanted items' (#8) from mcl_autogroup into master

Reviewed-on: https://git.minetest.land/Mineclonia/Mineclonia/pulls/8
Reviewed-by: cora <cora@noreply.git.minetest.land>
Reviewed-by: n_to <n_to@noreply.git.minetest.land>
Reviewed-by: erlehmann <nils+git.minetest.land@dieweltistgarnichtso.net>

API.md

@@ -17,6 +17,10 @@ Items can have these fields:
    anvil.
    See `mcl_banners` for an example.
 
+Tools can have these fields:
+* `_mcl_diggroups`: Specifies the digging groups that a tool can dig and how
+  efficiently.  See `_mcl_autogroup` for more information.
+
 All nodes can have these fields:
 
 * `_mcl_hardness`: Hardness of the block, ranges from 0 to infinity (represented by -1). Determines digging times. Default: 0

mods/CORE/_mcl_autogroup/README.txt

@@ -4,6 +4,11 @@ Specifically, this mod has 2 purposes:
 1) Automatically adding the group “solid” for blocks considered “solid” in Minecraft.
 2) Generating digging time group for all nodes based on node metadata (it's complicated)
 
+This mod also requires another mod called “mcl_autogroup” to function properly.
+“mcl_autogroup” exposes the API used to register digging groups, while this mod
+uses those digging groups to set the digging time groups for all the nodes and
+tools.
+
 See init.lua for more infos.
 
 The leading underscore in the name “_mcl_autogroup” was added to force Minetest to load this mod as late as possible.

mods/CORE/_mcl_autogroup/description.txt

@@ -1 +0,0 @@
-MineClone 2 core mod which automatically adds groups to all items. Very important for digging times.

mods/CORE/_mcl_autogroup/init.lua

@@ -1,169 +1,361 @@
---[[ 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 speed 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 <http://minecraft.gamepedia.com/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 <http://minecraft.gamepedia.com/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 nodes have the hardness set in the custom field
+"_mcl_hardness" (0 by default).  These values are used together with digging
+groups by this mod to create the correct digging times for nodes.  Digging
+groups are registered using the following code:
 
+    mcl_autogroup.register_diggroup("shovely")
+    mcl_autogroup.register_diggroup("pickaxey", {
+        levels = { "wood", "gold", "stone", "iron", "diamond" }
+    })
 
+The first line registers a simple digging group.  The second line registers a
+digging group with 5 different levels (in this case one for each material of a
+pickaxes).
 
-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=4 because it requires a
+pickaxe of level 4 be mined.
 
-]]
+For tools to be able to dig nodes of digging groups they need to use the have
+the custom field "_mcl_diggroups" function to get the groupcaps.  The value of
+this field is a table which defines which groups the tool can dig and how
+efficiently.
 
-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
+    _mcl_diggroups = {
+        handy = { speed = 1, level = 1, uses = 0 },
+        pickaxey = { speed = 1, level = 0, uses = 0 },
+    }
 
-mcl_autogroup = {}
-mcl_autogroup.digtimes = {}
-mcl_autogroup.creativetimes = {}	-- Copy of digtimes, except that all values are 0. Used for creative mode
+The "uses" field indicate how many uses (0 for infinite) a tool has when used on
+the specified digging group.  The "speed" field is a multiplier to the dig speed
+on that digging group.
 
-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 "level" field indicates which levels of the group the tool can harvest.  A
+level of 0 means that the tool cannot harvest blocks of that node.  A level of 1
+or above means that the tool can harvest nodes with that level or below.  See
+"mcl_tools/init.lua" for examples on how "_mcl_diggroups" is used in practice.
+
+Information about the mod
+=========================
+
+The mod is split up into two parts, mcl_autogroup and _mcl_autogroup.
+mcl_autogroup contains the API functions used to register custom digging groups.
+_mcl_autogroup contains most of the code.  The leading underscore in the name
+"_mcl_autogroup" is used to force Minetest to load that part of the mod as late
+as possible.  Minetest loads mods in reverse alphabetical order.
+
+This also means that it is very important that no mod adds _mcl_autogroup as a
+dependency.
+--]]
+
+assert(minetest.get_modpath("mcl_autogroup"), "This mod requires the mod mcl_autogroup to function")
+
+-- Returns a table containing the unique "_mcl_hardness" for nodes belonging to
+-- each diggroup.
+local function get_hardness_values_for_groups()
+	local maps = {}
+	local values = {}
+	for g, _ in pairs(mcl_autogroup.registered_diggroups) do
+		maps[g] = {}
+		values[g] = {}
+	end
+
+	for _, ndef in pairs(minetest.registered_nodes) do
+		for g, _ in pairs(mcl_autogroup.registered_diggroups) do
+			if ndef.groups[g] ~= nil then
+				maps[g][ndef._mcl_hardness or 0] = true
+			end
+		end
+	end
+
+	for g, map in pairs(maps) do
+		for k, _ in pairs(map) do
+			table.insert(values[g], k)
+		end
+	end
+
+	for g, _ in pairs(mcl_autogroup.registered_diggroups) 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 diggroup.
+local function get_hardness_lookup_for_groups(hardness_values)
+	local 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
+-- diggroup.
+--
+-- Parameters:
+-- group - the group which it is digging
+-- can_harvest - if the tool can harvest the block
+-- speed - dig speed multiplier for tool (default 1)
+-- efficiency - efficiency level for the tool if applicable
+local function get_digtimes(group, can_harvest, speed, efficiency)
+	local speed = speed or 1
+	if efficiency then
+		speed = speed + efficiency * efficiency + 1
+	end
+
+	local digtimes = {}
+
+	for index, hardness in pairs(hardness_values[group]) do
+		local digtime = (hardness or 0) / speed
+		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
+
+-- Add the groupcaps from a field in "_mcl_diggroups" to the groupcaps of a
+-- tool.
+local function add_groupcaps(toolname, groupcaps, groupcaps_def, efficiency)
+	if not groupcaps_def then
+		return
+	end
+
+	for g, capsdef in pairs(groupcaps_def) do
+		local mult = capsdef.speed or 1
+		local uses = capsdef.uses
+		local def = mcl_autogroup.registered_diggroups[g]
+		local max_level = def.levels and #def.levels or 1
+
+		assert(capsdef.level, toolname .. ' is missing level for ' .. g)
+		local level = math.min(capsdef.level, max_level)
+
+		if def.levels then
+			groupcaps[g .. "_dig_default"] = get_groupcap(g, false, mult, efficiency, uses)
+			if level > 0 then
+				groupcaps[g .. "_dig_" .. def.levels[level]] = get_groupcap(g, true, mult, efficiency, uses)
+			end
+		else
+			groupcaps[g .. "_dig"] = get_groupcap(g, level > 0, mult, efficiency, uses)
 		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] = {}
+
+-- Checks if the given node would drop its useful drop if dug by a given tool.
+-- Returns true if it will yield its useful drop, false otherwise.
+function mcl_autogroup.can_harvest(nodename, toolname)
+	local ndef = minetest.registered_nodes[nodename]
+
+	if minetest.get_item_group(nodename, "dig_immediate") >= 2 then
+		return true
 	end
+
+	-- Check if it can be dug by tool
+	local tdef = minetest.registered_tools[toolname]
+	if tdef and tdef._mcl_diggroups then
+		for g, gdef in pairs(tdef._mcl_diggroups) do
+			if ndef.groups[g] then
+				if ndef.groups[g] <= gdef.level then
+					return true
+				end
+			end
+		end
+	end
+
+	-- Check if it can be dug by hand
+	local tdef = minetest.registered_tools[""]
+	if tdef then
+		for g, gdef in pairs(tdef._mcl_diggroups) do
+			if ndef.groups[g] then
+				if ndef.groups[g] <= gdef.level then
+					return true
+				end
+			end
+		end
+	end
+
+	return false
+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
+
+-- Returns the tool_capabilities from a tool definition or a default set of
+-- tool_capabilities
+local function get_tool_capabilities(tdef)
+	if tdef.tool_capabilities then
+		return tdef.tool_capabilities
+	end
+
+	-- If the damage group and punch interval from hand is not included,
+	-- then the user will not be able to attack with the tool.
+	local hand_toolcaps = minetest.registered_tools[""].tool_capabilities
+	return {
+		full_punch_interval = hand_toolcaps.full_punch_interval,
+		damage_groups = hand_toolcaps.damage_groups
+	}
+end
+
+-- Get the groupcaps for a tool.  This function returns "groupcaps" table of
+-- digging which should be put in the "tool_capabilities" of the tool definition
+-- or in the metadata of an enchanted tool.
+--
+-- Parameters:
+-- toolname - Name of the tool being enchanted (like "mcl_tools:diamond_pickaxe")
+-- efficiency - The efficiency level the tool is enchanted with (default 0)
+--
+-- NOTE: 
+-- This function can only be called after mod initialization.  Otherwise a mod
+-- would have to add _mcl_autogroup as a dependency which would break the mod
+-- loading order.
+function mcl_autogroup.get_groupcaps(toolname, efficiency)
+	local tdef = minetest.registered_tools[toolname]
+	local groupcaps = table.copy(get_tool_capabilities(tdef).groupcaps or {})
+	add_groupcaps(toolname, groupcaps, tdef._mcl_diggroups, efficiency)
+	return groupcaps
+end
+
+-- Get the wear from using a tool on a digging group.
+--
+-- Parameters
+-- toolname - Name of the tool used
+-- diggroup - The name of the diggroup the tool is used on
+--
+-- NOTE: 
+-- This function can only be called after mod initialization.  Otherwise a mod
+-- would have to add _mcl_autogroup as a dependency which would break the mod
+-- loading order.
+function mcl_autogroup.get_wear(toolname, diggroup)
+	local tdef = minetest.registered_tools[toolname]
+	local uses = tdef._mcl_diggroups[diggroup].uses
+	return math.ceil(65535 / uses)
 end
 
 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
+			local creative_breakable = false
 
-			-- Hack in digging times
-			local hardness = ndef._mcl_hardness
-			if not hardness then
-				hardness = 0
-			end
+			-- Assign groups used for digging this node depending on
+			-- the registered digging groups
+			for g, gdef in pairs(mcl_autogroup.registered_diggroups) do
+				creative_breakable = true
+				local index = hardness_lookup[g][ndef._mcl_hardness or 0]
+				if ndef.groups[g] then
+					if gdef.levels then
+						newgroups[g .. "_dig_default"] = index
 
-			-- 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 i = ndef.groups[g], #gdef.levels do
+							newgroups[g .. "_dig_" .. gdef.levels[i]] = 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
+						newgroups[g .. "_dig"] = index
 					end
 				end
 			end
 
-			if groups_changed then
-				minetest.override_item(nname, {
-					groups = newgroups
-				})
-			end
+			-- Automatically assign the node to the
+			-- creative_breakable group if it belongs to any digging
+			-- group.
+			newgroups["creative_breakable"] = 1
+
+			minetest.override_item(nname, {
+				groups = newgroups
+			})
+		end
+	end
+
+	for tname, tdef in pairs(minetest.registered_tools) do
+		-- Assign groupcaps for digging the registered digging groups
+		-- depending on the _mcl_diggroups in the tool definition
+		if tdef._mcl_diggroups then
+			local toolcaps = table.copy(get_tool_capabilities(tdef))
+			toolcaps.groupcaps = mcl_autogroup.get_groupcaps(tname)
+
+			minetest.override_item(tname, {
+				tool_capabilities = toolcaps
+			})
 		end
 	end
 end

mods/CORE/_mcl_autogroup/mod.conf

@@ -1 +1,3 @@
 name = _mcl_autogroup
+author = ryvnf
+description = MineClone 2 core mod which automatically adds groups to all items. Very important for digging times.

mods/CORE/mcl_autogroup/init.lua

@@ -0,0 +1,28 @@
+--[[
+This is one part of a mod to replicate the digging times from Minecraft.  This
+part only exposes a function to register digging groups.  The rest of the mod is
+implemented and documented in the _mcl_autogroup.
+
+The mod is split up into two parts, mcl_autogroup and _mcl_autogroup.
+mcl_autogroup contains the API functions used to register custom digging groups.
+_mcl_autogroup contains most of the code.  The leading underscore in the name
+"_mcl_autogroup" is used to force Minetest to load that part of the mod as late
+as possible.  Minetest loads mods in reverse alphabetical order.
+--]]
+mcl_autogroup = {}
+mcl_autogroup.registered_diggroups = {}
+
+assert(minetest.get_modpath("_mcl_autogroup"), "This mod requires the mod _mcl_autogroup to function")
+
+-- Register a group as a digging group.
+--
+-- Parameters:
+-- group - Name of the group to register as a digging group
+-- def - Table with information about the diggroup (defaults to {} if unspecified)
+--
+-- Values in def:
+-- level - If specified it is an array containing the names of the different
+--         digging levels the digging group supports.
+function mcl_autogroup.register_diggroup(group, def)
+	mcl_autogroup.registered_diggroups[group] = def or {}
+end

mods/CORE/mcl_autogroup/mod.conf

@@ -0,0 +1,3 @@
+name = mcl_autogroup
+author = ryvnf
+description = MineClone 2 core mod which automatically adds groups to all items. Very important for digging times.

mods/ENTITIES/mcl_item_entity/init.lua

@@ -165,66 +165,6 @@ minetest.register_globalstep(function(dtime)
 	end
 end)
 
-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
@@ -281,17 +221,20 @@ function minetest.handle_node_drops(pos, drops, digger)
 
 	-- Check if node will yield its useful drop by the digger's tool
 	local dug_node = minetest.get_node(pos)
-	local toolcaps
+	local tooldef
 	local tool
 	if digger ~= nil then
 		tool = digger:get_wielded_item()
-		toolcaps = tool:get_tool_capabilities()
+		tooldef = minetest.registered_tools[tool:get_name()]
 
-		if not check_can_drop(dug_node.name, toolcaps) then
+		if not mcl_autogroup.can_harvest(dug_node.name, tool:get_name()) then
 			return
 		end
 	end
 
+	local diggroups = tooldef and tooldef._mcl_diggroups
+	local shearsy_level = diggroups and diggroups.shearsy and diggroups.shearsy.level
+
 	--[[ Special node drops when dug by shears by reading _mcl_shears_drop or with a silk touch tool reading _mcl_silk_touch_drop
 	from the node definition.
 	Definition of _mcl_shears_drop / _mcl_silk_touch_drop:
@@ -303,7 +246,7 @@ function minetest.handle_node_drops(pos, drops, digger)
 
 	local silk_touch_drop = false
 	local nodedef = minetest.registered_nodes[dug_node.name]
-	if toolcaps ~= nil and toolcaps.groupcaps and toolcaps.groupcaps.shearsy_dig and nodedef._mcl_shears_drop then
+	if shearsy_level and shearsy_level > 0 and nodedef._mcl_shears_drop then
 		if nodedef._mcl_shears_drop == true then
 			drops = { dug_node.name }
 		else

mods/ITEMS/mcl_core/depends.txt

@@ -1,3 +1,4 @@
+mcl_autogroup
 mcl_init
 mcl_sounds
 mcl_particles

mods/ITEMS/mcl_core/init.lua

@@ -3,6 +3,18 @@ mcl_core = {}
 -- Repair percentage for toolrepair
 mcl_core.repair = 0.05
 
+mcl_autogroup.register_diggroup("handy")
+mcl_autogroup.register_diggroup("pickaxey", {
+	levels = { "wood", "gold", "stone", "iron", "diamond" }
+})
+mcl_autogroup.register_diggroup("axey")
+mcl_autogroup.register_diggroup("shovely")
+mcl_autogroup.register_diggroup("shearsy")
+mcl_autogroup.register_diggroup("shearsy_wool")
+mcl_autogroup.register_diggroup("shearsy_cobweb")
+mcl_autogroup.register_diggroup("swordy")
+mcl_autogroup.register_diggroup("swordy_cobweb")
+
 -- Load files
 local modpath = minetest.get_modpath("mcl_core")
 dofile(modpath.."/functions.lua")

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(),

mods/ITEMS/mcl_enchanting/enchantments.lua

@@ -155,15 +155,7 @@ mcl_enchanting.enchantments.efficiency = {
 	description = S("Increases mining speed."),
 	curse = false,
 	on_enchant = function(itemstack, level)
-		local tool_capabilities = itemstack:get_tool_capabilities()
-		local groupcaps = {}
-		for group, capability in pairs(tool_capabilities.groupcaps) do
-			local groupname = group .. "_efficiency_" .. level
-			capability.times = mcl_autogroup.digtimes[groupname]
-			groupcaps[groupname] = capability
-		end
-		tool_capabilities.groupcaps = groupcaps
-		itemstack:get_meta():set_tool_capabilities(tool_capabilities)
+		mcl_enchanting.update_groupcaps(itemstack)
 	end,
 	requires_tool = false,
 	treasure = false,
@@ -778,12 +770,17 @@ mcl_enchanting.enchantments.unbreaking = {
 	description = S("Increases item durability."),
 	curse = false,
 	on_enchant = function(itemstack, level)
-		local tool_capabilities = itemstack:get_tool_capabilities()
-		for group, capability in pairs(tool_capabilities.groupcaps) do
-			capability.uses = capability.uses * (1 + level)
+		local name = itemstack:get_name()
+		if not minetest.registered_tools[name].tool_capabilities then
+			return
 		end
+
+		local tool_capabilities = itemstack:get_tool_capabilities()
 		tool_capabilities.punch_attack_uses = tool_capabilities.punch_attack_uses * (1 + level)
 		itemstack:get_meta():set_tool_capabilities(tool_capabilities)
+
+		-- Unbreaking for groupcaps is handled in this function.
+		mcl_enchanting.update_groupcaps(itemstack)
 	end,
 	requires_tool = true,
 	treasure = false,

mods/ITEMS/mcl_enchanting/engine.lua

@@ -12,11 +12,12 @@ end
 function mcl_enchanting.unload_enchantments(itemstack)
 	local itemdef = itemstack:get_definition()
 	if itemdef.tool_capabilities then
-		itemstack:get_meta():set_tool_capabilities(itemdef.tool_capabilities)
+		itemstack:get_meta():set_tool_capabilities(nil)
 	end
 	local meta = itemstack:get_meta()
 	if meta:get_string("name") == "" then
 		meta:set_string("description", "")
+		meta:set_string("groupcaps_hash", "")
 	end
 end
 
@@ -219,6 +220,38 @@ function mcl_enchanting.enchantments_snippet(_, _, itemstack)
 	end
 end
 
+-- Returns the after_use callback function to use when registering an enchanted
+-- item.  The after_use callback is used to update the tool_capabilities of
+-- efficiency enchanted tools with outdated digging times.
+--
+-- It does this by calling apply_efficiency to reapply the efficiency
+-- enchantment.  That function is written to use hash values to only update the
+-- tool if neccessary.
+--
+-- This is neccessary for digging times of tools to be in sync when MineClone2
+-- or mods add new hardness values.
+local function get_after_use_callback(itemdef)
+	if itemdef.after_use then
+		-- If the tool already has an after_use, make sure to call that
+		-- one too.
+		return function(itemstack, user, node, digparams)
+			itemdef.after_use(itemstack, user, node, digparams)
+			mcl_enchanting.update_groupcaps(itemstack)
+		end
+	end
+
+	-- If the tool does not have after_use, add wear to the tool as if no
+	-- after_use was registered.
+	return function(itemstack, user, node, digparams)
+		if not minetest.is_creative_enabled(user) then
+			itemstack:add_wear(digparams.wear)
+		end
+
+		local enchantments = mcl_enchanting.get_enchantments(itemstack)
+		mcl_enchanting.update_groupcaps(itemstack)
+	end
+end
+
 function mcl_enchanting.initialize()
 	local register_tool_list = {}
 	local register_item_list = {}
@@ -236,6 +269,7 @@ function mcl_enchanting.initialize()
 			new_def.groups.enchanted = 1
 			new_def.texture = itemdef.texture or itemname:gsub("%:", "_")
 			new_def._mcl_enchanting_enchanted_tool = new_name
+			new_def.after_use = get_after_use_callback(itemdef)
 			local register_list = register_item_list
 			if itemdef.type == "tool" then
 				register_list = register_tool_list

mods/ITEMS/mcl_enchanting/groupcaps.lua

@@ -0,0 +1,75 @@
+local groupcaps_cache = {}
+
+-- Compute a hash value.
+function compute_hash(value)
+	-- minetest.get_password_hash is quite fast, even if it uses a
+	-- cryptographic hashing function (SHA-1).  It is written in C++ and it
+	-- is probably hard to write a faster hashing function in Lua.
+	return string.sub(minetest.get_password_hash("ryvnf", minetest.serialize(value)), 1, 8)
+end
+
+-- Get the groupcaps and hash for an enchanted tool.  If this function is called
+-- repeatedly with the same values it will return data from a cache.
+--
+-- Parameters:
+-- toolname - Name of the tool
+-- level - The efficiency level of the tool
+--
+-- Returns a table with the following two fields:
+-- values - The groupcaps table
+-- hash - The hash of the groupcaps table
+local function get_efficiency_groupcaps(toolname, level)
+	local toolcache = groupcaps_cache[toolname]
+	local level = level
+
+	if not toolcache then
+		toolcache = {}
+		groupcaps_cache[toolname] = toolcache
+	end
+
+	local levelcache = toolcache[level]
+	if not levelcache then
+		levelcache = {}
+		levelcache.values = mcl_autogroup.get_groupcaps(toolname, level)
+		levelcache.hash = compute_hash(levelcache.values)
+		toolcache[level] = levelcache
+	end
+
+	return levelcache
+end
+
+-- Update groupcaps of an enchanted tool.  This function will be called
+-- repeatedly to make sure the digging times stored in groupcaps stays in sync
+-- when the digging times of nodes can change.
+--
+-- To make it more efficient it will first check a hash value to determine if
+-- the tool needs to be updated.
+function mcl_enchanting.update_groupcaps(itemstack)
+	local name = itemstack:get_name()
+	if not minetest.registered_tools[name].tool_capabilities then
+		return
+	end
+
+	local efficiency = mcl_enchanting.get_enchantment(itemstack, "efficiency")
+	local unbreaking = mcl_enchanting.get_enchantment(itemstack, "unbreaking")
+	if unbreaking == 0 and efficiency == 0 then
+		return
+	end
+
+	local groupcaps = get_efficiency_groupcaps(name, efficiency)
+	local hash = itemstack:get_meta():get_string("groupcaps_hash")
+
+	if not hash or hash ~= groupcaps.hash then
+		local tool_capabilities = itemstack:get_tool_capabilities()
+		tool_capabilities.groupcaps = table.copy(groupcaps.values)
+
+		-- Increase the number of uses depending on the unbreaking level
+		-- of the tool.
+		for group, capability in pairs(tool_capabilities.groupcaps) do
+			capability.uses = capability.uses * (1 + unbreaking)
+		end
+
+		itemstack:get_meta():set_tool_capabilities(tool_capabilities)
+		itemstack:get_meta():set_string("groupcaps_hash", groupcaps.hash)
+	end
+end

mods/ITEMS/mcl_enchanting/init.lua

@@ -59,6 +59,7 @@ mcl_enchanting = {
 }
 
 dofile(modpath .. "/engine.lua")
+dofile(modpath .. "/groupcaps.lua")
 dofile(modpath .. "/enchantments.lua")
 
 minetest.register_chatcommand("enchant", {

mods/ITEMS/mcl_tools/depends.txt

@@ -1,2 +1 @@
 mcl_sounds
-_mcl_autogroup

mods/ITEMS/mcl_tools/init.lua

@@ -6,14 +6,7 @@ local S = minetest.get_translator("mcl_tools")
 -- Tool definition
 --
 
---[[ Maximum drop level definitions:
-- 0: Hand
-- 1: Wood / Shears
-- 2: Gold
-- 3: Stone
-- 4: Iron
-- 5: Diamond
-
+--[[
 dig_speed_class group:
 - 1: Painfully slow
 - 2: Very slow
@@ -26,25 +19,18 @@ dig_speed_class group:
 
 -- The hand
 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},
-	}
-	-- 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
+	groupcaps = { creative_breakable = { times = {0}, uses = 0 } }
 	hand_range = 10
 	hand_groups = { dig_speed_class = 7 }
 else
-	groupcaps = {
-		handy_dig = {times=mcl_autogroup.digtimes.handy_dig, uses=0},
-	}
+	groupcaps = {}
 	hand_range = 4
 	hand_groups = { dig_speed_class = 1 }
 end
-minetest.register_item(":", {
+minetest.register_tool(":", {
 	type = "none",
 	_doc_items_longdesc = S("You use your bare hand whenever you are not wielding any item. With your hand you can mine most blocks, but this is the slowest method and only the weakest blocks will yield their useful drop. The hand also deals minor damage by punching. Using the hand is often a last resort, as proper mining tools and weapons are much better.").."\n"..
 			S("When you are wielding an item which is not a mining tool or a weapon, it will behave as if it were the hand when you start mining or punching.").."\n"..
@@ -61,6 +47,17 @@ minetest.register_item(":", {
 		damage_groups = {fleshy=1},
 	},
 	groups = hand_groups,
+	_mcl_diggroups = {
+		handy = { speed = 1, level = 1, uses = 0 },
+		axey = { speed = 1, level = 1, uses = 0 },
+		shovely = { speed = 1, level = 1, uses = 0 },
+		pickaxey = { speed = 1, level = 0, uses = 0 },
+		swordy = { speed = 1, level = 0, uses = 0 },
+		swordy_cobweb = { speed = 1, level = 0, uses = 0 },
+		shearsy = { speed = 1, level = 0, uses = 0 },
+		shearsy_wool = { speed = 1, level = 0, uses = 0 },
+		shearsy_cobweb = { speed = 1, level = 0, uses = 0 },
+	}
 })
 
 -- Help texts
@@ -86,15 +83,15 @@ 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},
-		},
 		damage_groups = {fleshy=2},
 		punch_attack_uses = 30,
 	},
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "group:wood",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		pickaxey = { speed = 2, level = 1, uses = 60 }
+	},
 })
 minetest.register_tool("mcl_tools:pick_stone", {
 	description = S("Stone Pickaxe"),
@@ -106,15 +103,15 @@ 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},
-		},
 		damage_groups = {fleshy=3},
 		punch_attack_uses = 66,
 	},
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:cobble",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		pickaxey = { speed = 4, level = 3, uses = 132 }
+	},
 })
 minetest.register_tool("mcl_tools:pick_iron", {
 	description = S("Iron Pickaxe"),
@@ -126,15 +123,15 @@ 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},
-		},
 		damage_groups = {fleshy=4},
 		punch_attack_uses = 126,
 	},
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:iron_ingot",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		pickaxey = { speed = 6, level = 4, uses = 251 }
+	},
 })
 minetest.register_tool("mcl_tools:pick_gold", {
 	description = S("Golden Pickaxe"),
@@ -146,15 +143,15 @@ 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},
-		},
 		damage_groups = {fleshy=2},
 		punch_attack_uses = 17,
 	},
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:gold_ingot",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		pickaxey = { speed = 12, level = 2, uses = 33 }
+	},
 })
 minetest.register_tool("mcl_tools:pick_diamond", {
 	description = S("Diamond Pickaxe"),
@@ -166,37 +163,17 @@ 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},
-		},
 		damage_groups = {fleshy=5},
 		punch_attack_uses = 781,
 	},
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:diamond",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		pickaxey = { speed = 8, level = 5, uses = 1562 }
+	},
 })
 
-local get_shovel_dig_group = function(itemstack)
-	local itemstring = itemstack:get_name()
-	local efficiency_level = mcl_enchanting.get_enchantment(itemstack, "efficiency")
-	local postfix = efficiency_level > 0 and "_efficiency_" .. efficiency_level or ""
-	if itemstring:find("mcl_tools:shovel_wood") == 1 then
-		return "shovely_dig_wood" .. postfix
-	elseif itemstring:find("mcl_tools:shovel_stone") == 1 then
-		return "shovely_dig_stone" .. postfix
-	elseif itemstring:find("mcl_tools:shovel_iron") == 1 then
-		return "shovely_dig_iron" .. postfix
-	elseif itemstring:find("mcl_tools:shovel_gold") == 1 then
-		return "shovely_dig_gold" .. postfix
-	elseif itemstring:find("mcl_tools:shovel_diamond") == 1 then
-		return "shovely_dig_diamond" .. postfix
-	else
-		-- Fallback
-		return "shovely_dig_wood"
-	end
-end
-
 local make_grass_path = function(itemstack, placer, pointed_thing)
 	-- Use pointed node's on_rightclick function first, if present
 	local node = minetest.get_node(pointed_thing.under)
@@ -221,15 +198,9 @@ local make_grass_path = function(itemstack, placer, pointed_thing)
 			end
 
 			if not minetest.is_creative_enabled(placer:get_player_name()) then
-				-- Add wear, as if digging a level 0 shovely node
+				-- Add wear (as if digging a shovely node)
 				local toolname = itemstack:get_name()
-				local def = minetest.registered_items[toolname]
-				local group = get_shovel_dig_group(itemstack)
-				local toolcaps = itemstack:get_tool_capabilities()
-				local base_uses = toolcaps.groupcaps[group].uses
-				local maxlevel = toolcaps.groupcaps[group].maxlevel
-				local uses = base_uses * math.pow(3, maxlevel)
-				local wear = math.ceil(65535 / uses)
+				local wear = mcl_autogroup.get_wear(toolname, "shovely")
 				itemstack:add_wear(wear)
 			end
 			minetest.sound_play({name="default_grass_footstep", gain=1}, {pos = above}, true)
@@ -258,12 +229,7 @@ if minetest.get_modpath("mcl_farming") then
 			if not minetest.is_creative_enabled(placer:get_player_name()) then
 				-- Add wear (as if digging a shearsy node)
 				local toolname = itemstack:get_name()
-				local def = minetest.registered_items[toolname]
-				local group = get_shovel_dig_group(toolname)
-				local base_uses = def.tool_capabilities.groupcaps["shearsy_dig"].uses
-				local maxlevel = def.tool_capabilities.groupcaps["shearsy_dig"].maxlevel
-				local uses = base_uses * math.pow(3, maxlevel)
-				local wear = math.ceil(65535 / uses)
+				local wear = mcl_autogroup.get_wear(toolname, "shearsy")
 				itemstack:add_wear(wear)
 			end
 			minetest.sound_play({name="default_grass_footstep", gain=1}, {pos = above}, true)
@@ -288,9 +254,6 @@ 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},
-		},
 		damage_groups = {fleshy=2},
 		punch_attack_uses = 30,
 	},
@@ -298,6 +261,9 @@ minetest.register_tool("mcl_tools:shovel_wood", {
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "group:wood",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		shovely = { speed = 2, level = 1, uses = 60 }
+	},
 })
 minetest.register_tool("mcl_tools:shovel_stone", {
 	description = S("Stone Shovel"),
@@ -309,9 +275,6 @@ 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},
-		},
 		damage_groups = {fleshy=3},
 		punch_attack_uses = 66,
 	},
@@ -319,6 +282,9 @@ minetest.register_tool("mcl_tools:shovel_stone", {
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:cobble",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		shovely = { speed = 4, level = 3, uses = 132 }
+	},
 })
 minetest.register_tool("mcl_tools:shovel_iron", {
 	description = S("Iron Shovel"),
@@ -330,9 +296,6 @@ 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},
-		},
 		damage_groups = {fleshy=4},
 		punch_attack_uses = 126,
 	},
@@ -340,6 +303,9 @@ minetest.register_tool("mcl_tools:shovel_iron", {
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:iron_ingot",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		shovely = { speed = 6, level = 4, uses = 251 }
+	},
 })
 minetest.register_tool("mcl_tools:shovel_gold", {
 	description = S("Golden Shovel"),
@@ -351,9 +317,6 @@ 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},
-		},
 		damage_groups = {fleshy=2},
 		punch_attack_uses = 17,
 	},
@@ -361,6 +324,9 @@ minetest.register_tool("mcl_tools:shovel_gold", {
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:gold_ingot",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		shovely = { speed = 12, level = 2, uses = 33 }
+	},
 })
 minetest.register_tool("mcl_tools:shovel_diamond", {
 	description = S("Diamond Shovel"),
@@ -372,9 +338,6 @@ 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},
-		},
 		damage_groups = {fleshy=5},
 		punch_attack_uses = 781,
 	},
@@ -382,6 +345,9 @@ minetest.register_tool("mcl_tools:shovel_diamond", {
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:diamond",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		shovely = { speed = 8, level = 5, uses = 1562 }
+	},
 })
 
 -- Axes
@@ -395,15 +361,15 @@ 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},
-		},
 		damage_groups = {fleshy=7},
 		punch_attack_uses = 30,
 	},
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "group:wood",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		axey = { speed = 2, level = 1, uses = 60 }
+	},
 })
 minetest.register_tool("mcl_tools:axe_stone", {
 	description = S("Stone Axe"),
@@ -414,15 +380,15 @@ 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},
-		},
 		damage_groups = {fleshy=9},
 		punch_attack_uses = 66,
 	},
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:cobble",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		axey = { speed = 4, level = 3, uses = 132 }
+	},
 })
 minetest.register_tool("mcl_tools:axe_iron", {
 	description = S("Iron Axe"),
@@ -434,15 +400,15 @@ 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},
-		},
 		damage_groups = {fleshy=9},
 		punch_attack_uses = 126,
 	},
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:iron_ingot",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		axey = { speed = 6, level = 4, uses = 251 }
+	},
 })
 minetest.register_tool("mcl_tools:axe_gold", {
 	description = S("Golden Axe"),
@@ -453,15 +419,15 @@ 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},
-		},
 		damage_groups = {fleshy=7},
 		punch_attack_uses = 17,
 	},
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:gold_ingot",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		axey = { speed = 12, level = 2, uses = 33 }
+	},
 })
 minetest.register_tool("mcl_tools:axe_diamond", {
 	description = S("Diamond Axe"),
@@ -472,15 +438,15 @@ 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},
-		},
 		damage_groups = {fleshy=9},
 		punch_attack_uses = 781,
 	},
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:diamond",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		axey = { speed = 8, level = 5, uses = 1562 }
+	},
 })
 
 -- Swords
@@ -494,16 +460,16 @@ 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},
-		},
 		damage_groups = {fleshy=4},
 		punch_attack_uses = 60,
 	},
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "group:wood",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		swordy = { speed = 2, level = 1, uses = 60 },
+		swordy_cobweb = { speed = 2, level = 1, uses = 60 }
+	},
 })
 minetest.register_tool("mcl_tools:sword_stone", {
 	description = S("Stone Sword"),
@@ -514,16 +480,16 @@ 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},
-		},
 		damage_groups = {fleshy=5},
 		punch_attack_uses = 132,
 	},
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:cobble",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		swordy = { speed = 4, level = 3, uses = 132 },
+		swordy_cobweb = { speed = 4, level = 3, uses = 132 }
+	},
 })
 minetest.register_tool("mcl_tools:sword_iron", {
 	description = S("Iron Sword"),
@@ -534,16 +500,16 @@ 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},
-		},
 		damage_groups = {fleshy=6},
 		punch_attack_uses = 251,
 	},
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:iron_ingot",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		swordy = { speed = 6, level = 4, uses = 251 },
+		swordy_cobweb = { speed = 6, level = 4, uses = 251 }
+	},
 })
 minetest.register_tool("mcl_tools:sword_gold", {
 	description = S("Golden Sword"),
@@ -554,16 +520,16 @@ 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},
-		},
 		damage_groups = {fleshy=4},
 		punch_attack_uses = 33,
 	},
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:gold_ingot",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		swordy = { speed = 12, level = 2, uses = 33 },
+		swordy_cobweb = { speed = 12, level = 2, uses = 33 }
+	},
 })
 minetest.register_tool("mcl_tools:sword_diamond", {
 	description = S("Diamond Sword"),
@@ -574,16 +540,16 @@ 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},
-		},
 		damage_groups = {fleshy=7},
 		punch_attack_uses = 1562,
 	},
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:diamond",
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		swordy = { speed = 8, level = 5, uses = 1562 },
+		swordy_cobweb = { speed = 8, level = 5, uses = 1562 }
+	},
 })
 
 --Shears
@@ -598,14 +564,15 @@ 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},
-		}
 	},
 	on_place = carve_pumpkin,
 	sound = { breaks = "default_tool_breaks" },
 	_mcl_toollike_wield = true,
+	_mcl_diggroups = {
+		shearsy = { speed = 1.5, level = 1, uses = 238 },
+		shearsy_wool = { speed = 5, level = 1, uses = 238 },
+		shearsy_cobweb = { speed = 15, level = 1, uses = 238 }
+	},
 })