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'},
-	},
-})
-
-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', ''},
+		{'fun_caves:bucket_wood_water', 'fun_caves:bucket_wood_water'},
+		{'fun_caves:bucket_wood_river_water', 'fun_caves:bucket_wood_river_water'},
 	},
 })

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,37 +177,54 @@ 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'}
-local mass_tools_list = {'default:axe_bronze', 'default:axe_diamond', 'default:axe_mese', 'default:pick_bronze', 'default:pick_diamond', 'default:pick_mese'}
-local mass_tools = {}
-for _, tool in pairs(mass_tools_list) do
+-- incompatible with buckets
+if false then
+	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'}
+	local mass_tools_list = {'default:axe_bronze', 'default:axe_diamond', 'default:axe_mese', 'default:pick_bronze', 'default:pick_diamond', 'default:pick_mese'}
+	local mass_tools = {}
+	for _, tool in pairs(mass_tools_list) do
 		mass_tools[tool] = true
-end
-local mass_minerals_list = {'default:gravel'}
-local mass_minerals = {}
-for _, min in pairs(mass_minerals_list) do
+	end
+	local mass_minerals_list = {'default:gravel'}
+	local mass_minerals = {}
+	for _, min in pairs(mass_minerals_list) do
 		mass_minerals[min] = true
-end
-for name, _ in pairs(minetest.registered_nodes) do
+	end
+	for name, _ in pairs(minetest.registered_nodes) do
 		if name:find('stone_with') then
 			mass_minerals[name] = true
 		end
-end
-local function default_rightclick(pos, node, clicker, itemstack, pointed_thing)
+	end
+	local function default_rightclick(pos, node, clicker, itemstack, pointed_thing)
 		if itemstack:get_definition().type == "node" then
 			return minetest.item_place_node(itemstack, clicker, pointed_thing)
 		end
 		return itemstack
-end
+	end
 
-for _, node in pairs(mass_nodes) do
+	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
 			local tool_type, maxr
@@ -326,4 +343,5 @@ for _, node in pairs(mass_nodes) do
 
 			return itemstack
 		end, })
+	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,
+})