builtin/game/register.lua

   1 -- Minetest: builtin/misc_register.lua
   2
   3 --
   4 -- Make raw registration functions inaccessible to anyone except this file
   5 --
   6
   7 local register_item_raw = core.register_item_raw
   8 core.register_item_raw = nil
   9
  10 local unregister_item_raw = core.unregister_item_raw
  11 core.unregister_item_raw = nil
  12
  13 local register_alias_raw = core.register_alias_raw
  14 core.register_alias_raw = nil
  15
  16 --
  17 -- Item / entity / ABM / LBM registration functions
  18 --
  19
  20 core.registered_abms = {}
  21 core.registered_lbms = {}
  22 core.registered_entities = {}
  23 core.registered_items = {}
  24 core.registered_nodes = {}
  25 core.registered_craftitems = {}
  26 core.registered_tools = {}
  27 core.registered_aliases = {}
  28
  29 -- For tables that are indexed by item name:
  30 -- If table[X] does not exist, default to table[core.registered_aliases[X]]
  31 local alias_metatable = {
  32         __index = function(t, name)
  33                 return rawget(t, core.registered_aliases[name])
  34         end
  35 }
  36 setmetatable(core.registered_items, alias_metatable)
  37 setmetatable(core.registered_nodes, alias_metatable)
  38 setmetatable(core.registered_craftitems, alias_metatable)
  39 setmetatable(core.registered_tools, alias_metatable)
  40
  41 -- These item names may not be used because they would interfere
  42 -- with legacy itemstrings
  43 local forbidden_item_names = {
  44         MaterialItem = true,
  45         MaterialItem2 = true,
  46         MaterialItem3 = true,
  47         NodeItem = true,
  48         node = true,
  49         CraftItem = true,
  50         craft = true,
  51         MBOItem = true,
  52         ToolItem = true,
  53         tool = true,
  54 }
  55
  56 local function check_modname_prefix(name)
  57         if name:sub(1,1) == ":" then
  58                 -- If the name starts with a colon, we can skip the modname prefix
  59                 -- mechanism.
  60                 return name:sub(2)
  61         else
  62                 -- Enforce that the name starts with the correct mod name.
  63                 local expected_prefix = core.get_current_modname() .. ":"
  64                 if name:sub(1, #expected_prefix) ~= expected_prefix then
  65                         error("Name " .. name .. " does not follow naming conventions: " ..
  66                                 "\"" .. expected_prefix .. "\" or \":\" prefix required")
  67                 end
  68
  69                 -- Enforce that the name only contains letters, numbers and underscores.
  70                 local subname = name:sub(#expected_prefix+1)
  71                 if subname:find("[^%w_]") then
  72                         error("Name " .. name .. " does not follow naming conventions: " ..
  73                                 "contains unallowed characters")
  74                 end
  75
  76                 return name
  77         end
  78 end
  79
  80 function core.register_abm(spec)
  81         -- Add to core.registered_abms
  82         core.registered_abms[#core.registered_abms + 1] = spec
  83         spec.mod_origin = core.get_current_modname() or "??"
  84 end
  85
  86 function core.register_lbm(spec)
  87         -- Add to core.registered_lbms
  88         check_modname_prefix(spec.name)
  89         core.registered_lbms[#core.registered_lbms + 1] = spec
  90         spec.mod_origin = core.get_current_modname() or "??"
  91 end
  92
  93 function core.register_entity(name, prototype)
  94         -- Check name
  95         if name == nil then
  96                 error("Unable to register entity: Name is nil")
  97         end
  98         name = check_modname_prefix(tostring(name))
  99
 100         prototype.name = name
 101         prototype.__index = prototype  -- so that it can be used as a metatable
 102
 103         -- Add to core.registered_entities
 104         core.registered_entities[name] = prototype
 105         prototype.mod_origin = core.get_current_modname() or "??"
 106 end
 107
 108 function core.register_item(name, itemdef)
 109         -- Check name
 110         if name == nil then
 111                 error("Unable to register item: Name is nil")
 112         end
 113         name = check_modname_prefix(tostring(name))
 114         if forbidden_item_names[name] then
 115                 error("Unable to register item: Name is forbidden: " .. name)
 116         end
 117         itemdef.name = name
 118
 119         -- Apply defaults and add to registered_* table
 120         if itemdef.type == "node" then
 121                 -- Use the nodebox as selection box if it's not set manually
 122                 if itemdef.drawtype == "nodebox" and not itemdef.selection_box then
 123                         itemdef.selection_box = itemdef.node_box
 124                 elseif itemdef.drawtype == "fencelike" and not itemdef.selection_box then
 125                         itemdef.selection_box = {
 126                                 type = "fixed",
 127                                 fixed = {-1/8, -1/2, -1/8, 1/8, 1/2, 1/8},
 128                         }
 129                 end
 130                 if itemdef.light_source and itemdef.light_source > core.LIGHT_MAX then
 131                         itemdef.light_source = core.LIGHT_MAX
 132                         core.log("warning", "Node 'light_source' value exceeds maximum," ..
 133                                 " limiting to maximum: " ..name)
 134                 end
 135                 setmetatable(itemdef, {__index = core.nodedef_default})
 136                 core.registered_nodes[itemdef.name] = itemdef
 137         elseif itemdef.type == "craft" then
 138                 setmetatable(itemdef, {__index = core.craftitemdef_default})
 139                 core.registered_craftitems[itemdef.name] = itemdef
 140         elseif itemdef.type == "tool" then
 141                 setmetatable(itemdef, {__index = core.tooldef_default})
 142                 core.registered_tools[itemdef.name] = itemdef
 143         elseif itemdef.type == "none" then
 144                 setmetatable(itemdef, {__index = core.noneitemdef_default})
 145         else
 146                 error("Unable to register item: Type is invalid: " .. dump(itemdef))
 147         end
 148
 149         -- Flowing liquid uses param2
 150         if itemdef.type == "node" and itemdef.liquidtype == "flowing" then
 151                 itemdef.paramtype2 = "flowingliquid"
 152         end
 153
 154         -- BEGIN Legacy stuff
 155         if itemdef.cookresult_itemstring ~= nil and itemdef.cookresult_itemstring ~= "" then
 156                 core.register_craft({
 157                         type="cooking",
 158                         output=itemdef.cookresult_itemstring,
 159                         recipe=itemdef.name,
 160                         cooktime=itemdef.furnace_cooktime
 161                 })
 162         end
 163         if itemdef.furnace_burntime ~= nil and itemdef.furnace_burntime >= 0 then
 164                 core.register_craft({
 165                         type="fuel",
 166                         recipe=itemdef.name,
 167                         burntime=itemdef.furnace_burntime
 168                 })
 169         end
 170         -- END Legacy stuff
 171
 172         itemdef.mod_origin = core.get_current_modname() or "??"
 173
 174         -- Disable all further modifications
 175         getmetatable(itemdef).__newindex = {}
 176
 177         --core.log("Registering item: " .. itemdef.name)
 178         core.registered_items[itemdef.name] = itemdef
 179         core.registered_aliases[itemdef.name] = nil
 180         register_item_raw(itemdef)
 181 end
 182
 183 function core.unregister_item(name)
 184         if not core.registered_items[name] then
 185                 core.log("warning", "Not unregistering item " ..name..
 186                         " because it doesn't exist.")
 187                 return
 188         end
 189         -- Erase from registered_* table
 190         local type = core.registered_items[name].type
 191         if type == "node" then
 192                 core.registered_nodes[name] = nil
 193         elseif type == "craft" then
 194                 core.registered_craftitems[name] = nil
 195         elseif type == "tool" then
 196                 core.registered_tools[name] = nil
 197         end
 198         core.registered_items[name] = nil
 199
 200
 201         unregister_item_raw(name)
 202 end
 203
 204 function core.register_node(name, nodedef)
 205         nodedef.type = "node"
 206         core.register_item(name, nodedef)
 207 end
 208
 209 function core.register_craftitem(name, craftitemdef)
 210         craftitemdef.type = "craft"
 211
 212         -- BEGIN Legacy stuff
 213         if craftitemdef.inventory_image == nil and craftitemdef.image ~= nil then
 214                 craftitemdef.inventory_image = craftitemdef.image
 215         end
 216         -- END Legacy stuff
 217
 218         core.register_item(name, craftitemdef)
 219 end
 220
 221 function core.register_tool(name, tooldef)
 222         tooldef.type = "tool"
 223         tooldef.stack_max = 1
 224
 225         -- BEGIN Legacy stuff
 226         if tooldef.inventory_image == nil and tooldef.image ~= nil then
 227                 tooldef.inventory_image = tooldef.image
 228         end
 229         if tooldef.tool_capabilities == nil and
 230            (tooldef.full_punch_interval ~= nil or
 231             tooldef.basetime ~= nil or
 232             tooldef.dt_weight ~= nil or
 233             tooldef.dt_crackiness ~= nil or
 234             tooldef.dt_crumbliness ~= nil or
 235             tooldef.dt_cuttability ~= nil or
 236             tooldef.basedurability ~= nil or
 237             tooldef.dd_weight ~= nil or
 238             tooldef.dd_crackiness ~= nil or
 239             tooldef.dd_crumbliness ~= nil or
 240             tooldef.dd_cuttability ~= nil) then
 241                 tooldef.tool_capabilities = {
 242                         full_punch_interval = tooldef.full_punch_interval,
 243                         basetime = tooldef.basetime,
 244                         dt_weight = tooldef.dt_weight,
 245                         dt_crackiness = tooldef.dt_crackiness,
 246                         dt_crumbliness = tooldef.dt_crumbliness,
 247                         dt_cuttability = tooldef.dt_cuttability,
 248                         basedurability = tooldef.basedurability,
 249                         dd_weight = tooldef.dd_weight,
 250                         dd_crackiness = tooldef.dd_crackiness,
 251                         dd_crumbliness = tooldef.dd_crumbliness,
 252                         dd_cuttability = tooldef.dd_cuttability,
 253                 }
 254         end
 255         -- END Legacy stuff
 256
 257         core.register_item(name, tooldef)
 258 end
 259
 260 function core.register_alias(name, convert_to)
 261         if forbidden_item_names[name] then
 262                 error("Unable to register alias: Name is forbidden: " .. name)
 263         end
 264         if core.registered_items[name] ~= nil then
 265                 core.log("warning", "Not registering alias, item with same name" ..
 266                         " is already defined: " .. name .. " -> " .. convert_to)
 267         else
 268                 --core.log("Registering alias: " .. name .. " -> " .. convert_to)
 269                 core.registered_aliases[name] = convert_to
 270                 register_alias_raw(name, convert_to)
 271         end
 272 end
 273
 274 function core.register_alias_force(name, convert_to)
 275         if forbidden_item_names[name] then
 276                 error("Unable to register alias: Name is forbidden: " .. name)
 277         end
 278         if core.registered_items[name] ~= nil then
 279                 core.unregister_item(name)
 280                 core.log("info", "Removed item " ..name..
 281                         " while attempting to force add an alias")
 282         end
 283         --core.log("Registering alias: " .. name .. " -> " .. convert_to)
 284         core.registered_aliases[name] = convert_to
 285         register_alias_raw(name, convert_to)
 286 end
 287
 288 function core.on_craft(itemstack, player, old_craft_list, craft_inv)
 289         for _, func in ipairs(core.registered_on_crafts) do
 290                 itemstack = func(itemstack, player, old_craft_list, craft_inv) or itemstack
 291         end
 292         return itemstack
 293 end
 294
 295 function core.craft_predict(itemstack, player, old_craft_list, craft_inv)
 296         for _, func in ipairs(core.registered_craft_predicts) do
 297                 itemstack = func(itemstack, player, old_craft_list, craft_inv) or itemstack
 298         end
 299         return itemstack
 300 end
 301
 302 -- Alias the forbidden item names to "" so they can't be
 303 -- created via itemstrings (e.g. /give)
 304 local name
 305 for name in pairs(forbidden_item_names) do
 306         core.registered_aliases[name] = ""
 307         register_alias_raw(name, "")
 308 end
 309
 310
 311 -- Deprecated:
 312 -- Aliases for core.register_alias (how ironic...)
 313 --core.alias_node = core.register_alias
 314 --core.alias_tool = core.register_alias
 315 --core.alias_craftitem = core.register_alias
 316
 317 --
 318 -- Built-in node definitions. Also defined in C.
 319 --
 320
 321 core.register_item(":unknown", {
 322         type = "none",
 323         description = "Unknown Item",
 324         inventory_image = "unknown_item.png",
 325         on_place = core.item_place,
 326         on_secondary_use = core.item_secondary_use,
 327         on_drop = core.item_drop,
 328         groups = {not_in_creative_inventory=1},
 329         diggable = true,
 330 })
 331
 332 core.register_node(":air", {
 333         description = "Air (you hacker you!)",
 334         inventory_image = "air.png",
 335         wield_image = "air.png",
 336         drawtype = "airlike",
 337         paramtype = "light",
 338         sunlight_propagates = true,
 339         walkable = false,
 340         pointable = false,
 341         diggable = false,
 342         buildable_to = true,
 343         floodable = true,
 344         air_equivalent = true,
 345         drop = "",
 346         groups = {not_in_creative_inventory=1},
 347 })
 348
 349 core.register_node(":ignore", {
 350         description = "Ignore (you hacker you!)",
 351         inventory_image = "ignore.png",
 352         wield_image = "ignore.png",
 353         drawtype = "airlike",
 354         paramtype = "none",
 355         sunlight_propagates = false,
 356         walkable = false,
 357         pointable = false,
 358         diggable = false,
 359         buildable_to = true, -- A way to remove accidentally placed ignores
 360         air_equivalent = true,
 361         drop = "",
 362         groups = {not_in_creative_inventory=1},
 363 })
 364
 365 -- The hand (bare definition)
 366 core.register_item(":", {
 367         type = "none",
 368         groups = {not_in_creative_inventory=1},
 369 })
 370
 371
 372 function core.override_item(name, redefinition)
 373         if redefinition.name ~= nil then
 374                 error("Attempt to redefine name of "..name.." to "..dump(redefinition.name), 2)
 375         end
 376         if redefinition.type ~= nil then
 377                 error("Attempt to redefine type of "..name.." to "..dump(redefinition.type), 2)
 378         end
 379         local item = core.registered_items[name]
 380         if not item then
 381                 error("Attempt to override non-existent item "..name, 2)
 382         end
 383         for k, v in pairs(redefinition) do
 384                 rawset(item, k, v)
 385         end
 386         register_item_raw(item)
 387 end
 388
 389
 390 core.callback_origins = {}
 391
 392 function core.run_callbacks(callbacks, mode, ...)
 393         assert(type(callbacks) == "table")
 394         local cb_len = #callbacks
 395         if cb_len == 0 then
 396                 if mode == 2 or mode == 3 then
 397                         return true
 398                 elseif mode == 4 or mode == 5 then
 399                         return false
 400                 end
 401         end
 402         local ret = nil
 403         for i = 1, cb_len do
 404                 local origin = core.callback_origins[callbacks[i]]
 405                 if origin then
 406                         core.set_last_run_mod(origin.mod)
 407                         --print("Running " .. tostring(callbacks[i]) ..
 408                         --      " (a " .. origin.name .. " callback in " .. origin.mod .. ")")
 409                 else
 410                         --print("No data associated with callback")
 411                 end
 412                 local cb_ret = callbacks[i](...)
 413
 414                 if mode == 0 and i == 1 then
 415                         ret = cb_ret
 416                 elseif mode == 1 and i == cb_len then
 417                         ret = cb_ret
 418                 elseif mode == 2 then
 419                         if not cb_ret or i == 1 then
 420                                 ret = cb_ret
 421                         end
 422                 elseif mode == 3 then
 423                         if cb_ret then
 424                                 return cb_ret
 425                         end
 426                         ret = cb_ret
 427                 elseif mode == 4 then
 428                         if (cb_ret and not ret) or i == 1 then
 429                                 ret = cb_ret
 430                         end
 431                 elseif mode == 5 and cb_ret then
 432                         return cb_ret
 433                 end
 434         end
 435         return ret
 436 end
 437
 438 function core.run_priv_callbacks(name, priv, caller, method)
 439         local def = core.registered_privileges[priv]
 440         if not def or not def["on_" .. method] or
 441                         not def[priv]["on_" .. method](name, caller) then
 442                 for _, func in ipairs(core["registered_on_priv_" .. method]) do
 443                         if not func(name, caller, priv) then
 444                                 break
 445                         end
 446                 end
 447         end
 448 end
 449
 450 --
 451 -- Callback registration
 452 --
 453
 454 local function make_registration()
 455         local t = {}
 456         local registerfunc = function(func)
 457                 t[#t + 1] = func
 458                 core.callback_origins[func] = {
 459                         mod = core.get_current_modname() or "??",
 460                         name = debug.getinfo(1, "n").name or "??"
 461                 }
 462                 --local origin = core.callback_origins[func]
 463                 --print(origin.name .. ": " .. origin.mod .. " registering cbk " .. tostring(func))
 464         end
 465         return t, registerfunc
 466 end
 467
 468 local function make_registration_reverse()
 469         local t = {}
 470         local registerfunc = function(func)
 471                 table.insert(t, 1, func)
 472                 core.callback_origins[func] = {
 473                         mod = core.get_current_modname() or "??",
 474                         name = debug.getinfo(1, "n").name or "??"
 475                 }
 476                 --local origin = core.callback_origins[func]
 477                 --print(origin.name .. ": " .. origin.mod .. " registering cbk " .. tostring(func))
 478         end
 479         return t, registerfunc
 480 end
 481
 482 local function make_registration_wrap(reg_fn_name, clear_fn_name)
 483         local list = {}
 484
 485         local orig_reg_fn = core[reg_fn_name]
 486         core[reg_fn_name] = function(def)
 487                 local retval = orig_reg_fn(def)
 488                 if retval ~= nil then
 489                         if def.name ~= nil then
 490                                 list[def.name] = def
 491                         else
 492                                 list[retval] = def
 493                         end
 494                 end
 495                 return retval
 496         end
 497
 498         local orig_clear_fn = core[clear_fn_name]
 499         core[clear_fn_name] = function()
 500                 for k in pairs(list) do
 501                         list[k] = nil
 502                 end
 503                 return orig_clear_fn()
 504         end
 505
 506         return list
 507 end
 508
 509 local function make_wrap_deregistration(reg_fn, clear_fn, list)
 510         local unregister = function (unregistered_key)
 511                 local temporary_list = table.copy(list)
 512                 clear_fn()
 513                 for k,v in pairs(temporary_list) do
 514                         if unregistered_key ~= k then
 515                                 reg_fn(v)
 516                         end
 517                 end
 518         end
 519         return unregister
 520 end
 521
 522 core.registered_on_player_hpchanges = { modifiers = { }, loggers = { } }
 523
 524 function core.registered_on_player_hpchange(player, hp_change)
 525         local last = false
 526         for i = #core.registered_on_player_hpchanges.modifiers, 1, -1 do
 527                 local func = core.registered_on_player_hpchanges.modifiers[i]
 528                 hp_change, last = func(player, hp_change)
 529                 if type(hp_change) ~= "number" then
 530                         local debuginfo = debug.getinfo(func)
 531                         error("The register_on_hp_changes function has to return a number at " ..
 532                                 debuginfo.short_src .. " line " .. debuginfo.linedefined)
 533                 end
 534                 if last then
 535                         break
 536                 end
 537         end
 538         for i, func in ipairs(core.registered_on_player_hpchanges.loggers) do
 539                 func(player, hp_change)
 540         end
 541         return hp_change
 542 end
 543
 544 function core.register_on_player_hpchange(func, modifier)
 545         if modifier then
 546                 core.registered_on_player_hpchanges.modifiers[#core.registered_on_player_hpchanges.modifiers + 1] = func
 547         else
 548                 core.registered_on_player_hpchanges.loggers[#core.registered_on_player_hpchanges.loggers + 1] = func
 549         end
 550         core.callback_origins[func] = {
 551                 mod = core.get_current_modname() or "??",
 552                 name = debug.getinfo(1, "n").name or "??"
 553         }
 554 end
 555
 556 core.registered_biomes      = make_registration_wrap("register_biome",      "clear_registered_biomes")
 557 core.registered_ores        = make_registration_wrap("register_ore",        "clear_registered_ores")
 558 core.registered_decorations = make_registration_wrap("register_decoration", "clear_registered_decorations")
 559
 560 core.unregister_biome = make_wrap_deregistration(core.register_biome, core.clear_registered_biomes, core.registered_biomes)
 561
 562 core.registered_on_chat_messages, core.register_on_chat_message = make_registration()
 563 core.registered_globalsteps, core.register_globalstep = make_registration()
 564 core.registered_playerevents, core.register_playerevent = make_registration()
 565 core.registered_on_shutdown, core.register_on_shutdown = make_registration()
 566 core.registered_on_punchnodes, core.register_on_punchnode = make_registration()
 567 core.registered_on_placenodes, core.register_on_placenode = make_registration()
 568 core.registered_on_dignodes, core.register_on_dignode = make_registration()
 569 core.registered_on_generateds, core.register_on_generated = make_registration()
 570 core.registered_on_newplayers, core.register_on_newplayer = make_registration()
 571 core.registered_on_dieplayers, core.register_on_dieplayer = make_registration()
 572 core.registered_on_respawnplayers, core.register_on_respawnplayer = make_registration()
 573 core.registered_on_prejoinplayers, core.register_on_prejoinplayer = make_registration()
 574 core.registered_on_joinplayers, core.register_on_joinplayer = make_registration()
 575 core.registered_on_leaveplayers, core.register_on_leaveplayer = make_registration()
 576 core.registered_on_player_receive_fields, core.register_on_player_receive_fields = make_registration_reverse()
 577 core.registered_on_cheats, core.register_on_cheat = make_registration()
 578 core.registered_on_crafts, core.register_on_craft = make_registration()
 579 core.registered_craft_predicts, core.register_craft_predict = make_registration()
 580 core.registered_on_protection_violation, core.register_on_protection_violation = make_registration()
 581 core.registered_on_item_eats, core.register_on_item_eat = make_registration()
 582 core.registered_on_punchplayers, core.register_on_punchplayer = make_registration()
 583 core.registered_on_priv_grant, core.register_on_priv_grant = make_registration()
 584 core.registered_on_priv_revoke, core.register_on_priv_revoke = make_registration()
 585 core.registered_can_bypass_userlimit, core.register_can_bypass_userlimit = make_registration()
 586 core.registered_on_modchannel_message, core.register_on_modchannel_message = make_registration()
 587
 588 --
 589 -- Compatibility for on_mapgen_init()
 590 --
 591
 592 core.register_on_mapgen_init = function(func) func(core.get_mapgen_params()) end