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, is6d)
  38         --account for y if requested
  39         if is6d and math.abs(dir.y) > math.abs(dir.x) and math.abs(dir.y) > math.abs(dir.z) then
  40
  41                 --from above
  42                 if dir.y < 0 then
  43                         if math.abs(dir.x) > math.abs(dir.z) then
  44                                 if dir.x < 0 then
  45                                         return 19
  46                                 else
  47                                         return 13
  48                                 end
  49                         else
  50                                 if dir.z < 0 then
  51                                         return 10
  52                                 else
  53                                         return 4
  54                                 end
  55                         end
  56
  57                 --from below
  58                 else
  59                         if math.abs(dir.x) > math.abs(dir.z) then
  60                                 if dir.x < 0 then
  61                                         return 15
  62                                 else
  63                                         return 17
  64                                 end
  65                         else
  66                                 if dir.z < 0 then
  67                                         return 6
  68                                 else
  69                                         return 8
  70                                 end
  71                         end
  72                 end
  73
  74         --otherwise, place horizontally
  75         elseif math.abs(dir.x) > math.abs(dir.z) then
  76                 if dir.x < 0 then
  77                         return 3
  78                 else
  79                         return 1
  80                 end
  81         else
  82                 if dir.z < 0 then
  83                         return 2
  84                 else
  85                         return 0
  86                 end
  87         end
  88 end
  89
  90 function minetest.facedir_to_dir(facedir)
  91         --a table of possible dirs
  92         return ({{x=0, y=0, z=1},
  93                                         {x=1, y=0, z=0},
  94                                         {x=0, y=0, z=-1},
  95                                         {x=-1, y=0, z=0},
  96                                         {x=0, y=-1, z=0},
  97                                         {x=0, y=1, z=0}})
  98
  99                                         --indexed into by a table of correlating facedirs
 100                                         [({[0]=1, 2, 3, 4,
 101                                                 5, 4, 6, 2,
 102                                                 6, 2, 5, 4,
 103                                                 1, 5, 3, 6,
 104                                                 1, 6, 3, 5,
 105                                                 1, 4, 3, 2})
 106
 107                                                 --indexed into by the facedir in question
 108                                                 [facedir]]
 109 end
 110
 111 function minetest.dir_to_wallmounted(dir)
 112         if math.abs(dir.y) > math.max(math.abs(dir.x), math.abs(dir.z)) then
 113                 if dir.y < 0 then
 114                         return 1
 115                 else
 116                         return 0
 117                 end
 118         elseif math.abs(dir.x) > math.abs(dir.z) then
 119                 if dir.x < 0 then
 120                         return 3
 121                 else
 122                         return 2
 123                 end
 124         else
 125                 if dir.z < 0 then
 126                         return 5
 127                 else
 128                         return 4
 129                 end
 130         end
 131 end
 132
 133 function minetest.get_node_drops(nodename, toolname)
 134         local drop = ItemStack({name=nodename}):get_definition().drop
 135         if drop == nil then
 136                 -- default drop
 137                 return {nodename}
 138         elseif type(drop) == "string" then
 139                 -- itemstring drop
 140                 return {drop}
 141         elseif drop.items == nil then
 142                 -- drop = {} to disable default drop
 143                 return {}
 144         end
 145
 146         -- Extended drop table
 147         local got_items = {}
 148         local got_count = 0
 149         local _, item, tool
 150         for _, item in ipairs(drop.items) do
 151                 local good_rarity = true
 152                 local good_tool = true
 153                 if item.rarity ~= nil then
 154                         good_rarity = item.rarity < 1 or math.random(item.rarity) == 1
 155                 end
 156                 if item.tools ~= nil then
 157                         good_tool = false
 158                         for _, tool in ipairs(item.tools) do
 159                                 if tool:sub(1, 1) == '~' then
 160                                         good_tool = toolname:find(tool:sub(2)) ~= nil
 161                                 else
 162                                         good_tool = toolname == tool
 163                                 end
 164                                 if good_tool then
 165                                         break
 166                                 end
 167                         end
 168                 end
 169                 if good_rarity and good_tool then
 170                         got_count = got_count + 1
 171                         for _, add_item in ipairs(item.items) do
 172                                 got_items[#got_items+1] = add_item
 173                         end
 174                         if drop.max_items ~= nil and got_count == drop.max_items then
 175                                 break
 176                         end
 177                 end
 178         end
 179         return got_items
 180 end
 181
 182 function minetest.item_place_node(itemstack, placer, pointed_thing, param2)
 183         local item = itemstack:peek_item()
 184         local def = itemstack:get_definition()
 185         if def.type ~= "node" or pointed_thing.type ~= "node" then
 186                 return itemstack, false
 187         end
 188
 189         local under = pointed_thing.under
 190         local oldnode_under = minetest.get_node_or_nil(under)
 191         local above = pointed_thing.above
 192         local oldnode_above = minetest.get_node_or_nil(above)
 193
 194         if not oldnode_under or not oldnode_above then
 195                 minetest.log("info", placer:get_player_name() .. " tried to place"
 196                         .. " node in unloaded position " .. minetest.pos_to_string(above))
 197                 return itemstack, false
 198         end
 199
 200         local olddef_under = ItemStack({name=oldnode_under.name}):get_definition()
 201         olddef_under = olddef_under or minetest.nodedef_default
 202         local olddef_above = ItemStack({name=oldnode_above.name}):get_definition()
 203         olddef_above = olddef_above or minetest.nodedef_default
 204
 205         if not olddef_above.buildable_to and not olddef_under.buildable_to then
 206                 minetest.log("info", placer:get_player_name() .. " tried to place"
 207                         .. " node in invalid position " .. minetest.pos_to_string(above)
 208                         .. ", replacing " .. oldnode_above.name)
 209                 return itemstack, false
 210         end
 211
 212         -- Place above pointed node
 213         local place_to = {x = above.x, y = above.y, z = above.z}
 214
 215         -- If node under is buildable_to, place into it instead (eg. snow)
 216         if olddef_under.buildable_to then
 217                 minetest.log("info", "node under is buildable to")
 218                 place_to = {x = under.x, y = under.y, z = under.z}
 219         end
 220
 221         if minetest.is_protected(place_to, placer:get_player_name()) then
 222                 minetest.log("action", placer:get_player_name()
 223                                 .. " tried to place " .. def.name
 224                                 .. " at protected position "
 225                                 .. minetest.pos_to_string(place_to))
 226                 minetest.record_protection_violation(place_to, placer:get_player_name())
 227                 return itemstack
 228         end
 229
 230         minetest.log("action", placer:get_player_name() .. " places node "
 231                 .. def.name .. " at " .. minetest.pos_to_string(place_to))
 232
 233         local oldnode = minetest.get_node(place_to)
 234         local newnode = {name = def.name, param1 = 0, param2 = param2}
 235
 236         -- Calculate direction for wall mounted stuff like torches and signs
 237         if def.paramtype2 == 'wallmounted' and not param2 then
 238                 local dir = {
 239                         x = under.x - above.x,
 240                         y = under.y - above.y,
 241                         z = under.z - above.z
 242                 }
 243                 newnode.param2 = minetest.dir_to_wallmounted(dir)
 244         -- Calculate the direction for furnaces and chests and stuff
 245         elseif def.paramtype2 == 'facedir' and not param2 then
 246                 local placer_pos = placer:getpos()
 247                 if placer_pos then
 248                         local dir = {
 249                                 x = above.x - placer_pos.x,
 250                                 y = above.y - placer_pos.y,
 251                                 z = above.z - placer_pos.z
 252                         }
 253                         newnode.param2 = minetest.dir_to_facedir(dir)
 254                         minetest.log("action", "facedir: " .. newnode.param2)
 255                 end
 256         end
 257
 258         -- Check if the node is attached and if it can be placed there
 259         if minetest.get_item_group(def.name, "attached_node") ~= 0 and
 260                 not check_attached_node(place_to, newnode) then
 261                 minetest.log("action", "attached node " .. def.name ..
 262                         " can not be placed at " .. minetest.pos_to_string(place_to))
 263                 return itemstack, false
 264         end
 265
 266         -- Add node and update
 267         minetest.add_node(place_to, newnode)
 268
 269         local take_item = true
 270
 271         -- Run callback
 272         if def.after_place_node then
 273                 -- Copy place_to because callback can modify it
 274                 local place_to_copy = {x=place_to.x, y=place_to.y, z=place_to.z}
 275                 if def.after_place_node(place_to_copy, placer, itemstack) then
 276                         take_item = false
 277                 end
 278         end
 279
 280         -- Run script hook
 281         local _, callback
 282         for _, callback in ipairs(minetest.registered_on_placenodes) do
 283                 -- Copy pos and node because callback can modify them
 284                 local place_to_copy = {x=place_to.x, y=place_to.y, z=place_to.z}
 285                 local newnode_copy = {name=newnode.name, param1=newnode.param1, param2=newnode.param2}
 286                 local oldnode_copy = {name=oldnode.name, param1=oldnode.param1, param2=oldnode.param2}
 287                 if callback(place_to_copy, newnode_copy, placer, oldnode_copy, itemstack) then
 288                         take_item = false
 289                 end
 290         end
 291
 292         if take_item then
 293                 itemstack:take_item()
 294         end
 295         return itemstack, true
 296 end
 297
 298 function minetest.item_place_object(itemstack, placer, pointed_thing)
 299         local pos = minetest.get_pointed_thing_position(pointed_thing, true)
 300         if pos ~= nil then
 301                 local item = itemstack:take_item()
 302                 minetest.add_item(pos, item)
 303         end
 304         return itemstack
 305 end
 306
 307 function minetest.item_place(itemstack, placer, pointed_thing, param2)
 308         -- Call on_rightclick if the pointed node defines it
 309         if pointed_thing.type == "node" and placer and
 310                         not placer:get_player_control().sneak then
 311                 local n = minetest.get_node(pointed_thing.under)
 312                 local nn = n.name
 313                 if minetest.registered_nodes[nn] and minetest.registered_nodes[nn].on_rightclick then
 314                         return minetest.registered_nodes[nn].on_rightclick(pointed_thing.under, n, placer, itemstack) or itemstack, false
 315                 end
 316         end
 317
 318         if itemstack:get_definition().type == "node" then
 319                 return minetest.item_place_node(itemstack, placer, pointed_thing, param2)
 320         end
 321         return itemstack
 322 end
 323
 324 function minetest.item_drop(itemstack, dropper, pos)
 325         if dropper.get_player_name then
 326                 local v = dropper:get_look_dir()
 327                 local p = {x=pos.x+v.x, y=pos.y+1.5+v.y, z=pos.z+v.z}
 328                 local obj = minetest.add_item(p, itemstack)
 329                 if obj then
 330                         v.x = v.x*2
 331                         v.y = v.y*2 + 1
 332                         v.z = v.z*2
 333                         obj:setvelocity(v)
 334                 end
 335         else
 336                 minetest.add_item(pos, itemstack)
 337         end
 338         return ItemStack("")
 339 end
 340
 341 function minetest.item_eat(hp_change, replace_with_item)
 342         return function(itemstack, user, pointed_thing)  -- closure
 343                 if itemstack:take_item() ~= nil then
 344                         user:set_hp(user:get_hp() + hp_change)
 345                         itemstack:add_item(replace_with_item) -- note: replace_with_item is optional
 346                 end
 347                 return itemstack
 348         end
 349 end
 350
 351 function minetest.node_punch(pos, node, puncher)
 352         -- Run script hook
 353         local _, callback
 354         for _, callback in ipairs(minetest.registered_on_punchnodes) do
 355                 -- Copy pos and node because callback can modify them
 356                 local pos_copy = {x=pos.x, y=pos.y, z=pos.z}
 357                 local node_copy = {name=node.name, param1=node.param1, param2=node.param2}
 358                 callback(pos_copy, node_copy, puncher)
 359         end
 360 end
 361
 362 function minetest.handle_node_drops(pos, drops, digger)
 363         -- Add dropped items to object's inventory
 364         if digger:get_inventory() then
 365                 local _, dropped_item
 366                 for _, dropped_item in ipairs(drops) do
 367                         local left = digger:get_inventory():add_item("main", dropped_item)
 368                         if not left:is_empty() then
 369                                 local p = {
 370                                         x = pos.x + math.random()/2-0.25,
 371                                         y = pos.y + math.random()/2-0.25,
 372                                         z = pos.z + math.random()/2-0.25,
 373                                 }
 374                                 minetest.add_item(p, left)
 375                         end
 376                 end
 377         end
 378 end
 379
 380 function minetest.node_dig(pos, node, digger)
 381         local def = ItemStack({name=node.name}):get_definition()
 382         if not def.diggable or (def.can_dig and not def.can_dig(pos,digger)) then
 383                 minetest.log("info", digger:get_player_name() .. " tried to dig "
 384                         .. node.name .. " which is not diggable "
 385                         .. minetest.pos_to_string(pos))
 386                 return
 387         end
 388
 389         if minetest.is_protected(pos, digger:get_player_name()) then
 390                 minetest.log("action", digger:get_player_name()
 391                                 .. " tried to dig " .. node.name
 392                                 .. " at protected position "
 393                                 .. minetest.pos_to_string(pos))
 394                 minetest.record_protection_violation(pos, digger:get_player_name())
 395                 return
 396         end
 397
 398         minetest.log('action', digger:get_player_name() .. " digs "
 399                 .. node.name .. " at " .. minetest.pos_to_string(pos))
 400
 401         local wielded = digger:get_wielded_item()
 402         local drops = minetest.get_node_drops(node.name, wielded:get_name())
 403
 404         local wdef = wielded:get_definition()
 405         local tp = wielded:get_tool_capabilities()
 406         local dp = minetest.get_dig_params(def.groups, tp)
 407         if wdef and wdef.after_use then
 408                 wielded = wdef.after_use(wielded, digger, node, dp) or wielded
 409         else
 410                 -- Wear out tool
 411                 if not minetest.setting_getbool("creative_mode") then
 412                         wielded:add_wear(dp.wear)
 413                 end
 414         end
 415         digger:set_wielded_item(wielded)
 416
 417         -- Handle drops
 418         minetest.handle_node_drops(pos, drops, digger)
 419
 420         local oldmetadata = nil
 421         if def.after_dig_node then
 422                 oldmetadata = minetest.get_meta(pos):to_table()
 423         end
 424
 425         -- Remove node and update
 426         minetest.remove_node(pos)
 427
 428         -- Run callback
 429         if def.after_dig_node then
 430                 -- Copy pos and node because callback can modify them
 431                 local pos_copy = {x=pos.x, y=pos.y, z=pos.z}
 432                 local node_copy = {name=node.name, param1=node.param1, param2=node.param2}
 433                 def.after_dig_node(pos_copy, node_copy, oldmetadata, digger)
 434         end
 435
 436         -- Run script hook
 437         local _, callback
 438         for _, callback in ipairs(minetest.registered_on_dignodes) do
 439                 -- Copy pos and node because callback can modify them
 440                 local pos_copy = {x=pos.x, y=pos.y, z=pos.z}
 441                 local node_copy = {name=node.name, param1=node.param1, param2=node.param2}
 442                 callback(pos_copy, node_copy, digger)
 443         end
 444 end
 445
 446 -- This is used to allow mods to redefine minetest.item_place and so on
 447 -- NOTE: This is not the preferred way. Preferred way is to provide enough
 448 --       callbacks to not require redefining global functions. -celeron55
 449 local function redef_wrapper(table, name)
 450         return function(...)
 451                 return table[name](...)
 452         end
 453 end
 454
 455 --
 456 -- Item definition defaults
 457 --
 458
 459 minetest.nodedef_default = {
 460         -- Item properties
 461         type="node",
 462         -- name intentionally not defined here
 463         description = "",
 464         groups = {},
 465         inventory_image = "",
 466         wield_image = "",
 467         wield_scale = {x=1,y=1,z=1},
 468         stack_max = 99,
 469         usable = false,
 470         liquids_pointable = false,
 471         tool_capabilities = nil,
 472         node_placement_prediction = nil,
 473
 474         -- Interaction callbacks
 475         on_place = redef_wrapper(minetest, 'item_place'), -- minetest.item_place
 476         on_drop = redef_wrapper(minetest, 'item_drop'), -- minetest.item_drop
 477         on_use = nil,
 478         can_dig = nil,
 479
 480         on_punch = redef_wrapper(minetest, 'node_punch'), -- minetest.node_punch
 481         on_rightclick = nil,
 482         on_dig = redef_wrapper(minetest, 'node_dig'), -- minetest.node_dig
 483
 484         on_receive_fields = nil,
 485
 486         on_metadata_inventory_move = minetest.node_metadata_inventory_move_allow_all,
 487         on_metadata_inventory_offer = minetest.node_metadata_inventory_offer_allow_all,
 488         on_metadata_inventory_take = minetest.node_metadata_inventory_take_allow_all,
 489
 490         -- Node properties
 491         drawtype = "normal",
 492         visual_scale = 1.0,
 493         -- Don't define these because otherwise the old tile_images and
 494         -- special_materials wouldn't be read
 495         --tiles ={""},
 496         --special_tiles = {
 497         --      {name="", backface_culling=true},
 498         --      {name="", backface_culling=true},
 499         --},
 500         alpha = 255,
 501         post_effect_color = {a=0, r=0, g=0, b=0},
 502         paramtype = "none",
 503         paramtype2 = "none",
 504         is_ground_content = true,
 505         sunlight_propagates = false,
 506         walkable = true,
 507         pointable = true,
 508         diggable = true,
 509         climbable = false,
 510         buildable_to = false,
 511         liquidtype = "none",
 512         liquid_alternative_flowing = "",
 513         liquid_alternative_source = "",
 514         liquid_viscosity = 0,
 515         drowning = 0,
 516         light_source = 0,
 517         damage_per_second = 0,
 518         selection_box = {type="regular"},
 519         legacy_facedir_simple = false,
 520         legacy_wallmounted = false,
 521 }
 522
 523 minetest.craftitemdef_default = {
 524         type="craft",
 525         -- name intentionally not defined here
 526         description = "",
 527         groups = {},
 528         inventory_image = "",
 529         wield_image = "",
 530         wield_scale = {x=1,y=1,z=1},
 531         stack_max = 99,
 532         liquids_pointable = false,
 533         tool_capabilities = nil,
 534
 535         -- Interaction callbacks
 536         on_place = redef_wrapper(minetest, 'item_place'), -- minetest.item_place
 537         on_drop = redef_wrapper(minetest, 'item_drop'), -- minetest.item_drop
 538         on_use = nil,
 539 }
 540
 541 minetest.tooldef_default = {
 542         type="tool",
 543         -- name intentionally not defined here
 544         description = "",
 545         groups = {},
 546         inventory_image = "",
 547         wield_image = "",
 548         wield_scale = {x=1,y=1,z=1},
 549         stack_max = 1,
 550         liquids_pointable = false,
 551         tool_capabilities = nil,
 552
 553         -- Interaction callbacks
 554         on_place = redef_wrapper(minetest, 'item_place'), -- minetest.item_place
 555         on_drop = redef_wrapper(minetest, 'item_drop'), -- minetest.item_drop
 556         on_use = nil,
 557 }
 558
 559 minetest.noneitemdef_default = {  -- This is used for the hand and unknown items
 560         type="none",
 561         -- name intentionally not defined here
 562         description = "",
 563         groups = {},
 564         inventory_image = "",
 565         wield_image = "",
 566         wield_scale = {x=1,y=1,z=1},
 567         stack_max = 99,
 568         liquids_pointable = false,
 569         tool_capabilities = nil,
 570
 571         -- Interaction callbacks
 572         on_place = redef_wrapper(minetest, 'item_place'),
 573         on_drop = nil,
 574         on_use = nil,
 575 }
 576