minetest
/
minetest
mirror of https://github.com/minetest/minetest.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Use "core" namespace internally

This commit is contained in:
ShadowNinja 2014-04-27 21:02:48 -04:00
parent 1cd512913e
commit c4359ff65c
45 changed files with 812 additions and 843 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
builtin/async/init.lua
View File

@ -1,6 +1,5 @@
engine.log("info", "Initializing Asynchronous environment")
local core = engine or minetest
core.log("info", "Initializing Asynchronous environment")
function core.job_processor(serialized_func, serialized_param)
local func = loadstring(serialized_func)

10
builtin/common/async_event.lua
View File

@ -1,6 +1,4 @@
local core = engine or minetest
core.async_jobs = {}
local function handle_job(jobid, serialized_retval)
@ -10,14 +8,14 @@ local function handle_job(jobid, serialized_retval)
core.async_jobs[jobid] = nil
end
if engine ~= nil then
core.async_event_handler = handle_job
else
minetest.register_globalstep(function(dtime)
if core.register_globalstep then
core.register_globalstep(function(dtime)
for i, job in ipairs(core.get_finished_jobs()) do
handle_job(job.jobid, job.retval)
end
end)
else
core.async_event_handler = handle_job
end
function core.handle_async(func, parameter, callback)

64
builtin/common/misc_helpers.lua
View File

@ -173,8 +173,7 @@ function cleanup_path(temppath)
return temppath
end
local tbl = engine or minetest
function tbl.formspec_escape(text)
function core.formspec_escape(text)
if text ~= nil then
text = string.gsub(text,"\\","\\\\")
text = string.gsub(text,"%]","\\]")
@ -186,7 +185,7 @@ function tbl.formspec_escape(text)
end
function tbl.splittext(text,charlimit)
function core.splittext(text,charlimit)
local retval = {}
local current_idx = 1
@ -243,33 +242,33 @@ end
--------------------------------------------------------------------------------
if minetest then
if INIT == "game" then
local dirs1 = {9, 18, 7, 12}
local dirs2 = {20, 23, 22, 21}
function minetest.rotate_and_place(itemstack, placer, pointed_thing,
function core.rotate_and_place(itemstack, placer, pointed_thing,
infinitestacks, orient_flags)
orient_flags = orient_flags or {}
local unode = minetest.get_node_or_nil(pointed_thing.under)
local unode = core.get_node_or_nil(pointed_thing.under)
if not unode then
return
end
local undef = minetest.registered_nodes[unode.name]
local undef = core.registered_nodes[unode.name]
if undef and undef.on_rightclick then
undef.on_rightclick(pointed_thing.under, unode, placer,
itemstack, pointed_thing)
return
end
local pitch = placer:get_look_pitch()
local fdir = minetest.dir_to_facedir(placer:get_look_dir())
local fdir = core.dir_to_facedir(placer:get_look_dir())
local wield_name = itemstack:get_name()
local above = pointed_thing.above
local under = pointed_thing.under
local iswall = (above.y == under.y)
local isceiling = not iswall and (above.y < under.y)
local anode = minetest.get_node_or_nil(above)
local anode = core.get_node_or_nil(above)
if not anode then
return
end
@ -282,13 +281,13 @@ if minetest then
iswall = false
end
if minetest.is_protected(pos, placer:get_player_name()) then
minetest.record_protection_violation(pos,
if core.is_protected(pos, placer:get_player_name()) then
core.record_protection_violation(pos,
placer:get_player_name())
return
end
local ndef = minetest.registered_nodes[node.name]
local ndef = core.registered_nodes[node.name]
if not ndef or not ndef.buildable_to then
return
end
@ -307,22 +306,22 @@ if minetest then
end
if iswall then
minetest.set_node(pos, {name = wield_name,
core.set_node(pos, {name = wield_name,
param2 = dirs1[fdir+1]})
elseif isceiling then
if orient_flags.force_facedir then
minetest.set_node(pos, {name = wield_name,
core.set_node(pos, {name = wield_name,
param2 = 20})
else
minetest.set_node(pos, {name = wield_name,
core.set_node(pos, {name = wield_name,
param2 = dirs2[fdir+1]})
end
else -- place right side up
if orient_flags.force_facedir then
minetest.set_node(pos, {name = wield_name,
core.set_node(pos, {name = wield_name,
param2 = 0})
else
minetest.set_node(pos, {name = wield_name,
core.set_node(pos, {name = wield_name,
param2 = fdir})
end
end
@ -340,16 +339,16 @@ if minetest then
--------------------------------------------------------------------------------
minetest.rotate_node = function(itemstack, placer, pointed_thing)
minetest.rotate_and_place(itemstack, placer, pointed_thing,
minetest.setting_getbool("creative_mode"),
core.rotate_node = function(itemstack, placer, pointed_thing)
core.rotate_and_place(itemstack, placer, pointed_thing,
core.setting_getbool("creative_mode"),
{invert_wall = placer:get_player_control().sneak})
return itemstack
end
end
--------------------------------------------------------------------------------
function tbl.explode_table_event(evt)
function core.explode_table_event(evt)
if evt ~= nil then
local parts = evt:split(":")
if #parts == 3 then
@ -365,7 +364,7 @@ function tbl.explode_table_event(evt)
end
--------------------------------------------------------------------------------
function tbl.explode_textlist_event(evt)
function core.explode_textlist_event(evt)
if evt ~= nil then
local parts = evt:split(":")
if #parts == 2 then
@ -379,11 +378,15 @@ function tbl.explode_textlist_event(evt)
return {type="INV", index=0}
end
function core.pos_to_string(pos)
return "(" .. pos.x .. "," .. pos.y .. "," .. pos.z .. ")"
end
--------------------------------------------------------------------------------
-- mainmenu only functions
--------------------------------------------------------------------------------
if engine ~= nil then
engine.get_game = function(index)
if INIT == "mainmenu" then
function core.get_game(index)
local games = game.get_games()
if index > 0 and index <= #games then
@ -394,7 +397,7 @@ if engine ~= nil then
end
function fgettext(text, ...)
text = engine.gettext(text)
text = core.gettext(text)
local arg = {n=select('#', ...), ...}
if arg.n >= 1 then
-- Insert positional parameters ($1, $2, ...)
@ -413,16 +416,7 @@ if engine ~= nil then
end
text = result
end
return engine.formspec_escape(text)
end
end
--------------------------------------------------------------------------------
-- core only fct
--------------------------------------------------------------------------------
if minetest ~= nil then
--------------------------------------------------------------------------------
function minetest.pos_to_string(pos)
return "(" .. pos.x .. "," .. pos.y .. "," .. pos.z .. ")"
return core.formspec_escape(text)
end
end

10
builtin/common/serialize.lua
View File

@ -14,7 +14,7 @@
local no_identity = { number=1, boolean=1, string=1, ['nil']=1 }
function minetest.serialize(x)
function core.serialize(x)
local gensym_max = 0 -- index of the gensym() symbol generator
local seen_once = { } -- element->true set of elements seen exactly once in the table
@ -188,13 +188,13 @@ local function stringtotable(sdata, safe)
return f()
end
function minetest.deserialize(sdata, safe)
function core.deserialize(sdata, safe)
local table = {}
local okay, results = pcall(stringtotable, sdata, safe)
if okay then
return results
end
minetest.log('error', 'minetest.deserialize(): '.. results)
core.log('error', 'core.deserialize(): '.. results)
return nil
end
@ -207,14 +207,14 @@ local function unit_test()
end
unittest_input = {cat={sound="nyan", speed=400}, dog={sound="woof"}}
unittest_output = minetest.deserialize(minetest.serialize(unittest_input))
unittest_output = core.deserialize(core.serialize(unittest_input))
unitTest("test 1a", unittest_input.cat.sound == unittest_output.cat.sound)
unitTest("test 1b", unittest_input.cat.speed == unittest_output.cat.speed)
unitTest("test 1c", unittest_input.dog.sound == unittest_output.dog.sound)
unittest_input = {escapechars="\n\r\t\v\\\"\'", noneuropean="θשׁ٩∂"}
unittest_output = minetest.deserialize(minetest.serialize(unittest_input))
unittest_output = core.deserialize(core.serialize(unittest_input))
unitTest("test 3a", unittest_input.escapechars == unittest_output.escapechars)
unitTest("test 3b", unittest_input.noneuropean == unittest_output.noneuropean)
end

106
builtin/game/auth.lua
View File

@ -4,7 +4,7 @@
-- Authentication handler
--
function minetest.string_to_privs(str, delim)
function core.string_to_privs(str, delim)
assert(type(str) == "string")
delim = delim or ','
privs = {}
@ -14,7 +14,7 @@ function minetest.string_to_privs(str, delim)
return privs
end
function minetest.privs_to_string(privs, delim)
function core.privs_to_string(privs, delim)
assert(type(privs) == "table")
delim = delim or ','
list = {}
@ -26,17 +26,17 @@ function minetest.privs_to_string(privs, delim)
return table.concat(list, delim)
end
assert(minetest.string_to_privs("a,b").b == true)
assert(minetest.privs_to_string({a=true,b=true}) == "a,b")
assert(core.string_to_privs("a,b").b == true)
assert(core.privs_to_string({a=true,b=true}) == "a,b")
minetest.auth_file_path = minetest.get_worldpath().."/auth.txt"
minetest.auth_table = {}
core.auth_file_path = core.get_worldpath().."/auth.txt"
core.auth_table = {}
local function read_auth_file()
local newtable = {}
local file, errmsg = io.open(minetest.auth_file_path, 'rb')
local file, errmsg = io.open(core.auth_file_path, 'rb')
if not file then
minetest.log("info", minetest.auth_file_path.." could not be opened for reading ("..errmsg.."); assuming new world")
core.log("info", core.auth_file_path.." could not be opened for reading ("..errmsg.."); assuming new world")
return
end
for line in file:lines() do
@ -45,31 +45,31 @@ local function read_auth_file()
if not name or not password or not privilegestring then
error("Invalid line in auth.txt: "..dump(line))
end
local privileges = minetest.string_to_privs(privilegestring)
local privileges = core.string_to_privs(privilegestring)
newtable[name] = {password=password, privileges=privileges}
end
end
io.close(file)
minetest.auth_table = newtable
minetest.notify_authentication_modified()
core.auth_table = newtable
core.notify_authentication_modified()
end
local function save_auth_file()
local newtable = {}
-- Check table for validness before attempting to save
for name, stuff in pairs(minetest.auth_table) do
for name, stuff in pairs(core.auth_table) do
assert(type(name) == "string")
assert(name ~= "")
assert(type(stuff) == "table")
assert(type(stuff.password) == "string")
assert(type(stuff.privileges) == "table")
end
local file, errmsg = io.open(minetest.auth_file_path, 'w+b')
local file, errmsg = io.open(core.auth_file_path, 'w+b')
if not file then
error(minetest.auth_file_path.." could not be opened for writing: "..errmsg)
error(core.auth_file_path.." could not be opened for writing: "..errmsg)
end
for name, stuff in pairs(minetest.auth_table) do
local privstring = minetest.privs_to_string(stuff.privileges)
for name, stuff in pairs(core.auth_table) do
local privstring = core.privs_to_string(stuff.privileges)
file:write(name..":"..stuff.password..":"..privstring..'\n')
end
io.close(file)
@ -77,7 +77,7 @@ end
read_auth_file()
minetest.builtin_auth_handler = {
core.builtin_auth_handler = {
get_auth = function(name)
assert(type(name) == "string")
-- Figure out what password to use for a new player (singleplayer
@ -85,52 +85,52 @@ minetest.builtin_auth_handler = {
-- usually empty too)
local new_password_hash = ""
-- If not in authentication table, return nil
if not minetest.auth_table[name] then
if not core.auth_table[name] then
return nil
end
-- Figure out what privileges the player should have.
-- Take a copy of the privilege table
local privileges = {}
for priv, _ in pairs(minetest.auth_table[name].privileges) do
for priv, _ in pairs(core.auth_table[name].privileges) do
privileges[priv] = true
end
-- If singleplayer, give all privileges except those marked as give_to_singleplayer = false
if minetest.is_singleplayer() then
for priv, def in pairs(minetest.registered_privileges) do
if core.is_singleplayer() then
for priv, def in pairs(core.registered_privileges) do
if def.give_to_singleplayer then
privileges[priv] = true
end
end
-- For the admin, give everything
elseif name == minetest.setting_get("name") then
for priv, def in pairs(minetest.registered_privileges) do
elseif name == core.setting_get("name") then
for priv, def in pairs(core.registered_privileges) do
privileges[priv] = true
end
end
-- All done
return {
password = minetest.auth_table[name].password,
password = core.auth_table[name].password,
privileges = privileges,
}
end,
create_auth = function(name, password)
assert(type(name) == "string")
assert(type(password) == "string")
minetest.log('info', "Built-in authentication handler adding player '"..name.."'")
minetest.auth_table[name] = {
core.log('info', "Built-in authentication handler adding player '"..name.."'")
core.auth_table[name] = {
password = password,
privileges = minetest.string_to_privs(minetest.setting_get("default_privs")),
privileges = core.string_to_privs(core.setting_get("default_privs")),
}
save_auth_file()
end,
set_password = function(name, password)
assert(type(name) == "string")
assert(type(password) == "string")
if not minetest.auth_table[name] then
minetest.builtin_auth_handler.create_auth(name, password)
if not core.auth_table[name] then
core.builtin_auth_handler.create_auth(name, password)
else
minetest.log('info', "Built-in authentication handler setting password of player '"..name.."'")
minetest.auth_table[name].password = password
core.log('info', "Built-in authentication handler setting password of player '"..name.."'")
core.auth_table[name].password = password
save_auth_file()
end
return true
@ -138,11 +138,11 @@ minetest.builtin_auth_handler = {
set_privileges = function(name, privileges)
assert(type(name) == "string")
assert(type(privileges) == "table")
if not minetest.auth_table[name] then
minetest.builtin_auth_handler.create_auth(name, minetest.get_password_hash(name, minetest.setting_get("default_password")))
if not core.auth_table[name] then
core.builtin_auth_handler.create_auth(name, core.get_password_hash(name, core.setting_get("default_password")))
end
minetest.auth_table[name].privileges = privileges
minetest.notify_authentication_modified(name)
core.auth_table[name].privileges = privileges
core.notify_authentication_modified(name)
save_auth_file()
end,
reload = function()
@ -151,36 +151,36 @@ minetest.builtin_auth_handler = {
end,
}
function minetest.register_authentication_handler(handler)
if minetest.registered_auth_handler then
error("Add-on authentication handler already registered by "..minetest.registered_auth_handler_modname)
function core.register_authentication_handler(handler)
if core.registered_auth_handler then
error("Add-on authentication handler already registered by "..core.registered_auth_handler_modname)
end
minetest.registered_auth_handler = handler
minetest.registered_auth_handler_modname = minetest.get_current_modname()
core.registered_auth_handler = handler
core.registered_auth_handler_modname = core.get_current_modname()
end
function minetest.get_auth_handler()
if minetest.registered_auth_handler then
return minetest.registered_auth_handler
function core.get_auth_handler()
if core.registered_auth_handler then
return core.registered_auth_handler
end
return minetest.builtin_auth_handler
return core.builtin_auth_handler
end
function minetest.set_player_password(name, password)
if minetest.get_auth_handler().set_password then
minetest.get_auth_handler().set_password(name, password)
function core.set_player_password(name, password)
if core.get_auth_handler().set_password then
core.get_auth_handler().set_password(name, password)
end
end
function minetest.set_player_privs(name, privs)
if minetest.get_auth_handler().set_privileges then
minetest.get_auth_handler().set_privileges(name, privs)
function core.set_player_privs(name, privs)
if core.get_auth_handler().set_privileges then
core.get_auth_handler().set_privileges(name, privs)
end
end
function minetest.auth_reload()
if minetest.get_auth_handler().reload then
return minetest.get_auth_handler().reload()
function core.auth_reload()
if core.get_auth_handler().reload then
return core.get_auth_handler().reload()
end
return false
end

388
builtin/game/chatcommands.lua
View File

@ -4,27 +4,27 @@
-- Chat command handler
--
minetest.chatcommands = {}
function minetest.register_chatcommand(cmd, def)
core.chatcommands = {}
function core.register_chatcommand(cmd, def)
def = def or {}
def.params = def.params or ""
def.description = def.description or ""
def.privs = def.privs or {}
minetest.chatcommands[cmd] = def
core.chatcommands[cmd] = def
end
minetest.register_on_chat_message(function(name, message)
core.register_on_chat_message(function(name, message)
local cmd, param = string.match(message, "^/([^ ]+) *(.*)")
if not param then
param = ""
end
local cmd_def = minetest.chatcommands[cmd]
local cmd_def = core.chatcommands[cmd]
if cmd_def then
local has_privs, missing_privs = minetest.check_player_privs(name, cmd_def.privs)
local has_privs, missing_privs = core.check_player_privs(name, cmd_def.privs)
if has_privs then
cmd_def.func(name, param)
else
minetest.chat_send_player(name, "You don't have permission to run this command (missing privileges: "..table.concat(missing_privs, ", ")..")")
core.chat_send_player(name, "You don't have permission to run this command (missing privileges: "..table.concat(missing_privs, ", ")..")")
end
return true -- handled chat message
end
@ -34,16 +34,16 @@ end)
--
-- Chat commands
--
minetest.register_chatcommand("me", {
core.register_chatcommand("me", {
params = "<action>",
description = "chat action (eg. /me orders a pizza)",
privs = {shout=true},
func = function(name, param)
minetest.chat_send_all("* " .. name .. " " .. param)
core.chat_send_all("* " .. name .. " " .. param)
end,
})
minetest.register_chatcommand("help", {
core.register_chatcommand("help", {
privs = {},
params = "(nothing)/all/privs/<cmd>",
description = "Get help for commands or list privileges",
@ -57,82 +57,82 @@ minetest.register_chatcommand("help", {
if param == "" then
local msg = ""
cmds = {}
for cmd, def in pairs(minetest.chatcommands) do
if minetest.check_player_privs(name, def.privs) then
for cmd, def in pairs(core.chatcommands) do
if core.check_player_privs(name, def.privs) then
table.insert(cmds, cmd)
end
end
minetest.chat_send_player(name, "Available commands: "..table.concat(cmds, " "))
minetest.chat_send_player(name, "Use '/help <cmd>' to get more information, or '/help all' to list everything.")
core.chat_send_player(name, "Available commands: "..table.concat(cmds, " "))
core.chat_send_player(name, "Use '/help <cmd>' to get more information, or '/help all' to list everything.")
elseif param == "all" then
minetest.chat_send_player(name, "Available commands:")
for cmd, def in pairs(minetest.chatcommands) do
if minetest.check_player_privs(name, def.privs) then
minetest.chat_send_player(name, format_help_line(cmd, def))
core.chat_send_player(name, "Available commands:")
for cmd, def in pairs(core.chatcommands) do
if core.check_player_privs(name, def.privs) then
core.chat_send_player(name, format_help_line(cmd, def))
end
end
elseif param == "privs" then
minetest.chat_send_player(name, "Available privileges:")
for priv, def in pairs(minetest.registered_privileges) do
minetest.chat_send_player(name, priv..": "..def.description)
core.chat_send_player(name, "Available privileges:")
for priv, def in pairs(core.registered_privileges) do
core.chat_send_player(name, priv..": "..def.description)
end
else
local cmd = param
def = minetest.chatcommands[cmd]
def = core.chatcommands[cmd]
if not def then
minetest.chat_send_player(name, "Command not available: "..cmd)
core.chat_send_player(name, "Command not available: "..cmd)
else
minetest.chat_send_player(name, format_help_line(cmd, def))
core.chat_send_player(name, format_help_line(cmd, def))
end
end
end,
})
minetest.register_chatcommand("privs", {
core.register_chatcommand("privs", {
params = "<name>",
description = "print out privileges of player",
func = function(name, param)
if param == "" then
param = name
else
--[[if not minetest.check_player_privs(name, {privs=true}) then
minetest.chat_send_player(name, "Privileges of "..param.." are hidden from you.")
--[[if not core.check_player_privs(name, {privs=true}) then
core.chat_send_player(name, "Privileges of "..param.." are hidden from you.")
return
end]]
end
minetest.chat_send_player(name, "Privileges of "..param..": "..minetest.privs_to_string(minetest.get_player_privs(param), ' '))
core.chat_send_player(name, "Privileges of "..param..": "..core.privs_to_string(core.get_player_privs(param), ' '))
end,
})
minetest.register_chatcommand("grant", {
core.register_chatcommand("grant", {
params = "<name> <privilege>|all",
description = "Give privilege to player",
privs = {},
func = function(name, param)
if not minetest.check_player_privs(name, {privs=true}) and
not minetest.check_player_privs(name, {basic_privs=true}) then
minetest.chat_send_player(name, "Your privileges are insufficient.")
if not core.check_player_privs(name, {privs=true}) and
not core.check_player_privs(name, {basic_privs=true}) then
core.chat_send_player(name, "Your privileges are insufficient.")
return
end
local grantname, grantprivstr = string.match(param, "([^ ]+) (.+)")
if not grantname or not grantprivstr then
minetest.chat_send_player(name, "Invalid parameters (see /help grant)")
core.chat_send_player(name, "Invalid parameters (see /help grant)")
return
elseif not minetest.auth_table[grantname] then
minetest.chat_send_player(name, "Player "..grantname.." does not exist.")
elseif not core.auth_table[grantname] then
core.chat_send_player(name, "Player "..grantname.." does not exist.")
return
end
local grantprivs = minetest.string_to_privs(grantprivstr)
local grantprivs = core.string_to_privs(grantprivstr)
if grantprivstr == "all" then
grantprivs = minetest.registered_privileges
grantprivs = core.registered_privileges
end
local privs = minetest.get_player_privs(grantname)
local privs = core.get_player_privs(grantname)
local privs_known = true
for priv, _ in pairs(grantprivs) do
if priv ~= "interact" and priv ~= "shout" and priv ~= "interact_extra" and not minetest.check_player_privs(name, {privs=true}) then
minetest.chat_send_player(name, "Your privileges are insufficient.")
if priv ~= "interact" and priv ~= "shout" and priv ~= "interact_extra" and not core.check_player_privs(name, {privs=true}) then
core.chat_send_player(name, "Your privileges are insufficient.")
return
end
if not minetest.registered_privileges[priv] then
minetest.chat_send_player(name, "Unknown privilege: "..priv)
if not core.registered_privileges[priv] then
core.chat_send_player(name, "Unknown privilege: "..priv)
privs_known = false
end
privs[priv] = true
@ -140,37 +140,37 @@ minetest.register_chatcommand("grant", {
if not privs_known then
return
end
minetest.set_player_privs(grantname, privs)
minetest.log(name..' granted ('..minetest.privs_to_string(grantprivs, ', ')..') privileges to '..grantname)
minetest.chat_send_player(name, "Privileges of "..grantname..": "..minetest.privs_to_string(minetest.get_player_privs(grantname), ' '))
core.set_player_privs(grantname, privs)
core.log(name..' granted ('..core.privs_to_string(grantprivs, ', ')..') privileges to '..grantname)
core.chat_send_player(name, "Privileges of "..grantname..": "..core.privs_to_string(core.get_player_privs(grantname), ' '))
if grantname ~= name then
minetest.chat_send_player(grantname, name.." granted you privileges: "..minetest.privs_to_string(grantprivs, ' '))
core.chat_send_player(grantname, name.." granted you privileges: "..core.privs_to_string(grantprivs, ' '))
end
end,
})
minetest.register_chatcommand("revoke", {
core.register_chatcommand("revoke", {
params = "<name> <privilege>|all",
description = "Remove privilege from player",
privs = {},
func = function(name, param)
if not minetest.check_player_privs(name, {privs=true}) and
not minetest.check_player_privs(name, {basic_privs=true}) then
minetest.chat_send_player(name, "Your privileges are insufficient.")
if not core.check_player_privs(name, {privs=true}) and
not core.check_player_privs(name, {basic_privs=true}) then
core.chat_send_player(name, "Your privileges are insufficient.")
return
end
local revokename, revokeprivstr = string.match(param, "([^ ]+) (.+)")
if not revokename or not revokeprivstr then
minetest.chat_send_player(name, "Invalid parameters (see /help revoke)")
core.chat_send_player(name, "Invalid parameters (see /help revoke)")
return
elseif not minetest.auth_table[revokename] then
minetest.chat_send_player(name, "Player "..revokename.." does not exist.")
elseif not core.auth_table[revokename] then
core.chat_send_player(name, "Player "..revokename.." does not exist.")
return
end
local revokeprivs = minetest.string_to_privs(revokeprivstr)
local privs = minetest.get_player_privs(revokename)
local revokeprivs = core.string_to_privs(revokeprivstr)
local privs = core.get_player_privs(revokename)
for priv, _ in pairs(revokeprivs) do
if priv ~= "interact" and priv ~= "shout" and priv ~= "interact_extra" and not minetest.check_player_privs(name, {privs=true}) then
minetest.chat_send_player(name, "Your privileges are insufficient.")
if priv ~= "interact" and priv ~= "shout" and priv ~= "interact_extra" and not core.check_player_privs(name, {privs=true}) then
core.chat_send_player(name, "Your privileges are insufficient.")
return
end
end
@ -181,15 +181,15 @@ minetest.register_chatcommand("revoke", {
privs[priv] = nil
end
end
minetest.set_player_privs(revokename, privs)
minetest.log(name..' revoked ('..minetest.privs_to_string(revokeprivs, ', ')..') privileges from '..revokename)
minetest.chat_send_player(name, "Privileges of "..revokename..": "..minetest.privs_to_string(minetest.get_player_privs(revokename), ' '))
core.set_player_privs(revokename, privs)
core.log(name..' revoked ('..core.privs_to_string(revokeprivs, ', ')..') privileges from '..revokename)
core.chat_send_player(name, "Privileges of "..revokename..": "..core.privs_to_string(core.get_player_privs(revokename), ' '))
if revokename ~= name then
minetest.chat_send_player(revokename, name.." revoked privileges from you: "..minetest.privs_to_string(revokeprivs, ' '))
core.chat_send_player(revokename, name.." revoked privileges from you: "..core.privs_to_string(revokeprivs, ' '))
end
end,
})
minetest.register_chatcommand("setpassword", {
core.register_chatcommand("setpassword", {
params = "<name> <password>",
description = "set given password",
privs = {password=true},
@ -200,53 +200,53 @@ minetest.register_chatcommand("setpassword", {
raw_password = nil
end
if not toname then
minetest.chat_send_player(name, "Name field required")
core.chat_send_player(name, "Name field required")
return
end
local actstr = "?"
if not raw_password then
minetest.set_player_password(toname, "")
core.set_player_password(toname, "")
actstr = "cleared"
else
minetest.set_player_password(toname, minetest.get_password_hash(toname, raw_password))
core.set_player_password(toname, core.get_password_hash(toname, raw_password))
actstr = "set"
end
minetest.chat_send_player(name, "Password of player \""..toname.."\" "..actstr)
core.chat_send_player(name, "Password of player \""..toname.."\" "..actstr)
if toname ~= name then
minetest.chat_send_player(toname, "Your password was "..actstr.." by "..name)
core.chat_send_player(toname, "Your password was "..actstr.." by "..name)
end
end,
})
minetest.register_chatcommand("clearpassword", {
core.register_chatcommand("clearpassword", {
params = "<name>",
description = "set empty password",
privs = {password=true},
func = function(name, param)
toname = param
if toname == "" then
minetest.chat_send_player(name, "Name field required")
core.chat_send_player(name, "Name field required")
return
end
minetest.set_player_password(toname, '')
minetest.chat_send_player(name, "Password of player \""..toname.."\" cleared")
core.set_player_password(toname, '')
core.chat_send_player(name, "Password of player \""..toname.."\" cleared")
end,
})
minetest.register_chatcommand("auth_reload", {
core.register_chatcommand("auth_reload", {
params = "",
description = "reload authentication data",
privs = {server=true},
func = function(name, param)
local done = minetest.auth_reload()
local done = core.auth_reload()
if done then
minetest.chat_send_player(name, "Done.")
core.chat_send_player(name, "Done.")
else
minetest.chat_send_player(name, "Failed.")
core.chat_send_player(name, "Failed.")
end
end,
})
minetest.register_chatcommand("teleport", {
core.register_chatcommand("teleport", {
params = "<X>,<Y>,<Z> | <to_name> | <name> <X>,<Y>,<Z> | <name> <to_name>",
description = "teleport to given position",
privs = {teleport=true},
@ -261,9 +261,9 @@ minetest.register_chatcommand("teleport", {
}
for _, d in ipairs(tries) do
local p = {x = pos.x+d.x, y = pos.y+d.y, z = pos.z+d.z}
local n = minetest.get_node_or_nil(p)
local n = core.get_node_or_nil(p)
if n and n.name then
local def = minetest.registered_nodes[n.name]
local def = core.registered_nodes[n.name]
if def and not def.walkable then
return p, true
end
@ -278,9 +278,9 @@ minetest.register_chatcommand("teleport", {
p.x = tonumber(p.x)
p.y = tonumber(p.y)
p.z = tonumber(p.z)
teleportee = minetest.get_player_by_name(name)
teleportee = core.get_player_by_name(name)
if teleportee and p.x and p.y and p.z then
minetest.chat_send_player(name, "Teleporting to ("..p.x..", "..p.y..", "..p.z..")")
core.chat_send_player(name, "Teleporting to ("..p.x..", "..p.y..", "..p.z..")")
teleportee:setpos(p)
return
end
@ -289,21 +289,21 @@ minetest.register_chatcommand("teleport", {
local p = nil
local target_name = nil
target_name = string.match(param, "^([^ ]+)$")
teleportee = minetest.get_player_by_name(name)
teleportee = core.get_player_by_name(name)
if target_name then
local target = minetest.get_player_by_name(target_name)
local target = core.get_player_by_name(target_name)
if target then
p = target:getpos()
end
end
if teleportee and p then
p = find_free_position_near(p)
minetest.chat_send_player(name, "Teleporting to "..target_name.." at ("..p.x..", "..p.y..", "..p.z..")")
core.chat_send_player(name, "Teleporting to "..target_name.." at ("..p.x..", "..p.y..", "..p.z..")")
teleportee:setpos(p)
return
end
if minetest.check_player_privs(name, {bring=true}) then
if core.check_player_privs(name, {bring=true}) then
local teleportee = nil
local p = {}
local teleportee_name = nil
@ -312,10 +312,10 @@ minetest.register_chatcommand("teleport", {
p.y = tonumber(p.y)
p.z = tonumber(p.z)
if teleportee_name then
teleportee = minetest.get_player_by_name(teleportee_name)
teleportee = core.get_player_by_name(teleportee_name)
end
if teleportee and p.x and p.y and p.z then
minetest.chat_send_player(name, "Teleporting "..teleportee_name.." to ("..p.x..", "..p.y..", "..p.z..")")
core.chat_send_player(name, "Teleporting "..teleportee_name.." to ("..p.x..", "..p.y..", "..p.z..")")
teleportee:setpos(p)
return
end
@ -326,68 +326,68 @@ minetest.register_chatcommand("teleport", {
local target_name = nil
teleportee_name, target_name = string.match(param, "^([^ ]+) +([^ ]+)$")
if teleportee_name then
teleportee = minetest.get_player_by_name(teleportee_name)
teleportee = core.get_player_by_name(teleportee_name)
end
if target_name then
local target = minetest.get_player_by_name(target_name)
local target = core.get_player_by_name(target_name)
if target then
p = target:getpos()
end
end
if teleportee and p then
p = find_free_position_near(p)
minetest.chat_send_player(name, "Teleporting "..teleportee_name.." to "..target_name.." at ("..p.x..", "..p.y..", "..p.z..")")
core.chat_send_player(name, "Teleporting "..teleportee_name.." to "..target_name.." at ("..p.x..", "..p.y..", "..p.z..")")
teleportee:setpos(p)
return
end
end
minetest.chat_send_player(name, "Invalid parameters (\""..param.."\") or player not found (see /help teleport)")
core.chat_send_player(name, "Invalid parameters (\""..param.."\") or player not found (see /help teleport)")
return
end,
})
minetest.register_chatcommand("set", {
core.register_chatcommand("set", {
params = "[-n] <name> <value> | <name>",
description = "set or read server configuration setting",
privs = {server=true},
func = function(name, param)
local arg, setname, setvalue = string.match(param, "(-[n]) ([^ ]+) (.+)")
if arg and arg == "-n" and setname and setvalue then
minetest.setting_set(setname, setvalue)
minetest.chat_send_player(name, setname.." = "..setvalue)
core.setting_set(setname, setvalue)
core.chat_send_player(name, setname.." = "..setvalue)
return
end
local setname, setvalue = string.match(param, "([^ ]+) (.+)")
if setname and setvalue then
if not minetest.setting_get(setname) then
minetest.chat_send_player(name, "Failed. Use '/set -n <name> <value>' to create a new setting.")
if not core.setting_get(setname) then
core.chat_send_player(name, "Failed. Use '/set -n <name> <value>' to create a new setting.")
return
end
minetest.setting_set(setname, setvalue)
minetest.chat_send_player(name, setname.." = "..setvalue)
core.setting_set(setname, setvalue)
core.chat_send_player(name, setname.." = "..setvalue)
return
end
local setname = string.match(param, "([^ ]+)")
if setname then
local setvalue = minetest.setting_get(setname)
local setvalue = core.setting_get(setname)
if not setvalue then
setvalue = "<not set>"
end
minetest.chat_send_player(name, setname.." = "..setvalue)
core.chat_send_player(name, setname.." = "..setvalue)
return
end
minetest.chat_send_player(name, "Invalid parameters (see /help set)")
core.chat_send_player(name, "Invalid parameters (see /help set)")
end,
})
minetest.register_chatcommand("mods", {
core.register_chatcommand("mods", {
params = "",
description = "lists mods installed on the server",
privs = {},
func = function(name, param)
local response = ""
local modnames = minetest.get_modnames()
local modnames = core.get_modnames()
for i, mod in ipairs(modnames) do
response = response .. mod
-- Add space if not at the end
@ -395,25 +395,25 @@ minetest.register_chatcommand("mods", {
response = response .. " "
end
end
minetest.chat_send_player(name, response)
core.chat_send_player(name, response)
end,
})
local function handle_give_command(cmd, giver, receiver, stackstring)
minetest.log("action", giver.." invoked "..cmd..', stackstring="'
core.log("action", giver.." invoked "..cmd..', stackstring="'
..stackstring..'"')
minetest.log(cmd..' invoked, stackstring="'..stackstring..'"')
core.log(cmd..' invoked, stackstring="'..stackstring..'"')
local itemstack = ItemStack(stackstring)
if itemstack:is_empty() then
minetest.chat_send_player(giver, 'error: cannot give an empty item')
core.chat_send_player(giver, 'error: cannot give an empty item')
return
elseif not itemstack:is_known() then
minetest.chat_send_player(giver, 'error: cannot give an unknown item')
core.chat_send_player(giver, 'error: cannot give an unknown item')
return
end
local receiverref = minetest.get_player_by_name(receiver)
local receiverref = core.get_player_by_name(receiver)
if receiverref == nil then
minetest.chat_send_player(giver, receiver..' is not a known player')
core.chat_send_player(giver, receiver..' is not a known player')
return
end
local leftover = receiverref:get_inventory():add_item("main", itemstack)
@ -428,96 +428,96 @@ local function handle_give_command(cmd, giver, receiver, stackstring)
-- entered (e.g. big numbers are always interpreted as 2^16-1).
stackstring = itemstack:to_string()
if giver == receiver then
minetest.chat_send_player(giver, '"'..stackstring
core.chat_send_player(giver, '"'..stackstring
..'" '..partiality..'added to inventory.');
else
minetest.chat_send_player(giver, '"'..stackstring
core.chat_send_player(giver, '"'..stackstring
..'" '..partiality..'added to '..receiver..'\'s inventory.');
minetest.chat_send_player(receiver, '"'..stackstring
core.chat_send_player(receiver, '"'..stackstring
..'" '..partiality..'added to inventory.');
end
end
minetest.register_chatcommand("give", {
core.register_chatcommand("give", {
params = "<name> <itemstring>",
description = "give item to player",
privs = {give=true},
func = function(name, param)
local toname, itemstring = string.match(param, "^([^ ]+) +(.+)$")
if not toname or not itemstring then
minetest.chat_send_player(name, "name and itemstring required")
core.chat_send_player(name, "name and itemstring required")
return
end
handle_give_command("/give", name, toname, itemstring)
end,
})
minetest.register_chatcommand("giveme", {
core.register_chatcommand("giveme", {
params = "<itemstring>",
description = "give item to yourself",
privs = {give=true},
func = function(name, param)
local itemstring = string.match(param, "(.+)$")
if not itemstring then
minetest.chat_send_player(name, "itemstring required")
core.chat_send_player(name, "itemstring required")
return
end
handle_give_command("/giveme", name, name, itemstring)
end,
})
minetest.register_chatcommand("spawnentity", {
core.register_chatcommand("spawnentity", {
params = "<entityname>",
description = "spawn entity at your position",
privs = {give=true, interact=true},
func = function(name, param)
local entityname = string.match(param, "(.+)$")
if not entityname then
minetest.chat_send_player(name, "entityname required")
core.chat_send_player(name, "entityname required")
return
end
minetest.log("action", '/spawnentity invoked, entityname="'..entityname..'"')
local player = minetest.get_player_by_name(name)
core.log("action", '/spawnentity invoked, entityname="'..entityname..'"')
local player = core.get_player_by_name(name)
if player == nil then
minetest.log("error", "Unable to spawn entity, player is nil")
core.log("error", "Unable to spawn entity, player is nil")
return true -- Handled chat message
end
local p = player:getpos()
p.y = p.y + 1
minetest.add_entity(p, entityname)
minetest.chat_send_player(name, '"'..entityname
core.add_entity(p, entityname)
core.chat_send_player(name, '"'..entityname
..'" spawned.');
end,
})
minetest.register_chatcommand("pulverize", {
core.register_chatcommand("pulverize", {
params = "",
description = "delete item in hand",
privs = {},
func = function(name, param)
local player = minetest.get_player_by_name(name)
local player = core.get_player_by_name(name)
if player == nil then
minetest.log("error", "Unable to pulverize, player is nil")
core.log("error", "Unable to pulverize, player is nil")
return true -- Handled chat message
end
if player:get_wielded_item():is_empty() then
minetest.chat_send_player(name, 'Unable to pulverize, no item in hand.')
core.chat_send_player(name, 'Unable to pulverize, no item in hand.')
else
player:set_wielded_item(nil)
minetest.chat_send_player(name, 'An item was pulverized.')
core.chat_send_player(name, 'An item was pulverized.')
end
end,
})
-- Key = player name
minetest.rollback_punch_callbacks = {}
core.rollback_punch_callbacks = {}
minetest.register_on_punchnode(function(pos, node, puncher)
core.register_on_punchnode(function(pos, node, puncher)
local name = puncher:get_player_name()
if minetest.rollback_punch_callbacks[name] then
minetest.rollback_punch_callbacks[name](pos, node, puncher)
minetest.rollback_punch_callbacks[name] = nil
if core.rollback_punch_callbacks[name] then
core.rollback_punch_callbacks[name](pos, node, puncher)
core.rollback_punch_callbacks[name] = nil
end
end)
minetest.register_chatcommand("rollback_check", {
core.register_chatcommand("rollback_check", {
params = "[<range>] [<seconds>] [limit]",
description = "check who has last touched a node or near it, "..
"max. <seconds> ago (default range=0, seconds=86400=24h, limit=5)",
@ -529,29 +529,29 @@ minetest.register_chatcommand("rollback_check", {
seconds = tonumber(seconds) or 86400
limit = tonumber(limit) or 5
if limit > 100 then
minetest.chat_send_player(name, "That limit is too high!")
core.chat_send_player(name, "That limit is too high!")
return
end
minetest.chat_send_player(name, "Punch a node (range="..
core.chat_send_player(name, "Punch a node (range="..
range..", seconds="..seconds.."s, limit="..limit..")")
minetest.rollback_punch_callbacks[name] = function(pos, node, puncher)
core.rollback_punch_callbacks[name] = function(pos, node, puncher)
local name = puncher:get_player_name()
minetest.chat_send_player(name, "Checking "..minetest.pos_to_string(pos).."...")
local actions = minetest.rollback_get_node_actions(pos, range, seconds, limit)
core.chat_send_player(name, "Checking "..core.pos_to_string(pos).."...")
local actions = core.rollback_get_node_actions(pos, range, seconds, limit)
local num_actions = #actions
if num_actions == 0 then
minetest.chat_send_player(name, "Nobody has touched the "..
core.chat_send_player(name, "Nobody has touched the "..
"specified location in "..seconds.." seconds")
return
end
local time = os.time()
for i = num_actions, 1, -1 do
local action = actions[i]
minetest.chat_send_player(name,
core.chat_send_player(name,
("%s %s %s -> %s %d seconds ago.")
:format(
minetest.pos_to_string(action.pos),
core.pos_to_string(action.pos),
action.actor,
action.oldnode.name,
action.newnode.name,
@ -561,7 +561,7 @@ minetest.register_chatcommand("rollback_check", {
end,
})
minetest.register_chatcommand("rollback", {
core.register_chatcommand("rollback", {
params = "<player name> [<seconds>] | :<actor> [<seconds>]",
description = "revert actions of a player; default for <seconds> is 60",
privs = {rollback=true},
@ -571,109 +571,109 @@ minetest.register_chatcommand("rollback", {
local player_name = nil
player_name, seconds = string.match(param, "([^ ]+) *(%d*)")
if not player_name then
minetest.chat_send_player(name, "Invalid parameters. See /help rollback and /help rollback_check")
core.chat_send_player(name, "Invalid parameters. See /help rollback and /help rollback_check")
return
end
target_name = "player:"..player_name
end
seconds = tonumber(seconds) or 60
minetest.chat_send_player(name, "Reverting actions of "..
core.chat_send_player(name, "Reverting actions of "..
target_name.." since "..seconds.." seconds.")
local success, log = minetest.rollback_revert_actions_by(
local success, log = core.rollback_revert_actions_by(
target_name, seconds)
if #log > 100 then
minetest.chat_send_player(name, "(log is too long to show)")
core.chat_send_player(name, "(log is too long to show)")
else
for _, line in pairs(log) do
minetest.chat_send_player(name, line)
core.chat_send_player(name, line)
end
end
if success then
minetest.chat_send_player(name, "Reverting actions succeeded.")
core.chat_send_player(name, "Reverting actions succeeded.")
else
minetest.chat_send_player(name, "Reverting actions FAILED.")
core.chat_send_player(name, "Reverting actions FAILED.")
end
end,
})
minetest.register_chatcommand("status", {
core.register_chatcommand("status", {
params = "",
description = "print server status line",
privs = {},
func = function(name, param)
minetest.chat_send_player(name, minetest.get_server_status())
core.chat_send_player(name, core.get_server_status())
end,
})
minetest.register_chatcommand("time", {
core.register_chatcommand("time", {
params = "<0...24000>",
description = "set time of day",
privs = {settime=true},
func = function(name, param)
if param == "" then
minetest.chat_send_player(name, "Missing parameter")
core.chat_send_player(name, "Missing parameter")
return
end
local newtime = tonumber(param)
if newtime == nil then
minetest.chat_send_player(name, "Invalid time")
core.chat_send_player(name, "Invalid time")
else
minetest.set_timeofday((newtime % 24000) / 24000)
minetest.chat_send_player(name, "Time of day changed.")
minetest.log("action", name .. " sets time " .. newtime)
core.set_timeofday((newtime % 24000) / 24000)
core.chat_send_player(name, "Time of day changed.")
core.log("action", name .. " sets time " .. newtime)
end
end,
})
minetest.register_chatcommand("shutdown", {
core.register_chatcommand("shutdown", {
params = "",
description = "shutdown server",
privs = {server=true},
func = function(name, param)
minetest.log("action", name .. " shuts down server")
minetest.request_shutdown()
minetest.chat_send_all("*** Server shutting down (operator request).")
core.log("action", name .. " shuts down server")
core.request_shutdown()
core.chat_send_all("*** Server shutting down (operator request).")
end,
})
minetest.register_chatcommand("ban", {
core.register_chatcommand("ban", {
params = "<name>",
description = "ban IP of player",
privs = {ban=true},
func = function(name, param)
if param == "" then
minetest.chat_send_player(name, "Ban list: " .. minetest.get_ban_list())
core.chat_send_player(name, "Ban list: " .. core.get_ban_list())
return
end
if not minetest.get_player_by_name(param) then
minetest.chat_send_player(name, "No such player")
if not core.get_player_by_name(param) then
core.chat_send_player(name, "No such player")
return
end
if not minetest.ban_player(param) then
minetest.chat_send_player(name, "Failed to ban player")
if not core.ban_player(param) then
core.chat_send_player(name, "Failed to ban player")
else
local desc = minetest.get_ban_description(param)
minetest.chat_send_player(name, "Banned " .. desc .. ".")
minetest.log("action", name .. " bans " .. desc .. ".")
local desc = core.get_ban_description(param)
core.chat_send_player(name, "Banned " .. desc .. ".")
core.log("action", name .. " bans " .. desc .. ".")
end
end,
})
minetest.register_chatcommand("unban", {
core.register_chatcommand("unban", {
params = "<name/ip>",
description = "remove IP ban",
privs = {ban=true},
func = function(name, param)
if not minetest.unban_player_or_ip(param) then
minetest.chat_send_player(name, "Failed to unban player/IP")
if not core.unban_player_or_ip(param) then
core.chat_send_player(name, "Failed to unban player/IP")
else
minetest.chat_send_player(name, "Unbanned " .. param)
minetest.log("action", name .. " unbans " .. param)
core.chat_send_player(name, "Unbanned " .. param)
core.log("action", name .. " unbans " .. param)
end
end,
})
minetest.register_chatcommand("kick", {
core.register_chatcommand("kick", {
params = "<name> [reason]",
description = "kick a player",
privs = {kick=true},
@ -682,44 +682,44 @@ minetest.register_chatcommand("kick", {
if not tokick then
tokick = param
end
if not minetest.kick_player(tokick, reason) then
minetest.chat_send_player(name, "Failed to kick player " .. tokick)
if not core.kick_player(tokick, reason) then
core.chat_send_player(name, "Failed to kick player " .. tokick)
else
minetest.chat_send_player(name, "kicked " .. tokick)
minetest.log("action", name .. " kicked " .. tokick)
core.chat_send_player(name, "kicked " .. tokick)
core.log("action", name .. " kicked " .. tokick)
end
end,
})
minetest.register_chatcommand("clearobjects", {
core.register_chatcommand("clearobjects", {
params = "",
description = "clear all objects in world",
privs = {server=true},
func = function(name, param)
minetest.log("action", name .. " clears all objects")
minetest.chat_send_all("Clearing all objects. This may take long. You may experience a timeout. (by " .. name .. ")")
minetest.clear_objects()
minetest.log("action", "object clearing done")
minetest.chat_send_all("*** Cleared all objects.")
core.log("action", name .. " clears all objects")
core.chat_send_all("Clearing all objects. This may take long. You may experience a timeout. (by " .. name .. ")")
core.clear_objects()
core.log("action", "object clearing done")
core.chat_send_all("*** Cleared all objects.")
end,
})
minetest.register_chatcommand("msg", {
core.register_chatcommand("msg", {
params = "<name> <message>",
description = "Send a private message",
privs = {shout=true},
func = function(name, param)
local found, _, sendto, message = param:find("^([^%s]+)%s(.+)$")
if found then
if minetest.get_player_by_name(sendto) then
minetest.log("action", "PM from "..name.." to "..sendto..": "..message)
minetest.chat_send_player(sendto, "PM from "..name..": "..message)
minetest.chat_send_player(name, "Message sent")
if core.get_player_by_name(sendto) then
core.log("action", "PM from "..name.." to "..sendto..": "..message)
core.chat_send_player(sendto, "PM from "..name..": "..message)
core.chat_send_player(name, "Message sent")
else
minetest.chat_send_player(name, "The player "..sendto.." is not online")
core.chat_send_player(name, "The player "..sendto.." is not online")
end
else
minetest.chat_send_player(name, "Invalid usage, see /help msg")
core.chat_send_player(name, "Invalid usage, see /help msg")
end
end,
})

38
builtin/game/deprecated.lua
View File

@ -4,38 +4,38 @@
-- Default material types
--
function digprop_err()
minetest.log("info", debug.traceback())
minetest.log("info", "WARNING: The minetest.digprop_* functions are obsolete and need to be replaced by item groups.")
core.log("info", debug.traceback())
core.log("info", "WARNING: The core.digprop_* functions are obsolete and need to be replaced by item groups.")
end
minetest.digprop_constanttime = digprop_err
minetest.digprop_stonelike = digprop_err
minetest.digprop_dirtlike = digprop_err
minetest.digprop_gravellike = digprop_err
minetest.digprop_woodlike = digprop_err
minetest.digprop_leaveslike = digprop_err
minetest.digprop_glasslike = digprop_err
core.digprop_constanttime = digprop_err
core.digprop_stonelike = digprop_err
core.digprop_dirtlike = digprop_err
core.digprop_gravellike = digprop_err
core.digprop_woodlike = digprop_err
core.digprop_leaveslike = digprop_err
core.digprop_glasslike = digprop_err
minetest.node_metadata_inventory_move_allow_all = function()
minetest.log("info", "WARNING: minetest.node_metadata_inventory_move_allow_all is obsolete and does nothing.")
core.node_metadata_inventory_move_allow_all = function()
core.log("info", "WARNING: core.node_metadata_inventory_move_allow_all is obsolete and does nothing.")
end
minetest.add_to_creative_inventory = function(itemstring)
minetest.log('info', "WARNING: minetest.add_to_creative_inventory: This function is deprecated and does nothing.")
core.add_to_creative_inventory = function(itemstring)
core.log('info', "WARNING: core.add_to_creative_inventory: This function is deprecated and does nothing.")
end
--
-- EnvRef
--
minetest.env = {}
core.env = {}
local envref_deprecation_message_printed = false
setmetatable(minetest.env, {
setmetatable(core.env, {
__index = function(table, key)
if not envref_deprecation_message_printed then
minetest.log("info", "WARNING: minetest.env:[...] is deprecated and should be replaced with minetest.[...]")
core.log("info", "WARNING: core.env:[...] is deprecated and should be replaced with core.[...]")
envref_deprecation_message_printed = true
end
local func = minetest[key]
local func = core[key]
if type(func) == "function" then
rawset(table, key, function(self, ...)
return func(...)
@ -47,7 +47,7 @@ setmetatable(minetest.env, {
end
})
function minetest.rollback_get_last_node_actor(pos, range, seconds)
return minetest.rollback_get_node_actions(pos, range, seconds, 1)[1]
function core.rollback_get_last_node_actor(pos, range, seconds)
return core.rollback_get_node_actions(pos, range, seconds, 1)[1]
end

8
builtin/game/detached_inventory.lua
View File

@ -1,8 +1,8 @@
-- Minetest: builtin/detached_inventory.lua
minetest.detached_inventories = {}
core.detached_inventories = {}
function minetest.create_detached_inventory(name, callbacks)
function core.create_detached_inventory(name, callbacks)
local stuff = {}
stuff.name = name
if callbacks then
@ -13,7 +13,7 @@ function minetest.create_detached_inventory(name, callbacks)
stuff.on_put = callbacks.on_put
stuff.on_take = callbacks.on_take
end
minetest.detached_inventories[name] = stuff
return minetest.create_detached_inventory_raw(name)
core.detached_inventories[name] = stuff
return core.create_detached_inventory_raw(name)
end

82
builtin/game/falling.lua
View File

@ -4,7 +4,7 @@
-- Falling stuff
--
minetest.register_entity(":__builtin:falling_node", {
core.register_entity(":__builtin:falling_node", {
initial_properties = {
physical = true,
collide_with_objects = false,
@ -26,9 +26,9 @@ minetest.register_entity(":__builtin:falling_node", {
end
local item_texture = nil
local item_type = ""
if minetest.registered_items[itemname] then
item_texture = minetest.registered_items[itemname].inventory_image
item_type = minetest.registered_items[itemname].type
if core.registered_items[itemname] then
item_texture = core.registered_items[itemname].inventory_image
item_type = core.registered_items[itemname].type
end
prop = {
is_visible = true,
@ -53,12 +53,12 @@ minetest.register_entity(":__builtin:falling_node", {
-- Turn to actual sand when collides to ground or just move
local pos = self.object:getpos()
local bcp = {x=pos.x, y=pos.y-0.7, z=pos.z} -- Position of bottom center point
local bcn = minetest.get_node(bcp)
local bcd = minetest.registered_nodes[bcn.name]
local bcn = core.get_node(bcp)
local bcd = core.registered_nodes[bcn.name]
-- Note: walkable is in the node definition, not in item groups
if not bcd or
(bcd.walkable or
(minetest.get_item_group(self.node.name, "float") ~= 0 and
(core.get_item_group(self.node.name, "float") ~= 0 and
bcd.liquidtype ~= "none")) then
if bcd and bcd.leveled and
bcn.name == self.node.name then
@ -66,38 +66,38 @@ minetest.register_entity(":__builtin:falling_node", {
if addlevel == nil or addlevel <= 0 then
addlevel = bcd.leveled
end
if minetest.add_node_level(bcp, addlevel) == 0 then
if core.add_node_level(bcp, addlevel) == 0 then
self.object:remove()
return
end
elseif bcd and bcd.buildable_to and
(minetest.get_item_group(self.node.name, "float") == 0 or
(core.get_item_group(self.node.name, "float") == 0 or
bcd.liquidtype == "none") then
minetest.remove_node(bcp)
core.remove_node(bcp)
return
end
local np = {x=bcp.x, y=bcp.y+1, z=bcp.z}
-- Check what's here
local n2 = minetest.get_node(np)
local n2 = core.get_node(np)
-- If it's not air or liquid, remove node and replace it with
-- it's drops
if n2.name ~= "air" and (not minetest.registered_nodes[n2.name] or
minetest.registered_nodes[n2.name].liquidtype == "none") then
local drops = minetest.get_node_drops(n2.name, "")
minetest.remove_node(np)
if n2.name ~= "air" and (not core.registered_nodes[n2.name] or
core.registered_nodes[n2.name].liquidtype == "none") then
local drops = core.get_node_drops(n2.name, "")
core.remove_node(np)
-- Add dropped items
local _, dropped_item
for _, dropped_item in ipairs(drops) do
minetest.add_item(np, dropped_item)
core.add_item(np, dropped_item)
end
-- Run script hook
local _, callback
for _, callback in ipairs(minetest.registered_on_dignodes) do
for _, callback in ipairs(core.registered_on_dignodes) do
callback(np, n2, nil)
end
end
-- Create node and remove entity
minetest.add_node(np, self.node)
core.add_node(np, self.node)
self.object:remove()
nodeupdate(np)
else
@ -107,25 +107,25 @@ minetest.register_entity(":__builtin:falling_node", {
})
function spawn_falling_node(p, node)
obj = minetest.add_entity(p, "__builtin:falling_node")
obj = core.add_entity(p, "__builtin:falling_node")
obj:get_luaentity():set_node(node)
end
function drop_attached_node(p)
local nn = minetest.get_node(p).name
minetest.remove_node(p)
for _,item in ipairs(minetest.get_node_drops(nn, "")) do
local nn = core.get_node(p).name
core.remove_node(p)
for _,item in ipairs(core.get_node_drops(nn, "")) do
local pos = {
x = p.x + math.random()/2 - 0.25,
y = p.y + math.random()/2 - 0.25,
z = p.z + math.random()/2 - 0.25,
}
minetest.add_item(pos, item)
core.add_item(pos, item)
end
end
function check_attached_node(p, n)
local def = minetest.registered_nodes[n.name]
local def = core.registered_nodes[n.name]
local d = {x=0, y=0, z=0}
if def.paramtype2 == "wallmounted" then
if n.param2 == 0 then
@ -145,8 +145,8 @@ function check_attached_node(p, n)
d.y = -1
end
local p2 = {x=p.x+d.x, y=p.y+d.y, z=p.z+d.z}
local nn = minetest.get_node(p2).name
local def2 = minetest.registered_nodes[nn]
local nn = core.get_node(p2).name
local def2 = core.registered_nodes[nn]
if def2 and not def2.walkable then
return false
end
@ -158,28 +158,30 @@ end
--
function nodeupdate_single(p, delay)
n = minetest.get_node(p)
if minetest.get_item_group(n.name, "falling_node") ~= 0 then
n = core.get_node(p)
if core.get_item_group(n.name, "falling_node") ~= 0 then
p_bottom = {x=p.x, y=p.y-1, z=p.z}
n_bottom = minetest.get_node(p_bottom)
n_bottom = core.get_node(p_bottom)
-- Note: walkable is in the node definition, not in item groups
if minetest.registered_nodes[n_bottom.name] and
(minetest.get_item_group(n.name, "float") == 0 or minetest.registered_nodes[n_bottom.name].liquidtype == "none") and
(n.name ~= n_bottom.name or (minetest.registered_nodes[n_bottom.name].leveled and minetest.env:get_node_level(p_bottom) < minetest.env:get_node_max_level(p_bottom))) and
(not minetest.registered_nodes[n_bottom.name].walkable or
minetest.registered_nodes[n_bottom.name].buildable_to) then
if core.registered_nodes[n_bottom.name] and
(core.get_item_group(n.name, "float") == 0 or
core.registered_nodes[n_bottom.name].liquidtype == "none") and
(n.name ~= n_bottom.name or (core.registered_nodes[n_bottom.name].leveled and
core.get_node_level(p_bottom) < core.get_node_max_level(p_bottom))) and
(not core.registered_nodes[n_bottom.name].walkable or
core.registered_nodes[n_bottom.name].buildable_to) then
if delay then
minetest.after(0.1, nodeupdate_single, {x=p.x, y=p.y, z=p.z}, false)
core.after(0.1, nodeupdate_single, {x=p.x, y=p.y, z=p.z}, false)
else
n.level = minetest.env:get_node_level(p)
minetest.remove_node(p)
n.level = core.env:get_node_level(p)
core.remove_node(p)
spawn_falling_node(p, n)
nodeupdate(p)
end
end
end
if minetest.get_item_group(n.name, "attached_node") ~= 0 then
if core.get_item_group(n.name, "attached_node") ~= 0 then
if not check_attached_node(p, n) then
drop_attached_node(p)
nodeupdate(p)
@ -209,9 +211,9 @@ end
function on_placenode(p, node)
nodeupdate(p)
end
minetest.register_on_placenode(on_placenode)
core.register_on_placenode(on_placenode)
function on_dignode(p, node)
nodeupdate(p)
end
minetest.register_on_dignode(on_dignode)
core.register_on_dignode(on_dignode)

8
builtin/game/features.lua
View File

@ -1,6 +1,6 @@
-- Minetest: builtin/features.lua
minetest.features = {
core.features = {
glasslike_framed = true,
nodebox_as_selectionbox = true,
chat_send_player_param3 = true,
@ -9,19 +9,19 @@ minetest.features = {
no_legacy_abms = true,
}
function minetest.has_feature(arg)
function core.has_feature(arg)
if type(arg) == "table" then
missing_features = {}
result = true
for ft, _ in pairs(arg) do
if not minetest.features[ftr] then
if not core.features[ftr] then
missing_features[ftr] = true
result = false
end
end
return result, missing_features
elseif type(arg) == "string" then
if not minetest.features[arg] then
if not core.features[arg] then
return false, {[arg]=true}
end
return true, {}

30
builtin/game/forceloading.lua
View File

@ -1,8 +1,8 @@
-- Prevent anyone else accessing those functions
local forceload_block = minetest.forceload_block
local forceload_free_block = minetest.forceload_free_block
minetest.forceload_block = nil
minetest.forceload_free_block = nil
local forceload_block = core.forceload_block
local forceload_free_block = core.forceload_free_block
core.forceload_block = nil
core.forceload_free_block = nil
local blocks_forceloaded
local total_forceloaded = 0
@ -15,14 +15,14 @@ local function get_blockpos(pos)
z = math.floor(pos.z/BLOCKSIZE)}
end
function minetest.forceload_block(pos)
function core.forceload_block(pos)
local blockpos = get_blockpos(pos)
local hash = minetest.hash_node_position(blockpos)
local hash = core.hash_node_position(blockpos)
if blocks_forceloaded[hash] ~= nil then
blocks_forceloaded[hash] = blocks_forceloaded[hash] + 1
return true
else
if total_forceloaded >= (tonumber(minetest.setting_get("max_forceloaded_blocks")) or 16) then
if total_forceloaded >= (tonumber(core.setting_get("max_forceloaded_blocks")) or 16) then
return false
end
total_forceloaded = total_forceloaded+1
@ -32,9 +32,9 @@ function minetest.forceload_block(pos)
end
end
function minetest.forceload_free_block(pos)
function core.forceload_free_block(pos)
local blockpos = get_blockpos(pos)
local hash = minetest.hash_node_position(blockpos)
local hash = core.hash_node_position(blockpos)
if blocks_forceloaded[hash] == nil then return end
if blocks_forceloaded[hash] > 1 then
blocks_forceloaded[hash] = blocks_forceloaded[hash] - 1
@ -46,19 +46,19 @@ function minetest.forceload_free_block(pos)
end
-- Keep the forceloaded areas after restart
local wpath = minetest.get_worldpath()
local wpath = core.get_worldpath()
local function read_file(filename)
local f = io.open(filename, "r")
if f==nil then return {} end
local t = f:read("*all")
f:close()
if t=="" or t==nil then return {} end
return minetest.deserialize(t)
return core.deserialize(t)
end
local function write_file(filename, table)
local f = io.open(filename, "w")
f:write(minetest.serialize(table))
f:write(core.serialize(table))
f:close()
end
@ -67,13 +67,13 @@ for _, __ in pairs(blocks_forceloaded) do
total_forceloaded = total_forceloaded + 1
end
minetest.after(5, function()
core.after(5, function()
for hash, _ in pairs(blocks_forceloaded) do
local blockpos = minetest.get_position_from_hash(hash)
local blockpos = core.get_position_from_hash(hash)
forceload_block(blockpos)
end
end)
minetest.register_on_shutdown(function()
core.register_on_shutdown(function()
write_file(wpath.."/force_loaded.txt", blocks_forceloaded)
end)

160
builtin/game/item.lua
View File

@ -13,7 +13,7 @@ end
-- Item definition helpers
--
function minetest.inventorycube(img1, img2, img3)
function core.inventorycube(img1, img2, img3)
img2 = img2 or img1
img3 = img3 or img1
return "[inventorycube"
@ -22,7 +22,7 @@ function minetest.inventorycube(img1, img2, img3)
.. "{" .. img3:gsub("%^", "&")
end
function minetest.get_pointed_thing_position(pointed_thing, above)
function core.get_pointed_thing_position(pointed_thing, above)
if pointed_thing.type == "node" then
if above then
-- The position where a node would be placed
@ -43,7 +43,7 @@ function minetest.get_pointed_thing_position(pointed_thing, above)
end
end
function minetest.dir_to_facedir(dir, is6d)
function core.dir_to_facedir(dir, is6d)
--account for y if requested
if is6d and math.abs(dir.y) > math.abs(dir.x) and math.abs(dir.y) > math.abs(dir.z) then
@ -96,7 +96,7 @@ function minetest.dir_to_facedir(dir, is6d)
end
end
function minetest.facedir_to_dir(facedir)
function core.facedir_to_dir(facedir)
--a table of possible dirs
return ({{x=0, y=0, z=1},
{x=1, y=0, z=0},
@ -117,7 +117,7 @@ function minetest.facedir_to_dir(facedir)
[facedir]]
end
function minetest.dir_to_wallmounted(dir)
function core.dir_to_wallmounted(dir)
if math.abs(dir.y) > math.max(math.abs(dir.x), math.abs(dir.z)) then
if dir.y < 0 then
return 1
@ -139,7 +139,7 @@ function minetest.dir_to_wallmounted(dir)
end
end
function minetest.get_node_drops(nodename, toolname)
function core.get_node_drops(nodename, toolname)
local drop = ItemStack({name=nodename}):get_definition().drop
if drop == nil then
-- default drop
@ -188,7 +188,7 @@ function minetest.get_node_drops(nodename, toolname)
return got_items
end
function minetest.item_place_node(itemstack, placer, pointed_thing, param2)
function core.item_place_node(itemstack, placer, pointed_thing, param2)
local item = itemstack:peek_item()
local def = itemstack:get_definition()
if def.type ~= "node" or pointed_thing.type ~= "node" then
@ -196,24 +196,24 @@ function minetest.item_place_node(itemstack, placer, pointed_thing, param2)
end
local under = pointed_thing.under
local oldnode_under = minetest.get_node_or_nil(under)
local oldnode_under = core.get_node_or_nil(under)
local above = pointed_thing.above
local oldnode_above = minetest.get_node_or_nil(above)
local oldnode_above = core.get_node_or_nil(above)
if not oldnode_under or not oldnode_above then
minetest.log("info", placer:get_player_name() .. " tried to place"
.. " node in unloaded position " .. minetest.pos_to_string(above))
core.log("info", placer:get_player_name() .. " tried to place"
.. " node in unloaded position " .. core.pos_to_string(above))
return itemstack, false
end
local olddef_under = ItemStack({name=oldnode_under.name}):get_definition()
olddef_under = olddef_under or minetest.nodedef_default
olddef_under = olddef_under or core.nodedef_default
local olddef_above = ItemStack({name=oldnode_above.name}):get_definition()
olddef_above = olddef_above or minetest.nodedef_default
olddef_above = olddef_above or core.nodedef_default
if not olddef_above.buildable_to and not olddef_under.buildable_to then
minetest.log("info", placer:get_player_name() .. " tried to place"
.. " node in invalid position " .. minetest.pos_to_string(above)
core.log("info", placer:get_player_name() .. " tried to place"
.. " node in invalid position " .. core.pos_to_string(above)
.. ", replacing " .. oldnode_above.name)
return itemstack, false
end
@ -223,23 +223,23 @@ function minetest.item_place_node(itemstack, placer, pointed_thing, param2)
-- If node under is buildable_to, place into it instead (eg. snow)
if olddef_under.buildable_to then
minetest.log("info", "node under is buildable to")
core.log("info", "node under is buildable to")
place_to = {x = under.x, y = under.y, z = under.z}
end
if minetest.is_protected(place_to, placer:get_player_name()) then
minetest.log("action", placer:get_player_name()
if core.is_protected(place_to, placer:get_player_name()) then
core.log("action", placer:get_player_name()
.. " tried to place " .. def.name
.. " at protected position "
.. minetest.pos_to_string(place_to))
minetest.record_protection_violation(place_to, placer:get_player_name())
.. core.pos_to_string(place_to))
core.record_protection_violation(place_to, placer:get_player_name())
return itemstack
end
minetest.log("action", placer:get_player_name() .. " places node "
.. def.name .. " at " .. minetest.pos_to_string(place_to))
core.log("action", placer:get_player_name() .. " places node "
.. def.name .. " at " .. core.pos_to_string(place_to))
local oldnode = minetest.get_node(place_to)
local oldnode = core.get_node(place_to)
local newnode = {name = def.name, param1 = 0, param2 = param2}
-- Calculate direction for wall mounted stuff like torches and signs
@ -249,7 +249,7 @@ function minetest.item_place_node(itemstack, placer, pointed_thing, param2)
y = under.y - above.y,
z = under.z - above.z
}
newnode.param2 = minetest.dir_to_wallmounted(dir)
newnode.param2 = core.dir_to_wallmounted(dir)
-- Calculate the direction for furnaces and chests and stuff
elseif def.paramtype2 == 'facedir' and not param2 then
local placer_pos = placer:getpos()
@ -259,21 +259,21 @@ function minetest.item_place_node(itemstack, placer, pointed_thing, param2)
y = above.y - placer_pos.y,
z = above.z - placer_pos.z
}
newnode.param2 = minetest.dir_to_facedir(dir)
minetest.log("action", "facedir: " .. newnode.param2)
newnode.param2 = core.dir_to_facedir(dir)
core.log("action", "facedir: " .. newnode.param2)
end
end
-- Check if the node is attached and if it can be placed there
if minetest.get_item_group(def.name, "attached_node") ~= 0 and
if core.get_item_group(def.name, "attached_node") ~= 0 and
not check_attached_node(place_to, newnode) then
minetest.log("action", "attached node " .. def.name ..
" can not be placed at " .. minetest.pos_to_string(place_to))
core.log("action", "attached node " .. def.name ..
" can not be placed at " .. core.pos_to_string(place_to))
return itemstack, false
end
-- Add node and update
minetest.add_node(place_to, newnode)
core.add_node(place_to, newnode)
local take_item = true
@ -290,7 +290,7 @@ function minetest.item_place_node(itemstack, placer, pointed_thing, param2)
-- Run script hook
local _, callback
for _, callback in ipairs(minetest.registered_on_placenodes) do
for _, callback in ipairs(core.registered_on_placenodes) do
-- Deepcopy pos, node and pointed_thing because callback can modify them
local place_to_copy = {x=place_to.x, y=place_to.y, z=place_to.z}
local newnode_copy = {name=newnode.name, param1=newnode.param1, param2=newnode.param2}
@ -307,38 +307,38 @@ function minetest.item_place_node(itemstack, placer, pointed_thing, param2)
return itemstack, true
end
function minetest.item_place_object(itemstack, placer, pointed_thing)
local pos = minetest.get_pointed_thing_position(pointed_thing, true)
function core.item_place_object(itemstack, placer, pointed_thing)
local pos = core.get_pointed_thing_position(pointed_thing, true)
if pos ~= nil then
local item = itemstack:take_item()
minetest.add_item(pos, item)
core.add_item(pos, item)
end
return itemstack
end
function minetest.item_place(itemstack, placer, pointed_thing, param2)
function core.item_place(itemstack, placer, pointed_thing, param2)
-- Call on_rightclick if the pointed node defines it
if pointed_thing.type == "node" and placer and
not placer:get_player_control().sneak then
local n = minetest.get_node(pointed_thing.under)
local n = core.get_node(pointed_thing.under)
local nn = n.name
if minetest.registered_nodes[nn] and minetest.registered_nodes[nn].on_rightclick then
return minetest.registered_nodes[nn].on_rightclick(pointed_thing.under, n,
if core.registered_nodes[nn] and core.registered_nodes[nn].on_rightclick then
return core.registered_nodes[nn].on_rightclick(pointed_thing.under, n,
placer, itemstack, pointed_thing) or itemstack, false
end
end
if itemstack:get_definition().type == "node" then
return minetest.item_place_node(itemstack, placer, pointed_thing, param2)
return core.item_place_node(itemstack, placer, pointed_thing, param2)
end
return itemstack
end
function minetest.item_drop(itemstack, dropper, pos)
function core.item_drop(itemstack, dropper, pos)
if dropper.get_player_name then
local v = dropper:get_look_dir()
local p = {x=pos.x+v.x, y=pos.y+1.5+v.y, z=pos.z+v.z}
local obj = minetest.add_item(p, itemstack)
local obj = core.add_item(p, itemstack)
if obj then
v.x = v.x*2
v.y = v.y*2 + 1
@ -346,12 +346,12 @@ function minetest.item_drop(itemstack, dropper, pos)
obj:setvelocity(v)
end
else
minetest.add_item(pos, itemstack)
core.add_item(pos, itemstack)
end
return ItemStack("")
end
function minetest.item_eat(hp_change, replace_with_item)
function core.item_eat(hp_change, replace_with_item)
return function(itemstack, user, pointed_thing) -- closure
if itemstack:take_item() ~= nil then
user:set_hp(user:get_hp() + hp_change)
@ -361,9 +361,9 @@ function minetest.item_eat(hp_change, replace_with_item)
end
end
function minetest.node_punch(pos, node, puncher, pointed_thing)
function core.node_punch(pos, node, puncher, pointed_thing)
-- Run script hook
for _, callback in ipairs(minetest.registered_on_punchnodes) do
for _, callback in ipairs(core.registered_on_punchnodes) do
-- Copy pos and node because callback can modify them
local pos_copy = vector.new(pos)
local node_copy = {name=node.name, param1=node.param1, param2=node.param2}
@ -372,7 +372,7 @@ function minetest.node_punch(pos, node, puncher, pointed_thing)
end
end
function minetest.handle_node_drops(pos, drops, digger)
function core.handle_node_drops(pos, drops, digger)
-- Add dropped items to object's inventory
if digger:get_inventory() then
local _, dropped_item
@ -384,59 +384,59 @@ function minetest.handle_node_drops(pos, drops, digger)
y = pos.y + math.random()/2-0.25,
z = pos.z + math.random()/2-0.25,
}
minetest.add_item(p, left)
core.add_item(p, left)
end
end
end
end
function minetest.node_dig(pos, node, digger)
function core.node_dig(pos, node, digger)
local def = ItemStack({name=node.name}):get_definition()
if not def.diggable or (def.can_dig and not def.can_dig(pos,digger)) then
minetest.log("info", digger:get_player_name() .. " tried to dig "
core.log("info", digger:get_player_name() .. " tried to dig "
.. node.name .. " which is not diggable "
.. minetest.pos_to_string(pos))
.. core.pos_to_string(pos))
return
end
if minetest.is_protected(pos, digger:get_player_name()) then
minetest.log("action", digger:get_player_name()
if core.is_protected(pos, digger:get_player_name()) then
core.log("action", digger:get_player_name()
.. " tried to dig " .. node.name
.. " at protected position "
.. minetest.pos_to_string(pos))
minetest.record_protection_violation(pos, digger:get_player_name())
.. core.pos_to_string(pos))
core.record_protection_violation(pos, digger:get_player_name())
return
end
minetest.log('action', digger:get_player_name() .. " digs "
.. node.name .. " at " .. minetest.pos_to_string(pos))
core.log('action', digger:get_player_name() .. " digs "
.. node.name .. " at " .. core.pos_to_string(pos))
local wielded = digger:get_wielded_item()
local drops = minetest.get_node_drops(node.name, wielded:get_name())
local drops = core.get_node_drops(node.name, wielded:get_name())
local wdef = wielded:get_definition()
local tp = wielded:get_tool_capabilities()
local dp = minetest.get_dig_params(def.groups, tp)
local dp = core.get_dig_params(def.groups, tp)
if wdef and wdef.after_use then
wielded = wdef.after_use(wielded, digger, node, dp) or wielded
else
-- Wear out tool
if not minetest.setting_getbool("creative_mode") then
if not core.setting_getbool("creative_mode") then
wielded:add_wear(dp.wear)
end
end
digger:set_wielded_item(wielded)
-- Handle drops
minetest.handle_node_drops(pos, drops, digger)
core.handle_node_drops(pos, drops, digger)
local oldmetadata = nil
if def.after_dig_node then
oldmetadata = minetest.get_meta(pos):to_table()
oldmetadata = core.get_meta(pos):to_table()
end
-- Remove node and update
minetest.remove_node(pos)
core.remove_node(pos)
-- Run callback
if def.after_dig_node then
@ -448,7 +448,7 @@ function minetest.node_dig(pos, node, digger)
-- Run script hook
local _, callback
for _, callback in ipairs(minetest.registered_on_dignodes) do
for _, callback in ipairs(core.registered_on_dignodes) do
-- Copy pos and node because callback can modify them
local pos_copy = {x=pos.x, y=pos.y, z=pos.z}
local node_copy = {name=node.name, param1=node.param1, param2=node.param2}
@ -456,7 +456,7 @@ function minetest.node_dig(pos, node, digger)
end
end
-- This is used to allow mods to redefine minetest.item_place and so on
-- This is used to allow mods to redefine core.item_place and so on
-- NOTE: This is not the preferred way. Preferred way is to provide enough
-- callbacks to not require redefining global functions. -celeron55
local function redef_wrapper(table, name)
@ -469,7 +469,7 @@ end
-- Item definition defaults
--
minetest.nodedef_default = {
core.nodedef_default = {
-- Item properties
type="node",
-- name intentionally not defined here
@ -485,20 +485,20 @@ minetest.nodedef_default = {
node_placement_prediction = nil,
-- Interaction callbacks
on_place = redef_wrapper(minetest, 'item_place'), -- minetest.item_place
on_drop = redef_wrapper(minetest, 'item_drop'), -- minetest.item_drop
on_place = redef_wrapper(core, 'item_place'), -- core.item_place
on_drop = redef_wrapper(core, 'item_drop'), -- core.item_drop
on_use = nil,
can_dig = nil,
on_punch = redef_wrapper(minetest, 'node_punch'), -- minetest.node_punch
on_punch = redef_wrapper(core, 'node_punch'), -- core.node_punch
on_rightclick = nil,
on_dig = redef_wrapper(minetest, 'node_dig'), -- minetest.node_dig
on_dig = redef_wrapper(core, 'node_dig'), -- core.node_dig
on_receive_fields = nil,
on_metadata_inventory_move = minetest.node_metadata_inventory_move_allow_all,
on_metadata_inventory_offer = minetest.node_metadata_inventory_offer_allow_all,
on_metadata_inventory_take = minetest.node_metadata_inventory_take_allow_all,
on_metadata_inventory_move = core.node_metadata_inventory_move_allow_all,
on_metadata_inventory_offer = core.node_metadata_inventory_offer_allow_all,
on_metadata_inventory_take = core.node_metadata_inventory_take_allow_all,
-- Node properties
drawtype = "normal",
@ -533,7 +533,7 @@ minetest.nodedef_default = {
legacy_wallmounted = false,
}
minetest.craftitemdef_default = {
core.craftitemdef_default = {
type="craft",
-- name intentionally not defined here
description = "",
@ -546,12 +546,12 @@ minetest.craftitemdef_default = {
tool_capabilities = nil,
-- Interaction callbacks
on_place = redef_wrapper(minetest, 'item_place'), -- minetest.item_place
on_drop = redef_wrapper(minetest, 'item_drop'), -- minetest.item_drop
on_place = redef_wrapper(core, 'item_place'), -- core.item_place
on_drop = redef_wrapper(core, 'item_drop'), -- core.item_drop
on_use = nil,
}
minetest.tooldef_default = {
core.tooldef_default = {
type="tool",
-- name intentionally not defined here
description = "",
@ -564,12 +564,12 @@ minetest.tooldef_default = {
tool_capabilities = nil,
-- Interaction callbacks
on_place = redef_wrapper(minetest, 'item_place'), -- minetest.item_place
on_drop = redef_wrapper(minetest, 'item_drop'), -- minetest.item_drop
on_place = redef_wrapper(core, 'item_place'), -- core.item_place
on_drop = redef_wrapper(core, 'item_drop'), -- core.item_drop
on_use = nil,
}
minetest.noneitemdef_default = { -- This is used for the hand and unknown items
core.noneitemdef_default = { -- This is used for the hand and unknown items
type="none",
-- name intentionally not defined here
description = "",
@ -582,7 +582,7 @@ minetest.noneitemdef_default = { -- This is used for the hand and unknown items
tool_capabilities = nil,
-- Interaction callbacks
on_place = redef_wrapper(minetest, 'item_place'),
on_place = redef_wrapper(core, 'item_place'),
on_drop = nil,
on_use = nil,
}

20
builtin/game/item_entity.lua
View File

@ -1,14 +1,14 @@
-- Minetest: builtin/item_entity.lua
function minetest.spawn_item(pos, item)
function core.spawn_item(pos, item)
-- Take item in any format
local stack = ItemStack(item)
local obj = minetest.add_entity(pos, "__builtin:item")
local obj = core.add_entity(pos, "__builtin:item")
obj:get_luaentity():set_item(stack:to_string())
return obj
end
minetest.register_entity(":__builtin:item", {
core.register_entity(":__builtin:item", {
initial_properties = {
hp_max = 1,
physical = true,
@ -35,9 +35,9 @@ minetest.register_entity(":__builtin:item", {
end
local item_texture = nil
local item_type = ""
if minetest.registered_items[itemname] then
item_texture = minetest.registered_items[itemname].inventory_image
item_type = minetest.registered_items[itemname].type
if core.registered_items[itemname] then
item_texture = core.registered_items[itemname].inventory_image
item_type = core.registered_items[itemname].type
end
prop = {
is_visible = true,
@ -59,7 +59,7 @@ minetest.register_entity(":__builtin:item", {
get_staticdata = function(self)
--return self.itemstring
return minetest.serialize({
return core.serialize({
itemstring = self.itemstring,
always_collect = self.always_collect,
})
@ -67,7 +67,7 @@ minetest.register_entity(":__builtin:item", {
on_activate = function(self, staticdata)
if string.sub(staticdata, 1, string.len("return")) == "return" then
local data = minetest.deserialize(staticdata)
local data = core.deserialize(staticdata)
if data and type(data) == "table" then
self.itemstring = data.itemstring
self.always_collect = data.always_collect
@ -84,10 +84,10 @@ minetest.register_entity(":__builtin:item", {
on_step = function(self, dtime)
local p = self.object:getpos()
p.y = p.y - 0.3
local nn = minetest.get_node(p).name
local nn = core.get_node(p).name
-- If node is not registered or node is walkably solid and resting on nodebox
local v = self.object:getvelocity()
if not minetest.registered_nodes[nn] or minetest.registered_nodes[nn].walkable and v.y == 0 then
if not core.registered_nodes[nn] or core.registered_nodes[nn].walkable and v.y == 0 then
if self.physical_state then
self.object:setvelocity({x=0,y=0,z=0})
self.object:setacceleration({x=0, y=0, z=0})

70
builtin/game/misc.lua
View File

@ -4,30 +4,30 @@
-- Misc. API functions
--
minetest.timers_to_add = {}
minetest.timers = {}
minetest.register_globalstep(function(dtime)
for _, timer in ipairs(minetest.timers_to_add) do
table.insert(minetest.timers, timer)
core.timers_to_add = {}
core.timers = {}
core.register_globalstep(function(dtime)
for _, timer in ipairs(core.timers_to_add) do
table.insert(core.timers, timer)
end
minetest.timers_to_add = {}
for index, timer in ipairs(minetest.timers) do
core.timers_to_add = {}
for index, timer in ipairs(core.timers) do
timer.time = timer.time - dtime
if timer.time <= 0 then
timer.func(unpack(timer.args or {}))
table.remove(minetest.timers,index)
table.remove(core.timers,index)
end
end
end)
function minetest.after(time, func, ...)
function core.after(time, func, ...)
assert(tonumber(time) and type(func) == "function",
"Invalid minetest.after invocation")
table.insert(minetest.timers_to_add, {time=time, func=func, args={...}})
"Invalid core.after invocation")
table.insert(core.timers_to_add, {time=time, func=func, args={...}})
end
function minetest.check_player_privs(name, privs)
local player_privs = minetest.get_player_privs(name)
function core.check_player_privs(name, privs)
local player_privs = core.get_player_privs(name)
local missing_privileges = {}
for priv, val in pairs(privs) do
if val then
@ -44,15 +44,15 @@ end
local player_list = {}
minetest.register_on_joinplayer(function(player)
core.register_on_joinplayer(function(player)
player_list[player:get_player_name()] = player
end)
minetest.register_on_leaveplayer(function(player)
core.register_on_leaveplayer(function(player)
player_list[player:get_player_name()] = nil
end)
function minetest.get_connected_players()
function core.get_connected_players()
local temp_table = {}
for index, value in pairs(player_list) do
if value:is_player_connected() then
@ -62,11 +62,11 @@ function minetest.get_connected_players()
return temp_table
end
function minetest.hash_node_position(pos)
function core.hash_node_position(pos)
return (pos.z+32768)*65536*65536 + (pos.y+32768)*65536 + pos.x+32768
end
function minetest.get_position_from_hash(hash)
function core.get_position_from_hash(hash)
local pos = {}
pos.x = (hash%65536) - 32768
hash = math.floor(hash/65536)
@ -76,20 +76,20 @@ function minetest.get_position_from_hash(hash)
return pos
end
function minetest.get_item_group(name, group)
if not minetest.registered_items[name] or not
minetest.registered_items[name].groups[group] then
function core.get_item_group(name, group)
if not core.registered_items[name] or not
core.registered_items[name].groups[group] then
return 0
end
return minetest.registered_items[name].groups[group]
return core.registered_items[name].groups[group]
end
function minetest.get_node_group(name, group)
minetest.log("deprecated", "Deprecated usage of get_node_group, use get_item_group instead")
return minetest.get_item_group(name, group)
function core.get_node_group(name, group)
core.log("deprecated", "Deprecated usage of get_node_group, use get_item_group instead")
return core.get_item_group(name, group)
end
function minetest.string_to_pos(value)
function core.string_to_pos(value)
local p = {}
p.x, p.y, p.z = string.match(value, "^([%d.-]+)[, ] *([%d.-]+)[, ] *([%d.-]+)$")
if p.x and p.y and p.z then
@ -109,25 +109,25 @@ function minetest.string_to_pos(value)
return nil
end
assert(minetest.string_to_pos("10.0, 5, -2").x == 10)
assert(minetest.string_to_pos("( 10.0, 5, -2)").z == -2)
assert(minetest.string_to_pos("asd, 5, -2)") == nil)
assert(core.string_to_pos("10.0, 5, -2").x == 10)
assert(core.string_to_pos("( 10.0, 5, -2)").z == -2)
assert(core.string_to_pos("asd, 5, -2)") == nil)
function minetest.setting_get_pos(name)
local value = minetest.setting_get(name)
function core.setting_get_pos(name)
local value = core.setting_get(name)
if not value then
return nil
end
return minetest.string_to_pos(value)
return core.string_to_pos(value)
end
-- To be overriden by protection mods
function minetest.is_protected(pos, name)
function core.is_protected(pos, name)
return false
end
function minetest.record_protection_violation(pos, name)
for _, func in pairs(minetest.registered_on_protection_violation) do
function core.record_protection_violation(pos, name)
for _, func in pairs(core.registered_on_protection_violation) do
func(pos, name)
end
end

38
builtin/game/privileges.lua
View File

@ -4,9 +4,9 @@
-- Privileges
--
minetest.registered_privileges = {}
core.registered_privileges = {}
function minetest.register_privilege(name, param)
function core.register_privilege(name, param)
local function fill_defaults(def)
if def.give_to_singleplayer == nil then
def.give_to_singleplayer = true
@ -22,32 +22,32 @@ function minetest.register_privilege(name, param)
def = {description = param}
end
fill_defaults(def)
minetest.registered_privileges[name] = def
core.registered_privileges[name] = def
end
minetest.register_privilege("interact", "Can interact with things and modify the world")
minetest.register_privilege("teleport", "Can use /teleport command")
minetest.register_privilege("bring", "Can teleport other players")
minetest.register_privilege("settime", "Can use /time")
minetest.register_privilege("privs", "Can modify privileges")
minetest.register_privilege("basic_privs", "Can modify 'shout' and 'interact' privileges")
minetest.register_privilege("server", "Can do server maintenance stuff")
minetest.register_privilege("shout", "Can speak in chat")
minetest.register_privilege("ban", "Can ban and unban players")
minetest.register_privilege("kick", "Can kick players")
minetest.register_privilege("give", "Can use /give and /giveme")
minetest.register_privilege("password", "Can use /setpassword and /clearpassword")
minetest.register_privilege("fly", {
core.register_privilege("interact", "Can interact with things and modify the world")
core.register_privilege("teleport", "Can use /teleport command")
core.register_privilege("bring", "Can teleport other players")
core.register_privilege("settime", "Can use /time")
core.register_privilege("privs", "Can modify privileges")
core.register_privilege("basic_privs", "Can modify 'shout' and 'interact' privileges")
core.register_privilege("server", "Can do server maintenance stuff")
core.register_privilege("shout", "Can speak in chat")
core.register_privilege("ban", "Can ban and unban players")
core.register_privilege("kick", "Can kick players")
core.register_privilege("give", "Can use /give and /giveme")
core.register_privilege("password", "Can use /setpassword and /clearpassword")
core.register_privilege("fly", {
description = "Can fly using the free_move mode",
give_to_singleplayer = false,
})
minetest.register_privilege("fast", {
core.register_privilege("fast", {
description = "Can walk fast using the fast_move mode",
give_to_singleplayer = false,
})
minetest.register_privilege("noclip", {
core.register_privilege("noclip", {
description = "Can fly through walls",
give_to_singleplayer = false,
})
minetest.register_privilege("rollback", "Can use the rollback functionality")
core.register_privilege("rollback", "Can use the rollback functionality")

180
builtin/game/register.lua
View File

@ -4,35 +4,35 @@
-- Make raw registration functions inaccessible to anyone except this file
--
local register_item_raw = minetest.register_item_raw
minetest.register_item_raw = nil
local register_item_raw = core.register_item_raw
core.register_item_raw = nil
local register_alias_raw = minetest.register_alias_raw
minetest.register_item_raw = nil
local register_alias_raw = core.register_alias_raw
core.register_item_raw = nil
--
-- Item / entity / ABM registration functions
--
minetest.registered_abms = {}
minetest.registered_entities = {}
minetest.registered_items = {}
minetest.registered_nodes = {}
minetest.registered_craftitems = {}
minetest.registered_tools = {}
minetest.registered_aliases = {}
core.registered_abms = {}
core.registered_entities = {}
core.registered_items = {}
core.registered_nodes = {}
core.registered_craftitems = {}
core.registered_tools = {}
core.registered_aliases = {}
-- For tables that are indexed by item name:
-- If table[X] does not exist, default to table[minetest.registered_aliases[X]]
-- If table[X] does not exist, default to table[core.registered_aliases[X]]
local alias_metatable = {
__index = function(t, name)
return rawget(t, minetest.registered_aliases[name])
return rawget(t, core.registered_aliases[name])
end
}
setmetatable(minetest.registered_items, alias_metatable)
setmetatable(minetest.registered_nodes, alias_metatable)
setmetatable(minetest.registered_craftitems, alias_metatable)
setmetatable(minetest.registered_tools, alias_metatable)
setmetatable(core.registered_items, alias_metatable)
setmetatable(core.registered_nodes, alias_metatable)
setmetatable(core.registered_craftitems, alias_metatable)
setmetatable(core.registered_tools, alias_metatable)
-- These item names may not be used because they would interfere
-- with legacy itemstrings
@ -55,7 +55,7 @@ local function check_modname_prefix(name)
return name:sub(2)
else
-- Modname prefix enforcement
local expected_prefix = minetest.get_current_modname() .. ":"
local expected_prefix = core.get_current_modname() .. ":"
if name:sub(1, #expected_prefix) ~= expected_prefix then
error("Name " .. name .. " does not follow naming conventions: " ..
"\"modname:\" or \":\" prefix required")
@ -69,12 +69,12 @@ local function check_modname_prefix(name)
end
end
function minetest.register_abm(spec)
-- Add to minetest.registered_abms
minetest.registered_abms[#minetest.registered_abms+1] = spec
function core.register_abm(spec)
-- Add to core.registered_abms
core.registered_abms[#core.registered_abms+1] = spec
end
function minetest.register_entity(name, prototype)
function core.register_entity(name, prototype)
-- Check name
if name == nil then
error("Unable to register entity: Name is nil")
@ -84,11 +84,11 @@ function minetest.register_entity(name, prototype)
prototype.name = name
prototype.__index = prototype -- so that it can be used as a metatable
-- Add to minetest.registered_entities
minetest.registered_entities[name] = prototype
-- Add to core.registered_entities
core.registered_entities[name] = prototype
end
function minetest.register_item(name, itemdef)
function core.register_item(name, itemdef)
-- Check name
if name == nil then
error("Unable to register item: Name is nil")
@ -110,16 +110,16 @@ function minetest.register_item(name, itemdef)
fixed = {-1/8, -1/2, -1/8, 1/8, 1/2, 1/8},
}
end
setmetatable(itemdef, {__index = minetest.nodedef_default})
minetest.registered_nodes[itemdef.name] = itemdef
setmetatable(itemdef, {__index = core.nodedef_default})
core.registered_nodes[itemdef.name] = itemdef
elseif itemdef.type == "craft" then
setmetatable(itemdef, {__index = minetest.craftitemdef_default})
minetest.registered_craftitems[itemdef.name] = itemdef
setmetatable(itemdef, {__index = core.craftitemdef_default})
core.registered_craftitems[itemdef.name] = itemdef
elseif itemdef.type == "tool" then
setmetatable(itemdef, {__index = minetest.tooldef_default})
minetest.registered_tools[itemdef.name] = itemdef
setmetatable(itemdef, {__index = core.tooldef_default})
core.registered_tools[itemdef.name] = itemdef
elseif itemdef.type == "none" then
setmetatable(itemdef, {__index = minetest.noneitemdef_default})
setmetatable(itemdef, {__index = core.noneitemdef_default})
else
error("Unable to register item: Type is invalid: " .. dump(itemdef))
end
@ -131,7 +131,7 @@ function minetest.register_item(name, itemdef)
-- BEGIN Legacy stuff
if itemdef.cookresult_itemstring ~= nil and itemdef.cookresult_itemstring ~= "" then
minetest.register_craft({
core.register_craft({
type="cooking",
output=itemdef.cookresult_itemstring,
recipe=itemdef.name,
@ -139,7 +139,7 @@ function minetest.register_item(name, itemdef)
})
end
if itemdef.furnace_burntime ~= nil and itemdef.furnace_burntime >= 0 then
minetest.register_craft({
core.register_craft({
type="fuel",
recipe=itemdef.name,
burntime=itemdef.furnace_burntime
@ -150,18 +150,18 @@ function minetest.register_item(name, itemdef)
-- Disable all further modifications
getmetatable(itemdef).__newindex = {}
--minetest.log("Registering item: " .. itemdef.name)
minetest.registered_items[itemdef.name] = itemdef
minetest.registered_aliases[itemdef.name] = nil
--core.log("Registering item: " .. itemdef.name)
core.registered_items[itemdef.name] = itemdef
core.registered_aliases[itemdef.name] = nil
register_item_raw(itemdef)
end
function minetest.register_node(name, nodedef)
function core.register_node(name, nodedef)
nodedef.type = "node"
minetest.register_item(name, nodedef)
core.register_item(name, nodedef)
end
function minetest.register_craftitem(name, craftitemdef)
function core.register_craftitem(name, craftitemdef)
craftitemdef.type = "craft"
-- BEGIN Legacy stuff
@ -170,10 +170,10 @@ function minetest.register_craftitem(name, craftitemdef)
end
-- END Legacy stuff
minetest.register_item(name, craftitemdef)
core.register_item(name, craftitemdef)
end
function minetest.register_tool(name, tooldef)
function core.register_tool(name, tooldef)
tooldef.type = "tool"
tooldef.stack_max = 1
@ -209,39 +209,39 @@ function minetest.register_tool(name, tooldef)
end
-- END Legacy stuff
minetest.register_item(name, tooldef)
core.register_item(name, tooldef)
end
function minetest.register_alias(name, convert_to)
function core.register_alias(name, convert_to)
if forbidden_item_names[name] then
error("Unable to register alias: Name is forbidden: " .. name)
end
if minetest.registered_items[name] ~= nil then
minetest.log("WARNING: Not registering alias, item with same name" ..
if core.registered_items[name] ~= nil then
core.log("WARNING: Not registering alias, item with same name" ..
" is already defined: " .. name .. " -> " .. convert_to)
else
--minetest.log("Registering alias: " .. name .. " -> " .. convert_to)
minetest.registered_aliases[name] = convert_to
--core.log("Registering alias: " .. name .. " -> " .. convert_to)
core.registered_aliases[name] = convert_to
register_alias_raw(name, convert_to)
end
end
local register_biome_raw = minetest.register_biome
minetest.registered_biomes = {}
function minetest.register_biome(biome)
minetest.registered_biomes[biome.name] = biome
local register_biome_raw = core.register_biome
core.registered_biomes = {}
function core.register_biome(biome)
core.registered_biomes[biome.name] = biome
register_biome_raw(biome)
end
function minetest.on_craft(itemstack, player, old_craft_list, craft_inv)
for _, func in ipairs(minetest.registered_on_crafts) do
function core.on_craft(itemstack, player, old_craft_list, craft_inv)
for _, func in ipairs(core.registered_on_crafts) do
itemstack = func(itemstack, player, old_craft_list, craft_inv) or itemstack
end
return itemstack
end
function minetest.craft_predict(itemstack, player, old_craft_list, craft_inv)
for _, func in ipairs(minetest.registered_craft_predicts) do
function core.craft_predict(itemstack, player, old_craft_list, craft_inv)
for _, func in ipairs(core.registered_craft_predicts) do
itemstack = func(itemstack, player, old_craft_list, craft_inv) or itemstack
end
return itemstack
@ -251,32 +251,32 @@ end
-- created via itemstrings (e.g. /give)
local name
for name in pairs(forbidden_item_names) do
minetest.registered_aliases[name] = ""
core.registered_aliases[name] = ""
register_alias_raw(name, "")
end
-- Deprecated:
-- Aliases for minetest.register_alias (how ironic...)
--minetest.alias_node = minetest.register_alias
--minetest.alias_tool = minetest.register_alias
--minetest.alias_craftitem = minetest.register_alias
-- Aliases for core.register_alias (how ironic...)
--core.alias_node = core.register_alias
--core.alias_tool = core.register_alias
--core.alias_craftitem = core.register_alias
--
-- Built-in node definitions. Also defined in C.
--
minetest.register_item(":unknown", {
core.register_item(":unknown", {
type = "none",
description = "Unknown Item",
inventory_image = "unknown_item.png",
on_place = minetest.item_place,
on_drop = minetest.item_drop,
on_place = core.item_place,
on_drop = core.item_drop,
groups = {not_in_creative_inventory=1},
diggable = true,
})
minetest.register_node(":air", {
core.register_node(":air", {
description = "Air (you hacker you!)",
inventory_image = "unknown_node.png",
wield_image = "unknown_node.png",
@ -292,7 +292,7 @@ minetest.register_node(":air", {
groups = {not_in_creative_inventory=1},
})
minetest.register_node(":ignore", {
core.register_node(":ignore", {
description = "Ignore (you hacker you!)",
inventory_image = "unknown_node.png",
wield_image = "unknown_node.png",
@ -309,20 +309,20 @@ minetest.register_node(":ignore", {
})
-- The hand (bare definition)
minetest.register_item(":", {
core.register_item(":", {
type = "none",
groups = {not_in_creative_inventory=1},
})
function minetest.override_item(name, redefinition)
function core.override_item(name, redefinition)
if redefinition.name ~= nil then
error("Attempt to redefine name of "..name.." to "..dump(redefinition.name), 2)
end
if redefinition.type ~= nil then
error("Attempt to redefine type of "..name.." to "..dump(redefinition.type), 2)
end
local item = minetest.registered_items[name]
local item = core.registered_items[name]
if not item then
error("Attempt to override non-existent item "..name, 2)
end
@ -333,7 +333,7 @@ function minetest.override_item(name, redefinition)
end
function minetest.run_callbacks(callbacks, mode, ...)
function core.run_callbacks(callbacks, mode, ...)
assert(type(callbacks) == "table")
local cb_len = #callbacks
if cb_len == 0 then
@ -387,24 +387,24 @@ local function make_registration_reverse()
return t, registerfunc
end
minetest.registered_on_chat_messages, minetest.register_on_chat_message = make_registration()
minetest.registered_globalsteps, minetest.register_globalstep = make_registration()
minetest.registered_playerevents, minetest.register_playerevent = make_registration()
minetest.registered_on_mapgen_inits, minetest.register_on_mapgen_init = make_registration()
minetest.registered_on_shutdown, minetest.register_on_shutdown = make_registration()
minetest.registered_on_punchnodes, minetest.register_on_punchnode = make_registration()
minetest.registered_on_placenodes, minetest.register_on_placenode = make_registration()
minetest.registered_on_dignodes, minetest.register_on_dignode = make_registration()
minetest.registered_on_generateds, minetest.register_on_generated = make_registration()
minetest.registered_on_newplayers, minetest.register_on_newplayer = make_registration()
minetest.registered_on_dieplayers, minetest.register_on_dieplayer = make_registration()
minetest.registered_on_respawnplayers, minetest.register_on_respawnplayer = make_registration()
minetest.registered_on_prejoinplayers, minetest.register_on_prejoinplayer = make_registration()
minetest.registered_on_joinplayers, minetest.register_on_joinplayer = make_registration()
minetest.registered_on_leaveplayers, minetest.register_on_leaveplayer = make_registration()
minetest.registered_on_player_receive_fields, minetest.register_on_player_receive_fields = make_registration_reverse()
minetest.registered_on_cheats, minetest.register_on_cheat = make_registration()
minetest.registered_on_crafts, minetest.register_on_craft = make_registration()
minetest.registered_craft_predicts, minetest.register_craft_predict = make_registration()
minetest.registered_on_protection_violation, minetest.register_on_protection_violation = make_registration()
core.registered_on_chat_messages, core.register_on_chat_message = make_registration()
core.registered_globalsteps, core.register_globalstep = make_registration()
core.registered_playerevents, core.register_playerevent = make_registration()
core.registered_on_mapgen_inits, core.register_on_mapgen_init = make_registration()
core.registered_on_shutdown, core.register_on_shutdown = make_registration()
core.registered_on_punchnodes, core.register_on_punchnode = make_registration()
core.registered_on_placenodes, core.register_on_placenode = make_registration()
core.registered_on_dignodes, core.register_on_dignode = make_registration()
core.registered_on_generateds, core.register_on_generated = make_registration()
core.registered_on_newplayers, core.register_on_newplayer = make_registration()
core.registered_on_dieplayers, core.register_on_dieplayer = make_registration()
core.registered_on_respawnplayers, core.register_on_respawnplayer = make_registration()
core.registered_on_prejoinplayers, core.register_on_prejoinplayer = make_registration()
core.registered_on_joinplayers, core.register_on_joinplayer = make_registration()
core.registered_on_leaveplayers, core.register_on_leaveplayer = make_registration()
core.registered_on_player_receive_fields, core.register_on_player_receive_fields = make_registration_reverse()
core.registered_on_cheats, core.register_on_cheat = make_registration()
core.registered_on_crafts, core.register_on_craft = make_registration()
core.registered_craft_predicts, core.register_craft_predict = make_registration()
core.registered_on_protection_violation, core.register_on_protection_violation = make_registration()

12
builtin/game/statbars.lua
View File

@ -118,7 +118,7 @@ local function player_event_handler(player,eventname)
return false
end
function minetest.hud_replace_builtin(name, definition)
function core.hud_replace_builtin(name, definition)
if definition == nil or
type(definition) ~= "table" or
@ -130,7 +130,7 @@ function minetest.hud_replace_builtin(name, definition)
health_bar_definition = definition
for name,ids in pairs(hud_ids) do
local player = minetest.get_player_by_name(name)
local player = core.get_player_by_name(name)
if player and hud_ids[name].id_healthbar then
player:hud_remove(hud_ids[name].id_healthbar)
initialize_builtin_statbars(player)
@ -143,7 +143,7 @@ function minetest.hud_replace_builtin(name, definition)
breath_bar_definition = definition
for name,ids in pairs(hud_ids) do
local player = minetest.get_player_by_name(name)
local player = core.get_player_by_name(name)
if player and hud_ids[name].id_breathbar then
player:hud_remove(hud_ids[name].id_breathbar)
initialize_builtin_statbars(player)
@ -155,6 +155,6 @@ function minetest.hud_replace_builtin(name, definition)
return false
end
minetest.register_on_joinplayer(initialize_builtin_statbars)
minetest.register_on_leaveplayer(cleanup_builtin_statbars)
minetest.register_playerevent(player_event_handler)
core.register_on_joinplayer(initialize_builtin_statbars)
core.register_on_leaveplayer(cleanup_builtin_statbars)
core.register_playerevent(player_event_handler)

18
builtin/game/static_spawn.lua
View File

@ -1,10 +1,10 @@
-- Minetest: builtin/static_spawn.lua
local function warn_invalid_static_spawnpoint()
if minetest.setting_get("static_spawnpoint") and
not minetest.setting_get_pos("static_spawnpoint") then
minetest.log('error', "The static_spawnpoint setting is invalid: \""..
minetest.setting_get("static_spawnpoint").."\"")
if core.setting_get("static_spawnpoint") and
not core.setting_get_pos("static_spawnpoint") then
core.log('error', "The static_spawnpoint setting is invalid: \""..
core.setting_get("static_spawnpoint").."\"")
end
end
@ -12,22 +12,22 @@ warn_invalid_static_spawnpoint()
local function put_player_in_spawn(obj)
warn_invalid_static_spawnpoint()
local static_spawnpoint = minetest.setting_get_pos("static_spawnpoint")
local static_spawnpoint = core.setting_get_pos("static_spawnpoint")
if not static_spawnpoint then
return false
end
minetest.log('action', "Moving "..obj:get_player_name()..
core.log('action', "Moving "..obj:get_player_name()..
" to static spawnpoint at "..
minetest.pos_to_string(static_spawnpoint))
core.pos_to_string(static_spawnpoint))
obj:setpos(static_spawnpoint)
return true
end
minetest.register_on_newplayer(function(obj)
core.register_on_newplayer(function(obj)
put_player_in_spawn(obj)
end)
minetest.register_on_respawnplayer(function(obj)
core.register_on_respawnplayer(function(obj)
return put_player_in_spawn(obj)
end)

4
builtin/init.lua
View File

@ -5,13 +5,11 @@
-- before loading and running any mods.
--
local core = minetest or engine
minetest = core
-- Initialize some very basic things
print = core.debug
math.randomseed(os.time())
os.setlocale("C", "numeric")
minetest = core
-- Load other files
local scriptdir = core.get_builtin_path()..DIR_DELIM

7
builtin/mainmenu/init.lua
View File

@ -1,6 +1,7 @@
local menupath = engine.get_mainmenu_path()..DIR_DELIM
local commonpath = engine.get_builtin_path()..DIR_DELIM.."common"..DIR_DELIM
engine = core
local menupath = core.get_mainmenu_path()..DIR_DELIM
local commonpath = core.get_builtin_path()..DIR_DELIM.."common"..DIR_DELIM
dofile(menupath.."filterlist.lua")
dofile(menupath.."modmgr.lua")
@ -217,7 +218,7 @@ function menu.asyncOnlineFavourites()
menu.favorites = {}
engine.handle_async(
function(param)
return engine.get_favorites("online")
--return core.get_favorites("online")
end,
nil,
function(result)

14
builtin/mainmenu/modmgr.lua
View File

@ -193,16 +193,9 @@ function modmgr.identify_modname(modpath,filename)
while line~= nil do
local modname = nil
if line:find("minetest.register_tool") then
modname = modmgr.parse_register_line(line)
end
if line:find("minetest.register_craftitem") then
modname = modmgr.parse_register_line(line)
end
if line:find("minetest.register_node") then
if line:find("register_tool") or
line:find("register_craftitem") or
line:find("register_node") then
modname = modmgr.parse_register_line(line)
end
@ -225,7 +218,6 @@ end
--------------------------------------------------------------------------------
function modmgr.tab()
if modmgr.global_mods == nil then
modmgr.refresh_globals()
end

8
doc/menu_lua_api.txt
View File

@ -3,7 +3,7 @@ Minetest Lua Mainmenu API Reference 0.4.9
Introduction
-------------
The main menu is defined as a formspec by Lua in builtin/mainmenu.lua
The main menu is defined as a formspec by Lua in builtin/mainmenu/
Description of formspec language to show your menu is in lua_api.txt
Callbacks
@ -83,7 +83,7 @@ engine.download_file(url,target) (possible in async calls)
^ target to store to
^ returns true/false
engine.get_version() (possible in async calls)
^ returns current minetest version
^ returns current core version
engine.sound_play(spec, looped) -> handle
^ spec = SimpleSoundSpec (see lua-api.txt)
^ looped = bool
@ -191,14 +191,14 @@ fgettext(string, ...) -> string
^ call engine.gettext(string), replace "$1"..."$9" with the given
^ extra arguments, call engine.formspec_escape and return the result
engine.parse_json(string[, nullvalue]) -> something (possible in async calls)
^ see minetest.parse_json (lua_api.txt)
^ see core.parse_json (lua_api.txt)
dump(obj, dumped={})
^ Return object serialized as a string
string:split(separator)
^ eg. string:split("a,b", ",") == {"a","b"}
string:trim()
^ eg. string.trim("\n \t\tfoo bar\t ") == "foo bar"
minetest.is_yes(arg) (possible in async calls)
core.is_yes(arg) (possible in async calls)
^ returns whether arg can be interpreted as yes
Async:

8
src/script/common/c_content.cpp
View File

@ -955,14 +955,14 @@ std::vector<ItemStack> read_items(lua_State *L, int index, Server *srv)
/******************************************************************************/
void luaentity_get(lua_State *L, u16 id)
{
// Get minetest.luaentities[i]
lua_getglobal(L, "minetest");
// Get luaentities[i]
lua_getglobal(L, "core");
lua_getfield(L, -1, "luaentities");
luaL_checktype(L, -1, LUA_TTABLE);
lua_pushnumber(L, id);
lua_gettable(L, -2);
lua_remove(L, -2); // luaentities
lua_remove(L, -2); // minetest
lua_remove(L, -2); // Remove luaentities
lua_remove(L, -2); // Remove core
}
/******************************************************************************/

4
src/script/common/c_internal.cpp
View File

@ -92,8 +92,8 @@ void script_run_callbacks(lua_State *L, int nargs, RunCallbacksMode mode)
int errorhandler = lua_gettop(L) - nargs - 1;
lua_insert(L, errorhandler);
// Insert minetest.run_callbacks between error handler and table
lua_getglobal(L, "minetest");
// Insert run_callbacks between error handler and table
lua_getglobal(L, "core");
lua_getfield(L, -1, "run_callbacks");
lua_remove(L, -2);
lua_insert(L, errorhandler + 1);

19
src/script/cpp_api/s_async.cpp
View File

@ -146,7 +146,7 @@ void AsyncEngine::putJobResult(LuaJobInfo result)
/******************************************************************************/
void AsyncEngine::step(lua_State *L, int errorhandler)
{
lua_getglobal(L, "engine");
lua_getglobal(L, "core");
resultQueueMutex.Lock();
while (!resultQueue.empty()) {
LuaJobInfo jobDone = resultQueue.front();
@ -169,7 +169,7 @@ void AsyncEngine::step(lua_State *L, int errorhandler)
}
}
resultQueueMutex.Unlock();
lua_pop(L, 1); // Pop engine
lua_pop(L, 1); // Pop core
}
/******************************************************************************/
@ -223,17 +223,10 @@ AsyncWorkerThread::AsyncWorkerThread(AsyncEngine* jobDispatcher,
{
lua_State *L = getStack();
luaL_openlibs(L);
// Prepare job lua environment
lua_newtable(L);
lua_setglobal(L, "engine");
lua_getglobal(L, "engine");
lua_getglobal(L, "core");
int top = lua_gettop(L);
lua_pushstring(L, DIR_DELIM);
lua_setglobal(L, "DIR_DELIM");
// Push builtin initialization type
lua_pushstring(L, "async");
lua_setglobal(L, "INIT");
@ -278,9 +271,9 @@ void* AsyncWorkerThread::Thread()
continue;
}
lua_getglobal(L, "engine");
lua_getglobal(L, "core");
if (lua_isnil(L, -1)) {
errorstream << "Unable to find engine within async environment!";
errorstream << "Unable to find core within async environment!";
abort();
}
@ -310,7 +303,7 @@ void* AsyncWorkerThread::Thread()
toProcess.serializedResult = std::string(retval, length);
}
// Pop engine, job_processor, and retval
// Pop core, job_processor, and retval
lua_pop(L, 3);
// Put job result

28
src/script/cpp_api/s_base.cpp
View File

@ -22,6 +22,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "lua_api/l_object.h"
#include "serverobject.h"
#include "debug.h"
#include "filesys.h"
#include "log.h"
#include "mods.h"
#include "util/string.h"
@ -48,13 +49,13 @@ public:
{
// Store current modname in registry
lua_pushstring(L, modname.c_str());
lua_setfield(L, LUA_REGISTRYINDEX, "minetest_current_modname");
lua_setfield(L, LUA_REGISTRYINDEX, "current_modname");
}
~ModNameStorer()
{
// Clear current modname in registry
lua_pushnil(L);
lua_setfield(L, LUA_REGISTRYINDEX, "minetest_current_modname");
lua_setfield(L, LUA_REGISTRYINDEX, "current_modname");
}
};
@ -72,6 +73,8 @@ ScriptApiBase::ScriptApiBase()
m_luastack = luaL_newstate();
assert(m_luastack);
luaL_openlibs(m_luastack);
// Add and save an error handler
lua_pushcfunction(m_luastack, script_error_handler);
m_errorhandler = lua_gettop(m_luastack);
@ -88,6 +91,13 @@ ScriptApiBase::ScriptApiBase()
lua_pop(m_luastack, 1);
#endif
// Add basic globals
lua_newtable(m_luastack);
lua_setglobal(m_luastack, "core");
lua_pushstring(m_luastack, DIR_DELIM);
lua_setglobal(m_luastack, "DIR_DELIM");
m_server = NULL;
m_environment = NULL;
m_guiengine = NULL;
@ -191,8 +201,8 @@ void ScriptApiBase::addObjectReference(ServerActiveObject *cobj)
ObjectRef::create(L, cobj); // Puts ObjectRef (as userdata) on stack
int object = lua_gettop(L);
// Get minetest.object_refs table
lua_getglobal(L, "minetest");
// Get core.object_refs table
lua_getglobal(L, "core");
lua_getfield(L, -1, "object_refs");
luaL_checktype(L, -1, LUA_TTABLE);
int objectstable = lua_gettop(L);
@ -208,8 +218,8 @@ void ScriptApiBase::removeObjectReference(ServerActiveObject *cobj)
SCRIPTAPI_PRECHECKHEADER
//infostream<<"scriptapi_rm_object_reference: id="<<cobj->getId()<<std::endl;
// Get minetest.object_refs table
lua_getglobal(L, "minetest");
// Get core.object_refs table
lua_getglobal(L, "core");
lua_getfield(L, -1, "object_refs");
luaL_checktype(L, -1, LUA_TTABLE);
int objectstable = lua_gettop(L);
@ -244,12 +254,12 @@ void ScriptApiBase::objectrefGet(u16 id)
{
lua_State *L = getStack();
// Get minetest.object_refs[i]
lua_getglobal(L, "minetest");
// Get core.object_refs[i]
lua_getglobal(L, "core");
lua_getfield(L, -1, "object_refs");
luaL_checktype(L, -1, LUA_TTABLE);
lua_pushnumber(L, id);
lua_gettable(L, -2);
lua_remove(L, -2); // object_refs
lua_remove(L, -2); // minetest
lua_remove(L, -2); // core
}

26
src/script/cpp_api/s_entity.cpp
View File

@ -31,8 +31,8 @@ bool ScriptApiEntity::luaentity_Add(u16 id, const char *name)
verbosestream<<"scriptapi_luaentity_add: id="<<id<<" name=\""
<<name<<"\""<<std::endl;
// Get minetest.registered_entities[name]
lua_getglobal(L, "minetest");
// Get core.registered_entities[name]
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_entities");
luaL_checktype(L, -1, LUA_TTABLE);
lua_pushstring(L, name);
@ -62,8 +62,8 @@ bool ScriptApiEntity::luaentity_Add(u16 id, const char *name)
luaL_typerror(L, -1, "ObjectRef");
lua_setfield(L, -2, "object");
// minetest.luaentities[id] = object
lua_getglobal(L, "minetest");
// core.luaentities[id] = object
lua_getglobal(L, "core");
lua_getfield(L, -1, "luaentities");
luaL_checktype(L, -1, LUA_TTABLE);
lua_pushnumber(L, id); // Push id
@ -80,7 +80,7 @@ void ScriptApiEntity::luaentity_Activate(u16 id,
verbosestream << "scriptapi_luaentity_activate: id=" << id << std::endl;
// Get minetest.luaentities[id]
// Get core.luaentities[id]
luaentity_get(L, id);
int object = lua_gettop(L);
@ -106,8 +106,8 @@ void ScriptApiEntity::luaentity_Remove(u16 id)
verbosestream << "scriptapi_luaentity_rm: id=" << id << std::endl;
// Get minetest.luaentities table
lua_getglobal(L, "minetest");
// Get core.luaentities table
lua_getglobal(L, "core");
lua_getfield(L, -1, "luaentities");
luaL_checktype(L, -1, LUA_TTABLE);
int objectstable = lua_gettop(L);
@ -117,7 +117,7 @@ void ScriptApiEntity::luaentity_Remove(u16 id)
lua_pushnil(L);
lua_settable(L, objectstable);
lua_pop(L, 2); // pop luaentities, minetest
lua_pop(L, 2); // pop luaentities, core
}
std::string ScriptApiEntity::luaentity_GetStaticdata(u16 id)
@ -126,7 +126,7 @@ std::string ScriptApiEntity::luaentity_GetStaticdata(u16 id)
//infostream<<"scriptapi_luaentity_get_staticdata: id="<<id<<std::endl;
// Get minetest.luaentities[id]
// Get core.luaentities[id]
luaentity_get(L, id);
int object = lua_gettop(L);
@ -157,7 +157,7 @@ void ScriptApiEntity::luaentity_GetProperties(u16 id,
//infostream<<"scriptapi_luaentity_get_properties: id="<<id<<std::endl;
// Get minetest.luaentities[id]
// Get core.luaentities[id]
luaentity_get(L, id);
// Set default values that differ from ObjectProperties defaults
@ -196,7 +196,7 @@ void ScriptApiEntity::luaentity_Step(u16 id, float dtime)
//infostream<<"scriptapi_luaentity_step: id="<<id<<std::endl;
// Get minetest.luaentities[id]
// Get core.luaentities[id]
luaentity_get(L, id);
int object = lua_gettop(L);
// State: object is at top of stack
@ -225,7 +225,7 @@ void ScriptApiEntity::luaentity_Punch(u16 id,
//infostream<<"scriptapi_luaentity_step: id="<<id<<std::endl;
// Get minetest.luaentities[id]
// Get core.luaentities[id]
luaentity_get(L,id);
int object = lua_gettop(L);
// State: object is at top of stack
@ -255,7 +255,7 @@ void ScriptApiEntity::luaentity_Rightclick(u16 id,
//infostream<<"scriptapi_luaentity_step: id="<<id<<std::endl;
// Get minetest.luaentities[id]
// Get core.luaentities[id]
luaentity_get(L, id);
int object = lua_gettop(L);
// State: object is at top of stack

16
src/script/cpp_api/s_env.cpp
View File

@ -31,8 +31,8 @@ void ScriptApiEnv::environment_OnGenerated(v3s16 minp, v3s16 maxp,
{
SCRIPTAPI_PRECHECKHEADER
// Get minetest.registered_on_generateds
lua_getglobal(L, "minetest");
// Get core.registered_on_generateds
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_on_generateds");
// Call callbacks
push_v3s16(L, minp);
@ -46,8 +46,8 @@ void ScriptApiEnv::environment_Step(float dtime)
SCRIPTAPI_PRECHECKHEADER
//infostream<<"scriptapi_environment_step"<<std::endl;
// Get minetest.registered_globalsteps
lua_getglobal(L, "minetest");
// Get core.registered_globalsteps
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_globalsteps");
// Call callbacks
lua_pushnumber(L, dtime);
@ -80,8 +80,8 @@ void ScriptApiEnv::environment_OnMapgenInit(MapgenParams *mgparams)
{
SCRIPTAPI_PRECHECKHEADER
// Get minetest.registered_on_mapgen_inits
lua_getglobal(L, "minetest");
// Get core.registered_on_mapgen_inits
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_on_mapgen_inits");
// Call callbacks
@ -114,8 +114,8 @@ void ScriptApiEnv::initializeEnvironment(ServerEnvironment *env)
Add ActiveBlockModifiers to environment
*/
// Get minetest.registered_abms
lua_getglobal(L, "minetest");
// Get core.registered_abms
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_abms");
luaL_checktype(L, -1, LUA_TTABLE);
int registered_abms = lua_gettop(L);

4
src/script/cpp_api/s_inventory.cpp
View File

@ -193,7 +193,7 @@ void ScriptApiDetached::detached_inventory_OnTake(
scriptError();
}
// Retrieves minetest.detached_inventories[name][callbackname]
// Retrieves core.detached_inventories[name][callbackname]
// If that is nil or on error, return false and stack is unchanged
// If that is a function, returns true and pushes the
// function onto the stack
@ -202,7 +202,7 @@ bool ScriptApiDetached::getDetachedInventoryCallback(
{
lua_State *L = getStack();
lua_getglobal(L, "minetest");
lua_getglobal(L, "core");
lua_getfield(L, -1, "detached_inventories");
lua_remove(L, -2);
luaL_checktype(L, -1, LUA_TTABLE);

16
src/script/cpp_api/s_item.cpp
View File

@ -112,7 +112,7 @@ bool ScriptApiItem::item_OnCraft(ItemStack &item, ServerActiveObject *user,
{
SCRIPTAPI_PRECHECKHEADER
lua_getglobal(L, "minetest");
lua_getglobal(L, "core");
lua_getfield(L, -1, "on_craft");
LuaItemStack::create(L, item);
objectrefGetOrCreate(user);
@ -143,7 +143,7 @@ bool ScriptApiItem::item_CraftPredict(ItemStack &item, ServerActiveObject *user,
{
SCRIPTAPI_PRECHECKHEADER
lua_getglobal(L, "minetest");
lua_getglobal(L, "core");
lua_getfield(L, -1, "craft_predict");
LuaItemStack::create(L, item);
objectrefGetOrCreate(user);
@ -169,19 +169,19 @@ bool ScriptApiItem::item_CraftPredict(ItemStack &item, ServerActiveObject *user,
return true;
}
// Retrieves minetest.registered_items[name][callbackname]
// Retrieves core.registered_items[name][callbackname]
// If that is nil or on error, return false and stack is unchanged
// If that is a function, returns true and pushes the
// function onto the stack
// If minetest.registered_items[name] doesn't exist, minetest.nodedef_default
// If core.registered_items[name] doesn't exist, core.nodedef_default
// is tried instead so unknown items can still be manipulated to some degree
bool ScriptApiItem::getItemCallback(const char *name, const char *callbackname)
{
lua_State* L = getStack();
lua_getglobal(L, "minetest");
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_items");
lua_remove(L, -2); // Remove minetest
lua_remove(L, -2); // Remove core
luaL_checktype(L, -1, LUA_TTABLE);
lua_getfield(L, -1, name);
lua_remove(L, -2); // Remove registered_items
@ -192,8 +192,8 @@ bool ScriptApiItem::getItemCallback(const char *name, const char *callbackname)
errorstream << "Item \"" << name << "\" not defined" << std::endl;
lua_pop(L, 1);
// Try minetest.nodedef_default instead
lua_getglobal(L, "minetest");
// Try core.nodedef_default instead
lua_getglobal(L, "core");
lua_getfield(L, -1, "nodedef_default");
lua_remove(L, -2);
luaL_checktype(L, -1, LUA_TTABLE);

8
src/script/cpp_api/s_mainmenu.cpp
View File

@ -38,9 +38,9 @@ void ScriptApiMainMenu::handleMainMenuEvent(std::string text)
SCRIPTAPI_PRECHECKHEADER
// Get handler function
lua_getglobal(L, "engine");
lua_getglobal(L, "core");
lua_getfield(L, -1, "event_handler");
lua_remove(L, -2); // Remove engine
lua_remove(L, -2); // Remove core
if (lua_isnil(L, -1)) {
lua_pop(L, 1); // Pop event_handler
return;
@ -58,9 +58,9 @@ void ScriptApiMainMenu::handleMainMenuButtons(std::map<std::string, std::string>
SCRIPTAPI_PRECHECKHEADER
// Get handler function
lua_getglobal(L, "engine");
lua_getglobal(L, "core");
lua_getfield(L, -1, "button_handler");
lua_remove(L, -2); // Remove engine
lua_remove(L, -2); // Remove core
if (lua_isnil(L, -1)) {
lua_pop(L, 1); // Pop button handler
return;

32
src/script/cpp_api/s_player.cpp
View File

@ -25,8 +25,8 @@ void ScriptApiPlayer::on_newplayer(ServerActiveObject *player)
{
SCRIPTAPI_PRECHECKHEADER
// Get minetest.registered_on_newplayers
lua_getglobal(L, "minetest");
// Get core.registered_on_newplayers
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_on_newplayers");
// Call callbacks
objectrefGetOrCreate(player);
@ -37,8 +37,8 @@ void ScriptApiPlayer::on_dieplayer(ServerActiveObject *player)
{
SCRIPTAPI_PRECHECKHEADER
// Get minetest.registered_on_dieplayers
lua_getglobal(L, "minetest");
// Get core.registered_on_dieplayers
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_on_dieplayers");
// Call callbacks
objectrefGetOrCreate(player);
@ -49,8 +49,8 @@ bool ScriptApiPlayer::on_respawnplayer(ServerActiveObject *player)
{
SCRIPTAPI_PRECHECKHEADER
// Get minetest.registered_on_respawnplayers
lua_getglobal(L, "minetest");
// Get core.registered_on_respawnplayers
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_on_respawnplayers");
// Call callbacks
objectrefGetOrCreate(player);
@ -63,8 +63,8 @@ bool ScriptApiPlayer::on_prejoinplayer(std::string name, std::string ip, std::st
{
SCRIPTAPI_PRECHECKHEADER
// Get minetest.registered_on_prejoinplayers
lua_getglobal(L, "minetest");
// Get core.registered_on_prejoinplayers
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_on_prejoinplayers");
lua_pushstring(L, name.c_str());
lua_pushstring(L, ip.c_str());
@ -80,8 +80,8 @@ void ScriptApiPlayer::on_joinplayer(ServerActiveObject *player)
{
SCRIPTAPI_PRECHECKHEADER
// Get minetest.registered_on_joinplayers
lua_getglobal(L, "minetest");
// Get core.registered_on_joinplayers
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_on_joinplayers");
// Call callbacks
objectrefGetOrCreate(player);
@ -92,8 +92,8 @@ void ScriptApiPlayer::on_leaveplayer(ServerActiveObject *player)
{
SCRIPTAPI_PRECHECKHEADER
// Get minetest.registered_on_leaveplayers
lua_getglobal(L, "minetest");
// Get core.registered_on_leaveplayers
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_on_leaveplayers");
// Call callbacks
objectrefGetOrCreate(player);
@ -105,8 +105,8 @@ void ScriptApiPlayer::on_cheat(ServerActiveObject *player,
{
SCRIPTAPI_PRECHECKHEADER
// Get minetest.registered_on_cheats
lua_getglobal(L, "minetest");
// Get core.registered_on_cheats
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_on_cheats");
// Call callbacks
objectrefGetOrCreate(player);
@ -122,8 +122,8 @@ void ScriptApiPlayer::on_playerReceiveFields(ServerActiveObject *player,
{
SCRIPTAPI_PRECHECKHEADER
// Get minetest.registered_on_chat_messages
lua_getglobal(L, "minetest");
// Get core.registered_on_chat_messages
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_on_player_receive_fields");
// Call callbacks
// param 1

10
src/script/cpp_api/s_server.cpp
View File

@ -62,13 +62,13 @@ void ScriptApiServer::getAuthHandler()
{
lua_State *L = getStack();
lua_getglobal(L, "minetest");
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_auth_handler");
if (lua_isnil(L, -1)){
lua_pop(L, 1);
lua_getfield(L, -1, "builtin_auth_handler");
}
lua_remove(L, -2); // Remove minetest
lua_remove(L, -2); // Remove core
if (lua_type(L, -1) != LUA_TTABLE)
throw LuaError("Authentication handler table not valid");
}
@ -130,8 +130,8 @@ bool ScriptApiServer::on_chat_message(const std::string &name,
{
SCRIPTAPI_PRECHECKHEADER
// Get minetest.registered_on_chat_messages
lua_getglobal(L, "minetest");
// Get core.registered_on_chat_messages
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_on_chat_messages");
// Call callbacks
lua_pushstring(L, name.c_str());
@ -146,7 +146,7 @@ void ScriptApiServer::on_shutdown()
SCRIPTAPI_PRECHECKHEADER
// Get registered shutdown hooks
lua_getglobal(L, "minetest");
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_on_shutdown");
// Call callbacks
script_run_callbacks(L, 0, RUN_CALLBACKS_MODE_FIRST);

86
src/script/lua_api/l_env.cpp
View File

@ -56,24 +56,24 @@ void LuaABM::trigger(ServerEnvironment *env, v3s16 p, MapNode n,
lua_pushcfunction(L, script_error_handler);
int errorhandler = lua_gettop(L);
// Get minetest.registered_abms
lua_getglobal(L, "minetest");
// Get registered_abms
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_abms");
luaL_checktype(L, -1, LUA_TTABLE);
lua_remove(L, -2); // Remove "minetest"
lua_remove(L, -2); // Remove core
// Get minetest.registered_abms[m_id]
// Get registered_abms[m_id]
lua_pushnumber(L, m_id);
lua_gettable(L, -2);
if(lua_isnil(L, -1))
assert(0);
lua_remove(L, -2); // Remove "registered_abms"
lua_remove(L, -2); // Remove registered_abms
// Call action
luaL_checktype(L, -1, LUA_TTABLE);
lua_getfield(L, -1, "action");
luaL_checktype(L, -1, LUA_TFUNCTION);
lua_remove(L, -2); // Remove "registered_abms[m_id]"
lua_remove(L, -2); // Remove registered_abms[m_id]
push_v3s16(L, p);
pushnode(L, n, env->getGameDef()->ndef());
lua_pushnumber(L, active_object_count);
@ -85,7 +85,7 @@ void LuaABM::trigger(ServerEnvironment *env, v3s16 p, MapNode n,
// Exported functions
// minetest.set_node(pos, node)
// set_node(pos, node)
// pos = {x=num, y=num, z=num}
int ModApiEnvMod::l_set_node(lua_State *L)
{
@ -106,7 +106,7 @@ int ModApiEnvMod::l_add_node(lua_State *L)
return l_set_node(L);
}
// minetest.remove_node(pos)
// remove_node(pos)
// pos = {x=num, y=num, z=num}
int ModApiEnvMod::l_remove_node(lua_State *L)
{
@ -120,7 +120,7 @@ int ModApiEnvMod::l_remove_node(lua_State *L)
return 1;
}
// minetest.swap_node(pos, node)
// swap_node(pos, node)
// pos = {x=num, y=num, z=num}
int ModApiEnvMod::l_swap_node(lua_State *L)
{
@ -136,7 +136,7 @@ int ModApiEnvMod::l_swap_node(lua_State *L)
return 1;
}
// minetest.get_node(pos)
// get_node(pos)
// pos = {x=num, y=num, z=num}
int ModApiEnvMod::l_get_node(lua_State *L)
{
@ -151,7 +151,7 @@ int ModApiEnvMod::l_get_node(lua_State *L)
return 1;
}
// minetest.get_node_or_nil(pos)
// get_node_or_nil(pos)
// pos = {x=num, y=num, z=num}
int ModApiEnvMod::l_get_node_or_nil(lua_State *L)
{
@ -172,7 +172,7 @@ int ModApiEnvMod::l_get_node_or_nil(lua_State *L)
}
}
// minetest.get_node_light(pos, timeofday)
// get_node_light(pos, timeofday)
// pos = {x=num, y=num, z=num}
// timeofday: nil = current time, 0 = night, 0.5 = day
int ModApiEnvMod::l_get_node_light(lua_State *L)
@ -198,7 +198,7 @@ int ModApiEnvMod::l_get_node_light(lua_State *L)
}
}
// minetest.place_node(pos, node)
// place_node(pos, node)
// pos = {x=num, y=num, z=num}
int ModApiEnvMod::l_place_node(lua_State *L)
{
@ -232,7 +232,7 @@ int ModApiEnvMod::l_place_node(lua_State *L)
return 1;
}
// minetest.dig_node(pos)
// dig_node(pos)
// pos = {x=num, y=num, z=num}
int ModApiEnvMod::l_dig_node(lua_State *L)
{
@ -255,7 +255,7 @@ int ModApiEnvMod::l_dig_node(lua_State *L)
return 1;
}
// minetest.punch_node(pos)
// punch_node(pos)
// pos = {x=num, y=num, z=num}
int ModApiEnvMod::l_punch_node(lua_State *L)
{
@ -278,7 +278,7 @@ int ModApiEnvMod::l_punch_node(lua_State *L)
return 1;
}
// minetest.get_node_max_level(pos)
// get_node_max_level(pos)
// pos = {x=num, y=num, z=num}
int ModApiEnvMod::l_get_node_max_level(lua_State *L)
{
@ -290,7 +290,7 @@ int ModApiEnvMod::l_get_node_max_level(lua_State *L)
return 1;
}
// minetest.get_node_level(pos)
// get_node_level(pos)
// pos = {x=num, y=num, z=num}
int ModApiEnvMod::l_get_node_level(lua_State *L)
{
@ -302,7 +302,7 @@ int ModApiEnvMod::l_get_node_level(lua_State *L)
return 1;
}
// minetest.set_node_level(pos, level)
// set_node_level(pos, level)
// pos = {x=num, y=num, z=num}
// level: 0..63
int ModApiEnvMod::l_set_node_level(lua_State *L)
@ -319,7 +319,7 @@ int ModApiEnvMod::l_set_node_level(lua_State *L)
return 1;
}
// minetest.add_node_level(pos, level)
// add_node_level(pos, level)
// pos = {x=num, y=num, z=num}
// level: 0..63
int ModApiEnvMod::l_add_node_level(lua_State *L)
@ -337,7 +337,7 @@ int ModApiEnvMod::l_add_node_level(lua_State *L)
}
// minetest.get_meta(pos)
// get_meta(pos)
int ModApiEnvMod::l_get_meta(lua_State *L)
{
GET_ENV_PTR;
@ -348,7 +348,7 @@ int ModApiEnvMod::l_get_meta(lua_State *L)
return 1;
}
// minetest.get_node_timer(pos)
// get_node_timer(pos)
int ModApiEnvMod::l_get_node_timer(lua_State *L)
{
GET_ENV_PTR;
@ -359,7 +359,7 @@ int ModApiEnvMod::l_get_node_timer(lua_State *L)
return 1;
}
// minetest.add_entity(pos, entityname) -> ObjectRef or nil
// add_entity(pos, entityname) -> ObjectRef or nil
// pos = {x=num, y=num, z=num}
int ModApiEnvMod::l_add_entity(lua_State *L)
{
@ -380,7 +380,7 @@ int ModApiEnvMod::l_add_entity(lua_State *L)
return 1;
}
// minetest.add_item(pos, itemstack or itemstring or table) -> ObjectRef or nil
// add_item(pos, itemstack or itemstring or table) -> ObjectRef or nil
// pos = {x=num, y=num, z=num}
int ModApiEnvMod::l_add_item(lua_State *L)
{
@ -396,10 +396,10 @@ int ModApiEnvMod::l_add_item(lua_State *L)
lua_pushcfunction(L, script_error_handler);
int errorhandler = lua_gettop(L);
// Use minetest.spawn_item to spawn a __builtin:item
lua_getglobal(L, "minetest");
// Use spawn_item to spawn a __builtin:item
lua_getglobal(L, "core");
lua_getfield(L, -1, "spawn_item");
lua_remove(L, -2); // Remove minetest
lua_remove(L, -2); // Remove core
if(lua_isnil(L, -1))
return 0;
lua_pushvalue(L, 1);
@ -423,7 +423,7 @@ int ModApiEnvMod::l_add_item(lua_State *L)
return 1;*/
}
// minetest.get_player_by_name(name)
// get_player_by_name(name)
int ModApiEnvMod::l_get_player_by_name(lua_State *L)
{
GET_ENV_PTR;
@ -445,7 +445,7 @@ int ModApiEnvMod::l_get_player_by_name(lua_State *L)
return 1;
}
// minetest.get_objects_inside_radius(pos, radius)
// get_objects_inside_radius(pos, radius)
int ModApiEnvMod::l_get_objects_inside_radius(lua_State *L)
{
GET_ENV_PTR;
@ -466,7 +466,7 @@ int ModApiEnvMod::l_get_objects_inside_radius(lua_State *L)
return 1;
}
// minetest.set_timeofday(val)
// set_timeofday(val)
// val = 0...1
int ModApiEnvMod::l_set_timeofday(lua_State *L)
{
@ -484,7 +484,7 @@ int ModApiEnvMod::l_set_timeofday(lua_State *L)
return 0;
}
// minetest.get_timeofday() -> 0...1
// get_timeofday() -> 0...1
int ModApiEnvMod::l_get_timeofday(lua_State *L)
{
GET_ENV_PTR;
@ -496,7 +496,7 @@ int ModApiEnvMod::l_get_timeofday(lua_State *L)
return 1;
}
// minetest.get_gametime()
// get_gametime()
int ModApiEnvMod::l_get_gametime(lua_State *L)
{
GET_ENV_PTR;
@ -507,7 +507,7 @@ int ModApiEnvMod::l_get_gametime(lua_State *L)
}
// minetest.find_node_near(pos, radius, nodenames) -> pos or nil
// find_node_near(pos, radius, nodenames) -> pos or nil
// nodenames: eg. {"ignore", "group:tree"} or "default:dirt"
int ModApiEnvMod::l_find_node_near(lua_State *L)
{
@ -547,7 +547,7 @@ int ModApiEnvMod::l_find_node_near(lua_State *L)
return 0;
}
// minetest.find_nodes_in_area(minp, maxp, nodenames) -> list of positions
// find_nodes_in_area(minp, maxp, nodenames) -> list of positions
// nodenames: eg. {"ignore", "group:tree"} or "default:dirt"
int ModApiEnvMod::l_find_nodes_in_area(lua_State *L)
{
@ -586,7 +586,7 @@ int ModApiEnvMod::l_find_nodes_in_area(lua_State *L)
return 1;
}
// minetest.get_perlin(seeddiff, octaves, persistence, scale)
// get_perlin(seeddiff, octaves, persistence, scale)
// returns world-specific PerlinNoise
int ModApiEnvMod::l_get_perlin(lua_State *L)
{
@ -604,7 +604,7 @@ int ModApiEnvMod::l_get_perlin(lua_State *L)
return 1;
}
// minetest.get_perlin_map(noiseparams, size)
// get_perlin_map(noiseparams, size)
// returns world-specific PerlinNoiseMap
int ModApiEnvMod::l_get_perlin_map(lua_State *L)
{
@ -623,7 +623,7 @@ int ModApiEnvMod::l_get_perlin_map(lua_State *L)
return 1;
}
// minetest.get_voxel_manip()
// get_voxel_manip()
// returns voxel manipulator
int ModApiEnvMod::l_get_voxel_manip(lua_State *L)
{
@ -638,7 +638,7 @@ int ModApiEnvMod::l_get_voxel_manip(lua_State *L)
return 1;
}
// minetest.clear_objects()
// clear_objects()
// clear all objects in the environment
int ModApiEnvMod::l_clear_objects(lua_State *L)
{
@ -648,7 +648,7 @@ int ModApiEnvMod::l_clear_objects(lua_State *L)
return 0;
}
// minetest.line_of_sight(pos1, pos2, stepsize) -> true/false, pos
// line_of_sight(pos1, pos2, stepsize) -> true/false, pos
int ModApiEnvMod::l_line_of_sight(lua_State *L) {
float stepsize = 1.0;
@ -673,7 +673,7 @@ int ModApiEnvMod::l_line_of_sight(lua_State *L) {
return 1;
}
// minetest.find_path(pos1, pos2, searchdistance,
// find_path(pos1, pos2, searchdistance,
// max_jump, max_drop, algorithm) -> table containing path
int ModApiEnvMod::l_find_path(lua_State *L)
{
@ -716,7 +716,7 @@ int ModApiEnvMod::l_find_path(lua_State *L)
return 0;
}
// minetest.spawn_tree(pos, treedef)
// spawn_tree(pos, treedef)
int ModApiEnvMod::l_spawn_tree(lua_State *L)
{
GET_ENV_PTR;
@ -765,7 +765,7 @@ int ModApiEnvMod::l_spawn_tree(lua_State *L)
return 1;
}
// minetest.transforming_liquid_add(pos)
// transforming_liquid_add(pos)
int ModApiEnvMod::l_transforming_liquid_add(lua_State *L)
{
GET_ENV_PTR;
@ -775,7 +775,7 @@ int ModApiEnvMod::l_transforming_liquid_add(lua_State *L)
return 1;
}
// minetest.forceload_block(blockpos)
// forceload_block(blockpos)
// blockpos = {x=num, y=num, z=num}
int ModApiEnvMod::l_forceload_block(lua_State *L)
{
@ -786,7 +786,7 @@ int ModApiEnvMod::l_forceload_block(lua_State *L)
return 0;
}
// minetest.forceload_free_block(blockpos)
// forceload_free_block(blockpos)
// blockpos = {x=num, y=num, z=num}
int ModApiEnvMod::l_forceload_free_block(lua_State *L)
{

68
src/script/lua_api/l_env.h
View File

@ -25,134 +25,134 @@ with this program; if not, write to the Free Software Foundation, Inc.,
class ModApiEnvMod : public ModApiBase {
private:
// minetest.set_node(pos, node)
// set_node(pos, node)
// pos = {x=num, y=num, z=num}
static int l_set_node(lua_State *L);
static int l_add_node(lua_State *L);
// minetest.remove_node(pos)
// remove_node(pos)
// pos = {x=num, y=num, z=num}
static int l_remove_node(lua_State *L);
// minetest.swap_node(pos, node)
// swap_node(pos, node)
// pos = {x=num, y=num, z=num}
static int l_swap_node(lua_State *L);
// minetest.get_node(pos)
// get_node(pos)
// pos = {x=num, y=num, z=num}
static int l_get_node(lua_State *L);
// minetest.get_node_or_nil(pos)
// get_node_or_nil(pos)
// pos = {x=num, y=num, z=num}
static int l_get_node_or_nil(lua_State *L);
// minetest.get_node_light(pos, timeofday)
// get_node_light(pos, timeofday)
// pos = {x=num, y=num, z=num}
// timeofday: nil = current time, 0 = night, 0.5 = day
static int l_get_node_light(lua_State *L);
// minetest.place_node(pos, node)
// place_node(pos, node)
// pos = {x=num, y=num, z=num}
static int l_place_node(lua_State *L);
// minetest.dig_node(pos)
// dig_node(pos)
// pos = {x=num, y=num, z=num}
static int l_dig_node(lua_State *L);
// minetest.punch_node(pos)
// punch_node(pos)
// pos = {x=num, y=num, z=num}
static int l_punch_node(lua_State *L);
// minetest.get_node_max_level(pos)
// get_node_max_level(pos)
// pos = {x=num, y=num, z=num}
static int l_get_node_max_level(lua_State *L);
// minetest.get_node_level(pos)
// get_node_level(pos)
// pos = {x=num, y=num, z=num}
static int l_get_node_level(lua_State *L);
// minetest.set_node_level(pos)
// set_node_level(pos)
// pos = {x=num, y=num, z=num}
static int l_set_node_level(lua_State *L);
// minetest.add_node_level(pos)
// add_node_level(pos)
// pos = {x=num, y=num, z=num}
static int l_add_node_level(lua_State *L);
// minetest.get_meta(pos)
// get_meta(pos)
static int l_get_meta(lua_State *L);
// minetest.get_node_timer(pos)
// get_node_timer(pos)
static int l_get_node_timer(lua_State *L);
// minetest.add_entity(pos, entityname) -> ObjectRef or nil
// add_entity(pos, entityname) -> ObjectRef or nil
// pos = {x=num, y=num, z=num}
static int l_add_entity(lua_State *L);
// minetest.add_item(pos, itemstack or itemstring or table) -> ObjectRef or nil
// add_item(pos, itemstack or itemstring or table) -> ObjectRef or nil
// pos = {x=num, y=num, z=num}
static int l_add_item(lua_State *L);
// minetest.get_player_by_name(name)
// get_player_by_name(name)
static int l_get_player_by_name(lua_State *L);
// minetest.get_objects_inside_radius(pos, radius)
// get_objects_inside_radius(pos, radius)
static int l_get_objects_inside_radius(lua_State *L);
// minetest.set_timeofday(val)
// set_timeofday(val)
// val = 0...1
static int l_set_timeofday(lua_State *L);
// minetest.get_timeofday() -> 0...1
// get_timeofday() -> 0...1
static int l_get_timeofday(lua_State *L);
// minetest.get_gametime()
// get_gametime()
static int l_get_gametime(lua_State *L);
// minetest.find_node_near(pos, radius, nodenames) -> pos or nil
// find_node_near(pos, radius, nodenames) -> pos or nil
// nodenames: eg. {"ignore", "group:tree"} or "default:dirt"
static int l_find_node_near(lua_State *L);
// minetest.find_nodes_in_area(minp, maxp, nodenames) -> list of positions
// find_nodes_in_area(minp, maxp, nodenames) -> list of positions
// nodenames: eg. {"ignore", "group:tree"} or "default:dirt"
static int l_find_nodes_in_area(lua_State *L);
// minetest.get_perlin(seeddiff, octaves, persistence, scale)
// get_perlin(seeddiff, octaves, persistence, scale)
// returns world-specific PerlinNoise
static int l_get_perlin(lua_State *L);
// minetest.get_perlin_map(noiseparams, size)
// get_perlin_map(noiseparams, size)
// returns world-specific PerlinNoiseMap
static int l_get_perlin_map(lua_State *L);
// minetest.get_voxel_manip()
// get_voxel_manip()
// returns world-specific voxel manipulator
static int l_get_voxel_manip(lua_State *L);
// minetest.clear_objects()
// clear_objects()
// clear all objects in the environment
static int l_clear_objects(lua_State *L);
// minetest.spawn_tree(pos, treedef)
// spawn_tree(pos, treedef)
static int l_spawn_tree(lua_State *L);
// minetest.line_of_sight(pos1, pos2, stepsize) -> true/false
// line_of_sight(pos1, pos2, stepsize) -> true/false
static int l_line_of_sight(lua_State *L);
// minetest.find_path(pos1, pos2, searchdistance,
// find_path(pos1, pos2, searchdistance,
// max_jump, max_drop, algorithm) -> table containing path
static int l_find_path(lua_State *L);
// minetest.transforming_liquid_add(pos)
// transforming_liquid_add(pos)
static int l_transforming_liquid_add(lua_State *L);
// minetest.forceload_block(blockpos)
// forceload_block(blockpos)
// forceloads a block
static int l_forceload_block(lua_State *L);
// minetest.forceload_free_block(blockpos)
// forceload_free_block(blockpos)
// stops forceloading a position
static int l_forceload_free_block(lua_State *L);

2
src/script/lua_api/l_inventory.cpp
View File

@ -361,7 +361,7 @@ int InvRef::l_remove_item(lua_State *L)
return 1;
}
// get_location() -> location (like minetest.get_inventory(location))
// get_location() -> location (like get_inventory(location))
int InvRef::l_get_location(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;

2
src/script/lua_api/l_inventory.h
View File

@ -101,7 +101,7 @@ private:
// Returns the items that were actually removed
static int l_remove_item(lua_State *L);
// get_location() -> location (like minetest.get_inventory(location))
// get_location() -> location (like get_inventory(location))
static int l_get_location(lua_State *L);
public:

6
src/script/lua_api/l_item.cpp
View File

@ -234,7 +234,7 @@ int LuaItemStack::l_is_known(lua_State *L)
}
// get_definition(self) -> table
// Returns the item definition table from minetest.registered_items,
// Returns the item definition table from registered_items,
// or a fallback one (name="unknown")
int LuaItemStack::l_get_definition(lua_State *L)
{
@ -242,8 +242,8 @@ int LuaItemStack::l_get_definition(lua_State *L)
LuaItemStack *o = checkobject(L, 1);
ItemStack &item = o->m_stack;
// Get minetest.registered_items[name]
lua_getglobal(L, "minetest");
// Get registered_items[name]
lua_getglobal(L, "core");
lua_getfield(L, -1, "registered_items");
luaL_checktype(L, -1, LUA_TTABLE);
lua_getfield(L, -1, item.name.c_str());

2
src/script/lua_api/l_item.h
View File

@ -85,7 +85,7 @@ private:
static int l_is_known(lua_State *L);
// get_definition(self) -> table
// Returns the item definition table from minetest.registered_items,
// Returns the item definition table from core.registered_items,
// or a fallback one (name="unknown")
static int l_get_definition(lua_State *L);

6
src/script/lua_api/l_mapgen.cpp
View File

@ -78,7 +78,7 @@ struct EnumString ModApiMapgen::es_Rotation[] =
};
// minetest.get_mapgen_object(objectname)
// get_mapgen_object(objectname)
// returns the requested object used during map generation
int ModApiMapgen::l_get_mapgen_object(lua_State *L)
{
@ -181,7 +181,7 @@ int ModApiMapgen::l_get_mapgen_object(lua_State *L)
return 0;
}
// minetest.set_mapgen_params(params)
// set_mapgen_params(params)
// set mapgen parameters
int ModApiMapgen::l_set_mapgen_params(lua_State *L)
{
@ -225,7 +225,7 @@ int ModApiMapgen::l_set_mapgen_params(lua_State *L)
return 0;
}
// minetest.set_noiseparam_defaults({np1={noise params}, ...})
// set_noiseparam_defaults({np1={noise params}, ...})
// set default values for noise parameters if not present in global settings
int ModApiMapgen::l_set_noiseparam_defaults(lua_State *L)
{

6
src/script/lua_api/l_mapgen.h
View File

@ -24,15 +24,15 @@ with this program; if not, write to the Free Software Foundation, Inc.,
class ModApiMapgen : public ModApiBase {
private:
// minetest.get_mapgen_object(objectname)
// get_mapgen_object(objectname)
// returns the requested object used during map generation
static int l_get_mapgen_object(lua_State *L);
// minetest.set_mapgen_params(params)
// set_mapgen_params(params)
// set mapgen parameters
static int l_set_mapgen_params(lua_State *L);
// minetest.set_noiseparam_defaults({np1={noise params}, ...})
// set_noiseparam_defaults({np1={noise params}, ...})
static int l_set_noiseparam_defaults(lua_State *L);
// set_gen_notify(flagstring)

2
src/script/lua_api/l_server.cpp
View File

@ -341,7 +341,7 @@ int ModApiServer::l_show_formspec(lua_State *L)
int ModApiServer::l_get_current_modname(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
lua_getfield(L, LUA_REGISTRYINDEX, "minetest_current_modname");
lua_getfield(L, LUA_REGISTRYINDEX, "current_modname");
return 1;
}

5
src/script/lua_api/l_util.h
View File

@ -28,9 +28,8 @@ class ModApiUtil : public ModApiBase {
private:
/*
NOTE:
The functions in this module are available through
minetest.<function> in the in-game API as well as
engine.<function> in the mainmenu API
The functions in this module are available in the in-game API
as well as in the mainmenu API.
All functions that don't require either a Server or
GUIEngine instance should be in here.

11
src/script/scripting_game.cpp
View File

@ -19,7 +19,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "scripting_game.h"
#include "server.h"
#include "filesys.h"
#include "log.h"
#include "cpp_api/s_internal.h"
#include "lua_api/l_base.h"
@ -52,17 +51,9 @@ GameScripting::GameScripting(Server* server)
//TODO add security
luaL_openlibs(getStack());
SCRIPTAPI_PRECHECKHEADER
lua_pushstring(L, DIR_DELIM);
lua_setglobal(L, "DIR_DELIM");
// Create the main minetest table
lua_newtable(L);
lua_setglobal(L, "minetest");
lua_getglobal(L, "minetest");
lua_getglobal(L, "core");
int top = lua_gettop(L);
lua_newtable(L);

10
src/script/scripting_mainmenu.cpp
View File

@ -21,7 +21,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "mods.h"
#include "porting.h"
#include "log.h"
#include "filesys.h"
#include "cpp_api/s_internal.h"
#include "lua_api/l_base.h"
#include "lua_api/l_mainmenu.h"
@ -41,18 +40,11 @@ MainMenuScripting::MainMenuScripting(GUIEngine* guiengine)
//TODO add security
luaL_openlibs(getStack());
SCRIPTAPI_PRECHECKHEADER
lua_newtable(L);
lua_setglobal(L, "engine");
lua_getglobal(L, "engine");
lua_getglobal(L, "core");
int top = lua_gettop(L);
lua_pushstring(L, DIR_DELIM);
lua_setglobal(L, "DIR_DELIM");
lua_newtable(L);
lua_setglobal(L, "gamedata");