data/builtin.lua

   1 --
   2 -- This file contains built-in stuff in Minetest implemented in Lua.
   3 --
   4 -- It is always loaded and executed after registration of the C API,
   5 -- before loading and running any mods.
   6 --
   7
   8 function basic_dump2(o)
   9         if type(o) == "number" then
  10                 return tostring(o)
  11         elseif type(o) == "string" then
  12                 return string.format("%q", o)
  13         elseif type(o) == "boolean" then
  14                 return tostring(o)
  15         elseif type(o) == "function" then
  16                 return "<function>"
  17         elseif type(o) == "userdata" then
  18                 return "<userdata>"
  19         elseif type(o) == "nil" then
  20                 return "nil"
  21         else
  22                 error("cannot dump a " .. type(o))
  23                 return nil
  24         end
  25 end
  26
  27 function dump2(o, name, dumped)
  28         name = name or "_"
  29         dumped = dumped or {}
  30         io.write(name, " = ")
  31         if type(o) == "number" or type(o) == "string" or type(o) == "boolean"
  32                         or type(o) == "function" or type(o) == "nil"
  33                         or type(o) == "userdata" then
  34                 io.write(basic_dump2(o), "\n")
  35         elseif type(o) == "table" then
  36                 if dumped[o] then
  37                         io.write(dumped[o], "\n")
  38                 else
  39                         dumped[o] = name
  40                         io.write("{}\n") -- new table
  41                         for k,v in pairs(o) do
  42                                 local fieldname = string.format("%s[%s]", name, basic_dump2(k))
  43                                 dump2(v, fieldname, dumped)
  44                         end
  45                 end
  46         else
  47                 error("cannot dump a " .. type(o))
  48                 return nil
  49         end
  50 end
  51
  52 function dump(o, dumped)
  53         dumped = dumped or {}
  54         if type(o) == "number" then
  55                 return tostring(o)
  56         elseif type(o) == "string" then
  57                 return string.format("%q", o)
  58         elseif type(o) == "table" then
  59                 if dumped[o] then
  60                         return "<circular reference>"
  61                 end
  62                 dumped[o] = true
  63                 local t = {}
  64                 for k,v in pairs(o) do
  65                         t[#t+1] = "" .. k .. " = " .. dump(v, dumped)
  66                 end
  67                 return "{" .. table.concat(t, ", ") .. "}"
  68         elseif type(o) == "boolean" then
  69                 return tostring(o)
  70         elseif type(o) == "function" then
  71                 return "<function>"
  72         elseif type(o) == "userdata" then
  73                 return "<userdata>"
  74         elseif type(o) == "nil" then
  75                 return "nil"
  76         else
  77                 error("cannot dump a " .. type(o))
  78                 return nil
  79         end
  80 end
  81
  82 --
  83 -- Item definition helpers
  84 --
  85
  86 function minetest.inventorycube(img1, img2, img3)
  87         img2 = img2 or img1
  88         img3 = img3 or img1
  89         return "[inventorycube"
  90                         .. "{" .. img1:gsub("%^", "&")
  91                         .. "{" .. img2:gsub("%^", "&")
  92                         .. "{" .. img3:gsub("%^", "&")
  93 end
  94
  95 function minetest.pos_to_string(pos)
  96         return "(" .. pos.x .. "," .. pos.y .. "," .. pos.z .. ")"
  97 end
  98
  99 function minetest.get_pointed_thing_position(pointed_thing, above)
 100         if pointed_thing.type == "node" then
 101                 if above then
 102                         -- The position where a node would be placed
 103                         return pointed_thing.above
 104                 else
 105                         -- The position where a node would be dug
 106                         return pointed_thing.under
 107                 end
 108         elseif pointed_thing.type == "object" then
 109                 obj = pointed.thing.ref
 110                 if obj ~= nil then
 111                         return obj:getpos()
 112                 else
 113                         return nil
 114                 end
 115         else
 116                 return nil
 117         end
 118 end
 119
 120 function minetest.dir_to_facedir(dir)
 121         if math.abs(dir.x) > math.abs(dir.z) then
 122                 if dir.x < 0 then
 123                         return 3
 124                 else
 125                         return 1
 126                 end
 127         else
 128                 if dir.z < 0 then
 129                         return 2
 130                 else
 131                         return 0
 132                 end
 133         end
 134 end
 135
 136 function minetest.dir_to_wallmounted(dir)
 137         if math.abs(dir.y) > math.max(math.abs(dir.x), math.abs(dir.z)) then
 138                 if dir.y < 0 then
 139                         return 1
 140                 else
 141                         return 0
 142                 end
 143         elseif math.abs(dir.x) > math.abs(dir.z) then
 144                 if dir.x < 0 then
 145                         return 3
 146                 else
 147                         return 2
 148                 end
 149         else
 150                 if dir.z < 0 then
 151                         return 5
 152                 else
 153                         return 4
 154                 end
 155         end
 156 end
 157
 158 function minetest.get_node_drops(nodename, toolname)
 159         local drop = ItemStack({name=nodename}):get_definition().drop
 160         if drop == nil then
 161                 -- default drop
 162                 print("default drop: " .. nodename)
 163                 return {ItemStack({name=nodename})}
 164         elseif type(drop) == "string" then
 165                 -- itemstring drop
 166                 return {ItemStack(drop)}
 167         elseif drop.items == nil then
 168                 -- drop = {} to disable default drop
 169                 return {}
 170         end
 171
 172         -- Extended drop table
 173         local got_items = {}
 174         local got_count = 0
 175         local _, item, tool
 176         for _, item in ipairs(drop.items) do
 177                 local good_rarity = true
 178                 local good_tool = true
 179                 if item.rarity ~= nil then
 180                         good_rarity = item.rarity < 1 or math.random(item.rarity) == 1
 181                 end
 182                 if item.tools ~= nil then
 183                         good_tool = false
 184                         for _, tool in ipairs(item.tools) do
 185                                 if tool:sub(1, 1) == '~' then
 186                                         good_tool = toolname:find(tool:sub(2)) ~= nil
 187                                 else
 188                                         good_tool = toolname == tool
 189                                 end
 190                                 if good_tool then
 191                                         break
 192                                 end
 193                         end
 194                 end
 195                 if good_rarity and good_tool then
 196                         got_count = got_count + 1
 197                         for _, add_item in ipairs(item.items) do
 198                                 got_items[#got_items+1] = add_item
 199                         end
 200                         if drop.max_items ~= nil and got_count == drop.max_items then
 201                                 break
 202                         end
 203                 end
 204         end
 205         return got_items
 206 end
 207
 208 function minetest.item_place_node(itemstack, placer, pointed_thing)
 209         local item = itemstack:peek_item()
 210         local def = itemstack:get_definition()
 211         if def.type == "node" and pointed_thing.type == "node" then
 212                 local pos = pointed_thing.above
 213                 local oldnode = minetest.env:get_node(pos)
 214                 local olddef = ItemStack({name=oldnode.name}):get_definition()
 215
 216                 if not olddef.buildable_to then
 217                         minetest.log("info", placer:get_player_name() .. " tried to place"
 218                                 .. " node in invalid position " .. minetest.pos_to_string(pos)
 219                                 .. ", replacing " .. oldnode.name)
 220                         return
 221                 end
 222
 223                 minetest.log("action", placer:get_player_name() .. " places node "
 224                         .. def.name .. " at " .. minetest.pos_to_string(pos))
 225
 226                 local newnode = {name = def.name, param1 = 0, param2 = 0}
 227
 228                 -- Calculate direction for wall mounted stuff like torches and signs
 229                 if def.paramtype2 == 'wallmounted' then
 230                         local under = pointed_thing.under
 231                         local above = pointed_thing.above
 232                         local dir = {x = under.x - above.x, y = under.y - above.y, z = under.z - above.z}
 233                         newnode.param2 = minetest.dir_to_wallmounted(dir)
 234                 -- Calculate the direction for furnaces and chests and stuff
 235                 elseif def.paramtype2 == 'facedir' then
 236                         local playerpos = placer:getpos()
 237                         local dir = {x = pos.x - playerpos.x, y = pos.y - playerpos.y, z = pos.z - playerpos.z}
 238                         newnode.param2 = minetest.dir_to_facedir(dir)
 239                         minetest.log("action", "facedir: " .. newnode.param2)
 240                 end
 241
 242                 -- Add node and update
 243                 minetest.env:add_node(pos, newnode)
 244
 245                 -- Set metadata owner
 246                 if def.metadata_name ~= "" then
 247                         minetest.env:get_meta(pos):set_owner(placer:get_player_name())
 248                 end
 249
 250                 -- Run script hook
 251                 local _, callback
 252                 for _, callback in ipairs(minetest.registered_on_placenodes) do
 253                         callback(pos, newnode, placer)
 254                 end
 255
 256                 itemstack:take_item()
 257         end
 258         return itemstack
 259 end
 260
 261 function minetest.item_place_object(itemstack, placer, pointed_thing)
 262         local pos = minetest.get_pointed_thing_position(pointed_thing, true)
 263         if pos ~= nil then
 264                 local item = itemstack:take_item()
 265                 minetest.env:add_item(pos, item)
 266         end
 267         return itemstack
 268 end
 269
 270 function minetest.item_place(itemstack, placer, pointed_thing)
 271         if itemstack:get_definition().type == "node" then
 272                 return minetest.item_place_node(itemstack, placer, pointed_thing)
 273         else
 274                 return minetest.item_place_object(itemstack, placer, pointed_thing)
 275         end
 276 end
 277
 278 function minetest.item_drop(itemstack, dropper, pos)
 279         minetest.env:add_item(pos, itemstack)
 280         return ""
 281 end
 282
 283 function minetest.item_eat(hp_change, replace_with_item)
 284         return function(itemstack, user, pointed_thing)  -- closure
 285                 if itemstack:take_item() ~= nil then
 286                         user:set_hp(user:get_hp() + hp_change)
 287                         itemstack:add_item(replace_with_item) -- note: replace_with_item is optional
 288                 end
 289                 return itemstack
 290         end
 291 end
 292
 293 function minetest.node_punch(pos, node, puncher)
 294         -- Run script hook
 295         local _, callback
 296         for _, callback in ipairs(minetest.registered_on_punchnodes) do
 297                 callback(pos, node, puncher)
 298         end
 299
 300 end
 301
 302 function minetest.node_dig(pos, node, digger)
 303         minetest.debug("node_dig")
 304
 305         local def = ItemStack({name=node.name}):get_definition()
 306         if not def.diggable then
 307                 minetest.debug("not diggable")
 308                 minetest.log("info", digger:get_player_name() .. " tried to dig "
 309                         .. node.name .. " which is not diggable "
 310                         .. minetest.pos_to_string(pos))
 311                 return
 312         end
 313
 314         local meta = minetest.env:get_meta(pos)
 315         if meta ~= nil and not meta:get_allow_removal() then
 316                 minetest.debug("dig prevented by metadata")
 317                 minetest.log("info", digger:get_player_name() .. " tried to dig "
 318                         .. node.name .. ", but removal is disabled by metadata "
 319                         .. minetest.pos_to_string(pos))
 320                 return
 321         end
 322
 323         minetest.log('action', digger:get_player_name() .. " digs "
 324                 .. node.name .. " at " .. minetest.pos_to_string(pos))
 325
 326         if not minetest.setting_getbool("creative_mode") then
 327                 local wielded = digger:get_wielded_item()
 328                 local drops = minetest.get_node_drops(node.name, wielded:get_name())
 329
 330                 -- Wear out tool
 331                 mp = def.material
 332                 tp = wielded:get_tool_digging_properties()
 333                 dp = minetest.get_digging_properties(mp, tp)
 334                 wielded:add_wear(dp.wear)
 335                 digger:set_wielded_item(wielded)
 336
 337                 -- Add dropped items
 338                 local _, dropped_item
 339                 for _, dropped_item in ipairs(drops) do
 340                         digger:get_inventory():add_item("main", dropped_item)
 341                 end
 342         end
 343
 344         -- Remove node and update
 345         minetest.env:remove_node(pos)
 346
 347         -- Run script hook
 348         local _, callback
 349         for _, callback in ipairs(minetest.registered_on_dignodes) do
 350                 callback(pos, node, digger)
 351         end
 352 end
 353
 354 --
 355 -- Item definition defaults
 356 --
 357
 358 minetest.nodedef_default = {
 359         -- Item properties
 360         type="node",
 361         -- name intentionally not defined here
 362         description = "",
 363         inventory_image = "",
 364         wield_image = "",
 365         wield_scale = {x=1,y=1,z=1},
 366         stack_max = 99,
 367         usable = false,
 368         liquids_pointable = false,
 369         tool_digging_properties = nil,
 370
 371         -- Interaction callbacks
 372         on_place = minetest.item_place,
 373         on_drop = minetest.item_drop,
 374         on_use = nil,
 375
 376         on_punch = minetest.node_punch,
 377         on_dig = minetest.node_dig,
 378
 379         -- Node properties
 380         drawtype = "normal",
 381         visual_scale = 1.0,
 382         tile_images = {""},
 383         special_materials = {
 384                 {image="", backface_culling=true},
 385                 {image="", backface_culling=true},
 386         },
 387         alpha = 255,
 388         post_effect_color = {a=0, r=0, g=0, b=0},
 389         paramtype = "none",
 390         paramtype2 = "none",
 391         is_ground_content = false,
 392         sunlight_propagates = false,
 393         walkable = true,
 394         pointable = true,
 395         diggable = true,
 396         climbable = false,
 397         buildable_to = false,
 398         metadata_name = "",
 399         liquidtype = "none",
 400         liquid_alternative_flowing = "",
 401         liquid_alternative_source = "",
 402         liquid_viscosity = 0,
 403         light_source = 0,
 404         damage_per_second = 0,
 405         selection_box = {type="regular"},
 406         material = {
 407                 diggablity = "normal",
 408                 weight = 0,
 409                 crackiness = 0,
 410                 crumbliness = 0,
 411                 cuttability = 0,
 412                 flammability = 0,
 413         },
 414         legacy_facedir_simple = false,
 415         legacy_wallmounted = false,
 416 }
 417
 418 minetest.craftitemdef_default = {
 419         type="craft",
 420         -- name intentionally not defined here
 421         description = "",
 422         inventory_image = "",
 423         wield_image = "",
 424         wield_scale = {x=1,y=1,z=1},
 425         stack_max = 99,
 426         liquids_pointable = false,
 427         tool_digging_properties = nil,
 428
 429         -- Interaction callbacks
 430         on_place = minetest.item_place,
 431         on_drop = minetest.item_drop,
 432         on_use = nil,
 433 }
 434
 435 minetest.tooldef_default = {
 436         type="tool",
 437         -- name intentionally not defined here
 438         description = "",
 439         inventory_image = "",
 440         wield_image = "",
 441         wield_scale = {x=1,y=1,z=1},
 442         stack_max = 1,
 443         liquids_pointable = false,
 444         tool_digging_properties = nil,
 445
 446         -- Interaction callbacks
 447         on_place = minetest.item_place,
 448         on_drop = minetest.item_drop,
 449         on_use = nil,
 450 }
 451
 452 minetest.noneitemdef_default = {  -- This is used for the hand and unknown items
 453         type="none",
 454         -- name intentionally not defined here
 455         description = "",
 456         inventory_image = "",
 457         wield_image = "",
 458         wield_scale = {x=1,y=1,z=1},
 459         stack_max = 99,
 460         liquids_pointable = false,
 461         tool_digging_properties = nil,
 462
 463         -- Interaction callbacks
 464         on_place = nil,
 465         on_drop = nil,
 466         on_use = nil,
 467 }
 468
 469 --
 470 -- Make raw registration functions inaccessible to anyone except builtin.lua
 471 --
 472
 473 local register_item_raw = minetest.register_item_raw
 474 minetest.register_item_raw = nil
 475
 476 local register_alias_raw = minetest.register_alias_raw
 477 minetest.register_item_raw = nil
 478
 479 --
 480 -- Item / entity / ABM registration functions
 481 --
 482
 483 minetest.registered_abms = {}
 484 minetest.registered_entities = {}
 485 minetest.registered_items = {}
 486 minetest.registered_nodes = {}
 487 minetest.registered_craftitems = {}
 488 minetest.registered_tools = {}
 489 minetest.registered_aliases = {}
 490
 491 -- For tables that are indexed by item name:
 492 -- If table[X] does not exist, default to table[minetest.registered_aliases[X]]
 493 local function set_alias_metatable(table)
 494         setmetatable(table, {
 495                 __index = function(name)
 496                         return rawget(table, minetest.registered_aliases[name])
 497                 end
 498         })
 499 end
 500 set_alias_metatable(minetest.registered_items)
 501 set_alias_metatable(minetest.registered_nodes)
 502 set_alias_metatable(minetest.registered_craftitems)
 503 set_alias_metatable(minetest.registered_tools)
 504
 505 -- These item names may not be used because they would interfere
 506 -- with legacy itemstrings
 507 local forbidden_item_names = {
 508         MaterialItem = true,
 509         MaterialItem2 = true,
 510         MaterialItem3 = true,
 511         NodeItem = true,
 512         node = true,
 513         CraftItem = true,
 514         craft = true,
 515         MBOItem = true,
 516         ToolItem = true,
 517         tool = true,
 518 }
 519
 520 local function check_modname_prefix(name)
 521         if name:sub(1,1) == ":" then
 522                 -- Escape the modname prefix enforcement mechanism
 523                 return name:sub(2)
 524         else
 525                 -- Modname prefix enforcement
 526                 local expected_prefix = minetest.get_current_modname() .. ":"
 527                 if name:sub(1, #expected_prefix) ~= expected_prefix then
 528                         error("Name " .. name .. " does not follow naming conventions: " ..
 529                                 "\"modname:\" or \":\" prefix required")
 530                 end
 531                 local subname = name:sub(#expected_prefix+1)
 532                 if subname:find("[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]") then
 533                         error("Name " .. name .. " does not follow naming conventions: " ..
 534                                 "contains unallowed characters")
 535                 end
 536                 return name
 537         end
 538 end
 539
 540 function minetest.register_abm(spec)
 541         -- Add to minetest.registered_abms
 542         minetest.registered_abms[#minetest.registered_abms+1] = spec
 543 end
 544
 545 function minetest.register_entity(name, prototype)
 546         -- Check name
 547         if name == nil then
 548                 error("Unable to register entity: Name is nil")
 549         end
 550         name = check_modname_prefix(tostring(name))
 551
 552         prototype.name = name
 553         prototype.__index = prototype  -- so that it can be used as a metatable
 554
 555         -- Add to minetest.registered_entities
 556         minetest.registered_entities[name] = prototype
 557 end
 558
 559 function minetest.register_item(name, itemdef)
 560         -- Check name
 561         if name == nil then
 562                 error("Unable to register item: Name is nil")
 563         end
 564         name = check_modname_prefix(tostring(name))
 565         if forbidden_item_names[name] then
 566                 error("Unable to register item: Name is forbidden: " .. name)
 567         end
 568         itemdef.name = name
 569
 570         -- Apply defaults and add to registered_* table
 571         if itemdef.type == "node" then
 572                 setmetatable(itemdef, {__index = minetest.nodedef_default})
 573                 minetest.registered_nodes[itemdef.name] = itemdef
 574         elseif itemdef.type == "craft" then
 575                 setmetatable(itemdef, {__index = minetest.craftitemdef_default})
 576                 minetest.registered_craftitems[itemdef.name] = itemdef
 577         elseif itemdef.type == "tool" then
 578                 setmetatable(itemdef, {__index = minetest.tooldef_default})
 579                 minetest.registered_tools[itemdef.name] = itemdef
 580         elseif itemdef.type == "none" then
 581                 setmetatable(itemdef, {__index = minetest.noneitemdef_default})
 582         else
 583                 error("Unable to register item: Type is invalid: " .. dump(itemdef))
 584         end
 585
 586         -- Flowing liquid uses param2
 587         if itemdef.type == "node" and itemdef.liquidtype == "flowing" then
 588                 itemdef.paramtype2 = "flowingliquid"
 589         end
 590
 591         -- BEGIN Legacy stuff
 592         if itemdef.cookresult_itemstring ~= nil and itemdef.cookresult_itemstring ~= "" then
 593                 minetest.register_craft({
 594                         type="cooking",
 595                         output=itemdef.cookresult_itemstring,
 596                         recipe=itemdef.name,
 597                         cooktime=itemdef.furnace_cooktime
 598                 })
 599         end
 600         if itemdef.furnace_burntime ~= nil and itemdef.furnace_burntime >= 0 then
 601                 minetest.register_craft({
 602                         type="fuel",
 603                         recipe=itemdef.name,
 604                         burntime=itemdef.furnace_burntime
 605                 })
 606         end
 607         -- END Legacy stuff
 608
 609         -- Disable all further modifications
 610         getmetatable(itemdef).__newindex = {}
 611
 612         --minetest.log("Registering item: " .. itemdef.name)
 613         minetest.registered_items[itemdef.name] = itemdef
 614         minetest.registered_aliases[itemdef.name] = nil
 615         register_item_raw(itemdef)
 616 end
 617
 618 function minetest.register_node(name, nodedef)
 619         nodedef.type = "node"
 620         minetest.register_item(name, nodedef)
 621 end
 622
 623 function minetest.register_craftitem(name, craftitemdef)
 624         craftitemdef.type = "craft"
 625
 626         -- BEGIN Legacy stuff
 627         if craftitemdef.inventory_image == nil and craftitemdef.image ~= nil then
 628                 craftitemdef.inventory_image = craftitemdef.image
 629         end
 630         -- END Legacy stuff
 631
 632         minetest.register_item(name, craftitemdef)
 633 end
 634
 635 function minetest.register_tool(name, tooldef)
 636         tooldef.type = "tool"
 637         tooldef.stack_max = 1
 638
 639         -- BEGIN Legacy stuff
 640         if tooldef.inventory_image == nil and tooldef.image ~= nil then
 641                 tooldef.inventory_image = tooldef.image
 642         end
 643         if tooldef.tool_digging_properties == nil and
 644            (tooldef.full_punch_interval ~= nil or
 645             tooldef.basetime ~= nil or
 646             tooldef.dt_weight ~= nil or
 647             tooldef.dt_crackiness ~= nil or
 648             tooldef.dt_crumbliness ~= nil or
 649             tooldef.dt_cuttability ~= nil or
 650             tooldef.basedurability ~= nil or
 651             tooldef.dd_weight ~= nil or
 652             tooldef.dd_crackiness ~= nil or
 653             tooldef.dd_crumbliness ~= nil or
 654             tooldef.dd_cuttability ~= nil) then
 655                 tooldef.tool_digging_properties = {
 656                         full_punch_interval = tooldef.full_punch_interval,
 657                         basetime = tooldef.basetime,
 658                         dt_weight = tooldef.dt_weight,
 659                         dt_crackiness = tooldef.dt_crackiness,
 660                         dt_crumbliness = tooldef.dt_crumbliness,
 661                         dt_cuttability = tooldef.dt_cuttability,
 662                         basedurability = tooldef.basedurability,
 663                         dd_weight = tooldef.dd_weight,
 664                         dd_crackiness = tooldef.dd_crackiness,
 665                         dd_crumbliness = tooldef.dd_crumbliness,
 666                         dd_cuttability = tooldef.dd_cuttability,
 667                 }
 668         end
 669         -- END Legacy stuff
 670
 671         minetest.register_item(name, tooldef)
 672 end
 673
 674 function minetest.register_alias(name, convert_to)
 675         if forbidden_item_names[name] then
 676                 error("Unable to register alias: Name is forbidden: " .. name)
 677         end
 678         if minetest.registered_items[name] ~= nil then
 679                 minetest.log("WARNING: Not registering alias, item with same name" ..
 680                         " is already defined: " .. name .. " -> " .. convert_to)
 681         else
 682                 --minetest.log("Registering alias: " .. name .. " -> " .. convert_to)
 683                 minetest.registered_aliases[name] = convert_to
 684                 register_alias_raw(name, convert_to)
 685         end
 686 end
 687
 688 -- Alias the forbidden item names to "" so they can't be
 689 -- created via itemstrings (e.g. /give)
 690 local name
 691 for name in pairs(forbidden_item_names) do
 692         minetest.registered_aliases[name] = ""
 693         register_alias_raw(name, "")
 694 end
 695
 696
 697 -- Deprecated:
 698 -- Aliases for minetest.register_alias (how ironic...)
 699 --minetest.alias_node = minetest.register_alias
 700 --minetest.alias_tool = minetest.register_alias
 701 --minetest.alias_craftitem = minetest.register_alias
 702
 703 --
 704 -- Built-in node definitions. Also defined in C.
 705 --
 706
 707 minetest.register_item(":", {
 708         type = "none",
 709         wield_image = "wieldhand.png",
 710         wield_scale = {x=1,y=1,z=2.5},
 711         tool_digging_properties = {
 712                 full_punch_interval = 2.0,
 713                 basetime = 0.5,
 714                 dt_weight = 1,
 715                 dt_crackiness = 0,
 716                 dt_crumbliness = -1,
 717                 dt_cuttability = 0,
 718                 basedurability = 50,
 719                 dd_weight = 0,
 720                 dd_crackiness = 0,
 721                 dd_crumbliness = 0,
 722                 dd_cuttability = 0,
 723         }
 724 })
 725
 726 minetest.register_item(":unknown", {
 727         type = "none",
 728         description = "Unknown Item",
 729         inventory_image = "unknown_item.png",
 730         on_place = minetest.item_place,
 731         on_drop = minetest.item_drop,
 732 })
 733
 734 minetest.register_node(":air", {
 735         description = "Air (you hacker you!)",
 736         inventory_image = "unknown_block.png",
 737         wield_image = "unknown_block.png",
 738         drawtype = "airlike",
 739         paramtype = "light",
 740         sunlight_propagates = true,
 741         walkable = false,
 742         pointable = false,
 743         diggable = false,
 744         buildable_to = true,
 745         air_equivalent = true,
 746 })
 747
 748 minetest.register_node(":ignore", {
 749         description = "Ignore (you hacker you!)",
 750         inventory_image = "unknown_block.png",
 751         wield_image = "unknown_block.png",
 752         drawtype = "airlike",
 753         paramtype = "none",
 754         sunlight_propagates = false,
 755         walkable = false,
 756         pointable = false,
 757         diggable = false,
 758         buildable_to = true, -- A way to remove accidentally placed ignores
 759         air_equivalent = true,
 760 })
 761
 762 --
 763 -- Default material types
 764 --
 765
 766 function minetest.digprop_constanttime(time)
 767         return {
 768                 diggability = "constant",
 769                 constant_time = time,
 770         }
 771 end
 772
 773 function minetest.digprop_stonelike(toughness)
 774         return {
 775                 diggablity = "normal",
 776                 weight = toughness * 5,
 777                 crackiness = 1,
 778                 crumbliness = -0.1,
 779                 cuttability = -0.2,
 780         }
 781 end
 782
 783 function minetest.digprop_dirtlike(toughness)
 784         return {
 785                 diggablity = "normal",
 786                 weight = toughness * 1.2,
 787                 crackiness = 0,
 788                 crumbliness = 1.2,
 789                 cuttability = -0.4,
 790         }
 791 end
 792
 793 function minetest.digprop_gravellike(toughness)
 794         return {
 795                 diggablity = "normal",
 796                 weight = toughness * 2,
 797                 crackiness = 0.2,
 798                 crumbliness = 1.5,
 799                 cuttability = -1.0,
 800         }
 801 end
 802
 803 function minetest.digprop_woodlike(toughness)
 804         return {
 805                 diggablity = "normal",
 806                 weight = toughness * 1.0,
 807                 crackiness = 0.75,
 808                 crumbliness = -1.0,
 809                 cuttability = 1.5,
 810         }
 811 end
 812
 813 function minetest.digprop_leaveslike(toughness)
 814         return {
 815                 diggablity = "normal",
 816                 weight = toughness * (-0.5),
 817                 crackiness = 0,
 818                 crumbliness = 0,
 819                 cuttability = 2.0,
 820         }
 821 end
 822
 823 function minetest.digprop_glasslike(toughness)
 824         return {
 825                 diggablity = "normal",
 826                 weight = toughness * 0.1,
 827                 crackiness = 2.0,
 828                 crumbliness = -1.0,
 829                 cuttability = -1.0,
 830         }
 831 end
 832
 833 --
 834 -- Creative inventory
 835 --
 836
 837 minetest.creative_inventory = {}
 838
 839 minetest.add_to_creative_inventory = function(itemstring)
 840         table.insert(minetest.creative_inventory, itemstring)
 841 end
 842
 843 --
 844 -- Callback registration
 845 --
 846
 847 local function make_registration()
 848         local t = {}
 849         local registerfunc = function(func) table.insert(t, func) end
 850         return t, registerfunc
 851 end
 852
 853 minetest.registered_on_chat_messages, minetest.register_on_chat_message = make_registration()
 854 minetest.registered_globalsteps, minetest.register_globalstep = make_registration()
 855 minetest.registered_on_placenodes, minetest.register_on_placenode = make_registration()
 856 minetest.registered_on_dignodes, minetest.register_on_dignode = make_registration()
 857 minetest.registered_on_punchnodes, minetest.register_on_punchnode = make_registration()
 858 minetest.registered_on_generateds, minetest.register_on_generated = make_registration()
 859 minetest.registered_on_newplayers, minetest.register_on_newplayer = make_registration()
 860 minetest.registered_on_dieplayers, minetest.register_on_dieplayer = make_registration()
 861 minetest.registered_on_respawnplayers, minetest.register_on_respawnplayer = make_registration()
 862
 863 --
 864 -- Set random seed
 865 --
 866
 867 math.randomseed(os.time())
 868
 869 -- END