X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fscriptapi.cpp;h=ec3d34676672decfdcca5db0d2a5f9b7665bd7f2;hb=318669327e84d8fc7498e32c5bacfad658d8ba87;hp=35f00b7b51791e531116b0d15983f7d75ddc9118;hpb=d15d6c4e6bbd64b8f6980b33413b7a8ffb39eb7c;p=oweals%2Fminetest.git

diff --git a/src/scriptapi.cpp b/src/scriptapi.cpp
index 35f00b7b5..ec3d34676 100644
--- a/src/scriptapi.cpp
+++ b/src/scriptapi.cpp
@@ -37,16 +37,19 @@ extern "C" {
 #include "content_sao.h" // For LuaEntitySAO and PlayerSAO
 #include "itemdef.h"
 #include "nodedef.h"
+#include "biome.h"
 #include "craftdef.h"
 #include "main.h" // For g_settings
 #include "settings.h" // For accessing g_settings
 #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"
+#include "treegen.h"
 
 static void stackDump(lua_State *L, std::ostream &o)
 {
@@ -382,6 +385,7 @@ struct EnumString es_DrawType[] =
 	{NDT_PLANTLIKE, "plantlike"},
 	{NDT_FENCELIKE, "fencelike"},
 	{NDT_RAILLIKE, "raillike"},
+	{NDT_NODEBOX, "nodebox"},
 	{0, NULL},
 };
 
@@ -433,6 +437,16 @@ struct EnumString es_TileAnimationType[] =
 	{0, NULL},
 };
 
+struct EnumString es_BiomeTerrainType[] =
+{
+	{BIOME_TERRAIN_NORMAL, "normal"},
+	{BIOME_TERRAIN_LIQUID, "liquid"},
+	{BIOME_TERRAIN_NETHER, "nether"},
+	{BIOME_TERRAIN_AETHER, "aether"},
+	{BIOME_TERRAIN_FLAT,   "flat"},
+	{0, NULL},
+};
+
 /*
 	C struct <-> Lua table converter functions
 */
@@ -595,52 +609,89 @@ static video::SColor readARGB8(lua_State *L, int index)
 	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
@@ -648,6 +699,8 @@ static MaterialProperties read_material_properties(
 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)
@@ -891,10 +944,12 @@ static void read_object_properties(lua_State *L, int index,
 
 	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);
+
+	getstringfield(L, -1, "mesh", prop->mesh);
 	
 	lua_getfield(L, -1, "visual_size");
 	if(lua_istable(L, -1))
@@ -917,6 +972,23 @@ static void read_object_properties(lua_State *L, int index,
 		}
 	}
 	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))
@@ -927,7 +999,7 @@ static void read_object_properties(lua_State *L, int index,
 	if(lua_istable(L, -1))
 		prop->initial_sprite_basepos = read_v2s16(L, -1);
 	lua_pop(L, 1);
-	
+
 	getboolfield(L, -1, "is_visible", prop->is_visible);
 	getboolfield(L, -1, "makes_footstep_sound", prop->makes_footstep_sound);
 	getfloatfield(L, -1, "automatic_rotate", prop->automatic_rotate);
@@ -971,7 +1043,7 @@ static ItemDefinition read_item_definition(lua_State *L, int index,
 
 	warn_if_field_exists(L, index, "tool_digging_properties",
 			"deprecated: use tool_capabilities");
-	
+
 	lua_getfield(L, index, "tool_capabilities");
 	if(lua_istable(L, -1)){
 		def.tool_capabilities = new ToolCapabilities(
@@ -1006,7 +1078,7 @@ 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
@@ -1052,7 +1124,7 @@ static ContentFeatures read_content_features(lua_State *L, int index)
 		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;
@@ -1077,7 +1149,7 @@ static ContentFeatures read_content_features(lua_State *L, int index)
 	f.drawtype = (NodeDrawType)getenumfield(L, index, "drawtype", es_DrawType,
 			NDT_NORMAL);
 	getfloatfield(L, index, "visual_scale", f.visual_scale);
-	
+
 	// tiles = {}
 	lua_getfield(L, index, "tiles");
 	// If nil, try the deprecated name "tile_images" instead
@@ -1112,7 +1184,7 @@ static ContentFeatures read_content_features(lua_State *L, int index)
 		}
 	}
 	lua_pop(L, 1);
-	
+
 	// special_tiles = {}
 	lua_getfield(L, index, "special_tiles");
 	// If nil, try the deprecated name "special_materials" instead
@@ -1143,7 +1215,7 @@ static ContentFeatures read_content_features(lua_State *L, int index)
 	f.alpha = getintfield_default(L, index, "alpha", 255);
 
 	/* Other stuff */
-	
+
 	lua_getfield(L, index, "post_effect_color");
 	if(!lua_isnil(L, -1))
 		f.post_effect_color = readARGB8(L, -1);
@@ -1167,7 +1239,7 @@ static ContentFeatures read_content_features(lua_State *L, int index)
 			"deprecated: use 'drop' field");
 	warn_if_field_exists(L, index, "metadata_name",
 			"deprecated: use on_add and metadata callbacks");
-	
+
 	// True for all ground-like things like stone and mud, false for eg. trees
 	getboolfield(L, index, "is_ground_content", f.is_ground_content);
 	f.light_propagates = (f.param_type == CPT_LIGHT);
@@ -1197,44 +1269,28 @@ static ContentFeatures read_content_features(lua_State *L, int index)
 	// 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);
 	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
 	getboolfield(L, index, "legacy_wallmounted", f.legacy_wallmounted);
-	
+
 	// Sound table
 	lua_getfield(L, index, "sounds");
 	if(lua_istable(L, -1)){
@@ -1323,7 +1379,7 @@ private:
 	static const luaL_reg methods[];
 
 	// Exported functions
-	
+
 	// garbage collector
 	static int gc_object(lua_State *L)
 	{
@@ -1576,7 +1632,7 @@ public:
 	{
 		return m_stack;
 	}
-	
+
 	// LuaItemStack(itemstack or itemstring or table or nil)
 	// Creates an LuaItemStack and leaves it on top of stack
 	static int create_object(lua_State *L)
@@ -1765,7 +1821,7 @@ private:
 		if(!ud) luaL_typerror(L, narg, className);
 		return *(InvRef**)ud;  // unbox pointer
 	}
-	
+
 	static Inventory* getinv(lua_State *L, InvRef *ref)
 	{
 		return get_server(L)->getInventory(ref->m_loc);
@@ -1785,9 +1841,9 @@ private:
 		// Inform other things that the inventory has changed
 		get_server(L)->setInventoryModified(ref->m_loc);
 	}
-	
+
 	// Exported functions
-	
+
 	// garbage collector
 	static int gc_object(lua_State *L) {
 		InvRef *o = *(InvRef **)(lua_touserdata(L, 1));
@@ -1823,6 +1879,20 @@ private:
 		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)
 	{
@@ -1845,6 +1915,23 @@ private:
 		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)
 	{
@@ -1973,6 +2060,43 @@ private:
 		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)
@@ -2038,6 +2162,8 @@ const luaL_reg InvRef::methods[] = {
 	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),
@@ -2046,6 +2172,7 @@ const luaL_reg InvRef::methods[] = {
 	method(InvRef, room_for_item),
 	method(InvRef, contains_item),
 	method(InvRef, remove_item),
+	method(InvRef, get_location),
 	{0,0}
 };
 
@@ -2069,7 +2196,7 @@ private:
 		if(!ud) luaL_typerror(L, narg, className);
 		return *(NodeMetaRef**)ud;  // unbox pointer
 	}
-	
+
 	static NodeMetadata* getmeta(NodeMetaRef *ref, bool auto_create)
 	{
 		NodeMetadata *meta = ref->m_env->getMap().getNodeMetadata(ref->m_p);
@@ -2083,6 +2210,7 @@ private:
 
 	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;
@@ -2095,9 +2223,9 @@ private:
 			block->raiseModified(MOD_STATE_WRITE_NEEDED,
 					"NodeMetaRef::reportMetadataChange");
 	}
-	
+
 	// Exported functions
-	
+
 	// garbage collector
 	static int gc_object(lua_State *L) {
 		NodeMetaRef *o = *(NodeMetaRef **)(lua_touserdata(L, 1));
@@ -2210,7 +2338,7 @@ private:
 		InvRef::createNodeMeta(L, ref->m_p);
 		return 1;
 	}
-	
+
 	// to_table(self)
 	static int l_to_table(lua_State *L)
 	{
@@ -2256,7 +2384,7 @@ private:
 	{
 		NodeMetaRef *ref = checkobject(L, 1);
 		int base = 2;
-		
+
 		if(lua_isnil(L, base)){
 			// No metadata
 			ref->m_env->getMap().removeNodeMetadata(ref->m_p);
@@ -2380,7 +2508,7 @@ public:
 		if(!ud) luaL_typerror(L, narg, className);
 		return *(ObjectRef**)ud;  // unbox pointer
 	}
-	
+
 	static ServerActiveObject* getobject(ObjectRef *ref)
 	{
 		ServerActiveObject *co = ref->m_object;
@@ -2396,7 +2524,7 @@ private:
 			return NULL;
 		return (LuaEntitySAO*)obj;
 	}
-	
+
 	static PlayerSAO* getplayersao(ObjectRef *ref)
 	{
 		ServerActiveObject *obj = getobject(ref);
@@ -2406,7 +2534,7 @@ private:
 			return NULL;
 		return (PlayerSAO*)obj;
 	}
-	
+
 	static Player* getplayer(ObjectRef *ref)
 	{
 		PlayerSAO *playersao = getplayersao(ref);
@@ -2414,9 +2542,9 @@ private:
 			return NULL;
 		return playersao->getPlayer();
 	}
-	
+
 	// Exported functions
-	
+
 	// garbage collector
 	static int gc_object(lua_State *L) {
 		ObjectRef *o = *(ObjectRef **)(lua_touserdata(L, 1));
@@ -2435,7 +2563,7 @@ private:
 		co->m_removed = true;
 		return 0;
 	}
-	
+
 	// getpos(self)
 	// returns: {x=num, y=num, z=num}
 	static int l_getpos(lua_State *L)
@@ -2453,7 +2581,7 @@ private:
 		lua_setfield(L, -2, "z");
 		return 1;
 	}
-	
+
 	// setpos(self, pos)
 	static int l_setpos(lua_State *L)
 	{
@@ -2467,7 +2595,7 @@ private:
 		co->setPos(pos);
 		return 0;
 	}
-	
+
 	// moveto(self, pos, continuous=false)
 	static int l_moveto(lua_State *L)
 	{
@@ -2484,7 +2612,7 @@ private:
 		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);
@@ -2493,13 +2621,18 @@ private:
 		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;
 	}
 
@@ -2633,6 +2766,80 @@ private:
 		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)
 	{
@@ -2660,7 +2867,7 @@ private:
 		co->setVelocity(pos);
 		return 0;
 	}
-	
+
 	// getvelocity(self)
 	static int l_getvelocity(lua_State *L)
 	{
@@ -2672,7 +2879,7 @@ private:
 		pushFloatPos(L, v);
 		return 1;
 	}
-	
+
 	// setacceleration(self, {x=num, y=num, z=num})
 	static int l_setacceleration(lua_State *L)
 	{
@@ -2685,7 +2892,7 @@ private:
 		co->setAcceleration(pos);
 		return 0;
 	}
-	
+
 	// getacceleration(self)
 	static int l_getacceleration(lua_State *L)
 	{
@@ -2697,7 +2904,7 @@ private:
 		pushFloatPos(L, v);
 		return 1;
 	}
-	
+
 	// setyaw(self, radians)
 	static int l_setyaw(lua_State *L)
 	{
@@ -2709,7 +2916,7 @@ private:
 		co->setYaw(yaw);
 		return 0;
 	}
-	
+
 	// getyaw(self)
 	static int l_getyaw(lua_State *L)
 	{
@@ -2721,7 +2928,7 @@ private:
 		lua_pushnumber(L, yaw);
 		return 1;
 	}
-	
+
 	// settexturemod(self, mod)
 	static int l_settexturemod(lua_State *L)
 	{
@@ -2733,7 +2940,7 @@ private:
 		co->setTextureMod(mod);
 		return 0;
 	}
-	
+
 	// setsprite(self, p={x=0,y=0}, num_frames=1, framelength=0.2,
 	//           select_horiz_by_yawpitch=false)
 	static int l_setsprite(lua_State *L)
@@ -2770,7 +2977,7 @@ private:
 		lua_pushstring(L, name.c_str());
 		return 1;
 	}
-	
+
 	// get_luaentity(self)
 	static int l_get_luaentity(lua_State *L)
 	{
@@ -2781,7 +2988,7 @@ private:
 		luaentity_get(L, co->getId());
 		return 1;
 	}
-	
+
 	/* Player-only */
 
 	// is_player(self)
@@ -2792,7 +2999,7 @@ private:
 		lua_pushboolean(L, (player != NULL));
 		return 1;
 	}
-	
+
 	// get_player_name(self)
 	static int l_get_player_name(lua_State *L)
 	{
@@ -2806,7 +3013,7 @@ private:
 		lua_pushstring(L, player->getName());
 		return 1;
 	}
-	
+
 	// get_look_dir(self)
 	static int l_get_look_dir(lua_State *L)
 	{
@@ -2843,29 +3050,102 @@ private:
 		return 1;
 	}
 
-public:
-	ObjectRef(ServerActiveObject *object):
-		m_object(object)
+	// set_inventory_formspec(self, formspec)
+	static int l_set_inventory_formspec(lua_State *L)
 	{
-		//infostream<<"ObjectRef created for id="<<m_object->getId()<<std::endl;
-	}
+		ObjectRef *ref = checkobject(L, 1);
+		Player *player = getplayer(ref);
+		if(player == NULL) return 0;
+		std::string formspec = luaL_checkstring(L, 2);
 
-	~ObjectRef()
-	{
-		/*if(m_object)
-			infostream<<"ObjectRef destructing for id="
-					<<m_object->getId()<<std::endl;
-		else
-			infostream<<"ObjectRef destructing for id=unknown"<<std::endl;*/
+		player->inventory_formspec = formspec;
+		get_server(L)->reportInventoryFormspecModified(player->getName());
+		lua_pushboolean(L, true);
+		return 1;
 	}
 
-	// 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)
+	// get_inventory_formspec(self) -> formspec
+	static int l_get_inventory_formspec(lua_State *L)
 	{
-		ObjectRef *o = new ObjectRef(object);
-		//infostream<<"ObjectRef::create: o="<<o<<std::endl;
-		*(void **)(lua_newuserdata(L, sizeof(void *))) = o;
+		ObjectRef *ref = checkobject(L, 1);
+		Player *player = getplayer(ref);
+		if(player == NULL) return 0;
+
+		std::string formspec = player->inventory_formspec;
+		lua_pushlstring(L, formspec.c_str(), formspec.size());
+		return 1;
+	}
+	
+	// get_player_control(self)
+	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)
+	{
+		//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);
 	}
@@ -2875,7 +3155,7 @@ public:
 		ObjectRef *o = checkobject(L, -1);
 		o->m_object = NULL;
 	}
-	
+
 	static void Register(lua_State *L)
 	{
 		lua_newtable(L);
@@ -2921,6 +3201,10 @@ const luaL_reg ObjectRef::methods[] = {
 	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),
@@ -2934,10 +3218,15 @@ const luaL_reg ObjectRef::methods[] = {
 	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),
+	method(ObjectRef, get_player_control),
+	method(ObjectRef, get_player_control_bits),
 	{0,0}
 };
 
@@ -2962,8 +3251,8 @@ class LuaPerlinNoise
 private:
 	int seed;
 	int octaves;
-	double persistence;
-	double scale;
+	float persistence;
+	float scale;
 	static const char className[];
 	static const luaL_reg methods[];
 
@@ -2995,8 +3284,8 @@ private:
 	}
 
 public:
-	LuaPerlinNoise(int a_seed, int a_octaves, double a_persistence,
-			double a_scale):
+	LuaPerlinNoise(int a_seed, int a_octaves, float a_persistence,
+			float a_scale):
 		seed(a_seed),
 		octaves(a_octaves),
 		persistence(a_persistence),
@@ -3014,8 +3303,8 @@ public:
 	{
 		int seed = luaL_checkint(L, 1);
 		int octaves = luaL_checkint(L, 2);
-		double persistence = luaL_checknumber(L, 3);
-		double scale = luaL_checknumber(L, 4);
+		float persistence = luaL_checknumber(L, 3);
+		float scale = luaL_checknumber(L, 4);
 		LuaPerlinNoise *o = new LuaPerlinNoise(seed, octaves, persistence, scale);
 		*(void **)(lua_newuserdata(L, sizeof(void *))) = o;
 		luaL_getmetatable(L, className);
@@ -3066,6 +3355,162 @@ const luaL_reg LuaPerlinNoise::methods[] = {
 	{0,0}
 };
 
+/*
+	NodeTimerRef
+*/
+
+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) {
+		NodeTimerRef *o = *(NodeTimerRef **)(lua_touserdata(L, 1));
+		delete o;
+		return 0;
+	}
+
+	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 *(NodeTimerRef**)ud;  // unbox pointer
+	}
+
+	static int l_set(lua_State *L)
+	{
+		NodeTimerRef *o = checkobject(L, 1);
+		ServerEnvironment *env = o->m_env;
+		if(env == NULL) return 0;
+		f32 t = luaL_checknumber(L,2);
+		f32 e = luaL_checknumber(L,3);
+		env->getMap().setNodeTimer(o->m_p,NodeTimer(t,e));
+		return 0;
+	}
+
+	static int l_start(lua_State *L)
+	{
+		NodeTimerRef *o = checkobject(L, 1);
+		ServerEnvironment *env = o->m_env;
+		if(env == NULL) return 0;
+		f32 t = luaL_checknumber(L,2);
+		env->getMap().setNodeTimer(o->m_p,NodeTimer(t,0));
+		return 0;
+	}
+
+	static int l_stop(lua_State *L)
+	{
+		NodeTimerRef *o = checkobject(L, 1);
+		ServerEnvironment *env = o->m_env;
+		if(env == NULL) return 0;
+		env->getMap().removeNodeTimer(o->m_p);
+		return 0;
+	}
+
+	static int l_is_started(lua_State *L)
+	{
+		NodeTimerRef *o = checkobject(L, 1);
+		ServerEnvironment *env = o->m_env;
+		if(env == NULL) return 0;
+
+		NodeTimer t = env->getMap().getNodeTimer(o->m_p);
+		lua_pushboolean(L,(t.timeout != 0));
+		return 1;
+	}
+
+	static int l_get_timeout(lua_State *L)
+	{
+		NodeTimerRef *o = checkobject(L, 1);
+		ServerEnvironment *env = o->m_env;
+		if(env == NULL) return 0;
+
+		NodeTimer t = env->getMap().getNodeTimer(o->m_p);
+		lua_pushnumber(L,t.timeout);
+		return 1;
+	}
+
+	static int l_get_elapsed(lua_State *L)
+	{
+		NodeTimerRef *o = checkobject(L, 1);
+		ServerEnvironment *env = o->m_env;
+		if(env == NULL) return 0;
+
+		NodeTimer t = env->getMap().getNodeTimer(o->m_p);
+		lua_pushnumber(L,t.elapsed);
+		return 1;
+	}
+
+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
 */
@@ -3091,7 +3536,7 @@ private:
 		if(!ud) luaL_typerror(L, narg, className);
 		return *(EnvRef**)ud;  // unbox pointer
 	}
-	
+
 	// Exported functions
 
 	// EnvRef:set_node(pos, node)
@@ -3106,20 +3551,7 @@ private:
 		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;
 	}
@@ -3140,20 +3572,8 @@ private:
 		// 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;
 	}
 
@@ -3209,7 +3629,7 @@ private:
 		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);
@@ -3299,6 +3719,31 @@ private:
 		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}
 	static int l_add_entity(lua_State *L)
@@ -3379,19 +3824,6 @@ private:
 		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)
 	{
@@ -3548,7 +3980,7 @@ private:
 		lua_getglobal(L, "table");
 		lua_getfield(L, -1, "insert");
 		int table_insert = lua_gettop(L);
-		
+
 		lua_newtable(L);
 		int table = lua_gettop(L);
 		for(s16 x=minp.X; x<=maxp.X; x++)
@@ -3578,8 +4010,8 @@ private:
 
 		int seeddiff = luaL_checkint(L, 2);
 		int octaves = luaL_checkint(L, 3);
-		double persistence = luaL_checknumber(L, 4);
-		double scale = luaL_checknumber(L, 5);
+		float persistence = luaL_checknumber(L, 4);
+		float scale = luaL_checknumber(L, 5);
 
 		LuaPerlinNoise *n = new LuaPerlinNoise(seeddiff + int(env->getServerMap().getSeed()), octaves, persistence, scale);
 		*(void **)(lua_newuserdata(L, sizeof(void *))) = n;
@@ -3588,6 +4020,63 @@ private:
 		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)
@@ -3616,7 +4105,7 @@ public:
 		EnvRef *o = checkobject(L, -1);
 		o->m_env = NULL;
 	}
-	
+
 	static void Register(lua_State *L)
 	{
 		lua_newtable(L);
@@ -3661,6 +4150,7 @@ const luaL_reg EnvRef::methods[] = {
 	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),
@@ -3668,6 +4158,10 @@ const luaL_reg EnvRef::methods[] = {
 	method(EnvRef, find_node_near),
 	method(EnvRef, find_nodes_in_area),
 	method(EnvRef, get_perlin),
+	//method{EnvRef, get_perlin_map_2d},
+	//method{EnvRef, get_perlin_map_3d},
+	method(EnvRef, clear_objects),
+	method(EnvRef, spawn_tree),
 	{0,0}
 };
 
@@ -3685,7 +4179,7 @@ private:
 	static const luaL_reg methods[];
 
 	// Exported functions
-	
+
 	// garbage collector
 	static int gc_object(lua_State *L)
 	{
@@ -3705,6 +4199,10 @@ private:
 			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;
@@ -3732,7 +4230,7 @@ public:
 	{
 		return m_pseudo;
 	}
-	
+
 	// LuaPseudoRandom(seed)
 	// Creates an LuaPseudoRandom and leaves it on top of stack
 	static int create_object(lua_State *L)
@@ -3836,7 +4334,7 @@ public:
 			u32 active_object_count, u32 active_object_count_wider)
 	{
 		lua_State *L = m_lua;
-	
+
 		realitycheck(L);
 		assert(lua_checkstack(L, 20));
 		StackUnroller stack_unroller(L);
@@ -3852,7 +4350,7 @@ public:
 		lua_gettable(L, registered_abms);
 		if(lua_isnil(L, -1))
 			assert(0);
-		
+
 		// Call action
 		luaL_checktype(L, -1, LUA_TTABLE);
 		lua_getfield(L, -1, "action");
@@ -3943,19 +4441,111 @@ static int l_log(lua_State *L)
 	return 0;
 }
 
-// register_item_raw({lots of stuff})
-static int l_register_item_raw(lua_State *L)
+// request_shutdown()
+static int l_request_shutdown(lua_State *L)
 {
-	luaL_checktype(L, 1, LUA_TTABLE);
-	int table = 1;
+	get_server(L)->requestShutdown();
+	return 0;
+}
 
-	// Get the writable item and node definition managers from the server
-	IWritableItemDefManager *idef =
-			get_server(L)->getWritableItemDefManager();
-	IWritableNodeDefManager *ndef =
-			get_server(L)->getWritableNodeDefManager();
+// 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;
+}
 
-	// Check if name is defined
+// register_biome_groups({frequencies})
+static int l_register_biome_groups(lua_State *L)
+{
+	luaL_checktype(L, 1, LUA_TTABLE);
+	int index = 1;
+	if (!lua_istable(L, index))
+		throw LuaError(L, "register_biome_groups: parameter is not a table");
+
+	BiomeDefManager *bmgr = get_server(L)->getBiomeDef();
+	if (!bmgr) {
+		verbosestream << "register_biome_groups: BiomeDefManager not active" << std::endl;
+		return 0;
+	}
+
+	lua_pushnil(L);
+	for (int i = 1; lua_next(L, index) != 0; i++) {
+		bmgr->addBiomeGroup(lua_tonumber(L, -1));
+		lua_pop(L, 1);
+	}
+	lua_pop(L, 1);
+
+	return 0;
+}
+
+// register_biome({lots of stuff})
+static int l_register_biome(lua_State *L)
+{
+	luaL_checktype(L, 1, LUA_TTABLE);
+	int index = 1, groupid;
+	std::string nodename;
+
+	IWritableNodeDefManager *ndef = get_server(L)->getWritableNodeDefManager();
+	BiomeDefManager *bmgr = get_server(L)->getBiomeDef();
+	if (!bmgr) {
+		verbosestream << "register_biome: BiomeDefManager not active" << std::endl;
+		return 0;
+	}
+
+	groupid = getintfield_default(L, index, "group_id", 0);
+
+	enum BiomeTerrainType terrain = (BiomeTerrainType)getenumfield(L, index,
+					"terrain_type", es_BiomeTerrainType, BIOME_TERRAIN_NORMAL);
+	Biome *b = bmgr->createBiome(terrain);
+
+	b->name = getstringfield_default(L, index, "name", "");
+
+	if (getstringfield(L, index, "node_top", nodename))
+		b->n_top = MapNode(ndef->getId(nodename));
+	else
+		b->n_top = MapNode(CONTENT_IGNORE);
+
+	if (getstringfield(L, index, "node_filler", nodename))
+		b->n_filler = MapNode(ndef->getId(nodename));
+	else
+		b->n_filler = b->n_top;
+
+	b->ntopnodes = getintfield_default(L, index, "num_top_nodes", 0);
+
+	b->height_min   = getintfield_default(L, index, "height_min", 0);
+	b->height_max   = getintfield_default(L, index, "height_max", 0);
+	b->heat_min     = getfloatfield_default(L, index, "heat_min", 0.);
+	b->heat_max     = getfloatfield_default(L, index, "heat_max", 0.);
+	b->humidity_min = getfloatfield_default(L, index, "humidity_min", 0.);
+	b->humidity_max = getfloatfield_default(L, index, "humidity_max", 0.);
+
+	b->np = new NoiseParams; // should read an entire NoiseParams later on...
+	getfloatfield(L, index, "scale", b->np->scale);
+	getfloatfield(L, index, "offset", b->np->offset);
+
+	b->groupid = (s8)groupid;
+	b->flags   = 0; //reserved
+
+	bmgr->addBiome(b);
+
+	verbosestream << "register_biome: " << b->name << std::endl;
+	return 0;
+}
+
+// register_item_raw({lots of stuff})
+static int l_register_item_raw(lua_State *L)
+{
+	luaL_checktype(L, 1, LUA_TTABLE);
+	int table = 1;
+
+	// Get the writable item and node definition managers from the server
+	IWritableItemDefManager *idef =
+			get_server(L)->getWritableItemDefManager();
+	IWritableNodeDefManager *ndef =
+			get_server(L)->getWritableNodeDefManager();
+
+	// Check if name is defined
 	std::string name;
 	lua_getfield(L, table, "name");
 	if(lua_isstring(L, -1)){
@@ -3982,7 +4572,7 @@ static int l_register_item_raw(lua_State *L)
 		else
 			def.node_placement_prediction = "";
 	}
-	
+
 	// Register item definition
 	idef->registerItem(def);
 
@@ -4005,9 +4595,9 @@ static int l_register_alias_raw(lua_State *L)
 	// Get the writable item definition manager from the server
 	IWritableItemDefManager *idef =
 			get_server(L)->getWritableItemDefManager();
-	
+
 	idef->registerAlias(name, convert_to);
-	
+
 	return 0; /* number of results */
 }
 
@@ -4116,7 +4706,7 @@ static int l_register_craft(lua_State *L)
 	// Get the writable craft definition manager from the server
 	IWritableCraftDefManager *craftdef =
 			get_server(L)->getWritableCraftDefManager();
-	
+
 	std::string type = getstringfield_default(L, table, "type", "shaped");
 
 	/*
@@ -4333,6 +4923,56 @@ static int l_get_player_privs(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)
 {
@@ -4346,8 +4986,11 @@ 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)
 		InvRef::create(L, loc);
 	else
@@ -4355,6 +4998,36 @@ static int l_get_inventory(lua_State *L)
 	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;
+}
+
+// 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)
 {
@@ -4409,6 +5082,60 @@ static int l_get_modpath(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)
 {
@@ -4480,7 +5207,7 @@ static int l_get_craft_result(lua_State *L)
 	lua_getfield(L, input_i, "items");
 	std::vector<ItemStack> items = read_items(L, -1);
 	lua_pop(L, 1); // items
-	
+
 	IGameDef *gdef = get_server(L);
 	ICraftDefManager *cdef = gdef->cdef();
 	CraftInput input(method, width, items);
@@ -4508,23 +5235,136 @@ static int l_get_craft_result(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},
+	{"register_biome", l_register_biome},
+	{"register_biome_groups", l_register_biome_groups},
 	{"setting_set", l_setting_set},
 	{"setting_get", l_setting_get},
 	{"setting_getbool", l_setting_getbool},
 	{"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},
 	{"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},
@@ -4532,6 +5372,9 @@ static const struct luaL_Reg minetest_f [] = {
 	{"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}
 };
 
@@ -4554,7 +5397,7 @@ void scriptapi_export(lua_State *L, Server *server)
 	lua_newtable(L);
 	luaL_register(L, NULL, minetest_f);
 	lua_setglobal(L, "minetest");
-	
+
 	// Get the main minetest table
 	lua_getglobal(L, "minetest");
 
@@ -4568,6 +5411,7 @@ void scriptapi_export(lua_State *L, Server *server)
 	LuaItemStack::Register(L);
 	InvRef::Register(L);
 	NodeMetaRef::Register(L);
+	NodeTimerRef::Register(L);
 	ObjectRef::Register(L);
 	EnvRef::Register(L);
 	LuaPseudoRandom::Register(L);
@@ -4586,7 +5430,7 @@ bool scriptapi_loadmod(lua_State *L, const std::string &scriptpath,
 				<<"Only chararacters [a-z0-9_] are allowed."<<std::endl;
 		return false;
 	}
-	
+
 	bool success = false;
 
 	try{
@@ -4630,7 +5474,7 @@ void scriptapi_add_environment(lua_State *L, ServerEnvironment *env)
 	lua_getfield(L, -1, "registered_abms");
 	luaL_checktype(L, -1, LUA_TTABLE);
 	int registered_abms = lua_gettop(L);
-	
+
 	if(lua_istable(L, registered_abms)){
 		int table = lua_gettop(L);
 		lua_pushnil(L);
@@ -4681,7 +5525,7 @@ void scriptapi_add_environment(lua_State *L, ServerEnvironment *env)
 
 			LuaABM *abm = new LuaABM(L, id, trigger_contents,
 					required_neighbors, trigger_interval, trigger_chance);
-			
+
 			env->addActiveBlockModifier(abm);
 
 			// removes value, keeps key for next iteration
@@ -4725,7 +5569,7 @@ void scriptapi_add_object_reference(lua_State *L, ServerActiveObject *cobj)
 	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
@@ -4744,7 +5588,7 @@ void scriptapi_rm_object_reference(lua_State *L, ServerActiveObject *cobj)
 	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);
@@ -4840,16 +5684,16 @@ static void scriptapi_run_callbacks(lua_State *L, int nargs,
 				lua_replace(L, rv);
 			else if(mode == RUN_CALLBACKS_MODE_AND ||
 					mode == RUN_CALLBACKS_MODE_AND_SC){
-				if(lua_toboolean(L, rv) == true &&
-						lua_toboolean(L, -1) == false)
+				if((bool)lua_toboolean(L, rv) == true &&
+						(bool)lua_toboolean(L, -1) == false)
 					lua_replace(L, rv);
 				else
 					lua_pop(L, 1);
 			}
 			else if(mode == RUN_CALLBACKS_MODE_OR ||
 					mode == RUN_CALLBACKS_MODE_OR_SC){
-				if(lua_toboolean(L, rv) == false &&
-						lua_toboolean(L, -1) == true)
+				if((bool)lua_toboolean(L, rv) == false &&
+						(bool)lua_toboolean(L, -1) == true)
 					lua_replace(L, rv);
 				else
 					lua_pop(L, 1);
@@ -4860,10 +5704,10 @@ static void scriptapi_run_callbacks(lua_State *L, int nargs,
 
 		// Handle short circuit modes
 		if(mode == RUN_CALLBACKS_MODE_AND_SC &&
-				lua_toboolean(L, rv) == false)
+				(bool)lua_toboolean(L, rv) == false)
 			break;
 		else if(mode == RUN_CALLBACKS_MODE_OR_SC &&
-				lua_toboolean(L, rv) == true)
+				(bool)lua_toboolean(L, rv) == true)
 			break;
 
 		// value removed, keep key for next iteration
@@ -4905,6 +5749,19 @@ bool scriptapi_on_chat_message(lua_State *L, const std::string &name,
 	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);
@@ -4977,21 +5834,6 @@ void scriptapi_on_leaveplayer(lua_State *L, ServerActiveObject *player)
 	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");
@@ -5010,7 +5852,7 @@ bool scriptapi_get_auth(lua_State *L, const std::string &playername,
 	realitycheck(L);
 	assert(lua_checkstack(L, 20));
 	StackUnroller stack_unroller(L);
-	
+
 	get_auth_handler(L);
 	lua_getfield(L, -1, "get_auth");
 	if(lua_type(L, -1) != LUA_TFUNCTION)
@@ -5018,12 +5860,12 @@ bool scriptapi_get_auth(lua_State *L, const std::string &playername,
 	lua_pushstring(L, playername.c_str());
 	if(lua_pcall(L, 1, 1, 0))
 		script_error(L, "error: %s", lua_tostring(L, -1));
-	
+
 	// nil = login not allowed
 	if(lua_isnil(L, -1))
 		return false;
 	luaL_checktype(L, -1, LUA_TTABLE);
-	
+
 	std::string password;
 	bool found = getstringfield(L, -1, "password", password);
 	if(!found)
@@ -5038,7 +5880,7 @@ bool scriptapi_get_auth(lua_State *L, const std::string &playername,
 	if(dst_privs)
 		read_privileges(L, -1, *dst_privs);
 	lua_pop(L, 1);
-	
+
 	return true;
 }
 
@@ -5048,7 +5890,7 @@ void scriptapi_create_auth(lua_State *L, const std::string &playername,
 	realitycheck(L);
 	assert(lua_checkstack(L, 20));
 	StackUnroller stack_unroller(L);
-	
+
 	get_auth_handler(L);
 	lua_getfield(L, -1, "create_auth");
 	if(lua_type(L, -1) != LUA_TFUNCTION)
@@ -5065,7 +5907,7 @@ bool scriptapi_set_password(lua_State *L, const std::string &playername,
 	realitycheck(L);
 	assert(lua_checkstack(L, 20));
 	StackUnroller stack_unroller(L);
-	
+
 	get_auth_handler(L);
 	lua_getfield(L, -1, "set_password");
 	if(lua_type(L, -1) != LUA_TFUNCTION)
@@ -5077,6 +5919,40 @@ bool scriptapi_set_password(lua_State *L, const std::string &playername,
 	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
 */
@@ -5085,6 +5961,8 @@ bool scriptapi_set_password(lua_State *L, const std::string &playername,
 // 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)
 {
@@ -5097,9 +5975,15 @@ static bool get_item_callback(lua_State *L,
 	// 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);
@@ -5287,31 +6171,54 @@ void scriptapi_node_after_destruct(lua_State *L, v3s16 p, MapNode node)
 		script_error(L, "error: %s", lua_tostring(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)
+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();
-	
-	// 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;
+	if(!get_item_callback(L, ndef->get(node).name.c_str(), "on_timer"))
+		return false;
 
 	// Call function
-	// param 1
 	push_v3s16(L, p);
-	// param 2
-	lua_pushstring(L, formname.c_str());
+	lua_pushnumber(L,dtime);
+	if(lua_pcall(L, 2, 1, 0))
+		script_error(L, "error: %s", lua_tostring(L, -1));
+	if((bool)lua_isboolean(L,-1) && (bool)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
@@ -5328,7 +6235,134 @@ void scriptapi_node_on_receive_fields(lua_State *L, v3s16 p,
 		script_error(L, "error: %s", lua_tostring(L, -1));
 }
 
-void scriptapi_node_on_metadata_inventory_move(lua_State *L, v3s16 p,
+/*
+	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));
+	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 0;
+
+	// Push callback function on stack
+	if(!get_item_callback(L, ndef->get(node).name.c_str(),
+			"allow_metadata_inventory_move"))
+		return count;
+
+	// 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, 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);
+}
+
+// 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));
+	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 0;
+
+	// Push callback function on stack
+	if(!get_item_callback(L, ndef->get(node).name.c_str(),
+			"allow_metadata_inventory_put"))
+		return stack.count;
+
+	// 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))
+		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, 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 0;
+
+	// Push callback function on stack
+	if(!get_item_callback(L, ndef->get(node).name.c_str(),
+			"allow_metadata_inventory_take"))
+		return stack.count;
+
+	// Call function(pos, listname, index, count, 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))
+		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 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)
@@ -5350,18 +6384,26 @@ void scriptapi_node_on_metadata_inventory_move(lua_State *L, v3s16 p,
 		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)
 {
@@ -5374,26 +6416,31 @@ ItemStack scriptapi_node_on_metadata_inventory_offer(lua_State *L, v3s16 p,
 	// 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);
@@ -5405,22 +6452,276 @@ ItemStack scriptapi_node_on_metadata_inventory_take(lua_State *L, v3s16 p,
 	// 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));
 }
 
 /*
@@ -5471,7 +6772,7 @@ bool scriptapi_luaentity_add(lua_State *L, u16 id, const char *name)
 	verbosestream<<"scriptapi_luaentity_add: id="<<id<<" name=\""
 			<<name<<"\""<<std::endl;
 	StackUnroller stack_unroller(L);
-	
+
 	// Get minetest.registered_entities[name]
 	lua_getglobal(L, "minetest");
 	lua_getfield(L, -1, "registered_entities");
@@ -5486,7 +6787,7 @@ bool scriptapi_luaentity_add(lua_State *L, u16 id, const char *name)
 	}
 	int prototype_table = lua_gettop(L);
 	//dump2(L, "prototype_table");
-	
+
 	// Create entity object
 	lua_newtable(L);
 	int object = lua_gettop(L);
@@ -5494,7 +6795,7 @@ bool scriptapi_luaentity_add(lua_State *L, u16 id, const char *name)
 	// Set object metatable
 	lua_pushvalue(L, prototype_table);
 	lua_setmetatable(L, -2);
-	
+
 	// Add object reference
 	// This should be userdata with metatable ObjectRef
 	objectref_get(L, id);
@@ -5510,22 +6811,22 @@ bool scriptapi_luaentity_add(lua_State *L, u16 id, const char *name)
 	lua_pushnumber(L, id); // Push id
 	lua_pushvalue(L, object); // Copy object to top of stack
 	lua_settable(L, -3);
-	
+
 	return true;
 }
 
 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));
 	verbosestream<<"scriptapi_luaentity_activate: id="<<id<<std::endl;
 	StackUnroller stack_unroller(L);
-	
+
 	// Get minetest.luaentities[id]
 	luaentity_get(L, id);
 	int object = lua_gettop(L);
-	
+
 	// Get on_activate function
 	lua_pushvalue(L, object);
 	lua_getfield(L, -1, "on_activate");
@@ -5533,8 +6834,9 @@ void scriptapi_luaentity_activate(lua_State *L, u16 id,
 		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));
 	}
@@ -5551,12 +6853,12 @@ void scriptapi_luaentity_rm(lua_State *L, u16 id)
 	lua_getfield(L, -1, "luaentities");
 	luaL_checktype(L, -1, LUA_TTABLE);
 	int objectstable = lua_gettop(L);
-	
+
 	// Set luaentities[id] = nil
 	lua_pushnumber(L, id); // Push id
 	lua_pushnil(L);
 	lua_settable(L, objectstable);
-	
+
 	lua_pop(L, 2); // pop luaentities, minetest
 }
 
@@ -5570,20 +6872,20 @@ std::string scriptapi_luaentity_get_staticdata(lua_State *L, u16 id)
 	// Get minetest.luaentities[id]
 	luaentity_get(L, id);
 	int object = lua_gettop(L);
-	
+
 	// Get get_staticdata function
 	lua_pushvalue(L, object);
 	lua_getfield(L, -1, "get_staticdata");
 	if(lua_isnil(L, -1))
 		return "";
-	
+
 	luaL_checktype(L, -1, LUA_TFUNCTION);
 	lua_pushvalue(L, object); // self
 	// Call with 1 arguments, 1 results
 	if(lua_pcall(L, 1, 1, 0))
 		script_error(L, "error running function get_staticdata: %s\n",
 				lua_tostring(L, -1));
-	
+
 	size_t len=0;
 	const char *s = lua_tolstring(L, -1, &len);
 	return std::string(s, len);
@@ -5603,10 +6905,27 @@ void scriptapi_luaentity_get_properties(lua_State *L, u16 id,
 
 	// 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);
+
+	getstringfield(L, -1, "mesh", prop->mesh);
+
 	// Deprecated: read object properties directly
 	read_object_properties(L, -1, prop);
-	
+
 	// Read initial_properties
 	lua_getfield(L, -1, "initial_properties");
 	read_object_properties(L, -1, prop);