#include "nodemetadata.h"
#include "mapblock.h" // For getNodeBlockPos
#include "content_nodemeta.h"
-#include "utility.h"
#include "tool.h"
#include "daynightratio.h"
#include "noise.h" // PseudoRandom for LuaPseudoRandom
+#include "util/pointedthing.h"
+#include "rollback.h"
static void stackDump(lua_State *L, std::ostream &o)
{
{NDT_PLANTLIKE, "plantlike"},
{NDT_FENCELIKE, "fencelike"},
{NDT_RAILLIKE, "raillike"},
+ {NDT_NODEBOX, "nodebox"},
{0, NULL},
};
{0, NULL},
};
+struct EnumString es_TileAnimationType[] =
+{
+ {TAT_NONE, "none"},
+ {TAT_VERTICAL_FRAMES, "vertical_frames"},
+ {0, NULL},
+};
+
/*
C struct <-> Lua table converter functions
*/
return color;
}
-static core::aabbox3d<f32> read_aabbox3df32(lua_State *L, int index, f32 scale)
+static aabb3f read_aabb3f(lua_State *L, int index, f32 scale)
{
- core::aabbox3d<f32> box;
- if(lua_istable(L, -1)){
- lua_rawgeti(L, -1, 1);
+ aabb3f box;
+ if(lua_istable(L, index)){
+ lua_rawgeti(L, index, 1);
box.MinEdge.X = lua_tonumber(L, -1) * scale;
lua_pop(L, 1);
- lua_rawgeti(L, -1, 2);
+ lua_rawgeti(L, index, 2);
box.MinEdge.Y = lua_tonumber(L, -1) * scale;
lua_pop(L, 1);
- lua_rawgeti(L, -1, 3);
+ lua_rawgeti(L, index, 3);
box.MinEdge.Z = lua_tonumber(L, -1) * scale;
lua_pop(L, 1);
- lua_rawgeti(L, -1, 4);
+ lua_rawgeti(L, index, 4);
box.MaxEdge.X = lua_tonumber(L, -1) * scale;
lua_pop(L, 1);
- lua_rawgeti(L, -1, 5);
+ lua_rawgeti(L, index, 5);
box.MaxEdge.Y = lua_tonumber(L, -1) * scale;
lua_pop(L, 1);
- lua_rawgeti(L, -1, 6);
+ lua_rawgeti(L, index, 6);
box.MaxEdge.Z = lua_tonumber(L, -1) * scale;
lua_pop(L, 1);
}
return box;
}
-#if 0
-/*
- MaterialProperties
-*/
+static std::vector<aabb3f> read_aabb3f_vector(lua_State *L, int index, f32 scale)
+{
+ std::vector<aabb3f> boxes;
+ if(lua_istable(L, index)){
+ int n = lua_objlen(L, index);
+ // Check if it's a single box or a list of boxes
+ bool possibly_single_box = (n == 6);
+ for(int i = 1; i <= n && possibly_single_box; i++){
+ lua_rawgeti(L, index, i);
+ if(!lua_isnumber(L, -1))
+ possibly_single_box = false;
+ lua_pop(L, 1);
+ }
+ if(possibly_single_box){
+ // Read a single box
+ boxes.push_back(read_aabb3f(L, index, scale));
+ } else {
+ // Read a list of boxes
+ for(int i = 1; i <= n; i++){
+ lua_rawgeti(L, index, i);
+ boxes.push_back(read_aabb3f(L, -1, scale));
+ lua_pop(L, 1);
+ }
+ }
+ }
+ return boxes;
+}
-static MaterialProperties read_material_properties(
- lua_State *L, int table)
+static NodeBox read_nodebox(lua_State *L, int index)
{
- MaterialProperties prop;
- prop.diggability = (Diggability)getenumfield(L, -1, "diggability",
- es_Diggability, DIGGABLE_NORMAL);
- getfloatfield(L, -1, "constant_time", prop.constant_time);
- getfloatfield(L, -1, "weight", prop.weight);
- getfloatfield(L, -1, "crackiness", prop.crackiness);
- getfloatfield(L, -1, "crumbliness", prop.crumbliness);
- getfloatfield(L, -1, "cuttability", prop.cuttability);
- getfloatfield(L, -1, "flammability", prop.flammability);
- return prop;
+ NodeBox nodebox;
+ if(lua_istable(L, -1)){
+ nodebox.type = (NodeBoxType)getenumfield(L, index, "type",
+ es_NodeBoxType, NODEBOX_REGULAR);
+
+ lua_getfield(L, index, "fixed");
+ if(lua_istable(L, -1))
+ nodebox.fixed = read_aabb3f_vector(L, -1, BS);
+ lua_pop(L, 1);
+
+ lua_getfield(L, index, "wall_top");
+ if(lua_istable(L, -1))
+ nodebox.wall_top = read_aabb3f(L, -1, BS);
+ lua_pop(L, 1);
+
+ lua_getfield(L, index, "wall_bottom");
+ if(lua_istable(L, -1))
+ nodebox.wall_bottom = read_aabb3f(L, -1, BS);
+ lua_pop(L, 1);
+
+ lua_getfield(L, index, "wall_side");
+ if(lua_istable(L, -1))
+ nodebox.wall_side = read_aabb3f(L, -1, BS);
+ lua_pop(L, 1);
+ }
+ return nodebox;
}
-#endif
/*
Groups
static void read_groups(lua_State *L, int index,
std::map<std::string, int> &result)
{
+ if (!lua_istable(L,index))
+ return;
result.clear();
lua_pushnil(L);
if(index < 0)
lua_getfield(L, -1, "collisionbox");
if(lua_istable(L, -1))
- prop->collisionbox = read_aabbox3df32(L, -1, 1.0);
+ prop->collisionbox = read_aabb3f(L, -1, 1.0);
lua_pop(L, 1);
getstringfield(L, -1, "visual", prop->visual);
ItemDefinition
*/
-static ItemDefinition read_item_definition(lua_State *L, int index)
+static ItemDefinition read_item_definition(lua_State *L, int index,
+ ItemDefinition default_def = ItemDefinition())
{
if(index < 0)
index = lua_gettop(L) + 1 + index;
// Read the item definition
- ItemDefinition def;
+ ItemDefinition def = default_def;
def.type = (ItemType)getenumfield(L, index, "type",
es_ItemType, ITEM_NONE);
read_groups(L, -1, def.groups);
lua_pop(L, 1);
+ // Client shall immediately place this node when player places the item.
+ // Server will update the precise end result a moment later.
+ // "" = no prediction
+ getstringfield(L, index, "node_placement_prediction",
+ def.node_placement_prediction);
+
return def;
}
+/*
+ TileDef
+*/
+
+static TileDef read_tiledef(lua_State *L, int index)
+{
+ if(index < 0)
+ index = lua_gettop(L) + 1 + index;
+
+ TileDef tiledef;
+
+ // key at index -2 and value at index
+ if(lua_isstring(L, index)){
+ // "default_lava.png"
+ tiledef.name = lua_tostring(L, index);
+ }
+ else if(lua_istable(L, index))
+ {
+ // {name="default_lava.png", animation={}}
+ tiledef.name = "";
+ getstringfield(L, index, "name", tiledef.name);
+ getstringfield(L, index, "image", tiledef.name); // MaterialSpec compat.
+ tiledef.backface_culling = getboolfield_default(
+ L, index, "backface_culling", true);
+ // animation = {}
+ lua_getfield(L, index, "animation");
+ if(lua_istable(L, -1)){
+ // {type="vertical_frames", aspect_w=16, aspect_h=16, length=2.0}
+ tiledef.animation.type = (TileAnimationType)
+ getenumfield(L, -1, "type", es_TileAnimationType,
+ TAT_NONE);
+ tiledef.animation.aspect_w =
+ getintfield_default(L, -1, "aspect_w", 16);
+ tiledef.animation.aspect_h =
+ getintfield_default(L, -1, "aspect_h", 16);
+ tiledef.animation.length =
+ getfloatfield_default(L, -1, "length", 1.0);
+ }
+ lua_pop(L, 1);
+ }
+
+ return tiledef;
+}
+
/*
ContentFeatures
*/
index = lua_gettop(L) + 1 + index;
ContentFeatures f;
+
+ /* Cache existence of some callbacks */
+ lua_getfield(L, index, "on_construct");
+ if(!lua_isnil(L, -1)) f.has_on_construct = true;
+ lua_pop(L, 1);
+ lua_getfield(L, index, "on_destruct");
+ if(!lua_isnil(L, -1)) f.has_on_destruct = true;
+ lua_pop(L, 1);
+ lua_getfield(L, index, "after_destruct");
+ if(!lua_isnil(L, -1)) f.has_after_destruct = true;
+ lua_pop(L, 1);
+
/* Name */
getstringfield(L, index, "name", f.name);
f.drawtype = (NodeDrawType)getenumfield(L, index, "drawtype", es_DrawType,
NDT_NORMAL);
getfloatfield(L, index, "visual_scale", f.visual_scale);
-
- lua_getfield(L, index, "tile_images");
+
+ // tiles = {}
+ lua_getfield(L, index, "tiles");
+ // If nil, try the deprecated name "tile_images" instead
+ if(lua_isnil(L, -1)){
+ lua_pop(L, 1);
+ warn_if_field_exists(L, index, "tile_images",
+ "Deprecated; new name is \"tiles\".");
+ lua_getfield(L, index, "tile_images");
+ }
if(lua_istable(L, -1)){
int table = lua_gettop(L);
lua_pushnil(L);
int i = 0;
while(lua_next(L, table) != 0){
- // key at index -2 and value at index -1
- if(lua_isstring(L, -1))
- f.tname_tiles[i] = lua_tostring(L, -1);
- else
- f.tname_tiles[i] = "";
+ // Read tiledef from value
+ f.tiledef[i] = read_tiledef(L, -1);
// removes value, keeps key for next iteration
lua_pop(L, 1);
i++;
}
// Copy last value to all remaining textures
if(i >= 1){
- std::string lastname = f.tname_tiles[i-1];
+ TileDef lasttile = f.tiledef[i-1];
while(i < 6){
- f.tname_tiles[i] = lastname;
+ f.tiledef[i] = lasttile;
i++;
}
}
}
lua_pop(L, 1);
-
- lua_getfield(L, index, "special_materials");
+
+ // special_tiles = {}
+ lua_getfield(L, index, "special_tiles");
+ // If nil, try the deprecated name "special_materials" instead
+ if(lua_isnil(L, -1)){
+ lua_pop(L, 1);
+ warn_if_field_exists(L, index, "special_materials",
+ "Deprecated; new name is \"special_tiles\".");
+ lua_getfield(L, index, "special_materials");
+ }
if(lua_istable(L, -1)){
int table = lua_gettop(L);
lua_pushnil(L);
int i = 0;
while(lua_next(L, table) != 0){
- // key at index -2 and value at index -1
- int smtable = lua_gettop(L);
- std::string tname = getstringfield_default(
- L, smtable, "image", "");
- bool backface_culling = getboolfield_default(
- L, smtable, "backface_culling", true);
- MaterialSpec mspec(tname, backface_culling);
- f.mspec_special[i] = mspec;
+ // Read tiledef from value
+ f.tiledef_special[i] = read_tiledef(L, -1);
// removes value, keeps key for next iteration
lua_pop(L, 1);
i++;
f.damage_per_second = getintfield_default(L, index,
"damage_per_second", f.damage_per_second);
- lua_getfield(L, index, "selection_box");
- if(lua_istable(L, -1)){
- f.selection_box.type = (NodeBoxType)getenumfield(L, -1, "type",
- es_NodeBoxType, NODEBOX_REGULAR);
-
- lua_getfield(L, -1, "fixed");
- if(lua_istable(L, -1))
- f.selection_box.fixed = read_aabbox3df32(L, -1, BS);
- lua_pop(L, 1);
-
- lua_getfield(L, -1, "wall_top");
- if(lua_istable(L, -1))
- f.selection_box.wall_top = read_aabbox3df32(L, -1, BS);
- lua_pop(L, 1);
-
- lua_getfield(L, -1, "wall_bottom");
- if(lua_istable(L, -1))
- f.selection_box.wall_bottom = read_aabbox3df32(L, -1, BS);
- lua_pop(L, 1);
-
- lua_getfield(L, -1, "wall_side");
- if(lua_istable(L, -1))
- f.selection_box.wall_side = read_aabbox3df32(L, -1, BS);
- lua_pop(L, 1);
- }
+ lua_getfield(L, index, "node_box");
+ if(lua_istable(L, -1))
+ f.node_box = read_nodebox(L, -1);
lua_pop(L, 1);
+ lua_getfield(L, index, "selection_box");
+ if(lua_istable(L, -1))
+ f.selection_box = read_nodebox(L, -1);
+ lua_pop(L, 1);
+
// Set to true if paramtype used to be 'facedir_simple'
getboolfield(L, index, "legacy_facedir_simple", f.legacy_facedir_simple);
// Set to true if wall_mounted used to be set to true
return 1;
}
+ // get_width(self, listname)
+ static int l_get_width(lua_State *L)
+ {
+ 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)
static int l_set_size(lua_State *L)
{
return 0;
}
+ // set_width(self, listname, size)
+ static int l_set_width(lua_State *L)
+ {
+ 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
static int l_get_stack(lua_State *L)
{
method(InvRef, is_empty),
method(InvRef, get_size),
method(InvRef, set_size),
+ method(InvRef, get_width),
+ method(InvRef, set_width),
method(InvRef, get_stack),
method(InvRef, set_stack),
method(InvRef, get_list),
static void 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;
return 0;
}
- // punch(self, puncher, tool_capabilities, direction, time_from_last_punch)
+ // punch(self, puncher, time_from_last_punch, tool_capabilities, dir)
static int l_punch(lua_State *L)
{
ObjectRef *ref = checkobject(L, 1);
ServerActiveObject *puncher = getobject(puncher_ref);
if(co == NULL) return 0;
if(puncher == NULL) return 0;
- ToolCapabilities toolcap = read_tool_capabilities(L, 3);
- v3f dir = read_v3f(L, 4);
+ 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, 5))
- time_from_last_punch = lua_tonumber(L, 5);
+ if(lua_isnumber(L, 3))
+ time_from_last_punch = lua_tonumber(L, 3);
+ ToolCapabilities toolcap = read_tool_capabilities(L, 4);
+ dir.normalize();
// Do it
- puncher->punch(dir, &toolcap, puncher, time_from_last_punch);
+ co->punch(dir, &toolcap, puncher, time_from_last_punch);
return 0;
}
{
ObjectRef *ref = checkobject(L, 1);
ServerActiveObject *co = getobject(ref);
- if(co == NULL) return 0;
+ 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;*/
if(get_server(L)->getInventory(loc) != NULL)
InvRef::create(L, loc);
else
- lua_pushnil(L);
+ lua_pushnil(L); // An object may have no inventory (nil)
return 1;
}
{
ObjectRef *ref = checkobject(L, 1);
ServerActiveObject *co = getobject(ref);
- if(co == NULL) return 0;
+ if(co == NULL){
+ // Empty ItemStack
+ LuaItemStack::create(L, ItemStack());
+ return 1;
+ }
// Do it
LuaItemStack::create(L, co->getWieldedItem());
return 1;
return 1;
}
+ // set_inventory_formspec(self, formspec)
+ static int l_set_inventory_formspec(lua_State *L)
+ {
+ 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;
+ get_server(L)->reportInventoryFormspecModified(player->getName());
+ lua_pushboolean(L, true);
+ return 1;
+ }
+
+ // get_inventory_formspec(self) -> formspec
+ static int l_get_inventory_formspec(lua_State *L)
+ {
+ 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;
+ }
+
public:
ObjectRef(ServerActiveObject *object):
m_object(object)
method(ObjectRef, get_entity_name),
method(ObjectRef, get_luaentity),
// Player-only
+ method(ObjectRef, is_player),
method(ObjectRef, get_player_name),
method(ObjectRef, get_look_dir),
method(ObjectRef, get_look_pitch),
method(ObjectRef, get_look_yaw),
+ method(ObjectRef, set_inventory_formspec),
+ method(ObjectRef, get_inventory_formspec),
{0,0}
};
-// Creates a new anonymous reference if id=0
+// Creates a new anonymous reference if cobj=NULL or id=0
static void objectref_get_or_create(lua_State *L,
ServerActiveObject *cobj)
{
- if(cobj->getId() == 0){
+ if(cobj == NULL || cobj->getId() == 0){
ObjectRef::create(L, cobj);
} else {
objectref_get(L, cobj->getId());
};
/*
- EnvRef
+ NodeTimerRef
*/
-class EnvRef
+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) {
- EnvRef *o = *(EnvRef **)(lua_touserdata(L, 1));
+ NodeTimerRef *o = *(NodeTimerRef **)(lua_touserdata(L, 1));
delete o;
return 0;
}
- static EnvRef *checkobject(lua_State *L, int narg)
+ static 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 *(EnvRef**)ud; // unbox pointer
+ return *(NodeTimerRef**)ud; // unbox pointer
}
- // Exported functions
-
- // EnvRef:set_node(pos, node)
- // pos = {x=num, y=num, z=num}
- static int l_set_node(lua_State *L)
+ static int l_set(lua_State *L)
{
- //infostream<<"EnvRef::l_set_node()"<<std::endl;
- EnvRef *o = checkobject(L, 1);
+ NodeTimerRef *o = checkobject(L, 1);
ServerEnvironment *env = o->m_env;
if(env == NULL) return 0;
- // pos
- v3s16 pos = read_v3s16(L, 2);
- // content
- MapNode n = readnode(L, 3, env->getGameDef()->ndef());
- // Do it
- // Call destructor
- MapNode n_old = env->getMap().getNodeNoEx(pos);
- scriptapi_node_on_destruct(L, pos, n_old);
- // Replace node
- bool succeeded = env->getMap().addNodeWithEvent(pos, n);
- lua_pushboolean(L, succeeded);
- // Call constructor
- if(succeeded)
- scriptapi_node_on_construct(L, pos, n);
- return 1;
+ f32 t = luaL_checknumber(L,2);
+ f32 e = luaL_checknumber(L,3);
+ env->getMap().setNodeTimer(o->m_p,NodeTimer(t,e));
+ return 0;
}
-
- static int l_add_node(lua_State *L)
+
+ static int l_start(lua_State *L)
{
- return l_set_node(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;
}
-
- // EnvRef:remove_node(pos)
- // pos = {x=num, y=num, z=num}
- static int l_remove_node(lua_State *L)
+
+ static int l_stop(lua_State *L)
{
- //infostream<<"EnvRef::l_remove_node()"<<std::endl;
- EnvRef *o = checkobject(L, 1);
+ NodeTimerRef *o = checkobject(L, 1);
ServerEnvironment *env = o->m_env;
if(env == NULL) return 0;
- // pos
- v3s16 pos = read_v3s16(L, 2);
- // Do it
- // Call destructor
- MapNode n = env->getMap().getNodeNoEx(pos);
- scriptapi_node_on_destruct(L, pos, n);
- // Replace with air
- bool succeeded = env->getMap().removeNodeWithEvent(pos);
- lua_pushboolean(L, succeeded);
- // Air doesn't require constructor
- return 1;
+ env->getMap().removeNodeTimer(o->m_p);
+ return 0;
}
-
- // EnvRef:get_node(pos)
- // pos = {x=num, y=num, z=num}
- static int l_get_node(lua_State *L)
+
+ static int l_is_started(lua_State *L)
{
- //infostream<<"EnvRef::l_get_node()"<<std::endl;
- EnvRef *o = checkobject(L, 1);
+ NodeTimerRef *o = checkobject(L, 1);
ServerEnvironment *env = o->m_env;
if(env == NULL) return 0;
- // pos
- v3s16 pos = read_v3s16(L, 2);
- // Do it
- MapNode n = env->getMap().getNodeNoEx(pos);
- // Return node
- pushnode(L, n, env->getGameDef()->ndef());
+
+ NodeTimer t = env->getMap().getNodeTimer(o->m_p);
+ lua_pushboolean(L,(t.timeout != 0));
return 1;
}
-
- // EnvRef:get_node_or_nil(pos)
- // pos = {x=num, y=num, z=num}
- static int l_get_node_or_nil(lua_State *L)
+
+ static int l_get_timeout(lua_State *L)
{
- //infostream<<"EnvRef::l_get_node()"<<std::endl;
- EnvRef *o = checkobject(L, 1);
+ NodeTimerRef *o = checkobject(L, 1);
ServerEnvironment *env = o->m_env;
if(env == NULL) return 0;
- // pos
- v3s16 pos = read_v3s16(L, 2);
- // 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;
- }
- }
- // EnvRef: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)
+ NodeTimer t = env->getMap().getNodeTimer(o->m_p);
+ lua_pushnumber(L,t.timeout);
+ return 1;
+ }
+
+ static int l_get_elapsed(lua_State *L)
{
- EnvRef *o = checkobject(L, 1);
+ NodeTimerRef *o = checkobject(L, 1);
ServerEnvironment *env = o->m_env;
if(env == NULL) return 0;
- // Do it
- v3s16 pos = read_v3s16(L, 2);
- u32 time_of_day = env->getTimeOfDay();
- if(lua_isnumber(L, 3))
- time_of_day = 24000.0 * lua_tonumber(L, 3);
- time_of_day %= 24000;
- u32 dnr = time_to_daynight_ratio(time_of_day);
- MapNode n = env->getMap().getNodeNoEx(pos);
- 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;
- }
- }
+
+ NodeTimer t = env->getMap().getNodeTimer(o->m_p);
+ lua_pushnumber(L,t.elapsed);
+ return 1;
+ }
+
+public:
+ NodeTimerRef(v3s16 p, ServerEnvironment *env):
+ m_p(p),
+ m_env(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)
+ {
+ NodeTimerRef *o = new NodeTimerRef(p, env);
+ *(void **)(lua_newuserdata(L, sizeof(void *))) = o;
+ luaL_getmetatable(L, className);
+ lua_setmetatable(L, -2);
+ }
+
+ static void set_null(lua_State *L)
+ {
+ NodeTimerRef *o = checkobject(L, -1);
+ o->m_env = NULL;
+ }
+
+ static void 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[] = {
+ method(NodeTimerRef, start),
+ method(NodeTimerRef, set),
+ method(NodeTimerRef, stop),
+ method(NodeTimerRef, is_started),
+ method(NodeTimerRef, get_timeout),
+ method(NodeTimerRef, get_elapsed),
+ {0,0}
+};
+
+/*
+ EnvRef
+*/
+
+class EnvRef
+{
+private:
+ ServerEnvironment *m_env;
+
+ static const char className[];
+ static const luaL_reg methods[];
+
+ static int gc_object(lua_State *L) {
+ EnvRef *o = *(EnvRef **)(lua_touserdata(L, 1));
+ delete o;
+ return 0;
+ }
+
+ static EnvRef *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 *(EnvRef**)ud; // unbox pointer
+ }
+
+ // Exported functions
+
+ // EnvRef:set_node(pos, node)
+ // pos = {x=num, y=num, z=num}
+ static int l_set_node(lua_State *L)
+ {
+ EnvRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+ INodeDefManager *ndef = env->getGameDef()->ndef();
+ // parameters
+ v3s16 pos = read_v3s16(L, 2);
+ MapNode n = readnode(L, 3, ndef);
+ // Do it
+ MapNode n_old = env->getMap().getNodeNoEx(pos);
+ // Call destructor
+ if(ndef->get(n_old).has_on_destruct)
+ scriptapi_node_on_destruct(L, pos, n_old);
+ // Replace node
+ bool succeeded = env->getMap().addNodeWithEvent(pos, n);
+ if(succeeded){
+ // Call post-destructor
+ if(ndef->get(n_old).has_after_destruct)
+ scriptapi_node_after_destruct(L, pos, n_old);
+ // Call constructor
+ if(ndef->get(n).has_on_construct)
+ scriptapi_node_on_construct(L, pos, n);
+ }
+ lua_pushboolean(L, succeeded);
+ return 1;
+ }
+
+ static int l_add_node(lua_State *L)
+ {
+ return l_set_node(L);
+ }
+
+ // EnvRef:remove_node(pos)
+ // pos = {x=num, y=num, z=num}
+ static int l_remove_node(lua_State *L)
+ {
+ EnvRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+ INodeDefManager *ndef = env->getGameDef()->ndef();
+ // parameters
+ v3s16 pos = read_v3s16(L, 2);
+ // Do it
+ MapNode n_old = env->getMap().getNodeNoEx(pos);
+ // Call destructor
+ if(ndef->get(n_old).has_on_destruct)
+ scriptapi_node_on_destruct(L, pos, n_old);
+ // Replace with air
+ // This is slightly optimized compared to addNodeWithEvent(air)
+ bool succeeded = env->getMap().removeNodeWithEvent(pos);
+ if(succeeded){
+ // Call post-destructor
+ if(ndef->get(n_old).has_after_destruct)
+ scriptapi_node_after_destruct(L, pos, n_old);
+ }
+ lua_pushboolean(L, succeeded);
+ // Air doesn't require constructor
+ return 1;
+ }
+
+ // EnvRef:get_node(pos)
+ // pos = {x=num, y=num, z=num}
+ static int l_get_node(lua_State *L)
+ {
+ EnvRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+ // pos
+ v3s16 pos = read_v3s16(L, 2);
+ // Do it
+ MapNode n = env->getMap().getNodeNoEx(pos);
+ // Return node
+ pushnode(L, n, env->getGameDef()->ndef());
+ return 1;
+ }
+
+ // EnvRef:get_node_or_nil(pos)
+ // pos = {x=num, y=num, z=num}
+ static int l_get_node_or_nil(lua_State *L)
+ {
+ EnvRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+ // pos
+ v3s16 pos = read_v3s16(L, 2);
+ // 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;
+ }
+ }
+
+ // EnvRef: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)
+ {
+ EnvRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+ // Do it
+ v3s16 pos = read_v3s16(L, 2);
+ u32 time_of_day = env->getTimeOfDay();
+ if(lua_isnumber(L, 3))
+ time_of_day = 24000.0 * lua_tonumber(L, 3);
+ time_of_day %= 24000;
+ u32 dnr = time_to_daynight_ratio(time_of_day);
+ MapNode n = env->getMap().getNodeNoEx(pos);
+ 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;
+ }
+ }
+
+ // EnvRef:place_node(pos, node)
+ // pos = {x=num, y=num, z=num}
+ static int l_place_node(lua_State *L)
+ {
+ EnvRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+ v3s16 pos = read_v3s16(L, 2);
+ MapNode n = readnode(L, 3, 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 = get_server(L)->ndef();
+ IItemDefManager *idef = get_server(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 = scriptapi_item_on_place(L, item, NULL, pointed);
+ lua_pushboolean(L, success);
+ return 1;
+ }
+
+ // EnvRef:dig_node(pos)
+ // pos = {x=num, y=num, z=num}
+ static int l_dig_node(lua_State *L)
+ {
+ EnvRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+ v3s16 pos = read_v3s16(L, 2);
+
+ // 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 = scriptapi_node_on_dig(L, pos, n, NULL);
+ lua_pushboolean(L, success);
+ return 1;
+ }
+
+ // EnvRef:punch_node(pos)
+ // pos = {x=num, y=num, z=num}
+ static int l_punch_node(lua_State *L)
+ {
+ EnvRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+ v3s16 pos = read_v3s16(L, 2);
+
+ // 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 = scriptapi_node_on_punch(L, pos, n, NULL);
+ lua_pushboolean(L, success);
+ return 1;
+ }
+
+ // EnvRef:get_meta(pos)
+ static int l_get_meta(lua_State *L)
+ {
+ //infostream<<"EnvRef::l_get_meta()"<<std::endl;
+ EnvRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+ // Do it
+ v3s16 p = read_v3s16(L, 2);
+ NodeMetaRef::create(L, p, env);
+ return 1;
+ }
+
+ // EnvRef:get_node_timer(pos)
+ static int l_get_node_timer(lua_State *L)
+ {
+ EnvRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+ // Do it
+ v3s16 p = read_v3s16(L, 2);
+ NodeTimerRef::create(L, p, env);
+ return 1;
+ }
// EnvRef:add_entity(pos, entityname) -> ObjectRef or nil
// pos = {x=num, y=num, z=num}
return 0;
}
- // EnvRef:get_meta(pos)
- static int l_get_meta(lua_State *L)
- {
- //infostream<<"EnvRef::l_get_meta()"<<std::endl;
- EnvRef *o = checkobject(L, 1);
- ServerEnvironment *env = o->m_env;
- if(env == NULL) return 0;
- // Do it
- v3s16 p = read_v3s16(L, 2);
- NodeMetaRef::create(L, p, env);
- return 1;
- }
-
// EnvRef:get_player_by_name(name)
static int l_get_player_by_name(lua_State *L)
{
return 1;
}
+ // EnvRef:clear_objects()
+ // clear all objects in the environment
+ static int l_clear_objects(lua_State *L)
+ {
+ EnvRef *o = checkobject(L, 1);
+ o->m_env->clearAllObjects();
+ return 0;
+ }
+
public:
EnvRef(ServerEnvironment *env):
m_env(env)
method(EnvRef, get_node),
method(EnvRef, get_node_or_nil),
method(EnvRef, get_node_light),
+ method(EnvRef, place_node),
+ method(EnvRef, dig_node),
+ method(EnvRef, punch_node),
method(EnvRef, add_entity),
method(EnvRef, add_item),
method(EnvRef, add_rat),
method(EnvRef, add_firefly),
method(EnvRef, get_meta),
+ method(EnvRef, get_node_timer),
method(EnvRef, get_player_by_name),
method(EnvRef, get_objects_inside_radius),
method(EnvRef, set_timeofday),
method(EnvRef, find_node_near),
method(EnvRef, find_nodes_in_area),
method(EnvRef, get_perlin),
+ method(EnvRef, clear_objects),
{0,0}
};
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;
return 0;
}
+// request_shutdown()
+static int l_request_shutdown(lua_State *L)
+{
+ get_server(L)->requestShutdown();
+ return 0;
+}
+
+// get_server_status()
+static int l_get_server_status(lua_State *L)
+{
+ lua_pushstring(L, wide_to_narrow(get_server(L)->getStatusString()).c_str());
+ return 1;
+}
+
// register_item_raw({lots of stuff})
static int l_register_item_raw(lua_State *L)
{
get_server(L)->getWritableNodeDefManager();
// Check if name is defined
+ std::string name;
lua_getfield(L, table, "name");
if(lua_isstring(L, -1)){
- std::string name = lua_tostring(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
- // Read the item definition and register it
- ItemDefinition def = read_item_definition(L, table);
+ 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
float cooktime = getfloatfield_default(L, table, "cooktime", 3.0);
+ CraftReplacements replacements;
+ lua_getfield(L, table, "replacements");
+ if(!lua_isnil(L, -1))
+ {
+ if(!read_craft_replacements(L, -1, replacements))
+ throw LuaError(L, "Invalid replacements"
+ " (cooking output=\"" + output + "\")");
+ }
+
CraftDefinition *def = new CraftDefinitionCooking(
- output, recipe, cooktime);
+ output, recipe, cooktime, replacements);
craftdef->registerCraft(def);
}
/*
float burntime = getfloatfield_default(L, table, "burntime", 1.0);
+ CraftReplacements replacements;
+ lua_getfield(L, table, "replacements");
+ if(!lua_isnil(L, -1))
+ {
+ if(!read_craft_replacements(L, -1, replacements))
+ throw LuaError(L, "Invalid replacements"
+ " (fuel recipe=\"" + recipe + "\")");
+ }
+
CraftDefinition *def = new CraftDefinitionFuel(
- recipe, burntime);
+ recipe, burntime, replacements);
craftdef->registerCraft(def);
}
else
return 1;
}
+// get_ban_list()
+static int l_get_ban_list(lua_State *L)
+{
+ lua_pushstring(L, get_server(L)->getBanDescription("").c_str());
+ return 1;
+}
+
+// get_ban_description()
+static int l_get_ban_description(lua_State *L)
+{
+ const char * ip_or_name = luaL_checkstring(L, 1);
+ lua_pushstring(L, get_server(L)->getBanDescription(std::string(ip_or_name)).c_str());
+ return 1;
+}
+
+// ban_player()
+static int l_ban_player(lua_State *L)
+{
+ const char * name = luaL_checkstring(L, 1);
+ Player *player = get_env(L)->getPlayer(name);
+ if(player == NULL)
+ {
+ lua_pushboolean(L, false); // no such player
+ return 1;
+ }
+ try
+ {
+ Address addr = get_server(L)->getPeerAddress(get_env(L)->getPlayer(name)->peer_id);
+ std::string ip_str = addr.serializeString();
+ get_server(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()
+static int l_unban_player_of_ip(lua_State *L)
+{
+ const char * ip_or_name = luaL_checkstring(L, 1);
+ get_server(L)->unsetIpBanned(ip_or_name);
+ lua_pushboolean(L, true);
+ return 1;
+}
+
// get_inventory(location)
static int l_get_inventory(lua_State *L)
{
lua_getfield(L, 1, "pos");
v3s16 pos = check_v3s16(L, -1);
loc.setNodeMeta(pos);
+ } else if(type == "detached"){
+ std::string name = checkstringfield(L, 1, "name");
+ loc.setDetached(name);
}
if(get_server(L)->getInventory(loc) != NULL)
return 1;
}
+// create_detached_inventory_raw(name)
+static int l_create_detached_inventory_raw(lua_State *L)
+{
+ const char *name = luaL_checkstring(L, 1);
+ if(get_server(L)->createDetachedInventory(name) != NULL){
+ InventoryLocation loc;
+ loc.setDetached(name);
+ InvRef::create(L, loc);
+ }else{
+ lua_pushnil(L);
+ }
+ return 1;
+}
+
// get_dig_params(groups, tool_capabilities[, time_from_last_punch])
static int l_get_dig_params(lua_State *L)
{
return 1;
}
+// get_modnames()
+// the returned list is sorted alphabetically for you
+static int l_get_modnames(lua_State *L)
+{
+ // Get a list of mods
+ core::list<std::string> mods_unsorted, mods_sorted;
+ get_server(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(core::list<std::string>::Iterator i = mods_unsorted.begin();
+ i != mods_unsorted.end(); i++)
+ {
+ bool added = false;
+ for(core::list<std::string>::Iterator x = mods_sorted.begin();
+ x != mods_unsorted.end(); x++)
+ {
+ // I doubt anybody using Minetest will be using
+ // anything not ASCII based :)
+ if((*i).compare(*x) <= 0)
+ {
+ mods_sorted.insert_before(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);
+ core::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()
static int l_get_worldpath(lua_State *L)
{
return 2;
}
+// get_craft_recipe(result item)
+static int l_get_craft_recipe(lua_State *L)
+{
+ int k = 0;
+ char tmp[20];
+ int input_i = 1;
+ std::string o_item = luaL_checkstring(L,input_i);
+
+ IGameDef *gdef = get_server(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;
+ }
+ sprintf(tmp,"%d",k);
+ lua_pushstring(L,tmp);
+ 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;
+}
+
+// rollback_get_last_node_actor(p, range, seconds) -> actor, p, seconds
+static int 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 = get_server(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
+static int l_rollback_revert_actions_by(lua_State *L)
+{
+ std::string actor = luaL_checkstring(L, 1);
+ int seconds = luaL_checknumber(L, 2);
+ Server *server = get_server(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;
+}
+
static const struct luaL_Reg minetest_f [] = {
{"debug", l_debug},
{"log", l_log},
+ {"request_shutdown", l_request_shutdown},
+ {"get_server_status", l_get_server_status},
{"register_item_raw", l_register_item_raw},
{"register_alias_raw", l_register_alias_raw},
{"register_craft", l_register_craft},
{"chat_send_all", l_chat_send_all},
{"chat_send_player", l_chat_send_player},
{"get_player_privs", l_get_player_privs},
+ {"get_ban_list", l_get_ban_list},
+ {"get_ban_description", l_get_ban_description},
+ {"ban_player", l_ban_player},
+ {"unban_player_or_ip", l_unban_player_of_ip},
{"get_inventory", l_get_inventory},
+ {"create_detached_inventory_raw", l_create_detached_inventory_raw},
{"get_dig_params", l_get_dig_params},
{"get_hit_params", l_get_hit_params},
{"get_current_modname", l_get_current_modname},
{"get_modpath", l_get_modpath},
+ {"get_modnames", l_get_modnames},
{"get_worldpath", l_get_worldpath},
{"sound_play", l_sound_play},
{"sound_stop", l_sound_stop},
{"get_password_hash", l_get_password_hash},
{"notify_authentication_modified", l_notify_authentication_modified},
{"get_craft_result", l_get_craft_result},
+ {"get_craft_recipe", l_get_craft_recipe},
+ {"rollback_get_last_node_actor", l_rollback_get_last_node_actor},
+ {"rollback_revert_actions_by", l_rollback_revert_actions_by},
{NULL, NULL}
};
lua_getglobal(L, "minetest");
// Add tables to minetest
-
lua_newtable(L);
lua_setfield(L, -2, "object_refs");
lua_newtable(L);
LuaItemStack::Register(L);
InvRef::Register(L);
NodeMetaRef::Register(L);
+ NodeTimerRef::Register(L);
ObjectRef::Register(L);
EnvRef::Register(L);
LuaPseudoRandom::Register(L);
scriptapi_run_callbacks(L, 1, RUN_CALLBACKS_MODE_FIRST);
}
-void scriptapi_get_creative_inventory(lua_State *L, ServerActiveObject *player)
-{
- realitycheck(L);
- assert(lua_checkstack(L, 20));
- StackUnroller stack_unroller(L);
-
- Inventory *inv = player->getInventory();
- assert(inv);
-
- lua_getglobal(L, "minetest");
- lua_getfield(L, -1, "creative_inventory");
- luaL_checktype(L, -1, LUA_TTABLE);
- inventory_set_list_from_lua(inv, "main", L, -1, PLAYER_INVENTORY_SIZE);
-}
-
static void get_auth_handler(lua_State *L)
{
lua_getglobal(L, "minetest");
return lua_toboolean(L, -1);
}
+/*
+ player
+*/
+
+void scriptapi_on_player_receive_fields(lua_State *L,
+ ServerActiveObject *player,
+ const std::string &formname,
+ const std::map<std::string, std::string> &fields)
+{
+ realitycheck(L);
+ assert(lua_checkstack(L, 20));
+ StackUnroller stack_unroller(L);
+
+ // Get minetest.registered_on_chat_messages
+ lua_getglobal(L, "minetest");
+ lua_getfield(L, -1, "registered_on_player_receive_fields");
+ // Call callbacks
+ // param 1
+ objectref_get_or_create(L, player);
+ // param 2
+ lua_pushstring(L, formname.c_str());
+ // param 3
+ lua_newtable(L);
+ 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_pushstring(L, name.c_str());
+ lua_pushlstring(L, value.c_str(), value.size());
+ lua_settable(L, -3);
+ }
+ scriptapi_run_callbacks(L, 3, RUN_CALLBACKS_MODE_OR_SC);
+}
+
/*
item callbacks and node callbacks
*/
// If that is nil or on error, return false and stack is unchanged
// If that is a function, returns true and pushes the
// function onto the stack
+// If minetest.registered_items[name] doesn't exist, minetest.nodedef_default
+// is tried instead so unknown items can still be manipulated to some degree
static bool get_item_callback(lua_State *L,
const char *name, const char *callbackname)
{
// Should be a table
if(lua_type(L, -1) != LUA_TTABLE)
{
+ // Report error and clean up
errorstream<<"Item \""<<name<<"\" not defined"<<std::endl;
lua_pop(L, 1);
- return false;
+
+ // Try minetest.nodedef_default instead
+ lua_getglobal(L, "minetest");
+ lua_getfield(L, -1, "nodedef_default");
+ lua_remove(L, -2);
+ luaL_checktype(L, -1, LUA_TTABLE);
}
lua_getfield(L, -1, callbackname);
lua_remove(L, -2);
return true;
}
-void scriptapi_node_on_construct(lua_State *L, v3s16 p, MapNode node)
+void scriptapi_node_on_construct(lua_State *L, v3s16 p, MapNode node)
+{
+ realitycheck(L);
+ assert(lua_checkstack(L, 20));
+ StackUnroller stack_unroller(L);
+
+ INodeDefManager *ndef = get_server(L)->ndef();
+
+ // Push callback function on stack
+ if(!get_item_callback(L, ndef->get(node).name.c_str(), "on_construct"))
+ return;
+
+ // Call function
+ push_v3s16(L, p);
+ if(lua_pcall(L, 1, 0, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
+}
+
+void scriptapi_node_on_destruct(lua_State *L, v3s16 p, MapNode node)
+{
+ realitycheck(L);
+ assert(lua_checkstack(L, 20));
+ StackUnroller stack_unroller(L);
+
+ INodeDefManager *ndef = get_server(L)->ndef();
+
+ // Push callback function on stack
+ if(!get_item_callback(L, ndef->get(node).name.c_str(), "on_destruct"))
+ return;
+
+ // Call function
+ push_v3s16(L, p);
+ if(lua_pcall(L, 1, 0, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
+}
+
+void scriptapi_node_after_destruct(lua_State *L, v3s16 p, MapNode node)
+{
+ realitycheck(L);
+ assert(lua_checkstack(L, 20));
+ StackUnroller stack_unroller(L);
+
+ INodeDefManager *ndef = get_server(L)->ndef();
+
+ // Push callback function on stack
+ if(!get_item_callback(L, ndef->get(node).name.c_str(), "after_destruct"))
+ return;
+
+ // Call function
+ push_v3s16(L, p);
+ pushnode(L, node, ndef);
+ if(lua_pcall(L, 2, 0, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
+}
+
+bool scriptapi_node_on_timer(lua_State *L, v3s16 p, MapNode node, f32 dtime)
+{
+ realitycheck(L);
+ assert(lua_checkstack(L, 20));
+ StackUnroller stack_unroller(L);
+
+ INodeDefManager *ndef = get_server(L)->ndef();
+
+ // Push callback function on stack
+ if(!get_item_callback(L, ndef->get(node).name.c_str(), "on_timer"))
+ return false;
+
+ // Call function
+ push_v3s16(L, p);
+ lua_pushnumber(L,dtime);
+ if(lua_pcall(L, 2, 1, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
+ if(lua_isboolean(L,-1) && lua_toboolean(L,-1) == true)
+ return true;
+
+ return false;
+}
+
+void scriptapi_node_on_receive_fields(lua_State *L, v3s16 p,
+ const std::string &formname,
+ const std::map<std::string, std::string> &fields,
+ ServerActiveObject *sender)
+{
+ realitycheck(L);
+ assert(lua_checkstack(L, 20));
+ StackUnroller stack_unroller(L);
+
+ INodeDefManager *ndef = get_server(L)->ndef();
+
+ // If node doesn't exist, we don't know what callback to call
+ MapNode node = get_env(L)->getMap().getNodeNoEx(p);
+ if(node.getContent() == CONTENT_IGNORE)
+ return;
+
+ // Push callback function on stack
+ if(!get_item_callback(L, ndef->get(node).name.c_str(), "on_receive_fields"))
+ return;
+
+ // Call function
+ // param 1
+ push_v3s16(L, p);
+ // param 2
+ lua_pushstring(L, formname.c_str());
+ // param 3
+ lua_newtable(L);
+ 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_pushstring(L, name.c_str());
+ lua_pushlstring(L, value.c_str(), value.size());
+ lua_settable(L, -3);
+ }
+ // param 4
+ objectref_get_or_create(L, sender);
+ if(lua_pcall(L, 4, 0, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
+}
+
+/*
+ Node metadata inventory callbacks
+*/
+
+// Return number of accepted items to be moved
+int scriptapi_nodemeta_inventory_allow_move(lua_State *L, v3s16 p,
+ const std::string &from_list, int from_index,
+ const std::string &to_list, int to_index,
+ int count, ServerActiveObject *player)
{
realitycheck(L);
assert(lua_checkstack(L, 20));
INodeDefManager *ndef = get_server(L)->ndef();
+ // If node doesn't exist, we don't know what callback to call
+ MapNode node = get_env(L)->getMap().getNodeNoEx(p);
+ if(node.getContent() == CONTENT_IGNORE)
+ return 0;
+
// Push callback function on stack
- if(!get_item_callback(L, ndef->get(node).name.c_str(), "on_construct"))
- return;
+ if(!get_item_callback(L, ndef->get(node).name.c_str(),
+ "allow_metadata_inventory_move"))
+ return count;
- // Call function
+ // function(pos, from_list, from_index, to_list, to_index, count, player)
+ // pos
push_v3s16(L, p);
- if(lua_pcall(L, 1, 0, 0))
+ // from_list
+ lua_pushstring(L, from_list.c_str());
+ // from_index
+ lua_pushinteger(L, from_index + 1);
+ // to_list
+ lua_pushstring(L, to_list.c_str());
+ // to_index
+ lua_pushinteger(L, to_index + 1);
+ // count
+ lua_pushinteger(L, count);
+ // player
+ objectref_get_or_create(L, player);
+ if(lua_pcall(L, 7, 1, 0))
script_error(L, "error: %s", lua_tostring(L, -1));
+ if(!lua_isnumber(L, -1))
+ throw LuaError(L, "allow_metadata_inventory_move should return a number");
+ return luaL_checkinteger(L, -1);
}
-void scriptapi_node_on_destruct(lua_State *L, v3s16 p, MapNode node)
+// Return number of accepted items to be put
+int scriptapi_nodemeta_inventory_allow_put(lua_State *L, v3s16 p,
+ const std::string &listname, int index, ItemStack &stack,
+ ServerActiveObject *player)
{
realitycheck(L);
assert(lua_checkstack(L, 20));
INodeDefManager *ndef = get_server(L)->ndef();
+ // If node doesn't exist, we don't know what callback to call
+ MapNode node = get_env(L)->getMap().getNodeNoEx(p);
+ if(node.getContent() == CONTENT_IGNORE)
+ return 0;
+
// Push callback function on stack
- if(!get_item_callback(L, ndef->get(node).name.c_str(), "on_destruct"))
- return;
+ if(!get_item_callback(L, ndef->get(node).name.c_str(),
+ "allow_metadata_inventory_put"))
+ return stack.count;
- // Call function
+ // Call function(pos, listname, index, stack, player)
+ // pos
push_v3s16(L, p);
- if(lua_pcall(L, 1, 0, 0))
+ // listname
+ lua_pushstring(L, listname.c_str());
+ // index
+ lua_pushinteger(L, index + 1);
+ // stack
+ LuaItemStack::create(L, stack);
+ // player
+ objectref_get_or_create(L, player);
+ if(lua_pcall(L, 5, 1, 0))
script_error(L, "error: %s", lua_tostring(L, -1));
+ if(!lua_isnumber(L, -1))
+ throw LuaError(L, "allow_metadata_inventory_put should return a number");
+ return luaL_checkinteger(L, -1);
}
-void scriptapi_node_on_receive_fields(lua_State *L, v3s16 p,
- const std::string &formname,
- const std::map<std::string, std::string> &fields,
- ServerActiveObject *sender)
+// Return number of accepted items to be taken
+int scriptapi_nodemeta_inventory_allow_take(lua_State *L, v3s16 p,
+ const std::string &listname, int index, ItemStack &stack,
+ ServerActiveObject *player)
{
realitycheck(L);
assert(lua_checkstack(L, 20));
StackUnroller stack_unroller(L);
INodeDefManager *ndef = get_server(L)->ndef();
-
+
// If node doesn't exist, we don't know what callback to call
MapNode node = get_env(L)->getMap().getNodeNoEx(p);
if(node.getContent() == CONTENT_IGNORE)
- return;
+ return 0;
// Push callback function on stack
- if(!get_item_callback(L, ndef->get(node).name.c_str(), "on_receive_fields"))
- return;
+ if(!get_item_callback(L, ndef->get(node).name.c_str(),
+ "allow_metadata_inventory_take"))
+ return stack.count;
- // Call function
- // param 1
+ // Call function(pos, listname, index, count, player)
+ // pos
push_v3s16(L, p);
- // param 2
- lua_pushstring(L, formname.c_str());
- // param 3
- lua_newtable(L);
- 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_pushstring(L, name.c_str());
- lua_pushlstring(L, value.c_str(), value.size());
- lua_settable(L, -3);
- }
- // param 4
- objectref_get_or_create(L, sender);
- if(lua_pcall(L, 4, 0, 0))
+ // listname
+ lua_pushstring(L, listname.c_str());
+ // index
+ lua_pushinteger(L, index + 1);
+ // stack
+ LuaItemStack::create(L, stack);
+ // player
+ objectref_get_or_create(L, player);
+ if(lua_pcall(L, 5, 1, 0))
script_error(L, "error: %s", lua_tostring(L, -1));
+ if(!lua_isnumber(L, -1))
+ throw LuaError(L, "allow_metadata_inventory_take should return a number");
+ return luaL_checkinteger(L, -1);
}
-void scriptapi_node_on_metadata_inventory_move(lua_State *L, v3s16 p,
+// Report moved items
+void scriptapi_nodemeta_inventory_on_move(lua_State *L, v3s16 p,
const std::string &from_list, int from_index,
const std::string &to_list, int to_index,
int count, ServerActiveObject *player)
return;
// function(pos, from_list, from_index, to_list, to_index, count, player)
+ // pos
push_v3s16(L, p);
+ // from_list
lua_pushstring(L, from_list.c_str());
+ // from_index
lua_pushinteger(L, from_index + 1);
+ // to_list
lua_pushstring(L, to_list.c_str());
+ // to_index
lua_pushinteger(L, to_index + 1);
+ // count
lua_pushinteger(L, count);
+ // player
objectref_get_or_create(L, player);
if(lua_pcall(L, 7, 0, 0))
script_error(L, "error: %s", lua_tostring(L, -1));
}
-ItemStack scriptapi_node_on_metadata_inventory_offer(lua_State *L, v3s16 p,
+// Report put items
+void scriptapi_nodemeta_inventory_on_put(lua_State *L, v3s16 p,
const std::string &listname, int index, ItemStack &stack,
ServerActiveObject *player)
{
// If node doesn't exist, we don't know what callback to call
MapNode node = get_env(L)->getMap().getNodeNoEx(p);
if(node.getContent() == CONTENT_IGNORE)
- return stack;
+ return;
// Push callback function on stack
if(!get_item_callback(L, ndef->get(node).name.c_str(),
- "on_metadata_inventory_offer"))
- return stack;
+ "on_metadata_inventory_put"))
+ return;
// Call function(pos, listname, index, stack, player)
+ // pos
push_v3s16(L, p);
+ // listname
lua_pushstring(L, listname.c_str());
+ // index
lua_pushinteger(L, index + 1);
+ // stack
LuaItemStack::create(L, stack);
+ // player
objectref_get_or_create(L, player);
- if(lua_pcall(L, 5, 1, 0))
+ if(lua_pcall(L, 5, 0, 0))
script_error(L, "error: %s", lua_tostring(L, -1));
- return read_item(L, -1);
}
-ItemStack scriptapi_node_on_metadata_inventory_take(lua_State *L, v3s16 p,
- const std::string &listname, int index, int count,
+// Report taken items
+void scriptapi_nodemeta_inventory_on_take(lua_State *L, v3s16 p,
+ const std::string &listname, int index, ItemStack &stack,
ServerActiveObject *player)
{
realitycheck(L);
// If node doesn't exist, we don't know what callback to call
MapNode node = get_env(L)->getMap().getNodeNoEx(p);
if(node.getContent() == CONTENT_IGNORE)
- return ItemStack();
+ return;
// Push callback function on stack
if(!get_item_callback(L, ndef->get(node).name.c_str(),
"on_metadata_inventory_take"))
- return ItemStack();
+ return;
- // Call function(pos, listname, index, count, player)
+ // Call function(pos, listname, index, stack, player)
+ // pos
push_v3s16(L, p);
+ // listname
lua_pushstring(L, listname.c_str());
+ // index
lua_pushinteger(L, index + 1);
+ // stack
+ LuaItemStack::create(L, stack);
+ // player
+ objectref_get_or_create(L, player);
+ if(lua_pcall(L, 5, 0, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
+}
+
+/*
+ Detached inventory callbacks
+*/
+
+// Retrieves minetest.detached_inventories[name][callbackname]
+// If that is nil or on error, return false and stack is unchanged
+// If that is a function, returns true and pushes the
+// function onto the stack
+static bool get_detached_inventory_callback(lua_State *L,
+ const std::string &name, const char *callbackname)
+{
+ lua_getglobal(L, "minetest");
+ lua_getfield(L, -1, "detached_inventories");
+ lua_remove(L, -2);
+ luaL_checktype(L, -1, LUA_TTABLE);
+ lua_getfield(L, -1, name.c_str());
+ lua_remove(L, -2);
+ // Should be a table
+ if(lua_type(L, -1) != LUA_TTABLE)
+ {
+ errorstream<<"Item \""<<name<<"\" not defined"<<std::endl;
+ lua_pop(L, 1);
+ return false;
+ }
+ lua_getfield(L, -1, callbackname);
+ lua_remove(L, -2);
+ // Should be a function or nil
+ if(lua_type(L, -1) == LUA_TFUNCTION)
+ {
+ return true;
+ }
+ else if(lua_isnil(L, -1))
+ {
+ lua_pop(L, 1);
+ return false;
+ }
+ else
+ {
+ errorstream<<"Detached inventory \""<<name<<"\" callback \""
+ <<callbackname<<"\" is not a function"<<std::endl;
+ lua_pop(L, 1);
+ return false;
+ }
+}
+
+// Return number of accepted items to be moved
+int scriptapi_detached_inventory_allow_move(lua_State *L,
+ const std::string &name,
+ const std::string &from_list, int from_index,
+ const std::string &to_list, int to_index,
+ int count, ServerActiveObject *player)
+{
+ realitycheck(L);
+ assert(lua_checkstack(L, 20));
+ StackUnroller stack_unroller(L);
+
+ // Push callback function on stack
+ if(!get_detached_inventory_callback(L, name, "allow_move"))
+ return count;
+
+ // function(inv, from_list, from_index, to_list, to_index, count, player)
+ // inv
+ InventoryLocation loc;
+ loc.setDetached(name);
+ InvRef::create(L, loc);
+ // from_list
+ lua_pushstring(L, from_list.c_str());
+ // from_index
+ lua_pushinteger(L, from_index + 1);
+ // to_list
+ lua_pushstring(L, to_list.c_str());
+ // to_index
+ lua_pushinteger(L, to_index + 1);
+ // count
lua_pushinteger(L, count);
+ // player
+ objectref_get_or_create(L, player);
+ if(lua_pcall(L, 7, 1, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
+ if(!lua_isnumber(L, -1))
+ throw LuaError(L, "allow_move should return a number");
+ return luaL_checkinteger(L, -1);
+}
+
+// Return number of accepted items to be put
+int scriptapi_detached_inventory_allow_put(lua_State *L,
+ const std::string &name,
+ const std::string &listname, int index, ItemStack &stack,
+ ServerActiveObject *player)
+{
+ realitycheck(L);
+ assert(lua_checkstack(L, 20));
+ StackUnroller stack_unroller(L);
+
+ // Push callback function on stack
+ if(!get_detached_inventory_callback(L, name, "allow_put"))
+ return stack.count; // All will be accepted
+
+ // Call function(inv, listname, index, stack, player)
+ // inv
+ InventoryLocation loc;
+ loc.setDetached(name);
+ InvRef::create(L, loc);
+ // listname
+ lua_pushstring(L, listname.c_str());
+ // index
+ lua_pushinteger(L, index + 1);
+ // stack
+ LuaItemStack::create(L, stack);
+ // player
+ objectref_get_or_create(L, player);
+ if(lua_pcall(L, 5, 1, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
+ if(!lua_isnumber(L, -1))
+ throw LuaError(L, "allow_put should return a number");
+ return luaL_checkinteger(L, -1);
+}
+
+// Return number of accepted items to be taken
+int scriptapi_detached_inventory_allow_take(lua_State *L,
+ const std::string &name,
+ const std::string &listname, int index, ItemStack &stack,
+ ServerActiveObject *player)
+{
+ realitycheck(L);
+ assert(lua_checkstack(L, 20));
+ StackUnroller stack_unroller(L);
+
+ // Push callback function on stack
+ if(!get_detached_inventory_callback(L, name, "allow_take"))
+ return stack.count; // All will be accepted
+
+ // Call function(inv, listname, index, stack, player)
+ // inv
+ InventoryLocation loc;
+ loc.setDetached(name);
+ InvRef::create(L, loc);
+ // listname
+ lua_pushstring(L, listname.c_str());
+ // index
+ lua_pushinteger(L, index + 1);
+ // stack
+ LuaItemStack::create(L, stack);
+ // player
objectref_get_or_create(L, player);
if(lua_pcall(L, 5, 1, 0))
script_error(L, "error: %s", lua_tostring(L, -1));
- return read_item(L, -1);
+ if(!lua_isnumber(L, -1))
+ throw LuaError(L, "allow_take should return a number");
+ return luaL_checkinteger(L, -1);
+}
+
+// Report moved items
+void scriptapi_detached_inventory_on_move(lua_State *L,
+ const std::string &name,
+ const std::string &from_list, int from_index,
+ const std::string &to_list, int to_index,
+ int count, ServerActiveObject *player)
+{
+ realitycheck(L);
+ assert(lua_checkstack(L, 20));
+ StackUnroller stack_unroller(L);
+
+ // Push callback function on stack
+ if(!get_detached_inventory_callback(L, name, "on_move"))
+ return;
+
+ // function(inv, from_list, from_index, to_list, to_index, count, player)
+ // inv
+ InventoryLocation loc;
+ loc.setDetached(name);
+ InvRef::create(L, loc);
+ // from_list
+ lua_pushstring(L, from_list.c_str());
+ // from_index
+ lua_pushinteger(L, from_index + 1);
+ // to_list
+ lua_pushstring(L, to_list.c_str());
+ // to_index
+ lua_pushinteger(L, to_index + 1);
+ // count
+ lua_pushinteger(L, count);
+ // player
+ objectref_get_or_create(L, player);
+ if(lua_pcall(L, 7, 0, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
+}
+
+// Report put items
+void scriptapi_detached_inventory_on_put(lua_State *L,
+ const std::string &name,
+ const std::string &listname, int index, ItemStack &stack,
+ ServerActiveObject *player)
+{
+ realitycheck(L);
+ assert(lua_checkstack(L, 20));
+ StackUnroller stack_unroller(L);
+
+ // Push callback function on stack
+ if(!get_detached_inventory_callback(L, name, "on_put"))
+ return;
+
+ // Call function(inv, listname, index, stack, player)
+ // inv
+ InventoryLocation loc;
+ loc.setDetached(name);
+ InvRef::create(L, loc);
+ // listname
+ lua_pushstring(L, listname.c_str());
+ // index
+ lua_pushinteger(L, index + 1);
+ // stack
+ LuaItemStack::create(L, stack);
+ // player
+ objectref_get_or_create(L, player);
+ if(lua_pcall(L, 5, 0, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
+}
+
+// Report taken items
+void scriptapi_detached_inventory_on_take(lua_State *L,
+ const std::string &name,
+ const std::string &listname, int index, ItemStack &stack,
+ ServerActiveObject *player)
+{
+ realitycheck(L);
+ assert(lua_checkstack(L, 20));
+ StackUnroller stack_unroller(L);
+
+ // Push callback function on stack
+ if(!get_detached_inventory_callback(L, name, "on_take"))
+ return;
+
+ // Call function(inv, listname, index, stack, player)
+ // inv
+ InventoryLocation loc;
+ loc.setDetached(name);
+ InvRef::create(L, loc);
+ // listname
+ lua_pushstring(L, listname.c_str());
+ // index
+ lua_pushinteger(L, index + 1);
+ // stack
+ LuaItemStack::create(L, stack);
+ // player
+ objectref_get_or_create(L, player);
+ if(lua_pcall(L, 5, 0, 0))
+ script_error(L, "error: %s", lua_tostring(L, -1));
}
/*
}
void scriptapi_luaentity_activate(lua_State *L, u16 id,
- const std::string &staticdata)
+ const std::string &staticdata, u32 dtime_s)
{
realitycheck(L);
assert(lua_checkstack(L, 20));
luaL_checktype(L, -1, LUA_TFUNCTION);
lua_pushvalue(L, object); // self
lua_pushlstring(L, staticdata.c_str(), staticdata.size());
- // Call with 2 arguments, 0 results
- if(lua_pcall(L, 2, 0, 0))
+ lua_pushinteger(L, dtime_s);
+ // Call with 3 arguments, 0 results
+ if(lua_pcall(L, 3, 0, 0))
script_error(L, "error running function on_activate: %s\n",
lua_tostring(L, -1));
}
// Set default values that differ from ObjectProperties defaults
prop->hp_max = 10;
+ /* Read stuff */
+
+ prop->hp_max = getintfield_default(L, -1, "hp_max", 10);
+
+ getboolfield(L, -1, "physical", prop->physical);
+
+ getfloatfield(L, -1, "weight", prop->weight);
+
+ lua_getfield(L, -1, "collisionbox");
+ if(lua_istable(L, -1))
+ prop->collisionbox = read_aabb3f(L, -1, 1.0);
+ lua_pop(L, 1);
+
+ getstringfield(L, -1, "visual", prop->visual);
+
// Deprecated: read object properties directly
read_object_properties(L, -1, prop);