summaryrefslogtreecommitdiff
path: root/src/script/lua_api
diff options
context:
space:
mode:
Diffstat (limited to 'src/script/lua_api')
-rw-r--r--src/script/lua_api/CMakeLists.txt13
-rw-r--r--src/script/lua_api/l_base.cpp63
-rw-r--r--src/script/lua_api/l_base.h63
-rw-r--r--src/script/lua_api/l_craft.cpp477
-rw-r--r--src/script/lua_api/l_craft.h52
-rw-r--r--src/script/lua_api/l_env.cpp687
-rw-r--r--src/script/lua_api/l_env.h172
-rw-r--r--src/script/lua_api/l_inventory.cpp479
-rw-r--r--src/script/lua_api/l_inventory.h137
-rw-r--r--src/script/lua_api/l_item.cpp472
-rw-r--r--src/script/lua_api/l_item.h151
-rw-r--r--src/script/lua_api/l_nodemeta.cpp332
-rw-r--r--src/script/lua_api/l_nodemeta.h93
-rw-r--r--src/script/lua_api/l_nodetimer.cpp169
-rw-r--r--src/script/lua_api/l_nodetimer.h70
-rw-r--r--src/script/lua_api/l_noise.cpp373
-rw-r--r--src/script/lua_api/l_noise.h134
-rw-r--r--src/script/lua_api/l_object.cpp1113
-rw-r--r--src/script/lua_api/l_object.h229
-rw-r--r--src/script/lua_api/l_particles.cpp149
-rw-r--r--src/script/lua_api/l_particles.h39
-rw-r--r--src/script/lua_api/luaapi.cpp653
-rw-r--r--src/script/lua_api/luaapi.h140
23 files changed, 6260 insertions, 0 deletions
diff --git a/src/script/lua_api/CMakeLists.txt b/src/script/lua_api/CMakeLists.txt
new file mode 100644
index 000000000..7610ce8f1
--- /dev/null
+++ b/src/script/lua_api/CMakeLists.txt
@@ -0,0 +1,13 @@
+set(SCRIPT_LUA_API_SRCS
+ ${CMAKE_CURRENT_SOURCE_DIR}/l_base.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/l_craft.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/l_env.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/l_inventory.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/l_item.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/luaapi.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/l_nodemeta.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/l_nodetimer.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/l_noise.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/l_object.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/l_particles.cpp
+ PARENT_SCOPE)
diff --git a/src/script/lua_api/l_base.cpp b/src/script/lua_api/l_base.cpp
new file mode 100644
index 000000000..b1766e6df
--- /dev/null
+++ b/src/script/lua_api/l_base.cpp
@@ -0,0 +1,63 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "cpp_api/scriptapi.h"
+#include "lua_api/l_base.h"
+#include "common/c_internal.h"
+#include "log.h"
+
+extern "C" {
+#include "lua.h"
+}
+
+ModApiBase::ModApiBase() {
+ ScriptApi::registerModApiModule(this);
+}
+
+Server* ModApiBase::getServer(lua_State* L) {
+ return get_scriptapi(L)->getServer();
+}
+
+Environment* ModApiBase::getEnv(lua_State* L) {
+ return get_scriptapi(L)->getEnv();
+}
+
+bool ModApiBase::registerFunction( lua_State* L,
+ const char* name,
+ lua_CFunction fct,
+ int top
+ ) {
+ //TODO check presence first!
+
+ lua_pushstring(L,name);
+ lua_pushcfunction(L,fct);
+ lua_settable(L, top);
+
+ return true;
+}
+
+struct EnumString es_BiomeTerrainType[] =
+{
+ {BIOME_TERRAIN_NORMAL, "normal"},
+ {BIOME_TERRAIN_LIQUID, "liquid"},
+ {BIOME_TERRAIN_NETHER, "nether"},
+ {BIOME_TERRAIN_AETHER, "aether"},
+ {BIOME_TERRAIN_FLAT, "flat"},
+ {0, NULL},
+};
diff --git a/src/script/lua_api/l_base.h b/src/script/lua_api/l_base.h
new file mode 100644
index 000000000..f2e0d59a9
--- /dev/null
+++ b/src/script/lua_api/l_base.h
@@ -0,0 +1,63 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef L_BASE_H_
+#define L_BASE_H_
+
+#include "biome.h"
+#include "common/c_types.h"
+
+extern "C" {
+#include "lua.h"
+}
+
+extern struct EnumString es_BiomeTerrainType[];
+
+class ScriptApi;
+class Server;
+class Environment;
+
+typedef class ModApiBase {
+
+public:
+ ModApiBase();
+
+ virtual bool Initialize(lua_State* L, int top) = 0;
+ virtual ~ModApiBase() {};
+
+protected:
+ static Server* getServer( lua_State* L);
+ static Environment* getEnv( lua_State* L);
+ static bool registerFunction( lua_State* L,
+ const char* name,
+ lua_CFunction fct,
+ int top
+ );
+} ModApiBase;
+
+#if (defined(WIN32) || defined(_WIN32_WCE))
+#define NO_MAP_LOCK_REQUIRED
+#else
+#include "main.h"
+#include "profiler.h"
+#define NO_MAP_LOCK_REQUIRED ScopeProfiler nolocktime(g_profiler,"Scriptapi: unlockable time",SPT_ADD)
+//#define NO_ENVLOCK_REQUIRED assert(getServer(L).m_env_mutex.IsLocked() == false)
+#endif
+
+#endif /* L_BASE_H_ */
diff --git a/src/script/lua_api/l_craft.cpp b/src/script/lua_api/l_craft.cpp
new file mode 100644
index 000000000..a32fb9dff
--- /dev/null
+++ b/src/script/lua_api/l_craft.cpp
@@ -0,0 +1,477 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+
+#include "lua_api/l_craft.h"
+#include "common/c_internal.h"
+#include "common/c_converter.h"
+#include "common/c_content.h"
+#include "server.h"
+#include "lua_api/l_item.h"
+
+extern "C" {
+#include "lauxlib.h"
+}
+
+ModApiCraft::ModApiCraft()
+ : ModApiBase() {
+
+}
+
+struct EnumString ModApiCraft::es_CraftMethod[] =
+{
+ {CRAFT_METHOD_NORMAL, "normal"},
+ {CRAFT_METHOD_COOKING, "cooking"},
+ {CRAFT_METHOD_FUEL, "fuel"},
+ {0, NULL},
+};
+
+
+// helper for register_craft
+bool ModApiCraft::readCraftRecipeShaped(lua_State *L, int index,
+ int &width, std::vector<std::string> &recipe)
+{
+ if(index < 0)
+ index = lua_gettop(L) + 1 + index;
+
+ if(!lua_istable(L, index))
+ return false;
+
+ lua_pushnil(L);
+ int rowcount = 0;
+ while(lua_next(L, index) != 0){
+ int colcount = 0;
+ // key at index -2 and value at index -1
+ if(!lua_istable(L, -1))
+ return false;
+ int table2 = lua_gettop(L);
+ lua_pushnil(L);
+ while(lua_next(L, table2) != 0){
+ // key at index -2 and value at index -1
+ if(!lua_isstring(L, -1))
+ return false;
+ recipe.push_back(lua_tostring(L, -1));
+ // removes value, keeps key for next iteration
+ lua_pop(L, 1);
+ colcount++;
+ }
+ if(rowcount == 0){
+ width = colcount;
+ } else {
+ if(colcount != width)
+ return false;
+ }
+ // removes value, keeps key for next iteration
+ lua_pop(L, 1);
+ rowcount++;
+ }
+ return width != 0;
+}
+
+// helper for register_craft
+bool ModApiCraft::readCraftRecipeShapeless(lua_State *L, int index,
+ std::vector<std::string> &recipe)
+{
+ if(index < 0)
+ index = lua_gettop(L) + 1 + index;
+
+ if(!lua_istable(L, index))
+ return false;
+
+ lua_pushnil(L);
+ while(lua_next(L, index) != 0){
+ // key at index -2 and value at index -1
+ if(!lua_isstring(L, -1))
+ return false;
+ recipe.push_back(lua_tostring(L, -1));
+ // removes value, keeps key for next iteration
+ lua_pop(L, 1);
+ }
+ return true;
+}
+
+// helper for register_craft
+bool ModApiCraft::readCraftReplacements(lua_State *L, int index,
+ CraftReplacements &replacements)
+{
+ if(index < 0)
+ index = lua_gettop(L) + 1 + index;
+
+ if(!lua_istable(L, index))
+ return false;
+
+ lua_pushnil(L);
+ while(lua_next(L, index) != 0){
+ // key at index -2 and value at index -1
+ if(!lua_istable(L, -1))
+ return false;
+ lua_rawgeti(L, -1, 1);
+ if(!lua_isstring(L, -1))
+ return false;
+ std::string replace_from = lua_tostring(L, -1);
+ lua_pop(L, 1);
+ lua_rawgeti(L, -1, 2);
+ if(!lua_isstring(L, -1))
+ return false;
+ std::string replace_to = lua_tostring(L, -1);
+ lua_pop(L, 1);
+ replacements.pairs.push_back(
+ std::make_pair(replace_from, replace_to));
+ // removes value, keeps key for next iteration
+ lua_pop(L, 1);
+ }
+ return true;
+}
+// register_craft({output=item, recipe={{item00,item10},{item01,item11}})
+int ModApiCraft::l_register_craft(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ //infostream<<"register_craft"<<std::endl;
+ luaL_checktype(L, 1, LUA_TTABLE);
+ int table = 1;
+
+ // Get the writable craft definition manager from the server
+ IWritableCraftDefManager *craftdef =
+ getServer(L)->getWritableCraftDefManager();
+
+ std::string type = getstringfield_default(L, table, "type", "shaped");
+
+ /*
+ CraftDefinitionShaped
+ */
+ if(type == "shaped"){
+ std::string output = getstringfield_default(L, table, "output", "");
+ if(output == "")
+ throw LuaError(L, "Crafting definition is missing an output");
+
+ int width = 0;
+ std::vector<std::string> recipe;
+ lua_getfield(L, table, "recipe");
+ if(lua_isnil(L, -1))
+ throw LuaError(L, "Crafting definition is missing a recipe"
+ " (output=\"" + output + "\")");
+ if(!readCraftRecipeShaped(L, -1, width, recipe))
+ throw LuaError(L, "Invalid crafting recipe"
+ " (output=\"" + output + "\")");
+
+ CraftReplacements replacements;
+ lua_getfield(L, table, "replacements");
+ if(!lua_isnil(L, -1))
+ {
+ if(!readCraftReplacements(L, -1, replacements))
+ throw LuaError(L, "Invalid replacements"
+ " (output=\"" + output + "\")");
+ }
+
+ CraftDefinition *def = new CraftDefinitionShaped(
+ output, width, recipe, replacements);
+ craftdef->registerCraft(def);
+ }
+ /*
+ CraftDefinitionShapeless
+ */
+ else if(type == "shapeless"){
+ std::string output = getstringfield_default(L, table, "output", "");
+ if(output == "")
+ throw LuaError(L, "Crafting definition (shapeless)"
+ " is missing an output");
+
+ std::vector<std::string> recipe;
+ lua_getfield(L, table, "recipe");
+ if(lua_isnil(L, -1))
+ throw LuaError(L, "Crafting definition (shapeless)"
+ " is missing a recipe"
+ " (output=\"" + output + "\")");
+ if(!readCraftRecipeShapeless(L, -1, recipe))
+ throw LuaError(L, "Invalid crafting recipe"
+ " (output=\"" + output + "\")");
+
+ CraftReplacements replacements;
+ lua_getfield(L, table, "replacements");
+ if(!lua_isnil(L, -1))
+ {
+ if(!readCraftReplacements(L, -1, replacements))
+ throw LuaError(L, "Invalid replacements"
+ " (output=\"" + output + "\")");
+ }
+
+ CraftDefinition *def = new CraftDefinitionShapeless(
+ output, recipe, replacements);
+ craftdef->registerCraft(def);
+ }
+ /*
+ CraftDefinitionToolRepair
+ */
+ else if(type == "toolrepair"){
+ float additional_wear = getfloatfield_default(L, table,
+ "additional_wear", 0.0);
+
+ CraftDefinition *def = new CraftDefinitionToolRepair(
+ additional_wear);
+ craftdef->registerCraft(def);
+ }
+ /*
+ CraftDefinitionCooking
+ */
+ else if(type == "cooking"){
+ std::string output = getstringfield_default(L, table, "output", "");
+ if(output == "")
+ throw LuaError(L, "Crafting definition (cooking)"
+ " is missing an output");
+
+ std::string recipe = getstringfield_default(L, table, "recipe", "");
+ if(recipe == "")
+ throw LuaError(L, "Crafting definition (cooking)"
+ " is missing a recipe"
+ " (output=\"" + output + "\")");
+
+ float cooktime = getfloatfield_default(L, table, "cooktime", 3.0);
+
+ CraftReplacements replacements;
+ lua_getfield(L, table, "replacements");
+ if(!lua_isnil(L, -1))
+ {
+ if(!readCraftReplacements(L, -1, replacements))
+ throw LuaError(L, "Invalid replacements"
+ " (cooking output=\"" + output + "\")");
+ }
+
+ CraftDefinition *def = new CraftDefinitionCooking(
+ output, recipe, cooktime, replacements);
+ craftdef->registerCraft(def);
+ }
+ /*
+ CraftDefinitionFuel
+ */
+ else if(type == "fuel"){
+ std::string recipe = getstringfield_default(L, table, "recipe", "");
+ if(recipe == "")
+ throw LuaError(L, "Crafting definition (fuel)"
+ " is missing a recipe");
+
+ float burntime = getfloatfield_default(L, table, "burntime", 1.0);
+
+ CraftReplacements replacements;
+ lua_getfield(L, table, "replacements");
+ if(!lua_isnil(L, -1))
+ {
+ if(!readCraftReplacements(L, -1, replacements))
+ throw LuaError(L, "Invalid replacements"
+ " (fuel recipe=\"" + recipe + "\")");
+ }
+
+ CraftDefinition *def = new CraftDefinitionFuel(
+ recipe, burntime, replacements);
+ craftdef->registerCraft(def);
+ }
+ else
+ {
+ throw LuaError(L, "Unknown crafting definition type: \"" + type + "\"");
+ }
+
+ lua_pop(L, 1);
+ return 0; /* number of results */
+}
+
+// get_craft_result(input)
+int ModApiCraft::l_get_craft_result(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+
+ int input_i = 1;
+ std::string method_s = getstringfield_default(L, input_i, "method", "normal");
+ enum CraftMethod method = (CraftMethod)getenumfield(L, input_i, "method",
+ es_CraftMethod, CRAFT_METHOD_NORMAL);
+ int width = 1;
+ lua_getfield(L, input_i, "width");
+ if(lua_isnumber(L, -1))
+ width = luaL_checkinteger(L, -1);
+ lua_pop(L, 1);
+ lua_getfield(L, input_i, "items");
+ std::vector<ItemStack> items = read_items(L, -1,getServer(L));
+ lua_pop(L, 1); // items
+
+ IGameDef *gdef = getServer(L);
+ ICraftDefManager *cdef = gdef->cdef();
+ CraftInput input(method, width, items);
+ CraftOutput output;
+ bool got = cdef->getCraftResult(input, output, true, gdef);
+ lua_newtable(L); // output table
+ if(got){
+ ItemStack item;
+ item.deSerialize(output.item, gdef->idef());
+ LuaItemStack::create(L, item);
+ lua_setfield(L, -2, "item");
+ setintfield(L, -1, "time", output.time);
+ } else {
+ LuaItemStack::create(L, ItemStack());
+ lua_setfield(L, -2, "item");
+ setintfield(L, -1, "time", 0);
+ }
+ lua_newtable(L); // decremented input table
+ lua_pushstring(L, method_s.c_str());
+ lua_setfield(L, -2, "method");
+ lua_pushinteger(L, width);
+ lua_setfield(L, -2, "width");
+ push_items(L, input.items);
+ lua_setfield(L, -2, "items");
+ return 2;
+}
+
+// get_craft_recipe(result item)
+int ModApiCraft::l_get_craft_recipe(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+
+ int k = 1;
+ int input_i = 1;
+ std::string o_item = luaL_checkstring(L,input_i);
+
+ IGameDef *gdef = getServer(L);
+ ICraftDefManager *cdef = gdef->cdef();
+ CraftInput input;
+ CraftOutput output(o_item,0);
+ bool got = cdef->getCraftRecipe(input, output, gdef);
+ lua_newtable(L); // output table
+ if(got){
+ lua_newtable(L);
+ for(std::vector<ItemStack>::const_iterator
+ i = input.items.begin();
+ i != input.items.end(); i++, k++)
+ {
+ if (i->empty())
+ {
+ continue;
+ }
+ lua_pushinteger(L,k);
+ lua_pushstring(L,i->name.c_str());
+ lua_settable(L, -3);
+ }
+ lua_setfield(L, -2, "items");
+ setintfield(L, -1, "width", input.width);
+ switch (input.method) {
+ case CRAFT_METHOD_NORMAL:
+ lua_pushstring(L,"normal");
+ break;
+ case CRAFT_METHOD_COOKING:
+ lua_pushstring(L,"cooking");
+ break;
+ case CRAFT_METHOD_FUEL:
+ lua_pushstring(L,"fuel");
+ break;
+ default:
+ lua_pushstring(L,"unknown");
+ }
+ lua_setfield(L, -2, "type");
+ } else {
+ lua_pushnil(L);
+ lua_setfield(L, -2, "items");
+ setintfield(L, -1, "width", 0);
+ }
+ return 1;
+}
+
+// get_all_craft_recipes(result item)
+int ModApiCraft::l_get_all_craft_recipes(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+
+ std::string o_item = luaL_checkstring(L,1);
+ IGameDef *gdef = getServer(L);
+ ICraftDefManager *cdef = gdef->cdef();
+ CraftInput input;
+ CraftOutput output(o_item,0);
+ std::vector<CraftDefinition*> recipes_list = cdef->getCraftRecipes(output, gdef);
+ if (recipes_list.empty())
+ {
+ lua_pushnil(L);
+ return 1;
+ }
+ // Get the table insert function
+ lua_getglobal(L, "table");
+ lua_getfield(L, -1, "insert");
+ int table_insert = lua_gettop(L);
+ lua_newtable(L);
+ int table = lua_gettop(L);
+ for (std::vector<CraftDefinition*>::const_iterator
+ i = recipes_list.begin();
+ i != recipes_list.end(); i++)
+ {
+ CraftOutput tmpout;
+ tmpout.item = "";
+ tmpout.time = 0;
+ CraftDefinition *def = *i;
+ tmpout = def->getOutput(input, gdef);
+ std::string query = tmpout.item;
+ char *fmtpos, *fmt = &query[0];
+ if (strtok_r(fmt, " ", &fmtpos) == output.item)
+ {
+ input = def->getInput(output, gdef);
+ lua_pushvalue(L, table_insert);
+ lua_pushvalue(L, table);
+ lua_newtable(L);
+ int k = 1;
+ lua_newtable(L);
+ for(std::vector<ItemStack>::const_iterator
+ i = input.items.begin();
+ i != input.items.end(); i++, k++)
+ {
+ if (i->empty())
+ continue;
+ lua_pushinteger(L,k);
+ lua_pushstring(L,i->name.c_str());
+ lua_settable(L, -3);
+ }
+ lua_setfield(L, -2, "items");
+ setintfield(L, -1, "width", input.width);
+ switch (input.method) {
+ case CRAFT_METHOD_NORMAL:
+ lua_pushstring(L,"normal");
+ break;
+ case CRAFT_METHOD_COOKING:
+ lua_pushstring(L,"cooking");
+ break;
+ case CRAFT_METHOD_FUEL:
+ lua_pushstring(L,"fuel");
+ break;
+ default:
+ lua_pushstring(L,"unknown");
+ }
+ lua_setfield(L, -2, "type");
+ lua_pushstring(L, &tmpout.item[0]);
+ lua_setfield(L, -2, "output");
+ if (lua_pcall(L, 2, 0, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
+ }
+ }
+ return 1;
+}
+
+bool ModApiCraft::Initialize(lua_State* L, int top) {
+ bool retval = true;
+
+ retval &= API_FCT(get_all_craft_recipes);
+ retval &= API_FCT(get_craft_recipe);
+ retval &= API_FCT(get_craft_result);
+ retval &= API_FCT(register_craft);
+
+ return retval;
+}
+
+ModApiCraft modapicraft_prototype;
diff --git a/src/script/lua_api/l_craft.h b/src/script/lua_api/l_craft.h
new file mode 100644
index 000000000..d8319199d
--- /dev/null
+++ b/src/script/lua_api/l_craft.h
@@ -0,0 +1,52 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef L_CRAFT_H_
+#define L_CRAFT_H_
+
+#include <vector>
+
+extern "C" {
+#include <lua.h>
+}
+
+#include "lua_api/l_base.h"
+#include "craftdef.h"
+
+class ModApiCraft : public ModApiBase {
+public:
+ ModApiCraft();
+ bool Initialize(lua_State* L, int top);
+private:
+ static int l_register_craft(lua_State *L);
+ static int l_get_craft_recipe(lua_State *L);
+ static int l_get_all_craft_recipes(lua_State *L);
+ static int l_get_craft_result(lua_State *L);
+
+ static bool readCraftReplacements(lua_State *L, int index,
+ CraftReplacements &replacements);
+ static bool readCraftRecipeShapeless(lua_State *L, int index,
+ std::vector<std::string> &recipe);
+ static bool readCraftRecipeShaped(lua_State *L, int index,
+ int &width, std::vector<std::string> &recipe);
+
+ static struct EnumString es_CraftMethod[];
+};
+
+#endif /* L_CRAFT_H_ */
diff --git a/src/script/lua_api/l_env.cpp b/src/script/lua_api/l_env.cpp
new file mode 100644
index 000000000..58cf337ed
--- /dev/null
+++ b/src/script/lua_api/l_env.cpp
@@ -0,0 +1,687 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "cpp_api/scriptapi.h"
+#include "lua_api/l_base.h"
+#include "lua_api/l_env.h"
+#include "environment.h"
+#include "server.h"
+#include "daynightratio.h"
+#include "util/pointedthing.h"
+#include "content_sao.h"
+
+#include "common/c_converter.h"
+#include "common/c_content.h"
+#include "common/c_internal.h"
+#include "lua_api/l_nodemeta.h"
+#include "lua_api/l_nodetimer.h"
+#include "lua_api/l_noise.h"
+#include "treegen.h"
+#include "pathfinder.h"
+
+
+#define GET_ENV_PTR ServerEnvironment* env = \
+ dynamic_cast<ServerEnvironment*>(getEnv(L)); \
+ if( env == NULL) return 0
+
+void LuaABM::trigger(ServerEnvironment *env, v3s16 p, MapNode n,
+ u32 active_object_count, u32 active_object_count_wider)
+{
+ ScriptApi* scriptIface = SERVER_TO_SA(env);
+ scriptIface->realityCheck();
+
+ lua_State* L = scriptIface->getStack();
+ assert(lua_checkstack(L, 20));
+ StackUnroller stack_unroller(L);
+
+ // Get minetest.registered_abms
+ lua_getglobal(L, "minetest");
+ lua_getfield(L, -1, "registered_abms");
+ luaL_checktype(L, -1, LUA_TTABLE);
+ int registered_abms = lua_gettop(L);
+
+ // Get minetest.registered_abms[m_id]
+ lua_pushnumber(L, m_id);
+ lua_gettable(L, registered_abms);
+ if(lua_isnil(L, -1))
+ assert(0);
+
+ // Call action
+ luaL_checktype(L, -1, LUA_TTABLE);
+ lua_getfield(L, -1, "action");
+ luaL_checktype(L, -1, LUA_TFUNCTION);
+ push_v3s16(L, p);
+ pushnode(L, n, env->getGameDef()->ndef());
+ lua_pushnumber(L, active_object_count);
+ lua_pushnumber(L, active_object_count_wider);
+ if(lua_pcall(L, 4, 0, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
+}
+
+// Exported functions
+
+// minetest.set_node(pos, node)
+// pos = {x=num, y=num, z=num}
+int ModApiEnvMod::l_set_node(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ INodeDefManager *ndef = env->getGameDef()->ndef();
+ // parameters
+ v3s16 pos = read_v3s16(L, 1);
+ MapNode n = readnode(L, 2, ndef);
+ // Do it
+ bool succeeded = env->setNode(pos, n);
+ lua_pushboolean(L, succeeded);
+ return 1;
+}
+
+int ModApiEnvMod::l_add_node(lua_State *L)
+{
+ return l_set_node(L);
+}
+
+// minetest.remove_node(pos)
+// pos = {x=num, y=num, z=num}
+int ModApiEnvMod::l_remove_node(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ // parameters
+ v3s16 pos = read_v3s16(L, 1);
+ // Do it
+ bool succeeded = env->removeNode(pos);
+ lua_pushboolean(L, succeeded);
+ return 1;
+}
+
+// minetest.get_node(pos)
+// pos = {x=num, y=num, z=num}
+int ModApiEnvMod::l_get_node(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ // pos
+ v3s16 pos = read_v3s16(L, 1);
+ // Do it
+ MapNode n = env->getMap().getNodeNoEx(pos);
+ // Return node
+ pushnode(L, n, env->getGameDef()->ndef());
+ return 1;
+}
+
+// minetest.get_node_or_nil(pos)
+// pos = {x=num, y=num, z=num}
+int ModApiEnvMod::l_get_node_or_nil(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ // pos
+ v3s16 pos = read_v3s16(L, 1);
+ // Do it
+ try{
+ MapNode n = env->getMap().getNode(pos);
+ // Return node
+ pushnode(L, n, env->getGameDef()->ndef());
+ return 1;
+ } catch(InvalidPositionException &e)
+ {
+ lua_pushnil(L);
+ return 1;
+ }
+}
+
+// minetest.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)
+{
+ GET_ENV_PTR;
+
+ // Do it
+ v3s16 pos = read_v3s16(L, 1);
+ u32 time_of_day = env->getTimeOfDay();
+ if(lua_isnumber(L, 2))
+ time_of_day = 24000.0 * lua_tonumber(L, 2);
+ time_of_day %= 24000;
+ u32 dnr = time_to_daynight_ratio(time_of_day, true);
+ try{
+ MapNode n = env->getMap().getNode(pos);
+ INodeDefManager *ndef = env->getGameDef()->ndef();
+ lua_pushinteger(L, n.getLightBlend(dnr, ndef));
+ return 1;
+ } catch(InvalidPositionException &e)
+ {
+ lua_pushnil(L);
+ return 1;
+ }
+}
+
+// minetest.place_node(pos, node)
+// pos = {x=num, y=num, z=num}
+int ModApiEnvMod::l_place_node(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ v3s16 pos = read_v3s16(L, 1);
+ MapNode n = readnode(L, 2, env->getGameDef()->ndef());
+
+ // Don't attempt to load non-loaded area as of now
+ MapNode n_old = env->getMap().getNodeNoEx(pos);
+ if(n_old.getContent() == CONTENT_IGNORE){
+ lua_pushboolean(L, false);
+ return 1;
+ }
+ // Create item to place
+ INodeDefManager *ndef = getServer(L)->ndef();
+ IItemDefManager *idef = getServer(L)->idef();
+ ItemStack item(ndef->get(n).name, 1, 0, "", idef);
+ // Make pointed position
+ PointedThing pointed;
+ pointed.type = POINTEDTHING_NODE;
+ pointed.node_abovesurface = pos;
+ pointed.node_undersurface = pos + v3s16(0,-1,0);
+ // Place it with a NULL placer (appears in Lua as a non-functional
+ // ObjectRef)
+ bool success = get_scriptapi(L)->item_OnPlace(item, NULL, pointed);
+ lua_pushboolean(L, success);
+ return 1;
+}
+
+// minetest.dig_node(pos)
+// pos = {x=num, y=num, z=num}
+int ModApiEnvMod::l_dig_node(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ v3s16 pos = read_v3s16(L, 1);
+
+ // Don't attempt to load non-loaded area as of now
+ MapNode n = env->getMap().getNodeNoEx(pos);
+ if(n.getContent() == CONTENT_IGNORE){
+ lua_pushboolean(L, false);
+ return 1;
+ }
+ // Dig it out with a NULL digger (appears in Lua as a
+ // non-functional ObjectRef)
+ bool success = get_scriptapi(L)->node_on_dig(pos, n, NULL);
+ lua_pushboolean(L, success);
+ return 1;
+}
+
+// minetest.punch_node(pos)
+// pos = {x=num, y=num, z=num}
+int ModApiEnvMod::l_punch_node(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ v3s16 pos = read_v3s16(L, 1);
+
+ // Don't attempt to load non-loaded area as of now
+ MapNode n = env->getMap().getNodeNoEx(pos);
+ if(n.getContent() == CONTENT_IGNORE){
+ lua_pushboolean(L, false);
+ return 1;
+ }
+ // Punch it with a NULL puncher (appears in Lua as a non-functional
+ // ObjectRef)
+ bool success = get_scriptapi(L)->node_on_punch(pos, n, NULL);
+ lua_pushboolean(L, success);
+ return 1;
+}
+
+// minetest.get_meta(pos)
+int ModApiEnvMod::l_get_meta(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ // Do it
+ v3s16 p = read_v3s16(L, 1);
+ NodeMetaRef::create(L, p, env);
+ return 1;
+}
+
+// minetest.get_node_timer(pos)
+int ModApiEnvMod::l_get_node_timer(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ // Do it
+ v3s16 p = read_v3s16(L, 1);
+ NodeTimerRef::create(L, p, env);
+ return 1;
+}
+
+// minetest.add_entity(pos, entityname) -> ObjectRef or nil
+// pos = {x=num, y=num, z=num}
+int ModApiEnvMod::l_add_entity(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ // pos
+ v3f pos = checkFloatPos(L, 1);
+ // content
+ const char *name = luaL_checkstring(L, 2);
+ // Do it
+ ServerActiveObject *obj = new LuaEntitySAO(env, pos, name, "");
+ int objectid = env->addActiveObject(obj);
+ // If failed to add, return nothing (reads as nil)
+ if(objectid == 0)
+ return 0;
+ // Return ObjectRef
+ get_scriptapi(L)->objectrefGetOrCreate(obj);
+ return 1;
+}
+
+// minetest.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)
+{
+ GET_ENV_PTR;
+
+ // pos
+ //v3f pos = checkFloatPos(L, 1);
+ // item
+ ItemStack item = read_item(L, 2,getServer(L));
+ if(item.empty() || !item.isKnown(getServer(L)->idef()))
+ return 0;
+ // Use minetest.spawn_item to spawn a __builtin:item
+ lua_getglobal(L, "minetest");
+ lua_getfield(L, -1, "spawn_item");
+ if(lua_isnil(L, -1))
+ return 0;
+ lua_pushvalue(L, 1);
+ lua_pushstring(L, item.getItemString().c_str());
+ if(lua_pcall(L, 2, 1, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
+ return 1;
+ /*lua_pushvalue(L, 1);
+ lua_pushstring(L, "__builtin:item");
+ lua_pushstring(L, item.getItemString().c_str());
+ return l_add_entity(L);*/
+ /*// Do it
+ ServerActiveObject *obj = createItemSAO(env, pos, item.getItemString());
+ int objectid = env->addActiveObject(obj);
+ // If failed to add, return nothing (reads as nil)
+ if(objectid == 0)
+ return 0;
+ // Return ObjectRef
+ objectrefGetOrCreate(L, obj);
+ return 1;*/
+}
+
+// minetest.get_player_by_name(name)
+int ModApiEnvMod::l_get_player_by_name(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ // Do it
+ const char *name = luaL_checkstring(L, 1);
+ Player *player = env->getPlayer(name);
+ if(player == NULL){
+ lua_pushnil(L);
+ return 1;
+ }
+ PlayerSAO *sao = player->getPlayerSAO();
+ if(sao == NULL){
+ lua_pushnil(L);
+ return 1;
+ }
+ // Put player on stack
+ get_scriptapi(L)->objectrefGetOrCreate(sao);
+ return 1;
+}
+
+// minetest.get_objects_inside_radius(pos, radius)
+int ModApiEnvMod::l_get_objects_inside_radius(lua_State *L)
+{
+ // Get the table insert function
+ lua_getglobal(L, "table");
+ lua_getfield(L, -1, "insert");
+ int table_insert = lua_gettop(L);
+
+ GET_ENV_PTR;
+
+ // Do it
+ v3f pos = checkFloatPos(L, 1);
+ float radius = luaL_checknumber(L, 2) * BS;
+ std::set<u16> ids = env->getObjectsInsideRadius(pos, radius);
+ lua_newtable(L);
+ int table = lua_gettop(L);
+ for(std::set<u16>::const_iterator
+ i = ids.begin(); i != ids.end(); i++){
+ ServerActiveObject *obj = env->getActiveObject(*i);
+ // Insert object reference into table
+ lua_pushvalue(L, table_insert);
+ lua_pushvalue(L, table);
+ get_scriptapi(L)->objectrefGetOrCreate(obj);
+ if(lua_pcall(L, 2, 0, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
+ }
+ return 1;
+}
+
+// minetest.set_timeofday(val)
+// val = 0...1
+int ModApiEnvMod::l_set_timeofday(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ // Do it
+ float timeofday_f = luaL_checknumber(L, 1);
+ assert(timeofday_f >= 0.0 && timeofday_f <= 1.0);
+ int timeofday_mh = (int)(timeofday_f * 24000.0);
+ // This should be set directly in the environment but currently
+ // such changes aren't immediately sent to the clients, so call
+ // the server instead.
+ //env->setTimeOfDay(timeofday_mh);
+ getServer(L)->setTimeOfDay(timeofday_mh);
+ return 0;
+}
+
+// minetest.get_timeofday() -> 0...1
+int ModApiEnvMod::l_get_timeofday(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ // Do it
+ int timeofday_mh = env->getTimeOfDay();
+ float timeofday_f = (float)timeofday_mh / 24000.0;
+ lua_pushnumber(L, timeofday_f);
+ return 1;
+}
+
+
+// minetest.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)
+{
+ GET_ENV_PTR;
+
+ INodeDefManager *ndef = getServer(L)->ndef();
+ v3s16 pos = read_v3s16(L, 1);
+ int radius = luaL_checkinteger(L, 2);
+ std::set<content_t> filter;
+ if(lua_istable(L, 3)){
+ int table = 3;
+ lua_pushnil(L);
+ while(lua_next(L, table) != 0){
+ // key at index -2 and value at index -1
+ luaL_checktype(L, -1, LUA_TSTRING);
+ ndef->getIds(lua_tostring(L, -1), filter);
+ // removes value, keeps key for next iteration
+ lua_pop(L, 1);
+ }
+ } else if(lua_isstring(L, 3)){
+ ndef->getIds(lua_tostring(L, 3), filter);
+ }
+
+ for(int d=1; d<=radius; d++){
+ std::list<v3s16> list;
+ getFacePositions(list, d);
+ for(std::list<v3s16>::iterator i = list.begin();
+ i != list.end(); ++i){
+ v3s16 p = pos + (*i);
+ content_t c = env->getMap().getNodeNoEx(p).getContent();
+ if(filter.count(c) != 0){
+ push_v3s16(L, p);
+ return 1;
+ }
+ }
+ }
+ return 0;
+}
+
+// minetest.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)
+{
+ GET_ENV_PTR;
+
+ INodeDefManager *ndef = getServer(L)->ndef();
+ v3s16 minp = read_v3s16(L, 1);
+ v3s16 maxp = read_v3s16(L, 2);
+ std::set<content_t> filter;
+ if(lua_istable(L, 3)){
+ int table = 3;
+ lua_pushnil(L);
+ while(lua_next(L, table) != 0){
+ // key at index -2 and value at index -1
+ luaL_checktype(L, -1, LUA_TSTRING);
+ ndef->getIds(lua_tostring(L, -1), filter);
+ // removes value, keeps key for next iteration
+ lua_pop(L, 1);
+ }
+ } else if(lua_isstring(L, 3)){
+ ndef->getIds(lua_tostring(L, 3), filter);
+ }
+
+ // Get the table insert function
+ lua_getglobal(L, "table");
+ lua_getfield(L, -1, "insert");
+ int table_insert = lua_gettop(L);
+
+ lua_newtable(L);
+ int table = lua_gettop(L);
+ for(s16 x=minp.X; x<=maxp.X; x++)
+ for(s16 y=minp.Y; y<=maxp.Y; y++)
+ for(s16 z=minp.Z; z<=maxp.Z; z++)
+ {
+ v3s16 p(x,y,z);
+ content_t c = env->getMap().getNodeNoEx(p).getContent();
+ if(filter.count(c) != 0){
+ lua_pushvalue(L, table_insert);
+ lua_pushvalue(L, table);
+ push_v3s16(L, p);
+ if(lua_pcall(L, 2, 0, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
+ }
+ }
+ return 1;
+}
+
+// minetest.get_perlin(seeddiff, octaves, persistence, scale)
+// returns world-specific PerlinNoise
+int ModApiEnvMod::l_get_perlin(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ int seeddiff = luaL_checkint(L, 1);
+ int octaves = luaL_checkint(L, 2);
+ float persistence = luaL_checknumber(L, 3);
+ float scale = luaL_checknumber(L, 4);
+
+ LuaPerlinNoise *n = new LuaPerlinNoise(seeddiff + int(env->getServerMap().getSeed()), octaves, persistence, scale);
+ *(void **)(lua_newuserdata(L, sizeof(void *))) = n;
+ luaL_getmetatable(L, "PerlinNoise");
+ lua_setmetatable(L, -2);
+ return 1;
+}
+
+// minetest.get_perlin_map(noiseparams, size)
+// returns world-specific PerlinNoiseMap
+int ModApiEnvMod::l_get_perlin_map(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ NoiseParams *np = read_noiseparams(L, 1);
+ if (!np)
+ return 0;
+ v3s16 size = read_v3s16(L, 2);
+
+ int seed = (int)(env->getServerMap().getSeed());
+ LuaPerlinNoiseMap *n = new LuaPerlinNoiseMap(np, seed, size);
+ *(void **)(lua_newuserdata(L, sizeof(void *))) = n;
+ luaL_getmetatable(L, "PerlinNoiseMap");
+ lua_setmetatable(L, -2);
+ return 1;
+}
+
+// minetest.clear_objects()
+// clear all objects in the environment
+int ModApiEnvMod::l_clear_objects(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ env->clearAllObjects();
+ return 0;
+}
+
+// minetest.line_of_sight(pos1, pos2, stepsize) -> true/false
+int ModApiEnvMod::l_line_of_sight(lua_State *L) {
+ float stepsize = 1.0;
+
+ GET_ENV_PTR;
+
+ // read position 1 from lua
+ v3f pos1 = checkFloatPos(L, 2);
+ // read position 2 from lua
+ v3f pos2 = checkFloatPos(L, 2);
+ //read step size from lua
+ if(lua_isnumber(L, 3))
+ stepsize = lua_tonumber(L, 3);
+
+ return (env->line_of_sight(pos1,pos2,stepsize));
+}
+
+// minetest.find_path(pos1, pos2, searchdistance,
+// max_jump, max_drop, algorithm) -> table containing path
+int ModApiEnvMod::l_find_path(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ v3s16 pos1 = read_v3s16(L, 2);
+ v3s16 pos2 = read_v3s16(L, 3);
+ unsigned int searchdistance = luaL_checkint(L, 4);
+ unsigned int max_jump = luaL_checkint(L, 5);
+ unsigned int max_drop = luaL_checkint(L, 6);
+ algorithm algo = A_PLAIN_NP;
+ if(! lua_isnil(L, 7)) {
+ std::string algorithm = luaL_checkstring(L,7);
+
+ if (algorithm == "A*")
+ algo = A_PLAIN;
+
+ if (algorithm == "Dijkstra")
+ algo = DIJKSTRA;
+ }
+
+ std::vector<v3s16> path =
+ get_Path(env,pos1,pos2,searchdistance,max_jump,max_drop,algo);
+
+ if (path.size() > 0)
+ {
+ lua_newtable(L);
+ int top = lua_gettop(L);
+ unsigned int index = 1;
+ for (std::vector<v3s16>::iterator i = path.begin(); i != path.end();i++)
+ {
+ lua_pushnumber(L,index);
+ push_v3s16(L, *i);
+ lua_settable(L, top);
+ index++;
+ }
+ return 1;
+ }
+
+ return 0;
+}
+
+// minetest.spawn_tree(pos, treedef)
+int ModApiEnvMod::l_spawn_tree(lua_State *L)
+{
+ GET_ENV_PTR;
+
+ v3s16 p0 = read_v3s16(L, 1);
+
+ treegen::TreeDef tree_def;
+ std::string trunk,leaves,fruit;
+ INodeDefManager *ndef = env->getGameDef()->ndef();
+
+ if(lua_istable(L, 2))
+ {
+ getstringfield(L, 2, "axiom", tree_def.initial_axiom);
+ getstringfield(L, 2, "rules_a", tree_def.rules_a);
+ getstringfield(L, 2, "rules_b", tree_def.rules_b);
+ getstringfield(L, 2, "rules_c", tree_def.rules_c);
+ getstringfield(L, 2, "rules_d", tree_def.rules_d);
+ getstringfield(L, 2, "trunk", trunk);
+ tree_def.trunknode=ndef->getId(trunk);
+ getstringfield(L, 2, "leaves", leaves);
+ tree_def.leavesnode=ndef->getId(leaves);
+ tree_def.leaves2_chance=0;
+ getstringfield(L, 2, "leaves2", leaves);
+ if (leaves !="")
+ {
+ tree_def.leaves2node=ndef->getId(leaves);
+ getintfield(L, 2, "leaves2_chance", tree_def.leaves2_chance);
+ }
+ getintfield(L, 2, "angle", tree_def.angle);
+ getintfield(L, 2, "iterations", tree_def.iterations);
+ getintfield(L, 2, "random_level", tree_def.iterations_random_level);
+ getstringfield(L, 2, "trunk_type", tree_def.trunk_type);
+ getboolfield(L, 2, "thin_branches", tree_def.thin_branches);
+ tree_def.fruit_chance=0;
+ getstringfield(L, 2, "fruit", fruit);
+ if (fruit != "")
+ {
+ tree_def.fruitnode=ndef->getId(fruit);
+ getintfield(L, 2, "fruit_chance",tree_def.fruit_chance);
+ }
+ getintfield(L, 2, "seed", tree_def.seed);
+ }
+ else
+ return 0;
+ treegen::spawn_ltree (env, p0, ndef, tree_def);
+ return 1;
+}
+
+bool ModApiEnvMod::Initialize(lua_State *L,int top)
+{
+
+ bool retval = true;
+
+ retval &= API_FCT(set_node);
+ retval &= API_FCT(add_node);
+ retval &= API_FCT(add_item);
+ retval &= API_FCT(remove_node);
+ retval &= API_FCT(get_node);
+ retval &= API_FCT(get_node_or_nil);
+ retval &= API_FCT(get_node_light);
+ retval &= API_FCT(place_node);
+ retval &= API_FCT(dig_node);
+ retval &= API_FCT(punch_node);
+ retval &= API_FCT(add_entity);
+ retval &= API_FCT(get_meta);
+ retval &= API_FCT(get_node_timer);
+ retval &= API_FCT(get_player_by_name);
+ retval &= API_FCT(get_objects_inside_radius);
+ retval &= API_FCT(set_timeofday);
+ retval &= API_FCT(get_timeofday);
+ retval &= API_FCT(find_node_near);
+ retval &= API_FCT(find_nodes_in_area);
+ retval &= API_FCT(get_perlin);
+ retval &= API_FCT(get_perlin_map);
+ retval &= API_FCT(clear_objects);
+ retval &= API_FCT(spawn_tree);
+
+ return retval;
+}
+
+ModApiEnvMod modapienv_prototype;
diff --git a/src/script/lua_api/l_env.h b/src/script/lua_api/l_env.h
new file mode 100644
index 000000000..61ecaecc8
--- /dev/null
+++ b/src/script/lua_api/l_env.h
@@ -0,0 +1,172 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef L_ENV_H_
+#define L_ENV_H_
+
+extern "C" {
+#include <lua.h>
+#include <lauxlib.h>
+}
+
+#include "environment.h"
+#include "lua_api/l_base.h"
+
+class ModApiEnvMod
+ :public ModApiBase
+{
+private:
+ // minetest.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)
+ // pos = {x=num, y=num, z=num}
+ static int l_remove_node(lua_State *L);
+
+ // minetest.get_node(pos)
+ // pos = {x=num, y=num, z=num}
+ static int l_get_node(lua_State *L);
+
+ // minetest.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)
+ // 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)
+ // pos = {x=num, y=num, z=num}
+ static int l_place_node(lua_State *L);
+
+ // minetest.dig_node(pos)
+ // pos = {x=num, y=num, z=num}
+ static int l_dig_node(lua_State *L);
+
+ // minetest.punch_node(pos)
+ // pos = {x=num, y=num, z=num}
+ static int l_punch_node(lua_State *L);
+
+ // minetest.get_meta(pos)
+ static int l_get_meta(lua_State *L);
+
+ // minetest.get_node_timer(pos)
+ static int l_get_node_timer(lua_State *L);
+
+ // minetest.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
+ // pos = {x=num, y=num, z=num}
+ static int l_add_item(lua_State *L);
+
+ // minetest.get_player_by_name(name)
+ static int l_get_player_by_name(lua_State *L);
+
+ // minetest.get_objects_inside_radius(pos, radius)
+ static int l_get_objects_inside_radius(lua_State *L);
+
+ // minetest.set_timeofday(val)
+ // val = 0...1
+ static int l_set_timeofday(lua_State *L);
+
+ // minetest.get_timeofday() -> 0...1
+ static int l_get_timeofday(lua_State *L);
+
+ // minetest.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
+ // 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)
+ // returns world-specific PerlinNoise
+ static int l_get_perlin(lua_State *L);
+
+ // minetest.get_perlin_map(noiseparams, size)
+ // returns world-specific PerlinNoiseMap
+ static int l_get_perlin_map(lua_State *L);
+
+ // minetest.clear_objects()
+ // clear all objects in the environment
+ static int l_clear_objects(lua_State *L);
+
+ // minetest.spawn_tree(pos, treedef)
+ static int l_spawn_tree(lua_State *L);
+
+ // minetest.line_of_sight(pos1, pos2, stepsize) -> true/false
+ static int l_line_of_sight(lua_State *L);
+
+ // minetest.find_path(pos1, pos2, searchdistance,
+ // max_jump, max_drop, algorithm) -> table containing path
+ static int l_find_path(lua_State *L);
+
+public:
+ bool Initialize(lua_State *L, int top);
+};
+
+class LuaABM : public ActiveBlockModifier
+{
+private:
+ int m_id;
+
+ std::set<std::string> m_trigger_contents;
+ std::set<std::string> m_required_neighbors;
+ float m_trigger_interval;
+ u32 m_trigger_chance;
+public:
+ LuaABM(lua_State *L, int id,
+ const std::set<std::string> &trigger_contents,
+ const std::set<std::string> &required_neighbors,
+ float trigger_interval, u32 trigger_chance):
+ m_id(id),
+ m_trigger_contents(trigger_contents),
+ m_required_neighbors(required_neighbors),
+ m_trigger_interval(trigger_interval),
+ m_trigger_chance(trigger_chance)
+ {
+ }
+ virtual std::set<std::string> getTriggerContents()
+ {
+ return m_trigger_contents;
+ }
+ virtual std::set<std::string> getRequiredNeighbors()
+ {
+ return m_required_neighbors;
+ }
+ virtual float getTriggerInterval()
+ {
+ return m_trigger_interval;
+ }
+ virtual u32 getTriggerChance()
+ {
+ return m_trigger_chance;
+ }
+ virtual void trigger(ServerEnvironment *env, v3s16 p, MapNode n,
+ u32 active_object_count, u32 active_object_count_wider);
+};
+
+#endif /* L_ENV_H_ */
diff --git a/src/script/lua_api/l_inventory.cpp b/src/script/lua_api/l_inventory.cpp
new file mode 100644
index 000000000..1404c3c8a
--- /dev/null
+++ b/src/script/lua_api/l_inventory.cpp
@@ -0,0 +1,479 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "cpp_api/scriptapi.h"
+#include "common/c_converter.h"
+#include "common/c_content.h"
+#include "lua_api/l_inventory.h"
+#include "lua_api/l_item.h"
+#include "common/c_internal.h"
+#include "server.h"
+#include "log.h"
+#include "inventorymanager.h"
+
+/*
+ InvRef
+*/
+InvRef* InvRef::checkobject(lua_State *L, int narg)
+{
+ luaL_checktype(L, narg, LUA_TUSERDATA);
+ void *ud = luaL_checkudata(L, narg, className);
+ if(!ud) luaL_typerror(L, narg, className);
+ return *(InvRef**)ud; // unbox pointer
+}
+
+Inventory* InvRef::getinv(lua_State *L, InvRef *ref)
+{
+ return STACK_TO_SERVER(L)->getInventory(ref->m_loc);
+}
+
+InventoryList* InvRef::getlist(lua_State *L, InvRef *ref,
+ const char *listname)
+{
+ NO_MAP_LOCK_REQUIRED;
+ Inventory *inv = getinv(L, ref);
+ if(!inv)
+ return NULL;
+ return inv->getList(listname);
+}
+
+void InvRef::reportInventoryChange(lua_State *L, InvRef *ref)
+{
+ // Inform other things that the inventory has changed
+ STACK_TO_SERVER(L)->setInventoryModified(ref->m_loc);
+}
+
+// Exported functions
+
+// garbage collector
+int InvRef::gc_object(lua_State *L) {
+ InvRef *o = *(InvRef **)(lua_touserdata(L, 1));
+ delete o;
+ return 0;
+}
+
+// is_empty(self, listname) -> true/false
+int InvRef::l_is_empty(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ InvRef *ref = checkobject(L, 1);
+ const char *listname = luaL_checkstring(L, 2);
+ InventoryList *list = getlist(L, ref, listname);
+ if(list && list->getUsedSlots() > 0){
+ lua_pushboolean(L, false);
+ } else {
+ lua_pushboolean(L, true);
+ }
+ return 1;
+}
+
+// get_size(self, listname)
+int InvRef::l_get_size(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ InvRef *ref = checkobject(L, 1);
+ const char *listname = luaL_checkstring(L, 2);
+ InventoryList *list = getlist(L, ref, listname);
+ if(list){
+ lua_pushinteger(L, list->getSize());
+ } else {
+ lua_pushinteger(L, 0);
+ }
+ return 1;
+}
+
+// get_width(self, listname)
+int InvRef::l_get_width(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ InvRef *ref = checkobject(L, 1);
+ const char *listname = luaL_checkstring(L, 2);
+ InventoryList *list = getlist(L, ref, listname);
+ if(list){
+ lua_pushinteger(L, list->getWidth());
+ } else {
+ lua_pushinteger(L, 0);
+ }
+ return 1;
+}
+
+// set_size(self, listname, size)
+int InvRef::l_set_size(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ InvRef *ref = checkobject(L, 1);
+ const char *listname = luaL_checkstring(L, 2);
+ int newsize = luaL_checknumber(L, 3);
+ Inventory *inv = getinv(L, ref);
+ if(newsize == 0){
+ inv->deleteList(listname);
+ reportInventoryChange(L, ref);
+ return 0;
+ }
+ InventoryList *list = inv->getList(listname);
+ if(list){
+ list->setSize(newsize);
+ } else {
+ list = inv->addList(listname, newsize);
+ }
+ reportInventoryChange(L, ref);
+ return 0;
+}
+
+// set_width(self, listname, size)
+int InvRef::l_set_width(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ InvRef *ref = checkobject(L, 1);
+ const char *listname = luaL_checkstring(L, 2);
+ int newwidth = luaL_checknumber(L, 3);
+ Inventory *inv = getinv(L, ref);
+ InventoryList *list = inv->getList(listname);
+ if(list){
+ list->setWidth(newwidth);
+ } else {
+ return 0;
+ }
+ reportInventoryChange(L, ref);
+ return 0;
+}
+
+// get_stack(self, listname, i) -> itemstack
+int InvRef::l_get_stack(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ InvRef *ref = checkobject(L, 1);
+ const char *listname = luaL_checkstring(L, 2);
+ int i = luaL_checknumber(L, 3) - 1;
+ InventoryList *list = getlist(L, ref, listname);
+ ItemStack item;
+ if(list != NULL && i >= 0 && i < (int) list->getSize())
+ item = list->getItem(i);
+ LuaItemStack::create(L, item);
+ return 1;
+}
+
+// set_stack(self, listname, i, stack) -> true/false
+int InvRef::l_set_stack(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ InvRef *ref = checkobject(L, 1);
+ const char *listname = luaL_checkstring(L, 2);
+ int i = luaL_checknumber(L, 3) - 1;
+ ItemStack newitem = read_item(L, 4,STACK_TO_SERVER(L));
+ InventoryList *list = getlist(L, ref, listname);
+ if(list != NULL && i >= 0 && i < (int) list->getSize()){
+ list->changeItem(i, newitem);
+ reportInventoryChange(L, ref);
+ lua_pushboolean(L, true);
+ } else {
+ lua_pushboolean(L, false);
+ }
+ return 1;
+}
+
+// get_list(self, listname) -> list or nil
+int InvRef::l_get_list(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ InvRef *ref = checkobject(L, 1);
+ const char *listname = luaL_checkstring(L, 2);
+ Inventory *inv = getinv(L, ref);
+ push_inventory_list(inv, listname, L);
+ return 1;
+}
+
+// set_list(self, listname, list)
+int InvRef::l_set_list(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ InvRef *ref = checkobject(L, 1);
+ const char *listname = luaL_checkstring(L, 2);
+ Inventory *inv = getinv(L, ref);
+ InventoryList *list = inv->getList(listname);
+ if(list)
+ read_inventory_list(inv, listname, L, 3,
+ STACK_TO_SERVER(L),list->getSize());
+ else
+ read_inventory_list(inv, listname, L, 3,STACK_TO_SERVER(L));
+ reportInventoryChange(L, ref);
+ return 0;
+}
+
+// add_item(self, listname, itemstack or itemstring or table or nil) -> itemstack
+// Returns the leftover stack
+int InvRef::l_add_item(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ InvRef *ref = checkobject(L, 1);
+ const char *listname = luaL_checkstring(L, 2);
+ ItemStack item = read_item(L, 3,STACK_TO_SERVER(L));
+ InventoryList *list = getlist(L, ref, listname);
+ if(list){
+ ItemStack leftover = list->addItem(item);
+ if(leftover.count != item.count)
+ reportInventoryChange(L, ref);
+ LuaItemStack::create(L, leftover);
+ } else {
+ LuaItemStack::create(L, item);
+ }
+ return 1;
+}
+
+// room_for_item(self, listname, itemstack or itemstring or table or nil) -> true/false
+// Returns true if the item completely fits into the list
+int InvRef::l_room_for_item(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ InvRef *ref = checkobject(L, 1);
+ const char *listname = luaL_checkstring(L, 2);
+ ItemStack item = read_item(L, 3,STACK_TO_SERVER(L));
+ InventoryList *list = getlist(L, ref, listname);
+ if(list){
+ lua_pushboolean(L, list->roomForItem(item));
+ } else {
+ lua_pushboolean(L, false);
+ }
+ return 1;
+}
+
+// contains_item(self, listname, itemstack or itemstring or table or nil) -> true/false
+// Returns true if the list contains the given count of the given item name
+int InvRef::l_contains_item(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ InvRef *ref = checkobject(L, 1);
+ const char *listname = luaL_checkstring(L, 2);
+ ItemStack item = read_item(L, 3, STACK_TO_SERVER(L));
+ InventoryList *list = getlist(L, ref, listname);
+ if(list){
+ lua_pushboolean(L, list->containsItem(item));
+ } else {
+ lua_pushboolean(L, false);
+ }
+ return 1;
+}
+
+// remove_item(self, listname, itemstack or itemstring or table or nil) -> itemstack
+// Returns the items that were actually removed
+int InvRef::l_remove_item(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ InvRef *ref = checkobject(L, 1);
+ const char *listname = luaL_checkstring(L, 2);
+ ItemStack item = read_item(L, 3,STACK_TO_SERVER(L));
+ InventoryList *list = getlist(L, ref, listname);
+ if(list){
+ ItemStack removed = list->removeItem(item);
+ if(!removed.empty())
+ reportInventoryChange(L, ref);
+ LuaItemStack::create(L, removed);
+ } else {
+ LuaItemStack::create(L, ItemStack());
+ }
+ return 1;
+}
+
+// get_location() -> location (like minetest.get_inventory(location))
+int InvRef::l_get_location(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ InvRef *ref = checkobject(L, 1);
+ const InventoryLocation &loc = ref->m_loc;
+ switch(loc.type){
+ case InventoryLocation::PLAYER:
+ lua_newtable(L);
+ lua_pushstring(L, "player");
+ lua_setfield(L, -2, "type");
+ lua_pushstring(L, loc.name.c_str());
+ lua_setfield(L, -2, "name");
+ return 1;
+ case InventoryLocation::NODEMETA:
+ lua_newtable(L);
+ lua_pushstring(L, "node");
+ lua_setfield(L, -2, "type");
+ push_v3s16(L, loc.p);
+ lua_setfield(L, -2, "pos");
+ return 1;
+ case InventoryLocation::DETACHED:
+ lua_newtable(L);
+ lua_pushstring(L, "detached");
+ lua_setfield(L, -2, "type");
+ lua_pushstring(L, loc.name.c_str());
+ lua_setfield(L, -2, "name");
+ return 1;
+ case InventoryLocation::UNDEFINED:
+ case InventoryLocation::CURRENT_PLAYER:
+ break;
+ }
+ lua_newtable(L);
+ lua_pushstring(L, "undefined");
+ lua_setfield(L, -2, "type");
+ return 1;
+}
+
+
+InvRef::InvRef(const InventoryLocation &loc):
+ m_loc(loc)
+{
+}
+
+InvRef::~InvRef()
+{
+}
+
+// Creates an InvRef and leaves it on top of stack
+// Not callable from Lua; all references are created on the C side.
+void InvRef::create(lua_State *L, const InventoryLocation &loc)
+{
+ NO_MAP_LOCK_REQUIRED;
+ InvRef *o = new InvRef(loc);
+ *(void **)(lua_newuserdata(L, sizeof(void *))) = o;
+ luaL_getmetatable(L, className);
+ lua_setmetatable(L, -2);
+}
+void InvRef::createPlayer(lua_State *L, Player *player)
+{
+ NO_MAP_LOCK_REQUIRED;
+ InventoryLocation loc;
+ loc.setPlayer(player->getName());
+ create(L, loc);
+}
+void InvRef::createNodeMeta(lua_State *L, v3s16 p)
+{
+ InventoryLocation loc;
+ loc.setNodeMeta(p);
+ create(L, loc);
+}
+
+void InvRef::Register(lua_State *L)
+{
+ lua_newtable(L);
+ int methodtable = lua_gettop(L);
+ luaL_newmetatable(L, className);
+ int metatable = lua_gettop(L);
+
+ lua_pushliteral(L, "__metatable");
+ lua_pushvalue(L, methodtable);
+ lua_settable(L, metatable); // hide metatable from Lua getmetatable()
+
+ lua_pushliteral(L, "__index");
+ lua_pushvalue(L, methodtable);
+ lua_settable(L, metatable);
+
+ lua_pushliteral(L, "__gc");
+ lua_pushcfunction(L, gc_object);
+ lua_settable(L, metatable);
+
+ lua_pop(L, 1); // drop metatable
+
+ luaL_openlib(L, 0, methods, 0); // fill methodtable
+ lua_pop(L, 1); // drop methodtable
+
+ // Cannot be created from Lua
+ //lua_register(L, className, create_object);
+}
+
+const char InvRef::className[] = "InvRef";
+const luaL_reg InvRef::methods[] = {
+ luamethod(InvRef, is_empty),
+ luamethod(InvRef, get_size),
+ luamethod(InvRef, set_size),
+ luamethod(InvRef, get_width),
+ luamethod(InvRef, set_width),
+ luamethod(InvRef, get_stack),
+ luamethod(InvRef, set_stack),
+ luamethod(InvRef, get_list),
+ luamethod(InvRef, set_list),
+ luamethod(InvRef, add_item),
+ luamethod(InvRef, room_for_item),
+ luamethod(InvRef, contains_item),
+ luamethod(InvRef, remove_item),
+ luamethod(InvRef, get_location),
+ {0,0}
+};
+
+// get_inventory(location)
+int ModApiInventory::l_get_inventory(lua_State *L)
+{
+ InventoryLocation loc;
+
+ std::string type = checkstringfield(L, 1, "type");
+
+ if(type == "node"){
+ lua_getfield(L, 1, "pos");
+ v3s16 pos = check_v3s16(L, -1);
+ loc.setNodeMeta(pos);
+
+ if(getServer(L)->getInventory(loc) != NULL)
+ InvRef::create(L, loc);
+ else
+ lua_pushnil(L);
+ return 1;
+ } else {
+ NO_MAP_LOCK_REQUIRED;
+ if(type == "player"){
+ std::string name = checkstringfield(L, 1, "name");
+ loc.setPlayer(name);
+ } else if(type == "detached"){
+ std::string name = checkstringfield(L, 1, "name");
+ loc.setDetached(name);
+ }
+
+ if(getServer(L)->getInventory(loc) != NULL)
+ InvRef::create(L, loc);
+ else
+ lua_pushnil(L);
+ return 1;
+ // END NO_MAP_LOCK_REQUIRED;
+ }
+}
+
+// create_detached_inventory_raw(name)
+int ModApiInventory::l_create_detached_inventory_raw(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ const char *name = luaL_checkstring(L, 1);
+ if(getServer(L)->createDetachedInventory(name) != NULL){
+ InventoryLocation loc;
+ loc.setDetached(name);
+ InvRef::create(L, loc);
+ }else{
+ lua_pushnil(L);
+ }
+ return 1;
+}
+
+bool ModApiInventory::Initialize(lua_State *L, int top) {
+ bool retval = true;
+
+ retval &= API_FCT(create_detached_inventory_raw);
+ retval &= API_FCT(get_inventory);
+
+ InvRef::Register(L);
+
+ return retval;
+}
+
+ModApiInventory::ModApiInventory()
+ : ModApiBase() {
+
+}
+
+ModApiInventory modapiinventory_prototype;
diff --git a/src/script/lua_api/l_inventory.h b/src/script/lua_api/l_inventory.h
new file mode 100644
index 000000000..83e8039b8
--- /dev/null
+++ b/src/script/lua_api/l_inventory.h
@@ -0,0 +1,137 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef L_INVENTORY_H_
+#define L_INVENTORY_H_
+
+extern "C" {
+#include <lua.h>
+#include <lauxlib.h>
+}
+
+#include "inventorymanager.h"
+#include "player.h"
+#include "serverobject.h"
+#include "inventory.h"
+
+#include "lua_api/l_base.h"
+/*
+ InvRef
+*/
+
+class InvRef
+{
+private:
+ InventoryLocation m_loc;
+
+ static const char className[];
+ static const luaL_reg methods[];
+
+ static InvRef *checkobject(lua_State *L, int narg);
+
+ static Inventory* getinv(lua_State *L, InvRef *ref);
+
+ static InventoryList* getlist(lua_State *L, InvRef *ref,
+ const char *listname);
+
+ static void reportInventoryChange(lua_State *L, InvRef *ref);
+
+ // Exported functions
+
+ // garbage collector
+ static int gc_object(lua_State *L);
+
+ // is_empty(self, listname) -> true/false
+ static int l_is_empty(lua_State *L);
+
+ // get_size(self, listname)
+ static int l_get_size(lua_State *L);
+
+ // get_width(self, listname)
+ static int l_get_width(lua_State *L);
+
+ // set_size(self, listname, size)
+ static int l_set_size(lua_State *L);
+
+ // set_width(self, listname, size)
+ static int l_set_width(lua_State *L);
+
+ // get_stack(self, listname, i) -> itemstack
+ static int l_get_stack(lua_State *L);
+
+ // set_stack(self, listname, i, stack) -> true/false
+ static int l_set_stack(lua_State *L);
+
+ // get_list(self, listname) -> list or nil
+ static int l_get_list(lua_State *L);
+
+ // set_list(self, listname, list)
+ static int l_set_list(lua_State *L);
+
+ // add_item(self, listname, itemstack or itemstring or table or nil) -> itemstack
+ // Returns the leftover stack
+ static int l_add_item(lua_State *L);
+
+ // room_for_item(self, listname, itemstack or itemstring or table or nil) -> true/false
+ // Returns true if the item completely fits into the list
+ static int l_room_for_item(lua_State *L);
+
+ // contains_item(self, listname, itemstack or itemstring or table or nil) -> true/false
+ // Returns true if the list contains the given count of the given item name
+ static int l_contains_item(lua_State *L);
+
+ // remove_item(self, listname, itemstack or itemstring or table or nil) -> itemstack
+ // Returns the items that were actually removed
+ static int l_remove_item(lua_State *L);
+
+ // get_location() -> location (like minetest.get_inventory(location))
+ static int l_get_location(lua_State *L);
+
+public:
+ InvRef(const InventoryLocation &loc);
+
+ ~InvRef();
+
+ // Creates an InvRef and leaves it on top of stack
+ // Not callable from Lua; all references are created on the C side.
+ static void create(lua_State *L, const InventoryLocation &loc);
+ static void createPlayer(lua_State *L, Player *player);
+ static void createNodeMeta(lua_State *L, v3s16 p);
+ static void Register(lua_State *L);
+};
+
+class ModApiInventory
+ : public ModApiBase
+{
+public:
+ ModApiInventory();
+
+ bool Initialize(lua_State *L, int top);
+
+ static int l_create_detached_inventory_raw(lua_State *L);
+ static int l_get_inventory(lua_State *L);
+private:
+ static void inventory_set_list_from_lua(Inventory *inv, const char *name,
+ lua_State *L, int tableindex, int forcesize);
+ static void inventory_get_list_to_lua(Inventory *inv, const char *name,
+ lua_State *L);
+
+};
+
+#endif /* L_INVENTORY_H_ */
diff --git a/src/script/lua_api/l_item.cpp b/src/script/lua_api/l_item.cpp
new file mode 100644
index 000000000..730dfd49b
--- /dev/null
+++ b/src/script/lua_api/l_item.cpp
@@ -0,0 +1,472 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "lua_api/l_item.h"
+#include "common/c_converter.h"
+#include "common/c_content.h"
+#include "cpp_api/scriptapi.h"
+#include "server.h"
+#include "common/c_internal.h"
+
+// garbage collector
+int LuaItemStack::gc_object(lua_State *L)
+{
+ LuaItemStack *o = *(LuaItemStack **)(lua_touserdata(L, 1));
+ delete o;
+ return 0;
+}
+
+// is_empty(self) -> true/false
+int LuaItemStack::l_is_empty(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ ItemStack &item = o->m_stack;
+ lua_pushboolean(L, item.empty());
+ return 1;
+}
+
+// get_name(self) -> string
+int LuaItemStack::l_get_name(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ ItemStack &item = o->m_stack;
+ lua_pushstring(L, item.name.c_str());
+ return 1;
+}
+
+// get_count(self) -> number
+int LuaItemStack::l_get_count(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ ItemStack &item = o->m_stack;
+ lua_pushinteger(L, item.count);
+ return 1;
+}
+
+// get_wear(self) -> number
+int LuaItemStack::l_get_wear(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ ItemStack &item = o->m_stack;
+ lua_pushinteger(L, item.wear);
+ return 1;
+}
+
+// get_metadata(self) -> string
+int LuaItemStack::l_get_metadata(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ ItemStack &item = o->m_stack;
+ lua_pushlstring(L, item.metadata.c_str(), item.metadata.size());
+ return 1;
+}
+
+// clear(self) -> true
+int LuaItemStack::l_clear(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ o->m_stack.clear();
+ lua_pushboolean(L, true);
+ return 1;
+}
+
+// replace(self, itemstack or itemstring or table or nil) -> true
+int LuaItemStack::l_replace(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ o->m_stack = read_item(L,2,STACK_TO_SERVER(L));
+ lua_pushboolean(L, true);
+ return 1;
+}
+
+// to_string(self) -> string
+int LuaItemStack::l_to_string(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ std::string itemstring = o->m_stack.getItemString();
+ lua_pushstring(L, itemstring.c_str());
+ return 1;
+}
+
+// to_table(self) -> table or nil
+int LuaItemStack::l_to_table(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ const ItemStack &item = o->m_stack;
+ if(item.empty())
+ {
+ lua_pushnil(L);
+ }
+ else
+ {
+ lua_newtable(L);
+ lua_pushstring(L, item.name.c_str());
+ lua_setfield(L, -2, "name");
+ lua_pushinteger(L, item.count);
+ lua_setfield(L, -2, "count");
+ lua_pushinteger(L, item.wear);
+ lua_setfield(L, -2, "wear");
+ lua_pushlstring(L, item.metadata.c_str(), item.metadata.size());
+ lua_setfield(L, -2, "metadata");
+ }
+ return 1;
+}
+
+// get_stack_max(self) -> number
+int LuaItemStack::l_get_stack_max(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ ItemStack &item = o->m_stack;
+ lua_pushinteger(L, item.getStackMax(STACK_TO_SERVER(L)->idef()));
+ return 1;
+}
+
+// get_free_space(self) -> number
+int LuaItemStack::l_get_free_space(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ ItemStack &item = o->m_stack;
+ lua_pushinteger(L, item.freeSpace(STACK_TO_SERVER(L)->idef()));
+ return 1;
+}
+
+// is_known(self) -> true/false
+// Checks if the item is defined.
+int LuaItemStack::l_is_known(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ ItemStack &item = o->m_stack;
+ bool is_known = item.isKnown(STACK_TO_SERVER(L)->idef());
+ lua_pushboolean(L, is_known);
+ return 1;
+}
+
+// get_definition(self) -> table
+// Returns the item definition table from minetest.registered_items,
+// or a fallback one (name="unknown")
+int LuaItemStack::l_get_definition(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ ItemStack &item = o->m_stack;
+
+ // Get minetest.registered_items[name]
+ lua_getglobal(L, "minetest");
+ lua_getfield(L, -1, "registered_items");
+ luaL_checktype(L, -1, LUA_TTABLE);
+ lua_getfield(L, -1, item.name.c_str());
+ if(lua_isnil(L, -1))
+ {
+ lua_pop(L, 1);
+ lua_getfield(L, -1, "unknown");
+ }
+ return 1;
+}
+
+// get_tool_capabilities(self) -> table
+// Returns the effective tool digging properties.
+// Returns those of the hand ("") if this item has none associated.
+int LuaItemStack::l_get_tool_capabilities(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ ItemStack &item = o->m_stack;
+ const ToolCapabilities &prop =
+ item.getToolCapabilities(STACK_TO_SERVER(L)->idef());
+ push_tool_capabilities(L, prop);
+ return 1;
+}
+
+// add_wear(self, amount) -> true/false
+// The range for "amount" is [0,65535]. Wear is only added if the item
+// is a tool. Adding wear might destroy the item.
+// Returns true if the item is (or was) a tool.
+int LuaItemStack::l_add_wear(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ ItemStack &item = o->m_stack;
+ int amount = lua_tointeger(L, 2);
+ bool result = item.addWear(amount, STACK_TO_SERVER(L)->idef());
+ lua_pushboolean(L, result);
+ return 1;
+}
+
+// add_item(self, itemstack or itemstring or table or nil) -> itemstack
+// Returns leftover item stack
+int LuaItemStack::l_add_item(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ ItemStack &item = o->m_stack;
+ ItemStack newitem = read_item(L,-1, STACK_TO_SERVER(L));
+ ItemStack leftover = item.addItem(newitem, STACK_TO_SERVER(L)->idef());
+ create(L, leftover);
+ return 1;
+}
+
+// item_fits(self, itemstack or itemstring or table or nil) -> true/false, itemstack
+// First return value is true iff the new item fits fully into the stack
+// Second return value is the would-be-left-over item stack
+int LuaItemStack::l_item_fits(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ ItemStack &item = o->m_stack;
+ ItemStack newitem = read_item(L, 2 ,STACK_TO_SERVER(L));
+ ItemStack restitem;
+ bool fits = item.itemFits(newitem, &restitem, STACK_TO_SERVER(L)->idef());
+ lua_pushboolean(L, fits); // first return value
+ create(L, restitem); // second return value
+ return 2;
+}
+
+// take_item(self, takecount=1) -> itemstack
+int LuaItemStack::l_take_item(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ ItemStack &item = o->m_stack;
+ u32 takecount = 1;
+ if(!lua_isnone(L, 2))
+ takecount = luaL_checkinteger(L, 2);
+ ItemStack taken = item.takeItem(takecount);
+ create(L, taken);
+ return 1;
+}
+
+// peek_item(self, peekcount=1) -> itemstack
+int LuaItemStack::l_peek_item(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = checkobject(L, 1);
+ ItemStack &item = o->m_stack;
+ u32 peekcount = 1;
+ if(!lua_isnone(L, 2))
+ peekcount = lua_tointeger(L, 2);
+ ItemStack peekaboo = item.peekItem(peekcount);
+ create(L, peekaboo);
+ return 1;
+}
+
+LuaItemStack::LuaItemStack(const ItemStack &item):
+ m_stack(item)
+{
+}
+
+LuaItemStack::~LuaItemStack()
+{
+}
+
+const ItemStack& LuaItemStack::getItem() const
+{
+ return m_stack;
+}
+ItemStack& LuaItemStack::getItem()
+{
+ return m_stack;
+}
+
+// LuaItemStack(itemstack or itemstring or table or nil)
+// Creates an LuaItemStack and leaves it on top of stack
+int LuaItemStack::create_object(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ItemStack item = read_item(L,1,STACK_TO_SERVER(L));
+ LuaItemStack *o = new LuaItemStack(item);
+ *(void **)(lua_newuserdata(L, sizeof(void *))) = o;
+ luaL_getmetatable(L, className);
+ lua_setmetatable(L, -2);
+ return 1;
+}
+// Not callable from Lua
+int LuaItemStack::create(lua_State *L, const ItemStack &item)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaItemStack *o = new LuaItemStack(item);
+ *(void **)(lua_newuserdata(L, sizeof(void *))) = o;
+ luaL_getmetatable(L, className);
+ lua_setmetatable(L, -2);
+ return 1;
+}
+
+LuaItemStack* LuaItemStack::checkobject(lua_State *L, int narg)
+{
+ luaL_checktype(L, narg, LUA_TUSERDATA);
+ void *ud = luaL_checkudata(L, narg, className);
+ if(!ud) luaL_typerror(L, narg, className);
+ return *(LuaItemStack**)ud; // unbox pointer
+}
+
+void LuaItemStack::Register(lua_State *L)
+{
+ lua_newtable(L);
+ int methodtable = lua_gettop(L);
+ luaL_newmetatable(L, className);
+ int metatable = lua_gettop(L);
+
+ lua_pushliteral(L, "__metatable");
+ lua_pushvalue(L, methodtable);
+ lua_settable(L, metatable); // hide metatable from Lua getmetatable()
+
+ lua_pushliteral(L, "__index");
+ lua_pushvalue(L, methodtable);
+ lua_settable(L, metatable);
+
+ lua_pushliteral(L, "__gc");
+ lua_pushcfunction(L, gc_object);
+ lua_settable(L, metatable);
+
+ lua_pop(L, 1); // drop metatable
+
+ luaL_openlib(L, 0, methods, 0); // fill methodtable
+ lua_pop(L, 1); // drop methodtable
+
+ // Can be created from Lua (LuaItemStack(itemstack or itemstring or table or nil))
+ lua_register(L, className, create_object);
+}
+
+const char LuaItemStack::className[] = "ItemStack";
+const luaL_reg LuaItemStack::methods[] = {
+ luamethod(LuaItemStack, is_empty),
+ luamethod(LuaItemStack, get_name),
+ luamethod(LuaItemStack, get_count),
+ luamethod(LuaItemStack, get_wear),
+ luamethod(LuaItemStack, get_metadata),
+ luamethod(LuaItemStack, clear),
+ luamethod(LuaItemStack, replace),
+ luamethod(LuaItemStack, to_string),
+ luamethod(LuaItemStack, to_table),
+ luamethod(LuaItemStack, get_stack_max),
+ luamethod(LuaItemStack, get_free_space),
+ luamethod(LuaItemStack, is_known),
+ luamethod(LuaItemStack, get_definition),
+ luamethod(LuaItemStack, get_tool_capabilities),
+ luamethod(LuaItemStack, add_wear),
+ luamethod(LuaItemStack, add_item),
+ luamethod(LuaItemStack, item_fits),
+ luamethod(LuaItemStack, take_item),
+ luamethod(LuaItemStack, peek_item),
+ {0,0}
+};
+
+ModApiItemMod::ModApiItemMod() {
+}
+
+/*
+ ItemDefinition
+*/
+
+// register_item_raw({lots of stuff})
+int ModApiItemMod::l_register_item_raw(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ luaL_checktype(L, 1, LUA_TTABLE);
+ int table = 1;
+
+ ScriptApi* scriptIface = get_scriptapi(L);
+
+ // Get the writable item and node definition managers from the server
+ IWritableItemDefManager *idef =
+ scriptIface->getServer()->getWritableItemDefManager();
+ IWritableNodeDefManager *ndef =
+ scriptIface->getServer()->getWritableNodeDefManager();
+
+ // Check if name is defined
+ std::string name;
+ lua_getfield(L, table, "name");
+ if(lua_isstring(L, -1)){
+ name = lua_tostring(L, -1);
+ verbosestream<<"register_item_raw: "<<name<<std::endl;
+ } else {
+ throw LuaError(L, "register_item_raw: name is not defined or not a string");
+ }
+
+ // Check if on_use is defined
+
+ ItemDefinition def;
+ // Set a distinctive default value to check if this is set
+ def.node_placement_prediction = "__default";
+
+ // Read the item definition
+ def = read_item_definition(L, table, def);
+
+ // Default to having client-side placement prediction for nodes
+ // ("" in item definition sets it off)
+ if(def.node_placement_prediction == "__default"){
+ if(def.type == ITEM_NODE)
+ def.node_placement_prediction = name;
+ else
+ def.node_placement_prediction = "";
+ }
+
+ // Register item definition
+ idef->registerItem(def);
+
+ // Read the node definition (content features) and register it
+ if(def.type == ITEM_NODE)
+ {
+ ContentFeatures f = read_content_features(L, table);
+ ndef->set(f.name, f);
+ }
+
+ return 0; /* number of results */
+}
+
+// register_alias_raw(name, convert_to_name)
+int ModApiItemMod::l_register_alias_raw(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ std::string name = luaL_checkstring(L, 1);
+ std::string convert_to = luaL_checkstring(L, 2);
+
+ // Get the writable item definition manager from the server
+ IWritableItemDefManager *idef =
+ STACK_TO_SERVER(L)->getWritableItemDefManager();
+
+ idef->registerAlias(name, convert_to);
+
+ return 0; /* number of results */
+}
+
+bool ModApiItemMod::Initialize(lua_State *L,int top) {
+
+ bool retval = true;
+
+ retval &= API_FCT(register_item_raw);
+ retval &= API_FCT(register_alias_raw);
+
+ LuaItemStack::Register(L);
+
+ return retval;
+}
+
+ModApiItemMod modapi_item_prototyp;
diff --git a/src/script/lua_api/l_item.h b/src/script/lua_api/l_item.h
new file mode 100644
index 000000000..cbed4ae0b
--- /dev/null
+++ b/src/script/lua_api/l_item.h
@@ -0,0 +1,151 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef L_ITEM_H_
+#define L_ITEM_H_
+
+extern "C" {
+#include <lua.h>
+#include <lauxlib.h>
+}
+
+#include <vector>
+
+#include "itemdef.h"
+#include "content_sao.h"
+#include "util/pointedthing.h"
+#include "inventory.h"
+
+#include "lua_api/l_base.h"
+
+class ModApiInventory;
+
+class LuaItemStack
+{
+private:
+ ItemStack m_stack;
+
+ static const char className[];
+ static const luaL_reg methods[];
+
+ // Exported functions
+
+ // garbage collector
+ static int gc_object(lua_State *L);
+
+ // is_empty(self) -> true/false
+ static int l_is_empty(lua_State *L);
+
+ // get_name(self) -> string
+ static int l_get_name(lua_State *L);
+
+ // get_count(self) -> number
+ static int l_get_count(lua_State *L);
+
+ // get_wear(self) -> number
+ static int l_get_wear(lua_State *L);
+
+ // get_metadata(self) -> string
+ static int l_get_metadata(lua_State *L);
+
+ // clear(self) -> true
+ static int l_clear(lua_State *L);
+
+ // replace(self, itemstack or itemstring or table or nil) -> true
+ static int l_replace(lua_State *L);
+
+ // to_string(self) -> string
+ static int l_to_string(lua_State *L);
+
+ // to_table(self) -> table or nil
+ static int l_to_table(lua_State *L);
+
+ // get_stack_max(self) -> number
+ static int l_get_stack_max(lua_State *L);
+
+ // get_free_space(self) -> number
+ static int l_get_free_space(lua_State *L);
+
+ // is_known(self) -> true/false
+ // Checks if the item is defined.
+ static int l_is_known(lua_State *L);
+
+ // get_definition(self) -> table
+ // Returns the item definition table from minetest.registered_items,
+ // or a fallback one (name="unknown")
+ static int l_get_definition(lua_State *L);
+
+ // get_tool_capabilities(self) -> table
+ // Returns the effective tool digging properties.
+ // Returns those of the hand ("") if this item has none associated.
+ static int l_get_tool_capabilities(lua_State *L);
+
+ // add_wear(self, amount) -> true/false
+ // The range for "amount" is [0,65535]. Wear is only added if the item
+ // is a tool. Adding wear might destroy the item.
+ // Returns true if the item is (or was) a tool.
+ static int l_add_wear(lua_State *L);
+
+ // add_item(self, itemstack or itemstring or table or nil) -> itemstack
+ // Returns leftover item stack
+ static int l_add_item(lua_State *L);
+
+ // item_fits(self, itemstack or itemstring or table or nil) -> true/false, itemstack
+ // First return value is true iff the new item fits fully into the stack
+ // Second return value is the would-be-left-over item stack
+ static int l_item_fits(lua_State *L);
+
+ // take_item(self, takecount=1) -> itemstack
+ static int l_take_item(lua_State *L);
+
+ // peek_item(self, peekcount=1) -> itemstack
+ static int l_peek_item(lua_State *L);
+
+public:
+ LuaItemStack(const ItemStack &item);
+ ~LuaItemStack();
+
+ const ItemStack& getItem() const;
+ ItemStack& getItem();
+
+ // LuaItemStack(itemstack or itemstring or table or nil)
+ // Creates an LuaItemStack and leaves it on top of stack
+ static int create_object(lua_State *L);
+ // Not callable from Lua
+ static int create(lua_State *L, const ItemStack &item);
+ static LuaItemStack* checkobject(lua_State *L, int narg);
+ static void Register(lua_State *L);
+
+};
+
+class ModApiItemMod
+ :virtual public ModApiBase
+{
+public:
+ ModApiItemMod();
+
+ bool Initialize(lua_State *L,int top);
+
+ static int l_register_item_raw(lua_State *L);
+ static int l_register_alias_raw(lua_State *L);
+};
+
+
+
+#endif /* L_ITEM_H_ */
diff --git a/src/script/lua_api/l_nodemeta.cpp b/src/script/lua_api/l_nodemeta.cpp
new file mode 100644
index 000000000..511fb38ce
--- /dev/null
+++ b/src/script/lua_api/l_nodemeta.cpp
@@ -0,0 +1,332 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "cpp_api/scriptapi.h"
+#include "common/c_converter.h"
+#include "common/c_content.h"
+#include "map.h"
+#include "lua_api/l_nodemeta.h"
+#include "common/c_internal.h"
+#include "lua_api/l_inventory.h"
+
+
+/*
+ NodeMetaRef
+*/
+NodeMetaRef* NodeMetaRef::checkobject(lua_State *L, int narg)
+{
+ luaL_checktype(L, narg, LUA_TUSERDATA);
+ void *ud = luaL_checkudata(L, narg, className);
+ if(!ud) luaL_typerror(L, narg, className);
+ return *(NodeMetaRef**)ud; // unbox pointer
+}
+
+NodeMetadata* NodeMetaRef::getmeta(NodeMetaRef *ref, bool auto_create)
+{
+ NodeMetadata *meta = ref->m_env->getMap().getNodeMetadata(ref->m_p);
+ if(meta == NULL && auto_create)
+ {
+ meta = new NodeMetadata(ref->m_env->getGameDef());
+ ref->m_env->getMap().setNodeMetadata(ref->m_p, meta);
+ }
+ return meta;
+}
+
+void NodeMetaRef::reportMetadataChange(NodeMetaRef *ref)
+{
+ // NOTE: This same code is in rollback_interface.cpp
+ // Inform other things that the metadata has changed
+ v3s16 blockpos = getNodeBlockPos(ref->m_p);
+ MapEditEvent event;
+ event.type = MEET_BLOCK_NODE_METADATA_CHANGED;
+ event.p = blockpos;
+ ref->m_env->getMap().dispatchEvent(&event);
+ // Set the block to be saved
+ MapBlock *block = ref->m_env->getMap().getBlockNoCreateNoEx(blockpos);
+ if(block)
+ block->raiseModified(MOD_STATE_WRITE_NEEDED,
+ "NodeMetaRef::reportMetadataChange");
+}
+
+// Exported functions
+
+// garbage collector
+int NodeMetaRef::gc_object(lua_State *L) {
+ NodeMetaRef *o = *(NodeMetaRef **)(lua_touserdata(L, 1));
+ delete o;
+ return 0;
+}
+
+// get_string(self, name)
+int NodeMetaRef::l_get_string(lua_State *L)
+{
+ NodeMetaRef *ref = checkobject(L, 1);
+ std::string name = luaL_checkstring(L, 2);
+
+ NodeMetadata *meta = getmeta(ref, false);
+ if(meta == NULL){
+ lua_pushlstring(L, "", 0);
+ return 1;
+ }
+ std::string str = meta->getString(name);
+ lua_pushlstring(L, str.c_str(), str.size());
+ return 1;
+}
+
+// set_string(self, name, var)
+int NodeMetaRef::l_set_string(lua_State *L)
+{
+ NodeMetaRef *ref = checkobject(L, 1);
+ std::string name = luaL_checkstring(L, 2);
+ size_t len = 0;
+ const char *s = lua_tolstring(L, 3, &len);
+ std::string str(s, len);
+
+ NodeMetadata *meta = getmeta(ref, !str.empty());
+ if(meta == NULL || str == meta->getString(name))
+ return 0;
+ meta->setString(name, str);
+ reportMetadataChange(ref);
+ return 0;
+}
+
+// get_int(self, name)
+int NodeMetaRef::l_get_int(lua_State *L)
+{
+ NodeMetaRef *ref = checkobject(L, 1);
+ std::string name = lua_tostring(L, 2);
+
+ NodeMetadata *meta = getmeta(ref, false);
+ if(meta == NULL){
+ lua_pushnumber(L, 0);
+ return 1;
+ }
+ std::string str = meta->getString(name);
+ lua_pushnumber(L, stoi(str));
+ return 1;
+}
+
+// set_int(self, name, var)
+int NodeMetaRef::l_set_int(lua_State *L)
+{
+ NodeMetaRef *ref = checkobject(L, 1);
+ std::string name = lua_tostring(L, 2);
+ int a = lua_tointeger(L, 3);
+ std::string str = itos(a);
+
+ NodeMetadata *meta = getmeta(ref, true);
+ if(meta == NULL || str == meta->getString(name))
+ return 0;
+ meta->setString(name, str);
+ reportMetadataChange(ref);
+ return 0;
+}
+
+// get_float(self, name)
+int NodeMetaRef::l_get_float(lua_State *L)
+{
+ NodeMetaRef *ref = checkobject(L, 1);
+ std::string name = lua_tostring(L, 2);
+
+ NodeMetadata *meta = getmeta(ref, false);
+ if(meta == NULL){
+ lua_pushnumber(L, 0);
+ return 1;
+ }
+ std::string str = meta->getString(name);
+ lua_pushnumber(L, stof(str));
+ return 1;
+}
+
+// set_float(self, name, var)
+int NodeMetaRef::l_set_float(lua_State *L)
+{
+ NodeMetaRef *ref = checkobject(L, 1);
+ std::string name = lua_tostring(L, 2);
+ float a = lua_tonumber(L, 3);
+ std::string str = ftos(a);
+
+ NodeMetadata *meta = getmeta(ref, true);
+ if(meta == NULL || str == meta->getString(name))
+ return 0;
+ meta->setString(name, str);
+ reportMetadataChange(ref);
+ return 0;
+}
+
+// get_inventory(self)
+int NodeMetaRef::l_get_inventory(lua_State *L)
+{
+ NodeMetaRef *ref = checkobject(L, 1);
+ getmeta(ref, true); // try to ensure the metadata exists
+ InvRef::createNodeMeta(L, ref->m_p);
+ return 1;
+}
+
+// to_table(self)
+int NodeMetaRef::l_to_table(lua_State *L)
+{
+ NodeMetaRef *ref = checkobject(L, 1);
+
+ NodeMetadata *meta = getmeta(ref, true);
+ if(meta == NULL){
+ lua_pushnil(L);
+ return 1;
+ }
+ lua_newtable(L);
+ // fields
+ lua_newtable(L);
+ {
+ std::map<std::string, std::string> fields = meta->getStrings();
+ for(std::map<std::string, std::string>::const_iterator
+ i = fields.begin(); i != fields.end(); i++){
+ const std::string &name = i->first;
+ const std::string &value = i->second;
+ lua_pushlstring(L, name.c_str(), name.size());
+ lua_pushlstring(L, value.c_str(), value.size());
+ lua_settable(L, -3);
+ }
+ }
+ lua_setfield(L, -2, "fields");
+ // inventory
+ lua_newtable(L);
+ Inventory *inv = meta->getInventory();
+ if(inv){
+ std::vector<const InventoryList*> lists = inv->getLists();
+ for(std::vector<const InventoryList*>::const_iterator
+ i = lists.begin(); i != lists.end(); i++){
+ push_inventory_list(inv, (*i)->getName().c_str(), L);
+ lua_setfield(L, -2, (*i)->getName().c_str());
+ }
+ }
+ lua_setfield(L, -2, "inventory");
+ return 1;
+}
+
+// from_table(self, table)
+int NodeMetaRef::l_from_table(lua_State *L)
+{
+ NodeMetaRef *ref = checkobject(L, 1);
+ int base = 2;
+
+ if(lua_isnil(L, base)){
+ // No metadata
+ ref->m_env->getMap().removeNodeMetadata(ref->m_p);
+ lua_pushboolean(L, true);
+ return 1;
+ }
+
+ // Has metadata; clear old one first
+ ref->m_env->getMap().removeNodeMetadata(ref->m_p);
+ // Create new metadata
+ NodeMetadata *meta = getmeta(ref, true);
+ // Set fields
+ lua_getfield(L, base, "fields");
+ int fieldstable = lua_gettop(L);
+ lua_pushnil(L);
+ while(lua_next(L, fieldstable) != 0){
+ // key at index -2 and value at index -1
+ std::string name = lua_tostring(L, -2);
+ size_t cl;
+ const char *cs = lua_tolstring(L, -1, &cl);
+ std::string value(cs, cl);
+ meta->setString(name, value);
+ lua_pop(L, 1); // removes value, keeps key for next iteration
+ }
+ // Set inventory
+ Inventory *inv = meta->getInventory();
+ lua_getfield(L, base, "inventory");
+ int inventorytable = lua_gettop(L);
+ lua_pushnil(L);
+ while(lua_next(L, inventorytable) != 0){
+ // key at index -2 and value at index -1
+ std::string name = lua_tostring(L, -2);
+ read_inventory_list(inv, name.c_str(), L, -1,STACK_TO_SERVER(L));
+ lua_pop(L, 1); // removes value, keeps key for next iteration
+ }
+ reportMetadataChange(ref);
+ lua_pushboolean(L, true);
+ return 1;
+}
+
+
+NodeMetaRef::NodeMetaRef(v3s16 p, ServerEnvironment *env):
+ m_p(p),
+ m_env(env)
+{
+}
+
+NodeMetaRef::~NodeMetaRef()
+{
+}
+
+// Creates an NodeMetaRef and leaves it on top of stack
+// Not callable from Lua; all references are created on the C side.
+void NodeMetaRef::create(lua_State *L, v3s16 p, ServerEnvironment *env)
+{
+ NodeMetaRef *o = new NodeMetaRef(p, env);
+ //infostream<<"NodeMetaRef::create: o="<<o<<std::endl;
+ *(void **)(lua_newuserdata(L, sizeof(void *))) = o;
+ luaL_getmetatable(L, className);
+ lua_setmetatable(L, -2);
+}
+
+void NodeMetaRef::Register(lua_State *L)
+{
+ lua_newtable(L);
+ int methodtable = lua_gettop(L);
+ luaL_newmetatable(L, className);
+ int metatable = lua_gettop(L);
+
+ lua_pushliteral(L, "__metatable");
+ lua_pushvalue(L, methodtable);
+ lua_settable(L, metatable); // hide metatable from Lua getmetatable()
+
+ lua_pushliteral(L, "__index");
+ lua_pushvalue(L, methodtable);
+ lua_settable(L, metatable);
+
+ lua_pushliteral(L, "__gc");
+ lua_pushcfunction(L, gc_object);
+ lua_settable(L, metatable);
+
+ lua_pop(L, 1); // drop metatable
+
+ luaL_openlib(L, 0, methods, 0); // fill methodtable
+ lua_pop(L, 1); // drop methodtable
+
+ // Cannot be created from Lua
+ //lua_register(L, className, create_object);
+}
+
+const char NodeMetaRef::className[] = "NodeMetaRef";
+const luaL_reg NodeMetaRef::methods[] = {
+ luamethod(NodeMetaRef, get_string),
+ luamethod(NodeMetaRef, set_string),
+ luamethod(NodeMetaRef, get_int),
+ luamethod(NodeMetaRef, set_int),
+ luamethod(NodeMetaRef, get_float),
+ luamethod(NodeMetaRef, set_float),
+ luamethod(NodeMetaRef, get_inventory),
+ luamethod(NodeMetaRef, to_table),
+ luamethod(NodeMetaRef, from_table),
+ {0,0}
+};
+
+REGISTER_LUA_REF(NodeMetaRef);
diff --git a/src/script/lua_api/l_nodemeta.h b/src/script/lua_api/l_nodemeta.h
new file mode 100644
index 000000000..23404a084
--- /dev/null
+++ b/src/script/lua_api/l_nodemeta.h
@@ -0,0 +1,93 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+#ifndef L_NODEMETA_H_
+#define L_NODEMETA_H_
+
+extern "C" {
+#include <lua.h>
+#include <lauxlib.h>
+}
+
+#include "environment.h"
+#include "nodemetadata.h"
+
+/*
+ NodeMetaRef
+*/
+
+class NodeMetaRef
+{
+private:
+ v3s16 m_p;
+ ServerEnvironment *m_env;
+
+ static const char className[];
+ static const luaL_reg methods[];
+
+ static NodeMetaRef *checkobject(lua_State *L, int narg);
+
+ static NodeMetadata* getmeta(NodeMetaRef *ref, bool auto_create);
+
+ static void reportMetadataChange(NodeMetaRef *ref);
+
+ // Exported functions
+
+ // garbage collector
+ static int gc_object(lua_State *L);
+
+ // get_string(self, name)
+ static int l_get_string(lua_State *L);
+
+ // set_string(self, name, var)
+ static int l_set_string(lua_State *L);
+
+ // get_int(self, name)
+ static int l_get_int(lua_State *L);
+
+ // set_int(self, name, var)
+ static int l_set_int(lua_State *L);
+
+ // get_float(self, name)
+ static int l_get_float(lua_State *L);
+
+ // set_float(self, name, var)
+ static int l_set_float(lua_State *L);
+
+ // get_inventory(self)
+ static int l_get_inventory(lua_State *L);
+
+ // to_table(self)
+ static int l_to_table(lua_State *L);
+
+ // from_table(self, table)
+ static int l_from_table(lua_State *L);
+
+public:
+ NodeMetaRef(v3s16 p, ServerEnvironment *env);
+
+ ~NodeMetaRef();
+
+ // Creates an NodeMetaRef and leaves it on top of stack
+ // Not callable from Lua; all references are created on the C side.
+ static void create(lua_State *L, v3s16 p, ServerEnvironment *env);
+
+ static void Register(lua_State *L);
+};
+
+#endif //L_NODEMETA_H_
diff --git a/src/script/lua_api/l_nodetimer.cpp b/src/script/lua_api/l_nodetimer.cpp
new file mode 100644
index 000000000..60e4ec061
--- /dev/null
+++ b/src/script/lua_api/l_nodetimer.cpp
@@ -0,0 +1,169 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "cpp_api/scriptapi.h"
+#include "lua_api/l_nodetimer.h"
+#include "common/c_internal.h"
+#include "map.h"
+
+
+int NodeTimerRef::gc_object(lua_State *L) {
+ NodeTimerRef *o = *(NodeTimerRef **)(lua_touserdata(L, 1));
+ delete o;
+ return 0;
+}
+
+NodeTimerRef* NodeTimerRef::checkobject(lua_State *L, int narg)
+{
+ luaL_checktype(L, narg, LUA_TUSERDATA);
+ void *ud = luaL_checkudata(L, narg, className);
+ if(!ud) luaL_typerror(L, narg, className);
+ return *(NodeTimerRef**)ud; // unbox pointer
+}
+
+int NodeTimerRef::l_set(lua_State *L)
+{
+ NodeTimerRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+ f32 t = luaL_checknumber(L,2);
+ f32 e = luaL_checknumber(L,3);
+ env->getMap().setNodeTimer(o->m_p,NodeTimer(t,e));
+ return 0;
+}
+
+int NodeTimerRef::l_start(lua_State *L)
+{
+ NodeTimerRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+ f32 t = luaL_checknumber(L,2);
+ env->getMap().setNodeTimer(o->m_p,NodeTimer(t,0));
+ return 0;
+}
+
+int NodeTimerRef::l_stop(lua_State *L)
+{
+ NodeTimerRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+ env->getMap().removeNodeTimer(o->m_p);
+ return 0;
+}
+
+int NodeTimerRef::l_is_started(lua_State *L)
+{
+ NodeTimerRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+
+ NodeTimer t = env->getMap().getNodeTimer(o->m_p);
+ lua_pushboolean(L,(t.timeout != 0));
+ return 1;
+}
+
+int NodeTimerRef::l_get_timeout(lua_State *L)
+{
+ NodeTimerRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+
+ NodeTimer t = env->getMap().getNodeTimer(o->m_p);
+ lua_pushnumber(L,t.timeout);
+ return 1;
+}
+
+int NodeTimerRef::l_get_elapsed(lua_State *L)
+{
+ NodeTimerRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+
+ NodeTimer t = env->getMap().getNodeTimer(o->m_p);
+ lua_pushnumber(L,t.elapsed);
+ return 1;
+}
+
+
+NodeTimerRef::NodeTimerRef(v3s16 p, ServerEnvironment *env):
+ m_p(p),
+ m_env(env)
+{
+}
+
+NodeTimerRef::~NodeTimerRef()
+{
+}
+
+// Creates an NodeTimerRef and leaves it on top of stack
+// Not callable from Lua; all references are created on the C side.
+void NodeTimerRef::create(lua_State *L, v3s16 p, ServerEnvironment *env)
+{
+ NodeTimerRef *o = new NodeTimerRef(p, env);
+ *(void **)(lua_newuserdata(L, sizeof(void *))) = o;
+ luaL_getmetatable(L, className);
+ lua_setmetatable(L, -2);
+}
+
+void NodeTimerRef::set_null(lua_State *L)
+{
+ NodeTimerRef *o = checkobject(L, -1);
+ o->m_env = NULL;
+}
+
+void NodeTimerRef::Register(lua_State *L)
+{
+ lua_newtable(L);
+ int methodtable = lua_gettop(L);
+ luaL_newmetatable(L, className);
+ int metatable = lua_gettop(L);
+
+ lua_pushliteral(L, "__metatable");
+ lua_pushvalue(L, methodtable);
+ lua_settable(L, metatable); // hide metatable from Lua getmetatable()
+
+ lua_pushliteral(L, "__index");
+ lua_pushvalue(L, methodtable);
+ lua_settable(L, metatable);
+
+ lua_pushliteral(L, "__gc");
+ lua_pushcfunction(L, gc_object);
+ lua_settable(L, metatable);
+
+ lua_pop(L, 1); // drop metatable
+
+ luaL_openlib(L, 0, methods, 0); // fill methodtable
+ lua_pop(L, 1); // drop methodtable
+
+ // Cannot be created from Lua
+ //lua_register(L, className, create_object);
+}
+
+const char NodeTimerRef::className[] = "NodeTimerRef";
+const luaL_reg NodeTimerRef::methods[] = {
+ luamethod(NodeTimerRef, start),
+ luamethod(NodeTimerRef, set),
+ luamethod(NodeTimerRef, stop),
+ luamethod(NodeTimerRef, is_started),
+ luamethod(NodeTimerRef, get_timeout),
+ luamethod(NodeTimerRef, get_elapsed),
+ {0,0}
+};
+
+REGISTER_LUA_REF(NodeTimerRef);
diff --git a/src/script/lua_api/l_nodetimer.h b/src/script/lua_api/l_nodetimer.h
new file mode 100644
index 000000000..f652b4900
--- /dev/null
+++ b/src/script/lua_api/l_nodetimer.h
@@ -0,0 +1,70 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef L_NODETIMER_H_
+#define L_NODETIMER_H_
+
+extern "C" {
+#include <lua.h>
+#include <lauxlib.h>
+}
+
+#include "environment.h"
+
+class NodeTimerRef
+{
+private:
+ v3s16 m_p;
+ ServerEnvironment *m_env;
+
+ static const char className[];
+ static const luaL_reg methods[];
+
+ static int gc_object(lua_State *L);
+
+ static NodeTimerRef *checkobject(lua_State *L, int narg);
+
+ static int l_set(lua_State *L);
+
+ static int l_start(lua_State *L);
+
+ static int l_stop(lua_State *L);
+
+ static int l_is_started(lua_State *L);
+
+ static int l_get_timeout(lua_State *L);
+
+ static int l_get_elapsed(lua_State *L);
+
+public:
+ NodeTimerRef(v3s16 p, ServerEnvironment *env);
+ ~NodeTimerRef();
+
+ // Creates an NodeTimerRef and leaves it on top of stack
+ // Not callable from Lua; all references are created on the C side.
+ static void create(lua_State *L, v3s16 p, ServerEnvironment *env);
+
+ static void set_null(lua_State *L);
+
+ static void Register(lua_State *L);
+};
+
+
+
+#endif /* L_NODETIMER_H_ */
diff --git a/src/script/lua_api/l_noise.cpp b/src/script/lua_api/l_noise.cpp
new file mode 100644
index 000000000..e0abeae94
--- /dev/null
+++ b/src/script/lua_api/l_noise.cpp
@@ -0,0 +1,373 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "lua_api/l_noise.h"
+#include "common/c_internal.h"
+#include "common/c_converter.h"
+#include "log.h"
+
+// garbage collector
+int LuaPerlinNoise::gc_object(lua_State *L)
+{
+ LuaPerlinNoise *o = *(LuaPerlinNoise **)(lua_touserdata(L, 1));
+ delete o;
+ return 0;
+}
+
+int LuaPerlinNoise::l_get2d(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaPerlinNoise *o = checkobject(L, 1);
+ v2f pos2d = read_v2f(L,2);
+ lua_Number val = noise2d_perlin(pos2d.X/o->scale, pos2d.Y/o->scale, o->seed, o->octaves, o->persistence);
+ lua_pushnumber(L, val);
+ return 1;
+}
+int LuaPerlinNoise::l_get3d(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaPerlinNoise *o = checkobject(L, 1);
+ v3f pos3d = read_v3f(L,2);
+ lua_Number val = noise3d_perlin(pos3d.X/o->scale, pos3d.Y/o->scale, pos3d.Z/o->scale, o->seed, o->octaves, o->persistence);
+ lua_pushnumber(L, val);
+ return 1;
+}
+
+
+LuaPerlinNoise::LuaPerlinNoise(int a_seed, int a_octaves, float a_persistence,
+ float a_scale):
+ seed(a_seed),
+ octaves(a_octaves),
+ persistence(a_persistence),
+ scale(a_scale)
+{
+}
+
+LuaPerlinNoise::~LuaPerlinNoise()
+{
+}
+
+// LuaPerlinNoise(seed, octaves, persistence, scale)
+// Creates an LuaPerlinNoise and leaves it on top of stack
+int LuaPerlinNoise::create_object(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ int seed = luaL_checkint(L, 1);
+ int octaves = luaL_checkint(L, 2);
+ float persistence = luaL_checknumber(L, 3);
+ float scale = luaL_checknumber(L, 4);
+ LuaPerlinNoise *o = new LuaPerlinNoise(seed, octaves, persistence, scale);
+ *(void **)(lua_newuserdata(L, sizeof(void *))) = o;
+ luaL_getmetatable(L, className);
+ lua_setmetatable(L, -2);
+ return 1;
+}
+
+LuaPerlinNoise* LuaPerlinNoise::checkobject(lua_State *L, int narg)
+{
+ NO_MAP_LOCK_REQUIRED;
+ luaL_checktype(L, narg, LUA_TUSERDATA);
+ void *ud = luaL_checkudata(L, narg, className);
+ if(!ud) luaL_typerror(L, narg, className);
+ return *(LuaPerlinNoise**)ud; // unbox pointer
+}
+
+void LuaPerlinNoise::Register(lua_State *L)
+{
+ lua_newtable(L);
+ int methodtable = lua_gettop(L);
+ luaL_newmetatable(L, className);
+ int metatable = lua_gettop(L);
+
+ lua_pushliteral(L, "__metatable");
+ lua_pushvalue(L, methodtable);
+ lua_settable(L, metatable); // hide metatable from Lua getmetatable()
+
+ lua_pushliteral(L, "__index");
+ lua_pushvalue(L, methodtable);
+ lua_settable(L, metatable);
+
+ lua_pushliteral(L, "__gc");
+ lua_pushcfunction(L, gc_object);
+ lua_settable(L, metatable);
+
+ lua_pop(L, 1); // drop metatable
+
+ luaL_openlib(L, 0, methods, 0); // fill methodtable
+ lua_pop(L, 1); // drop methodtable
+
+ // Can be created from Lua (PerlinNoise(seed, octaves, persistence)
+ lua_register(L, className, create_object);
+}
+
+const char LuaPerlinNoise::className[] = "PerlinNoise";
+const luaL_reg LuaPerlinNoise::methods[] = {
+ luamethod(LuaPerlinNoise, get2d),
+ luamethod(LuaPerlinNoise, get3d),
+ {0,0}
+};
+
+/*
+ PerlinNoiseMap
+ */
+
+
+int LuaPerlinNoiseMap::gc_object(lua_State *L)
+{
+ LuaPerlinNoiseMap *o = *(LuaPerlinNoiseMap **)(lua_touserdata(L, 1));
+ delete o;
+ return 0;
+}
+
+int LuaPerlinNoiseMap::l_get2dMap(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ int i = 0;
+
+ LuaPerlinNoiseMap *o = checkobject(L, 1);
+ v2f p = read_v2f(L, 2);
+
+ Noise *n = o->noise;
+ n->perlinMap2D(p.X, p.Y);
+
+ lua_newtable(L);
+ for (int y = 0; y != n->sy; y++) {
+ lua_newtable(L);
+ for (int x = 0; x != n->sx; x++) {
+ float noiseval = n->np->offset + n->np->scale * n->result[i++];
+ lua_pushnumber(L, noiseval);
+ lua_rawseti(L, -2, x + 1);
+ }
+ lua_rawseti(L, -2, y + 1);
+ }
+ return 1;
+}
+
+int LuaPerlinNoiseMap::l_get3dMap(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ int i = 0;
+
+ LuaPerlinNoiseMap *o = checkobject(L, 1);
+ v3f p = read_v3f(L, 2);
+
+ Noise *n = o->noise;
+ n->perlinMap3D(p.X, p.Y, p.Z);
+
+ lua_newtable(L);
+ for (int z = 0; z != n->sz; z++) {
+ lua_newtable(L);
+ for (int y = 0; y != n->sy; y++) {
+ lua_newtable(L);
+ for (int x = 0; x != n->sx; x++) {
+ lua_pushnumber(L, n->np->offset + n->np->scale * n->result[i++]);
+ lua_rawseti(L, -2, x + 1);
+ }
+ lua_rawseti(L, -2, y + 1);
+ }
+ lua_rawseti(L, -2, z + 1);
+ }
+ return 1;
+}
+
+LuaPerlinNoiseMap::LuaPerlinNoiseMap(NoiseParams *np, int seed, v3s16 size) {
+ noise = new Noise(np, seed, size.X, size.Y, size.Z);
+}
+
+LuaPerlinNoiseMap::~LuaPerlinNoiseMap()
+{
+ delete noise->np;
+ delete noise;
+}
+
+// LuaPerlinNoiseMap(np, size)
+// Creates an LuaPerlinNoiseMap and leaves it on top of stack
+int LuaPerlinNoiseMap::create_object(lua_State *L)
+{
+ NoiseParams *np = read_noiseparams(L, 1);
+ if (!np)
+ return 0;
+ v3s16 size = read_v3s16(L, 2);
+
+ LuaPerlinNoiseMap *o = new LuaPerlinNoiseMap(np, 0, size);
+ *(void **)(lua_newuserdata(L, sizeof(void *))) = o;
+ luaL_getmetatable(L, className);
+ lua_setmetatable(L, -2);
+ return 1;
+}
+
+LuaPerlinNoiseMap* LuaPerlinNoiseMap::checkobject(lua_State *L, int narg)
+{
+ luaL_checktype(L, narg, LUA_TUSERDATA);
+
+ void *ud = luaL_checkudata(L, narg, className);
+ if (!ud)
+ luaL_typerror(L, narg, className);
+
+ return *(LuaPerlinNoiseMap **)ud; // unbox pointer
+}
+
+void LuaPerlinNoiseMap::Register(lua_State *L)
+{
+ lua_newtable(L);
+ int methodtable = lua_gettop(L);
+ luaL_newmetatable(L, className);
+ int metatable = lua_gettop(L);
+
+ lua_pushliteral(L, "__metatable");
+ lua_pushvalue(L, methodtable);
+ lua_settable(L, metatable); // hide metatable from Lua getmetatable()
+
+ lua_pushliteral(L, "__index");
+ lua_pushvalue(L, methodtable);
+ lua_settable(L, metatable);
+
+ lua_pushliteral(L, "__gc");
+ lua_pushcfunction(L, gc_object);
+ lua_settable(L, metatable);
+
+ lua_pop(L, 1); // drop metatable
+
+ luaL_openlib(L, 0, methods, 0); // fill methodtable
+ lua_pop(L, 1); // drop methodtable
+
+ // Can be created from Lua (PerlinNoiseMap(np, size)
+ lua_register(L, className, create_object);
+}
+
+const char LuaPerlinNoiseMap::className[] = "PerlinNoiseMap";
+const luaL_reg LuaPerlinNoiseMap::methods[] = {
+ luamethod(LuaPerlinNoiseMap, get2dMap),
+ luamethod(LuaPerlinNoiseMap, get3dMap),
+ {0,0}
+};
+
+/*
+ LuaPseudoRandom
+*/
+
+// garbage collector
+int LuaPseudoRandom::gc_object(lua_State *L)
+{
+ LuaPseudoRandom *o = *(LuaPseudoRandom **)(lua_touserdata(L, 1));
+ delete o;
+ return 0;
+}
+
+// next(self, min=0, max=32767) -> get next value
+int LuaPseudoRandom::l_next(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ LuaPseudoRandom *o = checkobject(L, 1);
+ int min = 0;
+ int max = 32767;
+ lua_settop(L, 3); // Fill 2 and 3 with nil if they don't exist
+ if(!lua_isnil(L, 2))
+ min = luaL_checkinteger(L, 2);
+ if(!lua_isnil(L, 3))
+ max = luaL_checkinteger(L, 3);
+ if(max < min){
+ errorstream<<"PseudoRandom.next(): max="<<max<<" min="<<min<<std::endl;
+ throw LuaError(L, "PseudoRandom.next(): max < min");
+ }
+ if(max - min != 32767 && max - min > 32767/5)
+ throw LuaError(L, "PseudoRandom.next() max-min is not 32767 and is > 32768/5. This is disallowed due to the bad random distribution the implementation would otherwise make.");
+ PseudoRandom &pseudo = o->m_pseudo;
+ int val = pseudo.next();
+ val = (val % (max-min+1)) + min;
+ lua_pushinteger(L, val);
+ return 1;
+}
+
+
+LuaPseudoRandom::LuaPseudoRandom(int seed):
+ m_pseudo(seed)
+{
+}
+
+LuaPseudoRandom::~LuaPseudoRandom()
+{
+}
+
+const PseudoRandom& LuaPseudoRandom::getItem() const
+{
+ return m_pseudo;
+}
+PseudoRandom& LuaPseudoRandom::getItem()
+{
+ return m_pseudo;
+}
+
+// LuaPseudoRandom(seed)
+// Creates an LuaPseudoRandom and leaves it on top of stack
+int LuaPseudoRandom::create_object(lua_State *L)
+{
+ int seed = luaL_checknumber(L, 1);
+ LuaPseudoRandom *o = new LuaPseudoRandom(seed);
+ *(void **)(lua_newuserdata(L, sizeof(void *))) = o;
+ luaL_getmetatable(L, className);
+ lua_setmetatable(L, -2);
+ return 1;
+}
+
+LuaPseudoRandom* LuaPseudoRandom::checkobject(lua_State *L, int narg)
+{
+ luaL_checktype(L, narg, LUA_TUSERDATA);
+ void *ud = luaL_checkudata(L, narg, className);
+ if(!ud) luaL_typerror(L, narg, className);
+ return *(LuaPseudoRandom**)ud; // unbox pointer
+}
+
+void LuaPseudoRandom::Register(lua_State *L)
+{
+ lua_newtable(L);
+ int methodtable = lua_gettop(L);
+ luaL_newmetatable(L, className);
+ int metatable = lua_gettop(L);
+
+ lua_pushliteral(L, "__metatable");
+ lua_pushvalue(L, methodtable);
+ lua_settable(L, metatable); // hide metatable from Lua getmetatable()
+
+ lua_pushliteral(L, "__index");
+ lua_pushvalue(L, methodtable);
+ lua_settable(L, metatable);
+
+ lua_pushliteral(L, "__gc");
+ lua_pushcfunction(L, gc_object);
+ lua_settable(L, metatable);
+
+ lua_pop(L, 1); // drop metatable
+
+ luaL_openlib(L, 0, methods, 0); // fill methodtable
+ lua_pop(L, 1); // drop methodtable
+
+ // Can be created from Lua (LuaPseudoRandom(seed))
+ lua_register(L, className, create_object);
+}
+
+const char LuaPseudoRandom::className[] = "PseudoRandom";
+const luaL_reg LuaPseudoRandom::methods[] = {
+ luamethod(LuaPseudoRandom, next),
+ {0,0}
+};
+
+REGISTER_LUA_REF(LuaPseudoRandom);
+REGISTER_LUA_REF(LuaPerlinNoiseMap);
+REGISTER_LUA_REF(LuaPerlinNoise);
diff --git a/src/script/lua_api/l_noise.h b/src/script/lua_api/l_noise.h
new file mode 100644
index 000000000..d0b51d756
--- /dev/null
+++ b/src/script/lua_api/l_noise.h
@@ -0,0 +1,134 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef L_NOISE_H_
+#define L_NOISE_H_
+
+extern "C" {
+#include <lua.h>
+#include <lauxlib.h>
+}
+
+#include "irr_v3d.h"
+#include "noise.h"
+
+class LuaPerlinNoise
+{
+private:
+ int seed;
+ int octaves;
+ float persistence;
+ float scale;
+ static const char className[];
+ static const luaL_reg methods[];
+
+ // Exported functions
+
+ // garbage collector
+ static int gc_object(lua_State *L);
+
+ static int l_get2d(lua_State *L);
+ static int l_get3d(lua_State *L);
+
+public:
+ LuaPerlinNoise(int a_seed, int a_octaves, float a_persistence,
+ float a_scale);
+
+ ~LuaPerlinNoise();
+
+ // LuaPerlinNoise(seed, octaves, persistence, scale)
+ // Creates an LuaPerlinNoise and leaves it on top of stack
+ static int create_object(lua_State *L);
+
+ static LuaPerlinNoise* checkobject(lua_State *L, int narg);
+
+ static void Register(lua_State *L);
+};
+
+/*
+ PerlinNoiseMap
+ */
+class LuaPerlinNoiseMap
+{
+private:
+ Noise *noise;
+ static const char className[];
+ static const luaL_reg methods[];
+
+ static int gc_object(lua_State *L);
+
+ static int l_get2dMap(lua_State *L);
+
+ static int l_get3dMap(lua_State *L);
+
+public:
+ LuaPerlinNoiseMap(NoiseParams *np, int seed, v3s16 size);
+
+ ~LuaPerlinNoiseMap();
+
+ // LuaPerlinNoiseMap(np, size)
+ // Creates an LuaPerlinNoiseMap and leaves it on top of stack
+ static int create_object(lua_State *L);
+
+ static LuaPerlinNoiseMap *checkobject(lua_State *L, int narg);
+
+ static void Register(lua_State *L);
+};
+
+/*
+ LuaPseudoRandom
+*/
+
+
+class LuaPseudoRandom
+{
+private:
+ PseudoRandom m_pseudo;
+
+ static const char className[];
+ static const luaL_reg methods[];
+
+ // Exported functions
+
+ // garbage collector
+ static int gc_object(lua_State *L);
+
+ // next(self, min=0, max=32767) -> get next value
+ static int l_next(lua_State *L);
+
+public:
+ LuaPseudoRandom(int seed);
+
+ ~LuaPseudoRandom();
+
+ const PseudoRandom& getItem() const;
+ PseudoRandom& getItem();
+
+ // LuaPseudoRandom(seed)
+ // Creates an LuaPseudoRandom and leaves it on top of stack
+ static int create_object(lua_State *L);
+
+ static LuaPseudoRandom* checkobject(lua_State *L, int narg);
+
+ static void Register(lua_State *L);
+};
+
+NoiseParams *read_noiseparams(lua_State *L, int index);
+
+#endif /* L_NOISE_H_ */
diff --git a/src/script/lua_api/l_object.cpp b/src/script/lua_api/l_object.cpp
new file mode 100644
index 000000000..1e45610a6
--- /dev/null
+++ b/src/script/lua_api/l_object.cpp
@@ -0,0 +1,1113 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "cpp_api/scriptapi.h"
+#include "common/c_converter.h"
+#include "common/c_content.h"
+#include "lua_api/l_object.h"
+#include "common/c_internal.h"
+#include "lua_api/l_inventory.h"
+#include "lua_api/l_item.h"
+#include "log.h"
+#include "tool.h"
+#include "serverobject.h"
+#include "content_object.h"
+#include "content_sao.h"
+#include "server.h"
+#include "hud.h"
+
+
+struct EnumString es_HudElementType[] =
+{
+ {HUD_ELEM_IMAGE, "image"},
+ {HUD_ELEM_TEXT, "text"},
+ {HUD_ELEM_STATBAR, "statbar"},
+ {HUD_ELEM_INVENTORY, "inventory"},
+{0, NULL},
+};
+
+struct EnumString es_HudElementStat[] =
+{
+ {HUD_STAT_POS, "pos"},
+ {HUD_STAT_NAME, "name"},
+ {HUD_STAT_SCALE, "scale"},
+ {HUD_STAT_TEXT, "text"},
+ {HUD_STAT_NUMBER, "number"},
+ {HUD_STAT_ITEM, "item"},
+ {HUD_STAT_DIR, "direction"},
+ {HUD_STAT_ALIGN, "alignment"},
+ {HUD_STAT_OFFSET, "offset"},
+ {0, NULL},
+};
+
+struct EnumString es_HudBuiltinElement[] =
+{
+ {HUD_FLAG_HOTBAR_VISIBLE, "hotbar"},
+ {HUD_FLAG_HEALTHBAR_VISIBLE, "healthbar"},
+ {HUD_FLAG_CROSSHAIR_VISIBLE, "crosshair"},
+ {HUD_FLAG_WIELDITEM_VISIBLE, "wielditem"},
+ {0, NULL},
+};
+
+/*
+ ObjectRef
+*/
+
+
+ObjectRef* ObjectRef::checkobject(lua_State *L, int narg)
+{
+ luaL_checktype(L, narg, LUA_TUSERDATA);
+ void *ud = luaL_checkudata(L, narg, className);
+ if(!ud) luaL_typerror(L, narg, className);
+ return *(ObjectRef**)ud; // unbox pointer
+}
+
+ServerActiveObject* ObjectRef::getobject(ObjectRef *ref)
+{
+ ServerActiveObject *co = ref->m_object;
+ return co;
+}
+
+LuaEntitySAO* ObjectRef::getluaobject(ObjectRef *ref)
+{
+ ServerActiveObject *obj = getobject(ref);
+ if(obj == NULL)
+ return NULL;
+ if(obj->getType() != ACTIVEOBJECT_TYPE_LUAENTITY)
+ return NULL;
+ return (LuaEntitySAO*)obj;
+}
+
+PlayerSAO* ObjectRef::getplayersao(ObjectRef *ref)
+{
+ ServerActiveObject *obj = getobject(ref);
+ if(obj == NULL)
+ return NULL;
+ if(obj->getType() != ACTIVEOBJECT_TYPE_PLAYER)
+ return NULL;
+ return (PlayerSAO*)obj;
+}
+
+Player* ObjectRef::getplayer(ObjectRef *ref)
+{
+ PlayerSAO *playersao = getplayersao(ref);
+ if(playersao == NULL)
+ return NULL;
+ return playersao->getPlayer();
+}
+
+// Exported functions
+
+// garbage collector
+int ObjectRef::gc_object(lua_State *L) {
+ ObjectRef *o = *(ObjectRef **)(lua_touserdata(L, 1));
+ //infostream<<"ObjectRef::gc_object: o="<<o<<std::endl;
+ delete o;
+ return 0;
+}
+
+// remove(self)
+int ObjectRef::l_remove(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ ServerActiveObject *co = getobject(ref);
+ if(co == NULL) return 0;
+ verbosestream<<"ObjectRef::l_remove(): id="<<co->getId()<<std::endl;
+ co->m_removed = true;
+ return 0;
+}
+
+// getpos(self)
+// returns: {x=num, y=num, z=num}
+int ObjectRef::l_getpos(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ ServerActiveObject *co = getobject(ref);
+ if(co == NULL) return 0;
+ v3f pos = co->getBasePosition() / BS;
+ lua_newtable(L);
+ lua_pushnumber(L, pos.X);
+ lua_setfield(L, -2, "x");
+ lua_pushnumber(L, pos.Y);
+ lua_setfield(L, -2, "y");
+ lua_pushnumber(L, pos.Z);
+ lua_setfield(L, -2, "z");
+ return 1;
+}
+
+// setpos(self, pos)
+int ObjectRef::l_setpos(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ //LuaEntitySAO *co = getluaobject(ref);
+ ServerActiveObject *co = getobject(ref);
+ if(co == NULL) return 0;
+ // pos
+ v3f pos = checkFloatPos(L, 2);
+ // Do it
+ co->setPos(pos);
+ return 0;
+}
+
+// moveto(self, pos, continuous=false)
+int ObjectRef::l_moveto(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ //LuaEntitySAO *co = getluaobject(ref);
+ ServerActiveObject *co = getobject(ref);
+ if(co == NULL) return 0;
+ // pos
+ v3f pos = checkFloatPos(L, 2);
+ // continuous
+ bool continuous = lua_toboolean(L, 3);
+ // Do it
+ co->moveTo(pos, continuous);
+ return 0;
+}
+
+// punch(self, puncher, time_from_last_punch, tool_capabilities, dir)
+int ObjectRef::l_punch(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ ObjectRef *puncher_ref = checkobject(L, 2);
+ ServerActiveObject *co = getobject(ref);
+ ServerActiveObject *puncher = getobject(puncher_ref);
+ if(co == NULL) return 0;
+ if(puncher == NULL) return 0;
+ v3f dir;
+ if(lua_type(L, 5) != LUA_TTABLE)
+ dir = co->getBasePosition() - puncher->getBasePosition();
+ else
+ dir = read_v3f(L, 5);
+ float time_from_last_punch = 1000000;
+ if(lua_isnumber(L, 3))
+ time_from_last_punch = lua_tonumber(L, 3);
+ ToolCapabilities toolcap = read_tool_capabilities(L, 4);
+ dir.normalize();
+ // Do it
+ co->punch(dir, &toolcap, puncher, time_from_last_punch);
+ return 0;
+}
+
+// right_click(self, clicker); clicker = an another ObjectRef
+int ObjectRef::l_right_click(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ ObjectRef *ref2 = checkobject(L, 2);
+ ServerActiveObject *co = getobject(ref);
+ ServerActiveObject *co2 = getobject(ref2);
+ if(co == NULL) return 0;
+ if(co2 == NULL) return 0;
+ // Do it
+ co->rightClick(co2);
+ return 0;
+}
+
+// set_hp(self, hp)
+// hp = number of hitpoints (2 * number of hearts)
+// returns: nil
+int ObjectRef::l_set_hp(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ luaL_checknumber(L, 2);
+ ServerActiveObject *co = getobject(ref);
+ if(co == NULL) return 0;
+ int hp = lua_tonumber(L, 2);
+ /*infostream<<"ObjectRef::l_set_hp(): id="<<co->getId()
+ <<" hp="<<hp<<std::endl;*/
+ // Do it
+ co->setHP(hp);
+ // Return
+ return 0;
+}
+
+// get_hp(self)
+// returns: number of hitpoints (2 * number of hearts)
+// 0 if not applicable to this type of object
+int ObjectRef::l_get_hp(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ ServerActiveObject *co = getobject(ref);
+ if(co == NULL){
+ // Default hp is 1
+ lua_pushnumber(L, 1);
+ return 1;
+ }
+ int hp = co->getHP();
+ /*infostream<<"ObjectRef::l_get_hp(): id="<<co->getId()
+ <<" hp="<<hp<<std::endl;*/
+ // Return
+ lua_pushnumber(L, hp);
+ return 1;
+}
+
+// get_inventory(self)
+int ObjectRef::l_get_inventory(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ ServerActiveObject *co = getobject(ref);
+ if(co == NULL) return 0;
+ // Do it
+ InventoryLocation loc = co->getInventoryLocation();
+ if(STACK_TO_SERVER(L)->getInventory(loc) != NULL)
+ InvRef::create(L, loc);
+ else
+ lua_pushnil(L); // An object may have no inventory (nil)
+ return 1;
+}
+
+// get_wield_list(self)
+int ObjectRef::l_get_wield_list(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ ServerActiveObject *co = getobject(ref);
+ if(co == NULL) return 0;
+ // Do it
+ lua_pushstring(L, co->getWieldList().c_str());
+ return 1;
+}
+
+// get_wield_index(self)
+int ObjectRef::l_get_wield_index(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ ServerActiveObject *co = getobject(ref);
+ if(co == NULL) return 0;
+ // Do it
+ lua_pushinteger(L, co->getWieldIndex() + 1);
+ return 1;
+}
+
+// get_wielded_item(self)
+int ObjectRef::l_get_wielded_item(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ ServerActiveObject *co = getobject(ref);
+ if(co == NULL){
+ // Empty ItemStack
+ LuaItemStack::create(L, ItemStack());
+ return 1;
+ }
+ // Do it
+ LuaItemStack::create(L, co->getWieldedItem());
+ return 1;
+}
+
+// set_wielded_item(self, itemstack or itemstring or table or nil)
+int ObjectRef::l_set_wielded_item(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ ServerActiveObject *co = getobject(ref);
+ if(co == NULL) return 0;
+ // Do it
+ ItemStack item = read_item(L, 2,STACK_TO_SERVER(L));
+ bool success = co->setWieldedItem(item);
+ lua_pushboolean(L, success);
+ return 1;
+}
+
+// set_armor_groups(self, groups)
+int ObjectRef::l_set_armor_groups(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ ServerActiveObject *co = getobject(ref);
+ if(co == NULL) return 0;
+ // Do it
+ ItemGroupList groups;
+ read_groups(L, 2, groups);
+ co->setArmorGroups(groups);
+ return 0;
+}
+
+// set_physics_override(self, physics_override_speed, physics_override_jump, physics_override_gravity)
+int ObjectRef::l_set_physics_override(lua_State *L)
+{
+ ObjectRef *ref = checkobject(L, 1);
+ PlayerSAO *co = (PlayerSAO *) getobject(ref);
+ if(co == NULL) return 0;
+ // Do it
+ if(!lua_isnil(L, 2)){
+ co->m_physics_override_speed = lua_tonumber(L, 2);
+ co->m_physics_override_sent = false;
+ }
+ if(!lua_isnil(L, 3)){
+ co->m_physics_override_jump = lua_tonumber(L, 3);
+ co->m_physics_override_sent = false;
+ }
+ if(!lua_isnil(L, 4)){
+ co->m_physics_override_gravity = lua_tonumber(L, 4);
+ co->m_physics_override_sent = false;
+ }
+ return 0;
+}
+
+// set_animation(self, frame_range, frame_speed, frame_blend)
+int ObjectRef::l_set_animation(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ ServerActiveObject *co = getobject(ref);
+ if(co == NULL) return 0;
+ // Do it
+ v2f frames = v2f(1, 1);
+ if(!lua_isnil(L, 2))
+ frames = read_v2f(L, 2);
+ float frame_speed = 15;
+ if(!lua_isnil(L, 3))
+ frame_speed = lua_tonumber(L, 3);
+ float frame_blend = 0;
+ if(!lua_isnil(L, 4))
+ frame_blend = lua_tonumber(L, 4);
+ co->setAnimation(frames, frame_speed, frame_blend);
+ return 0;
+}
+
+// set_bone_position(self, std::string bone, v3f position, v3f rotation)
+int ObjectRef::l_set_bone_position(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ ServerActiveObject *co = getobject(ref);
+ if(co == NULL) return 0;
+ // Do it
+ std::string bone = "";
+ if(!lua_isnil(L, 2))
+ bone = lua_tostring(L, 2);
+ v3f position = v3f(0, 0, 0);
+ if(!lua_isnil(L, 3))
+ position = read_v3f(L, 3);
+ v3f rotation = v3f(0, 0, 0);
+ if(!lua_isnil(L, 4))
+ rotation = read_v3f(L, 4);
+ co->setBonePosition(bone, position, rotation);
+ return 0;
+}
+
+// set_attach(self, parent, bone, position, rotation)
+int ObjectRef::l_set_attach(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ ObjectRef *parent_ref = checkobject(L, 2);
+ ServerActiveObject *co = getobject(ref);
+ ServerActiveObject *parent = getobject(parent_ref);
+ if(co == NULL) return 0;
+ if(parent == NULL) return 0;
+ // Do it
+ std::string bone = "";
+ if(!lua_isnil(L, 3))
+ bone = lua_tostring(L, 3);
+ v3f position = v3f(0, 0, 0);
+ if(!lua_isnil(L, 4))
+ position = read_v3f(L, 4);
+ v3f rotation = v3f(0, 0, 0);
+ if(!lua_isnil(L, 5))
+ rotation = read_v3f(L, 5);
+ co->setAttachment(parent->getId(), bone, position, rotation);
+ return 0;
+}
+
+// set_detach(self)
+int ObjectRef::l_set_detach(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ ServerActiveObject *co = getobject(ref);
+ if(co == NULL) return 0;
+ // Do it
+ co->setAttachment(0, "", v3f(0,0,0), v3f(0,0,0));
+ return 0;
+}
+
+// set_properties(self, properties)
+int ObjectRef::l_set_properties(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ ServerActiveObject *co = getobject(ref);
+ if(co == NULL) return 0;
+ ObjectProperties *prop = co->accessObjectProperties();
+ if(!prop)
+ return 0;
+ read_object_properties(L, 2, prop);
+ co->notifyObjectPropertiesModified();
+ return 0;
+}
+
+/* LuaEntitySAO-only */
+
+// setvelocity(self, {x=num, y=num, z=num})
+int ObjectRef::l_setvelocity(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ LuaEntitySAO *co = getluaobject(ref);
+ if(co == NULL) return 0;
+ v3f pos = checkFloatPos(L, 2);
+ // Do it
+ co->setVelocity(pos);
+ return 0;
+}
+
+// getvelocity(self)
+int ObjectRef::l_getvelocity(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ LuaEntitySAO *co = getluaobject(ref);
+ if(co == NULL) return 0;
+ // Do it
+ v3f v = co->getVelocity();
+ pushFloatPos(L, v);
+ return 1;
+}
+
+// setacceleration(self, {x=num, y=num, z=num})
+int ObjectRef::l_setacceleration(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ LuaEntitySAO *co = getluaobject(ref);
+ if(co == NULL) return 0;
+ // pos
+ v3f pos = checkFloatPos(L, 2);
+ // Do it
+ co->setAcceleration(pos);
+ return 0;
+}
+
+// getacceleration(self)
+int ObjectRef::l_getacceleration(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ LuaEntitySAO *co = getluaobject(ref);
+ if(co == NULL) return 0;
+ // Do it
+ v3f v = co->getAcceleration();
+ pushFloatPos(L, v);
+ return 1;
+}
+
+// setyaw(self, radians)
+int ObjectRef::l_setyaw(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ LuaEntitySAO *co = getluaobject(ref);
+ if(co == NULL) return 0;
+ float yaw = luaL_checknumber(L, 2) * core::RADTODEG;
+ // Do it
+ co->setYaw(yaw);
+ return 0;
+}
+
+// getyaw(self)
+int ObjectRef::l_getyaw(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ LuaEntitySAO *co = getluaobject(ref);
+ if(co == NULL) return 0;
+ // Do it
+ float yaw = co->getYaw() * core::DEGTORAD;
+ lua_pushnumber(L, yaw);
+ return 1;
+}
+
+// settexturemod(self, mod)
+int ObjectRef::l_settexturemod(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ LuaEntitySAO *co = getluaobject(ref);
+ if(co == NULL) return 0;
+ // Do it
+ std::string mod = luaL_checkstring(L, 2);
+ co->setTextureMod(mod);
+ return 0;
+}
+
+// setsprite(self, p={x=0,y=0}, num_frames=1, framelength=0.2,
+// select_horiz_by_yawpitch=false)
+int ObjectRef::l_setsprite(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ LuaEntitySAO *co = getluaobject(ref);
+ if(co == NULL) return 0;
+ // Do it
+ v2s16 p(0,0);
+ if(!lua_isnil(L, 2))
+ p = read_v2s16(L, 2);
+ int num_frames = 1;
+ if(!lua_isnil(L, 3))
+ num_frames = lua_tonumber(L, 3);
+ float framelength = 0.2;
+ if(!lua_isnil(L, 4))
+ framelength = lua_tonumber(L, 4);
+ bool select_horiz_by_yawpitch = false;
+ if(!lua_isnil(L, 5))
+ select_horiz_by_yawpitch = lua_toboolean(L, 5);
+ co->setSprite(p, num_frames, framelength, select_horiz_by_yawpitch);
+ return 0;
+}
+
+// DEPRECATED
+// get_entity_name(self)
+int ObjectRef::l_get_entity_name(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ LuaEntitySAO *co = getluaobject(ref);
+ if(co == NULL) return 0;
+ // Do it
+ std::string name = co->getName();
+ lua_pushstring(L, name.c_str());
+ return 1;
+}
+
+// get_luaentity(self)
+int ObjectRef::l_get_luaentity(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ LuaEntitySAO *co = getluaobject(ref);
+ if(co == NULL) return 0;
+ // Do it
+ luaentity_get(L, co->getId());
+ return 1;
+}
+
+/* Player-only */
+
+// is_player(self)
+int ObjectRef::l_is_player(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ Player *player = getplayer(ref);
+ lua_pushboolean(L, (player != NULL));
+ return 1;
+}
+
+// get_player_name(self)
+int ObjectRef::l_get_player_name(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ Player *player = getplayer(ref);
+ if(player == NULL){
+ lua_pushlstring(L, "", 0);
+ return 1;
+ }
+ // Do it
+ lua_pushstring(L, player->getName());
+ return 1;
+}
+
+// get_look_dir(self)
+int ObjectRef::l_get_look_dir(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ Player *player = getplayer(ref);
+ if(player == NULL) return 0;
+ // Do it
+ float pitch = player->getRadPitch();
+ float yaw = player->getRadYaw();
+ v3f v(cos(pitch)*cos(yaw), sin(pitch), cos(pitch)*sin(yaw));
+ push_v3f(L, v);
+ return 1;
+}
+
+// get_look_pitch(self)
+int ObjectRef::l_get_look_pitch(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ Player *player = getplayer(ref);
+ if(player == NULL) return 0;
+ // Do it
+ lua_pushnumber(L, player->getRadPitch());
+ return 1;
+}
+
+// get_look_yaw(self)
+int ObjectRef::l_get_look_yaw(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ Player *player = getplayer(ref);
+ if(player == NULL) return 0;
+ // Do it
+ lua_pushnumber(L, player->getRadYaw());
+ return 1;
+}
+
+// set_look_pitch(self, radians)
+int ObjectRef::l_set_look_pitch(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ PlayerSAO* co = getplayersao(ref);
+ if(co == NULL) return 0;
+ float pitch = luaL_checknumber(L, 2) * core::RADTODEG;
+ // Do it
+ co->setPitch(pitch);
+ return 1;
+}
+
+// set_look_yaw(self, radians)
+int ObjectRef::l_set_look_yaw(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ PlayerSAO* co = getplayersao(ref);
+ if(co == NULL) return 0;
+ float yaw = luaL_checknumber(L, 2) * core::RADTODEG;
+ // Do it
+ co->setYaw(yaw);
+ return 1;
+}
+
+// set_inventory_formspec(self, formspec)
+int ObjectRef::l_set_inventory_formspec(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ Player *player = getplayer(ref);
+ if(player == NULL) return 0;
+ std::string formspec = luaL_checkstring(L, 2);
+
+ player->inventory_formspec = formspec;
+ STACK_TO_SERVER(L)->reportInventoryFormspecModified(player->getName());
+ lua_pushboolean(L, true);
+ return 1;
+}
+
+// get_inventory_formspec(self) -> formspec
+int ObjectRef::l_get_inventory_formspec(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ Player *player = getplayer(ref);
+ if(player == NULL) return 0;
+
+ std::string formspec = player->inventory_formspec;
+ lua_pushlstring(L, formspec.c_str(), formspec.size());
+ return 1;
+}
+
+// get_player_control(self)
+int ObjectRef::l_get_player_control(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ Player *player = getplayer(ref);
+ if(player == NULL){
+ lua_pushlstring(L, "", 0);
+ return 1;
+ }
+ // Do it
+ PlayerControl control = player->getPlayerControl();
+ lua_newtable(L);
+ lua_pushboolean(L, control.up);
+ lua_setfield(L, -2, "up");
+ lua_pushboolean(L, control.down);
+ lua_setfield(L, -2, "down");
+ lua_pushboolean(L, control.left);
+ lua_setfield(L, -2, "left");
+ lua_pushboolean(L, control.right);
+ lua_setfield(L, -2, "right");
+ lua_pushboolean(L, control.jump);
+ lua_setfield(L, -2, "jump");
+ lua_pushboolean(L, control.aux1);
+ lua_setfield(L, -2, "aux1");
+ lua_pushboolean(L, control.sneak);
+ lua_setfield(L, -2, "sneak");
+ lua_pushboolean(L, control.LMB);
+ lua_setfield(L, -2, "LMB");
+ lua_pushboolean(L, control.RMB);
+ lua_setfield(L, -2, "RMB");
+ return 1;
+}
+
+// get_player_control_bits(self)
+int ObjectRef::l_get_player_control_bits(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ ObjectRef *ref = checkobject(L, 1);
+ Player *player = getplayer(ref);
+ if(player == NULL){
+ lua_pushlstring(L, "", 0);
+ return 1;
+ }
+ // Do it
+ lua_pushnumber(L, player->keyPressed);
+ return 1;
+}
+
+// hud_add(self, form)
+int ObjectRef::l_hud_add(lua_State *L)
+{
+ ObjectRef *ref = checkobject(L, 1);
+ Player *player = getplayer(ref);
+ if (player == NULL)
+ return 0;
+
+ HudElement *elem = new HudElement;
+
+ elem->type = (HudElementType)getenumfield(L, 2, "hud_elem_type",
+ es_HudElementType, HUD_ELEM_TEXT);
+
+ lua_getfield(L, 2, "position");
+ elem->pos = lua_istable(L, -1) ? read_v2f(L, -1) : v2f();
+ lua_pop(L, 1);
+
+ lua_getfield(L, 2, "scale");
+ elem->scale = lua_istable(L, -1) ? read_v2f(L, -1) : v2f();
+ lua_pop(L, 1);
+
+ elem->name = getstringfield_default(L, 2, "name", "");
+ elem->text = getstringfield_default(L, 2, "text", "");
+ elem->number = getintfield_default(L, 2, "number", 0);
+ elem->item = getintfield_default(L, 2, "item", 0);
+ elem->dir = getintfield_default(L, 2, "dir", 0);
+
+ lua_getfield(L, 2, "alignment");
+ elem->align = lua_istable(L, -1) ? read_v2f(L, -1) : v2f();
+ lua_pop(L, 1);
+
+ lua_getfield(L, 2, "offset");
+ elem->offset = lua_istable(L, -1) ? read_v2f(L, -1) : v2f();
+ lua_pop(L, 1);
+
+ u32 id = STACK_TO_SERVER(L)->hudAdd(player, elem);
+ if (id == (u32)-1) {
+ delete elem;
+ return 0;
+ }
+
+ lua_pushnumber(L, id);
+ return 1;
+}
+
+// hud_remove(self, id)
+int ObjectRef::l_hud_remove(lua_State *L)
+{
+ ObjectRef *ref = checkobject(L, 1);
+ Player *player = getplayer(ref);
+ if (player == NULL)
+ return 0;
+
+ u32 id = -1;
+ if (!lua_isnil(L, 2))
+ id = lua_tonumber(L, 2);
+
+ if (!STACK_TO_SERVER(L)->hudRemove(player, id))
+ return 0;
+
+ lua_pushboolean(L, true);
+ return 1;
+}
+
+// hud_change(self, id, stat, data)
+int ObjectRef::l_hud_change(lua_State *L)
+{
+ ObjectRef *ref = checkobject(L, 1);
+ Player *player = getplayer(ref);
+ if (player == NULL)
+ return 0;
+
+ u32 id = -1;
+ if (!lua_isnil(L, 2))
+ id = lua_tonumber(L, 2);
+
+ HudElementStat stat = (HudElementStat)getenumfield(L, 3, "stat",
+ es_HudElementStat, HUD_STAT_NUMBER);
+
+ if (id >= player->hud.size())
+ return 0;
+
+ void *value = NULL;
+ HudElement *e = player->hud[id];
+ if (!e)
+ return 0;
+
+ switch (stat) {
+ case HUD_STAT_POS:
+ e->pos = read_v2f(L, 4);
+ value = &e->pos;
+ break;
+ case HUD_STAT_NAME:
+ e->name = lua_tostring(L, 4);
+ value = &e->name;
+ break;
+ case HUD_STAT_SCALE:
+ e->scale = read_v2f(L, 4);
+ value = &e->scale;
+ break;
+ case HUD_STAT_TEXT:
+ e->text = lua_tostring(L, 4);
+ value = &e->text;
+ break;
+ case HUD_STAT_NUMBER:
+ e->number = lua_tonumber(L, 4);
+ value = &e->number;
+ break;
+ case HUD_STAT_ITEM:
+ e->item = lua_tonumber(L, 4);
+ value = &e->item;
+ break;
+ case HUD_STAT_DIR:
+ e->dir = lua_tonumber(L, 4);
+ value = &e->dir;
+ case HUD_STAT_ALIGN:
+ e->align = read_v2f(L, 4);
+ value = &e->align;
+ case HUD_STAT_OFFSET:
+ e->offset = read_v2f(L, 4);
+ value = &e->offset;
+ }
+
+ STACK_TO_SERVER(L)->hudChange(player, id, stat, value);
+
+ lua_pushboolean(L, true);
+ return 1;
+}
+
+// hud_get(self, id)
+int ObjectRef::l_hud_get(lua_State *L)
+{
+ ObjectRef *ref = checkobject(L, 1);
+ Player *player = getplayer(ref);
+ if (player == NULL)
+ return 0;
+
+ u32 id = lua_tonumber(L, -1);
+ if (id >= player->hud.size())
+ return 0;
+
+ HudElement *e = player->hud[id];
+ if (!e)
+ return 0;
+
+ lua_newtable(L);
+
+ lua_pushstring(L, es_HudElementType[(u8)e->type].str);
+ lua_setfield(L, -2, "type");
+
+ push_v2f(L, e->pos);
+ lua_setfield(L, -2, "position");
+
+ lua_pushstring(L, e->name.c_str());
+ lua_setfield(L, -2, "name");
+
+ push_v2f(L, e->scale);
+ lua_setfield(L, -2, "scale");
+
+ lua_pushstring(L, e->text.c_str());
+ lua_setfield(L, -2, "text");
+
+ lua_pushnumber(L, e->number);
+ lua_setfield(L, -2, "number");
+
+ lua_pushnumber(L, e->item);
+ lua_setfield(L, -2, "item");
+
+ lua_pushnumber(L, e->dir);
+ lua_setfield(L, -2, "dir");
+
+ return 1;
+}
+
+// hud_set_flags(self, flags)
+int ObjectRef::l_hud_set_flags(lua_State *L)
+{
+ ObjectRef *ref = checkobject(L, 1);
+ Player *player = getplayer(ref);
+ if (player == NULL)
+ return 0;
+
+ u32 flags = 0;
+ u32 mask = 0;
+ bool flag;
+
+ const EnumString *esp = es_HudBuiltinElement;
+ for (int i = 0; esp[i].str; i++) {
+ if (getboolfield(L, 2, esp[i].str, flag)) {
+ flags |= esp[i].num * flag;
+ mask |= esp[i].num;
+ }
+ }
+ if (!STACK_TO_SERVER(L)->hudSetFlags(player, flags, mask))
+ return 0;
+
+ lua_pushboolean(L, true);
+ return 1;
+}
+
+// hud_set_hotbar_itemcount(self, hotbar_itemcount)
+int ObjectRef::l_hud_set_hotbar_itemcount(lua_State *L)
+{
+ ObjectRef *ref = checkobject(L, 1);
+ Player *player = getplayer(ref);
+ if (player == NULL)
+ return 0;
+
+ s32 hotbar_itemcount = lua_tonumber(L, 2);
+
+ if (!STACK_TO_SERVER(L)->hudSetHotbarItemcount(player, hotbar_itemcount))
+ return 0;
+
+ lua_pushboolean(L, true);
+ return 1;
+}
+
+ObjectRef::ObjectRef(ServerActiveObject *object):
+ m_object(object)
+{
+ //infostream<<"ObjectRef created for id="<<m_object->getId()<<std::endl;
+}
+
+ObjectRef::~ObjectRef()
+{
+ /*if(m_object)
+ infostream<<"ObjectRef destructing for id="
+ <<m_object->getId()<<std::endl;
+ else
+ infostream<<"ObjectRef destructing for id=unknown"<<std::endl;*/
+}
+
+// Creates an ObjectRef and leaves it on top of stack
+// Not callable from Lua; all references are created on the C side.
+void ObjectRef::create(lua_State *L, ServerActiveObject *object)
+{
+ ObjectRef *o = new ObjectRef(object);
+ //infostream<<"ObjectRef::create: o="<<o<<std::endl;
+ *(void **)(lua_newuserdata(L, sizeof(void *))) = o;
+ luaL_getmetatable(L, className);
+ lua_setmetatable(L, -2);
+}
+
+void ObjectRef::set_null(lua_State *L)
+{
+ ObjectRef *o = checkobject(L, -1);
+ o->m_object = NULL;
+}
+
+void ObjectRef::Register(lua_State *L)
+{
+ lua_newtable(L);
+ int methodtable = lua_gettop(L);
+ luaL_newmetatable(L, className);
+ int metatable = lua_gettop(L);
+
+ lua_pushliteral(L, "__metatable");
+ lua_pushvalue(L, methodtable);
+ lua_settable(L, metatable); // hide metatable from Lua getmetatable()
+
+ lua_pushliteral(L, "__index");
+ lua_pushvalue(L, methodtable);
+ lua_settable(L, metatable);
+
+ lua_pushliteral(L, "__gc");
+ lua_pushcfunction(L, gc_object);
+ lua_settable(L, metatable);
+
+ lua_pop(L, 1); // drop metatable
+
+ luaL_openlib(L, 0, methods, 0); // fill methodtable
+ lua_pop(L, 1); // drop methodtable
+
+ // Cannot be created from Lua
+ //lua_register(L, className, create_object);
+}
+
+const char ObjectRef::className[] = "ObjectRef";
+const luaL_reg ObjectRef::methods[] = {
+ // ServerActiveObject
+ luamethod(ObjectRef, remove),
+ luamethod(ObjectRef, getpos),
+ luamethod(ObjectRef, setpos),
+ luamethod(ObjectRef, moveto),
+ luamethod(ObjectRef, punch),
+ luamethod(ObjectRef, right_click),
+ luamethod(ObjectRef, set_hp),
+ luamethod(ObjectRef, get_hp),
+ luamethod(ObjectRef, get_inventory),
+ luamethod(ObjectRef, get_wield_list),
+ luamethod(ObjectRef, get_wield_index),
+ luamethod(ObjectRef, get_wielded_item),
+ luamethod(ObjectRef, set_wielded_item),
+ luamethod(ObjectRef, set_armor_groups),
+ luamethod(ObjectRef, set_physics_override),
+ luamethod(ObjectRef, set_animation),
+ luamethod(ObjectRef, set_bone_position),
+ luamethod(ObjectRef, set_attach),
+ luamethod(ObjectRef, set_detach),
+ luamethod(ObjectRef, set_properties),
+ // LuaEntitySAO-only
+ luamethod(ObjectRef, setvelocity),
+ luamethod(ObjectRef, getvelocity),
+ luamethod(ObjectRef, setacceleration),
+ luamethod(ObjectRef, getacceleration),
+ luamethod(ObjectRef, setyaw),
+ luamethod(ObjectRef, getyaw),
+ luamethod(ObjectRef, settexturemod),
+ luamethod(ObjectRef, setsprite),
+ luamethod(ObjectRef, get_entity_name),
+ luamethod(ObjectRef, get_luaentity),
+ // Player-only
+ luamethod(ObjectRef, is_player),
+ luamethod(ObjectRef, get_player_name),
+ luamethod(ObjectRef, get_look_dir),
+ luamethod(ObjectRef, get_look_pitch),
+ luamethod(ObjectRef, get_look_yaw),
+ luamethod(ObjectRef, set_look_yaw),
+ luamethod(ObjectRef, set_look_pitch),
+ luamethod(ObjectRef, set_inventory_formspec),
+ luamethod(ObjectRef, get_inventory_formspec),
+ luamethod(ObjectRef, get_player_control),
+ luamethod(ObjectRef, get_player_control_bits),
+ luamethod(ObjectRef, hud_add),
+ luamethod(ObjectRef, hud_remove),
+ luamethod(ObjectRef, hud_change),
+ luamethod(ObjectRef, hud_get),
+ luamethod(ObjectRef, hud_set_flags),
+ luamethod(ObjectRef, hud_set_hotbar_itemcount),
+ {0,0}
+};
+
+REGISTER_LUA_REF(ObjectRef)
diff --git a/src/script/lua_api/l_object.h b/src/script/lua_api/l_object.h
new file mode 100644
index 000000000..57dac0e64
--- /dev/null
+++ b/src/script/lua_api/l_object.h
@@ -0,0 +1,229 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef L_OBJECT_H_
+#define L_OBJECT_H_
+
+extern "C" {
+#include <lua.h>
+#include <lauxlib.h>
+}
+
+class ServerActiveObject;
+class LuaEntitySAO;
+class PlayerSAO;
+class Player;
+
+/*
+ ObjectRef
+*/
+
+class ObjectRef
+{
+private:
+ ServerActiveObject *m_object;
+
+ static const char className[];
+ static const luaL_reg methods[];
+public:
+ static ObjectRef *checkobject(lua_State *L, int narg);
+
+ static ServerActiveObject* getobject(ObjectRef *ref);
+private:
+ static LuaEntitySAO* getluaobject(ObjectRef *ref);
+
+ static PlayerSAO* getplayersao(ObjectRef *ref);
+
+ static Player* getplayer(ObjectRef *ref);
+
+ // Exported functions
+
+ // garbage collector
+ static int gc_object(lua_State *L);
+
+ // remove(self)
+ static int l_remove(lua_State *L);
+
+ // getpos(self)
+ // returns: {x=num, y=num, z=num}
+ static int l_getpos(lua_State *L);
+
+ // setpos(self, pos)
+ static int l_setpos(lua_State *L);
+
+ // moveto(self, pos, continuous=false)
+ static int l_moveto(lua_State *L);
+
+ // punch(self, puncher, time_from_last_punch, tool_capabilities, dir)
+ static int l_punch(lua_State *L);
+
+ // right_click(self, clicker); clicker = an another ObjectRef
+ static int l_right_click(lua_State *L);
+
+ // set_hp(self, hp)
+ // hp = number of hitpoints (2 * number of hearts)
+ // returns: nil
+ static int l_set_hp(lua_State *L);
+
+ // get_hp(self)
+ // returns: number of hitpoints (2 * number of hearts)
+ // 0 if not applicable to this type of object
+ static int l_get_hp(lua_State *L);
+
+ // get_inventory(self)
+ static int l_get_inventory(lua_State *L);
+
+ // get_wield_list(self)
+ static int l_get_wield_list(lua_State *L);
+
+ // get_wield_index(self)
+ static int l_get_wield_index(lua_State *L);
+
+ // get_wielded_item(self)
+ static int l_get_wielded_item(lua_State *L);
+
+ // set_wielded_item(self, itemstack or itemstring or table or nil)
+ static int l_set_wielded_item(lua_State *L);
+
+ // set_armor_groups(self, groups)
+ static int l_set_armor_groups(lua_State *L);
+
+ // set_physics_override(self, physics_override_speed, physics_override_jump, physics_override_gravity)
+ static int l_set_physics_override(lua_State *L);
+
+ // set_animation(self, frame_range, frame_speed, frame_blend)
+ static int l_set_animation(lua_State *L);
+
+ // set_bone_position(self, std::string bone, v3f position, v3f rotation)
+ static int l_set_bone_position(lua_State *L);
+
+ // set_attach(self, parent, bone, position, rotation)
+ static int l_set_attach(lua_State *L);
+
+ // set_detach(self)
+ static int l_set_detach(lua_State *L);
+
+ // set_properties(self, properties)
+ static int l_set_properties(lua_State *L);
+
+ /* LuaEntitySAO-only */
+
+ // setvelocity(self, {x=num, y=num, z=num})
+ static int l_setvelocity(lua_State *L);
+
+ // getvelocity(self)
+ static int l_getvelocity(lua_State *L);
+
+ // setacceleration(self, {x=num, y=num, z=num})
+ static int l_setacceleration(lua_State *L);
+
+ // getacceleration(self)
+ static int l_getacceleration(lua_State *L);
+
+ // setyaw(self, radians)
+ static int l_setyaw(lua_State *L);
+
+ // getyaw(self)
+ static int l_getyaw(lua_State *L);
+
+ // settexturemod(self, mod)
+ static int l_settexturemod(lua_State *L);
+
+ // setsprite(self, p={x=0,y=0}, num_frames=1, framelength=0.2,
+ // select_horiz_by_yawpitch=false)
+ static int l_setsprite(lua_State *L);
+
+ // DEPRECATED
+ // get_entity_name(self)
+ static int l_get_entity_name(lua_State *L);
+
+ // get_luaentity(self)
+ static int l_get_luaentity(lua_State *L);
+
+ /* Player-only */
+
+ // is_player(self)
+ static int l_is_player(lua_State *L);
+
+ // get_player_name(self)
+ static int l_get_player_name(lua_State *L);
+
+ // get_look_dir(self)
+ static int l_get_look_dir(lua_State *L);
+
+ // get_look_pitch(self)
+ static int l_get_look_pitch(lua_State *L);
+
+ // get_look_yaw(self)
+ static int l_get_look_yaw(lua_State *L);
+
+ // set_look_pitch(self, radians)
+ static int l_set_look_pitch(lua_State *L);
+
+ // set_look_yaw(self, radians)
+ static int l_set_look_yaw(lua_State *L);
+
+ // set_inventory_formspec(self, formspec)
+ static int l_set_inventory_formspec(lua_State *L);
+
+ // get_inventory_formspec(self) -> formspec
+ static int l_get_inventory_formspec(lua_State *L);
+
+ // get_player_control(self)
+ static int l_get_player_control(lua_State *L);
+
+ // get_player_control_bits(self)
+ static int l_get_player_control_bits(lua_State *L);
+
+ // hud_add(self, id, form)
+ static int l_hud_add(lua_State *L);
+
+ // hud_rm(self, id)
+ static int l_hud_remove(lua_State *L);
+
+ // hud_change(self, id, stat, data)
+ static int l_hud_change(lua_State *L);
+
+ // hud_get_next_id(self)
+ static u32 hud_get_next_id(lua_State *L);
+
+ // hud_get(self, id)
+ static int l_hud_get(lua_State *L);
+
+ // hud_set_flags(self, flags)
+ static int l_hud_set_flags(lua_State *L);
+
+ // hud_set_hotbar_itemcount(self, hotbar_itemcount)
+ static int l_hud_set_hotbar_itemcount(lua_State *L);
+
+public:
+ ObjectRef(ServerActiveObject *object);
+
+ ~ObjectRef();
+
+ // Creates an ObjectRef and leaves it on top of stack
+ // Not callable from Lua; all references are created on the C side.
+ static void create(lua_State *L, ServerActiveObject *object);
+
+ static void set_null(lua_State *L);
+
+ static void Register(lua_State *L);
+};
+
+#endif /* L_OBJECT_H_ */
diff --git a/src/script/lua_api/l_particles.cpp b/src/script/lua_api/l_particles.cpp
new file mode 100644
index 000000000..c291cc21e
--- /dev/null
+++ b/src/script/lua_api/l_particles.cpp
@@ -0,0 +1,149 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "cpp_api/scriptapi.h"
+#include "common/c_converter.h"
+#include "lua_api/l_base.h"
+#include "lua_api/l_particles.h"
+#include "server.h"
+#include "common/c_internal.h"
+
+bool ModApiParticles::Initialize(lua_State *L, int top) {
+ bool retval = true;
+
+ retval &= API_FCT(add_particle);
+ retval &= API_FCT(add_particlespawner);
+ retval &= API_FCT(delete_particlespawner);
+
+ return retval;
+}
+
+// add_particle(pos, velocity, acceleration, expirationtime,
+// size, collisiondetection, texture, player)
+// pos/velocity/acceleration = {x=num, y=num, z=num}
+// expirationtime = num (seconds)
+// size = num
+// texture = e.g."default_wood.png"
+int ModApiParticles::l_add_particle(lua_State *L)
+{
+ // Get parameters
+ v3f pos = check_v3f(L, 1);
+ v3f vel = check_v3f(L, 2);
+ v3f acc = check_v3f(L, 3);
+ float expirationtime = luaL_checknumber(L, 4);
+ float size = luaL_checknumber(L, 5);
+ bool collisiondetection = lua_toboolean(L, 6);
+ std::string texture = luaL_checkstring(L, 7);
+
+ if (lua_gettop(L) == 8) // only spawn for a single player
+ {
+ const char *playername = luaL_checkstring(L, 8);
+ getServer(L)->spawnParticle(playername,
+ pos, vel, acc, expirationtime,
+ size, collisiondetection, texture);
+ }
+ else // spawn for all players
+ {
+ getServer(L)->spawnParticleAll(pos, vel, acc,
+ expirationtime, size, collisiondetection, texture);
+ }
+ return 1;
+}
+
+// add_particlespawner(amount, time,
+// minpos, maxpos,
+// minvel, maxvel,
+// minacc, maxacc,
+// minexptime, maxexptime,
+// minsize, maxsize,
+// collisiondetection,
+// texture,
+// player)
+// minpos/maxpos/minvel/maxvel/minacc/maxacc = {x=num, y=num, z=num}
+// minexptime/maxexptime = num (seconds)
+// minsize/maxsize = num
+// collisiondetection = bool
+// texture = e.g."default_wood.png"
+int ModApiParticles::l_add_particlespawner(lua_State *L)
+{
+ // Get parameters
+ u16 amount = luaL_checknumber(L, 1);
+ float time = luaL_checknumber(L, 2);
+ v3f minpos = check_v3f(L, 3);
+ v3f maxpos = check_v3f(L, 4);
+ v3f minvel = check_v3f(L, 5);
+ v3f maxvel = check_v3f(L, 6);
+ v3f minacc = check_v3f(L, 7);
+ v3f maxacc = check_v3f(L, 8);
+ float minexptime = luaL_checknumber(L, 9);
+ float maxexptime = luaL_checknumber(L, 10);
+ float minsize = luaL_checknumber(L, 11);
+ float maxsize = luaL_checknumber(L, 12);
+ bool collisiondetection = lua_toboolean(L, 13);
+ std::string texture = luaL_checkstring(L, 14);
+
+ if (lua_gettop(L) == 15) // only spawn for a single player
+ {
+ const char *playername = luaL_checkstring(L, 15);
+ u32 id = getServer(L)->addParticleSpawner(playername,
+ amount, time,
+ minpos, maxpos,
+ minvel, maxvel,
+ minacc, maxacc,
+ minexptime, maxexptime,
+ minsize, maxsize,
+ collisiondetection,
+ texture);
+ lua_pushnumber(L, id);
+ }
+ else // spawn for all players
+ {
+ u32 id = getServer(L)->addParticleSpawnerAll( amount, time,
+ minpos, maxpos,
+ minvel, maxvel,
+ minacc, maxacc,
+ minexptime, maxexptime,
+ minsize, maxsize,
+ collisiondetection,
+ texture);
+ lua_pushnumber(L, id);
+ }
+ return 1;
+}
+
+// delete_particlespawner(id, player)
+// player (string) is optional
+int ModApiParticles::l_delete_particlespawner(lua_State *L)
+{
+ // Get parameters
+ u32 id = luaL_checknumber(L, 1);
+
+ if (lua_gettop(L) == 2) // only delete for one player
+ {
+ const char *playername = luaL_checkstring(L, 2);
+ getServer(L)->deleteParticleSpawner(playername, id);
+ }
+ else // delete for all players
+ {
+ getServer(L)->deleteParticleSpawnerAll(id);
+ }
+ return 1;
+}
+
+ModApiParticles modapiparticles_prototyp;
diff --git a/src/script/lua_api/l_particles.h b/src/script/lua_api/l_particles.h
new file mode 100644
index 000000000..3729f8761
--- /dev/null
+++ b/src/script/lua_api/l_particles.h
@@ -0,0 +1,39 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef L_PARTICLES_H_
+#define L_PARTICLES_H_
+
+extern "C" {
+#include <lua.h>
+#include <lauxlib.h>
+}
+
+class ModApiParticles : public ModApiBase {
+public:
+ bool Initialize(lua_State *L, int top);
+private:
+ static int l_add_particle(lua_State *L);
+ static int l_add_particlespawner(lua_State *L);
+ static int l_delete_particlespawner(lua_State *L);
+};
+
+
+
+#endif // L_PARTICLES_H_
diff --git a/src/script/lua_api/luaapi.cpp b/src/script/lua_api/luaapi.cpp
new file mode 100644
index 000000000..b75304b3a
--- /dev/null
+++ b/src/script/lua_api/luaapi.cpp
@@ -0,0 +1,653 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+extern "C" {
+#include "lua.h"
+#include "lauxlib.h"
+}
+
+#include "lua_api/l_base.h"
+#include "common/c_internal.h"
+#include "server.h"
+#include "common/c_converter.h"
+#include "common/c_content.h"
+#include "lua_api/luaapi.h"
+#include "settings.h"
+#include "tool.h"
+#include "rollback.h"
+#include "log.h"
+#include "emerge.h"
+#include "main.h" //required for g_settings
+
+struct EnumString ModApiBasic::es_OreType[] =
+{
+ {ORE_SCATTER, "scatter"},
+ {ORE_SHEET, "sheet"},
+ {ORE_CLAYLIKE, "claylike"},
+ {0, NULL},
+};
+
+
+ModApiBasic::ModApiBasic() : ModApiBase() {
+}
+
+bool ModApiBasic::Initialize(lua_State* L,int top) {
+
+ bool retval = true;
+
+ retval &= API_FCT(debug);
+ retval &= API_FCT(log);
+ retval &= API_FCT(request_shutdown);
+ retval &= API_FCT(get_server_status);
+
+ retval &= API_FCT(register_biome);
+
+ retval &= API_FCT(setting_set);
+ retval &= API_FCT(setting_get);
+ retval &= API_FCT(setting_getbool);
+ retval &= API_FCT(setting_save);
+
+ retval &= API_FCT(chat_send_all);
+ retval &= API_FCT(chat_send_player);
+ retval &= API_FCT(show_formspec);
+
+ retval &= API_FCT(get_player_privs);
+ retval &= API_FCT(get_player_ip);
+ retval &= API_FCT(get_ban_list);
+ retval &= API_FCT(get_ban_description);
+ retval &= API_FCT(ban_player);
+ retval &= API_FCT(unban_player_of_ip);
+ retval &= API_FCT(get_password_hash);
+ retval &= API_FCT(notify_authentication_modified);
+
+ retval &= API_FCT(get_dig_params);
+ retval &= API_FCT(get_hit_params);
+
+ retval &= API_FCT(get_current_modname);
+ retval &= API_FCT(get_modpath);
+ retval &= API_FCT(get_modnames);
+
+ retval &= API_FCT(get_worldpath);
+ retval &= API_FCT(is_singleplayer);
+ retval &= API_FCT(sound_play);
+ retval &= API_FCT(sound_stop);
+
+ retval &= API_FCT(rollback_get_last_node_actor);
+ retval &= API_FCT(rollback_revert_actions_by);
+
+ retval &= API_FCT(register_ore);
+
+ return retval;
+}
+
+// debug(text)
+// Writes a line to dstream
+int ModApiBasic::l_debug(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ std::string text = lua_tostring(L, 1);
+ dstream << text << std::endl;
+ return 0;
+}
+
+// log([level,] text)
+// Writes a line to the logger.
+// The one-argument version logs to infostream.
+// The two-argument version accept a log level: error, action, info, or verbose.
+int ModApiBasic::l_log(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ std::string text;
+ LogMessageLevel level = LMT_INFO;
+ if(lua_isnone(L, 2))
+ {
+ text = lua_tostring(L, 1);
+ }
+ else
+ {
+ std::string levelname = luaL_checkstring(L, 1);
+ text = luaL_checkstring(L, 2);
+ if(levelname == "error")
+ level = LMT_ERROR;
+ else if(levelname == "action")
+ level = LMT_ACTION;
+ else if(levelname == "verbose")
+ level = LMT_VERBOSE;
+ }
+ log_printline(level, text);
+ return 0;
+}
+
+// request_shutdown()
+int ModApiBasic::l_request_shutdown(lua_State *L)
+{
+ getServer(L)->requestShutdown();
+ return 0;
+}
+
+// get_server_status()
+int ModApiBasic::l_get_server_status(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ lua_pushstring(L, wide_to_narrow(getServer(L)->getStatusString()).c_str());
+ return 1;
+}
+
+// register_biome({lots of stuff})
+int ModApiBasic::l_register_biome(lua_State *L)
+{
+ int index = 1;
+ luaL_checktype(L, index, LUA_TTABLE);
+
+ BiomeDefManager *bmgr = getServer(L)->getEmergeManager()->biomedef;
+ if (!bmgr) {
+ verbosestream << "register_biome: BiomeDefManager not active" << std::endl;
+ return 0;
+ }
+
+ enum BiomeTerrainType terrain = (BiomeTerrainType)getenumfield(L, index,
+ "terrain_type", es_BiomeTerrainType, BIOME_TERRAIN_NORMAL);
+ Biome *b = bmgr->createBiome(terrain);
+
+ b->name = getstringfield_default(L, index, "name", "");
+ b->top_nodename = getstringfield_default(L, index, "top_node", "");
+ b->top_depth = getintfield_default(L, index, "top_depth", 0);
+ b->filler_nodename = getstringfield_default(L, index, "filler_node", "");
+ b->filler_height = getintfield_default(L, index, "filler_height", 0);
+ b->height_min = getintfield_default(L, index, "height_min", 0);
+ b->height_max = getintfield_default(L, index, "height_max", 0);
+ b->heat_point = getfloatfield_default(L, index, "heat_point", 0.);
+ b->humidity_point = getfloatfield_default(L, index, "humidity_point", 0.);
+
+ b->flags = 0; //reserved
+ b->c_top = CONTENT_IGNORE;
+ b->c_filler = CONTENT_IGNORE;
+ bmgr->addBiome(b);
+
+ verbosestream << "register_biome: " << b->name << std::endl;
+ return 0;
+}
+
+
+
+// setting_set(name, value)
+int ModApiBasic::l_setting_set(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ const char *name = luaL_checkstring(L, 1);
+ const char *value = luaL_checkstring(L, 2);
+ g_settings->set(name, value);
+ return 0;
+}
+
+// setting_get(name)
+int ModApiBasic::l_setting_get(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ const char *name = luaL_checkstring(L, 1);
+ try{
+ std::string value = g_settings->get(name);
+ lua_pushstring(L, value.c_str());
+ } catch(SettingNotFoundException &e){
+ lua_pushnil(L);
+ }
+ return 1;
+}
+
+// setting_getbool(name)
+int ModApiBasic::l_setting_getbool(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ const char *name = luaL_checkstring(L, 1);
+ try{
+ bool value = g_settings->getBool(name);
+ lua_pushboolean(L, value);
+ } catch(SettingNotFoundException &e){
+ lua_pushnil(L);
+ }
+ return 1;
+}
+
+// setting_save()
+int ModApiBasic::l_setting_save(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ getServer(L)->saveConfig();
+ return 0;
+}
+
+// chat_send_all(text)
+int ModApiBasic::l_chat_send_all(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ const char *text = luaL_checkstring(L, 1);
+ // Get server from registry
+ Server *server = getServer(L);
+ // Send
+ server->notifyPlayers(narrow_to_wide(text));
+ return 0;
+}
+
+// chat_send_player(name, text, prepend)
+int ModApiBasic::l_chat_send_player(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ const char *name = luaL_checkstring(L, 1);
+ const char *text = luaL_checkstring(L, 2);
+ bool prepend = true;
+
+ if (lua_isboolean(L, 3))
+ prepend = lua_toboolean(L, 3);
+
+ // Get server from registry
+ Server *server = getServer(L);
+ // Send
+ server->notifyPlayer(name, narrow_to_wide(text), prepend);
+ return 0;
+}
+
+// get_player_privs(name, text)
+int ModApiBasic::l_get_player_privs(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ const char *name = luaL_checkstring(L, 1);
+ // Get server from registry
+ Server *server = getServer(L);
+ // Do it
+ 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++){
+ lua_pushboolean(L, true);
+ lua_setfield(L, table, i->c_str());
+ }
+ lua_pushvalue(L, table);
+ return 1;
+}
+
+// get_player_ip()
+int ModApiBasic::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)
+ {
+ lua_pushnil(L); // no such player
+ return 1;
+ }
+ try
+ {
+ Address addr = getServer(L)->getPeerAddress(getEnv(L)->getPlayer(name)->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;
+ }
+}
+
+// get_ban_list()
+int ModApiBasic::l_get_ban_list(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ lua_pushstring(L, getServer(L)->getBanDescription("").c_str());
+ return 1;
+}
+
+// get_ban_description()
+int ModApiBasic::l_get_ban_description(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ const char * ip_or_name = luaL_checkstring(L, 1);
+ lua_pushstring(L, getServer(L)->getBanDescription(std::string(ip_or_name)).c_str());
+ return 1;
+}
+
+// ban_player()
+int ModApiBasic::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)
+ {
+ 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;
+ }
+ lua_pushboolean(L, true);
+ return 1;
+}
+
+// unban_player_or_ip()
+int ModApiBasic::l_unban_player_of_ip(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ const char * ip_or_name = luaL_checkstring(L, 1);
+ getServer(L)->unsetIpBanned(ip_or_name);
+ lua_pushboolean(L, true);
+ return 1;
+}
+
+// show_formspec(playername,formname,formspec)
+int ModApiBasic::l_show_formspec(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ const char *playername = luaL_checkstring(L, 1);
+ const char *formname = luaL_checkstring(L, 2);
+ const char *formspec = luaL_checkstring(L, 3);
+
+ if(getServer(L)->showFormspec(playername,formspec,formname))
+ {
+ lua_pushboolean(L, true);
+ }else{
+ lua_pushboolean(L, false);
+ }
+ return 1;
+}
+
+// get_dig_params(groups, tool_capabilities[, time_from_last_punch])
+int ModApiBasic::l_get_dig_params(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ std::map<std::string, int> groups;
+ read_groups(L, 1, groups);
+ ToolCapabilities tp = read_tool_capabilities(L, 2);
+ if(lua_isnoneornil(L, 3))
+ push_dig_params(L, getDigParams(groups, &tp));
+ else
+ push_dig_params(L, getDigParams(groups, &tp,
+ luaL_checknumber(L, 3)));
+ return 1;
+}
+
+// get_hit_params(groups, tool_capabilities[, time_from_last_punch])
+int ModApiBasic::l_get_hit_params(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ std::map<std::string, int> groups;
+ read_groups(L, 1, groups);
+ ToolCapabilities tp = read_tool_capabilities(L, 2);
+ if(lua_isnoneornil(L, 3))
+ push_hit_params(L, getHitParams(groups, &tp));
+ else
+ push_hit_params(L, getHitParams(groups, &tp,
+ luaL_checknumber(L, 3)));
+ return 1;
+}
+
+// get_current_modname()
+int ModApiBasic::l_get_current_modname(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ lua_getfield(L, LUA_REGISTRYINDEX, "minetest_current_modname");
+ return 1;
+}
+
+// get_modpath(modname)
+int ModApiBasic::l_get_modpath(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ std::string modname = luaL_checkstring(L, 1);
+ // Do it
+ if(modname == "__builtin"){
+ std::string path = getServer(L)->getBuiltinLuaPath();
+ lua_pushstring(L, path.c_str());
+ return 1;
+ }
+ const ModSpec *mod = getServer(L)->getModSpec(modname);
+ if(!mod){
+ lua_pushnil(L);
+ return 1;
+ }
+ lua_pushstring(L, mod->path.c_str());
+ return 1;
+}
+
+// get_modnames()
+// the returned list is sorted alphabetically for you
+int ModApiBasic::l_get_modnames(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ // Get a list of mods
+ std::list<std::string> mods_unsorted, mods_sorted;
+ getServer(L)->getModNames(mods_unsorted);
+
+ // 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.
+ for(std::list<std::string>::iterator i = mods_unsorted.begin();
+ i != mods_unsorted.end(); ++i)
+ {
+ bool added = false;
+ for(std::list<std::string>::iterator x = mods_sorted.begin();
+ x != mods_sorted.end(); ++x)
+ {
+ // I doubt anybody using Minetest will be using
+ // anything not ASCII based :)
+ if((*i).compare(*x) <= 0)
+ {
+ mods_sorted.insert(x, *i);
+ added = true;
+ break;
+ }
+ }
+ if(!added)
+ mods_sorted.push_back(*i);
+ }
+
+ // Get the table insertion function from Lua.
+ lua_getglobal(L, "table");
+ lua_getfield(L, -1, "insert");
+ int insertion_func = lua_gettop(L);
+
+ // Package them up for Lua
+ lua_newtable(L);
+ int new_table = lua_gettop(L);
+ std::list<std::string>::iterator i = mods_sorted.begin();
+ while(i != mods_sorted.end())
+ {
+ lua_pushvalue(L, insertion_func);
+ lua_pushvalue(L, new_table);
+ lua_pushstring(L, (*i).c_str());
+ if(lua_pcall(L, 2, 0, 0) != 0)
+ {
+ script_error(L, "error: %s", lua_tostring(L, -1));
+ }
+ ++i;
+ }
+ return 1;
+}
+
+// get_worldpath()
+int ModApiBasic::l_get_worldpath(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ std::string worldpath = getServer(L)->getWorldPath();
+ lua_pushstring(L, worldpath.c_str());
+ return 1;
+}
+
+// sound_play(spec, parameters)
+int ModApiBasic::l_sound_play(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ SimpleSoundSpec spec;
+ read_soundspec(L, 1, spec);
+ ServerSoundParams params;
+ read_server_sound_params(L, 2, params);
+ s32 handle = getServer(L)->playSound(spec, params);
+ lua_pushinteger(L, handle);
+ return 1;
+}
+
+// sound_stop(handle)
+int ModApiBasic::l_sound_stop(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ int handle = luaL_checkinteger(L, 1);
+ getServer(L)->stopSound(handle);
+ return 0;
+}
+
+// is_singleplayer()
+int ModApiBasic::l_is_singleplayer(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ lua_pushboolean(L, getServer(L)->isSingleplayer());
+ return 1;
+}
+
+// get_password_hash(name, raw_password)
+int ModApiBasic::l_get_password_hash(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ std::string name = luaL_checkstring(L, 1);
+ std::string raw_password = luaL_checkstring(L, 2);
+ std::string hash = translatePassword(name,
+ narrow_to_wide(raw_password));
+ lua_pushstring(L, hash.c_str());
+ return 1;
+}
+
+// notify_authentication_modified(name)
+int ModApiBasic::l_notify_authentication_modified(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+ std::string name = "";
+ if(lua_isstring(L, 1))
+ name = lua_tostring(L, 1);
+ getServer(L)->reportPrivsModified(name);
+ return 0;
+}
+
+// rollback_get_last_node_actor(p, range, seconds) -> actor, p, seconds
+int ModApiBasic::l_rollback_get_last_node_actor(lua_State *L)
+{
+ v3s16 p = read_v3s16(L, 1);
+ int range = luaL_checknumber(L, 2);
+ int seconds = luaL_checknumber(L, 3);
+ Server *server = getServer(L);
+ IRollbackManager *rollback = server->getRollbackManager();
+ v3s16 act_p;
+ int act_seconds = 0;
+ std::string actor = rollback->getLastNodeActor(p, range, seconds, &act_p, &act_seconds);
+ lua_pushstring(L, actor.c_str());
+ push_v3s16(L, act_p);
+ lua_pushnumber(L, act_seconds);
+ return 3;
+}
+
+// rollback_revert_actions_by(actor, seconds) -> bool, log messages
+int ModApiBasic::l_rollback_revert_actions_by(lua_State *L)
+{
+ std::string actor = luaL_checkstring(L, 1);
+ int seconds = luaL_checknumber(L, 2);
+ Server *server = getServer(L);
+ IRollbackManager *rollback = server->getRollbackManager();
+ std::list<RollbackAction> actions = rollback->getRevertActions(actor, seconds);
+ std::list<std::string> log;
+ bool success = server->rollbackRevertActions(actions, &log);
+ // Push boolean result
+ lua_pushboolean(L, success);
+ // Get the table insert function and push the log table
+ lua_getglobal(L, "table");
+ lua_getfield(L, -1, "insert");
+ int table_insert = lua_gettop(L);
+ lua_newtable(L);
+ int table = lua_gettop(L);
+ for(std::list<std::string>::const_iterator i = log.begin();
+ i != log.end(); i++)
+ {
+ lua_pushvalue(L, table_insert);
+ lua_pushvalue(L, table);
+ lua_pushstring(L, i->c_str());
+ if(lua_pcall(L, 2, 0, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
+ }
+ lua_remove(L, -2); // Remove table
+ lua_remove(L, -2); // Remove insert
+ return 2;
+}
+
+int ModApiBasic::l_register_ore(lua_State *L)
+{
+ int index = 1;
+ luaL_checktype(L, index, LUA_TTABLE);
+
+ EmergeManager *emerge = getServer(L)->getEmergeManager();
+
+ enum OreType oretype = (OreType)getenumfield(L, index,
+ "ore_type", es_OreType, ORE_SCATTER);
+ Ore *ore = createOre(oretype);
+ if (!ore) {
+ errorstream << "register_ore: ore_type "
+ << oretype << " not implemented";
+ return 0;
+ }
+
+ ore->ore_name = getstringfield_default(L, index, "ore", "");
+ ore->ore_param2 = (u8)getintfield_default(L, index, "ore_param2", 0);
+ ore->wherein_name = getstringfield_default(L, index, "wherein", "");
+ ore->clust_scarcity = getintfield_default(L, index, "clust_scarcity", 1);
+ ore->clust_num_ores = getintfield_default(L, index, "clust_num_ores", 1);
+ ore->clust_size = getintfield_default(L, index, "clust_size", 0);
+ ore->height_min = getintfield_default(L, index, "height_min", 0);
+ ore->height_max = getintfield_default(L, index, "height_max", 0);
+ ore->flags = getflagsfield(L, index, "flags", flagdesc_ore);
+ ore->nthresh = getfloatfield_default(L, index, "noise_threshhold", 0.);
+
+ lua_getfield(L, index, "noise_params");
+ ore->np = read_noiseparams(L, -1);
+ lua_pop(L, 1);
+
+ ore->noise = NULL;
+
+ if (ore->clust_scarcity <= 0 || ore->clust_num_ores <= 0) {
+ errorstream << "register_ore: clust_scarcity and clust_num_ores"
+ "must be greater than 0" << std::endl;
+ delete ore;
+ return 0;
+ }
+
+ emerge->ores.push_back(ore);
+
+ verbosestream << "register_ore: ore '" << ore->ore_name
+ << "' registered" << std::endl;
+ return 0;
+}
+
+ModApiBasic modapibasic_prototype;
diff --git a/src/script/lua_api/luaapi.h b/src/script/lua_api/luaapi.h
new file mode 100644
index 000000000..592046965
--- /dev/null
+++ b/src/script/lua_api/luaapi.h
@@ -0,0 +1,140 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef LUAAPI_H_
+#define LUAAPI_H_
+
+
+class ModApiBasic : public ModApiBase {
+
+public:
+ ModApiBasic();
+
+ bool Initialize(lua_State* L,int top);
+
+private:
+ // debug(text)
+ // Writes a line to dstream
+ static int l_debug(lua_State *L);
+
+ // log([level,] text)
+ // Writes a line to the logger.
+ // The one-argument version logs to infostream.
+ // The two-argument version accept a log level: error, action, info, or verbose.
+ static int l_log(lua_State *L);
+
+ // request_shutdown()
+ static int l_request_shutdown(lua_State *L);
+
+ // get_server_status()
+ static int l_get_server_status(lua_State *L);
+
+ // register_biome_groups({frequencies})
+ static int l_register_biome_groups(lua_State *L);
+
+ // register_biome({lots of stuff})
+ static int l_register_biome(lua_State *L);
+
+ // setting_set(name, value)
+ static int l_setting_set(lua_State *L);
+
+ // setting_get(name)
+ static int l_setting_get(lua_State *L);
+
+ // setting_getbool(name)
+ static int l_setting_getbool(lua_State *L);
+
+ // setting_save()
+ static int l_setting_save(lua_State *L);
+
+ // chat_send_all(text)
+ static int l_chat_send_all(lua_State *L);
+
+ // chat_send_player(name, text)
+ static int l_chat_send_player(lua_State *L);
+
+ // get_player_privs(name, text)
+ static int l_get_player_privs(lua_State *L);
+
+ // get_player_ip()
+ static int l_get_player_ip(lua_State *L);
+
+ // get_ban_list()
+ static int l_get_ban_list(lua_State *L);
+
+ // get_ban_description()
+ static int l_get_ban_description(lua_State *L);
+
+ // ban_player()
+ static int l_ban_player(lua_State *L);
+
+ // unban_player_or_ip()
+ static int l_unban_player_of_ip(lua_State *L);
+
+ // show_formspec(playername,formname,formspec)
+ static int l_show_formspec(lua_State *L);
+
+ // get_dig_params(groups, tool_capabilities[, time_from_last_punch])
+ static int l_get_dig_params(lua_State *L);
+
+ // get_hit_params(groups, tool_capabilities[, time_from_last_punch])
+ static int l_get_hit_params(lua_State *L);
+
+ // get_current_modname()
+ static int l_get_current_modname(lua_State *L);
+
+ // get_modpath(modname)
+ static int l_get_modpath(lua_State *L);
+
+ // get_modnames()
+ // the returned list is sorted alphabetically for you
+ static int l_get_modnames(lua_State *L);
+
+ // get_worldpath()
+ static int l_get_worldpath(lua_State *L);
+
+ // sound_play(spec, parameters)
+ static int l_sound_play(lua_State *L);
+
+ // sound_stop(handle)
+ static int l_sound_stop(lua_State *L);
+
+ // is_singleplayer()
+ static int l_is_singleplayer(lua_State *L);
+
+ // get_password_hash(name, raw_password)
+ static int l_get_password_hash(lua_State *L);
+
+ // notify_authentication_modified(name)
+ static int l_notify_authentication_modified(lua_State *L);
+
+ // rollback_get_last_node_actor(p, range, seconds) -> actor, p, seconds
+ static int l_rollback_get_last_node_actor(lua_State *L);
+
+ // rollback_revert_actions_by(actor, seconds) -> bool, log messages
+ static int l_rollback_revert_actions_by(lua_State *L);
+
+ static int l_register_ore(lua_State *L);
+
+ static struct EnumString es_OreType[];
+};
+
+
+
+#endif /* LUAAPI_H_ */