Initial upload (thanks Jordach)

README.txt

@@ -0,0 +1,26 @@
+Minetest 0.4 mod: bucket
+=========================
+
+License of source code:
+-----------------------
+Copyright (C) 2011-2012 Kahrl <kahrl@gmx.net>
+Copyright (C) 2011-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+http://www.gnu.org/licenses/lgpl-2.1.html
+
+License of media (textures and sounds)
+--------------------------------------
+Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)                                 
+http://creativecommons.org/licenses/by-sa/3.0/
+
+Authors of media files
+-----------------------
+Everything not listed in here:
+Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+

depends.txt

@@ -0,0 +1,2 @@
+default
+

init.lua

@@ -0,0 +1,199 @@
+bucket = {}
+
+bucket.place = {} -- list of liquids to place
+
+bucket.fill = {} -- list of liquids to loop over and set to air
+
+bucket.name = {} -- list of bucket names to return after using the empty bucket
+
+
+function bucket.give_filled(user, ltype)
+
+	local inv = user:get_inventory()
+
+	if inv:room_for_item("main", {name = ltype}) then
+		inv:add_item("main", ltype)
+	else
+		local pos = user:getpos()
+		pos.y = math.floor(pos.y + 0.5)
+		core.add_item(pos, ltype)
+	end
+end
+
+
+minetest.register_craftitem("bucket:bucket_empty", {
+	description = "Empty Bucket",
+	inventory_image = "bucket.png",
+	liquids_pointable = true,
+	stack_max = 99,
+
+	on_place = function(itemstack, user, pointed_thing)
+
+		if pointed_thing.type ~= "node" then
+			return
+		end
+
+		local pos = pointed_thing.under
+
+		if minetest.is_protected(pos, user:get_player_name()) then
+			minetest.record_protection_violation(pos, user:get_player_name())
+			return itemstack
+		end
+
+		local stack_count = user:get_wielded_item():get_count()
+		local return_item = itemstack
+
+		for i = 1, bucket.count do
+
+			if minetest.get_node(pos).name == bucket.fill[i] then
+
+				return_item = bucket.name[i] .. " 1"
+
+				if user:get_wielded_item():get_count() > 1 then
+
+					bucket.give_filled(user, bucket.name[i])
+
+					return_item = "bucket:bucket_empty " .. tostring(stack_count - 1)
+
+				end
+
+				minetest.add_node(pos, {name = "air"})
+			end
+
+		end
+
+		return ItemStack(return_item)
+	end,
+})
+
+minetest.register_craft({
+	output = 'bucket:bucket_empty 1',
+	recipe = {
+		{'default:steel_ingot', '', 'default:steel_ingot'},
+		{'', 'default:steel_ingot', ''},
+	}
+})
+
+-- how to register a filled bucket:
+
+--[[
+	name (string) refers to the item name of the bucket, eg:
+	"lava", "water", "decay_water", the after result will look like this, eg:
+	"bucket:lava", "bucket:water", "bucket:decay_water"
+	
+	image (string) refers to the inventory image used to display the bucket, eg:
+	"bucket_water.png" or "bucket_empty.png^water_overlay.png"
+	
+	liquid_source (string) is the node name of the liquid source block that the
+	empty bucket should pick up, eg:
+	"core:water_source", "core:lava_source", "core:acid_source"
+	
+	desc (string) is the description of the filled bucket, eg:
+	"Lava Bucket", "Bucket of Water", "Bucket of Lava"
+	
+	to_place (string) is the node name of the water source that the bucket should place,
+	eg: "core:water_source" "core:lava_source"
+	
+]]--
+
+
+bucket.count = 0
+
+function bucket.register_bucket(name, image, liquid_source, desc, to_place)
+
+	bucket.count = bucket.count + 1
+
+	bucket.fill[bucket.count] = liquid_source
+
+	bucket.place[bucket.count] = to_place
+
+	--bucket.name[bucket.count] = "bucket:"..name.."_bucket",
+	bucket.name[bucket.count] = "bucket:bucket_" .. name,
+
+	--minetest.register_craftitem("bucket:"..name.."_bucket", {
+	minetest.register_craftitem("bucket:bucket_" .. name, {
+		description = desc,
+		inventory_image = image,
+		stack_max = 1,
+		liquids_pointable = true,
+
+		on_place = function(itemstack, user, pointed_thing)
+
+			if pointed_thing.type ~= "node" then
+				return
+			end
+
+			local node = minetest.get_node_or_nil(pointed_thing.under)
+			local npos
+			local nodedef = minetest.registered_nodes[node.name]
+
+			if nodedef and nodedef.on_rightclick and not user:get_player_control().sneak then
+				return nodedef.on_rightclick(pointed_thing.under, node, user, itemstack)
+			end
+
+			if nodedef and nodedef.buildable_to then
+				npos = pointed_thing.under
+			else
+				npos = pointed_thing.above
+				node = minetest.get_node_or_nil(pointed_thing.above)
+
+				local above_node = minetest.registered_nodes[node.name]
+
+				if not above_node.buildable_to then
+					return itemstack
+				end
+			end
+
+			if minetest.is_protected(npos, user:get_player_name()) then
+				minetest.record_protection_violation(npos, user:get_player_name())
+				return itemstack
+			end
+
+			minetest.add_node(npos, {name = to_place})
+
+			return ItemStack("bucket:bucket_empty 1")
+		end,
+	})
+end
+
+
+-- register water, river water and lava buckets
+bucket.register_bucket("water", "bucket_water.png", "default:water_source", "Bucket of Water", "default:water_source")
+bucket.register_bucket("lava", "bucket_lava.png", "default:lava_source", "Bucket of Lava", "default:lava_source")
+bucket.register_bucket("river_water", "bucket_river_water.png", "default:river_water_source", "Bucket of River Water", "default:river_water_source")
+
+
+-- lava as fuel
+minetest.register_craft({
+	type = "fuel",
+	recipe = "bucket:bucket_lava",
+	burntime = 60,
+	replacements = {{"bucket:bucket_lava", "bucket:bucket_empty"}},
+})
+
+
+-- aliases
+minetest.register_alias("bucket", "bucket:bucket_empty")
+minetest.register_alias("bucket_water", "bucket:bucket_water")
+minetest.register_alias("bucket_lava", "bucket:bucket_lava")
+
+
+-- compabitility with default buckets
+function bucket.register_liquid(source, flowing, itemname, inventory_image, desc, groups)
+
+	local name = itemname:split("_")[2]
+
+	bucket.register_bucket(name, inventory_image, source, desc, source)
+
+end
+
+--[[
+bucket.register_liquid(
+	"default:water_source",
+	"default:water_flowing",
+	"bucket:bucket_water",
+	"bucket_water.png",
+	"Water Bucket",
+	{water_bucket = 1}
+)
+]]

init.lua_ok

@@ -0,0 +1,191 @@
+-- Minetest 0.4 mod: bucket
+-- See README.txt for licensing and other information.
+
+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 = 'bucket:bucket_empty 1',
+	recipe = {
+		{'default:steel_ingot', '', 'default:steel_ingot'},
+		{'', 'default:steel_ingot', ''},
+	}
+})
+
+bucket = {}
+bucket.liquids = {}
+
+local function check_protection(pos, name, text)
+	if minetest.is_protected(pos, name) then
+		minetest.log("action", (name ~= "" and name or "A mod")
+			.. " tried to " .. text
+			.. " at protected position "
+			.. minetest.pos_to_string(pos)
+			.. " with a bucket")
+		minetest.record_protection_violation(pos, name)
+		return true
+	end
+	return false
+end
+
+-- 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)
+--    name = text description of the bucket item
+--    groups = (optional) groups of the bucket item, for example {water_bucket = 1}
+-- This function can be called from any mod (that depends on bucket).
+function bucket.register_liquid(source, flowing, itemname, inventory_image, name, groups)
+	bucket.liquids[source] = {
+		source = source,
+		flowing = flowing,
+		itemname = itemname,
+	}
+	bucket.liquids[flowing] = bucket.liquids[source]
+
+	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 check_protection(lpos, user
+						and user:get_player_name()
+						or "", "place "..source) then
+					return itemstack
+				end
+
+				minetest.set_node(lpos, {name = source})
+minetest.get_meta(lpos):set_string("infotext", "Placed by " .. user:get_player_name())
+				return ItemStack("bucket:bucket_empty")
+			end
+		})
+	end
+end
+
+minetest.register_craftitem("bucket:bucket_empty", {
+	description = "Empty 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]
+		local item_count = user:get_wielded_item():get_count()
+
+		if liquiddef ~= nil
+		and liquiddef.itemname ~= nil
+		and node.name == liquiddef.source then
+			if check_protection(pointed_thing.under,
+					user:get_player_name(),
+					"take ".. node.name) then
+				return
+			end
+
+			-- default set to return filled bucket
+			local giving_back = liquiddef.itemname
+
+			-- check if holding more than 1 empty bucket
+			if item_count > 1 then
+
+				-- if space in inventory add filled bucked, otherwise drop as item
+				local inv = user:get_inventory()
+				if inv:room_for_item("main", {name=liquiddef.itemname}) then
+					inv:add_item("main", liquiddef.itemname)
+				else
+					local pos = user:getpos()
+					pos.y = math.floor(pos.y + 0.5)
+					minetest.add_item(pos, liquiddef.itemname)
+				end
+
+				-- set to return empty buckets minus 1
+				giving_back = "bucket:bucket_empty "..tostring(item_count-1)
+
+			end
+
+			minetest.set_node(pointed_thing.under, {name="air"})
+
+			return ItemStack(giving_back)
+		end
+	end,
+})
+
+bucket.register_liquid(
+	"default:water_source",
+	"default:water_flowing",
+	"bucket:bucket_water",
+	"bucket_water.png",
+	"Water Bucket",
+	{water_bucket = 1}
+)
+
+bucket.register_liquid(
+	"default:river_water_source",
+	"default:river_water_flowing",
+	"bucket:bucket_river_water",
+	"bucket_river_water.png",
+	"River Water Bucket",
+	{water_bucket = 1}
+)
+--[[
+bucket.register_liquid(
+	"default:lava_source",
+	"default:lava_flowing",
+	"bucket:bucket_lava",
+	"bucket_lava.png",
+	"Lava Bucket"
+)
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "bucket:bucket_lava",
+	burntime = 60,
+	replacements = {{"bucket:bucket_lava", "bucket:bucket_empty"}},
+})
+]]