2011-11-11 18:33:17 +01:00
|
|
|
/*
|
|
|
|
Minetest-c55
|
|
|
|
Copyright (C) 2011 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 General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 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 General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU 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 "scriptapi.h"
|
|
|
|
|
|
|
|
#include <iostream>
|
|
|
|
extern "C" {
|
|
|
|
#include <lua.h>
|
|
|
|
#include <lualib.h>
|
|
|
|
#include <lauxlib.h>
|
|
|
|
}
|
|
|
|
|
|
|
|
#include "log.h"
|
|
|
|
#include "server.h"
|
|
|
|
#include "porting.h"
|
|
|
|
#include "filesys.h"
|
|
|
|
#include "serverobject.h"
|
|
|
|
#include "script.h"
|
|
|
|
//#include "luna.h"
|
|
|
|
|
|
|
|
static void stackDump(lua_State *L, std::ostream &o)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int top = lua_gettop(L);
|
|
|
|
for (i = 1; i <= top; i++) { /* repeat for each level */
|
|
|
|
int t = lua_type(L, i);
|
|
|
|
switch (t) {
|
|
|
|
|
|
|
|
case LUA_TSTRING: /* strings */
|
|
|
|
o<<"\""<<lua_tostring(L, i)<<"\"";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LUA_TBOOLEAN: /* booleans */
|
|
|
|
o<<(lua_toboolean(L, i) ? "true" : "false");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LUA_TNUMBER: /* numbers */ {
|
|
|
|
char buf[10];
|
|
|
|
snprintf(buf, 10, "%g", lua_tonumber(L, i));
|
|
|
|
o<<buf;
|
|
|
|
break; }
|
|
|
|
|
|
|
|
default: /* other values */
|
|
|
|
o<<lua_typename(L, t);
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
o<<" ";
|
|
|
|
}
|
|
|
|
o<<std::endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void realitycheck(lua_State *L)
|
|
|
|
{
|
|
|
|
int top = lua_gettop(L);
|
|
|
|
if(top >= 30){
|
|
|
|
dstream<<"Stack is over 30:"<<std::endl;
|
|
|
|
stackDump(L, dstream);
|
|
|
|
script_error(L, "Stack is over 30 (reality check)");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-11-11 23:46:05 +01:00
|
|
|
// Register new object prototype
|
|
|
|
// register_entity(name, prototype)
|
2011-11-11 19:50:09 +01:00
|
|
|
static int l_register_entity(lua_State *L)
|
2011-11-11 18:33:17 +01:00
|
|
|
{
|
|
|
|
const char *name = luaL_checkstring(L, 1);
|
2011-11-11 23:46:05 +01:00
|
|
|
luaL_checktype(L, 2, LUA_TTABLE);
|
2011-11-11 19:50:09 +01:00
|
|
|
infostream<<"register_entity: "<<name<<std::endl;
|
2011-11-11 23:46:05 +01:00
|
|
|
|
|
|
|
// Get minetest.registered_entities
|
2011-11-11 18:33:17 +01:00
|
|
|
lua_getglobal(L, "minetest");
|
2011-11-11 19:50:09 +01:00
|
|
|
lua_getfield(L, -1, "registered_entities");
|
2011-11-11 18:33:17 +01:00
|
|
|
luaL_checktype(L, -1, LUA_TTABLE);
|
2011-11-11 23:46:05 +01:00
|
|
|
int registered_entities = lua_gettop(L);
|
|
|
|
lua_pushvalue(L, 2); // Object = param 2 -> stack top
|
|
|
|
// registered_entities[name] = object
|
|
|
|
lua_setfield(L, registered_entities, name);
|
|
|
|
|
|
|
|
// Get registered object to top of stack
|
|
|
|
lua_pushvalue(L, 2);
|
|
|
|
|
|
|
|
// Set __index to point to itself
|
|
|
|
lua_pushvalue(L, -1);
|
|
|
|
lua_setfield(L, -2, "__index");
|
|
|
|
|
|
|
|
// Set metatable.__index = metatable
|
|
|
|
luaL_getmetatable(L, "minetest.entity");
|
|
|
|
lua_pushvalue(L, -1); // duplicate metatable
|
|
|
|
lua_setfield(L, -2, "__index");
|
|
|
|
// Set object metatable
|
|
|
|
lua_setmetatable(L, -2);
|
2011-11-11 18:33:17 +01:00
|
|
|
|
|
|
|
return 0; /* number of results */
|
|
|
|
}
|
|
|
|
|
2011-11-11 19:50:09 +01:00
|
|
|
#if 0
|
2011-11-11 18:33:17 +01:00
|
|
|
static int l_new_entity(lua_State *L)
|
|
|
|
{
|
|
|
|
/* o = o or {}
|
|
|
|
setmetatable(o, self)
|
|
|
|
self.__index = self
|
|
|
|
return o */
|
|
|
|
if(lua_isnil(L, -1))
|
|
|
|
lua_newtable(L);
|
|
|
|
luaL_checktype(L, -1, LUA_TTABLE);
|
|
|
|
luaL_getmetatable(L, "minetest.entity");
|
|
|
|
lua_pushvalue(L, -1); // duplicate metatable
|
|
|
|
lua_setfield(L, -2, "__index");
|
|
|
|
lua_setmetatable(L, -2);
|
|
|
|
// return table
|
|
|
|
return 1;
|
|
|
|
}
|
2011-11-11 19:50:09 +01:00
|
|
|
#endif
|
2011-11-11 18:33:17 +01:00
|
|
|
|
|
|
|
static const struct luaL_Reg minetest_f [] = {
|
2011-11-11 19:50:09 +01:00
|
|
|
{"register_entity", l_register_entity},
|
|
|
|
//{"new_entity", l_new_entity},
|
2011-11-11 18:33:17 +01:00
|
|
|
{NULL, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
static int l_entity_set_deleted(lua_State *L)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct luaL_Reg minetest_entity_m [] = {
|
|
|
|
{"set_deleted", l_entity_set_deleted},
|
|
|
|
{NULL, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
class ObjectRef
|
|
|
|
{
|
|
|
|
private:
|
|
|
|
ServerActiveObject *m_object;
|
|
|
|
|
|
|
|
static const char className[];
|
|
|
|
static const luaL_reg methods[];
|
|
|
|
|
|
|
|
static 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
|
|
|
|
}
|
|
|
|
|
|
|
|
// Exported functions
|
|
|
|
|
|
|
|
static int l_remove(lua_State *L)
|
|
|
|
{
|
|
|
|
ObjectRef *o = checkobject(L, 1);
|
|
|
|
ServerActiveObject *co = o->m_object;
|
|
|
|
if(co == NULL) return 0;
|
|
|
|
infostream<<"ObjectRef::l_remove(): id="<<co->getId()<<std::endl;
|
|
|
|
co->m_removed = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gc_object(lua_State *L) {
|
|
|
|
//ObjectRef *o = checkobject(L, 1);
|
|
|
|
ObjectRef *o = *(ObjectRef **)(lua_touserdata(L, 1));
|
|
|
|
//infostream<<"ObjectRef::gc_object: o="<<o<<std::endl;
|
|
|
|
delete o;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
ObjectRef(ServerActiveObject *object):
|
|
|
|
m_object(object)
|
|
|
|
{
|
|
|
|
infostream<<"ObjectRef created for id="<<m_object->getId()<<std::endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
~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.
|
|
|
|
static void 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);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void set_null(lua_State *L)
|
|
|
|
{
|
|
|
|
ObjectRef *o = checkobject(L, -1);
|
|
|
|
ServerActiveObject *co = o->m_object;
|
|
|
|
if(co == NULL)
|
|
|
|
return;
|
|
|
|
o->m_object = 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 ObjectRef::className[] = "ObjectRef";
|
|
|
|
|
|
|
|
#define method(class, name) {#name, class::l_##name}
|
|
|
|
|
|
|
|
const luaL_reg ObjectRef::methods[] = {
|
|
|
|
method(ObjectRef, remove),
|
|
|
|
{0,0}
|
|
|
|
};
|
|
|
|
|
|
|
|
void scriptapi_export(lua_State *L, Server *server)
|
|
|
|
{
|
|
|
|
realitycheck(L);
|
|
|
|
assert(lua_checkstack(L, 20));
|
|
|
|
infostream<<"scriptapi_export"<<std::endl;
|
|
|
|
|
|
|
|
// Register global functions in table minetest
|
|
|
|
lua_newtable(L);
|
|
|
|
luaL_register(L, NULL, minetest_f);
|
|
|
|
lua_setglobal(L, "minetest");
|
|
|
|
|
|
|
|
// Get the main minetest table
|
|
|
|
lua_getglobal(L, "minetest");
|
|
|
|
|
2011-11-11 19:50:09 +01:00
|
|
|
// Add registered_entities table in minetest
|
2011-11-11 18:33:17 +01:00
|
|
|
lua_newtable(L);
|
2011-11-11 19:50:09 +01:00
|
|
|
lua_setfield(L, -2, "registered_entities");
|
2011-11-11 18:33:17 +01:00
|
|
|
|
|
|
|
// Add object_refs table in minetest
|
|
|
|
lua_newtable(L);
|
|
|
|
lua_setfield(L, -2, "object_refs");
|
|
|
|
|
|
|
|
// Add luaentities table in minetest
|
|
|
|
lua_newtable(L);
|
|
|
|
lua_setfield(L, -2, "luaentities");
|
|
|
|
|
|
|
|
// Load and run some base Lua stuff
|
|
|
|
/*script_load(L, (porting::path_data + DIR_DELIM + "scripts"
|
|
|
|
+ DIR_DELIM + "base.lua").c_str());*/
|
|
|
|
|
|
|
|
// Create entity reference metatable
|
|
|
|
luaL_newmetatable(L, "minetest.entity_reference");
|
|
|
|
lua_pop(L, 1);
|
|
|
|
|
|
|
|
// Create entity prototype
|
|
|
|
luaL_newmetatable(L, "minetest.entity");
|
|
|
|
// metatable.__index = metatable
|
|
|
|
lua_pushvalue(L, -1); // Duplicate metatable
|
|
|
|
lua_setfield(L, -2, "__index");
|
|
|
|
// Put functions in metatable
|
|
|
|
luaL_register(L, NULL, minetest_entity_m);
|
|
|
|
// Put other stuff in metatable
|
|
|
|
|
|
|
|
// Entity C reference
|
|
|
|
ObjectRef::Register(L);
|
|
|
|
}
|
|
|
|
|
2011-11-11 23:46:05 +01:00
|
|
|
// Dump stack top with the dump2 function
|
|
|
|
static void dump2(lua_State *L, const char *name)
|
|
|
|
{
|
|
|
|
// Dump object (debug)
|
|
|
|
lua_getglobal(L, "dump2");
|
|
|
|
luaL_checktype(L, -1, LUA_TFUNCTION);
|
|
|
|
lua_pushvalue(L, -2); // Get previous stack top as first parameter
|
|
|
|
lua_pushstring(L, name);
|
|
|
|
if(lua_pcall(L, 2, 0, 0))
|
|
|
|
script_error(L, "error: %s\n", lua_tostring(L, -1));
|
|
|
|
}
|
|
|
|
|
|
|
|
void scriptapi_luaentity_add(lua_State *L, u16 id, const char *name,
|
2011-11-11 18:33:17 +01:00
|
|
|
const char *init_state)
|
|
|
|
{
|
|
|
|
realitycheck(L);
|
|
|
|
assert(lua_checkstack(L, 20));
|
2011-11-11 23:46:05 +01:00
|
|
|
infostream<<"scriptapi_luaentity_add: id="<<id<<" name=\""
|
|
|
|
<<name<<"\""<<std::endl;
|
|
|
|
|
|
|
|
int initial_top = lua_gettop(L);
|
2011-11-11 18:33:17 +01:00
|
|
|
|
|
|
|
// Create object as a dummy string (TODO: Create properly)
|
2011-11-11 23:46:05 +01:00
|
|
|
|
|
|
|
// Get minetest.registered_entities[name]
|
|
|
|
lua_getglobal(L, "minetest");
|
|
|
|
lua_getfield(L, -1, "registered_entities");
|
|
|
|
luaL_checktype(L, -1, LUA_TTABLE);
|
|
|
|
lua_pushstring(L, name);
|
|
|
|
lua_gettable(L, -2);
|
|
|
|
// Should be a table, which we will use as a prototype
|
|
|
|
luaL_checktype(L, -1, LUA_TTABLE);
|
|
|
|
int prototype_table = lua_gettop(L);
|
|
|
|
//dump2(L, "prototype_table");
|
|
|
|
|
|
|
|
// Create entity object
|
|
|
|
lua_newtable(L);
|
2011-11-11 18:33:17 +01:00
|
|
|
int object = lua_gettop(L);
|
|
|
|
|
2011-11-11 23:46:05 +01:00
|
|
|
// Set object metatable
|
|
|
|
lua_pushvalue(L, prototype_table);
|
|
|
|
lua_setmetatable(L, -2);
|
|
|
|
|
|
|
|
/*// Set prototype_table.__index = prototype_table
|
|
|
|
lua_pushvalue(L, prototype_table); // Copy to top of stack
|
|
|
|
lua_pushvalue(L, -1); // duplicate prototype_table
|
|
|
|
lua_setfield(L, -2, "__index");*/
|
|
|
|
|
|
|
|
/*lua_pushstring(L, "debug from C");
|
|
|
|
lua_setfield(L, -2, "on_step");*/
|
|
|
|
|
2011-11-11 18:33:17 +01:00
|
|
|
// Get minetest.luaentities table
|
|
|
|
lua_getglobal(L, "minetest");
|
|
|
|
lua_getfield(L, -1, "luaentities");
|
|
|
|
luaL_checktype(L, -1, LUA_TTABLE);
|
2011-11-11 23:46:05 +01:00
|
|
|
int luaentities = lua_gettop(L);
|
2011-11-11 18:33:17 +01:00
|
|
|
|
|
|
|
// luaentities[id] = object
|
|
|
|
lua_pushnumber(L, id); // Push id
|
|
|
|
lua_pushvalue(L, object); // Copy object to top of stack
|
2011-11-11 23:46:05 +01:00
|
|
|
lua_settable(L, luaentities);
|
2011-11-11 18:33:17 +01:00
|
|
|
|
2011-11-11 23:46:05 +01:00
|
|
|
lua_settop(L, initial_top); // Reset stack
|
2011-11-11 18:33:17 +01:00
|
|
|
}
|
|
|
|
|
2011-11-11 23:46:05 +01:00
|
|
|
void scriptapi_luaentity_rm(lua_State *L, u16 id)
|
2011-11-11 18:33:17 +01:00
|
|
|
{
|
|
|
|
realitycheck(L);
|
|
|
|
assert(lua_checkstack(L, 20));
|
2011-11-11 23:46:05 +01:00
|
|
|
infostream<<"scriptapi_luaentity_rm: id="<<id<<std::endl;
|
2011-11-11 18:33:17 +01:00
|
|
|
|
|
|
|
// Get minetest.luaentities table
|
|
|
|
lua_getglobal(L, "minetest");
|
|
|
|
lua_getfield(L, -1, "luaentities");
|
|
|
|
luaL_checktype(L, -1, LUA_TTABLE);
|
|
|
|
int objectstable = lua_gettop(L);
|
|
|
|
|
|
|
|
/*// Get luaentities[id]
|
|
|
|
lua_pushnumber(L, cobj->getId()); // Push id
|
|
|
|
lua_gettable(L, objectstable);
|
|
|
|
// Object is at stack top
|
|
|
|
lua_pop(L, 1); // pop object*/
|
|
|
|
|
|
|
|
// Set luaentities[id] = nil
|
2011-11-11 19:50:09 +01:00
|
|
|
lua_pushnumber(L, id); // Push id
|
2011-11-11 18:33:17 +01:00
|
|
|
lua_pushnil(L);
|
|
|
|
lua_settable(L, objectstable);
|
|
|
|
|
|
|
|
lua_pop(L, 2); // pop luaentities, minetest
|
|
|
|
}
|
|
|
|
|
2011-11-11 23:46:05 +01:00
|
|
|
void scriptapi_luaentity_step(lua_State *L, u16 id, float dtime)
|
2011-11-11 18:33:17 +01:00
|
|
|
{
|
|
|
|
realitycheck(L);
|
|
|
|
assert(lua_checkstack(L, 20));
|
2011-11-11 23:46:05 +01:00
|
|
|
infostream<<"scriptapi_luaentity_step: id="<<id<<std::endl;
|
2011-11-11 18:33:17 +01:00
|
|
|
|
2011-11-11 23:46:05 +01:00
|
|
|
// Get minetest.luaentities[i]
|
2011-11-11 18:33:17 +01:00
|
|
|
lua_getglobal(L, "minetest");
|
|
|
|
lua_getfield(L, -1, "luaentities");
|
|
|
|
luaL_checktype(L, -1, LUA_TTABLE);
|
2011-11-11 23:46:05 +01:00
|
|
|
lua_pushnumber(L, id);
|
|
|
|
lua_gettable(L, -2);
|
|
|
|
int object = lua_gettop(L);
|
|
|
|
// State: object is at top of stack
|
|
|
|
/*dump2(L, "entity");
|
|
|
|
lua_getmetatable(L, -1);
|
|
|
|
dump2(L, "getmetatable(entity)");
|
|
|
|
lua_getfield(L, -1, "__index");
|
|
|
|
dump2(L, "getmetatable(entity).__index");
|
|
|
|
lua_pop(L, 1);
|
|
|
|
lua_pop(L, 1);*/
|
|
|
|
// Get step function
|
|
|
|
lua_getfield(L, -1, "on_step");
|
|
|
|
luaL_checktype(L, -1, LUA_TFUNCTION);
|
|
|
|
lua_pushvalue(L, object); // self
|
|
|
|
lua_pushnumber(L, dtime); // dtime
|
|
|
|
// Call with 2 arguments, 0 results
|
|
|
|
if(lua_pcall(L, 2, 0, 0))
|
|
|
|
script_error(L, "error running function 'step': %s\n", lua_tostring(L, -1));
|
2011-11-11 18:33:17 +01:00
|
|
|
|
|
|
|
lua_pop(L, 1); // pop object
|
|
|
|
lua_pop(L, 2); // pop luaentities, minetest
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string scriptapi_luaentity_get_state(lua_State *L, u16 id)
|
|
|
|
{
|
|
|
|
realitycheck(L);
|
|
|
|
assert(lua_checkstack(L, 20));
|
|
|
|
infostream<<"scriptapi_luaentity_get_state: id="<<id<<std::endl;
|
|
|
|
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
void scriptapi_add_object_reference(lua_State *L, ServerActiveObject *cobj)
|
|
|
|
{
|
|
|
|
realitycheck(L);
|
|
|
|
assert(lua_checkstack(L, 20));
|
|
|
|
infostream<<"scriptapi_add_object_reference: id="<<cobj->getId()<<std::endl;
|
|
|
|
|
|
|
|
// Create object on stack
|
|
|
|
ObjectRef::create(L, cobj); // Puts ObjectRef (as userdata) on stack
|
|
|
|
int object = lua_gettop(L);
|
|
|
|
|
|
|
|
// Get minetest.object_refs table
|
|
|
|
lua_getglobal(L, "minetest");
|
|
|
|
lua_getfield(L, -1, "object_refs");
|
|
|
|
luaL_checktype(L, -1, LUA_TTABLE);
|
|
|
|
int objectstable = lua_gettop(L);
|
|
|
|
|
|
|
|
// object_refs[id] = object
|
|
|
|
lua_pushnumber(L, cobj->getId()); // Push id
|
|
|
|
lua_pushvalue(L, object); // Copy object to top of stack
|
|
|
|
lua_settable(L, objectstable);
|
|
|
|
|
|
|
|
// pop object_refs, minetest and the object
|
|
|
|
lua_pop(L, 3);
|
|
|
|
}
|
|
|
|
|
|
|
|
void scriptapi_rm_object_reference(lua_State *L, ServerActiveObject *cobj)
|
|
|
|
{
|
|
|
|
realitycheck(L);
|
|
|
|
assert(lua_checkstack(L, 20));
|
|
|
|
infostream<<"scriptapi_rm_object_reference: id="<<cobj->getId()<<std::endl;
|
|
|
|
|
|
|
|
// Get minetest.object_refs table
|
|
|
|
lua_getglobal(L, "minetest");
|
|
|
|
lua_getfield(L, -1, "object_refs");
|
|
|
|
luaL_checktype(L, -1, LUA_TTABLE);
|
|
|
|
int objectstable = lua_gettop(L);
|
|
|
|
|
|
|
|
// Get object_refs[id]
|
|
|
|
lua_pushnumber(L, cobj->getId()); // Push id
|
|
|
|
lua_gettable(L, objectstable);
|
|
|
|
// Set object reference to NULL
|
|
|
|
ObjectRef::set_null(L);
|
|
|
|
lua_pop(L, 1); // pop object
|
|
|
|
|
|
|
|
// Set object_refs[id] = nil
|
|
|
|
lua_pushnumber(L, cobj->getId()); // Push id
|
|
|
|
lua_pushnil(L);
|
|
|
|
lua_settable(L, objectstable);
|
|
|
|
|
|
|
|
// pop object_refs, minetest
|
|
|
|
lua_pop(L, 2);
|
|
|
|
}
|
|
|
|
|