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
  56                         on_place = function(itemstack, user, pointed_thing)
  57                                 -- Must be pointing to node
  58                                 if pointed_thing.type ~= "node" then
  59                                         return
  60                                 end
  61
  62                                 local node = minetest.get_node_or_nil(pointed_thing.under)
  63                                 local ndef = node and minetest.registered_nodes[node.name]
  64
  65                                 -- Call on_rightclick if the pointed node defines it
  66                                 if ndef and ndef.on_rightclick and
  67                                    user and not user:get_player_control().sneak then
  68                                         return ndef.on_rightclick(
  69                                                 pointed_thing.under,
  70                                                 node, user,
  71                                                 itemstack)
  72                                 end
  73
  74                                 local lpos
  75
  76                                 -- Check if pointing to a buildable node
  77                                 if ndef and ndef.buildable_to then
  78                                         -- buildable; replace the node
  79                                         lpos = pointed_thing.under
  80                                 else
  81                                         -- not buildable to; place the liquid above
  82                                         -- check if the node above can be replaced
  83
  84                                         lpos = pointed_thing.above
  85                                         node = minetest.get_node_or_nil(lpos)
  86                                         local above_ndef = node and minetest.registered_nodes[node.name]
  87
  88                                         if not above_ndef or not above_ndef.buildable_to then
  89                                                 -- do not remove the bucket with the liquid
  90                                                 return itemstack
  91                                         end
  92                                 end
  93
  94                                 if check_protection(lpos, user
  95                                                 and user:get_player_name()
  96                                                 or "", "place "..source) then
  97                                         return
  98                                 end
  99
 100                                 minetest.set_node(lpos, {name = source})
 101                                 return ItemStack("bucket:bucket_empty")
 102                         end
 103                 })
 104         end
 105 end
 106
 107 minetest.register_craftitem("bucket:bucket_empty", {
 108         description = "Empty Bucket",
 109         inventory_image = "bucket.png",
 110         stack_max = 99,
 111         liquids_pointable = true,
 112         on_use = function(itemstack, user, pointed_thing)
 113                 -- Must be pointing to node
 114                 if pointed_thing.type ~= "node" then
 115                         return
 116                 end
 117                 -- Check if pointing to a liquid source
 118                 local node = minetest.get_node(pointed_thing.under)
 119                 local liquiddef = bucket.liquids[node.name]
 120                 local item_count = user:get_wielded_item():get_count()
 121
 122                 if liquiddef ~= nil
 123                 and liquiddef.itemname ~= nil
 124                 and node.name == liquiddef.source then
 125                         if check_protection(pointed_thing.under,
 126                                         user:get_player_name(),
 127                                         "take ".. node.name) then
 128                                 return
 129                         end
 130
 131                         -- default set to return filled bucket
 132                         local giving_back = liquiddef.itemname
 133
 134                         -- check if holding more than 1 empty bucket
 135                         if item_count > 1 then
 136
 137                                 -- if space in inventory add filled bucked, otherwise drop as item
 138                                 local inv = user:get_inventory()
 139                                 if inv:room_for_item("main", {name=liquiddef.itemname}) then
 140                                         inv:add_item("main", liquiddef.itemname)
 141                                 else
 142                                         local pos = user:getpos()
 143                                         pos.y = math.floor(pos.y + 0.5)
 144                                         core.add_item(pos, liquiddef.itemname)
 145                                 end
 146
 147                                 -- set to return empty buckets minus 1
 148                                 giving_back = "bucket:bucket_empty "..tostring(item_count-1)
 149
 150                         end
 151
 152                         minetest.add_node(pointed_thing.under, {name="air"})
 153
 154                         return ItemStack(giving_back)
 155                 end
 156         end,
 157 })
 158
 159 bucket.register_liquid(
 160         "default:water_source",
 161         "default:water_flowing",
 162         "bucket:bucket_water",
 163         "bucket_water.png",
 164         "Water Bucket",
 165         {water_bucket = 1}
 166 )
 167
 168 bucket.register_liquid(
 169         "default:river_water_source",
 170         "default:river_water_flowing",
 171         "bucket:bucket_river_water",
 172         "bucket_river_water.png",
 173         "River Water Bucket",
 174         {water_bucket = 1}
 175 )
 176
 177 bucket.register_liquid(
 178         "default:lava_source",
 179         "default:lava_flowing",
 180         "bucket:bucket_lava",
 181         "bucket_lava.png",
 182         "Lava Bucket"
 183 )
 184
 185 minetest.register_craft({
 186         type = "fuel",
 187         recipe = "bucket:bucket_lava",
 188         burntime = 60,
 189         replacements = {{"bucket:bucket_lava", "bucket:bucket_empty"}},
 190 })
 191