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                         error("Unable to register node: 'light_source' exceeds maximum: " .. name)
 132                 end
 133                 setmetatable(itemdef, {__index = core.nodedef_default})
 134                 core.registered_nodes[itemdef.name] = itemdef
 135         elseif itemdef.type == "craft" then
 136                 setmetatable(itemdef, {__index = core.craftitemdef_default})
 137                 core.registered_craftitems[itemdef.name] = itemdef
 138         elseif itemdef.type == "tool" then
 139                 setmetatable(itemdef, {__index = core.tooldef_default})
 140                 core.registered_tools[itemdef.name] = itemdef
 141         elseif itemdef.type == "none" then
 142                 setmetatable(itemdef, {__index = core.noneitemdef_default})
 143         else
 144                 error("Unable to register item: Type is invalid: " .. dump(itemdef))
 145         end
 146
 147         -- Flowing liquid uses param2
 148         if itemdef.type == "node" and itemdef.liquidtype == "flowing" then
 149                 itemdef.paramtype2 = "flowingliquid"
 150         end
 151
 152         -- BEGIN Legacy stuff
 153         if itemdef.cookresult_itemstring ~= nil and itemdef.cookresult_itemstring ~= "" then
 154                 core.register_craft({
 155                         type="cooking",
 156                         output=itemdef.cookresult_itemstring,
 157                         recipe=itemdef.name,
 158                         cooktime=itemdef.furnace_cooktime
 159                 })
 160         end
 161         if itemdef.furnace_burntime ~= nil and itemdef.furnace_burntime >= 0 then
 162                 core.register_craft({
 163                         type="fuel",
 164                         recipe=itemdef.name,
 165                         burntime=itemdef.furnace_burntime
 166                 })
 167         end
 168         -- END Legacy stuff
 169
 170         itemdef.mod_origin = core.get_current_modname() or "??"
 171
 172         -- Disable all further modifications
 173         getmetatable(itemdef).__newindex = {}
 174
 175         --core.log("Registering item: " .. itemdef.name)
 176         core.registered_items[itemdef.name] = itemdef
 177         core.registered_aliases[itemdef.name] = nil
 178         register_item_raw(itemdef)
 179 end
 180
 181 function core.unregister_item(name)
 182         if not core.registered_items[name] then
 183                 core.log("warning", "Not unregistering item " ..name..
 184                         " because it doesn't exist.")
 185                 return
 186         end
 187         -- Erase from registered_* table
 188         local type = core.registered_items[name].type
 189         if type == "node" then
 190                 core.registered_nodes[name] = nil
 191         elseif type == "craft" then
 192                 core.registered_craftitems[name] = nil
 193         elseif type == "tool" then
 194                 core.registered_tools[name] = nil
 195         end
 196         core.registered_items[name] = nil
 197
 198
 199         unregister_item_raw(name)
 200 end
 201
 202 function core.register_node(name, nodedef)
 203         nodedef.type = "node"
 204         core.register_item(name, nodedef)
 205 end
 206
 207 function core.register_craftitem(name, craftitemdef)
 208         craftitemdef.type = "craft"
 209
 210         -- BEGIN Legacy stuff
 211         if craftitemdef.inventory_image == nil and craftitemdef.image ~= nil then
 212                 craftitemdef.inventory_image = craftitemdef.image
 213         end
 214         -- END Legacy stuff
 215
 216         core.register_item(name, craftitemdef)
 217 end
 218
 219 function core.register_tool(name, tooldef)
 220         tooldef.type = "tool"
 221         tooldef.stack_max = 1
 222
 223         -- BEGIN Legacy stuff
 224         if tooldef.inventory_image == nil and tooldef.image ~= nil then
 225                 tooldef.inventory_image = tooldef.image
 226         end
 227         if tooldef.tool_capabilities == nil and
 228            (tooldef.full_punch_interval ~= nil or
 229             tooldef.basetime ~= nil or
 230             tooldef.dt_weight ~= nil or
 231             tooldef.dt_crackiness ~= nil or
 232             tooldef.dt_crumbliness ~= nil or
 233             tooldef.dt_cuttability ~= nil or
 234             tooldef.basedurability ~= nil or
 235             tooldef.dd_weight ~= nil or
 236             tooldef.dd_crackiness ~= nil or
 237             tooldef.dd_crumbliness ~= nil or
 238             tooldef.dd_cuttability ~= nil) then
 239                 tooldef.tool_capabilities = {
 240                         full_punch_interval = tooldef.full_punch_interval,
 241                         basetime = tooldef.basetime,
 242                         dt_weight = tooldef.dt_weight,
 243                         dt_crackiness = tooldef.dt_crackiness,
 244                         dt_crumbliness = tooldef.dt_crumbliness,
 245                         dt_cuttability = tooldef.dt_cuttability,
 246                         basedurability = tooldef.basedurability,
 247                         dd_weight = tooldef.dd_weight,
 248                         dd_crackiness = tooldef.dd_crackiness,
 249                         dd_crumbliness = tooldef.dd_crumbliness,
 250                         dd_cuttability = tooldef.dd_cuttability,
 251                 }
 252         end
 253         -- END Legacy stuff
 254
 255         core.register_item(name, tooldef)
 256 end
 257
 258 function core.register_alias(name, convert_to)
 259         if forbidden_item_names[name] then
 260                 error("Unable to register alias: Name is forbidden: " .. name)
 261         end
 262         if core.registered_items[name] ~= nil then
 263                 core.log("warning", "Not registering alias, item with same name" ..
 264                         " is already defined: " .. name .. " -> " .. convert_to)
 265         else
 266                 --core.log("Registering alias: " .. name .. " -> " .. convert_to)
 267                 core.registered_aliases[name] = convert_to
 268                 register_alias_raw(name, convert_to)
 269         end
 270 end
 271
 272 function core.register_alias_force(name, convert_to)
 273         if forbidden_item_names[name] then
 274                 error("Unable to register alias: Name is forbidden: " .. name)
 275         end
 276         if core.registered_items[name] ~= nil then
 277                 core.unregister_item(name)
 278                 core.log("info", "Removed item " ..name..
 279                         " while attempting to force add an alias")
 280         end
 281         --core.log("Registering alias: " .. name .. " -> " .. convert_to)
 282         core.registered_aliases[name] = convert_to
 283         register_alias_raw(name, convert_to)
 284 end
 285
 286 function core.on_craft(itemstack, player, old_craft_list, craft_inv)
 287         for _, func in ipairs(core.registered_on_crafts) do
 288                 itemstack = func(itemstack, player, old_craft_list, craft_inv) or itemstack
 289         end
 290         return itemstack
 291 end
 292
 293 function core.craft_predict(itemstack, player, old_craft_list, craft_inv)
 294         for _, func in ipairs(core.registered_craft_predicts) do
 295                 itemstack = func(itemstack, player, old_craft_list, craft_inv) or itemstack
 296         end
 297         return itemstack
 298 end
 299
 300 -- Alias the forbidden item names to "" so they can't be
 301 -- created via itemstrings (e.g. /give)
 302 local name
 303 for name in pairs(forbidden_item_names) do
 304         core.registered_aliases[name] = ""
 305         register_alias_raw(name, "")
 306 end
 307
 308
 309 -- Deprecated:
 310 -- Aliases for core.register_alias (how ironic...)
 311 --core.alias_node = core.register_alias
 312 --core.alias_tool = core.register_alias
 313 --core.alias_craftitem = core.register_alias
 314
 315 --
 316 -- Built-in node definitions. Also defined in C.
 317 --
 318
 319 core.register_item(":unknown", {
 320         type = "none",
 321         description = "Unknown Item",
 322         inventory_image = "unknown_item.png",
 323         on_place = core.item_place,
 324         on_secondary_use = core.item_secondary_use,
 325         on_drop = core.item_drop,
 326         groups = {not_in_creative_inventory=1},
 327         diggable = true,
 328 })
 329
 330 core.register_node(":air", {
 331         description = "Air (you hacker you!)",
 332         inventory_image = "unknown_node.png",
 333         wield_image = "unknown_node.png",
 334         drawtype = "airlike",
 335         paramtype = "light",
 336         sunlight_propagates = true,
 337         walkable = false,
 338         pointable = false,
 339         diggable = false,
 340         buildable_to = true,
 341         floodable = true,
 342         air_equivalent = true,
 343         drop = "",
 344         groups = {not_in_creative_inventory=1},
 345 })
 346
 347 core.register_node(":ignore", {
 348         description = "Ignore (you hacker you!)",
 349         inventory_image = "unknown_node.png",
 350         wield_image = "unknown_node.png",
 351         drawtype = "airlike",
 352         paramtype = "none",
 353         sunlight_propagates = false,
 354         walkable = false,
 355         pointable = false,
 356         diggable = false,
 357         buildable_to = true, -- A way to remove accidentally placed ignores
 358         air_equivalent = true,
 359         drop = "",
 360         groups = {not_in_creative_inventory=1},
 361 })
 362
 363 -- The hand (bare definition)
 364 core.register_item(":", {
 365         type = "none",
 366         groups = {not_in_creative_inventory=1},
 367 })
 368
 369
 370 function core.override_item(name, redefinition)
 371         if redefinition.name ~= nil then
 372                 error("Attempt to redefine name of "..name.." to "..dump(redefinition.name), 2)
 373         end
 374         if redefinition.type ~= nil then
 375                 error("Attempt to redefine type of "..name.." to "..dump(redefinition.type), 2)
 376         end
 377         local item = core.registered_items[name]
 378         if not item then
 379                 error("Attempt to override non-existent item "..name, 2)
 380         end
 381         for k, v in pairs(redefinition) do
 382                 rawset(item, k, v)
 383         end
 384         register_item_raw(item)
 385 end
 386
 387
 388 core.callback_origins = {}
 389
 390 function core.run_callbacks(callbacks, mode, ...)
 391         assert(type(callbacks) == "table")
 392         local cb_len = #callbacks
 393         if cb_len == 0 then
 394                 if mode == 2 or mode == 3 then
 395                         return true
 396                 elseif mode == 4 or mode == 5 then
 397                         return false
 398                 end
 399         end
 400         local ret = nil
 401         for i = 1, cb_len do
 402                 local origin = core.callback_origins[callbacks[i]]
 403                 if origin then
 404                         core.set_last_run_mod(origin.mod)
 405                         --print("Running " .. tostring(callbacks[i]) ..
 406                         --      " (a " .. origin.name .. " callback in " .. origin.mod .. ")")
 407                 else
 408                         --print("No data associated with callback")
 409                 end
 410                 local cb_ret = callbacks[i](...)
 411
 412                 if mode == 0 and i == 1 then
 413                         ret = cb_ret
 414                 elseif mode == 1 and i == cb_len then
 415                         ret = cb_ret
 416                 elseif mode == 2 then
 417                         if not cb_ret or i == 1 then
 418                                 ret = cb_ret
 419                         end
 420                 elseif mode == 3 then
 421                         if cb_ret then
 422                                 return cb_ret
 423                         end
 424                         ret = cb_ret
 425                 elseif mode == 4 then
 426                         if (cb_ret and not ret) or i == 1 then
 427                                 ret = cb_ret
 428                         end
 429                 elseif mode == 5 and cb_ret then
 430                         return cb_ret
 431                 end
 432         end
 433         return ret
 434 end
 435
 436 --
 437 -- Callback registration
 438 --
 439
 440 local function make_registration()
 441         local t = {}
 442         local registerfunc = function(func)
 443                 t[#t + 1] = func
 444                 core.callback_origins[func] = {
 445                         mod = core.get_current_modname() or "??",
 446                         name = debug.getinfo(1, "n").name or "??"
 447                 }
 448                 --local origin = core.callback_origins[func]
 449                 --print(origin.name .. ": " .. origin.mod .. " registering cbk " .. tostring(func))
 450         end
 451         return t, registerfunc
 452 end
 453
 454 local function make_registration_reverse()
 455         local t = {}
 456         local registerfunc = function(func)
 457                 table.insert(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_wrap(reg_fn_name, clear_fn_name)
 469         local list = {}
 470
 471         local orig_reg_fn = core[reg_fn_name]
 472         core[reg_fn_name] = function(def)
 473                 local retval = orig_reg_fn(def)
 474                 if retval ~= nil then
 475                         if def.name ~= nil then
 476                                 list[def.name] = def
 477                         else
 478                                 list[retval] = def
 479                         end
 480                 end
 481                 return retval
 482         end
 483
 484         local orig_clear_fn = core[clear_fn_name]
 485         core[clear_fn_name] = function()
 486                 for k in pairs(list) do
 487                         list[k] = nil
 488                 end
 489                 return orig_clear_fn()
 490         end
 491
 492         return list
 493 end
 494
 495 core.registered_on_player_hpchanges = { modifiers = { }, loggers = { } }
 496
 497 function core.registered_on_player_hpchange(player, hp_change)
 498         local last = false
 499         for i = #core.registered_on_player_hpchanges.modifiers, 1, -1 do
 500                 local func = core.registered_on_player_hpchanges.modifiers[i]
 501                 hp_change, last = func(player, hp_change)
 502                 if type(hp_change) ~= "number" then
 503                         local debuginfo = debug.getinfo(func)
 504                         error("The register_on_hp_changes function has to return a number at " ..
 505                                 debuginfo.short_src .. " line " .. debuginfo.linedefined)
 506                 end
 507                 if last then
 508                         break
 509                 end
 510         end
 511         for i, func in ipairs(core.registered_on_player_hpchanges.loggers) do
 512                 func(player, hp_change)
 513         end
 514         return hp_change
 515 end
 516
 517 function core.register_on_player_hpchange(func, modifier)
 518         if modifier then
 519                 core.registered_on_player_hpchanges.modifiers[#core.registered_on_player_hpchanges.modifiers + 1] = func
 520         else
 521                 core.registered_on_player_hpchanges.loggers[#core.registered_on_player_hpchanges.loggers + 1] = func
 522         end
 523         core.callback_origins[func] = {
 524                 mod = core.get_current_modname() or "??",
 525                 name = debug.getinfo(1, "n").name or "??"
 526         }
 527 end
 528
 529 core.registered_biomes      = make_registration_wrap("register_biome",      "clear_registered_biomes")
 530 core.registered_ores        = make_registration_wrap("register_ore",        "clear_registered_ores")
 531 core.registered_decorations = make_registration_wrap("register_decoration", "clear_registered_decorations")
 532
 533 core.registered_on_chat_messages, core.register_on_chat_message = make_registration()
 534 core.registered_globalsteps, core.register_globalstep = make_registration()
 535 core.registered_playerevents, core.register_playerevent = make_registration()
 536 core.registered_on_shutdown, core.register_on_shutdown = make_registration()
 537 core.registered_on_punchnodes, core.register_on_punchnode = make_registration()
 538 core.registered_on_placenodes, core.register_on_placenode = make_registration()
 539 core.registered_on_dignodes, core.register_on_dignode = make_registration()
 540 core.registered_on_generateds, core.register_on_generated = make_registration()
 541 core.registered_on_newplayers, core.register_on_newplayer = make_registration()
 542 core.registered_on_dieplayers, core.register_on_dieplayer = make_registration()
 543 core.registered_on_respawnplayers, core.register_on_respawnplayer = make_registration()
 544 core.registered_on_prejoinplayers, core.register_on_prejoinplayer = make_registration()
 545 core.registered_on_joinplayers, core.register_on_joinplayer = make_registration()
 546 core.registered_on_leaveplayers, core.register_on_leaveplayer = make_registration()
 547 core.registered_on_player_receive_fields, core.register_on_player_receive_fields = make_registration_reverse()
 548 core.registered_on_cheats, core.register_on_cheat = make_registration()
 549 core.registered_on_crafts, core.register_on_craft = make_registration()
 550 core.registered_craft_predicts, core.register_craft_predict = make_registration()
 551 core.registered_on_protection_violation, core.register_on_protection_violation = make_registration()
 552 core.registered_on_item_eats, core.register_on_item_eat = make_registration()
 553 core.registered_on_punchplayers, core.register_on_punchplayer = make_registration()
 554
 555 --
 556 -- Compatibility for on_mapgen_init()
 557 --
 558
 559 core.register_on_mapgen_init = function(func) func(core.get_mapgen_params()) end
 560