builtin/item.lua

   1 -- Minetest: builtin/item.lua
   2
   3 --
   4 -- Item definition helpers
   5 --
   6
   7 function minetest.inventorycube(img1, img2, img3)
   8         img2 = img2 or img1
   9         img3 = img3 or img1
  10         return "[inventorycube"
  11                         .. "{" .. img1:gsub("%^", "&")
  12                         .. "{" .. img2:gsub("%^", "&")
  13                         .. "{" .. img3:gsub("%^", "&")
  14 end
  15
  16 function minetest.get_pointed_thing_position(pointed_thing, above)
  17         if pointed_thing.type == "node" then
  18                 if above then
  19                         -- The position where a node would be placed
  20                         return pointed_thing.above
  21                 else
  22                         -- The position where a node would be dug
  23                         return pointed_thing.under
  24                 end
  25         elseif pointed_thing.type == "object" then
  26                 obj = pointed_thing.ref
  27                 if obj ~= nil then
  28                         return obj:getpos()
  29                 else
  30                         return nil
  31                 end
  32         else
  33                 return nil
  34         end
  35 end
  36
  37 function minetest.dir_to_facedir(dir)
  38         if math.abs(dir.x) > math.abs(dir.z) then
  39                 if dir.x < 0 then
  40                         return 3
  41                 else
  42                         return 1
  43                 end
  44         else
  45                 if dir.z < 0 then
  46                         return 2
  47                 else
  48                         return 0
  49                 end
  50         end
  51 end
  52
  53 function minetest.dir_to_wallmounted(dir)
  54         if math.abs(dir.y) > math.max(math.abs(dir.x), math.abs(dir.z)) then
  55                 if dir.y < 0 then
  56                         return 1
  57                 else
  58                         return 0
  59                 end
  60         elseif math.abs(dir.x) > math.abs(dir.z) then
  61                 if dir.x < 0 then
  62                         return 3
  63                 else
  64                         return 2
  65                 end
  66         else
  67                 if dir.z < 0 then
  68                         return 5
  69                 else
  70                         return 4
  71                 end
  72         end
  73 end
  74
  75 function minetest.get_node_drops(nodename, toolname)
  76         local drop = ItemStack({name=nodename}):get_definition().drop
  77         if drop == nil then
  78                 -- default drop
  79                 return {ItemStack({name=nodename})}
  80         elseif type(drop) == "string" then
  81                 -- itemstring drop
  82                 return {ItemStack(drop)}
  83         elseif drop.items == nil then
  84                 -- drop = {} to disable default drop
  85                 return {}
  86         end
  87
  88         -- Extended drop table
  89         local got_items = {}
  90         local got_count = 0
  91         local _, item, tool
  92         for _, item in ipairs(drop.items) do
  93                 local good_rarity = true
  94                 local good_tool = true
  95                 if item.rarity ~= nil then
  96                         good_rarity = item.rarity < 1 or math.random(item.rarity) == 1
  97                 end
  98                 if item.tools ~= nil then
  99                         good_tool = false
 100                         for _, tool in ipairs(item.tools) do
 101                                 if tool:sub(1, 1) == '~' then
 102                                         good_tool = toolname:find(tool:sub(2)) ~= nil
 103                                 else
 104                                         good_tool = toolname == tool
 105                                 end
 106                                 if good_tool then
 107                                         break
 108                                 end
 109                         end
 110                 end
 111                 if good_rarity and good_tool then
 112                         got_count = got_count + 1
 113                         for _, add_item in ipairs(item.items) do
 114                                 got_items[#got_items+1] = add_item
 115                         end
 116                         if drop.max_items ~= nil and got_count == drop.max_items then
 117                                 break
 118                         end
 119                 end
 120         end
 121         return got_items
 122 end
 123
 124 function minetest.item_place_node(itemstack, placer, pointed_thing)
 125         local item = itemstack:peek_item()
 126         local def = itemstack:get_definition()
 127         if def.type ~= "node" or pointed_thing.type ~= "node" then
 128                 return itemstack
 129         end
 130
 131         local under = pointed_thing.under
 132         local oldnode_under = minetest.env:get_node(under)
 133         local olddef_under = ItemStack({name=oldnode_under.name}):get_definition()
 134         olddef_under = olddef_under or minetest.nodedef_default
 135         local above = pointed_thing.above
 136         local oldnode_above = minetest.env:get_node(above)
 137         local olddef_above = ItemStack({name=oldnode_above.name}):get_definition()
 138         olddef_above = olddef_above or minetest.nodedef_default
 139
 140         if not olddef_above.buildable_to and not olddef_under.buildable_to then
 141                 minetest.log("info", placer:get_player_name() .. " tried to place"
 142                         .. " node in invalid position " .. minetest.pos_to_string(above)
 143                         .. ", replacing " .. oldnode_above.name)
 144                 return
 145         end
 146
 147         -- Place above pointed node
 148         local place_to = {x = above.x, y = above.y, z = above.z}
 149
 150         -- If node under is buildable_to, place into it instead (eg. snow)
 151         if olddef_under.buildable_to then
 152                 minetest.log("info", "node under is buildable to")
 153                 place_to = {x = under.x, y = under.y, z = under.z}
 154         end
 155
 156         minetest.log("action", placer:get_player_name() .. " places node "
 157                 .. def.name .. " at " .. minetest.pos_to_string(place_to))
 158
 159         local oldnode = minetest.env:get_node(place_to)
 160         local newnode = {name = def.name, param1 = 0, param2 = 0}
 161
 162         -- Calculate direction for wall mounted stuff like torches and signs
 163         if def.paramtype2 == 'wallmounted' then
 164                 local dir = {
 165                         x = under.x - above.x,
 166                         y = under.y - above.y,
 167                         z = under.z - above.z
 168                 }
 169                 newnode.param2 = minetest.dir_to_wallmounted(dir)
 170         -- Calculate the direction for furnaces and chests and stuff
 171         elseif def.paramtype2 == 'facedir' then
 172                 local placer_pos = placer:getpos()
 173                 if placer_pos then
 174                         local dir = {
 175                                 x = above.x - placer_pos.x,
 176                                 y = above.y - placer_pos.y,
 177                                 z = above.z - placer_pos.z
 178                         }
 179                         newnode.param2 = minetest.dir_to_facedir(dir)
 180                         minetest.log("action", "facedir: " .. newnode.param2)
 181                 end
 182         end
 183
 184         -- Add node and update
 185         minetest.env:add_node(place_to, newnode)
 186
 187         -- Run callback
 188         if def.after_place_node then
 189                 -- Copy place_to because callback can modify it
 190                 local place_to_copy = {x=place_to.x, y=place_to.y, z=place_to.z}
 191                 def.after_place_node(place_to_copy, placer)
 192         end
 193
 194         -- Run script hook
 195         local _, callback
 196         for _, callback in ipairs(minetest.registered_on_placenodes) do
 197                 -- Copy pos and node because callback can modify them
 198                 local place_to_copy = {x=place_to.x, y=place_to.y, z=place_to.z}
 199                 local newnode_copy = {name=newnode.name, param1=newnode.param1, param2=newnode.param2}
 200                 local oldnode_copy = {name=oldnode.name, param1=oldnode.param1, param2=oldnode.param2}
 201                 callback(place_to_copy, newnode_copy, placer, oldnode_copy)
 202         end
 203
 204         itemstack:take_item()
 205         return itemstack
 206 end
 207
 208 function minetest.item_place_object(itemstack, placer, pointed_thing)
 209         local pos = minetest.get_pointed_thing_position(pointed_thing, true)
 210         if pos ~= nil then
 211                 local item = itemstack:take_item()
 212                 minetest.env:add_item(pos, item)
 213         end
 214         return itemstack
 215 end
 216
 217 function minetest.item_place(itemstack, placer, pointed_thing)
 218         if itemstack:get_definition().type == "node" then
 219                 return minetest.item_place_node(itemstack, placer, pointed_thing)
 220         else
 221                 return minetest.item_place_object(itemstack, placer, pointed_thing)
 222         end
 223 end
 224
 225 function minetest.item_drop(itemstack, dropper, pos)
 226         if dropper.get_player_name then
 227                 local v = dropper:get_look_dir()
 228                 local p = {x=pos.x+v.x, y=pos.y+1.5+v.y, z=pos.z+v.z}
 229                 local obj = minetest.env:add_item(p, itemstack)
 230                 if obj then
 231                         v.x = v.x*2
 232                         v.y = v.y*2 + 1
 233                         v.z = v.z*2
 234                         obj:setvelocity(v)
 235                 end
 236         else
 237                 minetest.env:add_item(pos, itemstack)
 238         end
 239         return ""
 240 end
 241
 242 function minetest.item_eat(hp_change, replace_with_item)
 243         return function(itemstack, user, pointed_thing)  -- closure
 244                 if itemstack:take_item() ~= nil then
 245                         user:set_hp(user:get_hp() + hp_change)
 246                         itemstack:add_item(replace_with_item) -- note: replace_with_item is optional
 247                 end
 248                 return itemstack
 249         end
 250 end
 251
 252 function minetest.node_punch(pos, node, puncher)
 253         -- Run script hook
 254         local _, callback
 255         for _, callback in ipairs(minetest.registered_on_punchnodes) do
 256                 -- Copy pos and node because callback can modify them
 257                 local pos_copy = {x=pos.x, y=pos.y, z=pos.z}
 258                 local node_copy = {name=node.name, param1=node.param1, param2=node.param2}
 259                 callback(pos_copy, node_copy, puncher)
 260         end
 261 end
 262
 263 function minetest.handle_node_drops(pos, drops, digger)
 264         -- Add dropped items to object's inventory
 265         if digger:get_inventory() then
 266                 local _, dropped_item
 267                 for _, dropped_item in ipairs(drops) do
 268                         digger:get_inventory():add_item("main", dropped_item)
 269                 end
 270         end
 271 end
 272
 273 function minetest.node_dig(pos, node, digger)
 274         minetest.debug("node_dig")
 275
 276         local def = ItemStack({name=node.name}):get_definition()
 277         -- Check if def ~= 0 because we always want to be able to remove unknown nodes
 278         if #def ~= 0 and not def.diggable or (def.can_dig and not def.can_dig(pos,digger)) then
 279                 minetest.debug("not diggable")
 280                 minetest.log("info", digger:get_player_name() .. " tried to dig "
 281                         .. node.name .. " which is not diggable "
 282                         .. minetest.pos_to_string(pos))
 283                 return
 284         end
 285
 286         minetest.log('action', digger:get_player_name() .. " digs "
 287                 .. node.name .. " at " .. minetest.pos_to_string(pos))
 288
 289         local wielded = digger:get_wielded_item()
 290         local drops = minetest.get_node_drops(node.name, wielded:get_name())
 291
 292         -- Wear out tool
 293         local tp = wielded:get_tool_capabilities()
 294         local dp = minetest.get_dig_params(def.groups, tp)
 295         wielded:add_wear(dp.wear)
 296         digger:set_wielded_item(wielded)
 297
 298         -- Handle drops
 299         minetest.handle_node_drops(pos, drops, digger)
 300
 301         local oldmetadata = nil
 302         if def.after_dig_node then
 303                 oldmetadata = minetest.env:get_meta(pos):to_table()
 304         end
 305
 306         -- Remove node and update
 307         minetest.env:remove_node(pos)
 308
 309         -- Run callback
 310         if def.after_dig_node then
 311                 -- Copy pos and node because callback can modify them
 312                 local pos_copy = {x=pos.x, y=pos.y, z=pos.z}
 313                 local node_copy = {name=node.name, param1=node.param1, param2=node.param2}
 314                 def.after_dig_node(pos_copy, node_copy, oldmetadata, digger)
 315         end
 316
 317         -- Run script hook
 318         local _, callback
 319         for _, callback in ipairs(minetest.registered_on_dignodes) do
 320                 -- Copy pos and node because callback can modify them
 321                 local pos_copy = {x=pos.x, y=pos.y, z=pos.z}
 322                 local node_copy = {name=node.name, param1=node.param1, param2=node.param2}
 323                 callback(pos_copy, node_copy, digger)
 324         end
 325 end
 326
 327 -- This is used to allow mods to redefine minetest.item_place and so on
 328 -- NOTE: This is not the preferred way. Preferred way is to provide enough
 329 --       callbacks to not require redefining global functions. -celeron55
 330 local function redef_wrapper(table, name)
 331         return function(...)
 332                 return table[name](...)
 333         end
 334 end
 335
 336 --
 337 -- Item definition defaults
 338 --
 339
 340 minetest.nodedef_default = {
 341         -- Item properties
 342         type="node",
 343         -- name intentionally not defined here
 344         description = "",
 345         groups = {},
 346         inventory_image = "",
 347         wield_image = "",
 348         wield_scale = {x=1,y=1,z=1},
 349         stack_max = 99,
 350         usable = false,
 351         liquids_pointable = false,
 352         tool_capabilities = nil,
 353         node_placement_prediction = nil,
 354
 355         -- Interaction callbacks
 356         on_place = redef_wrapper(minetest, 'item_place'), -- minetest.item_place
 357         on_drop = redef_wrapper(minetest, 'item_drop'), -- minetest.item_drop
 358         on_use = nil,
 359         can_dig = nil,
 360
 361         on_punch = redef_wrapper(minetest, 'node_punch'), -- minetest.node_punch
 362         on_dig = redef_wrapper(minetest, 'node_dig'), -- minetest.node_dig
 363
 364         on_receive_fields = nil,
 365
 366         on_metadata_inventory_move = minetest.node_metadata_inventory_move_allow_all,
 367         on_metadata_inventory_offer = minetest.node_metadata_inventory_offer_allow_all,
 368         on_metadata_inventory_take = minetest.node_metadata_inventory_take_allow_all,
 369
 370         -- Node properties
 371         drawtype = "normal",
 372         visual_scale = 1.0,
 373         -- Don't define these because otherwise the old tile_images and
 374         -- special_materials wouldn't be read
 375         --tiles ={""},
 376         --special_tiles = {
 377         --      {name="", backface_culling=true},
 378         --      {name="", backface_culling=true},
 379         --},
 380         alpha = 255,
 381         post_effect_color = {a=0, r=0, g=0, b=0},
 382         paramtype = "none",
 383         paramtype2 = "none",
 384         is_ground_content = false,
 385         sunlight_propagates = false,
 386         walkable = true,
 387         pointable = true,
 388         diggable = true,
 389         climbable = false,
 390         buildable_to = false,
 391         liquidtype = "none",
 392         liquid_alternative_flowing = "",
 393         liquid_alternative_source = "",
 394         liquid_viscosity = 0,
 395         light_source = 0,
 396         damage_per_second = 0,
 397         selection_box = {type="regular"},
 398         legacy_facedir_simple = false,
 399         legacy_wallmounted = false,
 400 }
 401
 402 minetest.craftitemdef_default = {
 403         type="craft",
 404         -- name intentionally not defined here
 405         description = "",
 406         groups = {},
 407         inventory_image = "",
 408         wield_image = "",
 409         wield_scale = {x=1,y=1,z=1},
 410         stack_max = 99,
 411         liquids_pointable = false,
 412         tool_capabilities = nil,
 413
 414         -- Interaction callbacks
 415         on_place = redef_wrapper(minetest, 'item_place'), -- minetest.item_place
 416         on_drop = redef_wrapper(minetest, 'item_drop'), -- minetest.item_drop
 417         on_use = nil,
 418 }
 419
 420 minetest.tooldef_default = {
 421         type="tool",
 422         -- name intentionally not defined here
 423         description = "",
 424         groups = {},
 425         inventory_image = "",
 426         wield_image = "",
 427         wield_scale = {x=1,y=1,z=1},
 428         stack_max = 1,
 429         liquids_pointable = false,
 430         tool_capabilities = nil,
 431
 432         -- Interaction callbacks
 433         on_place = redef_wrapper(minetest, 'item_place'), -- minetest.item_place
 434         on_drop = redef_wrapper(minetest, 'item_drop'), -- minetest.item_drop
 435         on_use = nil,
 436 }
 437
 438 minetest.noneitemdef_default = {  -- This is used for the hand and unknown items
 439         type="none",
 440         -- name intentionally not defined here
 441         description = "",
 442         groups = {},
 443         inventory_image = "",
 444         wield_image = "",
 445         wield_scale = {x=1,y=1,z=1},
 446         stack_max = 99,
 447         liquids_pointable = false,
 448         tool_capabilities = nil,
 449
 450         -- Interaction callbacks
 451         on_place = nil,
 452         on_drop = nil,
 453         on_use = nil,
 454 }
 455