#include "lua_api/l_internal.h"
#include "common/c_converter.h"
#include "common/c_content.h"
+#include "common/c_packer.h"
#include "cpp_api/s_base.h"
+#include "cpp_api/s_security.h"
+#include "scripting_server.h"
#include "server.h"
#include "environment.h"
-#include "player.h"
+#include "remoteplayer.h"
#include "log.h"
+#include <algorithm>
// request_shutdown()
int ModApiServer::l_request_shutdown(lua_State *L)
{
+ NO_MAP_LOCK_REQUIRED;
const char *msg = lua_tolstring(L, 1, NULL);
- bool reconnect = lua_toboolean(L, 2);
- getServer(L)->requestShutdown(msg ? msg : "", reconnect);
+ bool reconnect = readParam<bool>(L, 2);
+ float seconds_before_shutdown = lua_tonumber(L, 3);
+ getServer(L)->requestShutdown(msg ? msg : "", reconnect, seconds_before_shutdown);
return 0;
}
int ModApiServer::l_get_server_status(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
- lua_pushstring(L, wide_to_narrow(getServer(L)->getStatusString()).c_str());
+ lua_pushstring(L, getServer(L)->getStatusString().c_str());
+ return 1;
+}
+
+// get_server_uptime()
+int ModApiServer::l_get_server_uptime(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ lua_pushnumber(L, getServer(L)->getUptime());
+ return 1;
+}
+
+// get_server_max_lag()
+int ModApiServer::l_get_server_max_lag(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ GET_ENV_PTR;
+ lua_pushnumber(L, env->getMaxLagEstimate());
return 1;
}
+// print(text)
+int ModApiServer::l_print(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ std::string text;
+ text = luaL_checkstring(L, 1);
+ getServer(L)->printToConsoleOnly(text);
+ return 0;
+}
+
// chat_send_all(text)
int ModApiServer::l_chat_send_all(lua_State *L)
{
// Get server from registry
Server *server = getServer(L);
// Send
- server->notifyPlayers(narrow_to_wide(text));
+ server->notifyPlayers(utf8_to_wide(text));
return 0;
}
// Get server from registry
Server *server = getServer(L);
// Send
- server->notifyPlayer(name, narrow_to_wide(text));
+ server->notifyPlayer(name, utf8_to_wide(text));
return 0;
}
lua_newtable(L);
int table = lua_gettop(L);
std::set<std::string> privs_s = server->getPlayerEffectivePrivs(name);
- for(std::set<std::string>::const_iterator
- i = privs_s.begin(); i != privs_s.end(); i++){
+ for (const std::string &privs_ : privs_s) {
lua_pushboolean(L, true);
- lua_setfield(L, table, i->c_str());
+ lua_setfield(L, table, privs_.c_str());
}
lua_pushvalue(L, table);
return 1;
int ModApiServer::l_get_player_ip(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
- const char * name = luaL_checkstring(L, 1);
- Player *player = getEnv(L)->getPlayer(name);
- if(player == NULL)
- {
+
+ Server *server = getServer(L);
+
+ const char *name = luaL_checkstring(L, 1);
+ RemotePlayer *player = server->getEnv().getPlayer(name);
+ if (!player) {
lua_pushnil(L); // no such player
return 1;
}
- try
- {
- Address addr = getServer(L)->getPeerAddress(player->peer_id);
- std::string ip_str = addr.serializeString();
- lua_pushstring(L, ip_str.c_str());
- return 1;
- }
- catch(con::PeerNotFoundException) // unlikely
- {
- dstream << __FUNCTION_NAME << ": peer was not found" << std::endl;
- lua_pushnil(L); // error
- return 1;
- }
+
+ lua_pushstring(L, server->getPeerAddress(player->getPeerId()).serializeString().c_str());
+ return 1;
}
-// get_player_information()
+// get_player_information(name)
int ModApiServer::l_get_player_information(lua_State *L)
{
-
NO_MAP_LOCK_REQUIRED;
- const char * name = luaL_checkstring(L, 1);
- Player *player = getEnv(L)->getPlayer(name);
- if(player == NULL)
- {
+
+ Server *server = getServer(L);
+
+ const char *name = luaL_checkstring(L, 1);
+ RemotePlayer *player = server->getEnv().getPlayer(name);
+ if (!player) {
lua_pushnil(L); // no such player
return 1;
}
- Address addr;
- try
- {
- addr = getServer(L)->getPeerAddress(player->peer_id);
- }
- catch(con::PeerNotFoundException) // unlikely
- {
- dstream << __FUNCTION_NAME << ": peer was not found" << std::endl;
+ /*
+ Be careful not to introduce a depdendency on the connection to
+ the peer here. This function is >>REQUIRED<< to still be able to return
+ values even when the peer unexpectedly disappears.
+ Hence all the ConInfo values here are optional.
+ */
+
+ auto getConInfo = [&] (con::rtt_stat_type type, float *value) -> bool {
+ return server->getClientConInfo(player->getPeerId(), type, value);
+ };
+
+ float min_rtt, max_rtt, avg_rtt, min_jitter, max_jitter, avg_jitter;
+ bool have_con_info =
+ getConInfo(con::MIN_RTT, &min_rtt) &&
+ getConInfo(con::MAX_RTT, &max_rtt) &&
+ getConInfo(con::AVG_RTT, &avg_rtt) &&
+ getConInfo(con::MIN_JITTER, &min_jitter) &&
+ getConInfo(con::MAX_JITTER, &max_jitter) &&
+ getConInfo(con::AVG_JITTER, &avg_jitter);
+
+ ClientInfo info;
+ if (!server->getClientInfo(player->getPeerId(), info)) {
+ warningstream << FUNCTION_NAME << ": no client info?!" << std::endl;
lua_pushnil(L); // error
return 1;
}
- float min_rtt,max_rtt,avg_rtt,min_jitter,max_jitter,avg_jitter;
- ClientState state;
- u32 uptime;
- u16 prot_vers;
- u8 ser_vers,major,minor,patch;
- std::string vers_string;
-
-#define ERET(code) \
- if (!(code)) { \
- dstream << __FUNCTION_NAME << ": peer was not found" << std::endl; \
- lua_pushnil(L); /* error */ \
- return 1; \
- }
-
- ERET(getServer(L)->getClientConInfo(player->peer_id,con::MIN_RTT,&min_rtt))
- ERET(getServer(L)->getClientConInfo(player->peer_id,con::MAX_RTT,&max_rtt))
- ERET(getServer(L)->getClientConInfo(player->peer_id,con::AVG_RTT,&avg_rtt))
- ERET(getServer(L)->getClientConInfo(player->peer_id,con::MIN_JITTER,&min_jitter))
- ERET(getServer(L)->getClientConInfo(player->peer_id,con::MAX_JITTER,&max_jitter))
- ERET(getServer(L)->getClientConInfo(player->peer_id,con::AVG_JITTER,&avg_jitter))
-
- ERET(getServer(L)->getClientInfo(player->peer_id,
- &state, &uptime, &ser_vers, &prot_vers,
- &major, &minor, &patch, &vers_string))
-
lua_newtable(L);
int table = lua_gettop(L);
lua_pushstring(L,"address");
- lua_pushstring(L, addr.serializeString().c_str());
+ lua_pushstring(L, info.addr.serializeString().c_str());
lua_settable(L, table);
lua_pushstring(L,"ip_version");
- if (addr.getFamily() == AF_INET) {
+ if (info.addr.getFamily() == AF_INET) {
lua_pushnumber(L, 4);
- } else if (addr.getFamily() == AF_INET6) {
+ } else if (info.addr.getFamily() == AF_INET6) {
lua_pushnumber(L, 6);
} else {
lua_pushnumber(L, 0);
}
lua_settable(L, table);
- lua_pushstring(L,"min_rtt");
- lua_pushnumber(L, min_rtt);
- lua_settable(L, table);
+ if (have_con_info) { // may be missing
+ lua_pushstring(L, "min_rtt");
+ lua_pushnumber(L, min_rtt);
+ lua_settable(L, table);
- lua_pushstring(L,"max_rtt");
- lua_pushnumber(L, max_rtt);
- lua_settable(L, table);
+ lua_pushstring(L, "max_rtt");
+ lua_pushnumber(L, max_rtt);
+ lua_settable(L, table);
- lua_pushstring(L,"avg_rtt");
- lua_pushnumber(L, avg_rtt);
- lua_settable(L, table);
+ lua_pushstring(L, "avg_rtt");
+ lua_pushnumber(L, avg_rtt);
+ lua_settable(L, table);
- lua_pushstring(L,"min_jitter");
- lua_pushnumber(L, min_jitter);
+ lua_pushstring(L, "min_jitter");
+ lua_pushnumber(L, min_jitter);
+ lua_settable(L, table);
+
+ lua_pushstring(L, "max_jitter");
+ lua_pushnumber(L, max_jitter);
+ lua_settable(L, table);
+
+ lua_pushstring(L, "avg_jitter");
+ lua_pushnumber(L, avg_jitter);
+ lua_settable(L, table);
+ }
+
+ lua_pushstring(L,"connection_uptime");
+ lua_pushnumber(L, info.uptime);
lua_settable(L, table);
- lua_pushstring(L,"max_jitter");
- lua_pushnumber(L, max_jitter);
+ lua_pushstring(L,"protocol_version");
+ lua_pushnumber(L, info.prot_vers);
lua_settable(L, table);
- lua_pushstring(L,"avg_jitter");
- lua_pushnumber(L, avg_jitter);
+ lua_pushstring(L, "formspec_version");
+ lua_pushnumber(L, player->formspec_version);
lua_settable(L, table);
- lua_pushstring(L,"connection_uptime");
- lua_pushnumber(L, uptime);
+ lua_pushstring(L, "lang_code");
+ lua_pushstring(L, info.lang_code.c_str());
lua_settable(L, table);
#ifndef NDEBUG
lua_pushstring(L,"serialization_version");
- lua_pushnumber(L, ser_vers);
- lua_settable(L, table);
-
- lua_pushstring(L,"protocol_version");
- lua_pushnumber(L, prot_vers);
+ lua_pushnumber(L, info.ser_vers);
lua_settable(L, table);
lua_pushstring(L,"major");
- lua_pushnumber(L, major);
+ lua_pushnumber(L, info.major);
lua_settable(L, table);
lua_pushstring(L,"minor");
- lua_pushnumber(L, minor);
+ lua_pushnumber(L, info.minor);
lua_settable(L, table);
lua_pushstring(L,"patch");
- lua_pushnumber(L, patch);
+ lua_pushnumber(L, info.patch);
lua_settable(L, table);
lua_pushstring(L,"version_string");
- lua_pushstring(L, vers_string.c_str());
+ lua_pushstring(L, info.vers_string.c_str());
lua_settable(L, table);
lua_pushstring(L,"state");
- lua_pushstring(L,ClientInterface::state2Name(state).c_str());
+ lua_pushstring(L, ClientInterface::state2Name(info.state).c_str());
lua_settable(L, table);
#endif
-#undef ERET
+ return 1;
+}
+
+// get_player_window_information(name)
+int ModApiServer::l_get_player_window_information(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+
+ Server *server = getServer(L);
+
+ const char *name = luaL_checkstring(L, 1);
+ RemotePlayer *player = server->getEnv().getPlayer(name);
+ if (!player)
+ return 0;
+
+ auto dynamic = server->getClientDynamicInfo(player->getPeerId());
+
+ if (!dynamic || dynamic->render_target_size == v2u32())
+ return 0;
+
+ lua_newtable(L);
+ int dyn_table = lua_gettop(L);
+
+ lua_pushstring(L, "size");
+ push_v2u32(L, dynamic->render_target_size);
+ lua_settable(L, dyn_table);
+
+ lua_pushstring(L, "max_formspec_size");
+ push_v2f(L, dynamic->max_fs_size);
+ lua_settable(L, dyn_table);
+
+ lua_pushstring(L, "real_gui_scaling");
+ lua_pushnumber(L, dynamic->real_gui_scaling);
+ lua_settable(L, dyn_table);
+
+ lua_pushstring(L, "real_hud_scaling");
+ lua_pushnumber(L, dynamic->real_hud_scaling);
+ lua_settable(L, dyn_table);
return 1;
}
int ModApiServer::l_ban_player(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
- const char * name = luaL_checkstring(L, 1);
- Player *player = getEnv(L)->getPlayer(name);
- if(player == NULL)
- {
+
+ if (!getEnv(L))
+ throw LuaError("Can't ban player before server has started up");
+
+ Server *server = getServer(L);
+ const char *name = luaL_checkstring(L, 1);
+ RemotePlayer *player = server->getEnv().getPlayer(name);
+ if (!player) {
lua_pushboolean(L, false); // no such player
return 1;
}
- try
- {
- Address addr = getServer(L)->getPeerAddress(getEnv(L)->getPlayer(name)->peer_id);
- std::string ip_str = addr.serializeString();
- getServer(L)->setIpBanned(ip_str, name);
- }
- catch(con::PeerNotFoundException) // unlikely
- {
- dstream << __FUNCTION_NAME << ": peer was not found" << std::endl;
- lua_pushboolean(L, false); // error
- return 1;
- }
+
+ std::string ip_str = server->getPeerAddress(player->getPeerId()).serializeString();
+ server->setIpBanned(ip_str, name);
lua_pushboolean(L, true);
return 1;
}
-// kick_player(name, [reason]) -> success
-int ModApiServer::l_kick_player(lua_State *L)
+// disconnect_player(name, [reason]) -> success
+int ModApiServer::l_disconnect_player(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
+
+ if (!getEnv(L))
+ throw LuaError("Can't kick player before server has started up");
+
const char *name = luaL_checkstring(L, 1);
std::string message;
if (lua_isstring(L, 2))
- {
- message = std::string("Kicked: ") + lua_tostring(L, 2);
- }
+ message.append(readParam<std::string>(L, 2));
else
- {
- message = "Kicked.";
- }
- Player *player = getEnv(L)->getPlayer(name);
- if (player == NULL)
- {
+ message.append("Disconnected.");
+
+ Server *server = getServer(L);
+
+ RemotePlayer *player = server->getEnv().getPlayer(name);
+ if (!player) {
lua_pushboolean(L, false); // No such player
return 1;
}
- getServer(L)->DenyAccess_Legacy(player->peer_id, utf8_to_wide(message));
+
+ server->DenyAccess(player->getPeerId(), SERVER_ACCESSDENIED_CUSTOM_STRING, message);
lua_pushboolean(L, true);
return 1;
}
+int ModApiServer::l_remove_player(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ std::string name = luaL_checkstring(L, 1);
+ ServerEnvironment *s_env = dynamic_cast<ServerEnvironment *>(getEnv(L));
+ if (!s_env)
+ throw LuaError("Can't remove player before server has started up");
+
+ RemotePlayer *player = s_env->getPlayer(name.c_str());
+ if (!player)
+ lua_pushinteger(L, s_env->removePlayerFromDatabase(name) ? 0 : 1);
+ else
+ lua_pushinteger(L, 2);
+
+ return 1;
+}
+
// unban_player_or_ip()
int ModApiServer::l_unban_player_or_ip(lua_State *L)
{
{
NO_MAP_LOCK_REQUIRED;
std::string modname = luaL_checkstring(L, 1);
- const ModSpec *mod = getServer(L)->getModSpec(modname);
- if (!mod) {
+ const ModSpec *mod = getGameDef(L)->getModSpec(modname);
+ if (!mod)
lua_pushnil(L);
- return 1;
- }
- lua_pushstring(L, mod->path.c_str());
+ else
+ lua_pushstring(L, mod->path.c_str());
return 1;
}
// Get a list of mods
std::vector<std::string> modlist;
- getServer(L)->getModNames(modlist);
+ for (auto &it : getGameDef(L)->getMods())
+ modlist.emplace_back(it.name);
- // Take unsorted items from mods_unsorted and sort them into
- // mods_sorted; not great performance but the number of mods on a
- // server will likely be small.
std::sort(modlist.begin(), modlist.end());
// Package them up for Lua
lua_createtable(L, modlist.size(), 0);
- std::vector<std::string>::iterator iter = modlist.begin();
- for (u16 i = 0; iter != modlist.end(); iter++) {
+ auto iter = modlist.begin();
+ for (u16 i = 0; iter != modlist.end(); ++iter) {
lua_pushstring(L, iter->c_str());
lua_rawseti(L, -2, ++i);
}
return 1;
}
+// get_game_info()
+int ModApiServer::l_get_game_info(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ const SubgameSpec *game_spec = getGameDef(L)->getGameSpec();
+ assert(game_spec);
+ lua_newtable(L);
+ setstringfield(L, -1, "id", game_spec->id);
+ setstringfield(L, -1, "title", game_spec->title);
+ setstringfield(L, -1, "author", game_spec->author);
+ setstringfield(L, -1, "path", game_spec->path);
+ return 1;
+}
+
// get_worldpath()
int ModApiServer::l_get_worldpath(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
- std::string worldpath = getServer(L)->getWorldPath();
- lua_pushstring(L, worldpath.c_str());
+ const Server *srv = getServer(L);
+ lua_pushstring(L, srv->getWorldPath().c_str());
return 1;
}
-// sound_play(spec, parameters)
+// sound_play(spec, parameters, [ephemeral])
int ModApiServer::l_sound_play(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
- SimpleSoundSpec spec;
- read_soundspec(L, 1, spec);
- ServerSoundParams params;
+ ServerPlayingSound params;
+ read_soundspec(L, 1, params.spec);
read_server_sound_params(L, 2, params);
- s32 handle = getServer(L)->playSound(spec, params);
- lua_pushinteger(L, handle);
+ bool ephemeral = lua_gettop(L) > 2 && readParam<bool>(L, 3);
+ if (ephemeral) {
+ getServer(L)->playSound(params, true);
+ lua_pushnil(L);
+ } else {
+ s32 handle = getServer(L)->playSound(params);
+ lua_pushinteger(L, handle);
+ }
return 1;
}
int ModApiServer::l_sound_stop(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
- int handle = luaL_checkinteger(L, 1);
+ s32 handle = luaL_checkinteger(L, 1);
getServer(L)->stopSound(handle);
return 0;
}
+int ModApiServer::l_sound_fade(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ s32 handle = luaL_checkinteger(L, 1);
+ float step = readParam<float>(L, 2);
+ float gain = readParam<float>(L, 3);
+ getServer(L)->fadeSound(handle, step, gain);
+ return 0;
+}
+
+// dynamic_add_media(filepath)
+int ModApiServer::l_dynamic_add_media(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+
+ if (!getEnv(L))
+ throw LuaError("Dynamic media cannot be added before server has started up");
+ Server *server = getServer(L);
+
+ std::string filepath;
+ std::string to_player;
+ bool ephemeral = false;
+
+ if (lua_istable(L, 1)) {
+ getstringfield(L, 1, "filepath", filepath);
+ getstringfield(L, 1, "to_player", to_player);
+ getboolfield(L, 1, "ephemeral", ephemeral);
+ } else {
+ filepath = readParam<std::string>(L, 1);
+ }
+ if (filepath.empty())
+ luaL_typerror(L, 1, "non-empty string");
+ luaL_checktype(L, 2, LUA_TFUNCTION);
+
+ CHECK_SECURE_PATH(L, filepath.c_str(), false);
+
+ u32 token = server->getScriptIface()->allocateDynamicMediaCallback(L, 2);
+
+ bool ok = server->dynamicAddMedia(filepath, token, to_player, ephemeral);
+ if (!ok)
+ server->getScriptIface()->freeDynamicMediaCallback(token);
+ lua_pushboolean(L, ok);
+
+ return 1;
+}
+
// is_singleplayer()
int ModApiServer::l_is_singleplayer(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
- lua_pushboolean(L, getServer(L)->isSingleplayer());
+ const Server *srv = getServer(L);
+ lua_pushboolean(L, srv->isSingleplayer());
return 1;
}
int ModApiServer::l_notify_authentication_modified(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
- std::string name = "";
+ std::string name;
if(lua_isstring(L, 1))
- name = lua_tostring(L, 1);
+ name = readParam<std::string>(L, 1);
getServer(L)->reportPrivsModified(name);
return 0;
}
-// get_last_run_mod()
-int ModApiServer::l_get_last_run_mod(lua_State *L)
+// do_async_callback(func, params, mod_origin)
+int ModApiServer::l_do_async_callback(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
- lua_rawgeti(L, LUA_REGISTRYINDEX, CUSTOM_RIDX_CURRENT_MOD_NAME);
- const char *current_mod = lua_tostring(L, -1);
- if (current_mod == NULL || current_mod[0] == '\0') {
- lua_pop(L, 1);
- lua_pushstring(L, getScriptApiBase(L)->getOrigin().c_str());
- }
+ ServerScripting *script = getScriptApi<ServerScripting>(L);
+
+ luaL_checktype(L, 1, LUA_TFUNCTION);
+ luaL_checktype(L, 2, LUA_TTABLE);
+ luaL_checktype(L, 3, LUA_TSTRING);
+
+ call_string_dump(L, 1);
+ size_t func_length;
+ const char *serialized_func_raw = lua_tolstring(L, -1, &func_length);
+
+ PackedValue *param = script_pack(L, 2);
+
+ std::string mod_origin = readParam<std::string>(L, 3);
+
+ u32 jobId = script->queueAsync(
+ std::string(serialized_func_raw, func_length),
+ param, mod_origin);
+
+ lua_settop(L, 0);
+ lua_pushinteger(L, jobId);
return 1;
}
-// set_last_run_mod(modname)
-int ModApiServer::l_set_last_run_mod(lua_State *L)
+// register_async_dofile(path)
+int ModApiServer::l_register_async_dofile(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
-#ifdef SCRIPTAPI_DEBUG
- const char *mod = lua_tostring(L, 1);
- getScriptApiBase(L)->setOriginDirect(mod);
- //printf(">>>> last mod set from Lua: %s\n", mod);
-#endif
- return 0;
+
+ std::string path = readParam<std::string>(L, 1);
+ CHECK_SECURE_PATH(L, path.c_str(), false);
+
+ // Find currently running mod name (only at init time)
+ lua_rawgeti(L, LUA_REGISTRYINDEX, CUSTOM_RIDX_CURRENT_MOD_NAME);
+ if (!lua_isstring(L, -1))
+ return 0;
+ std::string modname = readParam<std::string>(L, -1);
+
+ getServer(L)->m_async_init_files.emplace_back(modname, path);
+ lua_pushboolean(L, true);
+ return 1;
}
-#ifndef NDEBUG
-// cause_error(type_of_error)
-int ModApiServer::l_cause_error(lua_State *L)
+// serialize_roundtrip(value)
+// Meant for unit testing the packer from Lua
+int ModApiServer::l_serialize_roundtrip(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
- std::string type_of_error = "none";
- if(lua_isstring(L, 1))
- type_of_error = lua_tostring(L, 1);
-
- errorstream << "Error handler test called, errortype=" << type_of_error << std::endl;
-
- if(type_of_error == "segv") {
- volatile int* some_pointer = 0;
- errorstream << "Cause a sigsegv now: " << (*some_pointer) << std::endl;
- } else if (type_of_error == "zerodivision") {
+ int top = lua_gettop(L);
+ auto *pv = script_pack(L, 1);
+ if (top != lua_gettop(L))
+ throw LuaError("stack values leaked");
- unsigned int some_number = porting::getTimeS();
- unsigned int zerovalue = 0;
- unsigned int result = some_number / zerovalue;
- errorstream << "Well this shouldn't ever be shown: " << result << std::endl;
+#ifndef NDEBUG
+ script_dump_packed(pv);
+#endif
- } else if (type_of_error == "exception") {
- throw BaseException("Errorhandler test fct called");
- }
+ top = lua_gettop(L);
+ script_unpack(L, pv);
+ delete pv;
+ if (top + 1 != lua_gettop(L))
+ throw LuaError("stack values leaked");
- return 0;
+ return 1;
}
-#endif
void ModApiServer::Initialize(lua_State *L, int top)
{
API_FCT(request_shutdown);
API_FCT(get_server_status);
+ API_FCT(get_server_uptime);
+ API_FCT(get_server_max_lag);
API_FCT(get_worldpath);
API_FCT(is_singleplayer);
API_FCT(get_current_modname);
API_FCT(get_modpath);
API_FCT(get_modnames);
+ API_FCT(get_game_info);
+
+ API_FCT(print);
API_FCT(chat_send_all);
API_FCT(chat_send_player);
API_FCT(show_formspec);
API_FCT(sound_play);
API_FCT(sound_stop);
+ API_FCT(sound_fade);
+ API_FCT(dynamic_add_media);
API_FCT(get_player_information);
+ API_FCT(get_player_window_information);
API_FCT(get_player_privs);
API_FCT(get_player_ip);
API_FCT(get_ban_list);
API_FCT(get_ban_description);
API_FCT(ban_player);
- API_FCT(kick_player);
+ API_FCT(disconnect_player);
+ API_FCT(remove_player);
API_FCT(unban_player_or_ip);
API_FCT(notify_authentication_modified);
- API_FCT(get_last_run_mod);
- API_FCT(set_last_run_mod);
-#ifndef NDEBUG
- API_FCT(cause_error);
-#endif
+ API_FCT(do_async_callback);
+ API_FCT(register_async_dofile);
+ API_FCT(serialize_roundtrip);
+}
+
+void ModApiServer::InitializeAsync(lua_State *L, int top)
+{
+ API_FCT(get_worldpath);
+ API_FCT(is_singleplayer);
+
+ API_FCT(get_current_modname);
+ API_FCT(get_modpath);
+ API_FCT(get_modnames);
+ API_FCT(get_game_info);
}
projects / minetest.git / blobdiff