mods/bucket/init.lua

   1 -- Minetest 0.4 mod: bucket
   2 -- See README.txt for licensing and other information.
   3
   4 minetest.register_alias("bucket", "bucket:bucket_empty")
   5 minetest.register_alias("bucket_water", "bucket:bucket_water")
   6 minetest.register_alias("bucket_lava", "bucket:bucket_lava")
   7
   8 minetest.register_craft({
   9         output = 'bucket:bucket_empty 1',
  10         recipe = {
  11                 {'default:steel_ingot', '', 'default:steel_ingot'},
  12                 {'', 'default:steel_ingot', ''},
  13         }
  14 })
  15
  16 bucket = {}
  17 bucket.liquids = {}
  18
  19 local function check_protection(pos, name, text)
  20         if minetest.is_protected(pos, name) then
  21                 minetest.log("action", (name ~= "" and name or "A mod")
  22                         .. " tried to " .. text
  23                         .. " at protected position "
  24                         .. minetest.pos_to_string(pos)
  25                         .. " with a bucket")
  26                 minetest.record_protection_violation(pos, name)
  27                 return true
  28         end
  29         return false
  30 end
  31
  32 -- Register a new liquid
  33 --    source = name of the source node
  34 --    flowing = name of the flowing node
  35 --    itemname = name of the new bucket item (or nil if liquid is not takeable)
  36 --    inventory_image = texture of the new bucket item (ignored if itemname == nil)
  37 --    name = text description of the bucket item
  38 --    groups = (optional) groups of the bucket item, for example {water_bucket = 1}
  39 -- This function can be called from any mod (that depends on bucket).
  40 function bucket.register_liquid(source, flowing, itemname, inventory_image, name, groups)
  41         bucket.liquids[source] = {
  42                 source = source,
  43                 flowing = flowing,
  44                 itemname = itemname,
  45         }
  46         bucket.liquids[flowing] = bucket.liquids[source]
  47
  48         if itemname ~= nil then
  49                 minetest.register_craftitem(itemname, {
  50                         description = name,
  51                         inventory_image = inventory_image,
  52                         stack_max = 1,
  53                         liquids_pointable = true,
  54                         groups = groups,
  55                         on_place = function(itemstack, user, pointed_thing)
  56                                 -- Must be pointing to node
  57                                 if pointed_thing.type ~= "node" then
  58                                         return
  59                                 end
  60
  61                                 local node = minetest.get_node_or_nil(pointed_thing.under)
  62                                 local ndef
  63                                 if node then
  64                                         ndef = minetest.registered_nodes[node.name]
  65                                 end
  66                                 -- Call on_rightclick if the pointed node defines it
  67                                 if ndef and ndef.on_rightclick and
  68                                    user and not user:get_player_control().sneak then
  69                                         return ndef.on_rightclick(
  70                                                 pointed_thing.under,
  71                                                 node, user,
  72                                                 itemstack) or itemstack
  73                                 end
  74
  75                                 local place_liquid = function(pos, node, source, flowing)
  76                                         if check_protection(pos,
  77                                                         user and user:get_player_name() or "",
  78                                                         "place "..source) then
  79                                                 return
  80                                         end
  81                                         minetest.add_node(pos, {name=source})
  82                                 end
  83
  84                                 -- Check if pointing to a buildable node
  85                                 if ndef and ndef.buildable_to then
  86                                         -- buildable; replace the node
  87                                         place_liquid(pointed_thing.under, node,
  88                                                         source, flowing)
  89                                 else
  90                                         -- not buildable to; place the liquid above
  91                                         -- check if the node above can be replaced
  92                                         local node = minetest.get_node_or_nil(pointed_thing.above)
  93                                         if node and minetest.registered_nodes[node.name].buildable_to then
  94                                                 place_liquid(pointed_thing.above,
  95                                                                 node, source,
  96                                                                 flowing)
  97                                         else
  98                                                 -- do not remove the bucket with the liquid
  99                                                 return
 100                                         end
 101                                 end
 102                                 return {name="bucket:bucket_empty"}
 103                         end
 104                 })
 105         end
 106 end
 107
 108 minetest.register_craftitem("bucket:bucket_empty", {
 109         description = "Empty Bucket",
 110         inventory_image = "bucket.png",
 111         stack_max = 99,
 112         liquids_pointable = true,
 113         on_use = function(itemstack, user, pointed_thing)
 114                 -- Must be pointing to node
 115                 if pointed_thing.type ~= "node" then
 116                         return
 117                 end
 118                 -- Check if pointing to a liquid source
 119                 local node = minetest.get_node(pointed_thing.under)
 120                 local liquiddef = bucket.liquids[node.name]
 121                 local item_count = user:get_wielded_item():get_count()
 122
 123                 if liquiddef ~= nil
 124                 and liquiddef.itemname ~= nil
 125                 and node.name == liquiddef.source then
 126                         if check_protection(pointed_thing.under,
 127                                         user:get_player_name(),
 128                                         "take ".. node.name) then
 129                                 return
 130                         end
 131
 132                         -- default set to return filled bucket
 133                         local giving_back = liquiddef.itemname
 134
 135                         -- check if holding more than 1 empty bucket
 136                         if item_count > 1 then
 137
 138                                 -- if space in inventory add filled bucked, otherwise drop as item
 139                                 local inv = user:get_inventory()
 140                                 if inv:room_for_item("main", {name=liquiddef.itemname}) then
 141                                         inv:add_item("main", liquiddef.itemname)
 142                                 else
 143                                         local pos = user:getpos()
 144                                         pos.y = math.floor(pos.y + 0.5)
 145                                         core.add_item(pos, liquiddef.itemname)
 146                                 end
 147
 148                                 -- set to return empty buckets minus 1
 149                                 giving_back = "bucket:bucket_empty "..tostring(item_count-1)
 150
 151                         end
 152
 153                         minetest.add_node(pointed_thing.under, {name="air"})
 154
 155                         return ItemStack(giving_back)
 156                 end
 157         end,
 158 })
 159
 160 bucket.register_liquid(
 161         "default:water_source",
 162         "default:water_flowing",
 163         "bucket:bucket_water",
 164         "bucket_water.png",
 165         "Water Bucket",
 166         {water_bucket = 1}
 167 )
 168
 169 bucket.register_liquid(
 170         "default:river_water_source",
 171         "default:river_water_flowing",
 172         "bucket:bucket_river_water",
 173         "bucket_river_water.png",
 174         "River Water Bucket",
 175         {water_bucket = 1}
 176 )
 177
 178 bucket.register_liquid(
 179         "default:lava_source",
 180         "default:lava_flowing",
 181         "bucket:bucket_lava",
 182         "bucket_lava.png",
 183         "Lava Bucket"
 184 )
 185
 186 minetest.register_craft({
 187         type = "fuel",
 188         recipe = "bucket:bucket_lava",
 189         burntime = 60,
 190         replacements = {{"bucket:bucket_lava", "bucket:bucket_empty"}},
 191 })
 192