builtin/game/item.lua

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