Add wooden buckets. Disable mass-dig.

Change bowl recipe.
Mass digging is not compatible.
Also, keep elephants from drowning.

fungal_tree.lua

@@ -159,23 +159,7 @@ minetest.register_craft({
 	replacements = {
 		{'bucket:bucket_water', 'bucket:bucket_water'},
 		{'bucket:bucket_river_water', 'bucket:bucket_river_water'},
-	},
+		{'fun_caves:bucket_wood_water', 'fun_caves:bucket_wood_water'},
-})
+		{'fun_caves:bucket_wood_river_water', 'fun_caves:bucket_wood_river_water'},
-
-minetest.register_craftitem("fun_caves:wooden_bowl", {
-	description = "Wooden Bowl",
-	drawtype = "plantlike",
-	paramtype = "light",
-	tiles = {"fun_caves_wooden_bowl.png"},
-	inventory_image = "fun_caves_wooden_bowl.png",
-	groups = {bowl = 1, dig_immediate = 3},
-})
-
-minetest.register_craft({
-	output = 'fun_caves:wooden_bowl 20',
-	recipe = {
-		{'', '', ''},
-		{'group:wood', '', 'group:wood'},
-		{'', 'group:wood', ''},
 	},
 })

init.lua

@@ -169,6 +169,7 @@ dofile(fun_caves.path .. "/deco.lua")
 dofile(fun_caves.path .. "/fungal_tree.lua")
 dofile(fun_caves.path .. "/wallhammer.lua")
 dofile(fun_caves.path .. "/mapgen.lua")
+dofile(fun_caves.path .. "/wooden_buckets.lua")
 dofile(fun_caves.path .. "/spec_bomb.lua")
 dofile(fun_caves.path .. "/elixir.lua")  -- must go after all items are registered
 dofile(fun_caves.path .. "/chat.lua")

mobs.lua

@@ -696,6 +696,7 @@ end
 if minetest.registered_entities["dmobs:elephant"] then
 	local m = minetest.registered_entities["dmobs:elephant"]
 	m.type = "monster"
+	m.water_damage = 0
 end
 
 if minetest.registered_entities["mobs_bat:bat"] then

nodes.lua

@@ -428,3 +428,21 @@ for i = 3, 5 do
 		},
 	})
 end
+
+minetest.register_craftitem("fun_caves:wooden_bowl", {
+	description = "Wooden Bowl",
+	drawtype = "plantlike",
+	paramtype = "light",
+	tiles = {"fun_caves_wooden_bowl.png"},
+	inventory_image = "fun_caves_wooden_bowl.png",
+	groups = {bowl = 1, dig_immediate = 3},
+})
+
+minetest.register_craft({
+	output = 'fun_caves:wooden_bowl 20',
+	recipe = {
+		{'group:wood', '', 'group:wood'},
+		{'group:wood', '', 'group:wood'},
+		{'', 'group:wood', ''},
+	},
+})

spec_bomb.lua

@@ -177,153 +177,171 @@ for _, node in pairs(nodes) do
 end
 
 
-local mass_nodes = {'fun_caves:tree', 'default:tree', 'default:jungletree', 'default:acacia_tree', 'default:aspen_tree', 'default:stone', 'default:sandstone', 'default:desert_stone', 'fun_caves:stone_with_algae', 'fun_caves:stone_with_moss', 'fun_caves:stone_with_lichen'}
+-- incompatible with buckets
-local mass_tools_list = {'default:axe_bronze', 'default:axe_diamond', 'default:axe_mese', 'default:pick_bronze', 'default:pick_diamond', 'default:pick_mese'}
+if false then
-local mass_tools = {}
+	local mass_nodes = {'fun_caves:tree', 'default:tree', 'default:jungletree', 'default:acacia_tree', 'default:aspen_tree', 'default:stone', 'default:sandstone', 'default:desert_stone', 'fun_caves:stone_with_algae', 'fun_caves:stone_with_moss', 'fun_caves:stone_with_lichen'}
-for _, tool in pairs(mass_tools_list) do
+	local mass_tools_list = {'default:axe_bronze', 'default:axe_diamond', 'default:axe_mese', 'default:pick_bronze', 'default:pick_diamond', 'default:pick_mese'}
-	mass_tools[tool] = true
+	local mass_tools = {}
-end
+	for _, tool in pairs(mass_tools_list) do
-local mass_minerals_list = {'default:gravel'}
+		mass_tools[tool] = true
-local mass_minerals = {}
-for _, min in pairs(mass_minerals_list) do
-	mass_minerals[min] = true
-end
-for name, _ in pairs(minetest.registered_nodes) do
-	if name:find('stone_with') then
-		mass_minerals[name] = true
 	end
-end
+	local mass_minerals_list = {'default:gravel'}
-local function default_rightclick(pos, node, clicker, itemstack, pointed_thing)
+	local mass_minerals = {}
-	if itemstack:get_definition().type == "node" then
+	for _, min in pairs(mass_minerals_list) do
-		return minetest.item_place_node(itemstack, clicker, pointed_thing)
+		mass_minerals[min] = true
 	end
-	return itemstack
+	for name, _ in pairs(minetest.registered_nodes) do
-end
+		if name:find('stone_with') then
-
+			mass_minerals[name] = true
-for _, node in pairs(mass_nodes) do
-	if not minetest.registered_items[node] then
-		break
-	end
-
-	minetest.override_item(node, {on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
-		local tool = itemstack:get_name()
-		if not mass_tools[tool] then
-			return default_rightclick(pos, node, clicker, itemstack, pointed_thing)
 		end
-		local tool_type, maxr
+	end
-		if tool:find('axe') then
+	local function default_rightclick(pos, node, clicker, itemstack, pointed_thing)
-			if minetest.get_item_group(node.name, "tree") == 0 then
+		if itemstack:get_definition().type == "node" then
+			return minetest.item_place_node(itemstack, clicker, pointed_thing)
+		end
+		return itemstack
+	end
+
+	for _, node in pairs(mass_nodes) do
+		if not minetest.registered_items[node] then
+			break
+		end
+
+		local node_def = minetest.registered_items[node]
+		if node_def.on_rightclick then
+			print(node)
+			node_def.fun_caves_default_rightclick = node.on_rightclick
+			print(dump(node_def))
+		end
+
+		minetest.override_item(node, {on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
+			local tool = itemstack:get_name()
+			if not mass_tools[tool] then
+				print('* return default')
+				if node then
+					local node_def = minetest.registered_items[node.name]
+					print(dump(node_def))
+					if node_def and node_def.fun_caves_default_rightclick then
+						return node_def.fun_caves_default_rightclick(pos, node, clicker, itemstack, pointed_thing)
+					end
+				end
 				return default_rightclick(pos, node, clicker, itemstack, pointed_thing)
 			end
-			tool_type = 'axe'
+			local tool_type, maxr
-			maxr = {x = 2, y = 20, z = 2}
+			if tool:find('axe') then
-		elseif tool:find('pick') then
+				if minetest.get_item_group(node.name, "tree") == 0 then
-			if node.name ~= 'default:sandstone' and minetest.get_item_group(node.name, "stone") == 0 then
+					return default_rightclick(pos, node, clicker, itemstack, pointed_thing)
+				end
+				tool_type = 'axe'
+				maxr = {x = 2, y = 20, z = 2}
+			elseif tool:find('pick') then
+				if node.name ~= 'default:sandstone' and minetest.get_item_group(node.name, "stone") == 0 then
+					return default_rightclick(pos, node, clicker, itemstack, pointed_thing)
+				end
+				tool_type = 'pick'
+				maxr = {x = 2, y = 4, z = 2}
+			else
 				return default_rightclick(pos, node, clicker, itemstack, pointed_thing)
 			end
-			tool_type = 'pick'
-			maxr = {x = 2, y = 4, z = 2}
-		else
-			return default_rightclick(pos, node, clicker, itemstack, pointed_thing)
-		end
 
-		local player_pos = vector.round(clicker:getpos())
+			local player_pos = vector.round(clicker:getpos())
-		local player_name = clicker:get_player_name()
+			local player_name = clicker:get_player_name()
-		local inv = clicker:get_inventory()
+			local inv = clicker:get_inventory()
-		if not (player_pos and player_name and inv) then
+			if not (player_pos and player_name and inv) then
-			return default_rightclick(pos, node, clicker, itemstack, pointed_thing)
+				return default_rightclick(pos, node, clicker, itemstack, pointed_thing)
-		end
-		pos = vector.round(pos)
-		local max_nodes = 60
-		local minp = vector.subtract(pos, 2)
-		local maxp = vector.add(pos, maxr)
-		if pos.y >= player_pos.y then
-			minp.y = player_pos.y
-			if pos.y - player_pos.y < 3 then
-				maxp.y = player_pos.y + 3
 			end
-		end
+			pos = vector.round(pos)
-
+			local max_nodes = 60
-		local air = minetest.get_content_id('air')
+			local minp = vector.subtract(pos, 2)
-		local vm = minetest.get_voxel_manip()
+			local maxp = vector.add(pos, maxr)
-		local emin, emax = vm:read_from_map(minp, maxp)
+			if pos.y >= player_pos.y then
-		local area = VoxelArea:new({MinEdge = emin, MaxEdge = emax})
+				minp.y = player_pos.y
-		local data = vm:get_data()
+				if pos.y - player_pos.y < 3 then
-		local drops = {}
+					maxp.y = player_pos.y + 3
-		local names = {}
-		local diggable = {}
-		local tree_like = {}
-		local leaf_like = {}
-		local stone_like = {}
-		local count = 0
-		local p = {}
-		for y = minp.y, maxp.y do
-			p.y = y
-			for z = minp.z, maxp.z do
-				p.z = z
-				local ivm = area:index(minp.x, y, z)
-				for x = minp.x, maxp.x do
-					p.x = x
-					if not names[data[ivm]] then
-						names[data[ivm]] = minetest.get_name_from_content_id(data[ivm])
-					end
-
-					if not diggable[data[ivm]] then
-						if tool_type == 'axe' then
-							diggable[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'choppy') or 0
-							diggable[data[ivm]] = diggable[data[ivm]] + minetest.get_item_group(names[data[ivm]], 'snappy') or 0
-							diggable[data[ivm]] = diggable[data[ivm]] + minetest.get_item_group(names[data[ivm]], 'fleshy') or 0
-						elseif tool_type == 'pick' then
-							diggable[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'cracky') or 0
-						end
-					end
-
-					if not stone_like[data[ivm]] then
-						stone_like[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'stone') or 0
-						stone_like[data[ivm]] = stone_like[data[ivm]] + (names[data[ivm]] == 'default:sandstone' and 1 or 0)
-					end
-
-					if not tree_like[data[ivm]] then
-						tree_like[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'tree') or 0
-					end
-
-					if not leaf_like[data[ivm]] then
-						leaf_like[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'leafdecay') or 0
-					end
-
-					local dig_it
-					if tool_type == 'axe' then
-						dig_it = tree_like[data[ivm]] > 0 or leaf_like[data[ivm]] > 0
-					elseif tool_type == 'pick' then
-						dig_it = stone_like[data[ivm]] > 0 or mass_minerals[names[data[ivm]]]
-					end
-
-					if count < max_nodes and diggable[data[ivm]] > 0 and dig_it and not minetest.is_protected(p, player_name) then
-						drops[data[ivm]] = (drops[data[ivm]] or 0) + 1
-						data[ivm] = air
-						count = count + 1
-					end
-					ivm = ivm + 1
 				end
 			end
-		end
-		vm:set_data(data)
-		vm:write_to_map()
-		vm:update_map()
 
-		for id, number in pairs(drops) do
+			local air = minetest.get_content_id('air')
-			for i = 1, number do
+			local vm = minetest.get_voxel_manip()
-				local drops = minetest.get_node_drops(names[id], tool)
+			local emin, emax = vm:read_from_map(minp, maxp)
-				minetest.handle_node_drops(pos, drops, clicker)
+			local area = VoxelArea:new({MinEdge = emin, MaxEdge = emax})
+			local data = vm:get_data()
+			local drops = {}
+			local names = {}
+			local diggable = {}
+			local tree_like = {}
+			local leaf_like = {}
+			local stone_like = {}
+			local count = 0
+			local p = {}
+			for y = minp.y, maxp.y do
+				p.y = y
+				for z = minp.z, maxp.z do
+					p.z = z
+					local ivm = area:index(minp.x, y, z)
+					for x = minp.x, maxp.x do
+						p.x = x
+						if not names[data[ivm]] then
+							names[data[ivm]] = minetest.get_name_from_content_id(data[ivm])
+						end
+
+						if not diggable[data[ivm]] then
+							if tool_type == 'axe' then
+								diggable[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'choppy') or 0
+								diggable[data[ivm]] = diggable[data[ivm]] + minetest.get_item_group(names[data[ivm]], 'snappy') or 0
+								diggable[data[ivm]] = diggable[data[ivm]] + minetest.get_item_group(names[data[ivm]], 'fleshy') or 0
+							elseif tool_type == 'pick' then
+								diggable[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'cracky') or 0
+							end
+						end
+
+						if not stone_like[data[ivm]] then
+							stone_like[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'stone') or 0
+							stone_like[data[ivm]] = stone_like[data[ivm]] + (names[data[ivm]] == 'default:sandstone' and 1 or 0)
+						end
+
+						if not tree_like[data[ivm]] then
+							tree_like[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'tree') or 0
+						end
+
+						if not leaf_like[data[ivm]] then
+							leaf_like[data[ivm]] = minetest.get_item_group(names[data[ivm]], 'leafdecay') or 0
+						end
+
+						local dig_it
+						if tool_type == 'axe' then
+							dig_it = tree_like[data[ivm]] > 0 or leaf_like[data[ivm]] > 0
+						elseif tool_type == 'pick' then
+							dig_it = stone_like[data[ivm]] > 0 or mass_minerals[names[data[ivm]]]
+						end
+
+						if count < max_nodes and diggable[data[ivm]] > 0 and dig_it and not minetest.is_protected(p, player_name) then
+							drops[data[ivm]] = (drops[data[ivm]] or 0) + 1
+							data[ivm] = air
+							count = count + 1
+						end
+						ivm = ivm + 1
+					end
+				end
+			end
+			vm:set_data(data)
+			vm:write_to_map()
+			vm:update_map()
+
+			for id, number in pairs(drops) do
+				for i = 1, number do
+					local drops = minetest.get_node_drops(names[id], tool)
+					minetest.handle_node_drops(pos, drops, clicker)
+				end
+
+				local tp = itemstack:get_tool_capabilities()
+				local def = ItemStack({name=names[id]}):get_definition()
+				local dp = minetest.get_dig_params(def.groups, tp)
+				--print(names[id], dp.wear, number)
+				itemstack:add_wear(dp.wear * number)
 			end
 
-			local tp = itemstack:get_tool_capabilities()
+			return itemstack
-			local def = ItemStack({name=names[id]}):get_definition()
+		end, })
-			local dp = minetest.get_dig_params(def.groups, tp)
+	end
-			--print(names[id], dp.wear, number)
-			itemstack:add_wear(dp.wear * number)
-		end
-
-		return itemstack
-	end, })
 end

treegen.lua

@@ -146,7 +146,7 @@ bucket.register_liquid(
 	"fun_caves:bucket_sap",
 	"fun_caves_bucket_sap.png",
 	"Bucket of Sap",
-	{}
+	{sap_bucket = 1}
 )
 
 minetest.register_node("fun_caves:amber", {
@@ -188,7 +188,7 @@ minetest.register_on_craft(function(itemstack, player, old_craft_grid, craft_inv
 	local index
 	for i = 1, player:get_inventory():get_size("craft") do
 		if (old_craft_grid[i]:get_name()):find('^fun_caves:bucket') then
-			bucket = old_craft_grid[i]
+			bucket = old_craft_grid[i]:get_name()
 			index = i
 		end
 	end
@@ -196,7 +196,8 @@ minetest.register_on_craft(function(itemstack, player, old_craft_grid, craft_inv
 		return
 	end
 
-	craft_inv:set_stack("craft", index, 'bucket:bucket_empty')
+	bucket = bucket:gsub('sap', 'empty')
+	craft_inv:set_stack("craft", index, bucket)
 end)
 
 newnode = fun_caves.clone_node("default:tree")
@@ -264,9 +265,12 @@ minetest.register_craft({
 	type = "shapeless",
 	recipe = {
 		'vessels:glass_bottle',
-		'fun_caves:bucket_sap',
+		'group:sap_bucket',
+	},
+	replacements = {
+		{'fun_caves:bucket_sap', 'bucket:bucket_empty'},
+		{'fun_caves:bucket_wood_sap', 'bucket:bucket_wood_empty'},
 	},
-	replacements = {{'fun_caves:bucket_sap', 'bucket:bucket_empty'},},
 })
 
 minetest.register_craft({

wooden_buckets.lua

@@ -0,0 +1,127 @@
+local function register_liquid_wood(source, itemname, inventory_image, name, groups)
+	if itemname ~= nil then
+		minetest.register_craftitem(itemname, {
+			description = name,
+			inventory_image = inventory_image,
+			stack_max = 1,
+			liquids_pointable = true,
+			groups = groups,
+
+			on_place = function(itemstack, user, pointed_thing)
+				-- Must be pointing to node
+				if pointed_thing.type ~= "node" then
+					return
+				end
+
+				local node = minetest.get_node_or_nil(pointed_thing.under)
+				local ndef = node and minetest.registered_nodes[node.name]
+
+				-- Call on_rightclick if the pointed node defines it
+				if ndef and ndef.on_rightclick and
+				   user and not user:get_player_control().sneak then
+					return ndef.on_rightclick(
+						pointed_thing.under,
+						node, user,
+						itemstack)
+				end
+
+				local lpos
+
+				-- Check if pointing to a buildable node
+				if ndef and ndef.buildable_to then
+					-- buildable; replace the node
+					lpos = pointed_thing.under
+				else
+					-- not buildable to; place the liquid above
+					-- check if the node above can be replaced
+					lpos = pointed_thing.above
+					local node = minetest.get_node_or_nil(lpos)
+					local above_ndef = node and minetest.registered_nodes[node.name]
+
+					if not above_ndef or not above_ndef.buildable_to then
+						-- do not remove the bucket with the liquid
+						return itemstack
+					end
+				end
+
+				if minetest.is_protected(lpos, user and user:get_player_name() or "") then
+					return
+				end
+
+				minetest.set_node(lpos, {name = source})
+				return ItemStack("fun_caves:bucket_wood_empty")
+			end
+		})
+	end
+end
+
+for fluid, def in pairs(bucket.liquids) do
+	if not fluid:find('flowing') and not fluid:find('lava') and not fluid:find('molten') and not fluid:find('weightless') then
+		local item_name = def.itemname:gsub('[^:]+:bucket', 'fun_caves:bucket_wood')
+		local original = minetest.registered_items[def.itemname]
+		if original and item_name and item_name ~= def.itemname then
+			local new_name = original.description:gsub('Bucket', 'Wooden Bucket')
+			local new_image = original.inventory_image
+			register_liquid_wood(fluid, item_name, new_image, new_name, original.groups)
+		end
+	end
+end
+
+
+minetest.register_craft({
+	output = 'fun_caves:bucket_wood_empty 1',
+	recipe = {
+		{'group:wood', '', 'group:wood'},
+		{'', 'group:wood', ''},
+	}
+})
+
+minetest.register_craftitem("fun_caves:bucket_wood_empty", {
+	description = "Empty Wooden Bucket",
+	inventory_image = "bucket.png",
+	stack_max = 99,
+	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 source
+		local node = minetest.get_node(pointed_thing.under)
+		local liquiddef = bucket.liquids[node.name]
+		if node.name ~= liquiddef.source then
+			return
+		end
+
+		if minetest.is_protected(pointed_thing.under, user:get_player_name()) then
+			return
+		end
+
+		local item_count = user:get_wielded_item():get_count()
+
+		-- default set to return filled bucket
+		local giving_back = liquiddef.itemname:gsub('^[^:]+:bucket', 'fun_caves:bucket_wood')
+
+		-- check if holding more than 1 empty bucket
+		if item_count > 1 then
+
+			-- if space in inventory add filled bucket, otherwise drop as item
+			local inv = user:get_inventory()
+			if inv:room_for_item("main", {name=giving_back}) then
+				inv:add_item("main", giving_back)
+			else
+				local pos = user:getpos()
+				pos.y = math.floor(pos.y + 0.5)
+				minetest.add_item(pos, giving_back)
+			end
+
+			-- set to return empty buckets minus 1
+			giving_back = "fun_caves:bucket_wood_empty "..tostring(item_count-1)
+
+		end
+
+		minetest.add_node(pointed_thing.under, {name="air"})
+
+		return ItemStack(giving_back)
+	end,
+})