#include "daynightratio.h"
#include "noise.h" // PseudoRandom for LuaPseudoRandom
#include "util/pointedthing.h"
+#include "rollback.h"
+#include "treegen.h"
static void stackDump(lua_State *L, std::ostream &o)
{
lua_pop(L, 1);
getstringfield(L, -1, "visual", prop->visual);
+
+ getstringfield(L, -1, "mesh", prop->mesh);
lua_getfield(L, -1, "visual_size");
if(lua_istable(L, -1))
}
}
lua_pop(L, 1);
+
+ lua_getfield(L, -1, "colors");
+ if(lua_istable(L, -1)){
+ prop->colors.clear();
+ int table = lua_gettop(L);
+ lua_pushnil(L);
+ while(lua_next(L, table) != 0){
+ // key at index -2 and value at index -1
+ if(lua_isstring(L, -1))
+ prop->colors.push_back(readARGB8(L, -1));
+ else
+ prop->colors.push_back(video::SColor(255, 255, 255, 255));
+ // removes value, keeps key for next iteration
+ lua_pop(L, 1);
+ }
+ }
+ lua_pop(L, 1);
lua_getfield(L, -1, "spritediv");
if(lua_istable(L, -1))
// the slowest possible
f.liquid_viscosity = getintfield_default(L, index,
"liquid_viscosity", f.liquid_viscosity);
+ getboolfield(L, index, "liquid_renewable", f.liquid_renewable);
// Amount of light the node emits
f.light_source = getintfield_default(L, index,
"light_source", f.light_source);
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)
{
return 1;
}
+ // get_location() -> location (like minetest.get_inventory(location))
+ static int l_get_location(lua_State *L)
+ {
+ 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, "nodemeta");
+ lua_setfield(L, -2, "type");
+ push_v3s16(L, loc.p);
+ lua_setfield(L, -2, "name");
+ 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;
+ }
+
public:
InvRef(const InventoryLocation &loc):
m_loc(loc)
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),
method(InvRef, room_for_item),
method(InvRef, contains_item),
method(InvRef, remove_item),
+ method(InvRef, get_location),
{0,0}
};
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;
}
return 0;
}
+ // set_animation(self, frame_range, frame_speed, frame_blend)
+ static int l_set_animation(lua_State *L)
+ {
+ 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)
+ static int l_set_bone_position(lua_State *L)
+ {
+ 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)
+ static int l_set_attach(lua_State *L)
+ {
+ 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)
+ static int l_set_detach(lua_State *L)
+ {
+ 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)
static int l_set_properties(lua_State *L)
{
lua_pushlstring(L, formspec.c_str(), formspec.size());
return 1;
}
-
+
+ // get_player_control(self)
+ static int l_get_player_control(lua_State *L)
+ {
+ 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)
+ static int l_get_player_control_bits(lua_State *L)
+ {
+ 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;
+ }
+
public:
ObjectRef(ServerActiveObject *object):
m_object(object)
method(ObjectRef, get_wielded_item),
method(ObjectRef, set_wielded_item),
method(ObjectRef, set_armor_groups),
+ method(ObjectRef, set_animation),
+ method(ObjectRef, set_bone_position),
+ method(ObjectRef, set_attach),
+ method(ObjectRef, set_detach),
method(ObjectRef, set_properties),
// LuaEntitySAO-only
method(ObjectRef, setvelocity),
method(ObjectRef, get_look_yaw),
method(ObjectRef, set_inventory_formspec),
method(ObjectRef, get_inventory_formspec),
+ method(ObjectRef, get_player_control),
+ method(ObjectRef, get_player_control_bits),
{0,0}
};
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);
- }
+ bool succeeded = env->setNode(pos, n);
lua_pushboolean(L, succeeded);
return 1;
}
// 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);
- }
+ bool succeeded = env->removeNode(pos);
lua_pushboolean(L, succeeded);
- // Air doesn't require constructor
return 1;
}
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);
+ u32 dnr = time_to_daynight_ratio(time_of_day, true);
MapNode n = env->getMap().getNodeNoEx(pos);
try{
MapNode n = env->getMap().getNode(pos);
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;
+ }
+
+ static int l_spawn_tree(lua_State *L)
+ {
+ EnvRef *o = checkobject(L, 1);
+ ServerEnvironment *env = o->m_env;
+ if(env == NULL) return 0;
+ v3s16 p0 = read_v3s16(L, 2);
+
+ treegen::TreeDef tree_def;
+ std::string trunk,leaves,fruit;
+ INodeDefManager *ndef = env->getGameDef()->ndef();
+
+ if(lua_istable(L, 3))
+ {
+ getstringfield(L, 3, "axiom", tree_def.initial_axiom);
+ getstringfield(L, 3, "rules_a", tree_def.rules_a);
+ getstringfield(L, 3, "rules_b", tree_def.rules_b);
+ getstringfield(L, 3, "rules_c", tree_def.rules_c);
+ getstringfield(L, 3, "rules_d", tree_def.rules_d);
+ getstringfield(L, 3, "trunk", trunk);
+ tree_def.trunknode=ndef->getId(trunk);
+ getstringfield(L, 3, "leaves", leaves);
+ tree_def.leavesnode=ndef->getId(leaves);
+ tree_def.leaves2_chance=0;
+ getstringfield(L, 3, "leaves2", leaves);
+ if (leaves !="")
+ {
+ tree_def.leaves2node=ndef->getId(leaves);
+ getintfield(L, 3, "leaves2_chance", tree_def.leaves2_chance);
+ }
+ getintfield(L, 3, "angle", tree_def.angle);
+ getintfield(L, 3, "iterations", tree_def.iterations);
+ getintfield(L, 3, "random_level", tree_def.iterations_random_level);
+ getstringfield(L, 3, "trunk_type", tree_def.trunk_type);
+ getboolfield(L, 3, "thin_branches", tree_def.thin_branches);
+ tree_def.fruit_chance=0;
+ getstringfield(L, 3, "fruit", fruit);
+ if (fruit != "")
+ {
+ tree_def.fruitnode=ndef->getId(fruit);
+ getintfield(L, 3, "fruit_chance",tree_def.fruit_chance);
+ }
+ }
+ else
+ return 0;
+ treegen::spawn_ltree (env, p0, ndef, tree_def);
+ return 1;
+ }
+
public:
EnvRef(ServerEnvironment *env):
m_env(env)
method(EnvRef, find_node_near),
method(EnvRef, find_nodes_in_area),
method(EnvRef, get_perlin),
+ method(EnvRef, clear_objects),
+ method(EnvRef, spawn_tree),
{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)
{
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)
{
return 1;
}
+// show_formspec(playername,formname,formspec)
+static int l_show_formspec(lua_State *L)
+{
+ const char *playername = luaL_checkstring(L, 1);
+ const char *formname = luaL_checkstring(L, 2);
+ const char *formspec = luaL_checkstring(L, 3);
+
+ if(get_server(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])
static int l_get_dig_params(lua_State *L)
{
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},
+ {"show_formspec", l_show_formspec},
{"get_dig_params", l_get_dig_params},
{"get_hit_params", l_get_hit_params},
{"get_current_modname", l_get_current_modname},
{"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}
};
return ate;
}
+void scriptapi_on_shutdown(lua_State *L)
+{
+ realitycheck(L);
+ assert(lua_checkstack(L, 20));
+ StackUnroller stack_unroller(L);
+
+ // Get registered shutdown hooks
+ lua_getglobal(L, "minetest");
+ lua_getfield(L, -1, "registered_on_shutdown");
+ // Call callbacks
+ scriptapi_run_callbacks(L, 0, RUN_CALLBACKS_MODE_FIRST);
+}
+
void scriptapi_on_newplayer(lua_State *L, ServerActiveObject *player)
{
realitycheck(L);
// 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);
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);
}
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);
}
// 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, int count,
+ const std::string &listname, int index, ItemStack &stack,
ServerActiveObject *player)
{
realitycheck(L);
// Push callback function on stack
if(!get_item_callback(L, ndef->get(node).name.c_str(),
"allow_metadata_inventory_take"))
- return count;
+ return stack.count;
// Call function(pos, listname, index, count, player)
// pos
lua_pushstring(L, listname.c_str());
// index
lua_pushinteger(L, index + 1);
- // count
- lua_pushinteger(L, count);
+ // 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);
}
// Report taken items
void scriptapi_nodemeta_inventory_on_take(lua_State *L, v3s16 p,
- const std::string &listname, int index, int count,
+ const std::string &listname, int index, ItemStack &stack,
ServerActiveObject *player)
{
realitycheck(L);
"on_metadata_inventory_take"))
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);
- // count
- lua_pushinteger(L, count);
+ // stack
+ LuaItemStack::create(L, stack);
// player
objectref_get_or_create(L, player);
if(lua_pcall(L, 5, 0, 0))
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);
}
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, int count,
+ const std::string &listname, int index, ItemStack &stack,
ServerActiveObject *player)
{
realitycheck(L);
// Push callback function on stack
if(!get_detached_inventory_callback(L, name, "allow_take"))
- return count; // All will be accepted
+ return stack.count; // All will be accepted
- // Call function(inv, listname, index, count, player)
+ // Call function(inv, listname, index, stack, player)
// inv
InventoryLocation loc;
loc.setDetached(name);
lua_pushstring(L, listname.c_str());
// index
lua_pushinteger(L, index + 1);
- // count
- lua_pushinteger(L, count);
+ // 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_take should return a number");
return luaL_checkinteger(L, -1);
}
// Report taken items
void scriptapi_detached_inventory_on_take(lua_State *L,
const std::string &name,
- const std::string &listname, int index, int count,
+ const std::string &listname, int index, ItemStack &stack,
ServerActiveObject *player)
{
realitycheck(L);
if(!get_detached_inventory_callback(L, name, "on_take"))
return;
- // Call function(inv, listname, index, count, player)
+ // Call function(inv, listname, index, stack, player)
// inv
InventoryLocation loc;
loc.setDetached(name);
lua_pushstring(L, listname.c_str());
// index
lua_pushinteger(L, index + 1);
- // count
- lua_pushinteger(L, count);
+ // stack
+ LuaItemStack::create(L, stack);
// player
objectref_get_or_create(L, player);
if(lua_pcall(L, 5, 0, 0))
}
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));
}
lua_pop(L, 1);
getstringfield(L, -1, "visual", prop->visual);
+
+ getstringfield(L, -1, "mesh", prop->mesh);
// Deprecated: read object properties directly
read_object_properties(L, -1, prop);
projects / minetest.git / blobdiff