builtin/game/register.lua

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