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" and pointed_thing.type == "node" then
 128                 local pos = pointed_thing.above
 129                 local oldnode = minetest.env:get_node(pos)
 130                 local olddef = ItemStack({name=oldnode.name}):get_definition()
 131
 132                 if not olddef.buildable_to then
 133                         minetest.log("info", placer:get_player_name() .. " tried to place"
 134                                 .. " node in invalid position " .. minetest.pos_to_string(pos)
 135                                 .. ", replacing " .. oldnode.name)
 136                         return
 137                 end
 138
 139                 minetest.log("action", placer:get_player_name() .. " places node "
 140                         .. def.name .. " at " .. minetest.pos_to_string(pos))
 141
 142                 local newnode = {name = def.name, param1 = 0, param2 = 0}
 143
 144                 -- Calculate direction for wall mounted stuff like torches and signs
 145                 if def.paramtype2 == 'wallmounted' then
 146                         local under = pointed_thing.under
 147                         local above = pointed_thing.above
 148                         local dir = {x = under.x - above.x, y = under.y - above.y, z = under.z - above.z}
 149                         newnode.param2 = minetest.dir_to_wallmounted(dir)
 150                 -- Calculate the direction for furnaces and chests and stuff
 151                 elseif def.paramtype2 == 'facedir' then
 152                         local placer_pos = placer:getpos()
 153                         if placer_pos then
 154                                 local dir = {x = pos.x - placer_pos.x, y = pos.y - placer_pos.y, z = pos.z - placer_pos.z}
 155                                 newnode.param2 = minetest.dir_to_facedir(dir)
 156                                 minetest.log("action", "facedir: " .. newnode.param2)
 157                         end
 158                 end
 159
 160                 -- Add node and update
 161                 minetest.env:add_node(pos, newnode)
 162
 163                 -- Run callback
 164                 if def.after_place_node then
 165                         def.after_place_node(pos, placer)
 166                 end
 167
 168                 -- Run script hook (deprecated)
 169                 local _, callback
 170                 for _, callback in ipairs(minetest.registered_on_placenodes) do
 171                         callback(pos, newnode, placer)
 172                 end
 173
 174                 itemstack:take_item()
 175         end
 176         return itemstack
 177 end
 178
 179 function minetest.item_place_object(itemstack, placer, pointed_thing)
 180         local pos = minetest.get_pointed_thing_position(pointed_thing, true)
 181         if pos ~= nil then
 182                 local item = itemstack:take_item()
 183                 minetest.env:add_item(pos, item)
 184         end
 185         return itemstack
 186 end
 187
 188 function minetest.item_place(itemstack, placer, pointed_thing)
 189         if itemstack:get_definition().type == "node" then
 190                 return minetest.item_place_node(itemstack, placer, pointed_thing)
 191         else
 192                 return minetest.item_place_object(itemstack, placer, pointed_thing)
 193         end
 194 end
 195
 196 function minetest.item_drop(itemstack, dropper, pos)
 197         if dropper.get_player_name then
 198                 local v = dropper:get_look_dir()
 199                 local p = {x=pos.x+v.x, y=pos.y+1.5+v.y, z=pos.z+v.z}
 200                 local obj = minetest.env:add_item(p, itemstack)
 201                 v.x = v.x*2
 202                 v.y = v.y*2 + 1
 203                 v.z = v.z*2
 204                 obj:setvelocity(v)
 205         else
 206                 minetest.env:add_item(pos, itemstack)
 207         end
 208         return ""
 209 end
 210
 211 function minetest.item_eat(hp_change, replace_with_item)
 212         return function(itemstack, user, pointed_thing)  -- closure
 213                 if itemstack:take_item() ~= nil then
 214                         user:set_hp(user:get_hp() + hp_change)
 215                         itemstack:add_item(replace_with_item) -- note: replace_with_item is optional
 216                 end
 217                 return itemstack
 218         end
 219 end
 220
 221 function minetest.node_punch(pos, node, puncher)
 222         -- Run script hook
 223         local _, callback
 224         for _, callback in ipairs(minetest.registered_on_punchnodes) do
 225                 callback(pos, node, puncher)
 226         end
 227
 228 end
 229
 230 function minetest.node_dig(pos, node, digger)
 231         minetest.debug("node_dig")
 232
 233         local def = ItemStack({name=node.name}):get_definition()
 234         if not def.diggable or (def.can_dig and not def.can_dig(pos,digger)) then
 235                 minetest.debug("not diggable")
 236                 minetest.log("info", digger:get_player_name() .. " tried to dig "
 237                         .. node.name .. " which is not diggable "
 238                         .. minetest.pos_to_string(pos))
 239                 return
 240         end
 241
 242         minetest.log('action', digger:get_player_name() .. " digs "
 243                 .. node.name .. " at " .. minetest.pos_to_string(pos))
 244
 245         if not minetest.setting_getbool("creative_mode") then
 246                 local wielded = digger:get_wielded_item()
 247                 local drops = minetest.get_node_drops(node.name, wielded:get_name())
 248
 249                 -- Wear out tool
 250                 tp = wielded:get_tool_capabilities()
 251                 dp = minetest.get_dig_params(def.groups, tp)
 252                 wielded:add_wear(dp.wear)
 253                 digger:set_wielded_item(wielded)
 254
 255                 -- Add dropped items to object's inventory
 256                 if digger:get_inventory() then
 257                         local _, dropped_item
 258                         for _, dropped_item in ipairs(drops) do
 259                                 digger:get_inventory():add_item("main", dropped_item)
 260                         end
 261                 end
 262         end
 263
 264         local oldnode = nil
 265         local oldmetadata = nil
 266         if def.after_dig_node then
 267                 oldnode = node;
 268                 oldmetadata = minetest.env:get_meta(pos):to_table()
 269         end
 270
 271         -- Remove node and update
 272         minetest.env:remove_node(pos)
 273
 274         -- Run callback
 275         if def.after_dig_node then
 276                 def.after_dig_node(pos, oldnode, oldmetadata, digger)
 277         end
 278
 279         -- Run script hook (deprecated)
 280         local _, callback
 281         for _, callback in ipairs(minetest.registered_on_dignodes) do
 282                 callback(pos, node, digger)
 283         end
 284 end
 285
 286 function minetest.node_metadata_inventory_move_allow_all(pos, from_list,
 287                 from_index, to_list, to_index, count, player)
 288         minetest.log("verbose", "node_metadata_inventory_move_allow_all")
 289         local meta = minetest.env:get_meta(pos)
 290         local inv = meta:get_inventory()
 291
 292         local from_stack = inv:get_stack(from_list, from_index)
 293         local taken_items = from_stack:take_item(count)
 294         inv:set_stack(from_list, from_index, from_stack)
 295
 296         local to_stack = inv:get_stack(to_list, to_index)
 297         to_stack:add_item(taken_items)
 298         inv:set_stack(to_list, to_index, to_stack)
 299 end
 300
 301 function minetest.node_metadata_inventory_offer_allow_all(pos, listname, index, stack, player)
 302         minetest.log("verbose", "node_metadata_inventory_offer_allow_all")
 303         local meta = minetest.env:get_meta(pos)
 304         local inv = meta:get_inventory()
 305         local the_stack = inv:get_stack(listname, index)
 306         the_stack:add_item(stack)
 307         inv:set_stack(listname, index, the_stack)
 308         return ItemStack("")
 309 end
 310
 311 function minetest.node_metadata_inventory_take_allow_all(pos, listname, index, count, player)
 312         minetest.log("verbose", "node_metadata_inventory_take_allow_all")
 313         local meta = minetest.env:get_meta(pos)
 314         local inv = meta:get_inventory()
 315         local the_stack = inv:get_stack(listname, index)
 316         local taken_items = the_stack:take_item(count)
 317         inv:set_stack(listname, index, the_stack)
 318         return taken_items
 319 end
 320
 321 -- This is used to allow mods to redefine minetest.item_place and so on
 322 -- NOTE: This is not the preferred way. Preferred way is to provide enough
 323 --       callbacks to not require redefining global functions. -celeron55
 324 local function redef_wrapper(table, name)
 325         return function(...)
 326                 return table[name](...)
 327         end
 328 end
 329
 330 --
 331 -- Item definition defaults
 332 --
 333
 334 minetest.nodedef_default = {
 335         -- Item properties
 336         type="node",
 337         -- name intentionally not defined here
 338         description = "",
 339         groups = {},
 340         inventory_image = "",
 341         wield_image = "",
 342         wield_scale = {x=1,y=1,z=1},
 343         stack_max = 99,
 344         usable = false,
 345         liquids_pointable = false,
 346         tool_capabilities = nil,
 347         node_placement_prediction = nil,
 348
 349         -- Interaction callbacks
 350         on_place = redef_wrapper(minetest, 'item_place'), -- minetest.item_place
 351         on_drop = redef_wrapper(minetest, 'item_drop'), -- minetest.item_drop
 352         on_use = nil,
 353         can_dig = nil,
 354
 355         on_punch = redef_wrapper(minetest, 'node_punch'), -- minetest.node_punch
 356         on_dig = redef_wrapper(minetest, 'node_dig'), -- minetest.node_dig
 357
 358         on_receive_fields = nil,
 359
 360         on_metadata_inventory_move = minetest.node_metadata_inventory_move_allow_all,
 361         on_metadata_inventory_offer = minetest.node_metadata_inventory_offer_allow_all,
 362         on_metadata_inventory_take = minetest.node_metadata_inventory_take_allow_all,
 363
 364         -- Node properties
 365         drawtype = "normal",
 366         visual_scale = 1.0,
 367         -- Don't define these because otherwise the old tile_images and
 368         -- special_materials wouldn't be read
 369         --tiles ={""},
 370         --special_tiles = {
 371         --      {name="", backface_culling=true},
 372         --      {name="", backface_culling=true},
 373         --},
 374         alpha = 255,
 375         post_effect_color = {a=0, r=0, g=0, b=0},
 376         paramtype = "none",
 377         paramtype2 = "none",
 378         is_ground_content = false,
 379         sunlight_propagates = false,
 380         walkable = true,
 381         pointable = true,
 382         diggable = true,
 383         climbable = false,
 384         buildable_to = false,
 385         liquidtype = "none",
 386         liquid_alternative_flowing = "",
 387         liquid_alternative_source = "",
 388         liquid_viscosity = 0,
 389         light_source = 0,
 390         damage_per_second = 0,
 391         selection_box = {type="regular"},
 392         legacy_facedir_simple = false,
 393         legacy_wallmounted = false,
 394 }
 395
 396 minetest.craftitemdef_default = {
 397         type="craft",
 398         -- name intentionally not defined here
 399         description = "",
 400         groups = {},
 401         inventory_image = "",
 402         wield_image = "",
 403         wield_scale = {x=1,y=1,z=1},
 404         stack_max = 99,
 405         liquids_pointable = false,
 406         tool_capabilities = nil,
 407
 408         -- Interaction callbacks
 409         on_place = redef_wrapper(minetest, 'item_place'), -- minetest.item_place
 410         on_drop = redef_wrapper(minetest, 'item_drop'), -- minetest.item_drop
 411         on_use = nil,
 412 }
 413
 414 minetest.tooldef_default = {
 415         type="tool",
 416         -- name intentionally not defined here
 417         description = "",
 418         groups = {},
 419         inventory_image = "",
 420         wield_image = "",
 421         wield_scale = {x=1,y=1,z=1},
 422         stack_max = 1,
 423         liquids_pointable = false,
 424         tool_capabilities = nil,
 425
 426         -- Interaction callbacks
 427         on_place = redef_wrapper(minetest, 'item_place'), -- minetest.item_place
 428         on_drop = redef_wrapper(minetest, 'item_drop'), -- minetest.item_drop
 429         on_use = nil,
 430 }
 431
 432 minetest.noneitemdef_default = {  -- This is used for the hand and unknown items
 433         type="none",
 434         -- name intentionally not defined here
 435         description = "",
 436         groups = {},
 437         inventory_image = "",
 438         wield_image = "",
 439         wield_scale = {x=1,y=1,z=1},
 440         stack_max = 99,
 441         liquids_pointable = false,
 442         tool_capabilities = nil,
 443
 444         -- Interaction callbacks
 445         on_place = nil,
 446         on_drop = nil,
 447         on_use = nil,
 448 }
 449