The huge item definition and item namespace unification patch (itemdef), see http://c55.me/minetest/wiki/doku.php?id=changes:itemdef

6 files changed, 1351 insertions, 847 deletions

diff --git a/data/builtin.lua b/data/builtin.lua
index 1046e934e..1926d88b4 100644
--- a/data/builtin.lua
+++ b/data/builtin.lua
@@ -80,15 +80,91 @@ function dump(o, dumped)
 end
 
 --
--- Built-in node definitions. Also defined in C.
+-- Item definition helpers
+--
+
+minetest.inventorycube = function(img1, img2, img3)
+	img2 = img2 or img1
+	img3 = img3 or img1
+	return "[inventorycube"
+			.. "{" .. img1:gsub("%^", "&")
+			.. "{" .. img2:gsub("%^", "&")
+			.. "{" .. img3:gsub("%^", "&")
+end
+
+minetest.get_pointed_thing_position = function(pointed_thing, above)
+	if pointed_thing.type == "node" then
+		if above then
+			-- The position where a node would be placed
+			return pointed_thing.above
+		else
+			-- The position where a node would be dug
+			return pointed_thing.under
+		end
+	elseif pointed_thing.type == "object" then
+		obj = pointed.thing.ref
+		if obj ~= nil then
+			return obj:getpos()
+		else
+			return nil
+		end
+	else
+		return nil
+	end
+end
+
+function minetest.item_place(itemstack, placer, pointed_thing)
+	pos = minetest.get_pointed_thing_position(pointed_thing, true)
+	if pos ~= nil then
+		item = itemstack:take_item()
+		if item ~= nil then
+			minetest.env:add_item(pos, item)
+		end
+	end
+	return itemstack
+end
+
+function minetest.item_drop(itemstack, dropper, pos)
+	minetest.env:add_item(pos, itemstack)
+	return ""
+end
+
+function minetest.item_eat(hp_change)
+	return function(itemstack, user, pointed_thing)  -- closure
+		if itemstack:take_item() ~= nil then
+			user:set_hp(user:get_hp() + hp_change)
+		end
+		return itemstack
+	end
+end
+
+--
+-- Item definition defaults
 --
 
-minetest.register_nodedef_defaults({
+minetest.nodedef_default = {
+	-- Item properties
+	type="node",
 	-- name intentionally not defined here
+	description = "",
+	inventory_image = "",
+	wield_image = "",
+	wield_scale = {x=1,y=1,z=1},
+	stack_max = 99,
+	dropcount = -1,
+	usable = false,
+	liquids_pointable = false,
+	tool_digging_properties = nil,
+
+	-- Interaction callbacks
+	on_place = nil, -- let C handle node placement for now
+	on_drop = minetest.item_drop,
+	on_use = nil,
+
+	-- Node properties
 	drawtype = "normal",
 	visual_scale = 1.0,
-	tile_images = {"unknown_block.png"},
-	inventory_image = "unknown_block.png",
+	tile_images = {""},
 	special_materials = {
 		{image="", backface_culling=true},
 		{image="", backface_culling=true},
@@ -104,8 +180,7 @@ minetest.register_nodedef_defaults({
 	climbable = false,
 	buildable_to = false,
 	wall_mounted = false,
-	often_contains_mineral = false,
-	dug_item = "",
+	--dug_item intentionally not defined here
 	extra_dug_item = "",
 	extra_dug_item_rarity = 2,
 	metadata_name = "",
@@ -124,219 +199,349 @@ minetest.register_nodedef_defaults({
 		cuttability = 0,
 		flammability = 0,
 	},
-	cookresult_item = "", -- Cannot be cooked
-	furnace_cooktime = 3.0,
-	furnace_burntime = -1, -- Cannot be used as fuel
-})
+}
 
-minetest.register_node("air", {
-	drawtype = "airlike",
-	paramtype = "light",
-	sunlight_propagates = true,
-	walkable = false,
-	pointable = false,
-	diggable = false,
-	buildable_to = true,
-	air_equivalent = true,
-})
+minetest.craftitemdef_default = {
+	type="craft",
+	-- name intentionally not defined here
+	description = "",
+	inventory_image = "",
+	wield_image = "",
+	wield_scale = {x=1,y=1,z=1},
+	stack_max = 99,
+	liquids_pointable = false,
+	tool_digging_properties = nil,
+
+	-- Interaction callbacks
+	on_place = minetest.item_place,
+	on_drop = minetest.item_drop,
+	on_use = nil,
+}
+
+minetest.tooldef_default = {
+	type="tool",
+	-- name intentionally not defined here
+	description = "",
+	inventory_image = "",
+	wield_image = "",
+	wield_scale = {x=1,y=1,z=1},
+	stack_max = 1,
+	liquids_pointable = false,
+	tool_digging_properties = nil,
+
+	-- Interaction callbacks
+	on_place = minetest.item_place,
+	on_drop = minetest.item_drop,
+	on_use = nil,
+}
+
+minetest.noneitemdef_default = {  -- This is used for the hand and unknown items
+	type="none",
+	-- name intentionally not defined here
+	description = "",
+	inventory_image = "",
+	wield_image = "",
+	wield_scale = {x=1,y=1,z=1},
+	stack_max = 99,
+	liquids_pointable = false,
+	tool_digging_properties = nil,
+
+	-- Interaction callbacks
+	on_place = nil,
+	on_drop = nil,
+	on_use = nil,
+}
 
-minetest.register_node("ignore", {
-	drawtype = "airlike",
-	paramtype = "none",
-	sunlight_propagates = false,
-	walkable = false,
-	pointable = false,
-	diggable = false,
-	buildable_to = true, -- A way to remove accidentally placed ignores
-	air_equivalent = true,
-})
+--
+-- Make raw registration functions inaccessible to anyone except builtin.lua
+--
+
+local register_item_raw = minetest.register_item_raw
+minetest.register_item_raw = nil
+
+local register_alias_raw = minetest.register_alias_raw
+minetest.register_item_raw = nil
 
 --
--- stackstring manipulation functions
--- example stackstring: 'craft "apple" 4'
--- example item: {type="craft", name="apple"}
--- example item: {type="tool", name="SteelPick", wear="23272"}
+-- Item / entity / ABM registration functions
 --
 
-function stackstring_take_item(stackstring)
-	if stackstring == nil then
-		return '', nil
-	end
-	local stacktype = nil
-	stacktype = string.match(stackstring,
-			'([%a%d]+)')
-	if stacktype == "node" or stacktype == "craft" then
-		local itemtype = nil
-		local itemname = nil
-		local itemcount = nil
-		itemtype, itemname, itemcount = string.match(stackstring,
-				'([%a%d]+) "([^"]*)" (%d+)')
-		itemcount = tonumber(itemcount)
-		if itemcount == 0 then
-			return '', nil
-		elseif itemcount == 1 then
-			return '', {type=itemtype, name=itemname}
-		else
-			return itemtype.." \""..itemname.."\" "..(itemcount-1),
-					{type=itemtype, name=itemname}
+minetest.registered_abms = {}
+minetest.registered_entities = {}
+minetest.registered_items = {}
+minetest.registered_nodes = {}
+minetest.registered_craftitems = {}
+minetest.registered_tools = {}
+minetest.registered_aliases = {}
+
+-- For tables that are indexed by item name:
+-- If table[X] does not exist, default to table[minetest.registered_aliases[X]]
+local function set_alias_metatable(table)
+	setmetatable(table, {
+		__index = function(name)
+			return rawget(table, minetest.registered_aliases[name])
+		end
+	})
+end
+set_alias_metatable(minetest.registered_items)
+set_alias_metatable(minetest.registered_nodes)
+set_alias_metatable(minetest.registered_craftitems)
+set_alias_metatable(minetest.registered_tools)
+
+-- These item names may not be used because they would interfere
+-- with legacy itemstrings
+local forbidden_item_names = {
+	MaterialItem = true,
+	MaterialItem2 = true,
+	MaterialItem3 = true,
+	NodeItem = true,
+	node = true,
+	CraftItem = true,
+	craft = true,
+	MBOItem = true,
+	ToolItem = true,
+	tool = true,
+}
+
+local function check_modname_prefix(name)
+	if name:sub(1,1) == ":" then
+		-- Escape the modname prefix enforcement mechanism
+		return name:sub(2)
+	else
+		-- Modname prefix enforcement
+		local expected_prefix = minetest.get_current_modname() .. ":"
+		if name:sub(1, #expected_prefix) ~= expected_prefix then
+			error("Name " .. name .. " does not follow naming conventions: " ..
+				"\"modname:\" or \":\" prefix required")
 		end
-	elseif stacktype == "tool" then
-		local itemtype = nil
-		local itemname = nil
-		local itemwear = nil
-		itemtype, itemname, itemwear = string.match(stackstring,
-				'([%a%d]+) "([^"]*)" (%d+)')
-		itemwear = tonumber(itemwear)
-		return '', {type=itemtype, name=itemname, wear=itemwear}
+		local subname = name:sub(#expected_prefix+1)
+		if subname:find("[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]") then
+			error("Name " .. name .. " does not follow naming conventions: " ..
+				"contains unallowed characters")
+		end
+		return name
 	end
 end
 
-function stackstring_put_item(stackstring, item)
-	if item == nil then
-		return stackstring, false
+function minetest.register_abm(spec)
+	-- Add to minetest.registered_abms
+	minetest.registered_abms[#minetest.registered_abms+1] = spec
+end
+
+function minetest.register_entity(name, prototype)
+	-- Check name
+	if name == nil then
+		error("Unable to register entity: Name is nil")
 	end
-	stackstring = stackstring or ''
-	local stacktype = nil
-	stacktype = string.match(stackstring,
-			'([%a%d]+)')
-	stacktype = stacktype or ''
-	if stacktype ~= '' and stacktype ~= item.type then
-		return stackstring, false
+	name = check_modname_prefix(tostring(name))
+
+	prototype.name = name
+	prototype.__index = prototype  -- so that it can be used as a metatable
+
+	-- Add to minetest.registered_entities
+	minetest.registered_entities[name] = prototype
+end
+
+function minetest.register_item(name, itemdef)
+	-- Check name
+	if name == nil then
+		error("Unable to register item: Name is nil")
 	end
-	if item.type == "node" or item.type == "craft" then
-		local itemtype = nil
-		local itemname = nil
-		local itemcount = nil
-		itemtype, itemname, itemcount = string.match(stackstring,
-				'([%a%d]+) "([^"]*)" (%d+)')
-		itemtype = itemtype or item.type
-		itemname = itemname or item.name
-		if itemcount == nil then
-			itemcount = 0
-		end
-		itemcount = itemcount + 1
-		return itemtype.." \""..itemname.."\" "..itemcount, true
-	elseif item.type == "tool" then
-		if stacktype ~= nil then
-			return stackstring, false
-		end
-		local itemtype = nil
-		local itemname = nil
-		local itemwear = nil
-		itemtype, itemname, itemwear = string.match(stackstring,
-				'([%a%d]+) "([^"]*)" (%d+)')
-		itemwear = tonumber(itemwear)
-		return itemtype.." \""..itemname.."\" "..itemwear, true
+	name = check_modname_prefix(tostring(name))
+	if forbidden_item_names[name] then
+		error("Unable to register item: Name is forbidden: " .. name)
+	end
+	itemdef.name = name
+
+	-- Apply defaults and add to registered_* table
+	if itemdef.type == "node" then
+		setmetatable(itemdef, {__index = minetest.nodedef_default})
+		minetest.registered_nodes[itemdef.name] = itemdef
+	elseif itemdef.type == "craft" then
+		setmetatable(itemdef, {__index = minetest.craftitemdef_default})
+		minetest.registered_craftitems[itemdef.name] = itemdef
+	elseif itemdef.type == "tool" then
+		setmetatable(itemdef, {__index = minetest.tooldef_default})
+		minetest.registered_tools[itemdef.name] = itemdef
+	elseif itemdef.type == "none" then
+		setmetatable(itemdef, {__index = minetest.noneitemdef_default})
+	else
+		error("Unable to register item: Type is invalid: " .. dump(itemdef))
 	end
-	return stackstring, false
-end
 
-function stackstring_put_stackstring(stackstring, src)
-	while src ~= '' do
-		--print("src="..dump(src))
-		src, item = stackstring_take_item(src)
-		--print("src="..dump(src).." item="..dump(item))
-		local success
-		stackstring, success = stackstring_put_item(stackstring, item)
-		if not success then
-			return stackstring, false
-		end
+	-- Default dug item
+	if itemdef.type == "node" and itemdef.dug_item == nil then
+		itemdef.dug_item = ItemStack({name=itemdef.name}):to_string()
 	end
-	return stackstring, true
+
+	-- Legacy stuff
+	if itemdef.cookresult_itemstring ~= nil and itemdef.cookresult_itemstring ~= "" then
+		minetest.register_craft({
+			type="cooking",
+			output=itemdef.cookresult_itemstring,
+			recipe=itemdef.name,
+			cooktime=itemdef.furnace_cooktime
+		})
+	end
+	if itemdef.furnace_burntime ~= nil and itemdef.furnace_burntime >= 0 then
+		minetest.register_craft({
+			type="fuel",
+			recipe=itemdef.name,
+			burntime=itemdef.furnace_burntime
+		})
+	end
+
+	-- Disable all further modifications
+	getmetatable(itemdef).__newindex = {}
+
+	--minetest.log("Registering item: " .. itemdef.name)
+	minetest.registered_items[itemdef.name] = itemdef
+	minetest.registered_aliases[itemdef.name] = nil
+	register_item_raw(itemdef)
 end
 
-function test_stackstring()
-	local stack
-	local item
-	local success
-
-	stack, item = stackstring_take_item('node "TNT" 3')
-	assert(stack == 'node "TNT" 2')
-	assert(item.type == 'node')
-	assert(item.name == 'TNT')
-
-	stack, item = stackstring_take_item('craft "with spaces" 2')
-	assert(stack == 'craft "with spaces" 1')
-	assert(item.type == 'craft')
-	assert(item.name == 'with spaces')
-
-	stack, item = stackstring_take_item('craft "with spaces" 1')
-	assert(stack == '')
-	assert(item.type == 'craft')
-	assert(item.name == 'with spaces')
-
-	stack, item = stackstring_take_item('craft "s8df2kj3" 0')
-	assert(stack == '')
-	assert(item == nil)
-
-	stack, item = stackstring_take_item('tool "With Spaces" 32487')
-	assert(stack == '')
-	assert(item.type == 'tool')
-	assert(item.name == 'With Spaces')
-	assert(item.wear == 32487)
-
-	stack, success = stackstring_put_item('node "With Spaces" 40',
-			{type='node', name='With Spaces'})
-	assert(stack == 'node "With Spaces" 41')
-	assert(success == true)
-
-	stack, success = stackstring_put_item('craft "With Spaces" 40',
-			{type='craft', name='With Spaces'})
-	assert(stack == 'craft "With Spaces" 41')
-	assert(success == true)
-
-	stack, success = stackstring_put_item('tool "With Spaces" 32487',
-			{type='tool', name='With Spaces'})
-	assert(stack == 'tool "With Spaces" 32487')
-	assert(success == false)
-
-	stack, success = stackstring_put_item('node "With Spaces" 40',
-			{type='tool', name='With Spaces'})
-	assert(stack == 'node "With Spaces" 40')
-	assert(success == false)
-	
-	assert(stackstring_put_stackstring('node "With Spaces" 2',
-			'node "With Spaces" 1') == 'node "With Spaces" 3')
+function minetest.register_node(name, nodedef)
+	nodedef.type = "node"
+	minetest.register_item(name, nodedef)
 end
-test_stackstring()
 
---
--- NodeItem helpers
---
+function minetest.register_craftitem(name, craftitemdef)
+	craftitemdef.type = "craft"
 
-minetest.inventorycube = function(img1, img2, img3)
-	img2 = img2 or img1
-	img3 = img3 or img1
-	return "[inventorycube"
-			.. "{" .. img1:gsub("%^", "&")
-			.. "{" .. img2:gsub("%^", "&")
-			.. "{" .. img3:gsub("%^", "&")
+	-- Legacy stuff
+	if craftitemdef.inventory_image == nil and craftitemdef.image ~= nil then
+		craftitemdef.inventory_image = craftitemdef.image
+	end
+
+	minetest.register_item(name, craftitemdef)
 end
 
---
--- CraftItem helpers
---
+function minetest.register_tool(name, tooldef)
+	tooldef.type = "tool"
+	tooldef.stack_max = 1
+
+	-- Legacy stuff
+	if tooldef.inventory_image == nil and tooldef.image ~= nil then
+		tooldef.inventory_image = tooldef.image
+	end
+	if tooldef.tool_digging_properties == nil and
+	   (tooldef.full_punch_interval ~= nil or
+	    tooldef.basetime ~= nil or
+	    tooldef.dt_weight ~= nil or
+	    tooldef.dt_crackiness ~= nil or
+	    tooldef.dt_crumbliness ~= nil or
+	    tooldef.dt_cuttability ~= nil or
+	    tooldef.basedurability ~= nil or
+	    tooldef.dd_weight ~= nil or
+	    tooldef.dd_crackiness ~= nil or
+	    tooldef.dd_crumbliness ~= nil or
+	    tooldef.dd_cuttability ~= nil) then
+		tooldef.tool_digging_properties = {
+			full_punch_interval = tooldef.full_punch_interval,
+			basetime = tooldef.basetime,
+			dt_weight = tooldef.dt_weight,
+			dt_crackiness = tooldef.dt_crackiness,
+			dt_crumbliness = tooldef.dt_crumbliness,
+			dt_cuttability = tooldef.dt_cuttability,
+			basedurability = tooldef.basedurability,
+			dd_weight = tooldef.dd_weight,
+			dd_crackiness = tooldef.dd_crackiness,
+			dd_crumbliness = tooldef.dd_crumbliness,
+			dd_cuttability = tooldef.dd_cuttability,
+		}
+	end
 
-minetest.craftitem_place_item = function(item, placer, pos)
-	--print("craftitem_place_item")
-	--print("item: " .. dump(item))
-	--print("placer: " .. dump(placer))
-	--print("pos: " .. dump(pos))
-	minetest.env:add_item(pos, 'craft "' .. item .. '" 1')
-	return true
+	minetest.register_item(name, tooldef)
 end
 
-minetest.craftitem_eat = function(hp_change)
-	return function(item, user, pointed_thing)  -- closure
-		--print("craftitem_eat(" .. hp_change .. ")")
-		--print("item: " .. dump(item))
-		--print("user: " .. dump(user))
-		--print("pointed_thing: " .. dump(pointed_thing))
-		user:set_hp(user:get_hp() + hp_change)
-		return true
+function minetest.register_alias(name, convert_to)
+	if forbidden_item_names[name] then
+		error("Unable to register alias: Name is forbidden: " .. name)
 	end
+	if minetest.registered_items[name] ~= nil then
+		minetest.log("WARNING: Not registering alias, item with same name" ..
+			" is already defined: " .. name .. " -> " .. convert_to)
+	else
+		--minetest.log("Registering alias: " .. name .. " -> " .. convert_to)
+		minetest.registered_aliases[name] = convert_to
+		register_alias_raw(name, convert_to)
+	end
+end
+
+-- Alias the forbidden item names to "" so they can't be
+-- created via itemstrings (e.g. /give)
+local name
+for name in pairs(forbidden_item_names) do
+	minetest.registered_aliases[name] = ""
+	register_alias_raw(name, "")
 end
 
+
+-- Deprecated:
+-- Aliases for minetest.register_alias (how ironic...)
+--minetest.alias_node = minetest.register_alias
+--minetest.alias_tool = minetest.register_alias
+--minetest.alias_craftitem = minetest.register_alias
+
+--
+-- Built-in node definitions. Also defined in C.
+--
+
+minetest.register_item(":", {
+	type = "none",
+	wield_image = "wieldhand.png",
+	wield_scale = {x=1,y=1,z=2.5},
+	tool_digging_properties = {
+		full_punch_interval = 2.0,
+		basetime = 0.5,
+		dt_weight = 1,
+		dt_crackiness = 0,
+		dt_crumbliness = -1,
+		dt_cuttability = 0,
+		basedurability = 50,
+		dd_weight = 0,
+		dd_crackiness = 0,
+		dd_crumbliness = 0,
+		dd_cuttability = 0,
+	}
+})
+
+minetest.register_item(":unknown", {
+	type = "none",
+	description = "Unknown Item",
+	inventory_image = "unknown_item.png",
+	on_place = minetest.item_place,
+	on_drop = minetest.item_drop,
+})
+
+minetest.register_node(":air", {
+	description = "Air (you hacker you!)",
+	inventory_image = "unknown_block.png",
+	wield_image = "unknown_block.png",
+	drawtype = "airlike",
+	paramtype = "light",
+	sunlight_propagates = true,
+	walkable = false,
+	pointable = false,
+	diggable = false,
+	buildable_to = true,
+	air_equivalent = true,
+})
+
+minetest.register_node(":ignore", {
+	description = "Ignore (you hacker you!)",
+	inventory_image = "unknown_block.png",
+	wield_image = "unknown_block.png",
+	drawtype = "airlike",
+	paramtype = "none",
+	sunlight_propagates = false,
+	walkable = false,
+	pointable = false,
+	diggable = false,
+	buildable_to = true, -- A way to remove accidentally placed ignores
+	air_equivalent = true,
+})
+
 --
 -- Default material types
 --
@@ -422,7 +627,7 @@ end
 -- Callback registration
 --
 
-function make_registration()
+local function make_registration()
 	local t = {}
 	local registerfunc = function(func) table.insert(t, func) end
 	return t, registerfunc
diff --git a/data/clienttextures/unknown_item.png b/data/clienttextures/unknown_item.png
new file mode 100644
index 000000000..35cabf0ad
--- /dev/null
+++ b/data/clienttextures/unknown_item.png
diff --git a/data/mods/bucket/init.lua b/data/mods/bucket/init.lua
index 639a614d4..8ed9da522 100644
--- a/data/mods/bucket/init.lua
+++ b/data/mods/bucket/init.lua
@@ -1,80 +1,95 @@
 -- bucket (Minetest 0.4 mod)
 -- A bucket, which can pick up water and lava
 
-minetest.alias_craftitem("bucket", "bucket:bucket_empty")
-minetest.alias_craftitem("bucket_water", "bucket:bucket_water")
-minetest.alias_craftitem("bucket_lava", "bucket:bucket_lava")
+minetest.register_alias("bucket", "bucket:bucket_empty")
+minetest.register_alias("bucket_water", "bucket:bucket_water")
+minetest.register_alias("bucket_lava", "bucket:bucket_lava")
 
 minetest.register_craft({
-	output = 'craft "bucket:bucket_empty" 1',
+	output = 'bucket:bucket_empty 1',
 	recipe = {
-		{'craft "steel_ingot"', '', 'craft "steel_ingot"'},
-		{'', 'craft "steel_ingot"', ''},
+		{'default:steel_ingot', '', 'default:steel_ingot'},
+		{'', 'default:steel_ingot', ''},
 	}
 })
 
-minetest.register_craftitem("bucket:bucket_empty", {
-	image = "bucket.png",
-	stack_max = 1,
-	liquids_pointable = true,
-	on_place_on_ground = minetest.craftitem_place_item,
-	on_use = function(item, player, pointed_thing)
-		if pointed_thing.type == "node" then
-			n = minetest.env:get_node(pointed_thing.under)
-			if n.name == "default:water_source" then
-				minetest.env:add_node(pointed_thing.under, {name="air"})
-				player:add_to_inventory_later('craft "bucket:bucket_water" 1')
-				return true
-			elseif n.name == "default:lava_source" then
-				minetest.env:add_node(pointed_thing.under, {name="air"})
-				player:add_to_inventory_later('craft "bucket:bucket_lava" 1')
-				return true
+bucket = {}
+bucket.liquids = {}
+
+-- Register a new liquid
+--   source = name of the source node
+--   flowing = name of the flowing node
+--   itemname = name of the new bucket item (or nil if liquid is not takeable)
+--   inventory_image = texture of the new bucket item (ignored if itemname == nil)
+-- This function can be called from any mod (that depends on bucket).
+function bucket.register_liquid(source, flowing, itemname, inventory_image)
+	bucket.liquids[source] = {
+		source = source,
+		flowing = flowing,
+		itemname = itemname,
+	}
+	bucket.liquids[flowing] = bucket.liquids[source]
+
+	if itemname ~= nil then
+		minetest.register_craftitem(itemname, {
+			inventory_image = inventory_image,
+			stack_max = 1,
+			liquids_pointable = true,
+			on_use = function(itemstack, user, pointed_thing)
+				-- Must be pointing to node
+				if pointed_thing.type ~= "node" then
+					return
+				end
+				-- Check if pointing to a liquid
+				n = minetest.env:get_node(pointed_thing.under)
+				if bucket.liquids[n.name] == nil then
+					-- Not a liquid
+					minetest.env:add_node(pointed_thing.above, {name=source})
+				elseif n.name ~= source then
+					-- It's a liquid
+					minetest.env:add_node(pointed_thing.under, {name=source})
+				end
+				return {name="bucket:bucket_empty"}
 			end
-		end
-		return false
-	end,
-})
+		})
+	end
+end
 
-minetest.register_craftitem("bucket:bucket_water", {
-	image = "bucket_water.png",
+minetest.register_craftitem("bucket:bucket_empty", {
+	inventory_image = "bucket.png",
 	stack_max = 1,
 	liquids_pointable = true,
-	on_place_on_ground = minetest.craftitem_place_item,
-	on_use = function(item, player, pointed_thing)
-		if pointed_thing.type == "node" then
-			n = minetest.env:get_node(pointed_thing.under)
-			if n.name == "default:water_source" then
-				-- unchanged
-			elseif n.name == "default:water_flowing" or n.name == "default:lava_source" or n.name == "default:lava_flowing" then
-				minetest.env:add_node(pointed_thing.under, {name="default:water_source"})
-			else
-				minetest.env:add_node(pointed_thing.above, {name="default:water_source"})
-			end
-			player:add_to_inventory_later('craft "bucket:bucket_empty" 1')
-			return true
+	on_use = function(itemstack, user, pointed_thing)
+		-- Must be pointing to node
+		if pointed_thing.type ~= "node" then
+			return
+		end
+		-- Check if pointing to a liquid source
+		n = minetest.env:get_node(pointed_thing.under)
+		liquiddef = bucket.liquids[n.name]
+		if liquiddef ~= nil and liquiddef.source == n.name and liquiddef.itemname ~= nil then
+			minetest.env:add_node(pointed_thing.under, {name="air"})
+			return {name=liquiddef.itemname}
 		end
-		return false
 	end,
 })
 
-minetest.register_craftitem("bucket:bucket_lava", {
-	image = "bucket_lava.png",
-	stack_max = 1,
-	liquids_pointable = true,
-	on_place_on_ground = minetest.craftitem_place_item,
-	on_use = function(item, player, pointed_thing)
-		if pointed_thing.type == "node" then
-			n = minetest.env:get_node(pointed_thing.under)
-			if n.name == "default:lava_source" then
-				-- unchanged
-			elseif n.name == "default:water_source" or n.name == "default:water_flowing" or n.name == "default:lava_flowing" then
-				minetest.env:add_node(pointed_thing.under, {name="default:lava_source"})
-			else
-				minetest.env:add_node(pointed_thing.above, {name="default:lava_source"})
-			end
-			player:add_to_inventory_later('craft "bucket:bucket_empty" 1')
-			return true
-		end
-		return false
-	end,
+bucket.register_liquid(
+	"default:water_source",
+	"default:water_flowing",
+	"bucket:bucket_water",
+	"bucket_water.png"
+)
+
+bucket.register_liquid(
+	"default:lava_source",
+	"default:lava_flowing",
+	"bucket:bucket_lava",
+	"bucket_lava.png"
+)
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:bucket_lava",
+	burntime = 60,
 })
diff --git a/data/mods/default/init.lua b/data/mods/default/init.lua
index aa03eabe8..2bd950230 100644
--- a/data/mods/default/init.lua
+++ b/data/mods/default/init.lua
@@ -77,24 +77,25 @@
 -- eg. 'tool "default:pick_wood" 21323'
 -- eg. 'craft "default:apple" 2'
 --
--- item: A single item in Lua table format.
--- eg. {type="node", name="default:dirt"} 
+-- item: A stack of items in Lua table format.
+-- eg. {name="default:dirt", count=1, wear=0, metadata=""} 
 --     ^ a single dirt node
--- eg. {type="tool", name="default:pick_wood", wear=21323}
+-- eg. {name="default:pick_wood", count=1, wear=21323, metadata=""}
 --     ^ a wooden pick about 1/3 weared out
--- eg. {type="craft", name="default:apple"}
+-- eg. {name="default:apple", count=1, wear=0, metadata=""}
 --     ^ an apple.
 --
+-- Any time an item must be passed to a function, it can be an
+-- ItemStack (see below), an itemstring or a table in the above format.
+--
 -- Global functions:
 -- minetest.register_entity(name, prototype table)
--- minetest.register_tool(name, tool definition)
+-- minetest.register_abm(abm definition)
 -- minetest.register_node(name, node definition)
--- minetest.register_craftitem(name, craftitem definition)
+-- minetest.register_tool(name, item definition)
+-- minetest.register_craftitem(name, item definition)
+-- minetest.register_alias(name, convert_to)
 -- minetest.register_craft(recipe)
--- minetest.register_abm(abm definition)
--- minetest.alias_node(name, convert_to)
--- minetest.alias_tool(name, convert_to)
--- minetest.alias_craftitem(name, convert_to)
 -- minetest.register_globalstep(func(dtime))
 -- minetest.register_on_placenode(func(pos, newnode, placer))
 -- minetest.register_on_dignode(func(pos, oldnode, digger))
@@ -113,13 +114,16 @@
 -- minetest.chat_send_player(name, text)
 -- minetest.get_player_privs(name) -> set of privs
 -- minetest.get_inventory(location) -> InvRef
+-- minetest.get_current_modname() -> string
 -- minetest.get_modpath(modname) -> eg. "/home/user/.minetest/usermods/modname"
 -- ^ location = eg. {type="player", name="celeron55"}
 --                  {type="node", pos={x=, y=, z=}}
 --
--- stackstring_take_item(stackstring) -> stackstring, item
--- stackstring_put_item(stackstring, item) -> stackstring, success
--- stackstring_put_stackstring(stackstring, stackstring) -> stackstring, success
+-- minetest.debug(line)
+-- ^ Goes to dstream
+-- minetest.log(line)
+-- minetest.log(loglevel, line)
+-- ^ loglevel one of "error", "action", "info", "verbose"
 --
 -- minetest.digprop_constanttime(time)
 -- minetest.digprop_stonelike(toughness)
@@ -133,10 +137,14 @@
 -- minetest.env - environment reference
 --
 -- Global tables:
+-- minetest.registered_items
+-- ^ List of registered items, indexed by name
 -- minetest.registered_nodes
 -- ^ List of registered node definitions, indexed by name
 -- minetest.registered_craftitems
 -- ^ List of registered craft item definitions, indexed by name
+-- minetest.registered_tools
+-- ^ List of registered tool definitions, indexed by name
 -- minetest.registered_entities
 -- ^ List of registered entity prototypes, indexed by name
 -- minetest.object_refs
@@ -171,8 +179,6 @@
 -- Generic node metadata specific:
 -- - set_infotext(infotext)
 -- - get_inventory() -> InvRef
--- - inventory_set_list(name, {item1, item2, ...})
--- - inventory_get_list(name)
 -- - set_inventory_draw_spec(string)
 -- - set_allow_text_input(bool)
 -- - set_allow_removal(bool)
@@ -194,12 +200,13 @@
 --   ^ puncher = an another ObjectRef,
 --   ^ time_from_last_punch = time since last punch action of the puncher
 -- - right_click(clicker); clicker = an another ObjectRef
--- - get_wield_digging_properties() -> digging property table
--- - damage_wielded_item(num) (item damage/wear range is 0-65535)
--- - add_to_inventory(itemstring): add an item to object inventory (actually only works for the player as of now)
--- - add_to_inventory_later(itemstring): like above, but after callback returns (only allowed for craftitem callbacks)
 -- - get_hp(): returns number of hitpoints (2 * number of hearts)
 -- - set_hp(hp): set number of hitpoints (2 * number of hearts)
+-- - get_inventory() -> InvRef
+-- - get_wield_list(): returns the name of the inventory list the wielded item is in
+-- - get_wield_index(): returns the index of the wielded item
+-- - get_wielded_item() -> ItemStack
+-- - set_wielded_item(item): replaces the wielded item, returns true if successful
 -- LuaEntitySAO-only: (no-op for other objects)
 -- - setvelocity({x=num, y=num, z=num})
 -- - getvelocity() -> {x=num, y=num, z=num}
@@ -216,9 +223,6 @@
 -- - get_luaentity()
 -- Player-only: (no-op for other objects)
 -- - get_player_name(): will return nil if is not a player
--- - get_inventory() -> InvRef
--- - inventory_set_list(name, {item1, item2, ...})
--- - inventory_get_list(name) -> {item1, item2, ...}
 -- - get_look_dir(): get camera direction as a unit vector
 -- - get_look_pitch(): pitch in radians
 -- - get_look_yaw(): yaw in radians (wraps around pretty randomly as of now)
@@ -230,14 +234,41 @@
 -- - set_stack(listname, i, stack): copy stack to index i in list
 -- - get_list(listname): return full list
 -- - set_list(listname, list): set full list (size will not change)
--- - autoinsert_stack(listname, stack): insert stack somewhere in list
--- - autoinsert_stackstring(listname, stackstring)
+-- - add_item(listname, stack): add item somewhere in list, returns leftover ItemStack
+-- - room_for_item(listname, stack): returns true if the stack of items
+--     can be fully added to the list
+-- - contains_item(listname, stack): returns true if the stack of items
+--     can be fully taken from the list
+--   remove_item(listname, stack): take as many items as specified from the list,
+--     returns the items that were actually removed (as an ItemStack)
 --
 -- ItemStack methods:
--- - peek_item(): return item from stack without removing it
--- - take_item(): remove item from stack and return it
--- - put_item(item): put item in stack; return false if not possible
--- - put_stackstring(stackstring): return false if not possible
+-- - is_empty(): return true if stack is empty
+-- - get_name(): returns item name (e.g. "default:stone")
+-- - get_count(): returns number of items on the stack
+-- - get_wear(): returns tool wear (0-65535), 0 for non-tools
+-- - get_metadata(): returns metadata (a string attached to an item stack)
+-- - clear(): removes all items from the stack, making it empty
+-- - replace(item): replace the contents of this stack (item can also
+--     be an itemstring or table)
+-- - to_string(): returns the stack in itemstring form
+-- - to_table(): returns the stack in Lua table form
+-- - get_stack_max(): returns the maximum size of the stack (depends on the item)
+-- - get_free_space(): returns get_stack_max() - get_count()
+-- - is_known(): returns true if the item name refers to a defined item type
+-- - get_definition(): returns the item definition table
+-- - get_tool_digging_properties(): returns the digging properties of the item,
+--   ^ or those of the hand if none are defined for this item type
+-- - add_wear(amount): increases wear by amount if the item is a tool
+-- - add_item(item): put some item or stack onto this stack,
+--   ^ returns leftover ItemStack
+-- - item_fits(item): returns true if item or stack can be fully added to this one
+-- - take_item(n): take (and remove) up to n items from this stack
+--   ^ returns taken ItemStack
+--   ^ if n is omitted, n=1 is used
+-- - peek_item(n): copy (don't remove) up to n items from this stack
+--   ^ returns copied ItemStack
+--   ^ if n is omitted, n=1 is used
 --
 -- Registered entities:
 -- - Functions receive a "luaentity" as self:
@@ -271,29 +302,38 @@
 --     myvariable = whatever,
 -- }
 --
--- Tool definition:
+-- Item definition:
 -- {
---     image = "default_tool_steelaxe.png",
---     full_punch_interval = 1.0,
---     basetime = 1.0,
---     dt_weight = 0.5,
---     dt_crackiness = -0.2,
---     dt_crumbliness = 1,
---     dt_cuttability = -0.5,
---     basedurability = 330,
---     dd_weight = 0,
---     dd_crackiness = 0,
---     dd_crumbliness = 0,
---     dd_cuttability = 0,
+--     description = "Steel Axe",
+--     inventory_image = "default_tool_steelaxe.png",
+--     wield_image = "",
+--     wield_scale = {x=1,y=1,z=1},
+--     stack_max = 99,
+--     liquids_pointable = false,
+--     tool_digging_properties = {
+--         full_punch_interval = 1.0,
+--         basetime = 1.0,
+--         dt_weight = 0.5,
+--         dt_crackiness = -0.2,
+--         dt_crumbliness = 1,
+--         dt_cuttability = -0.5,
+--         basedurability = 330,
+--         dd_weight = 0,
+--         dd_crackiness = 0,
+--         dd_crumbliness = 0,
+--         dd_cuttability = 0,
+--     }
+--     on_drop = func(item, dropper, pos),
+--     on_place = func(item, placer, pointed_thing),
+--     on_use = func(item, user, pointed_thing),
 -- }
 --
 -- Node definition options:
 -- {
---     name = "modname:somenode",
+--     <all fields from item definitions>,
 --     drawtype = "normal",
 --     visual_scale = 1.0,
 --     tile_images = {"default_unknown_block.png"},
---     inventory_image = "default_unknown_block.png",
 --     special_materials = {
 --         {image="", backface_culling=true},
 --         {image="", backface_culling=true},
@@ -309,7 +349,6 @@
 --     climbable = false,
 --     buildable_to = false,
 --     wall_mounted = false,
---     often_contains_mineral = false,
 --     dug_item = "",
 --     extra_dug_item = "",
 --     extra_dug_item_rarity = 2,
@@ -329,34 +368,67 @@
 --         cuttability = 0,
 --         flammability = 0,
 --     },
---     cookresult_itemstring = "", -- Cannot be cooked
---     furnace_cooktime = 3.0,
---     furnace_burntime = -1, -- Cannot be used as fuel
+--     on_drop = func(item, dropper),
+--     on_place = func(item, placer, pointed_thing),
+--     on_use = func(item, user, pointed_thing),
 -- }
 --
 -- Craftitem definition options:
--- minetest.register_craftitem("modname_name", {
---     image = "default_image.png",
+-- {
+--     description = <tooltip text>,
+--     inventory_image = "default_unknown_block.png",
+--     wield_image = "",
 --     stack_max = <maximum number of items in stack>,
---     cookresult_itemstring = itemstring (result of cooking),
---     furnace_cooktime = <cooking time>,
---     furnace_burntime = <time to burn as fuel in furnace>,
---     usable = <uh... some boolean value>,
---     dropcount = <amount of items to drop using drop action>
 --     liquids_pointable = <whether can point liquids>,
---     on_drop = func(item, dropper, pos),
---     on_place_on_ground = func(item, placer, pos),
---     on_use = func(item, player, pointed_thing),
--- })
+--     on_drop = func(item, dropper),
+--     on_place = func(item, placer, pointed_thing),
+--     on_use = func(item, user, pointed_thing),
+-- }
 -- 
 -- Recipe:
 -- {
---     output = 'tool "default:pick_stone"',
+--     output = 'default:pick_stone',
 --     recipe = {
---         {'node "default:cobble"', 'node "default:cobble"', 'node "default:cobble"'},
---         {'', 'craft "default:stick"', ''},
---         {'', 'craft "default:stick"', ''},
---     }
+--         {'default:cobble', 'default:cobble', 'default:cobble'},
+--         {'', 'default:stick', ''},
+--         {'', 'default:stick', ''},
+--     },
+--     replacements = <optional list of item pairs,
+--                     replace one input item with another item on crafting>
+-- }
+--
+-- Recipe (shapeless):
+-- {
+--     type = "shapeless",
+--     output = 'mushrooms:mushroom_stew',
+--     recipe = {
+--         "mushrooms:bowl",
+--         "mushrooms:mushroom_brown",
+--         "mushrooms:mushroom_red",
+--     },
+--     replacements = <optional list of item pairs,
+--                     replace one input item with another item on crafting>
+-- }
+--
+-- Recipe (tool repair):
+-- {
+--     type = "toolrepair",
+--     additional_wear = -0.02,
+-- }
+--
+-- Recipe (cooking):
+-- {
+--     type = "cooking",
+--     output = "default:glass",
+--     recipe = "default:sand",
+--     cooktime = 3,
+-- }
+--
+-- Recipe (furnace fuel):
+-- {
+--     type = "fuel",
+--     recipe = "default:leaves",
+--     burntime = 1,
 -- }
 --
 -- ABM (ActiveBlockModifier) definition:
@@ -382,189 +454,213 @@ default = {}
 -- Tool definition
 --
 
--- The hand
-minetest.register_tool(":", {
-	image = "",
-	basetime = 0.5,
-	dt_weight = 1,
-	dt_crackiness = 0,
-	dt_crumbliness = -1,
-	dt_cuttability = 0,
-	basedurability = 50,
-	dd_weight = 0,
-	dd_crackiness = 0,
-	dd_crumbliness = 0,
-	dd_cuttability = 0,
-})
-
 minetest.register_tool("default:pick_wood", {
-	image = "default_tool_woodpick.png",
-	basetime = 2.0,
-	dt_weight = 0,
-	dt_crackiness = -0.5,
-	dt_crumbliness = 2,
-	dt_cuttability = 0,
-	basedurability = 30,
-	dd_weight = 0,
-	dd_crackiness = 0,
-	dd_crumbliness = 0,
-	dd_cuttability = 0,
+	description = "Wooden Pickaxe",
+	inventory_image = "default_tool_woodpick.png",
+	tool_digging_properties = {
+		basetime = 2.0,
+		dt_weight = 0,
+		dt_crackiness = -0.5,
+		dt_crumbliness = 2,
+		dt_cuttability = 0,
+		basedurability = 30,
+		dd_weight = 0,
+		dd_crackiness = 0,
+		dd_crumbliness = 0,
+		dd_cuttability = 0,
+	},
 })
 minetest.register_tool("default:pick_stone", {
-	image = "default_tool_stonepick.png",
-	basetime = 1.5,
-	dt_weight = 0,
-	dt_crackiness = -0.5,
-	dt_crumbliness = 2,
-	dt_cuttability = 0,
-	basedurability = 100,
-	dd_weight = 0,
-	dd_crackiness = 0,
-	dd_crumbliness = 0,
-	dd_cuttability = 0,
+	description = "Stone Pickaxe",
+	inventory_image = "default_tool_stonepick.png",
+	tool_digging_properties = {
+		basetime = 1.5,
+		dt_weight = 0,
+		dt_crackiness = -0.5,
+		dt_crumbliness = 2,
+		dt_cuttability = 0,
+		basedurability = 100,
+		dd_weight = 0,
+		dd_crackiness = 0,
+		dd_crumbliness = 0,
+		dd_cuttability = 0,
+	},
 })
 minetest.register_tool("default:pick_steel", {
-	image = "default_tool_steelpick.png",
-	basetime = 1.0,
-	dt_weight = 0,
-	dt_crackiness = -0.5,
-	dt_crumbliness = 2,
-	dt_cuttability = 0,
-	basedurability = 333,
-	dd_weight = 0,
-	dd_crackiness = 0,
-	dd_crumbliness = 0,
-	dd_cuttability = 0,
+	description = "Steel Pickaxe",
+	inventory_image = "default_tool_steelpick.png",
+	tool_digging_properties = {
+		basetime = 1.0,
+		dt_weight = 0,
+		dt_crackiness = -0.5,
+		dt_crumbliness = 2,
+		dt_cuttability = 0,
+		basedurability = 333,
+		dd_weight = 0,
+		dd_crackiness = 0,
+		dd_crumbliness = 0,
+		dd_cuttability = 0,
+	},
 })
 minetest.register_tool("default:pick_mese", {
-	image = "default_tool_mesepick.png",
-	basetime = 0,
-	dt_weight = 0,
-	dt_crackiness = 0,
-	dt_crumbliness = 0,
-	dt_cuttability = 0,
-	basedurability = 1337,
-	dd_weight = 0,
-	dd_crackiness = 0,
-	dd_crumbliness = 0,
-	dd_cuttability = 0,
+	description = "Mese Pickaxe",
+	inventory_image = "default_tool_mesepick.png",
+	tool_digging_properties = {
+		basetime = 0,
+		dt_weight = 0,
+		dt_crackiness = 0,
+		dt_crumbliness = 0,
+		dt_cuttability = 0,
+		basedurability = 1337,
+		dd_weight = 0,
+		dd_crackiness = 0,
+		dd_crumbliness = 0,
+		dd_cuttability = 0,
+	},
 })
 minetest.register_tool("default:shovel_wood", {
-	image = "default_tool_woodshovel.png",
-	basetime = 2.0,
-	dt_weight = 0.5,
-	dt_crackiness = 2,
-	dt_crumbliness = -1.5,
-	dt_cuttability = 0.3,
-	basedurability = 30,
-	dd_weight = 0,
-	dd_crackiness = 0,
-	dd_crumbliness = 0,
-	dd_cuttability = 0,
+	description = "Wooden Shovel",
+	inventory_image = "default_tool_woodshovel.png",
+	tool_digging_properties = {
+		basetime = 2.0,
+		dt_weight = 0.5,
+		dt_crackiness = 2,
+		dt_crumbliness = -1.5,
+		dt_cuttability = 0.3,
+		basedurability = 30,
+		dd_weight = 0,
+		dd_crackiness = 0,
+		dd_crumbliness = 0,
+		dd_cuttability = 0,
+	},
 })
 minetest.register_tool("default:shovel_stone", {
-	image = "default_tool_stoneshovel.png",
-	basetime = 1.5,
-	dt_weight = 0.5,
-	dt_crackiness = 2,
-	dt_crumbliness = -1.5,
-	dt_cuttability = 0.1,
-	basedurability = 100,
-	dd_weight = 0,
-	dd_crackiness = 0,
-	dd_crumbliness = 0,
-	dd_cuttability = 0,
+	description = "Stone Shovel",
+	inventory_image = "default_tool_stoneshovel.png",
+	tool_digging_properties = {
+		basetime = 1.5,
+		dt_weight = 0.5,
+		dt_crackiness = 2,
+		dt_crumbliness = -1.5,
+		dt_cuttability = 0.1,
+		basedurability = 100,
+		dd_weight = 0,
+		dd_crackiness = 0,
+		dd_crumbliness = 0,
+		dd_cuttability = 0,
+	},
 })
 minetest.register_tool("default:shovel_steel", {
-	image = "default_tool_steelshovel.png",
-	basetime = 1.0,
-	dt_weight = 0.5,
-	dt_crackiness = 2,
-	dt_crumbliness = -1.5,
-	dt_cuttability = 0.0,
-	basedurability = 330,
-	dd_weight = 0,
-	dd_crackiness = 0,
-	dd_crumbliness = 0,
-	dd_cuttability = 0,
+	description = "Steel Shovel",
+	inventory_image = "default_tool_steelshovel.png",
+	tool_digging_properties = {
+		basetime = 1.0,
+		dt_weight = 0.5,
+		dt_crackiness = 2,
+		dt_crumbliness = -1.5,
+		dt_cuttability = 0.0,
+		basedurability = 330,
+		dd_weight = 0,
+		dd_crackiness = 0,
+		dd_crumbliness = 0,
+		dd_cuttability = 0,
+	},
 })
 minetest.register_tool("default:axe_wood", {
-	image = "default_tool_woodaxe.png",
-	basetime = 2.0,
-	dt_weight = 0.5,
-	dt_crackiness = -0.2,
-	dt_crumbliness = 1,
-	dt_cuttability = -0.5,
-	basedurability = 30,
-	dd_weight = 0,
-	dd_crackiness = 0,
-	dd_crumbliness = 0,
-	dd_cuttability = 0,
+	description = "Wooden Axe",
+	inventory_image = "default_tool_woodaxe.png",
+	tool_digging_properties = {
+		basetime = 2.0,
+		dt_weight = 0.5,
+		dt_crackiness = -0.2,
+		dt_crumbliness = 1,
+		dt_cuttability = -0.5,
+		basedurability = 30,
+		dd_weight = 0,
+		dd_crackiness = 0,
+		dd_crumbliness = 0,
+		dd_cuttability = 0,
+	},
 })
 minetest.register_tool("default:axe_stone", {
-	image = "default_tool_stoneaxe.png",
-	basetime = 1.5,
-	dt_weight = 0.5,
-	dt_crackiness = -0.2,
-	dt_crumbliness = 1,
-	dt_cuttability = -0.5,
-	basedurability = 100,
-	dd_weight = 0,
-	dd_crackiness = 0,
-	dd_crumbliness = 0,
-	dd_cuttability = 0,
+	description = "Stone Axe",
+	inventory_image = "default_tool_stoneaxe.png",
+	tool_digging_properties = {
+		basetime = 1.5,
+		dt_weight = 0.5,
+		dt_crackiness = -0.2,
+		dt_crumbliness = 1,
+		dt_cuttability = -0.5,
+		basedurability = 100,
+		dd_weight = 0,
+		dd_crackiness = 0,
+		dd_crumbliness = 0,
+		dd_cuttability = 0,
+	},
 })
 minetest.register_tool("default:axe_steel", {
-	image = "default_tool_steelaxe.png",
-	basetime = 1.0,
-	dt_weight = 0.5,
-	dt_crackiness = -0.2,
-	dt_crumbliness = 1,
-	dt_cuttability = -0.5,
-	basedurability = 330,
-	dd_weight = 0,
-	dd_crackiness = 0,
-	dd_crumbliness = 0,
-	dd_cuttability = 0,
+	description = "Steel Axe",
+	inventory_image = "default_tool_steelaxe.png",
+	tool_digging_properties = {
+		basetime = 1.0,
+		dt_weight = 0.5,
+		dt_crackiness = -0.2,
+		dt_crumbliness = 1,
+		dt_cuttability = -0.5,
+		basedurability = 330,
+		dd_weight = 0,
+		dd_crackiness = 0,
+		dd_crumbliness = 0,
+		dd_cuttability = 0,
+	},
 })
 minetest.register_tool("default:sword_wood", {
-	image = "default_tool_woodsword.png",
-	basetime = 3.0,
-	dt_weight = 3,
-	dt_crackiness = 0,
-	dt_crumbliness = 1,
-	dt_cuttability = -1,
-	basedurability = 30,
-	dd_weight = 0,
-	dd_crackiness = 0,
-	dd_crumbliness = 0,
-	dd_cuttability = 0,
+	description = "Wooden Sword",
+	inventory_image = "default_tool_woodsword.png",
+	tool_digging_properties = {
+		basetime = 3.0,
+		dt_weight = 3,
+		dt_crackiness = 0,
+		dt_crumbliness = 1,
+		dt_cuttability = -1,
+		basedurability = 30,
+		dd_weight = 0,
+		dd_crackiness = 0,
+		dd_crumbliness = 0,
+		dd_cuttability = 0,
+	}
 })
 minetest.register_tool("default:sword_stone", {
-	image = "default_tool_stonesword.png",
-	basetime = 2.5,
-	dt_weight = 3,
-	dt_crackiness = 0,
-	dt_crumbliness = 1,
-	dt_cuttability = -1,
-	basedurability = 100,
-	dd_weight = 0,
-	dd_crackiness = 0,
-	dd_crumbliness = 0,
-	dd_cuttability = 0,
+	description = "Stone Sword",
+	inventory_image = "default_tool_stonesword.png",
+	tool_digging_properties = {
+		basetime = 2.5,
+		dt_weight = 3,
+		dt_crackiness = 0,
+		dt_crumbliness = 1,
+		dt_cuttability = -1,
+		basedurability = 100,
+		dd_weight = 0,
+		dd_crackiness = 0,
+		dd_crumbliness = 0,
+		dd_cuttability = 0,
+	}
 })
 minetest.register_tool("default:sword_steel", {
-	image = "default_tool_steelsword.png",
-	basetime = 2.0,
-	dt_weight = 3,
-	dt_crackiness = 0,
-	dt_crumbliness = 1,
-	dt_cuttability = -1,
-	basedurability = 330,
-	dd_weight = 0,
-	dd_crackiness = 0,
-	dd_crumbliness = 0,
-	dd_cuttability = 0,
+	description = "Steel Sword",
+	inventory_image = "default_tool_steelsword.png",
+	tool_digging_properties = {
+		basetime = 2.0,
+		dt_weight = 3,
+		dt_crackiness = 0,
+		dt_crumbliness = 1,
+		dt_cuttability = -1,
+		basedurability = 330,
+		dd_weight = 0,
+		dd_crackiness = 0,
+		dd_crumbliness = 0,
+		dd_cuttability = 0,
+	}
 })
 
 --
@@ -572,409 +668,581 @@ minetest.register_tool("default:sword_steel", {
 --
 
 minetest.register_craft({
-	output = 'node "default:wood" 4',
+	output = 'default:wood 4',
 	recipe = {
-		{'node "default:tree"'},
+		{'default:tree'},
 	}
 })
 
 minetest.register_craft({
-	output = 'craft "default:stick" 4',
+	output = 'default:stick 4',
 	recipe = {
-		{'node "default:wood"'},
+		{'default:wood'},
 	}
 })
 
 minetest.register_craft({
-	output = 'node "default:fence_wood" 2',
+	output = 'default:fence_wood 2',
 	recipe = {
-		{'craft "default:stick"', 'craft "default:stick"', 'craft "default:stick"'},
-		{'craft "default:stick"', 'craft "default:stick"', 'craft "default:stick"'},
+		{'default:stick', 'default:stick', 'default:stick'},
+		{'default:stick', 'default:stick', 'default:stick'},
 	}
 })
 
 minetest.register_craft({
-	output = 'node "default:sign_wall" 1',
+	output = 'default:sign_wall',
 	recipe = {
-		{'node "default:wood"', 'node "default:wood"', 'node "default:wood"'},
-		{'node "default:wood"', 'node "default:wood"', 'node "default:wood"'},
-		{'', 'craft "default:stick"', ''},
+		{'default:wood', 'default:wood', 'default:wood'},
+		{'default:wood', 'default:wood', 'default:wood'},
+		{'', 'default:stick', ''},
 	}
 })
 
 minetest.register_craft({
-	output = 'node "default:torch" 4',
+	output = 'default:torch 4',
 	recipe = {
-		{'craft "default:coal_lump"'},
-		{'craft "default:stick"'},
+		{'default:coal_lump'},
+		{'default:stick'},
 	}
 })
 
 minetest.register_craft({
-	output = 'tool "default:pick_wood"',
+	output = 'default:pick_wood',
 	recipe = {
-		{'node "default:wood"', 'node "default:wood"', 'node "default:wood"'},
-		{'', 'craft "default:stick"', ''},
-		{'', 'craft "default:stick"', ''},
+		{'default:wood', 'default:wood', 'default:wood'},
+		{'', 'default:stick', ''},
+		{'', 'default:stick', ''},
 	}
 })
 
 minetest.register_craft({
-	output = 'tool "default:pick_stone"',
+	output = 'default:pick_stone',
 	recipe = {
-		{'node "default:cobble"', 'node "default:cobble"', 'node "default:cobble"'},
-		{'', 'craft "default:stick"', ''},
-		{'', 'craft "default:stick"', ''},
+		{'default:cobble', 'default:cobble', 'default:cobble'},
+		{'', 'default:stick', ''},
+		{'', 'default:stick', ''},
 	}
 })
 
 minetest.register_craft({
-	output = 'tool "default:pick_steel"',
+	output = 'default:pick_steel',
 	recipe = {
-		{'craft "default:steel_ingot"', 'craft "default:steel_ingot"', 'craft "default:steel_ingot"'},
-		{'', 'craft "default:stick"', ''},
-		{'', 'craft "default:stick"', ''},
+		{'default:steel_ingot', 'default:steel_ingot', 'default:steel_ingot'},
+		{'', 'default:stick', ''},
+		{'', 'default:stick', ''},
 	}
 })
 
 minetest.register_craft({
-	output = 'tool "default:pick_mese"',
+	output = 'default:pick_mese',
 	recipe = {
-		{'node "default:mese"', 'node "default:mese"', 'node "default:mese"'},
-		{'', 'craft "default:stick"', ''},
-		{'', 'craft "default:stick"', ''},
+		{'default:mese', 'default:mese', 'default:mese'},
+		{'', 'default:stick', ''},
+		{'', 'default:stick', ''},
 	}
 })
 
 minetest.register_craft({
-	output = 'tool "default:shovel_wood"',
+	output = 'default:shovel_wood',
 	recipe = {
-		{'node "default:wood"'},
-		{'craft "default:stick"'},
-		{'craft "default:stick"'},
+		{'default:wood'},
+		{'default:stick'},
+		{'default:stick'},
 	}
 })
 
 minetest.register_craft({
-	output = 'tool "default:shovel_stone"',
+	output = 'default:shovel_stone',
 	recipe = {
-		{'node "default:cobble"'},
-		{'craft "default:stick"'},
-		{'craft "default:stick"'},
+		{'default:cobble'},
+		{'default:stick'},
+		{'default:stick'},
 	}
 })
 
 minetest.register_craft({
-	output = 'tool "default:shovel_steel"',
+	output = 'default:shovel_steel',
 	recipe = {
-		{'craft "default:steel_ingot"'},
-		{'craft "default:stick"'},
-		{'craft "default:stick"'},
+		{'default:steel_ingot'},
+		{'default:stick'},
+		{'default:stick'},
 	}
 })
 
 minetest.register_craft({
-	output = 'tool "default:axe_wood"',
+	output = 'default:axe_wood',
 	recipe = {
-		{'node "default:wood"', 'node "default:wood"'},
-		{'node "default:wood"', 'craft "default:stick"'},
-		{'', 'craft "default:stick"'},
+		{'default:wood', 'default:wood'},
+		{'default:wood', 'default:stick'},
+		{'', 'default:stick'},
 	}
 })
 
 minetest.register_craft({
-	output = 'tool "default:axe_stone"',
+	output = 'default:axe_stone',
 	recipe = {
-		{'node "default:cobble"', 'node "default:cobble"'},
-		{'node "default:cobble"', 'craft "default:stick"'},
-		{'', 'craft "default:stick"'},
+		{'default:cobble', 'default:cobble'},
+		{'default:cobble', 'default:stick'},
+		{'', 'default:stick'},
 	}
 })
 
 minetest.register_craft({
-	output = 'tool "default:axe_steel"',
+	output = 'default:axe_steel',
 	recipe = {
-		{'craft "default:steel_ingot"', 'craft "default:steel_ingot"'},
-		{'craft "default:steel_ingot"', 'craft "default:stick"'},
-		{'', 'craft "default:stick"'},
+		{'default:steel_ingot', 'default:steel_ingot'},
+		{'default:steel_ingot', 'default:stick'},
+		{'', 'default:stick'},
 	}
 })
 
 minetest.register_craft({
-	output = 'tool "default:sword_wood"',
+	output = 'default:sword_wood',
 	recipe = {
-		{'node "default:wood"'},
-		{'node "default:wood"'},
-		{'craft "default:stick"'},
+		{'default:wood'},
+		{'default:wood'},
+		{'default:stick'},
 	}
 })
 
 minetest.register_craft({
-	output = 'tool "default:sword_stone"',
+	output = 'default:sword_stone',
 	recipe = {
-		{'node "default:cobble"'},
-		{'node "default:cobble"'},
-		{'craft "default:stick"'},
+		{'default:cobble'},
+		{'default:cobble'},
+		{'default:stick'},
 	}
 })
 
 minetest.register_craft({
-	output = 'tool "default:sword_steel"',
+	output = 'default:sword_steel',
 	recipe = {
-		{'craft "default:steel_ingot"'},
-		{'craft "default:steel_ingot"'},
-		{'craft "default:stick"'},
+		{'default:steel_ingot'},
+		{'default:steel_ingot'},
+		{'default:stick'},
 	}
 })
 
 minetest.register_craft({
-	output = 'node "default:rail" 15',
+	output = 'default:rail 15',
 	recipe = {
-		{'craft "default:steel_ingot"', '', 'craft "default:steel_ingot"'},
-		{'craft "default:steel_ingot"', 'craft "default:stick"', 'craft "default:steel_ingot"'},
-		{'craft "default:steel_ingot"', '', 'craft "default:steel_ingot"'},
+		{'default:steel_ingot', '', 'default:steel_ingot'},
+		{'default:steel_ingot', 'default:stick', 'default:steel_ingot'},
+		{'default:steel_ingot', '', 'default:steel_ingot'},
 	}
 })
 
 minetest.register_craft({
-	output = 'node "default:chest" 1',
+	output = 'default:chest',
 	recipe = {
-		{'node "default:wood"', 'node "default:wood"', 'node "default:wood"'},
-		{'node "default:wood"', '', 'node "default:wood"'},
-		{'node "default:wood"', 'node "default:wood"', 'node "default:wood"'},
+		{'default:wood', 'default:wood', 'default:wood'},
+		{'default:wood', '', 'default:wood'},
+		{'default:wood', 'default:wood', 'default:wood'},
 	}
 })
 
 minetest.register_craft({
-	output = 'node "default:chest_locked" 1',
+	output = 'default:chest_locked',
 	recipe = {
-		{'node "default:wood"', 'node "default:wood"', 'node "default:wood"'},
-		{'node "default:wood"', 'craft "default:steel_ingot"', 'node "default:wood"'},
-		{'node "default:wood"', 'node "default:wood"', 'node "default:wood"'},
+		{'default:wood', 'default:wood', 'default:wood'},
+		{'default:wood', 'default:steel_ingot', 'default:wood'},
+		{'default:wood', 'default:wood', 'default:wood'},
 	}
 })
 
 minetest.register_craft({
-	output = 'node "default:furnace" 1',
+	output = 'default:furnace',
 	recipe = {
-		{'node "default:cobble"', 'node "default:cobble"', 'node "default:cobble"'},
-		{'node "default:cobble"', '', 'node "default:cobble"'},
-		{'node "default:cobble"', 'node "default:cobble"', 'node "default:cobble"'},
+		{'default:cobble', 'default:cobble', 'default:cobble'},
+		{'default:cobble', '', 'default:cobble'},
+		{'default:cobble', 'default:cobble', 'default:cobble'},
 	}
 })
 
 minetest.register_craft({
-	output = 'node "default:steelblock" 1',
+	output = 'default:steelblock',
 	recipe = {
-		{'craft "default:steel_ingot"', 'craft "default:steel_ingot"', 'craft "default:steel_ingot"'},
-		{'craft "default:steel_ingot"', 'craft "default:steel_ingot"', 'craft "default:steel_ingot"'},
-		{'craft "default:steel_ingot"', 'craft "default:steel_ingot"', 'craft "default:steel_ingot"'},
+		{'default:steel_ingot', 'default:steel_ingot', 'default:steel_ingot'},
+		{'default:steel_ingot', 'default:steel_ingot', 'default:steel_ingot'},
+		{'default:steel_ingot', 'default:steel_ingot', 'default:steel_ingot'},
 	}
 })
 
 minetest.register_craft({
-	output = 'node "default:sandstone" 1',
+	output = 'default:sandstone',
 	recipe = {
-		{'node "default:sand"', 'node "default:sand"'},
-		{'node "default:sand"', 'node "default:sand"'},
+		{'default:sand', 'default:sand'},
+		{'default:sand', 'default:sand'},
 	}
 })
 
 minetest.register_craft({
-	output = 'node "default:clay" 1',
+	output = 'default:clay',
 	recipe = {
-		{'craft "default:clay_lump"', 'craft "default:clay_lump"'},
-		{'craft "default:clay_lump"', 'craft "default:clay_lump"'},
+		{'default:clay_lump', 'default:clay_lump'},
+		{'default:clay_lump', 'default:clay_lump'},
 	}
 })
 
 minetest.register_craft({
-	output = 'node "default:brick" 1',
+	output = 'default:brick',
 	recipe = {
-		{'craft "default:clay_brick"', 'craft "default:clay_brick"'},
-		{'craft "default:clay_brick"', 'craft "default:clay_brick"'},
+		{'default:clay_brick', 'default:clay_brick'},
+		{'default:clay_brick', 'default:clay_brick'},
 	}
 })
 
 minetest.register_craft({
-	output = 'craft "default:paper" 1',
+	output = 'default:paper',
 	recipe = {
-		{'node "default:papyrus"', 'node "default:papyrus"', 'node "default:papyrus"'},
+		{'default:papyrus', 'default:papyrus', 'default:papyrus'},
 	}
 })
 
 minetest.register_craft({
-	output = 'craft "default:book" 1',
+	output = 'default:book',
 	recipe = {
-		{'craft "default:paper"'},
-		{'craft "default:paper"'},
-		{'craft "default:paper"'},
+		{'default:paper'},
+		{'default:paper'},
+		{'default:paper'},
 	}
 })
 
 minetest.register_craft({
-	output = 'node "default:bookshelf" 1',
+	output = 'default:bookshelf',
 	recipe = {
-		{'node "default:wood"', 'node "default:wood"', 'node "default:wood"'},
-		{'craft "default:book"', 'craft "default:book"', 'craft "default:book"'},
-		{'node "default:wood"', 'node "default:wood"', 'node "default:wood"'},
+		{'default:wood', 'default:wood', 'default:wood'},
+		{'default:book', 'default:book', 'default:book'},
+		{'default:wood', 'default:wood', 'default:wood'},
 	}
 })
 
 minetest.register_craft({
-	output = 'node "default:ladder" 1',
+	output = 'default:ladder',
 	recipe = {
-		{'craft "default:stick"', '', 'craft "default:stick"'},
-		{'craft "default:stick"', 'craft "default:stick"', 'craft "default:stick"'},
-		{'craft "default:stick"', '', 'craft "default:stick"'},
+		{'default:stick', '', 'default:stick'},
+		{'default:stick', 'default:stick', 'default:stick'},
+		{'default:stick', '', 'default:stick'},
 	}
 })
 
 --
+-- Crafting (tool repair)
+--
+minetest.register_craft({
+	type = "toolrepair",
+	additional_wear = -0.02,
+})
+
+--
+-- Cooking recipes
+--
+
+minetest.register_craft({
+	type = "cooking",
+	output = "default:glass",
+	recipe = "default:sand",
+})
+
+minetest.register_craft({
+	type = "cooking",
+	output = "default:coal_lump",
+	recipe = "default:tree",
+})
+
+minetest.register_craft({
+	type = "cooking",
+	output = "default:coal_lump",
+	recipe = "default:jungletree",
+})
+
+minetest.register_craft({
+	type = "cooking",
+	output = "default:stone",
+	recipe = "default:cobble",
+})
+
+minetest.register_craft({
+	type = "cooking",
+	output = "default:steel_ingot",
+	recipe = "default:iron_lump",
+})
+
+minetest.register_craft({
+	type = "cooking",
+	output = "default:clay_brick",
+	recipe = "default:clay_lump",
+})
+
+--
+-- Fuels
+--
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:tree",
+	burntime = 30,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:jungletree",
+	burntime = 30,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:junglegrass",
+	burntime = 2,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:leaves",
+	burntime = 1,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:cactus",
+	burntime = 15,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:papyrus",
+	burntime = 1,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:bookshelf",
+	burntime = 30,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:fence_wood",
+	burntime = 15,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:ladder",
+	burntime = 5,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:wood",
+	burntime = 7,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:mese",
+	burntime = 30,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:lava_source",
+	burntime = 60,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:torch",
+	burntime = 4,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:sign_wall",
+	burntime = 10,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:chest",
+	burntime = 30,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:chest_locked",
+	burntime = 30,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:nyancat",
+	burntime = 1,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:nyancat_rainbow",
+	burntime = 1,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:sapling",
+	burntime = 10,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:apple",
+	burntime = 3,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "default:coal_lump",
+	burntime = 40,
+})
+
+--
 -- Node definitions
 --
 
 minetest.register_node("default:stone", {
+	description = "Stone",
 	tile_images = {"default_stone.png"},
-	inventory_image = minetest.inventorycube("default_stone.png"),
 	paramtype = "mineral",
 	is_ground_content = true,
-	often_contains_mineral = true, -- Texture atlas hint
 	material = minetest.digprop_stonelike(1.0),
 	dug_item = 'node "default:cobble" 1',
 })
 
 minetest.register_node("default:dirt_with_grass", {
+	description = "Dirt with grass",
 	tile_images = {"default_grass.png", "default_dirt.png", "default_dirt.png^default_grass_side.png"},
-	inventory_image = minetest.inventorycube("default_dirt.png^default_grass_side.png"),
 	is_ground_content = true,
 	material = minetest.digprop_dirtlike(1.0),
 	dug_item = 'node "default:dirt" 1',
 })
 
 minetest.register_node("default:dirt_with_grass_footsteps", {
+	description = "Dirt with grass and footsteps",
 	tile_images = {"default_grass_footsteps.png", "default_dirt.png", "default_dirt.png^default_grass_side.png"},
-	inventory_image = "default_grass_footsteps.png",
 	is_ground_content = true,
 	material = minetest.digprop_dirtlike(1.0),
 	dug_item = 'node "default:dirt" 1',
 })
 
 minetest.register_node("default:dirt", {
+	description = "Dirt",
 	tile_images = {"default_dirt.png"},
-	inventory_image = minetest.inventorycube("default_dirt.png"),
 	is_ground_content = true,
 	material = minetest.digprop_dirtlike(1.0),
 })
 
 minetest.register_node("default:sand", {
+	description = "Sand",
 	tile_images = {"default_sand.png"},
-	inventory_image = minetest.inventorycube("default_sand.png"),
 	is_ground_content = true,
 	material = minetest.digprop_dirtlike(1.0),
-	cookresult_itemstring = 'node "default:glass" 1',
 })
 
 minetest.register_node("default:gravel", {
+	description = "Gravel",
 	tile_images = {"default_gravel.png"},
-	inventory_image = minetest.inventorycube("default_gravel.png"),
 	is_ground_content = true,
 	material = minetest.digprop_gravellike(1.0),
 })
 
 minetest.register_node("default:sandstone", {
+	description = "Sandstone",
 	tile_images = {"default_sandstone.png"},
-	inventory_image = minetest.inventorycube("default_sandstone.png"),
 	is_ground_content = true,
 	material = minetest.digprop_dirtlike(1.0),  -- FIXME should this be stonelike?
 	dug_item = 'node "default:sand" 1',  -- FIXME is this intentional?
 })
 
 minetest.register_node("default:clay", {
+	description = "Clay",
 	tile_images = {"default_clay.png"},
-	inventory_image = minetest.inventorycube("default_clay.png"),
 	is_ground_content = true,
 	material = minetest.digprop_dirtlike(1.0),
 	dug_item = 'craft "default:clay_lump" 4',
 })
 
 minetest.register_node("default:brick", {
+	description = "Brick",
 	tile_images = {"default_brick.png"},
-	inventory_image = minetest.inventorycube("default_brick.png"),
 	is_ground_content = true,
 	material = minetest.digprop_stonelike(1.0),
 	dug_item = 'craft "default:clay_brick" 4',
 })
 
 minetest.register_node("default:tree", {
+	description = "Tree",
 	tile_images = {"default_tree_top.png", "default_tree_top.png", "default_tree.png"},
-	inventory_image = minetest.inventorycube("default_tree_top.png", "default_tree.png", "default_tree.png"),
 	is_ground_content = true,
 	material = minetest.digprop_woodlike(1.0),
-	cookresult_itemstring = 'craft "default:coal_lump" 1',
-	furnace_burntime = 30,
 })
 
 minetest.register_node("default:jungletree", {
+	description = "Jungle Tree",
 	tile_images = {"default_jungletree_top.png", "default_jungletree_top.png", "default_jungletree.png"},
-	inventory_image = minetest.inventorycube("default_jungletree_top.png", "default_jungletree.png", "default_jungletree.png"),
 	is_ground_content = true,
 	material = minetest.digprop_woodlike(1.0),
-	cookresult_itemstring = 'craft "default:coal_lump" 1',
-	furnace_burntime = 30,
 })
 
 minetest.register_node("default:junglegrass", {
+	description = "Jungle Grass",
 	drawtype = "plantlike",
 	visual_scale = 1.3,
 	tile_images = {"default_junglegrass.png"},
 	inventory_image = "default_junglegrass.png",
+	wield_image = "default_junglegrass.png",
 	paramtype = "light",
 	walkable = false,
 	material = minetest.digprop_leaveslike(1.0),
-	furnace_burntime = 2,
 })
 
 minetest.register_node("default:leaves", {
+	description = "Leaves",
 	drawtype = "allfaces_optional",
 	visual_scale = 1.3,
 	tile_images = {"default_leaves.png"},
-	inventory_image = minetest.inventorycube("default_leaves.png"),
 	paramtype = "light",
 	material = minetest.digprop_leaveslike(1.0),
 	extra_dug_item = 'node "default:sapling" 1',
 	extra_dug_item_rarity = 20,
-	furnace_burntime = 1,
 })
 
 minetest.register_node("default:cactus", {
+	description = "Cactus",
 	tile_images = {"default_cactus_top.png", "default_cactus_top.png", "default_cactus_side.png"},
-	inventory_image = minetest.inventorycube("default_cactus_top.png", "default_cactus_side.png", "default_cactus_side.png"),
 	is_ground_content = true,
 	material = minetest.digprop_woodlike(0.75),
-	furnace_burntime = 15,
 })
 
 minetest.register_node("default:papyrus", {
+	description = "Papyrus",
 	drawtype = "plantlike",
 	tile_images = {"default_papyrus.png"},
 	inventory_image = "default_papyrus.png",
+	wield_image = "default_papyrus.png",
 	paramtype = "light",
 	is_ground_content = true,
 	walkable = false,
 	material = minetest.digprop_leaveslike(0.5),
-	furnace_burntime = 1,
 })
 
 minetest.register_node("default:bookshelf", {
+	description = "Bookshelf",
 	tile_images = {"default_wood.png", "default_wood.png", "default_bookshelf.png"},
-	inventory_image = minetest.inventorycube("default_wood.png", "default_bookshelf.png", "default_bookshelf.png"),
 	is_ground_content = true,
 	material = minetest.digprop_woodlike(0.75),
-	furnace_burntime = 30,
 })
 
 minetest.register_node("default:glass", {
+	description = "Glass",
 	drawtype = "glasslike",
 	tile_images = {"default_glass.png"},
 	inventory_image = minetest.inventorycube("default_glass.png"),
@@ -985,23 +1253,26 @@ minetest.register_node("default:glass", {
 })
 
 minetest.register_node("default:fence_wood", {
+	description = "Wooden Fence",
 	drawtype = "fencelike",
 	tile_images = {"default_wood.png"},
 	inventory_image = "default_fence.png",
+	wield_image = "default_fence.png",
 	paramtype = "light",
 	is_ground_content = true,
 	selection_box = {
 		type = "fixed",
 		fixed = {-1/7, -1/2, -1/7, 1/7, 1/2, 1/7},
 	},
-	furnace_burntime = 15,
 	material = minetest.digprop_woodlike(0.75),
 })
 
 minetest.register_node("default:rail", {
+	description = "Rail",
 	drawtype = "raillike",
 	tile_images = {"default_rail.png", "default_rail_curved.png", "default_rail_t_junction.png", "default_rail_crossing.png"},
 	inventory_image = "default_rail.png",
+	wield_image = "default_rail.png",
 	paramtype = "light",
 	is_ground_content = true,
 	walkable = false,
@@ -1013,9 +1284,11 @@ minetest.register_node("default:rail", {
 })
 
 minetest.register_node("default:ladder", {
+	dsecription = "Ladder",
 	drawtype = "signlike",
 	tile_images = {"default_ladder.png"},
 	inventory_image = "default_ladder.png",
+	wield_image = "default_ladder.png",
 	paramtype = "light",
 	is_ground_content = true,
 	wall_mounted = true,
@@ -1027,37 +1300,35 @@ minetest.register_node("default:ladder", {
 		--wall_bottom = = <default>
 		--wall_side = = <default>
 	},
-	furnace_burntime = 5,
 	material = minetest.digprop_woodlike(0.5),
 })
 
 minetest.register_node("default:wood", {
+	description = "Wood",
 	tile_images = {"default_wood.png"},
-	inventory_image = minetest.inventorycube("default_wood.png"),
 	is_ground_content = true,
-	furnace_burntime = 7,
 	material = minetest.digprop_woodlike(0.75),
 })
 
 minetest.register_node("default:mese", {
+	description = "Mese",
 	tile_images = {"default_mese.png"},
-	inventory_image = minetest.inventorycube("default_mese.png"),
 	is_ground_content = true,
-	furnace_burntime = 30,
 	material = minetest.digprop_stonelike(0.5),
 })
 
 minetest.register_node("default:cloud", {
+	description = "Cloud",
 	tile_images = {"default_cloud.png"},
-	inventory_image = minetest.inventorycube("default_cloud.png"),
 	is_ground_content = true,
 })
 
 minetest.register_node("default:water_flowing", {
+	description = "Water (flowing)",
+	inventory_image = minetest.inventorycube("default_water.png"),
 	drawtype = "flowingliquid",
 	tile_images = {"default_water.png"},
 	alpha = WATER_ALPHA,
-	inventory_image = minetest.inventorycube("default_water.png"),
 	paramtype = "light",
 	walkable = false,
 	pointable = false,
@@ -1075,10 +1346,11 @@ minetest.register_node("default:water_flowing", {
 })
 
 minetest.register_node("default:water_source", {
+	description = "Water",
+	inventory_image = minetest.inventorycube("default_water.png"),
 	drawtype = "liquid",
 	tile_images = {"default_water.png"},
 	alpha = WATER_ALPHA,
-	inventory_image = minetest.inventorycube("default_water.png"),
 	paramtype = "light",
 	walkable = false,
 	pointable = false,
@@ -1096,9 +1368,10 @@ minetest.register_node("default:water_source", {
 })
 
 minetest.register_node("default:lava_flowing", {
+	description = "Lava (flowing)",
+	inventory_image = minetest.inventorycube("default_lava.png"),
 	drawtype = "flowingliquid",
 	tile_images = {"default_lava.png"},
-	inventory_image = minetest.inventorycube("default_lava.png"),
 	paramtype = "light",
 	light_source = LIGHT_MAX - 1,
 	walkable = false,
@@ -1118,9 +1391,10 @@ minetest.register_node("default:lava_flowing", {
 })
 
 minetest.register_node("default:lava_source", {
+	description = "Lava",
+	inventory_image = minetest.inventorycube("default_lava.png"),
 	drawtype = "liquid",
 	tile_images = {"default_lava.png"},
-	inventory_image = minetest.inventorycube("default_lava.png"),
 	paramtype = "light",
 	light_source = LIGHT_MAX - 1,
 	walkable = false,
@@ -1137,13 +1411,14 @@ minetest.register_node("default:lava_source", {
 		-- New-style lava source material (mostly unused)
 		{image="default_lava.png", backface_culling=false},
 	},
-	furnace_burntime = 60,
 })
 
 minetest.register_node("default:torch", {
+	description = "Torch",
 	drawtype = "torchlike",
 	tile_images = {"default_torch_on_floor.png", "default_torch_on_ceiling.png", "default_torch.png"},
 	inventory_image = "default_torch_on_floor.png",
+	wield_image = "default_torch_on_floor.png",
 	paramtype = "light",
 	sunlight_propagates = true,
 	walkable = false,
@@ -1156,13 +1431,14 @@ minetest.register_node("default:torch", {
 		wall_side = {-0.5, -0.3, -0.1, -0.5+0.3, 0.3, 0.1},
 	},
 	material = minetest.digprop_constanttime(0.0),
-	furnace_burntime = 4,
 })
 
 minetest.register_node("default:sign_wall", {
+	description = "Sign",
 	drawtype = "signlike",
 	tile_images = {"default_sign_wall.png"},
 	inventory_image = "default_sign_wall.png",
+	wield_image = "default_sign_wall.png",
 	paramtype = "light",
 	sunlight_propagates = true,
 	walkable = false,
@@ -1175,88 +1451,86 @@ minetest.register_node("default:sign_wall", {
 		--wall_side = <default>
 	},
 	material = minetest.digprop_constanttime(0.5),
-	furnace_burntime = 10,
 })
 
 minetest.register_node("default:chest", {
+	description = "Chest",
 	tile_images = {"default_chest_top.png", "default_chest_top.png", "default_chest_side.png",
 		"default_chest_side.png", "default_chest_side.png", "default_chest_front.png"},
-	inventory_image = minetest.inventorycube("default_chest_top.png", "default_chest_front.png", "default_chest_side.png"),
 	paramtype = "facedir_simple",
 	metadata_name = "chest",
 	material = minetest.digprop_woodlike(1.0),
-	furnace_burntime = 30,
 })
 
 minetest.register_node("default:chest_locked", {
+	description = "Locked Chest",
 	tile_images = {"default_chest_top.png", "default_chest_top.png", "default_chest_side.png",
 		"default_chest_side.png", "default_chest_side.png", "default_chest_lock.png"},
-	inventory_image = minetest.inventorycube("default_chest_top.png", "default_chest_lock.png", "default_chest_side.png"),
 	paramtype = "facedir_simple",
 	metadata_name = "locked_chest",
 	material = minetest.digprop_woodlike(1.0),
-	furnace_burntime = 30,
 })
 
 minetest.register_node("default:furnace", {
+	description = "Furnace",
 	tile_images = {"default_furnace_side.png", "default_furnace_side.png", "default_furnace_side.png",
 		"default_furnace_side.png", "default_furnace_side.png", "default_furnace_front.png"},
-	inventory_image = minetest.inventorycube("default_furnace_side.png", "default_furnace_front.png", "default_furnace_side.png"),
 	paramtype = "facedir_simple",
 	metadata_name = "furnace",
 	material = minetest.digprop_stonelike(3.0),
 })
 
 minetest.register_node("default:cobble", {
+	description = "Cobble",
 	tile_images = {"default_cobble.png"},
-	inventory_image = minetest.inventorycube("default_cobble.png"),
 	is_ground_content = true,
-	cookresult_itemstring = 'node "default:stone" 1',
 	material = minetest.digprop_stonelike(0.9),
 })
 
 minetest.register_node("default:mossycobble", {
+	description = "Mossy Cobble",
 	tile_images = {"default_mossycobble.png"},
-	inventory_image = minetest.inventorycube("default_mossycobble.png"),
 	is_ground_content = true,
 	material = minetest.digprop_stonelike(0.8),
 })
 
 minetest.register_node("default:steelblock", {
+	description = "Steel Block",
 	tile_images = {"default_steel_block.png"},
-	inventory_image = minetest.inventorycube("default_steel_block.png"),
 	is_ground_content = true,
 	material = minetest.digprop_stonelike(5.0),
 })
 
 minetest.register_node("default:nyancat", {
+	description = "Nyancat",
 	tile_images = {"default_nc_side.png", "default_nc_side.png", "default_nc_side.png",
 		"default_nc_side.png", "default_nc_back.png", "default_nc_front.png"},
 	inventory_image = "default_nc_front.png",
 	paramtype = "facedir_simple",
 	material = minetest.digprop_stonelike(3.0),
-	furnace_burntime = 1,
 })
 
 minetest.register_node("default:nyancat_rainbow", {
+	description = "Nyancat Rainbow",
 	tile_images = {"default_nc_rb.png"},
 	inventory_image = "default_nc_rb.png",
 	material = minetest.digprop_stonelike(3.0),
-	furnace_burntime = 1,
 })
 
 minetest.register_node("default:sapling", {
+	description = "Sapling",
 	drawtype = "plantlike",
 	visual_scale = 1.0,
 	tile_images = {"default_sapling.png"},
 	inventory_image = "default_sapling.png",
+	wield_image = "default_sapling.png",
 	paramtype = "light",
 	walkable = false,
 	material = minetest.digprop_constanttime(0.0),
-	furnace_burntime = 10,
 })
 
 minetest.register_node("default:apple", {
+	description = "Apple",
 	drawtype = "plantlike",
 	visual_scale = 1.0,
 	tile_images = {"default_apple.png"},
@@ -1264,9 +1538,8 @@ minetest.register_node("default:apple", {
 	paramtype = "light",
 	sunlight_propagates = true,
 	walkable = false,
-	dug_item = 'craft "default:apple" 1',
 	material = minetest.digprop_constanttime(0.0),
-	furnace_burntime = 3,
+	on_use = minetest.item_eat(4),
 })
 
 --
@@ -1274,93 +1547,84 @@ minetest.register_node("default:apple", {
 --
 
 minetest.register_craftitem("default:stick", {
-	image = "default_stick.png",
-	--furnace_burntime = ...,
-	on_place_on_ground = minetest.craftitem_place_item,
+	description = "Stick",
+	inventory_image = "default_stick.png",
 })
 
 minetest.register_craftitem("default:paper", {
-	image = "default_paper.png",
-	on_place_on_ground = minetest.craftitem_place_item,
+	description = "Paper",
+	inventory_image = "default_paper.png",
 })
 
 minetest.register_craftitem("default:book", {
-	image = "default_book.png",
-	on_place_on_ground = minetest.craftitem_place_item,
+	description = "Book",
+	inventory_image = "default_book.png",
 })
 
 minetest.register_craftitem("default:coal_lump", {
-	image = "default_coal_lump.png",
-	furnace_burntime = 40;
-	on_place_on_ground = minetest.craftitem_place_item,
+	description = "Lump of coal",
+	inventory_image = "default_coal_lump.png",
 })
 
 minetest.register_craftitem("default:iron_lump", {
-	image = "default_iron_lump.png",
-	cookresult_itemstring = 'craft "default:steel_ingot" 1',
-	on_place_on_ground = minetest.craftitem_place_item,
+	description = "Lump of iron",
+	inventory_image = "default_iron_lump.png",
 })
 
 minetest.register_craftitem("default:clay_lump", {
-	image = "default_clay_lump.png",
-	cookresult_itemstring = 'craft "default:clay_brick" 1',
-	on_place_on_ground = minetest.craftitem_place_item,
+	description = "Lump of clay",
+	inventory_image = "default_clay_lump.png",
 })
 
 minetest.register_craftitem("default:steel_ingot", {
-	image = "default_steel_ingot.png",
-	on_place_on_ground = minetest.craftitem_place_item,
+	description = "Steel ingot",
+	inventory_image = "default_steel_ingot.png",
 })
 
 minetest.register_craftitem("default:clay_brick", {
-	image = "default_clay_brick.png",
-	on_place_on_ground = minetest.craftitem_place_item,
+	description = "Clay brick",
+	inventory_image = "default_steel_ingot.png",
+	inventory_image = "default_clay_brick.png",
 })
 
 minetest.register_craftitem("default:scorched_stuff", {
-	image = "default_scorched_stuff.png",
-	on_place_on_ground = minetest.craftitem_place_item,
-})
-
-minetest.register_craftitem("default:apple", {
-	image = "default_apple.png",
-	on_place_on_ground = minetest.craftitem_place_item,
-	on_use = minetest.craftitem_eat(4),
+	description = "Scorched stuff",
+	inventory_image = "default_scorched_stuff.png",
 })
 
 --
 -- Creative inventory
 --
 
-minetest.add_to_creative_inventory('tool "default:pick_mese" 0')
-minetest.add_to_creative_inventory('tool "default:pick_steel" 0')
-minetest.add_to_creative_inventory('tool "default:axe_steel" 0')
-minetest.add_to_creative_inventory('tool "default:shovel_steel" 0')
-
-minetest.add_to_creative_inventory('node "default:torch" 0')
-minetest.add_to_creative_inventory('node "default:cobble" 0')
-minetest.add_to_creative_inventory('node "default:dirt" 0')
-minetest.add_to_creative_inventory('node "default:stone" 0')
-minetest.add_to_creative_inventory('node "default:sand" 0')
-minetest.add_to_creative_inventory('node "default:sandstone" 0')
-minetest.add_to_creative_inventory('node "default:clay" 0')
-minetest.add_to_creative_inventory('node "default:brick" 0')
-minetest.add_to_creative_inventory('node "default:tree" 0')
-minetest.add_to_creative_inventory('node "default:wood" 0')
-minetest.add_to_creative_inventory('node "default:leaves" 0')
-minetest.add_to_creative_inventory('node "default:cactus" 0')
-minetest.add_to_creative_inventory('node "default:papyrus" 0')
-minetest.add_to_creative_inventory('node "default:bookshelf" 0')
-minetest.add_to_creative_inventory('node "default:glass" 0')
-minetest.add_to_creative_inventory('node "default:fence" 0')
-minetest.add_to_creative_inventory('node "default:rail" 0')
-minetest.add_to_creative_inventory('node "default:mese" 0')
-minetest.add_to_creative_inventory('node "default:chest" 0')
-minetest.add_to_creative_inventory('node "default:furnace" 0')
-minetest.add_to_creative_inventory('node "default:sign_wall" 0')
-minetest.add_to_creative_inventory('node "default:water_source" 0')
-minetest.add_to_creative_inventory('node "default:lava_source" 0')
-minetest.add_to_creative_inventory('node "default:ladder" 0')
+minetest.add_to_creative_inventory('default:pick_mese')
+minetest.add_to_creative_inventory('default:pick_steel')
+minetest.add_to_creative_inventory('default:axe_steel')
+minetest.add_to_creative_inventory('default:shovel_steel')
+
+minetest.add_to_creative_inventory('default:torch')
+minetest.add_to_creative_inventory('default:cobble')
+minetest.add_to_creative_inventory('default:dirt')
+minetest.add_to_creative_inventory('default:stone')
+minetest.add_to_creative_inventory('default:sand')
+minetest.add_to_creative_inventory('default:sandstone')
+minetest.add_to_creative_inventory('default:clay')
+minetest.add_to_creative_inventory('default:brick')
+minetest.add_to_creative_inventory('default:tree')
+minetest.add_to_creative_inventory('default:wood')
+minetest.add_to_creative_inventory('default:leaves')
+minetest.add_to_creative_inventory('default:cactus')
+minetest.add_to_creative_inventory('default:papyrus')
+minetest.add_to_creative_inventory('default:bookshelf')
+minetest.add_to_creative_inventory('default:glass')
+minetest.add_to_creative_inventory('default:fence')
+minetest.add_to_creative_inventory('default:rail')
+minetest.add_to_creative_inventory('default:mese')
+minetest.add_to_creative_inventory('default:chest')
+minetest.add_to_creative_inventory('default:furnace')
+minetest.add_to_creative_inventory('default:sign_wall')
+minetest.add_to_creative_inventory('default:water_source')
+minetest.add_to_creative_inventory('default:lava_source')
+minetest.add_to_creative_inventory('default:ladder')
 
 --
 -- Some common functions
@@ -1455,64 +1719,66 @@ function on_punchnode(p, node)
 end
 minetest.register_on_punchnode(on_punchnode)
 
+local function handle_give_command(cmd, giver, receiver, stackstring)
+	if not minetest.get_player_privs(giver)["give"] then
+		minetest.chat_send_player(giver, "error: you don't have permission to give")
+		return
+	end
+	minetest.debug("DEBUG: "..cmd..' invoked, stackstring="'..stackstring..'"')
+	minetest.log(cmd..' invoked, stackstring="'..stackstring..'"')
+	local itemstack = ItemStack(stackstring)
+	if itemstack:is_empty() then
+		minetest.chat_send_player(giver, 'error: cannot give an empty item')
+		return
+	elseif not itemstack:is_known() then
+		minetest.chat_send_player(giver, 'error: cannot give an unknown item')
+		return
+	end
+	local receiverref = minetest.env:get_player_by_name(receiver)
+	if receiverref == nil then
+		minetest.chat_send_player(giver, receiver..' is not a known player')
+		return
+	end
+	local leftover = receiverref:get_inventory():add_item("main", itemstack)
+	if leftover:is_empty() then
+		partiality = ""
+	elseif leftover:get_count() == itemstack:get_count() then
+		partiality = "could not be "
+	else
+		partiality = "partially "
+	end
+	if giver == receiver then
+		minetest.chat_send_player(giver, '"'..stackstring
+			..'" '..partiality..'added to inventory.');
+	else
+		minetest.chat_send_player(giver, '"'..stackstring
+			..'" '..partiality..'added to '..receiver..'\'s inventory.');
+		minetest.chat_send_player(receiver, '"'..stackstring
+			..'" '..partiality..'added to inventory.');
+	end
+end
+
 minetest.register_on_chat_message(function(name, message)
 	--print("default on_chat_message: name="..dump(name).." message="..dump(message))
 	local cmd = "/giveme"
 	if message:sub(0, #cmd) == cmd then
-		if not minetest.get_player_privs(name)["give"] then
-			minetest.chat_send_player(name, "you don't have permission to give")
-			return true -- Handled chat message
-		end
 		local stackstring = string.match(message, cmd.." (.*)")
 		if stackstring == nil then
 			minetest.chat_send_player(name, 'usage: '..cmd..' stackstring')
 			return true -- Handled chat message
 		end
-		print(cmd..' invoked, stackstring="'..stackstring..'"')
-		local player = minetest.env:get_player_by_name(name)
-		if player == nil then
-			minetest.chat_send_player(name, name2..' is not a known player')
-			return true -- Handled chat message
-		end
-		local added, error_msg = player:add_to_inventory(stackstring)
-		if added then
-			minetest.chat_send_player(name, '"'..stackstring
-					..'" added to inventory.');
-		else
-			minetest.chat_send_player(name, 'Could not give "'..stackstring
-					..'": '..error_msg);
-		end
-		return true -- Handled chat message
+		handle_give_command(cmd, name, name, stackstring)
+		return true
 	end
 	local cmd = "/give"
 	if message:sub(0, #cmd) == cmd then
-		if not minetest.get_player_privs(name)["give"] then
-			minetest.chat_send_player(name, "you don't have permission to give")
-			return true -- Handled chat message
-		end
-		local name2, stackstring = string.match(message, cmd.." ([%a%d_-]+) (.*)")
-		if name == nil or stackstring == nil then
+		local receiver, stackstring = string.match(message, cmd.." ([%a%d_-]+) (.*)")
+		if receiver == nil or stackstring == nil then
 			minetest.chat_send_player(name, 'usage: '..cmd..' name stackstring')
 			return true -- Handled chat message
 		end
-		print(cmd..' invoked, name2="'..name2
-				..'" stackstring="'..stackstring..'"')
-		local player = minetest.env:get_player_by_name(name2)
-		if player == nil then
-			minetest.chat_send_player(name, name2..' is not a known player')
-			return true -- Handled chat message
-		end
-		local added, error_msg = player:add_to_inventory(stackstring)
-		if added then
-			minetest.chat_send_player(name, '"'..stackstring
-					..'" added to '..name2..'\'s inventory.');
-			minetest.chat_send_player(name2, '"'..stackstring
-					..'" added to inventory.');
-		else
-			minetest.chat_send_player(name, 'Could not give "'..stackstring
-					..'": '..error_msg);
-		end
-		return true -- Handled chat message
+		handle_give_command(cmd, name, receiver, stackstring)
+		return true
 	end
 	local cmd = "/spawnentity"
 	if message:sub(0, #cmd) == cmd then
@@ -1520,6 +1786,10 @@ minetest.register_on_chat_message(function(name, message)
 			minetest.chat_send_player(name, "you don't have permission to spawn (give)")
 			return true -- Handled chat message
 		end
+		if not minetest.get_player_privs(name)["interact"] then
+			minetest.chat_send_player(name, "you don't have permission to interact")
+			return true -- Handled chat message
+		end
 		local entityname = string.match(message, cmd.." (.*)")
 		if entityname == nil then
 			minetest.chat_send_player(name, 'usage: '..cmd..' entityname')
@@ -1538,6 +1808,21 @@ minetest.register_on_chat_message(function(name, message)
 				..'" spawned.');
 		return true -- Handled chat message
 	end
+	local cmd = "/pulverize"
+	if message:sub(0, #cmd) == cmd then
+		local player = minetest.env:get_player_by_name(name)
+		if player == nil then
+			print("Unable to pulverize, player is nil")
+			return true -- Handled chat message
+		end
+		if player:get_wielded_item():is_empty() then
+			minetest.chat_send_player(name, 'Unable to pulverize, no item in hand.')
+		else
+			player:set_wielded_item(nil)
+			minetest.chat_send_player(name, 'An item was pulverized.')
+		end
+		return true
+	end
 end)
 
 --
diff --git a/data/mods/experimental/init.lua b/data/mods/experimental/init.lua
index 2aae9b199..a58d8f08d 100644
--- a/data/mods/experimental/init.lua
+++ b/data/mods/experimental/init.lua
@@ -25,6 +25,7 @@ minetest.register_globalstep(on_step)
 
 -- An example furnace-thing implemented in Lua
 
+--[[
 minetest.register_node("experimental:luafurnace", {
 	tile_images = {"default_lava.png", "default_furnace_side.png",
 		"default_furnace_side.png", "default_furnace_side.png",
@@ -56,15 +57,6 @@ minetest.register_on_placenode(function(pos, newnode, placer)
 	end
 end)
 
-local get_item_definition = function(item)
-	if not item then return nil end
-	if item.type == "node" then
-		return minetest.registered_nodes[item.name]
-	elseif item.type == "craft" then
-		return minetest.registered_craftitems[item.name]
-	end
-end
-
 minetest.register_abm({
 	nodenames = {"experimental:luafurnace"},
 	interval = 1.0,
@@ -176,7 +168,6 @@ minetest.register_abm({
 		inv:set_stack("fuel", 1, stack)
 	end,
 })
---[[
 minetest.register_abm({
 	nodenames = {"experimental:luafurnace"},
 	interval = 1.0,
@@ -231,7 +222,6 @@ minetest.register_abm({
 		meta:set_infotext("Lua Furnace: total cooked: "..total_cooked)
 	end,
 })
---]]
 minetest.register_craft({
 	output = 'node "experimental:luafurnace" 1',
 	recipe = {
@@ -240,6 +230,7 @@ minetest.register_craft({
 		{'node "default:cobble"', 'node "default:cobble"', 'node "default:cobble"'},
 	}
 })
+--]]
 
 --
 -- Random stuff
@@ -261,38 +252,16 @@ minetest.register_tool("experimental:horribletool", {
 })
 --]]
 
---[[minetest.register_craft({
-	output = 'node "somenode" 4',
-	recipe = {
-		{'craft "default_tick" 1'},
-	}
-})
-
-minetest.register_node("experimental:somenode", {
-	tile_images = {"lava.png", "mese.png", "stone.png", "grass.png", "cobble.png", "tree_top.png"},
-	inventory_image = minetest.inventorycube("lava.png", "mese.png", "stone.png"),
-	--inventory_image = "treeprop.png",
-	material = {
-		diggability = "normal",
-		weight = 0,
-		crackiness = 0,
-		crumbliness = 0,
-		cuttability = 0,
-		flammability = 0
-	},
-	metadata_name = "chest",
-})]]
-
 --
 -- TNT (not functional)
 --
 
 minetest.register_craft({
-	output = 'node "experimental:tnt" 4',
+	output = 'experimental:tnt',
 	recipe = {
-		{'node "default:wood" 1'},
-		{'craft "default:coal_lump" 1'},
-		{'node "default:wood" 1'}
+		{'default:wood'},
+		{'default:coal_lump'},
+		{'default:wood'}
 	}
 })
 
@@ -363,7 +332,7 @@ function TNT:on_punch(hitter)
 	self.health = self.health - 1
 	if self.health <= 0 then
 		self.object:remove()
-		hitter:add_to_inventory("node TNT 1")
+		hitter:get_inventory():add_item("main", "experimental:tnt")
 		hitter:set_hp(hitter:get_hp() - 1)
 	end
 end
@@ -380,7 +349,7 @@ end
 minetest.register_entity("experimental:tnt", TNT)
 
 -- Add TNT's old name also
-minetest.alias_node("TNT", "experimental:tnt")
+minetest.register_alias("TNT", "experimental:tnt")
 
 --
 -- A test entity for testing animated and yaw-modulated sprites
@@ -547,6 +516,7 @@ minetest.register_abm({
     end,
 })--]]
 
+print("experimental modname="..dump(minetest.get_current_modname()))
 print("experimental modpath="..dump(minetest.get_modpath("experimental")))
 
 -- END
diff --git a/data/mods/legacy/init.lua b/data/mods/legacy/init.lua
index 3bd68f0bc..127b0e17f 100644
--- a/data/mods/legacy/init.lua
+++ b/data/mods/legacy/init.lua
@@ -5,97 +5,126 @@
 -- Aliases to support loading 0.3 and old 0.4 worlds and inventories
 --
 
-minetest.alias_node("stone", "default:stone")
-minetest.alias_node("dirt_with_grass", "default:dirt_with_grass")
-minetest.alias_node("dirt_with_grass_footsteps", "default:dirt_with_grass_footsteps")
-minetest.alias_node("dirt", "default:dirt")
-minetest.alias_node("sand", "default:sand")
-minetest.alias_node("gravel", "default:gravel")
-minetest.alias_node("sandstone", "default:sandstone")
-minetest.alias_node("clay", "default:clay")
-minetest.alias_node("brick", "default:brick")
-minetest.alias_node("tree", "default:tree")
-minetest.alias_node("jungletree", "default:jungletree")
-minetest.alias_node("junglegrass", "default:junglegrass")
-minetest.alias_node("leaves", "default:leaves")
-minetest.alias_node("cactus", "default:cactus")
-minetest.alias_node("papyrus", "default:papyrus")
-minetest.alias_node("bookshelf", "default:bookshelf")
-minetest.alias_node("glass", "default:glass")
-minetest.alias_node("wooden_fence", "default:fence_wood")
-minetest.alias_node("rail", "default:rail")
-minetest.alias_node("ladder", "default:ladder")
-minetest.alias_node("wood", "default:wood")
-minetest.alias_node("mese", "default:mese")
-minetest.alias_node("cloud", "default:cloud")
-minetest.alias_node("water_flowing", "default:water_flowing")
-minetest.alias_node("water_source", "default:water_source")
-minetest.alias_node("lava_flowing", "default:lava_flowing")
-minetest.alias_node("lava_source", "default:lava_source")
-minetest.alias_node("torch", "default:torch")
-minetest.alias_node("sign_wall", "default:sign_wall")
-minetest.alias_node("furnace", "default:furnace")
-minetest.alias_node("chest", "default:chest")
-minetest.alias_node("locked_chest", "default:chest_locked")
-minetest.alias_node("cobble", "default:cobble")
-minetest.alias_node("mossycobble", "default:mossycobble")
-minetest.alias_node("steelblock", "default:steelblock")
-minetest.alias_node("nyancat", "default:nyancat")
-minetest.alias_node("nyancat_rainbow", "default:nyancat_rainbow")
-minetest.alias_node("sapling", "default:sapling")
-minetest.alias_node("apple", "default:apple")
+minetest.register_alias("stone", "default:stone")
+minetest.register_alias("dirt_with_grass", "default:dirt_with_grass")
+minetest.register_alias("dirt_with_grass_footsteps", "default:dirt_with_grass_footsteps")
+minetest.register_alias("dirt", "default:dirt")
+minetest.register_alias("sand", "default:sand")
+minetest.register_alias("gravel", "default:gravel")
+minetest.register_alias("sandstone", "default:sandstone")
+minetest.register_alias("clay", "default:clay")
+minetest.register_alias("brick", "default:brick")
+minetest.register_alias("tree", "default:tree")
+minetest.register_alias("jungletree", "default:jungletree")
+minetest.register_alias("junglegrass", "default:junglegrass")
+minetest.register_alias("leaves", "default:leaves")
+minetest.register_alias("cactus", "default:cactus")
+minetest.register_alias("papyrus", "default:papyrus")
+minetest.register_alias("bookshelf", "default:bookshelf")
+minetest.register_alias("glass", "default:glass")
+minetest.register_alias("wooden_fence", "default:fence_wood")
+minetest.register_alias("rail", "default:rail")
+minetest.register_alias("ladder", "default:ladder")
+minetest.register_alias("wood", "default:wood")
+minetest.register_alias("mese", "default:mese")
+minetest.register_alias("cloud", "default:cloud")
+minetest.register_alias("water_flowing", "default:water_flowing")
+minetest.register_alias("water_source", "default:water_source")
+minetest.register_alias("lava_flowing", "default:lava_flowing")
+minetest.register_alias("lava_source", "default:lava_source")
+minetest.register_alias("torch", "default:torch")
+minetest.register_alias("sign_wall", "default:sign_wall")
+minetest.register_alias("furnace", "default:furnace")
+minetest.register_alias("chest", "default:chest")
+minetest.register_alias("locked_chest", "default:chest_locked")
+minetest.register_alias("cobble", "default:cobble")
+minetest.register_alias("mossycobble", "default:mossycobble")
+minetest.register_alias("steelblock", "default:steelblock")
+minetest.register_alias("nyancat", "default:nyancat")
+minetest.register_alias("nyancat_rainbow", "default:nyancat_rainbow")
+minetest.register_alias("sapling", "default:sapling")
+minetest.register_alias("apple", "default:apple")
 
-minetest.alias_tool("WPick", "default:pick_wood")
-minetest.alias_tool("STPick", "default:pick_stone")
-minetest.alias_tool("SteelPick", "default:pick_steel")
-minetest.alias_tool("MesePick", "default:pick_mese")
-minetest.alias_tool("WShovel", "default:shovel_wood")
-minetest.alias_tool("STShovel", "default:shovel_stone")
-minetest.alias_tool("SteelShovel", "default:shovel_steel")
-minetest.alias_tool("WAxe", "default:axe_wood")
-minetest.alias_tool("STAxe", "default:axe_stone")
-minetest.alias_tool("SteelAxe", "default:axe_steel")
-minetest.alias_tool("WSword", "default:sword_wood")
-minetest.alias_tool("STSword", "default:sword_stone")
-minetest.alias_tool("SteelSword", "default:sword_steel")
+minetest.register_alias("WPick", "default:pick_wood")
+minetest.register_alias("STPick", "default:pick_stone")
+minetest.register_alias("SteelPick", "default:pick_steel")
+minetest.register_alias("MesePick", "default:pick_mese")
+minetest.register_alias("WShovel", "default:shovel_wood")
+minetest.register_alias("STShovel", "default:shovel_stone")
+minetest.register_alias("SteelShovel", "default:shovel_steel")
+minetest.register_alias("WAxe", "default:axe_wood")
+minetest.register_alias("STAxe", "default:axe_stone")
+minetest.register_alias("SteelAxe", "default:axe_steel")
+minetest.register_alias("WSword", "default:sword_wood")
+minetest.register_alias("STSword", "default:sword_stone")
+minetest.register_alias("SteelSword", "default:sword_steel")
 
-minetest.alias_craftitem("Stick", "default:stick")
-minetest.alias_craftitem("paper", "default:paper")
-minetest.alias_craftitem("book", "default:book")
-minetest.alias_craftitem("lump_of_coal", "default:coal_lump")
-minetest.alias_craftitem("lump_of_iron", "default:iron_lump")
-minetest.alias_craftitem("lump_of_clay", "default:clay_lump")
-minetest.alias_craftitem("steel_ingot", "default:steel_ingot")
-minetest.alias_craftitem("clay_brick", "default:clay_brick")
-minetest.alias_craftitem("scorched_stuff", "default:scorched_stuff")
-minetest.alias_craftitem("apple", "default:apple")
+minetest.register_alias("Stick", "default:stick")
+minetest.register_alias("paper", "default:paper")
+minetest.register_alias("book", "default:book")
+minetest.register_alias("lump_of_coal", "default:coal_lump")
+minetest.register_alias("lump_of_iron", "default:iron_lump")
+minetest.register_alias("lump_of_clay", "default:clay_lump")
+minetest.register_alias("steel_ingot", "default:steel_ingot")
+minetest.register_alias("clay_brick", "default:clay_brick")
+minetest.register_alias("scorched_stuff", "default:scorched_stuff")
 
 --
 -- Old items
 --
 
 minetest.register_craftitem(":rat", {
-	image = "rat.png",
-	cookresult_itemstring = 'craft "cooked_rat" 1',
+	description = "Rat",
+	inventory_image = "rat.png",
 	on_drop = function(item, dropper, pos)
 		minetest.env:add_rat(pos)
-		return true
+		item:take_item()
+		return item
 	end,
+	on_place = function(item, dropped, pointed)
+		pos = minetest.get_pointed_thing_position(pointed, true)
+		if pos ~= nil then
+			minetest.env:add_rat(pos)
+			item:take_item()
+			return item
+		end
+	end
 })
 
 minetest.register_craftitem(":cooked_rat", {
-	image = "cooked_rat.png",
-	cookresult_itemstring = 'craft "scorched_stuff" 1',
-	on_place_on_ground = minetest.craftitem_place_item,
-	on_use = minetest.craftitem_eat(6),
+	description = "Cooked rat",
+	inventory_image = "cooked_rat.png",
+	on_use = minetest.item_eat(6),
 })
 
 minetest.register_craftitem(":firefly", {
-	image = "firefly.png",
+	description = "Firefly",
+	inventory_image = "firefly.png",
 	on_drop = function(item, dropper, pos)
 		minetest.env:add_firefly(pos)
-		return true
+		item:take_item()
+		return item
 	end,
+	on_place = function(item, dropped, pointed)
+		pos = minetest.get_pointed_thing_position(pointed, true)
+		if pos ~= nil then
+			minetest.env:add_firefly(pos)
+			item:take_item()
+			return item
+		end
+	end
+})
+
+minetest.register_craft({
+	type = "cooking",
+	output = "cooked_rat",
+	recipe = "rat",
+})
+
+minetest.register_craft({
+	type = "cooking",
+	output = "scorched_stuff",
+	recipe = "cooked_rat",
 })
 
 -- END