19 files changed, 2312 insertions, 400 deletions

diff --git a/src/Bindings/AllToLua.bat b/src/Bindings/AllToLua.bat
index b2a192880..f085af9e9 100644
--- a/src/Bindings/AllToLua.bat
+++ b/src/Bindings/AllToLua.bat
@@ -4,17 +4,21 @@
 :: When called without any parameters, it will pause for a keypress at the end
 :: Call with any parameter to disable the wait (for buildserver use)
 
+@echo off
+
 
 
 
 
 :: Regenerate the files:
+echo Regenerating LUA bindings . . .
 "tolua++.exe" -L virtual_method_hooks.lua -o Bindings.cpp -H Bindings.h AllToLua.pkg
 
 
 
 
 : Wait for keypress, if no param given:
+echo.
 if %ALLTOLUA_WAIT%N == N pause
 
 
diff --git a/src/Bindings/AllToLua.pkg b/src/Bindings/AllToLua.pkg
index f65aed9bb..1cd7c74f8 100644
--- a/src/Bindings/AllToLua.pkg
+++ b/src/Bindings/AllToLua.pkg
@@ -11,6 +11,7 @@ typedef unsigned int       UInt32;
 typedef unsigned short     UInt16;
 
 
+$cfile "../Vector3.h"
 $cfile "../ChunkDef.h"
 $cfile "../BiomeDef.h"
 
@@ -26,6 +27,7 @@ $cfile "WebPlugin.h"
 $cfile "LuaWindow.h"
 
 $cfile "../BlockID.h"
+$cfile "../BlockInfo.h"
 $cfile "../StringUtils.h"
 $cfile "../Defines.h"
 $cfile "../ChatColor.h"
@@ -34,6 +36,7 @@ $cfile "../Entities/Entity.h"
 $cfile "../Entities/Floater.h"
 $cfile "../Entities/Pawn.h"
 $cfile "../Entities/Player.h"
+$cfile "../Entities/Painting.h"
 $cfile "../Entities/Pickup.h"
 $cfile "../Entities/ProjectileEntity.h"
 $cfile "../Entities/TNTEntity.h"
@@ -47,6 +50,7 @@ $cfile "../ItemGrid.h"
 $cfile "../BlockEntities/BlockEntity.h"
 $cfile "../BlockEntities/BlockEntityWithItems.h"
 $cfile "../BlockEntities/ChestEntity.h"
+$cfile "../BlockEntities/CommandBlockEntity.h"
 $cfile "../BlockEntities/DropSpenserEntity.h"
 $cfile "../BlockEntities/DispenserEntity.h"
 $cfile "../BlockEntities/DropperEntity.h"
@@ -55,12 +59,10 @@ $cfile "../BlockEntities/HopperEntity.h"
 $cfile "../BlockEntities/JukeboxEntity.h"
 $cfile "../BlockEntities/NoteEntity.h"
 $cfile "../BlockEntities/SignEntity.h"
+$cfile "../BlockEntities/MobHeadEntity.h"
+$cfile "../BlockEntities/FlowerPotEntity.h"
 $cfile "../WebAdmin.h"
 $cfile "../Root.h"
-$cfile "../Vector3f.h"
-$cfile "../Vector3d.h"
-$cfile "../Vector3i.h"
-$cfile "../Matrix4f.h"
 $cfile "../Cuboid.h"
 $cfile "../BoundingBox.h"
 $cfile "../Tracer.h"
@@ -70,6 +72,10 @@ $cfile "../Generating/ChunkDesc.h"
 $cfile "../CraftingRecipes.h"
 $cfile "../UI/Window.h"
 $cfile "../Mobs/Monster.h"
+$cfile "../CompositeChat.h"
+$cfile "../Map.h"
+$cfile "../MapManager.h"
+$cfile "../Scoreboard.h"
 
 
 
@@ -82,3 +88,16 @@ class cLineBlockTracer;
 
 
 
+
+// To avoid tolua treating Byte as a class, and avoid the need to $cfile entire Globals.h:
+typedef unsigned char Byte;
+
+
+
+// Aliases
+$renaming Vector3<double> @ Vector3d
+$renaming Vector3<float>  @ Vector3f
+$renaming Vector3<int>    @ Vector3i
+
+
+
diff --git a/src/Bindings/CMakeLists.txt b/src/Bindings/CMakeLists.txt
deleted file mode 100644
index 50b81e42a..000000000
--- a/src/Bindings/CMakeLists.txt
+++ /dev/null
@@ -1,24 +0,0 @@
-
-cmake_minimum_required (VERSION 2.6)
-project (MCServer)
-
-# NOTE: This CMake file is processed only for Unix builds; Windows(MSVC) builds handle all the subfolders in /src in a single file, /src/CMakeLists.txt
-
-include_directories ("${PROJECT_SOURCE_DIR}/../")
-
-ADD_CUSTOM_COMMAND(
-	# add any new generated bindings here
-	OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/Bindings.cpp ${CMAKE_CURRENT_SOURCE_DIR}/Bindings.h
-	
-	# command execuded to regerate bindings
-	COMMAND tolua -L virtual_method_hooks.lua -o Bindings.cpp -H Bindings.h AllToLua.pkg
-	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-	
-	# add any new generation dependencies here
-	DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/virtual_method_hooks.lua ${CMAKE_CURRENT_SOURCE_DIR}/AllToLua.pkg tolua
-)
-
-#add cpp files here
-add_library(Bindings PluginManager LuaState WebPlugin Bindings ManualBindings LuaWindow Plugin PluginLua WebPlugin)
-
-target_link_libraries(Bindings lua sqlite tolualib)
diff --git a/src/Bindings/DeprecatedBindings.cpp b/src/Bindings/DeprecatedBindings.cpp
new file mode 100644
index 000000000..d51ba2da3
--- /dev/null
+++ b/src/Bindings/DeprecatedBindings.cpp
@@ -0,0 +1,275 @@
+
+#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+
+#include "DeprecatedBindings.h"
+#undef TOLUA_TEMPLATE_BIND
+#include "tolua++/include/tolua++.h"
+
+#include "Plugin.h"
+#include "PluginLua.h"
+#include "PluginManager.h"
+#include "LuaWindow.h"
+#include "LuaChunkStay.h"
+
+#include "../BlockInfo.h"
+
+
+
+
+
+/* get function: g_BlockLightValue */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockLightValue
+static int tolua_get_AllToLua_g_BlockLightValue(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+		{
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+		}
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushnumber(tolua_S,(lua_Number)cBlockInfo::GetLightValue((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* get function: g_BlockSpreadLightFalloff */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockSpreadLightFalloff
+static int tolua_get_AllToLua_g_BlockSpreadLightFalloff(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushnumber(tolua_S, (lua_Number)cBlockInfo::GetSpreadLightFalloff((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* get function: g_BlockTransparent */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockTransparent
+static int tolua_get_AllToLua_g_BlockTransparent(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushboolean(tolua_S, cBlockInfo::IsTransparent((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* get function: g_BlockOneHitDig */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockOneHitDig
+static int tolua_get_AllToLua_g_BlockOneHitDig(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushboolean(tolua_S, cBlockInfo::IsOneHitDig((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* get function: g_BlockPistonBreakable */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockPistonBreakable
+static int tolua_get_AllToLua_g_BlockPistonBreakable(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushboolean(tolua_S, cBlockInfo::IsPistonBreakable((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* get function: g_BlockIsSnowable */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockIsSnowable
+static int tolua_get_AllToLua_g_BlockIsSnowable(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushboolean(tolua_S, cBlockInfo::IsSnowable((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* get function: g_BlockRequiresSpecialTool */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockRequiresSpecialTool
+static int tolua_get_AllToLua_g_BlockRequiresSpecialTool(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushboolean(tolua_S, cBlockInfo::RequiresSpecialTool((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* get function: g_BlockIsSolid */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockIsSolid
+static int tolua_get_AllToLua_g_BlockIsSolid(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushboolean(tolua_S, (bool)cBlockInfo::IsSolid((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* get function: g_BlockFullyOccupiesVoxel */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockFullyOccupiesVoxel
+static int tolua_get_AllToLua_g_BlockFullyOccupiesVoxel(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushboolean(tolua_S, (bool)cBlockInfo::FullyOccupiesVoxel((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+void DeprecatedBindings::Bind(lua_State * tolua_S)
+{
+	tolua_beginmodule(tolua_S, NULL);
+
+	tolua_array(tolua_S, "g_BlockLightValue",          tolua_get_AllToLua_g_BlockLightValue,          NULL);
+	tolua_array(tolua_S, "g_BlockSpreadLightFalloff",  tolua_get_AllToLua_g_BlockSpreadLightFalloff,  NULL);
+	tolua_array(tolua_S, "g_BlockTransparent",         tolua_get_AllToLua_g_BlockTransparent,         NULL);
+	tolua_array(tolua_S, "g_BlockOneHitDig",           tolua_get_AllToLua_g_BlockOneHitDig,           NULL);
+	tolua_array(tolua_S, "g_BlockPistonBreakable",     tolua_get_AllToLua_g_BlockPistonBreakable,     NULL);
+	tolua_array(tolua_S, "g_BlockIsSnowable",          tolua_get_AllToLua_g_BlockIsSnowable,          NULL);
+	tolua_array(tolua_S, "g_BlockRequiresSpecialTool", tolua_get_AllToLua_g_BlockRequiresSpecialTool, NULL);
+	tolua_array(tolua_S, "g_BlockIsSolid",             tolua_get_AllToLua_g_BlockIsSolid,             NULL);
+	tolua_array(tolua_S, "g_BlockFullyOccupiesVoxel",  tolua_get_AllToLua_g_BlockFullyOccupiesVoxel,  NULL);
+
+	tolua_endmodule(tolua_S);
+}
+
+
+
+
diff --git a/src/Bindings/DeprecatedBindings.h b/src/Bindings/DeprecatedBindings.h
new file mode 100644
index 000000000..5fc3cfa80
--- /dev/null
+++ b/src/Bindings/DeprecatedBindings.h
@@ -0,0 +1,8 @@
+#pragma once
+
+struct lua_State;
+class DeprecatedBindings
+{
+public:
+	static void Bind( lua_State* tolua_S );
+};
diff --git a/src/Bindings/LuaChunkStay.cpp b/src/Bindings/LuaChunkStay.cpp
new file mode 100644
index 000000000..db865cfa4
--- /dev/null
+++ b/src/Bindings/LuaChunkStay.cpp
@@ -0,0 +1,170 @@
+
+// LuaChunkStay.cpp
+
+// Implements the cLuaChunkStay class representing a cChunkStay binding for plugins, used by cWorld:ChunkStay() Lua API
+
+#include "Globals.h"
+#include "LuaChunkStay.h"
+#include "PluginLua.h"
+#include "../World.h"
+
+
+
+
+
+cLuaChunkStay::cLuaChunkStay(cPluginLua & a_Plugin) :
+	m_Plugin(a_Plugin),
+	m_LuaState(NULL)
+{
+}
+
+
+
+
+
+bool cLuaChunkStay::AddChunks(int a_ChunkCoordTableStackPos)
+{
+	// This function is expected to be called just once, with all the coords in a table
+	ASSERT(m_Chunks.empty());
+	
+	cPluginLua::cOperation Op(m_Plugin);
+	cLuaState & L = Op();
+	
+	// Check that we got a table:
+	if (!lua_istable(L, a_ChunkCoordTableStackPos))
+	{
+		LOGWARNING("%s: The parameter is not a table of coords (got %s). Ignoring the call.",
+			__FUNCTION__, lua_typename(L, lua_type(L, a_ChunkCoordTableStackPos))
+		);
+		L.LogStackTrace();
+		return false;
+	}
+	
+	// Add each set of coords:
+	int NumChunks = luaL_getn(L, a_ChunkCoordTableStackPos);
+	m_Chunks.reserve(NumChunks);
+	for (int idx = 1; idx <= NumChunks; idx++)
+	{
+		// Push the idx-th element of the array onto stack top, check that it's a table:
+		lua_rawgeti(L, a_ChunkCoordTableStackPos, idx);
+		if (!lua_istable(L, -1))
+		{
+			LOGWARNING("%s: Element #%d is not a table (got %s). Ignoring the element.",
+				__FUNCTION__, idx, lua_typename(L, -1)
+			);
+			L.LogStackTrace();
+			lua_pop(L, 1);
+			continue;
+		}
+		AddChunkCoord(L, idx);
+		lua_pop(L, 1);
+	}
+	
+	// If there are no chunks, log a warning and return failure:
+	if (m_Chunks.empty())
+	{
+		LOGWARNING("%s: Zero chunks to stay.", __FUNCTION__);
+		L.LogStackTrace();
+		return false;
+	}
+	
+	// All ok
+	return true;
+}
+
+
+
+
+
+void cLuaChunkStay::AddChunkCoord(cLuaState & L, int a_Index)		
+{
+	// Check that the element has 2 coords:
+	int NumCoords = luaL_getn(L, -1);
+	if (NumCoords != 2)
+	{
+		LOGWARNING("%s: Element #%d doesn't contain 2 coords (got %d). Ignoring the element.",
+			__FUNCTION__, a_Index, NumCoords
+		);
+		return;
+	}
+	
+	// Read the two coords from the element:
+	lua_rawgeti(L, -1, 1);
+	lua_rawgeti(L, -2, 2);
+	int ChunkX = luaL_checkint(L, -2);
+	int ChunkZ = luaL_checkint(L, -1);
+	lua_pop(L, 2);
+	
+	// Check that a coord is not yet present:
+	for (cChunkCoordsVector::iterator itr = m_Chunks.begin(), end = m_Chunks.end(); itr != end; ++itr)
+	{
+		if ((itr->m_ChunkX == ChunkX) && (itr->m_ChunkZ == ChunkZ))
+		{
+			LOGWARNING("%s: Element #%d is a duplicate, ignoring it.",
+				__FUNCTION__, a_Index
+			);
+			return;
+		}
+	}  // for itr - m_Chunks[]
+	
+	m_Chunks.push_back(cChunkCoords(ChunkX, ZERO_CHUNK_Y, ChunkZ));
+}
+
+
+
+
+
+void cLuaChunkStay::Enable(cChunkMap & a_ChunkMap, int a_OnChunkAvailableStackPos, int a_OnAllChunksAvailableStackPos)
+{
+	// Get the references to the callback functions:
+	m_LuaState = &m_Plugin.GetLuaState();
+	m_OnChunkAvailable.RefStack(*m_LuaState, a_OnChunkAvailableStackPos);
+	m_OnAllChunksAvailable.RefStack(*m_LuaState, a_OnAllChunksAvailableStackPos);
+	
+	// Enable the ChunkStay:
+	super::Enable(a_ChunkMap);
+}
+
+
+
+
+
+void cLuaChunkStay::OnChunkAvailable(int a_ChunkX, int a_ChunkZ)
+{
+	cPluginLua::cOperation Op(m_Plugin);
+	Op().Call((int)m_OnChunkAvailable, a_ChunkX, a_ChunkZ);
+}
+
+
+
+
+
+bool cLuaChunkStay::OnAllChunksAvailable(void)
+{
+	{
+		// Call the callback:
+		cPluginLua::cOperation Op(m_Plugin);
+		Op().Call((int)m_OnAllChunksAvailable);
+		
+		// Remove the callback references - they won't be needed anymore
+		m_OnChunkAvailable.UnRef();
+		m_OnAllChunksAvailable.UnRef();
+	}
+	
+	// Disable the ChunkStay by returning true
+	return true;
+}
+
+
+
+
+
+void cLuaChunkStay::OnDisabled(void)
+{
+	// This object is no longer needed, delete it
+	delete this;
+}
+
+
+
+
diff --git a/src/Bindings/LuaChunkStay.h b/src/Bindings/LuaChunkStay.h
new file mode 100644
index 000000000..49ab9a0ad
--- /dev/null
+++ b/src/Bindings/LuaChunkStay.h
@@ -0,0 +1,73 @@
+
+// LuaChunkStay.h
+
+// Declares the cLuaChunkStay class representing a cChunkStay binding for plugins, used by cWorld:ChunkStay() Lua API
+
+
+
+
+
+#pragma once
+
+#include "LuaState.h"
+#include "../ChunkStay.h"
+
+
+
+
+
+// fwd:
+class cPluginLua;
+
+
+
+
+
+class cLuaChunkStay
+	: public cChunkStay
+{
+	typedef cChunkStay super;
+	
+public:
+	cLuaChunkStay(cPluginLua & a_Plugin);
+	
+	~cLuaChunkStay() { }
+
+	/** Adds chunks in the specified on-stack Lua table.
+	Returns true if any chunk added, false (plus log warning) if none. */
+	bool AddChunks(int a_ChunkCoordTableStackPos);
+	
+	/** Enables the ChunkStay for the specified chunkmap, with the specified Lua callbacks. */
+	void Enable(cChunkMap & a_ChunkMap, int a_OnChunkAvailableStackPos, int a_OnAllChunksAvailableStackPos);
+	
+protected:
+	/** The plugin which has created the ChunkStay, via cWorld:ChunkStay() binding method.  */
+	cPluginLua & m_Plugin;
+	
+	/** The Lua state associated with the callbacks. Only valid when enabled. */
+	cLuaState * m_LuaState;
+	
+	/** The Lua function to call in OnChunkAvailable. Only valid when enabled. */
+	cLuaState::cRef m_OnChunkAvailable;
+	
+	/** The Lua function to call in OnAllChunksAvailable. Only valid when enabled. */
+	cLuaState::cRef m_OnAllChunksAvailable;
+	
+	
+	// cChunkStay overrides:
+	virtual void OnChunkAvailable(int a_ChunkX, int a_ChunkZ) override;
+	virtual bool OnAllChunksAvailable(void) override;
+	virtual void OnDisabled(void) override;
+	
+	/** Adds a single chunk coord from the table at the top of the Lua stack.
+	Expects the top element to be a table, checks that it contains two numbers.
+	Uses those two numbers as chunk coords appended to m_Chunks.
+	If the coords are already present, gives a warning and ignores the pair.
+	The a_Index parameter is only for the error messages. */
+	void AddChunkCoord(cLuaState & a_LuaState, int a_Index);
+} ;
+
+
+
+
+
diff --git a/src/Bindings/LuaState.cpp b/src/Bindings/LuaState.cpp
index bfee1d037..a33459ad2 100644
--- a/src/Bindings/LuaState.cpp
+++ b/src/Bindings/LuaState.cpp
@@ -11,9 +11,11 @@ extern "C"
 	#include "lua/src/lualib.h"
 }
 
+#undef TOLUA_TEMPLATE_BIND
 #include "tolua++/include/tolua++.h"
 #include "Bindings.h"
 #include "ManualBindings.h"
+#include "DeprecatedBindings.h"
 
 // fwd: SQLite/lsqlite3.c
 extern "C"
@@ -93,11 +95,20 @@ void cLuaState::Create(void)
 	}
 	m_LuaState = lua_open();
 	luaL_openlibs(m_LuaState);
+	m_IsOwned = true;
+}
+
+
+
+
+
+void cLuaState::RegisterAPILibs(void)
+{
 	tolua_AllToLua_open(m_LuaState);
 	ManualBindings::Bind(m_LuaState);
+	DeprecatedBindings::Bind(m_LuaState);
 	luaopen_lsqlite3(m_LuaState);
 	luaopen_lxp(m_LuaState);
-	m_IsOwned = true;
 }
 
 
@@ -173,6 +184,31 @@ void cLuaState::Detach(void)
 
 
 
+void cLuaState::AddPackagePath(const AString & a_PathVariable, const AString & a_Path)
+{
+	// Get the current path:
+	lua_getfield(m_LuaState, LUA_GLOBALSINDEX, "package");                           // Stk: <package>
+	lua_getfield(m_LuaState, -1, a_PathVariable.c_str());                            // Stk: <package> <package.path>
+	size_t len = 0;
+	const char * PackagePath = lua_tolstring(m_LuaState, -1, &len);
+	
+	// Append the new path:
+	AString NewPackagePath(PackagePath, len);
+	NewPackagePath.append(LUA_PATHSEP);
+	NewPackagePath.append(a_Path);
+	
+	// Set the new path to the environment:
+	lua_pop(m_LuaState, 1);                                                          // Stk: <package>
+	lua_pushlstring(m_LuaState, NewPackagePath.c_str(), NewPackagePath.length());    // Stk: <package> <NewPackagePath>
+	lua_setfield(m_LuaState, -2, a_PathVariable.c_str());                            // Stk: <package>
+	lua_pop(m_LuaState, 1);
+	lua_pop(m_LuaState, 1);                                                          // Stk: -
+}
+
+
+
+
+
 bool cLuaState::LoadFile(const AString & a_FileName)
 {
 	ASSERT(IsValid());
@@ -235,7 +271,7 @@ bool cLuaState::PushFunction(const char * a_FunctionName)
 	if (!lua_isfunction(m_LuaState, -1))
 	{
 		LOGWARNING("Error in %s: Could not find function %s()", m_SubsystemName.c_str(), a_FunctionName);
-		lua_pop(m_LuaState, 1);
+		lua_pop(m_LuaState, 2);
 		return false;
 	}
 	m_CurrentFunctionName.assign(a_FunctionName);
@@ -258,7 +294,7 @@ bool cLuaState::PushFunction(int a_FnRef)
 	lua_rawgeti(m_LuaState, LUA_REGISTRYINDEX, a_FnRef);  // same as lua_getref()
 	if (!lua_isfunction(m_LuaState, -1))
 	{
-		lua_pop(m_LuaState, 1);
+		lua_pop(m_LuaState, 2);
 		return false;
 	}
 	m_CurrentFunctionName = "<callback>";
@@ -282,16 +318,20 @@ bool cLuaState::PushFunction(const cTableRef & a_TableRef)
 	if (!lua_istable(m_LuaState, -1))
 	{
 		// Not a table, bail out
-		lua_pop(m_LuaState, 1);
+		lua_pop(m_LuaState, 2);
 		return false;
 	}
 	lua_getfield(m_LuaState, -1, a_TableRef.GetFnName());
 	if (lua_isnil(m_LuaState, -1) || !lua_isfunction(m_LuaState, -1))
 	{
 		// Not a valid function, bail out
-		lua_pop(m_LuaState, 2);
+		lua_pop(m_LuaState, 3);
 		return false;
 	}
+	
+	// Pop the table off the stack:
+	lua_remove(m_LuaState, -2);
+	
 	Printf(m_CurrentFunctionName, "<table-callback %s>", a_TableRef.GetFnName());
 	m_NumCurrentFunctionArgs = 0;
 	return true;
@@ -440,6 +480,18 @@ void cLuaState::Push(cEntity * a_Entity)
 
 
 
+void cLuaState::Push(cProjectileEntity * a_ProjectileEntity)
+{
+	ASSERT(IsValid());
+
+	tolua_pushusertype(m_LuaState, a_ProjectileEntity, "cProjectileEntity");
+	m_NumCurrentFunctionArgs += 1;
+}
+
+
+
+
+
 void cLuaState::Push(cMonster * a_Monster)
 {
 	ASSERT(IsValid());
@@ -646,8 +698,15 @@ void cLuaState::Push(Vector3i * a_Vector)
 
 void cLuaState::Push(void * a_Ptr)
 {
+	UNUSED(a_Ptr);
 	ASSERT(IsValid());
 
+	// Investigate the cause of this - what is the callstack?
+	// One code path leading here is the OnHookExploding / OnHookExploded with exotic parameters. Need to decide what to do with them
+	LOGWARNING("Lua engine: attempting to push a plain pointer, pushing nil instead.");
+	LOGWARNING("This indicates an unimplemented part of MCS bindings");
+	LogStackTrace();
+	
 	lua_pushnil(m_LuaState);
 	m_NumCurrentFunctionArgs += 1;
 }
@@ -680,7 +739,7 @@ void cLuaState::Push(cBlockEntity * a_BlockEntity)
 
 
 
-void cLuaState::GetReturn(int a_StackPos, bool & a_ReturnedVal)
+void cLuaState::GetStackValue(int a_StackPos, bool & a_ReturnedVal)
 {
 	a_ReturnedVal = (tolua_toboolean(m_LuaState, a_StackPos, a_ReturnedVal ? 1 : 0) > 0);
 }
@@ -689,11 +748,13 @@ void cLuaState::GetReturn(int a_StackPos, bool & a_ReturnedVal)
 
 
 
-void cLuaState::GetReturn(int a_StackPos, AString & a_ReturnedVal)
+void cLuaState::GetStackValue(int a_StackPos, AString & a_Value)
 {
-	if (lua_isstring(m_LuaState, a_StackPos))
+	size_t len = 0;
+	const char * data = lua_tolstring(m_LuaState, a_StackPos, &len);
+	if (data != NULL)
 	{
-		a_ReturnedVal = tolua_tocppstring(m_LuaState, a_StackPos, a_ReturnedVal.c_str());
+		a_Value.assign(data, len);
 	}
 }
 
@@ -701,7 +762,7 @@ void cLuaState::GetReturn(int a_StackPos, AString & a_ReturnedVal)
 
 
 
-void cLuaState::GetReturn(int a_StackPos, int & a_ReturnedVal)
+void cLuaState::GetStackValue(int a_StackPos, int & a_ReturnedVal)
 {
 	if (lua_isnumber(m_LuaState, a_StackPos))
 	{
@@ -713,7 +774,7 @@ void cLuaState::GetReturn(int a_StackPos, int & a_ReturnedVal)
 
 
 
-void cLuaState::GetReturn(int a_StackPos, double & a_ReturnedVal)
+void cLuaState::GetStackValue(int a_StackPos, double & a_ReturnedVal)
 {
 	if (lua_isnumber(m_LuaState, a_StackPos))
 	{
@@ -731,17 +792,24 @@ bool cLuaState::CallFunction(int a_NumResults)
 	ASSERT(lua_isfunction(m_LuaState, -m_NumCurrentFunctionArgs - 1));  // The function to call
 	ASSERT(lua_isfunction(m_LuaState, -m_NumCurrentFunctionArgs - 2));  // The error handler
 	
-	int s = lua_pcall(m_LuaState, m_NumCurrentFunctionArgs, a_NumResults, -m_NumCurrentFunctionArgs - 2);
+	// Save the current "stack" state and reset, in case the callback calls another function:
+	AString CurrentFunctionName;
+	std::swap(m_CurrentFunctionName, CurrentFunctionName);
+	int NumArgs = m_NumCurrentFunctionArgs;
+	m_NumCurrentFunctionArgs = -1;
+	
+	// Call the function:
+	int s = lua_pcall(m_LuaState, NumArgs, a_NumResults, -NumArgs - 2);
 	if (s != 0)
 	{
 		// The error has already been printed together with the stacktrace
-		LOGWARNING("Error in %s calling function %s()", m_SubsystemName.c_str(), m_CurrentFunctionName.c_str());
-		m_NumCurrentFunctionArgs = -1;
-		m_CurrentFunctionName.clear();
+		LOGWARNING("Error in %s calling function %s()", m_SubsystemName.c_str(), CurrentFunctionName.c_str());
 		return false;
 	}
-	m_NumCurrentFunctionArgs = -1;
-	m_CurrentFunctionName.clear();
+	
+	// Remove the error handler from the stack:
+	lua_remove(m_LuaState, -a_NumResults - 1);
+	
 	return true;
 }
 
@@ -933,10 +1001,42 @@ bool cLuaState::CheckParamFunction(int a_StartParam, int a_EndParam)
 		lua_Debug entry;
 		VERIFY(lua_getstack(m_LuaState, 0,   &entry));
 		VERIFY(lua_getinfo (m_LuaState, "n", &entry));
-		AString ErrMsg = Printf("Error in function '%s' parameter #%d. Function expected, got %s",
+		luaL_error(m_LuaState, "Error in function '%s' parameter #%d. Function expected, got %s",
+			(entry.name != NULL) ? entry.name : "?", i, GetTypeText(i).c_str()
+		);
+		return false;
+	}  // for i - Param
+	
+	// All params checked ok
+	return true;
+}
+
+
+
+
+
+bool cLuaState::CheckParamFunctionOrNil(int a_StartParam, int a_EndParam)
+{
+	ASSERT(IsValid());
+	
+	if (a_EndParam < 0)
+	{
+		a_EndParam = a_StartParam;
+	}
+	
+	for (int i = a_StartParam; i <= a_EndParam; i++)
+	{
+		if (lua_isfunction(m_LuaState, i) || lua_isnil(m_LuaState, i))
+		{
+			continue;
+		}
+		// Not the correct parameter
+		lua_Debug entry;
+		VERIFY(lua_getstack(m_LuaState, 0,   &entry));
+		VERIFY(lua_getinfo (m_LuaState, "n", &entry));
+		luaL_error(m_LuaState, "Error in function '%s' parameter #%d. Function expected, got %s",
 			(entry.name != NULL) ? entry.name : "?", i, GetTypeText(i).c_str()
 		);
-		LogStackTrace();
 		return false;
 	}  // for i - Param
 	
@@ -994,25 +1094,23 @@ bool cLuaState::ReportErrors(lua_State * a_LuaState, int a_Status)
 
 
 
-void cLuaState::LogStackTrace(void)
+void cLuaState::LogStackTrace(int a_StartingDepth)
 {
-	LogStackTrace(m_LuaState);
+	LogStackTrace(m_LuaState, a_StartingDepth);
 }
 
 
 
 
 
-void cLuaState::LogStackTrace(lua_State * a_LuaState)
+void cLuaState::LogStackTrace(lua_State * a_LuaState, int a_StartingDepth)
 {
 	LOGWARNING("Stack trace:");
 	lua_Debug entry;
-	int depth = 0;
+	int depth = a_StartingDepth;
 	while (lua_getstack(a_LuaState, depth, &entry))
 	{
-		int status = lua_getinfo(a_LuaState, "Sln", &entry);
-		assert(status);
-
+		lua_getinfo(a_LuaState, "Sln", &entry);
 		LOGWARNING("  %s(%d): %s", entry.short_src, entry.currentline, entry.name ? entry.name : "(no name)");
 		depth++;
 	}
@@ -1025,21 +1123,200 @@ void cLuaState::LogStackTrace(lua_State * a_LuaState)
 
 AString cLuaState::GetTypeText(int a_StackPos)
 {
-	int Type = lua_type(m_LuaState, a_StackPos);
-	switch (Type)
+	return lua_typename(m_LuaState, lua_type(m_LuaState, a_StackPos));
+}
+
+
+
+
+
+int cLuaState::CallFunctionWithForeignParams(
+	const AString & a_FunctionName,
+	cLuaState & a_SrcLuaState,
+	int a_SrcParamStart,
+	int a_SrcParamEnd
+)
+{
+	ASSERT(IsValid());
+	ASSERT(a_SrcLuaState.IsValid());
+	
+	// Store the stack position before any changes
+	int OldTop = lua_gettop(m_LuaState);
+	
+	// Push the function to call, including the error handler:
+	if (!PushFunction(a_FunctionName.c_str()))
 	{
-		case LUA_TNONE:          return "TNONE";
-		case LUA_TNIL:           return "TNIL";
-		case LUA_TBOOLEAN:       return "TBOOLEAN";
-		case LUA_TLIGHTUSERDATA: return "TLIGHTUSERDATA";
-		case LUA_TNUMBER:        return "TNUMBER";
-		case LUA_TSTRING:        return "TSTRING";
-		case LUA_TTABLE:         return "TTABLE";
-		case LUA_TFUNCTION:      return "TFUNCTION";
-		case LUA_TUSERDATA:      return "TUSERDATA";
-		case LUA_TTHREAD:        return "TTHREAD";
+		LOGWARNING("Function '%s' not found", a_FunctionName.c_str());
+		lua_pop(m_LuaState, 2);
+		return -1;
 	}
-	return Printf("Unknown (%d)", Type);
+
+	// Copy the function parameters to the target state
+	if (CopyStackFrom(a_SrcLuaState, a_SrcParamStart, a_SrcParamEnd) < 0)
+	{
+		// Something went wrong, fix the stack and exit
+		lua_pop(m_LuaState, 2);
+		m_NumCurrentFunctionArgs = -1;
+		m_CurrentFunctionName.clear();
+		return -1;
+	}
+	
+	// Call the function, with an error handler:
+	int s = lua_pcall(m_LuaState, a_SrcParamEnd - a_SrcParamStart + 1, LUA_MULTRET, OldTop + 1);
+	if (ReportErrors(s))
+	{
+		LOGWARN("Error while calling function '%s' in '%s'", a_FunctionName.c_str(), m_SubsystemName.c_str());
+		// Fix the stack.
+		// We don't know how many values have been pushed, so just get rid of any that weren't there initially
+		int CurTop = lua_gettop(m_LuaState);
+		if (CurTop > OldTop)
+		{
+			lua_pop(m_LuaState, CurTop - OldTop);
+		}
+		
+		// Reset the internal checking mechanisms:
+		m_NumCurrentFunctionArgs = -1;
+		m_CurrentFunctionName.clear();
+		
+		// Make Lua think everything is okay and return 0 values, so that plugins continue executing.
+		// The failure is indicated by the zero return values.
+		return 0;
+	}
+	
+	// Reset the internal checking mechanisms:
+	m_NumCurrentFunctionArgs = -1;
+	m_CurrentFunctionName.clear();
+	
+	// Remove the error handler from the stack:
+	lua_remove(m_LuaState, OldTop + 1);
+	
+	// Return the number of return values:
+	return lua_gettop(m_LuaState) - OldTop;
+}
+
+
+
+
+
+int cLuaState::CopyStackFrom(cLuaState & a_SrcLuaState, int a_SrcStart, int a_SrcEnd)
+{
+	/*
+	// DEBUG:
+	LOGD("Copying stack values from %d to %d", a_SrcStart, a_SrcEnd);
+	a_SrcLuaState.LogStack("Src stack before copying:");
+	LogStack("Dst stack before copying:");
+	*/
+	for (int i = a_SrcStart; i <= a_SrcEnd; ++i)
+	{
+		int t = lua_type(a_SrcLuaState, i);
+		switch (t)
+		{
+			case LUA_TNIL:
+			{
+				lua_pushnil(m_LuaState);
+				break;
+			}
+			case LUA_TSTRING:
+			{
+				AString s;
+				a_SrcLuaState.ToString(i, s);
+				Push(s);
+				break;
+			}
+			case LUA_TBOOLEAN:
+			{
+				bool b = (tolua_toboolean(a_SrcLuaState, i, false) != 0);
+				Push(b);
+				break;
+			}
+			case LUA_TNUMBER:
+			{
+				lua_Number d = tolua_tonumber(a_SrcLuaState, i, 0);
+				Push(d);
+				break;
+			}
+			case LUA_TUSERDATA:
+			{
+				// Get the class name:
+				const char * type = NULL;
+				if (lua_getmetatable(a_SrcLuaState, i) == 0)
+				{
+					LOGWARNING("%s: Unknown class in pos %d, cannot copy.", __FUNCTION__, i);
+					lua_pop(m_LuaState, i - a_SrcStart);
+					return -1;
+				}
+				lua_rawget(a_SrcLuaState, LUA_REGISTRYINDEX);  // Stack +1
+				type = lua_tostring(a_SrcLuaState, -1);
+				lua_pop(a_SrcLuaState, 1);                     // Stack -1
+				
+				// Copy the value:
+				void * ud = tolua_touserdata(a_SrcLuaState, i, NULL);
+				tolua_pushusertype(m_LuaState, ud, type);
+				break;
+			}
+			default:
+			{
+				LOGWARNING("%s: Unsupported value: '%s' at stack position %d. Can only copy numbers, strings, bools and classes!",
+					__FUNCTION__, lua_typename(a_SrcLuaState, t), i
+				);
+				a_SrcLuaState.LogStack("Stack where copying failed:");
+				lua_pop(m_LuaState, i - a_SrcStart);
+				return -1;
+			}
+		}
+	}
+	return a_SrcEnd - a_SrcStart + 1;
+}
+
+
+
+
+
+void cLuaState::ToString(int a_StackPos, AString & a_String)
+{
+	size_t len;
+	const char * s = lua_tolstring(m_LuaState, a_StackPos, &len);
+	if (s != NULL)
+	{
+		a_String.assign(s, len);
+	}
+}
+
+
+
+
+
+void cLuaState::LogStack(const char * a_Header)
+{
+	LogStack(m_LuaState, a_Header);
+}
+
+
+
+
+
+void cLuaState::LogStack(lua_State * a_LuaState, const char * a_Header)
+{
+	UNUSED(a_Header);  // The param seems unused when compiling for release, so the compiler warns
+	
+	
+	// Format string consisting only of %s is used to appease the compiler
+	LOGD("%s",(a_Header != NULL) ? a_Header : "Lua C API Stack contents:");
+	for (int i = lua_gettop(a_LuaState); i > 0; i--)
+	{
+		AString Value;
+		int Type = lua_type(a_LuaState, i);
+		switch (Type)
+		{
+			case LUA_TBOOLEAN: Value.assign((lua_toboolean(a_LuaState, i) != 0) ? "true" : "false"); break;
+			case LUA_TLIGHTUSERDATA: Printf(Value, "%p", lua_touserdata(a_LuaState, i)); break;
+			case LUA_TNUMBER:        Printf(Value, "%f", (double)lua_tonumber(a_LuaState, i)); break;
+			case LUA_TSTRING:        Printf(Value, "%s", lua_tostring(a_LuaState, i)); break;
+			case LUA_TTABLE:         Printf(Value, "%p", lua_topointer(a_LuaState, i)); break;
+			default: break;
+		}
+		LOGD("  Idx %d: type %d (%s) %s", i, Type, lua_typename(a_LuaState, Type), Value.c_str());
+	}  // for i - stack idx
 }
 
 
@@ -1049,7 +1326,7 @@ AString cLuaState::GetTypeText(int a_StackPos)
 int cLuaState::ReportFnCallErrors(lua_State * a_LuaState)
 {
 	LOGWARNING("LUA: %s", lua_tostring(a_LuaState, -1));
-	LogStackTrace(a_LuaState);
+	LogStackTrace(a_LuaState, 1);
 	return 1;  // We left the error message on the stack as the return value
 }
 
@@ -1060,13 +1337,21 @@ int cLuaState::ReportFnCallErrors(lua_State * a_LuaState)
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cLuaState::cRef:
 
+cLuaState::cRef::cRef(void) :
+	m_LuaState(NULL),
+	m_Ref(LUA_REFNIL)
+{
+}
+
+
+
+
+
 cLuaState::cRef::cRef(cLuaState & a_LuaState, int a_StackPos) :
-	m_LuaState(a_LuaState)
+	m_LuaState(NULL),
+	m_Ref(LUA_REFNIL)
 {
-	ASSERT(m_LuaState.IsValid());
-	
-	lua_pushvalue(m_LuaState, a_StackPos);  // Push a copy of the value at a_StackPos onto the stack
-	m_Ref = luaL_ref(m_LuaState, LUA_REGISTRYINDEX);
+	RefStack(a_LuaState, a_StackPos);
 }
 
 
@@ -1075,12 +1360,42 @@ cLuaState::cRef::cRef(cLuaState & a_LuaState, int a_StackPos) :
 
 cLuaState::cRef::~cRef()
 {
-	ASSERT(m_LuaState.IsValid());
+	if (m_LuaState != NULL)
+	{
+		UnRef();
+	}
+}
+
+
+
+
+
+void cLuaState::cRef::RefStack(cLuaState & a_LuaState, int a_StackPos)
+{
+	ASSERT(a_LuaState.IsValid());
+	if (m_LuaState != NULL)
+	{
+		UnRef();
+	}
+	m_LuaState = &a_LuaState;
+	lua_pushvalue(a_LuaState, a_StackPos);  // Push a copy of the value at a_StackPos onto the stack
+	m_Ref = luaL_ref(a_LuaState, LUA_REGISTRYINDEX);
+}
+
+
+
+
+
+void cLuaState::cRef::UnRef(void)
+{
+	ASSERT(m_LuaState->IsValid());  // The reference should be destroyed before destroying the LuaState
 	
 	if (IsValid())
 	{
-		luaL_unref(m_LuaState, LUA_REGISTRYINDEX, m_Ref);
+		luaL_unref(*m_LuaState, LUA_REGISTRYINDEX, m_Ref);
 	}
+	m_LuaState = NULL;
+	m_Ref = LUA_REFNIL;
 }
 
 
diff --git a/src/Bindings/LuaState.h b/src/Bindings/LuaState.h
index f8b67f5cd..b9ca2f29b 100644
--- a/src/Bindings/LuaState.h
+++ b/src/Bindings/LuaState.h
@@ -29,6 +29,8 @@ extern "C"
 	#include "lua/src/lauxlib.h"
 }
 
+#include "../Vector3.h"
+
 
 
 
@@ -36,6 +38,7 @@ extern "C"
 class cWorld;
 class cPlayer;
 class cEntity;
+class cProjectileEntity;
 class cMonster;
 class cItem;
 class cItems;
@@ -52,7 +55,6 @@ class cWebAdmin;
 struct HTTPTemplateRequest;
 class cTNTEntity;
 class cCreeper;
-class Vector3i;
 class cHopperEntity;
 class cBlockEntity;
 
@@ -60,27 +62,40 @@ class cBlockEntity;
 
 
 
-/// Encapsulates a Lua state and provides some syntactic sugar for common operations
+/** Encapsulates a Lua state and provides some syntactic sugar for common operations */
 class cLuaState
 {
 public:
 
-	/// Used for storing references to object in the global registry
+	/** Used for storing references to object in the global registry.
+	Can be bound (contains a reference) or unbound (doesn't contain reference).
+	The reference can also be reset by calling RefStack(). */
 	class cRef
 	{
 	public:
-		/// Creates a reference in the specified LuaState for object at the specified StackPos
+		/** Creates an unbound reference object. */
+		cRef(void);
+		
+		/** Creates a reference in the specified LuaState for object at the specified StackPos */
 		cRef(cLuaState & a_LuaState, int a_StackPos);
+		
 		~cRef();
 		
-		/// Returns true if the reference is valid
+		/** Creates a reference to Lua object at the specified stack pos, binds this object to it.
+		Calls UnRef() first if previously bound to another reference. */
+		void RefStack(cLuaState & a_LuaState, int a_StackPos);
+		
+		/** Removes the bound reference, resets the object to Unbound state. */
+		void UnRef(void);
+		
+		/** Returns true if the reference is valid */
 		bool IsValid(void) const {return (m_Ref != LUA_REFNIL); }
 		
-		/// Allows to use this class wherever an int (i. e. ref) is to be used
+		/** Allows to use this class wherever an int (i. e. ref) is to be used */
 		operator int(void) const { return m_Ref; }
 		
 	protected:
-		cLuaState & m_LuaState;
+		cLuaState * m_LuaState;
 		int m_Ref;
 	} ;
 	
@@ -102,7 +117,7 @@ public:
 	} ;
 	
 	
-	/// A dummy class that's used only to delimit function args from return values for cLuaState::Call()
+	/** A dummy class that's used only to delimit function args from return values for cLuaState::Call() */
 	class cRet
 	{
 	} ;
@@ -123,31 +138,39 @@ public:
 	
 	~cLuaState();
 	
-	/// Allows this object to be used in the same way as a lua_State *, for example in the LuaLib functions
+	/** Allows this object to be used in the same way as a lua_State *, for example in the LuaLib functions */
 	operator lua_State * (void) { return m_LuaState; }
 	
-	/// Creates the m_LuaState, if not closed already. This state will be automatically closed in the destructor
+	/** Creates the m_LuaState, if not closed already. This state will be automatically closed in the destructor.
+	The regular Lua libs are registered, but the MCS API is not registered (so that Lua can be used as
+	lite-config as well), use RegisterAPILibs() to do that. */
 	void Create(void);
 	
-	/// Closes the m_LuaState, if not closed already
+	/** Registers all the API libraries that MCS provides into m_LuaState. */
+	void RegisterAPILibs(void);
+	
+	/** Closes the m_LuaState, if not closed already */
 	void Close(void);
 	
-	/// Attaches the specified state. Operations will be carried out on this state, but it will not be closed in the destructor
+	/** Attaches the specified state. Operations will be carried out on this state, but it will not be closed in the destructor */
 	void Attach(lua_State * a_State);
 	
-	/// Detaches a previously attached state.
+	/** Detaches a previously attached state. */
 	void Detach(void);
 	
-	/// Returns true if the m_LuaState is valid
+	/** Returns true if the m_LuaState is valid */
 	bool IsValid(void) const { return (m_LuaState != NULL); }
 	
+	/** Adds the specified path to package.<a_PathVariable> */
+	void AddPackagePath(const AString & a_PathVariable, const AString & a_Path);
+	
 	/** Loads the specified file
 	Returns false and logs a warning to the console if not successful (but the LuaState is kept open).
 	m_SubsystemName is displayed in the warning log message.
 	*/
 	bool LoadFile(const AString & a_FileName);
 	
-	/// Returns true if a_FunctionName is a valid Lua function that can be called
+	/** Returns true if a_FunctionName is a valid Lua function that can be called */
 	bool HasFunction(const char * a_FunctionName);
 	
 	// Push a value onto the stack
@@ -161,6 +184,7 @@ public:
 	void Push(cPlayer * a_Player);
 	void Push(const cPlayer * a_Player);
 	void Push(cEntity * a_Entity);
+	void Push(cProjectileEntity * a_ProjectileEntity);
 	void Push(cMonster * a_Monster);
 	void Push(cItem * a_Item);
 	void Push(cItems * a_Items);
@@ -181,8 +205,21 @@ public:
 	void Push(void * a_Ptr);
 	void Push(cHopperEntity * a_Hopper);
 	void Push(cBlockEntity * a_BlockEntity);
+	
+	/** Retrieve value at a_StackPos, if it is a valid bool. If not, a_Value is unchanged */
+	void GetStackValue(int a_StackPos, bool & a_Value);
+	
+	/** Retrieve value at a_StackPos, if it is a valid string. If not, a_Value is unchanged */
+	void GetStackValue(int a_StackPos, AString & a_Value);
+	
+	/** Retrieve value at a_StackPos, if it is a valid number. If not, a_Value is unchanged */
+	void GetStackValue(int a_StackPos, int & a_Value);
+	
+	/** Retrieve value at a_StackPos, if it is a valid number. If not, a_Value is unchanged */
+	void GetStackValue(int a_StackPos, double & a_Value);
+	
 
-	/// Call any 0-param 0-return Lua function in a single line:
+	/** Call any 0-param 0-return Lua function in a single line: */
 	template <typename FnT>
 	bool Call(FnT a_FnName)
 	{
@@ -193,7 +230,7 @@ public:
 		return CallFunction(0);
 	}
 
-	/// Call any 1-param 0-return Lua function in a single line:
+	/** Call any 1-param 0-return Lua function in a single line: */
 	template<
 		typename FnT,
 		typename ArgT1
@@ -208,7 +245,7 @@ public:
 		return CallFunction(0);
 	}
 
-	/// Call any 2-param 0-return Lua function in a single line:
+	/** Call any 2-param 0-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2
 	>
@@ -223,7 +260,7 @@ public:
 		return CallFunction(0);
 	}
 
-	/// Call any 3-param 0-return Lua function in a single line:
+	/** Call any 3-param 0-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3
 	>
@@ -239,7 +276,7 @@ public:
 		return CallFunction(0);
 	}
 
-	/// Call any 0-param 1-return Lua function in a single line:
+	/** Call any 0-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename RetT1
 	>
@@ -254,17 +291,18 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 
-	/// Call any 1-param 1-return Lua function in a single line:
+	/** Call any 1-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename RetT1
 	>
 	bool Call(FnT a_FnName, ArgT1 a_Arg1, const cRet & a_Mark, RetT1 & a_Ret1)
 	{
+		int InitialTop = lua_gettop(m_LuaState);
 		UNUSED(a_Mark);
 		if (!PushFunction(a_FnName))
 		{
@@ -275,12 +313,13 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
+		ASSERT(InitialTop == lua_gettop(m_LuaState));
 		return true;
 	}
 
-	/// Call any 2-param 1-return Lua function in a single line:
+	/** Call any 2-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename RetT1
 	>
@@ -297,12 +336,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 
-	/// Call any 3-param 1-return Lua function in a single line:
+	/** Call any 3-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename RetT1
 	>
@@ -320,12 +359,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 	
-	/// Call any 4-param 1-return Lua function in a single line:
+	/** Call any 4-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename RetT1
 	>
@@ -344,12 +383,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 	
-	/// Call any 5-param 1-return Lua function in a single line:
+	/** Call any 5-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5, typename RetT1
 	>
@@ -369,12 +408,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 	
-	/// Call any 6-param 1-return Lua function in a single line:
+	/** Call any 6-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5, typename ArgT6,
 		typename RetT1
@@ -396,12 +435,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 	
-	/// Call any 7-param 1-return Lua function in a single line:
+	/** Call any 7-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5, typename ArgT6,
 		typename ArgT7, typename RetT1
@@ -424,12 +463,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 	
-	/// Call any 8-param 1-return Lua function in a single line:
+	/** Call any 8-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5, typename ArgT6,
 		typename ArgT7, typename ArgT8, typename RetT1
@@ -453,12 +492,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 	
-	/// Call any 9-param 1-return Lua function in a single line:
+	/** Call any 9-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5, typename ArgT6,
 		typename ArgT7, typename ArgT8, typename ArgT9, typename RetT1
@@ -483,12 +522,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 	
-	/// Call any 10-param 1-return Lua function in a single line:
+	/** Call any 10-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5, typename ArgT6,
 		typename ArgT7, typename ArgT8, typename ArgT9, typename ArgT10, typename RetT1
@@ -514,12 +553,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 	
-	/// Call any 1-param 2-return Lua function in a single line:
+	/** Call any 1-param 2-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename RetT1, typename RetT2
 	>
@@ -535,13 +574,13 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-2, a_Ret1);
-		GetReturn(-1, a_Ret2);
+		GetStackValue(-2, a_Ret1);
+		GetStackValue(-1, a_Ret2);
 		lua_pop(m_LuaState, 2);
 		return true;
 	}
 
-	/// Call any 2-param 2-return Lua function in a single line:
+	/** Call any 2-param 2-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename RetT1, typename RetT2
 	>
@@ -558,13 +597,13 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-2, a_Ret1);
-		GetReturn(-1, a_Ret2);
+		GetStackValue(-2, a_Ret1);
+		GetStackValue(-1, a_Ret2);
 		lua_pop(m_LuaState, 2);
 		return true;
 	}
 
-	/// Call any 3-param 2-return Lua function in a single line:
+	/** Call any 3-param 2-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3,
 		typename RetT1, typename RetT2
@@ -583,13 +622,13 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-2, a_Ret1);
-		GetReturn(-1, a_Ret2);
+		GetStackValue(-2, a_Ret1);
+		GetStackValue(-1, a_Ret2);
 		lua_pop(m_LuaState, 2);
 		return true;
 	}
 
-	/// Call any 4-param 2-return Lua function in a single line:
+	/** Call any 4-param 2-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4,
 		typename RetT1, typename RetT2
@@ -609,13 +648,13 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-2, a_Ret1);
-		GetReturn(-1, a_Ret2);
+		GetStackValue(-2, a_Ret1);
+		GetStackValue(-1, a_Ret2);
 		lua_pop(m_LuaState, 2);
 		return true;
 	}
 
-	/// Call any 5-param 2-return Lua function in a single line:
+	/** Call any 5-param 2-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5,
 		typename RetT1, typename RetT2
@@ -636,13 +675,13 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-2, a_Ret1);
-		GetReturn(-1, a_Ret2);
+		GetStackValue(-2, a_Ret1);
+		GetStackValue(-1, a_Ret2);
 		lua_pop(m_LuaState, 2);
 		return true;
 	}
 
-	/// Call any 6-param 2-return Lua function in a single line:
+	/** Call any 6-param 2-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5,
 		typename ArgT6,
@@ -665,13 +704,13 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-2, a_Ret1);
-		GetReturn(-1, a_Ret2);
+		GetStackValue(-2, a_Ret1);
+		GetStackValue(-1, a_Ret2);
 		lua_pop(m_LuaState, 2);
 		return true;
 	}
 
-	/// Call any 7-param 2-return Lua function in a single line:
+	/** Call any 7-param 2-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5,
 		typename ArgT6, typename ArgT7,
@@ -695,13 +734,13 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-2, a_Ret1);
-		GetReturn(-1, a_Ret2);
+		GetStackValue(-2, a_Ret1);
+		GetStackValue(-1, a_Ret2);
 		lua_pop(m_LuaState, 2);
 		return true;
 	}
 
-	/// Call any 7-param 3-return Lua function in a single line:
+	/** Call any 7-param 3-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5,
 		typename ArgT6, typename ArgT7,
@@ -725,14 +764,14 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-3, a_Ret1);
-		GetReturn(-2, a_Ret2);
-		GetReturn(-1, a_Ret3);
+		GetStackValue(-3, a_Ret1);
+		GetStackValue(-2, a_Ret2);
+		GetStackValue(-1, a_Ret3);
 		lua_pop(m_LuaState, 3);
 		return true;
 	}
 
-	/// Call any 8-param 3-return Lua function in a single line:
+	/** Call any 8-param 3-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5,
 		typename ArgT6, typename ArgT7, typename ArgT8,
@@ -757,14 +796,14 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-3, a_Ret1);
-		GetReturn(-2, a_Ret2);
-		GetReturn(-1, a_Ret3);
+		GetStackValue(-3, a_Ret1);
+		GetStackValue(-2, a_Ret2);
+		GetStackValue(-1, a_Ret3);
 		lua_pop(m_LuaState, 3);
 		return true;
 	}
 
-	/// Call any 9-param 5-return Lua function in a single line:
+	/** Call any 9-param 5-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5,
 		typename ArgT6, typename ArgT7, typename ArgT8, typename ArgT9, 
@@ -790,56 +829,84 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-5, a_Ret1);
-		GetReturn(-4, a_Ret2);
-		GetReturn(-3, a_Ret3);
-		GetReturn(-2, a_Ret4);
-		GetReturn(-1, a_Ret5);
+		GetStackValue(-5, a_Ret1);
+		GetStackValue(-4, a_Ret2);
+		GetStackValue(-3, a_Ret3);
+		GetStackValue(-2, a_Ret4);
+		GetStackValue(-1, a_Ret5);
 		lua_pop(m_LuaState, 5);
 		return true;
 	}
 
 
-	/// Returns true if the specified parameters on the stack are of the specified usertable type; also logs warning if not. Used for static functions
+	/** Returns true if the specified parameters on the stack are of the specified usertable type; also logs warning if not. Used for static functions */
 	bool CheckParamUserTable(int a_StartParam, const char * a_UserTable, int a_EndParam = -1);
 	
-	/// Returns true if the specified parameters on the stack are of the specified usertype; also logs warning if not. Used for regular functions
+	/** Returns true if the specified parameters on the stack are of the specified usertype; also logs warning if not. Used for regular functions */
 	bool CheckParamUserType(int a_StartParam, const char * a_UserType, int a_EndParam = -1);
 	
-	/// Returns true if the specified parameters on the stack are tables; also logs warning if not
+	/** Returns true if the specified parameters on the stack are tables; also logs warning if not */
 	bool CheckParamTable(int a_StartParam, int a_EndParam = -1);
 	
-	/// Returns true if the specified parameters on the stack are numbers; also logs warning if not
+	/** Returns true if the specified parameters on the stack are numbers; also logs warning if not */
 	bool CheckParamNumber(int a_StartParam, int a_EndParam = -1);
 	
-	/// Returns true if the specified parameters on the stack are strings; also logs warning if not
+	/** Returns true if the specified parameters on the stack are strings; also logs warning if not */
 	bool CheckParamString(int a_StartParam, int a_EndParam = -1);
 	
-	/// Returns true if the specified parameters on the stack are functions; also logs warning if not
+	/** Returns true if the specified parameters on the stack are functions; also logs warning if not */
 	bool CheckParamFunction(int a_StartParam, int a_EndParam = -1);
 	
-	/// Returns true if the specified parameter on the stack is nil (indicating an end-of-parameters)
+	/** Returns true if the specified parameters on the stack are functions or nils; also logs warning if not */
+	bool CheckParamFunctionOrNil(int a_StartParam, int a_EndParam = -1);
+	
+	/** Returns true if the specified parameter on the stack is nil (indicating an end-of-parameters) */
 	bool CheckParamEnd(int a_Param);
 	
-	/// If the status is nonzero, prints the text on the top of Lua stack and returns true
+	/** If the status is nonzero, prints the text on the top of Lua stack and returns true */
 	bool ReportErrors(int status);
 	
-	/// If the status is nonzero, prints the text on the top of Lua stack and returns true
+	/** If the status is nonzero, prints the text on the top of Lua stack and returns true */
 	static bool ReportErrors(lua_State * a_LuaState, int status);
 	
-	/// Logs all items in the current stack trace to the server console
-	void LogStackTrace(void);
+	/** Logs all items in the current stack trace to the server console */
+	void LogStackTrace(int a_StartingDepth = 0);
 	
-	/// Logs all items in the current stack trace to the server console
-	static void LogStackTrace(lua_State * a_LuaState);
+	/** Logs all items in the current stack trace to the server console */
+	static void LogStackTrace(lua_State * a_LuaState, int a_StartingDepth = 0);
 	
-	/// Returns the type of the item on the specified position in the stack
+	/** Returns the type of the item on the specified position in the stack */
 	AString GetTypeText(int a_StackPos);
 	
+	/** Calls the function specified by its name, with arguments copied off the foreign state.
+	If successful, keeps the return values on the stack and returns their number.
+	If unsuccessful, returns a negative number and keeps the stack position unchanged. */
+	int CallFunctionWithForeignParams(
+		const AString & a_FunctionName,
+		cLuaState & a_SrcLuaState,
+		int a_SrcParamStart,
+		int a_SrcParamEnd
+	);
+	
+	/** Copies objects on the stack from the specified state.
+	Only numbers, bools, strings and userdatas are copied.
+	If successful, returns the number of objects copied.
+	If failed, returns a negative number and rewinds the stack position. */
+	int CopyStackFrom(cLuaState & a_SrcLuaState, int a_SrcStart, int a_SrcEnd);
+	
+	/** Reads the value at the specified stack position as a string and sets it to a_String. */
+	void ToString(int a_StackPos, AString & a_String);
+
+	/** Logs all the elements' types on the API stack, with an optional header for the listing. */
+	void LogStack(const char * a_Header);
+	
+	/** Logs all the elements' types on the API stack, with an optional header for the listing. */
+	static void LogStack(lua_State * a_LuaState, const char * a_Header = NULL);
+	
 protected:
 	lua_State * m_LuaState;
 	
-	/// If true, the state is owned by this object and will be auto-Closed. False => attached state
+	/** If true, the state is owned by this object and will be auto-Closed. False => attached state */
 	bool m_IsOwned;
 	
 	/** The subsystem name is used for reporting errors to the console, it is either "plugin %s" or "LuaScript"
@@ -847,10 +914,10 @@ protected:
 	*/
 	AString m_SubsystemName;
 	
-	/// Name of the currently pushed function (for the Push / Call chain)
+	/** Name of the currently pushed function (for the Push / Call chain) */
 	AString m_CurrentFunctionName;
 	
-	/// Number of arguments currently pushed (for the Push / Call chain)
+	/** Number of arguments currently pushed (for the Push / Call chain) */
 	int m_NumCurrentFunctionArgs;
 
 
@@ -869,21 +936,9 @@ protected:
 	*/
 	bool PushFunction(const cTableRef & a_TableRef);
 	
-	/// Pushes a usertype of the specified class type onto the stack
+	/** Pushes a usertype of the specified class type onto the stack */
 	void PushUserType(void * a_Object, const char * a_Type);
 
-	/// Retrieve value returned at a_StackPos, if it is a valid bool. If not, a_ReturnedVal is unchanged
-	void GetReturn(int a_StackPos, bool & a_ReturnedVal);
-	
-	/// Retrieve value returned at a_StackPos, if it is a valid string. If not, a_ReturnedVal is unchanged
-	void GetReturn(int a_StackPos, AString & a_ReturnedVal);
-	
-	/// Retrieve value returned at a_StackPos, if it is a valid number. If not, a_ReturnedVal is unchanged
-	void GetReturn(int a_StackPos, int & a_ReturnedVal);
-	
-	/// Retrieve value returned at a_StackPos, if it is a valid number. If not, a_ReturnedVal is unchanged
-	void GetReturn(int a_StackPos, double & a_ReturnedVal);
-	
 	/**
 	Calls the function that has been pushed onto the stack by PushFunction(),
 	with arguments pushed by PushXXX().
diff --git a/src/Bindings/ManualBindings.cpp b/src/Bindings/ManualBindings.cpp
index 2206dd371..92b410481 100644
--- a/src/Bindings/ManualBindings.cpp
+++ b/src/Bindings/ManualBindings.cpp
@@ -2,17 +2,20 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "ManualBindings.h"
+#undef TOLUA_TEMPLATE_BIND
 #include "tolua++/include/tolua++.h"
 
 #include "Plugin.h"
 #include "PluginLua.h"
 #include "PluginManager.h"
 #include "LuaWindow.h"
+#include "LuaChunkStay.h"
 #include "../Root.h"
 #include "../World.h"
 #include "../Entities/Player.h"
 #include "../WebAdmin.h"
 #include "../ClientHandle.h"
+#include "../BlockArea.h"
 #include "../BlockEntities/ChestEntity.h"
 #include "../BlockEntities/CommandBlockEntity.h"
 #include "../BlockEntities/DispenserEntity.h"
@@ -20,8 +23,12 @@
 #include "../BlockEntities/FurnaceEntity.h"
 #include "../BlockEntities/HopperEntity.h"
 #include "../BlockEntities/NoteEntity.h"
+#include "../BlockEntities/MobHeadEntity.h"
+#include "../BlockEntities/FlowerPotEntity.h"
 #include "md5/md5.h"
 #include "../LineBlockTracer.h"
+#include "../WorldStorage/SchematicFileSerializer.h"
+#include "../CompositeChat.h"
 
 
 
@@ -109,10 +116,44 @@ static int tolua_StringSplitAndTrim(lua_State * tolua_S)
 
 
 
-static int tolua_LOG(lua_State* tolua_S)
+/** Retrieves the log message from the first param on the Lua stack.
+Can take either a string or a cCompositeChat.
+*/
+static AString GetLogMessage(lua_State * tolua_S)
 {
-	const char* str = tolua_tocppstring(tolua_S,1,0);
-	cMCLogger::GetInstance()->LogSimple( str, 0 );
+	tolua_Error err;
+	if (tolua_isusertype(tolua_S, 1, "cCompositeChat", false, &err))
+	{
+		return ((cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL))->ExtractText();
+	}
+	else
+	{
+		size_t len = 0;
+		const char * str = lua_tolstring(tolua_S, 1, &len);
+		if (str != NULL)
+		{
+			return AString(str, len);
+		}
+	}
+	return "";
+}
+
+
+
+
+
+static int tolua_LOG(lua_State * tolua_S)
+{
+	// If the param is a cCompositeChat, read the log level from it:
+	cMCLogger::eLogLevel LogLevel = cMCLogger::llRegular;
+	tolua_Error err;
+	if (tolua_isusertype(tolua_S, 1, "cCompositeChat", false, &err))
+	{
+		LogLevel = cCompositeChat::MessageTypeToLogLevel(((cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL))->GetMessageType());
+	}
+	
+	// Log the message:
+	cMCLogger::GetInstance()->LogSimple(GetLogMessage(tolua_S).c_str(), LogLevel);
 	return 0;
 }
 
@@ -120,10 +161,9 @@ static int tolua_LOG(lua_State* tolua_S)
 
 
 
-static int tolua_LOGINFO(lua_State* tolua_S)
+static int tolua_LOGINFO(lua_State * tolua_S)
 {
-	const char* str = tolua_tocppstring(tolua_S,1,0);
-	cMCLogger::GetInstance()->LogSimple( str, 1 );
+	cMCLogger::GetInstance()->LogSimple(GetLogMessage(tolua_S).c_str(), cMCLogger::llInfo);
 	return 0;
 }
 
@@ -131,10 +171,9 @@ static int tolua_LOGINFO(lua_State* tolua_S)
 
 
 
-static int tolua_LOGWARN(lua_State* tolua_S)
+static int tolua_LOGWARN(lua_State * tolua_S)
 {
-	const char* str = tolua_tocppstring(tolua_S,1,0);
-	cMCLogger::GetInstance()->LogSimple( str, 2 );
+	cMCLogger::GetInstance()->LogSimple(GetLogMessage(tolua_S).c_str(), cMCLogger::llWarning);
 	return 0;
 }
 
@@ -142,10 +181,9 @@ static int tolua_LOGWARN(lua_State* tolua_S)
 
 
 
-static int tolua_LOGERROR(lua_State* tolua_S)
+static int tolua_LOGERROR(lua_State * tolua_S)
 {
-	const char* str = tolua_tocppstring(tolua_S,1,0);
-	cMCLogger::GetInstance()->LogSimple( str, 3 );
+	cMCLogger::GetInstance()->LogSimple(GetLogMessage(tolua_S).c_str(), cMCLogger::llError);
 	return 0;
 }
 
@@ -153,6 +191,50 @@ static int tolua_LOGERROR(lua_State* tolua_S)
 
 
 
+static int tolua_Base64Encode(lua_State * tolua_S)
+{
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamString(1) ||
+		!L.CheckParamEnd(2)
+	)
+	{
+		return 0;
+	}
+	
+	AString Src;
+	L.GetStackValue(1, Src);
+	AString res = Base64Encode(Src);
+	L.Push(res);
+	return 1;
+}
+
+
+
+
+
+static int tolua_Base64Decode(lua_State * tolua_S)
+{
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamString(1) ||
+		!L.CheckParamEnd(2)
+	)
+	{
+		return 0;
+	}
+	
+	AString Src;
+	L.GetStackValue(1, Src);
+	AString res = Base64Decode(Src);
+	L.Push(res);
+	return 1;
+}
+
+
+
+
+
 cPluginLua * GetLuaPlugin(lua_State * L)
 {
 	// Get the plugin identification out of LuaState:
@@ -209,7 +291,7 @@ static int tolua_DoWith(lua_State* tolua_S)
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 2 or 3 arguments, got %i", NumArgs);
 	}
 
-	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, 0);
+	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, NULL);
 
 	const char * ItemName = tolua_tocppstring(tolua_S, 2, "");
 	if ((ItemName == NULL) || (ItemName[0] == 0))
@@ -303,7 +385,7 @@ static int tolua_DoWithID(lua_State* tolua_S)
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 2 or 3 arguments, got %i", NumArgs);
 	}
 
-	Ty1 * self = (Ty1 *)tolua_tousertype(tolua_S, 1, 0);
+	Ty1 * self = (Ty1 *)tolua_tousertype(tolua_S, 1, NULL);
 
 	int ItemID = (int)tolua_tonumber(tolua_S, 2, 0);
 	if (!lua_isfunction(tolua_S, 3))
@@ -393,7 +475,7 @@ static int tolua_DoWithXYZ(lua_State* tolua_S)
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 4 or 5 arguments, got %i", NumArgs);
 	}
 
-	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, 0);
+	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, NULL);
 	if (!lua_isnumber(tolua_S, 2) || !lua_isnumber(tolua_S, 3) || !lua_isnumber(tolua_S, 4))
 	{
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a number for parameters #1, #2 and #3");
@@ -487,7 +569,7 @@ static int tolua_ForEachInChunk(lua_State* tolua_S)
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 3 or 4 arguments, got %i", NumArgs);
 	}
 
-	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, 0);
+	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, NULL);
 	if (!lua_isnumber(tolua_S, 2) || !lua_isnumber(tolua_S, 3))
 	{
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a number for parameters #1 and #2");
@@ -581,7 +663,7 @@ static int tolua_ForEach(lua_State * tolua_S)
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 1 or 2 arguments, got %i", NumArgs);
 	}
 
-	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, 0);
+	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, NULL);
 	if (self == NULL)
 	{
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Not called on an object instance");
@@ -678,7 +760,7 @@ static int tolua_cWorld_GetBlockInfo(lua_State * tolua_S)
 	else
 	#endif
 	{
-		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, 0);
+		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, NULL);
 		int BlockX          = (int)      tolua_tonumber   (tolua_S, 2, 0);
 		int BlockY          = (int)      tolua_tonumber   (tolua_S, 3, 0);
 		int BlockZ          = (int)      tolua_tonumber   (tolua_S, 4, 0);
@@ -733,7 +815,7 @@ static int tolua_cWorld_GetBlockTypeMeta(lua_State * tolua_S)
 	else
 	#endif
 	{
-		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, 0);
+		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, NULL);
 		int BlockX          = (int)      tolua_tonumber   (tolua_S, 2, 0);
 		int BlockY          = (int)      tolua_tonumber   (tolua_S, 3, 0);
 		int BlockZ          = (int)      tolua_tonumber   (tolua_S, 4, 0);
@@ -785,7 +867,7 @@ static int tolua_cWorld_GetSignLines(lua_State * tolua_S)
 	else
 	#endif
 	{
-		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, 0);
+		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, NULL);
 		int BlockX          = (int)      tolua_tonumber   (tolua_S, 2, 0);
 		int BlockY          = (int)      tolua_tonumber   (tolua_S, 3, 0);
 		int BlockZ          = (int)      tolua_tonumber   (tolua_S, 4, 0);
@@ -843,7 +925,7 @@ static int tolua_cWorld_SetSignLines(lua_State * tolua_S)
 	else
 	#endif
 	{
-		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, 0);
+		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, NULL);
 		int BlockX          = (int)      tolua_tonumber   (tolua_S, 2, 0);
 		int BlockY          = (int)      tolua_tonumber   (tolua_S, 3, 0);
 		int BlockZ          = (int)      tolua_tonumber   (tolua_S, 4, 0);
@@ -892,7 +974,7 @@ static int tolua_cWorld_TryGetHeight(lua_State * tolua_S)
 	else
 	#endif
 	{
-		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, 0);
+		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, NULL);
 		int BlockX          = (int)      tolua_tonumber   (tolua_S, 2, 0);
 		int BlockZ          = (int)      tolua_tonumber   (tolua_S, 3, 0);
 		#ifndef TOLUA_RELEASE
@@ -904,8 +986,12 @@ static int tolua_cWorld_TryGetHeight(lua_State * tolua_S)
 		{
 			int Height = 0;
 			bool res = self->TryGetHeight(BlockX, BlockZ, Height);
-			tolua_pushnumber(tolua_S, Height);
 			tolua_pushboolean(tolua_S, res ? 1 : 0);
+			if (res)
+			{
+				tolua_pushnumber(tolua_S, Height);
+				return 2;
+			}
 		}
 	}
 	return 1;
@@ -960,7 +1046,7 @@ static int tolua_cWorld_QueueTask(lua_State * tolua_S)
 	}
 
 	// Retrieve the args:
-	cWorld * self = (cWorld *)tolua_tousertype(tolua_S, 1, 0);
+	cWorld * self = (cWorld *)tolua_tousertype(tolua_S, 1, NULL);
 	if (self == NULL)
 	{
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Not called on an object instance");
@@ -1058,7 +1144,7 @@ static int tolua_cWorld_ScheduleTask(lua_State * tolua_S)
 
 static int tolua_cPluginManager_GetAllPlugins(lua_State * tolua_S)
 {
-	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, 0);
+	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, NULL);
 
 	const cPluginManager::PluginMap & AllPlugins = self->GetAllPlugins();
 
@@ -1104,6 +1190,16 @@ static int tolua_cPluginManager_GetCurrentPlugin(lua_State * S)
 
 
 
+static int tolua_cPluginManager_LogStackTrace(lua_State * S)
+{
+	cLuaState::LogStackTrace(S);
+	return 0;
+}
+
+
+
+
+
 static int tolua_cPluginManager_AddHook_FnRef(cPluginManager * a_PluginManager, cLuaState & S, int a_ParamIdx)
 {
 	// Helper function for cPluginmanager:AddHook() binding
@@ -1272,7 +1368,7 @@ static int tolua_cPluginManager_ForEachCommand(lua_State * tolua_S)
 		return 0;
 	}
 
-	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, 0);
+	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, NULL);
 	if (self == NULL)
 	{
 		LOGWARN("Error in function call 'ForEachCommand': Not called on an object instance");
@@ -1303,7 +1399,9 @@ static int tolua_cPluginManager_ForEachCommand(lua_State * tolua_S)
 	private:
 		virtual bool Command(const AString & a_Command, const cPlugin * a_Plugin, const AString & a_Permission, const AString & a_HelpString) override
 		{
-			lua_rawgeti( LuaState, LUA_REGISTRYINDEX, FuncRef);  /* Push function reference */
+			UNUSED(a_Plugin);
+			
+			lua_rawgeti(LuaState, LUA_REGISTRYINDEX, FuncRef);  /* Push function reference */
 			tolua_pushcppstring(LuaState, a_Command);
 			tolua_pushcppstring(LuaState, a_Permission);
 			tolua_pushcppstring(LuaState, a_HelpString);
@@ -1347,7 +1445,7 @@ static int tolua_cPluginManager_ForEachConsoleCommand(lua_State * tolua_S)
 		return 0;
 	}
 
-	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, 0);
+	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, NULL);
 	if (self == NULL)
 	{
 		LOGWARN("Error in function call 'ForEachConsoleCommand': Not called on an object instance");
@@ -1378,7 +1476,10 @@ static int tolua_cPluginManager_ForEachConsoleCommand(lua_State * tolua_S)
 	private:
 		virtual bool Command(const AString & a_Command, const cPlugin * a_Plugin, const AString & a_Permission, const AString & a_HelpString) override
 		{
-			lua_rawgeti( LuaState, LUA_REGISTRYINDEX, FuncRef);  /* Push function reference */
+			UNUSED(a_Plugin);
+			UNUSED(a_Permission);
+			
+			lua_rawgeti(LuaState, LUA_REGISTRYINDEX, FuncRef);  /* Push function reference */
 			tolua_pushcppstring(LuaState, a_Command);
 			tolua_pushcppstring(LuaState, a_HelpString);
 
@@ -1427,7 +1528,10 @@ static int tolua_cPluginManager_BindCommand(lua_State * L)
 	// Read the arguments to this API call:
 	tolua_Error tolua_err;
 	int idx = 1;
-	if (tolua_isusertype(L, 1, "cPluginManager", 0, &tolua_err))
+	if (
+		tolua_isusertype (L, 1, "cPluginManager", 0, &tolua_err) ||
+		tolua_isusertable(L, 1, "cPluginManager", 0, &tolua_err)
+	)
 	{
 		idx++;
 	}
@@ -1469,7 +1573,8 @@ static int tolua_cPluginManager_BindCommand(lua_State * L)
 	}
 	
 	Plugin->BindCommand(Command, FnRef);
-	return 0;
+	lua_pushboolean(L, true);
+	return 1;
 }
 
 
@@ -1493,7 +1598,10 @@ static int tolua_cPluginManager_BindConsoleCommand(lua_State * L)
 	// Read the arguments to this API call:
 	tolua_Error tolua_err;
 	int idx = 1;
-	if (tolua_isusertype(L, 1, "cPluginManager", 0, &tolua_err))
+	if (
+		tolua_isusertype(L, 1, "cPluginManager", 0, &tolua_err) ||
+		tolua_isusertable(L, 1, "cPluginManager", 0, &tolua_err)
+	)
 	{
 		idx++;
 	}
@@ -1533,6 +1641,131 @@ static int tolua_cPluginManager_BindConsoleCommand(lua_State * L)
 	}
 	
 	Plugin->BindConsoleCommand(Command, FnRef);
+	lua_pushboolean(L, true);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cPluginManager_CallPlugin(lua_State * tolua_S)
+{
+	/*
+	Function signature:
+	cPluginManager:CallPlugin("PluginName", "FunctionName", args...)
+	*/
+	
+	// Check the parameters:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserTable(1, "cPluginManager") ||
+		!L.CheckParamString(2, 3))
+	{
+		return 0;
+	}
+	
+	// Retrieve the plugin name and function name
+	AString PluginName, FunctionName;
+	L.ToString(2, PluginName);
+	L.ToString(3, FunctionName);
+	if (PluginName.empty() || FunctionName.empty())
+	{
+		LOGWARNING("cPluginManager:CallPlugin(): Invalid plugin name or function name");
+		L.LogStackTrace();
+		return 0;
+	}
+	
+	// If requesting calling the current plugin, refuse:
+	cPluginLua * ThisPlugin = GetLuaPlugin(L);
+	if (ThisPlugin == NULL)
+	{
+		return 0;
+	}
+	if (ThisPlugin->GetName() == PluginName)
+	{
+		LOGWARNING("cPluginManager::CallPlugin(): Calling self is not implemented (why would it?)");
+		L.LogStackTrace();
+		return 0;
+	}
+	
+	// Call the destination plugin using a plugin callback:
+	class cCallback :
+		public cPluginManager::cPluginCallback
+	{
+	public:
+		int m_NumReturns;
+
+		cCallback(const AString & a_FunctionName, cLuaState & a_SrcLuaState) :
+			m_NumReturns(0),
+			m_FunctionName(a_FunctionName),
+			m_SrcLuaState(a_SrcLuaState)
+		{
+		}
+	protected:
+		const AString & m_FunctionName;
+		cLuaState & m_SrcLuaState;
+		
+		virtual bool Item(cPlugin * a_Plugin) override
+		{
+			m_NumReturns = ((cPluginLua *)a_Plugin)->CallFunctionFromForeignState(
+				m_FunctionName, m_SrcLuaState, 4, lua_gettop(m_SrcLuaState)
+			);
+			return true;
+		}
+	} Callback(FunctionName, L);
+	if (!cPluginManager::Get()->DoWithPlugin(PluginName, Callback))
+	{
+		// TODO 2014_01_20 _X: This might be too much logging, plugins cannot know if other plugins are loaded (async)
+		LOGWARNING("cPluginManager::CallPlugin: No such plugin name (\"%s\")", PluginName.c_str());
+		L.LogStackTrace();
+		return 0;
+	}
+	return Callback.m_NumReturns;
+}
+
+
+
+
+
+static int tolua_cWorld_ChunkStay(lua_State * tolua_S)
+{
+	/* Function signature:
+	World:ChunkStay(ChunkCoordTable, OnChunkAvailable, OnAllChunksAvailable)
+	ChunkCoordTable == { {Chunk1x, Chunk1z}, {Chunk2x, Chunk2z}, ... }
+	*/
+	
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType     (1, "cWorld") ||
+		!L.CheckParamTable        (2) ||
+		!L.CheckParamFunctionOrNil(3, 4)
+	)
+	{
+		return 0;
+	}
+	
+	cPluginLua * Plugin = GetLuaPlugin(tolua_S);
+	if (Plugin == NULL)
+	{
+		return 0;
+	}
+	cLuaChunkStay * ChunkStay = new cLuaChunkStay(*Plugin);
+	
+	// Read the params:
+	cWorld * World = (cWorld *)tolua_tousertype(tolua_S, 1, NULL);
+	if (World == NULL)
+	{
+		LOGWARNING("World:ChunkStay(): invalid world parameter");
+		L.LogStackTrace();
+		return 0;
+	}
+	if (!ChunkStay->AddChunks(2))
+	{
+		return 0;
+	}
+
+	ChunkStay->Enable(*World->GetChunkMap(), 3, 4);
 	return 0;
 }
 
@@ -1542,7 +1775,7 @@ static int tolua_cPluginManager_BindConsoleCommand(lua_State * L)
 
 static int tolua_cPlayer_GetGroups(lua_State* tolua_S)
 {
-	cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,0);
+	cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S, 1, NULL);
 
 	const cPlayer::GroupList & AllGroups = self->GetGroups();
 
@@ -1567,7 +1800,7 @@ static int tolua_cPlayer_GetGroups(lua_State* tolua_S)
 
 static int tolua_cPlayer_GetResolvedPermissions(lua_State* tolua_S)
 {
-	cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,0);
+	cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S, 1, NULL);
 
 	cPlayer::StringList AllPermissions = self->GetResolvedPermissions();
 
@@ -1680,7 +1913,7 @@ static int tolua_SetObjectCallback(lua_State * tolua_S)
 
 static int tolua_cPluginLua_AddWebTab(lua_State * tolua_S)
 {
-	cPluginLua * self = (cPluginLua *)tolua_tousertype(tolua_S,1,0);
+	cPluginLua * self = (cPluginLua *)tolua_tousertype(tolua_S, 1, NULL);
 
 	tolua_Error tolua_err;
 	tolua_err.array = 0;
@@ -1724,7 +1957,7 @@ static int tolua_cPluginLua_AddWebTab(lua_State * tolua_S)
 
 static int tolua_cPluginLua_AddTab(lua_State* tolua_S)
 {
-	cPluginLua * self = (cPluginLua *) tolua_tousertype(tolua_S, 1, 0);
+	cPluginLua * self = (cPluginLua *) tolua_tousertype(tolua_S, 1, NULL);
 	LOGWARN("WARNING: Using deprecated function AddTab()! Use AddWebTab() instead. (plugin \"%s\" in folder \"%s\")",
 		self->GetName().c_str(), self->GetDirectory().c_str()
 	);
@@ -1734,112 +1967,28 @@ static int tolua_cPluginLua_AddTab(lua_State* tolua_S)
 
 
 
-// Perhaps use this as well for copying tables https://github.com/keplerproject/rings/pull/1
-static int copy_lua_values(lua_State * a_Source, lua_State * a_Destination, int i, int top)
-{
-	for(; i <= top; ++i )
-	{
-		int t = lua_type(a_Source, i);
-		switch (t) {
-			case LUA_TSTRING:  /* strings */
-				{
-					const char * s = lua_tostring(a_Source, i);
-					LOGD("%i push string: %s", i, s);
-					tolua_pushstring(a_Destination, s);
-				}
-				break;
-			case LUA_TBOOLEAN:  /* booleans */
-				{
-					int b = tolua_toboolean(a_Source, i, false);
-					LOGD("%i push bool: %i", i, b);
-					tolua_pushboolean(a_Destination, b );
-				}
-				break;
-			case LUA_TNUMBER:  /* numbers */
-				{
-					lua_Number d = tolua_tonumber(a_Source, i, 0);
-					LOGD("%i push number: %0.2f", i, d);
-					tolua_pushnumber(a_Destination, d );
-				}
-				break;
-			case LUA_TUSERDATA:
-				{
-					const char * type = 0;
-					if (lua_getmetatable(a_Source,i))
-					{
-						lua_rawget(a_Source, LUA_REGISTRYINDEX);
-						type = lua_tostring(a_Source, -1);
-						lua_pop(a_Source, 1); // Pop.. something?! I don't knooow~~ T_T
-					}
-					
-					// don't need tolua_tousertype we already have the type
-					void * ud = tolua_touserdata(a_Source, i, 0);
-					LOGD("%i push usertype: %p of type '%s'", i, ud, type);
-					if( type == 0 )
-					{
-						LOGERROR("Call(): Something went wrong when trying to get usertype name!");
-						return 0;
-					}
-					tolua_pushusertype(a_Destination, ud, type);
-				}
-				break;
-			default:  /* other values */
-				LOGERROR("Call(): Unsupported value: '%s'. Can only use numbers and strings!", lua_typename(a_Source, t));
-				return 0;
-		}
-	}
-	return 1;
-}
-
-
-
 
-
-static int tolua_cPlugin_Call(lua_State* tolua_S)
+static int tolua_cPlugin_Call(lua_State * tolua_S)
 {
-	cPluginLua * self = (cPluginLua *) tolua_tousertype(tolua_S, 1, 0);
-	lua_State* targetState = self->GetLuaState();
-	int targetTop = lua_gettop(targetState);
-
-	int top = lua_gettop(tolua_S);
-	LOGD("total in stack: %i", top );
-
-	std::string funcName = tolua_tostring(tolua_S, 2, "");
-	LOGD("Func name: %s", funcName.c_str() );
-
-	lua_getglobal(targetState, funcName.c_str());
-	if(!lua_isfunction(targetState,-1))
-	{
-		LOGWARN("Error could not find function '%s' in plugin '%s'", funcName.c_str(), self->GetName().c_str() );
-		lua_pop(targetState,1);
-		return 0;
-	}
-
-	if( copy_lua_values(tolua_S, targetState, 3, top) == 0 ) // Start at 3 because 1 and 2 are the plugin and function name respectively
-	{
-		// something went wrong, exit
-		return 0;
-	}
+	cLuaState L(tolua_S);
 	
-	int s = lua_pcall(targetState, top - 2, LUA_MULTRET, 0);
-	if (cLuaState::ReportErrors(targetState, s))
-	{
-		LOGWARN("Error while calling function '%s' in plugin '%s'", funcName.c_str(), self->GetName().c_str() );
-		return 0;
-	}
-
-	int nresults = lua_gettop(targetState) - targetTop;
-	LOGD("num results: %i", nresults);
-	int ttop = lua_gettop(targetState);
-	if( copy_lua_values(targetState, tolua_S, targetTop+1, ttop) == 0 ) // Start at targetTop+1 and I have no idea why xD
+	// Log the obsoletion warning:
+	LOGWARNING("cPlugin:Call() is obsolete and unsafe, use cPluginManager:CallPlugin() instead.");
+	L.LogStackTrace();
+	
+	// Retrieve the params: plugin and the function name to call
+	cPluginLua * TargetPlugin = (cPluginLua *) tolua_tousertype(tolua_S, 1, NULL);
+	AString FunctionName = tolua_tostring(tolua_S, 2, "");
+	
+	// Call the function:
+	int NumReturns = TargetPlugin->CallFunctionFromForeignState(FunctionName, L, 3, lua_gettop(L));
+	if (NumReturns < 0)
 	{
-		// something went wrong, exit
+		LOGWARNING("cPlugin::Call() failed to call destination function");
+		L.LogStackTrace();
 		return 0;
 	}
-
-	lua_pop(targetState, nresults); // I have no idea what I'm doing, but it works
-
-	return nresults;
+	return NumReturns;
 }
 
 
@@ -1881,7 +2030,7 @@ static int tolua_push_StringStringMap(lua_State* tolua_S, std::map< std::string,
 
 static int tolua_get_HTTPRequest_Params(lua_State* tolua_S)
 {
-	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S,1,0);
+	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S, 1, NULL);
 	return tolua_push_StringStringMap(tolua_S, self->Params);
 }
 
@@ -1891,7 +2040,7 @@ static int tolua_get_HTTPRequest_Params(lua_State* tolua_S)
 
 static int tolua_get_HTTPRequest_PostParams(lua_State* tolua_S)
 {
-	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S,1,0);
+	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S, 1, NULL);
 	return tolua_push_StringStringMap(tolua_S, self->PostParams);
 }
 
@@ -1901,7 +2050,7 @@ static int tolua_get_HTTPRequest_PostParams(lua_State* tolua_S)
 
 static int tolua_get_HTTPRequest_FormData(lua_State* tolua_S)
 {
-	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S,1,0);
+	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S, 1, NULL);
 	std::map< std::string, HTTPFormData >& FormData = self->FormData;
 
 	lua_newtable(tolua_S);
@@ -1924,7 +2073,7 @@ static int tolua_get_HTTPRequest_FormData(lua_State* tolua_S)
 
 static int tolua_cWebAdmin_GetPlugins(lua_State * tolua_S)
 {
-	cWebAdmin* self = (cWebAdmin*)  tolua_tousertype(tolua_S,1,0);
+	cWebAdmin* self = (cWebAdmin*)  tolua_tousertype(tolua_S, 1, NULL);
 
 	const cWebAdmin::PluginList & AllPlugins = self->GetPlugins();
 
@@ -1949,7 +2098,7 @@ static int tolua_cWebAdmin_GetPlugins(lua_State * tolua_S)
 
 static int tolua_cWebPlugin_GetTabNames(lua_State * tolua_S)
 {
-	cWebPlugin* self = (cWebPlugin*)  tolua_tousertype(tolua_S,1,0);
+	cWebPlugin* self = (cWebPlugin*)  tolua_tousertype(tolua_S, 1, NULL);
 
 	const cWebPlugin::TabNameList & TabNames = self->GetTabNames();
 
@@ -2016,7 +2165,7 @@ static int Lua_ItemGrid_GetSlotCoords(lua_State * L)
 	}
 
 	{
-		const cItemGrid * self = (const cItemGrid *)tolua_tousertype(L, 1, 0);
+		const cItemGrid * self = (const cItemGrid *)tolua_tousertype(L, 1, NULL);
 		int SlotNum = (int)tolua_tonumber(L, 2, 0);
 		if (self == NULL)
 		{
@@ -2131,26 +2280,40 @@ protected:
 
 static int tolua_cLineBlockTracer_Trace(lua_State * tolua_S)
 {
-	// cLineBlockTracer.Trace(World, Callbacks, StartX, StartY, StartZ, EndX, EndY, EndZ)
+	/* Supported function signatures:
+	cLineBlockTracer:Trace(World, Callbacks, StartX, StartY, StartZ, EndX, EndY, EndZ)  // Canonical
+	cLineBlockTracer.Trace(World, Callbacks, StartX, StartY, StartZ, EndX, EndY, EndZ)
+	*/
+	
+	// If the first param is the cLineBlockTracer class, shift param index by one:
+	int idx = 1;
+	tolua_Error err;
+	if (tolua_isusertable(tolua_S, 1, "cLineBlockTracer", 0, &err))
+	{
+		idx = 2;
+	}
+	
+	// Check params:
 	cLuaState L(tolua_S);
 	if (
-		!L.CheckParamUserType(1, "cWorld") ||
-		!L.CheckParamTable   (2) ||
-		!L.CheckParamNumber  (3, 8) ||
-		!L.CheckParamEnd     (9)
+		!L.CheckParamUserType(idx, "cWorld") ||
+		!L.CheckParamTable   (idx + 1) ||
+		!L.CheckParamNumber  (idx + 2, idx + 7) ||
+		!L.CheckParamEnd     (idx + 8)
 	)
 	{
 		return 0;
 	}
 
-	cWorld * World = (cWorld *)tolua_tousertype(L, 1, NULL);
-	cLuaBlockTracerCallbacks Callbacks(L, 2);
-	double StartX = tolua_tonumber(L, 3, 0);
-	double StartY = tolua_tonumber(L, 4, 0);
-	double StartZ = tolua_tonumber(L, 5, 0);
-	double EndX   = tolua_tonumber(L, 6, 0);
-	double EndY   = tolua_tonumber(L, 7, 0);
-	double EndZ   = tolua_tonumber(L, 8, 0);
+	// Trace:
+	cWorld * World = (cWorld *)tolua_tousertype(L, idx, NULL);
+	cLuaBlockTracerCallbacks Callbacks(L, idx + 1);
+	double StartX = tolua_tonumber(L, idx + 2, 0);
+	double StartY = tolua_tonumber(L, idx + 3, 0);
+	double StartZ = tolua_tonumber(L, idx + 4, 0);
+	double EndX   = tolua_tonumber(L, idx + 5, 0);
+	double EndY   = tolua_tonumber(L, idx + 6, 0);
+	double EndZ   = tolua_tonumber(L, idx + 7, 0);
 	bool res = cLineBlockTracer::Trace(*World, Callbacks, StartX, StartY, StartZ, EndX, EndY, EndZ);
 	tolua_pushboolean(L, res ? 1 : 0);
 	return 1;
@@ -2214,7 +2377,7 @@ static int tolua_cHopperEntity_GetOutputBlockPos(lua_State * tolua_S)
 	{
 		return 0;
 	}
-	cHopperEntity * self = (cHopperEntity *)tolua_tousertype(tolua_S, 1, 0);
+	cHopperEntity * self = (cHopperEntity *)tolua_tousertype(tolua_S, 1, NULL);
 	if (self == NULL)
 	{
 		tolua_error(tolua_S, "invalid 'self' in function 'cHopperEntity::GetOutputBlockPos()'", NULL);
@@ -2239,6 +2402,508 @@ static int tolua_cHopperEntity_GetOutputBlockPos(lua_State * tolua_S)
 
 
 
+
+static int tolua_cBlockArea_GetBlockTypeMeta(lua_State * tolua_S)
+{
+	// function cBlockArea::GetBlockTypeMeta()
+	// Exported manually because tolua generates extra input params for the outputs
+	
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cBlockArea") ||
+		!L.CheckParamNumber  (2, 4)
+	)
+	{
+		return 0;
+	}
+	
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetRelBlockTypeMeta'", NULL);
+		return 0;
+	}
+	int BlockX = (int)tolua_tonumber(tolua_S, 2, 0);
+	int BlockY = (int)tolua_tonumber(tolua_S, 3, 0);
+	int BlockZ = (int)tolua_tonumber(tolua_S, 4, 0);
+	BLOCKTYPE BlockType;
+	NIBBLETYPE BlockMeta;
+	self->GetBlockTypeMeta(BlockX, BlockY, BlockZ, BlockType, BlockMeta);
+	tolua_pushnumber(tolua_S, BlockType);
+	tolua_pushnumber(tolua_S, BlockMeta);
+	return 2;
+}
+
+
+
+
+
+static int tolua_cBlockArea_GetOrigin(lua_State * tolua_S)
+{
+	// function cBlockArea::GetOrigin()
+	// Returns all three coords of the origin point
+	// Exported manually because there's no direct C++ equivalent,
+	// plus tolua would generate extra input params for the outputs
+	
+	cLuaState L(tolua_S);
+	if (!L.CheckParamUserType(1, "cBlockArea"))
+	{
+		return 0;
+	}
+	
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetOrigin'", NULL);
+		return 0;
+	}
+	
+	// Push the three origin coords:
+	lua_pushnumber(tolua_S, self->GetOriginX());
+	lua_pushnumber(tolua_S, self->GetOriginY());
+	lua_pushnumber(tolua_S, self->GetOriginZ());
+	return 3;
+}
+
+
+
+
+
+static int tolua_cBlockArea_GetRelBlockTypeMeta(lua_State * tolua_S)
+{
+	// function cBlockArea::GetRelBlockTypeMeta()
+	// Exported manually because tolua generates extra input params for the outputs
+	
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cBlockArea") ||
+		!L.CheckParamNumber  (2, 4)
+	)
+	{
+		return 0;
+	}
+	
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetRelBlockTypeMeta'", NULL);
+		return 0;
+	}
+	int BlockX = (int)tolua_tonumber(tolua_S, 2, 0);
+	int BlockY = (int)tolua_tonumber(tolua_S, 3, 0);
+	int BlockZ = (int)tolua_tonumber(tolua_S, 4, 0);
+	BLOCKTYPE BlockType;
+	NIBBLETYPE BlockMeta;
+	self->GetRelBlockTypeMeta(BlockX, BlockY, BlockZ, BlockType, BlockMeta);
+	tolua_pushnumber(tolua_S, BlockType);
+	tolua_pushnumber(tolua_S, BlockMeta);
+	return 2;
+}
+
+
+
+
+
+static int tolua_cBlockArea_GetSize(lua_State * tolua_S)
+{
+	// function cBlockArea::GetSize()
+	// Returns all three sizes of the area
+	// Exported manually because there's no direct C++ equivalent,
+	// plus tolua would generate extra input params for the outputs
+	
+	cLuaState L(tolua_S);
+	if (!L.CheckParamUserType(1, "cBlockArea"))
+	{
+		return 0;
+	}
+	
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetSize'", NULL);
+		return 0;
+	}
+	
+	// Push the three origin coords:
+	lua_pushnumber(tolua_S, self->GetSizeX());
+	lua_pushnumber(tolua_S, self->GetSizeY());
+	lua_pushnumber(tolua_S, self->GetSizeZ());
+	return 3;
+}
+
+
+
+
+
+static int tolua_cBlockArea_LoadFromSchematicFile(lua_State * tolua_S)
+{
+	// function cBlockArea::LoadFromSchematicFile
+	// Exported manually because function has been moved to SchematicFileSerializer.cpp
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cBlockArea") ||
+		!L.CheckParamString  (2) ||
+		!L.CheckParamEnd     (3)
+	)
+	{
+		return 0;
+	}
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::LoadFromSchematicFile'", NULL);
+		return 0;
+	}
+
+	AString Filename = tolua_tostring(tolua_S, 2, 0);
+	bool res = cSchematicFileSerializer::LoadFromSchematicFile(*self,Filename);
+	tolua_pushboolean(tolua_S, res);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cBlockArea_LoadFromSchematicString(lua_State * tolua_S)
+{
+	// function cBlockArea::LoadFromSchematicString
+	// Exported manually because function has been moved to SchematicFileSerializer.cpp
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cBlockArea") ||
+		!L.CheckParamString  (2) ||
+		!L.CheckParamEnd     (3)
+	)
+	{
+		return 0;
+	}
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::LoadFromSchematicFile'", NULL);
+		return 0;
+	}
+
+	AString Data;
+	L.GetStackValue(2, Data);
+	bool res = cSchematicFileSerializer::LoadFromSchematicString(*self, Data);
+	tolua_pushboolean(tolua_S, res);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cBlockArea_SaveToSchematicFile(lua_State * tolua_S)
+{
+	// function cBlockArea::SaveToSchematicFile
+	// Exported manually because function has been moved to SchematicFileSerializer.cpp
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cBlockArea") ||
+		!L.CheckParamString  (2) ||
+		!L.CheckParamEnd     (3)
+	)
+	{
+		return 0;
+	}
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::SaveToSchematicFile'", NULL);
+		return 0;
+	}
+	AString Filename = tolua_tostring(tolua_S, 2, 0);
+	bool res = cSchematicFileSerializer::SaveToSchematicFile(*self,Filename);
+	tolua_pushboolean(tolua_S, res);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cBlockArea_SaveToSchematicString(lua_State * tolua_S)
+{
+	// function cBlockArea::SaveToSchematicString
+	// Exported manually because function has been moved to SchematicFileSerializer.cpp
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cBlockArea") ||
+		!L.CheckParamEnd     (2)
+	)
+	{
+		return 0;
+	}
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::SaveToSchematicFile'", NULL);
+		return 0;
+	}
+	
+	AString Data;
+	if (cSchematicFileSerializer::SaveToSchematicString(*self, Data))
+	{
+		L.Push(Data);
+		return 1;
+	}
+	return 0;
+}
+
+
+
+
+
+static int tolua_cCompositeChat_AddRunCommandPart(lua_State * tolua_S)
+{
+	// function cCompositeChat:AddRunCommandPart(Message, Command, [Style])
+	// Exported manually to support call-chaining (return *this)
+	
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cCompositeChat") ||
+		!L.CheckParamString(2, 3)
+	)
+	{
+		return 0;
+	}
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:AddRunCommandPart'", NULL);
+		return 0;
+	}
+	
+	// Add the part:
+	AString Text, Command, Style;
+	L.GetStackValue(2, Text);
+	L.GetStackValue(3, Command);
+	L.GetStackValue(4, Style);
+	self->AddRunCommandPart(Text, Command, Style);
+	
+	// Cut away everything from the stack except for the cCompositeChat instance; return that:
+	lua_settop(L, 1);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cCompositeChat_AddSuggestCommandPart(lua_State * tolua_S)
+{
+	// function cCompositeChat:AddSuggestCommandPart(Message, Command, [Style])
+	// Exported manually to support call-chaining (return *this)
+	
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cCompositeChat") ||
+		!L.CheckParamString(2, 3)
+	)
+	{
+		return 0;
+	}
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:AddSuggestCommandPart'", NULL);
+		return 0;
+	}
+	
+	// Add the part:
+	AString Text, Command, Style;
+	L.GetStackValue(2, Text);
+	L.GetStackValue(3, Command);
+	L.GetStackValue(4, Style);
+	self->AddSuggestCommandPart(Text, Command, Style);
+	
+	// Cut away everything from the stack except for the cCompositeChat instance; return that:
+	lua_settop(L, 1);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cCompositeChat_AddTextPart(lua_State * tolua_S)
+{
+	// function cCompositeChat:AddTextPart(Message, [Style])
+	// Exported manually to support call-chaining (return *this)
+	
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cCompositeChat") ||
+		!L.CheckParamString(2)
+	)
+	{
+		return 0;
+	}
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:AddTextPart'", NULL);
+		return 0;
+	}
+	
+	// Add the part:
+	AString Text, Style;
+	L.GetStackValue(2, Text);
+	L.GetStackValue(3, Style);
+	self->AddTextPart(Text, Style);
+	
+	// Cut away everything from the stack except for the cCompositeChat instance; return that:
+	lua_settop(L, 1);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cCompositeChat_AddUrlPart(lua_State * tolua_S)
+{
+	// function cCompositeChat:AddTextPart(Message, Url, [Style])
+	// Exported manually to support call-chaining (return *this)
+	
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cCompositeChat") ||
+		!L.CheckParamString(2, 3)
+	)
+	{
+		return 0;
+	}
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:AddUrlPart'", NULL);
+		return 0;
+	}
+	
+	// Add the part:
+	AString Text, Url, Style;
+	L.GetStackValue(2, Text);
+	L.GetStackValue(3, Url);
+	L.GetStackValue(4, Style);
+	self->AddUrlPart(Text, Url, Style);
+	
+	// Cut away everything from the stack except for the cCompositeChat instance; return that:
+	lua_settop(L, 1);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cCompositeChat_ParseText(lua_State * tolua_S)
+{
+	// function cCompositeChat:ParseText(TextMessage)
+	// Exported manually to support call-chaining (return *this)
+	
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cCompositeChat") ||
+		!L.CheckParamString(2)
+	)
+	{
+		return 0;
+	}
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:ParseText'", NULL);
+		return 0;
+	}
+	
+	// Parse the text:
+	AString Text;
+	L.GetStackValue(2, Text);
+	self->ParseText(Text);
+	
+	// Cut away everything from the stack except for the cCompositeChat instance; return that:
+	lua_settop(L, 1);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cCompositeChat_SetMessageType(lua_State * tolua_S)
+{
+	// function cCompositeChat:SetMessageType(MessageType)
+	// Exported manually to support call-chaining (return *this)
+	
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cCompositeChat") ||
+		!L.CheckParamNumber(2)
+	)
+	{
+		return 0;
+	}
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:SetMessageType'", NULL);
+		return 0;
+	}
+	
+	// Set the type:
+	int MessageType;
+	L.GetStackValue(1, MessageType);
+	self->SetMessageType((eMessageType)MessageType);
+	
+	// Cut away everything from the stack except for the cCompositeChat instance; return that:
+	lua_settop(L, 1);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cCompositeChat_UnderlineUrls(lua_State * tolua_S)
+{
+	// function cCompositeChat:UnderlineUrls()
+	// Exported manually to support call-chaining (return *this)
+	
+	// Check params:
+	cLuaState L(tolua_S);
+	if (!L.CheckParamUserType(1, "cCompositeChat"))
+	{
+		return 0;
+	}
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:UnderlineUrls'", NULL);
+		return 0;
+	}
+	
+	// Call the processing
+	self->UnderlineUrls();
+	
+	// Cut away everything from the stack except for the cCompositeChat instance; return that:
+	lua_settop(L, 1);
+	return 1;
+}
+
+
+
+
+
 void ManualBindings::Bind(lua_State * tolua_S)
 {
 	tolua_beginmodule(tolua_S, NULL);
@@ -2249,11 +2914,34 @@ void ManualBindings::Bind(lua_State * tolua_S)
 		tolua_function(tolua_S, "LOGWARN",            tolua_LOGWARN);
 		tolua_function(tolua_S, "LOGWARNING",         tolua_LOGWARN);
 		tolua_function(tolua_S, "LOGERROR",           tolua_LOGERROR);
+		tolua_function(tolua_S, "Base64Encode",       tolua_Base64Encode);
+		tolua_function(tolua_S, "Base64Decode",       tolua_Base64Decode);
 		
 		tolua_beginmodule(tolua_S, "cFile");
 			tolua_function(tolua_S, "GetFolderContents", tolua_cFile_GetFolderContents);
 		tolua_endmodule(tolua_S);
 		
+		tolua_beginmodule(tolua_S, "cBlockArea");
+			tolua_function(tolua_S, "GetBlockTypeMeta",        tolua_cBlockArea_GetBlockTypeMeta);
+			tolua_function(tolua_S, "GetOrigin",               tolua_cBlockArea_GetOrigin);
+			tolua_function(tolua_S, "GetRelBlockTypeMeta",     tolua_cBlockArea_GetRelBlockTypeMeta);
+			tolua_function(tolua_S, "GetSize",                 tolua_cBlockArea_GetSize);
+			tolua_function(tolua_S, "LoadFromSchematicFile",   tolua_cBlockArea_LoadFromSchematicFile);
+			tolua_function(tolua_S, "LoadFromSchematicString", tolua_cBlockArea_LoadFromSchematicString);
+			tolua_function(tolua_S, "SaveToSchematicFile",     tolua_cBlockArea_SaveToSchematicFile);
+			tolua_function(tolua_S, "SaveToSchematicString",   tolua_cBlockArea_SaveToSchematicString);
+		tolua_endmodule(tolua_S);
+		
+		tolua_beginmodule(tolua_S, "cCompositeChat");
+			tolua_function(tolua_S, "AddRunCommandPart",     tolua_cCompositeChat_AddRunCommandPart);
+			tolua_function(tolua_S, "AddSuggestCommandPart", tolua_cCompositeChat_AddSuggestCommandPart);
+			tolua_function(tolua_S, "AddTextPart",           tolua_cCompositeChat_AddTextPart);
+			tolua_function(tolua_S, "AddUrlPart",            tolua_cCompositeChat_AddUrlPart);
+			tolua_function(tolua_S, "ParseText",             tolua_cCompositeChat_ParseText);
+			tolua_function(tolua_S, "SetMessageType",        tolua_cCompositeChat_SetMessageType);
+			tolua_function(tolua_S, "UnderlineUrls",         tolua_cCompositeChat_UnderlineUrls);
+		tolua_endmodule(tolua_S);
+		
 		tolua_beginmodule(tolua_S, "cHopperEntity");
 			tolua_function(tolua_S, "GetOutputBlockPos", tolua_cHopperEntity_GetOutputBlockPos);
 		tolua_endmodule(tolua_S);
@@ -2270,6 +2958,7 @@ void ManualBindings::Bind(lua_State * tolua_S)
 		tolua_endmodule(tolua_S);
 		
 		tolua_beginmodule(tolua_S, "cWorld");
+			tolua_function(tolua_S, "ChunkStay",                 tolua_cWorld_ChunkStay);
 			tolua_function(tolua_S, "DoWithBlockEntityAt",       tolua_DoWithXYZ<cWorld, cBlockEntity,        &cWorld::DoWithBlockEntityAt>);
 			tolua_function(tolua_S, "DoWithChestAt",             tolua_DoWithXYZ<cWorld, cChestEntity,        &cWorld::DoWithChestAt>);
 			tolua_function(tolua_S, "DoWithDispenserAt",         tolua_DoWithXYZ<cWorld, cDispenserEntity,    &cWorld::DoWithDispenserAt>);
@@ -2279,6 +2968,8 @@ void ManualBindings::Bind(lua_State * tolua_S)
 			tolua_function(tolua_S, "DoWithFurnaceAt",           tolua_DoWithXYZ<cWorld, cFurnaceEntity,      &cWorld::DoWithFurnaceAt>);
 			tolua_function(tolua_S, "DoWithNoteBlockAt",         tolua_DoWithXYZ<cWorld, cNoteEntity,         &cWorld::DoWithNoteBlockAt>);
 			tolua_function(tolua_S, "DoWithCommandBlockAt",      tolua_DoWithXYZ<cWorld, cCommandBlockEntity, &cWorld::DoWithCommandBlockAt>);
+			tolua_function(tolua_S, "DoWithMobHeadAt",           tolua_DoWithXYZ<cWorld, cMobHeadEntity,      &cWorld::DoWithMobHeadAt>);
+			tolua_function(tolua_S, "DoWithFlowerPotAt",         tolua_DoWithXYZ<cWorld, cFlowerPotEntity,    &cWorld::DoWithFlowerPotAt>);
 			tolua_function(tolua_S, "DoWithPlayer",              tolua_DoWith<   cWorld, cPlayer,             &cWorld::DoWithPlayer>);
 			tolua_function(tolua_S, "FindAndDoWithPlayer",       tolua_DoWith<   cWorld, cPlayer,             &cWorld::FindAndDoWithPlayer>);
 			tolua_function(tolua_S, "ForEachBlockEntityInChunk", tolua_ForEachInChunk<cWorld, cBlockEntity,   &cWorld::ForEachBlockEntityInChunk>);
@@ -2297,6 +2988,15 @@ void ManualBindings::Bind(lua_State * tolua_S)
 			tolua_function(tolua_S, "UpdateSign",                tolua_cWorld_SetSignLines);
 		tolua_endmodule(tolua_S);
 		
+		tolua_beginmodule(tolua_S, "cMapManager");
+			tolua_function(tolua_S, "DoWithMap", tolua_DoWithID<cMapManager, cMap, &cMapManager::DoWithMap>);
+		tolua_endmodule(tolua_S);
+
+		tolua_beginmodule(tolua_S, "cScoreboard");
+			tolua_function(tolua_S, "ForEachObjective", tolua_ForEach<cScoreboard, cObjective, &cScoreboard::ForEachObjective>);
+			tolua_function(tolua_S, "ForEachTeam",      tolua_ForEach<cScoreboard, cTeam,      &cScoreboard::ForEachTeam>);
+		tolua_endmodule(tolua_S);
+		
 		tolua_beginmodule(tolua_S, "cPlugin");
 			tolua_function(tolua_S, "Call", tolua_cPlugin_Call);
 		tolua_endmodule(tolua_S);
@@ -2305,10 +3005,12 @@ void ManualBindings::Bind(lua_State * tolua_S)
 			tolua_function(tolua_S, "AddHook",               tolua_cPluginManager_AddHook);
 			tolua_function(tolua_S, "BindCommand",           tolua_cPluginManager_BindCommand);
 			tolua_function(tolua_S, "BindConsoleCommand",    tolua_cPluginManager_BindConsoleCommand);
+			tolua_function(tolua_S, "CallPlugin",            tolua_cPluginManager_CallPlugin);
 			tolua_function(tolua_S, "ForEachCommand",        tolua_cPluginManager_ForEachCommand);
 			tolua_function(tolua_S, "ForEachConsoleCommand", tolua_cPluginManager_ForEachConsoleCommand);
 			tolua_function(tolua_S, "GetAllPlugins",         tolua_cPluginManager_GetAllPlugins);
 			tolua_function(tolua_S, "GetCurrentPlugin",      tolua_cPluginManager_GetCurrentPlugin);
+			tolua_function(tolua_S, "LogStackTrace",         tolua_cPluginManager_LogStackTrace);
 		tolua_endmodule(tolua_S);
 		
 		tolua_beginmodule(tolua_S, "cPlayer");
diff --git a/src/Bindings/ManualBindings.h b/src/Bindings/ManualBindings.h
index e6594947e..f38e26267 100644
--- a/src/Bindings/ManualBindings.h
+++ b/src/Bindings/ManualBindings.h
@@ -5,4 +5,4 @@ class ManualBindings
 {
 public:
 	static void Bind( lua_State* tolua_S );
-};
\ No newline at end of file
+};
diff --git a/src/Bindings/Plugin.h b/src/Bindings/Plugin.h
index f4a117721..df0bd4dcc 100644
--- a/src/Bindings/Plugin.h
+++ b/src/Bindings/Plugin.h
@@ -46,6 +46,7 @@ public:
 	 * On all these functions, return true if you want to override default behavior and not call other plugins on that callback.
 	 * You can also return false, so default behavior is used.
 	 **/
+	virtual bool OnBlockSpread              (cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, eSpreadSource a_Source) = 0;
 	virtual bool OnBlockToPickups           (cWorld * a_World, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, cItems & a_Pickups) = 0;
 	virtual bool OnChat                     (cPlayer * a_Player, AString & a_Message) = 0;
 	virtual bool OnChunkAvailable           (cWorld * a_World, int a_ChunkX, int a_ChunkZ) = 0;
@@ -67,6 +68,7 @@ public:
 	virtual bool OnPlayerAnimation          (cPlayer & a_Player, int a_Animation) = 0;
 	virtual bool OnPlayerBreakingBlock      (cPlayer & a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) = 0;
 	virtual bool OnPlayerBrokenBlock        (cPlayer & a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) = 0;
+	virtual bool OnPlayerDestroyed          (cPlayer & a_Player) = 0;
 	virtual bool OnPlayerEating             (cPlayer & a_Player) = 0;
 	virtual bool OnPlayerFished             (cPlayer & a_Player, const cItems & a_Reward) = 0;
 	virtual bool OnPlayerFishing            (cPlayer & a_Player, cItems & a_Reward) = 0;
@@ -88,6 +90,8 @@ public:
 	virtual bool OnPluginsLoaded            (void) = 0;
 	virtual bool OnPostCrafting             (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe) = 0;
 	virtual bool OnPreCrafting              (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe) = 0;
+	virtual bool OnProjectileHitBlock       (cProjectileEntity & a_Projectile) = 0;
+	virtual bool OnProjectileHitEntity      (cProjectileEntity & a_Projectile, cEntity & a_HitEntity) = 0;
 	virtual bool OnSpawnedEntity            (cWorld & a_World, cEntity & a_Entity) = 0;
 	virtual bool OnSpawnedMonster           (cWorld & a_World, cMonster & a_Monster) = 0;
 	virtual bool OnSpawningEntity           (cWorld & a_World, cEntity & a_Entity) = 0;
diff --git a/src/Bindings/PluginLua.cpp b/src/Bindings/PluginLua.cpp
index 4c4664815..dcc816839 100644
--- a/src/Bindings/PluginLua.cpp
+++ b/src/Bindings/PluginLua.cpp
@@ -5,7 +5,11 @@
 
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
+#ifdef __APPLE__
+#define LUA_USE_MACOSX
+#else
 #define LUA_USE_POSIX
+#endif
 #include "PluginLua.h"
 #include "../CommandOutput.h"
 
@@ -14,6 +18,7 @@ extern "C"
 	#include "lua/src/lualib.h"
 }
 
+#undef TOLUA_TEMPLATE_BIND
 #include "tolua++/include/tolua++.h"
 
 
@@ -75,6 +80,7 @@ bool cPluginLua::Initialize(void)
 	if (!m_LuaState.IsValid())
 	{	
 		m_LuaState.Create();
+		m_LuaState.RegisterAPILibs();
 		
 		// Inject the identification global variables into the state:
 		lua_pushlightuserdata(m_LuaState, this);
@@ -82,42 +88,69 @@ bool cPluginLua::Initialize(void)
 		lua_pushstring(m_LuaState, GetName().c_str());
 		lua_setglobal(m_LuaState, LUA_PLUGIN_NAME_VAR_NAME);
 		
+		// Add the plugin's folder to the package.path and package.cpath variables (#693):
+		m_LuaState.AddPackagePath("path", FILE_IO_PREFIX + GetLocalFolder() + "/?.lua");
+		#ifdef _WIN32
+			m_LuaState.AddPackagePath("cpath", GetLocalFolder() + "\\?.dll");
+		#else
+			m_LuaState.AddPackagePath("cpath", FILE_IO_PREFIX + GetLocalFolder() + "/?.so");
+		#endif
+		
 		tolua_pushusertype(m_LuaState, this, "cPluginLua");
 		lua_setglobal(m_LuaState, "g_Plugin");
 	}
 
 	std::string PluginPath = FILE_IO_PREFIX + GetLocalFolder() + "/";
 
-	// Load all files for this plugin, and execute them
+	// List all Lua files for this plugin. Info.lua has a special handling - make it the last to load:
 	AStringVector Files = cFile::GetFolderContents(PluginPath.c_str());
-
-	int numFiles = 0;
-	for (AStringVector::const_iterator itr = Files.begin(); itr != Files.end(); ++itr)
+	AStringVector LuaFiles;
+	bool HasInfoLua = false;
+	for (AStringVector::const_iterator itr = Files.begin(), end = Files.end(); itr != end; ++itr)
 	{
-		if (itr->rfind(".lua") == AString::npos)
+		if (itr->rfind(".lua") != AString::npos)
 		{
-			continue;
+			if (*itr == "Info.lua")
+			{
+				HasInfoLua = true;
+			}
+			else
+			{
+				LuaFiles.push_back(*itr);
+			}
 		}
+	}
+	std::sort(LuaFiles.begin(), LuaFiles.end());
+	
+	// Warn if there are no Lua files in the plugin folder:
+	if (LuaFiles.empty())
+	{
+		LOGWARNING("No lua files found: plugin %s is missing.", GetName().c_str());
+		Close();
+		return false;
+	}
+
+	// Load all files in the list, including the Info.lua as last, if it exists:
+	for (AStringVector::const_iterator itr = LuaFiles.begin(), end = LuaFiles.end(); itr != end; ++itr)
+	{
 		AString Path = PluginPath + *itr;
 		if (!m_LuaState.LoadFile(Path))
 		{
 			Close();
 			return false;
-		} 
-		else 
-		{
-			numFiles++;
 		}
 	}  // for itr - Files[]
-
-	if (numFiles == 0)
+	if (HasInfoLua)
 	{
-		LOGWARNING("No lua files found: plugin %s is missing.", GetName().c_str());
-		Close();
-		return false;
+		AString Path = PluginPath + "Info.lua";
+		if (!m_LuaState.LoadFile(Path))
+		{
+			Close();
+			return false;
+		}
 	}
 
-	// Call intialize function
+	// Call the Initialize function:
 	bool res = false;
 	if (!m_LuaState.Call("Initialize", this, cLuaState::Return, res))
 	{
@@ -125,7 +158,6 @@ bool cPluginLua::Initialize(void)
 		Close();
 		return false;
 	}
-
 	if (!res)
 	{
 		LOGINFO("Plugin %s: Initialize() call failed, plugin is temporarily disabled.", GetName().c_str());
@@ -168,6 +200,26 @@ void cPluginLua::Tick(float a_Dt)
 
 
 
+bool cPluginLua::OnBlockSpread(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, eSpreadSource a_Source)
+{
+	cCSLock Lock(m_CriticalSection);
+	bool res = false;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_BLOCK_SPREAD];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_World, a_BlockX, a_BlockY, a_BlockZ, a_Source, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
 bool cPluginLua::OnBlockToPickups(cWorld * a_World, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, cItems & a_Pickups)
 {
 	cCSLock Lock(m_CriticalSection);
@@ -623,6 +675,26 @@ bool cPluginLua::OnPlayerBrokenBlock(cPlayer & a_Player, int a_BlockX, int a_Blo
 
 
 
+bool cPluginLua::OnPlayerDestroyed(cPlayer & a_Player)
+{
+	cCSLock Lock(m_CriticalSection);
+	bool res = false;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_DESTROYED];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Player, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
 bool cPluginLua::OnPlayerEating(cPlayer & a_Player)
 {
 	cCSLock Lock(m_CriticalSection);
@@ -1041,6 +1113,46 @@ bool cPluginLua::OnPreCrafting(const cPlayer * a_Player, const cCraftingGrid * a
 
 
 
+bool cPluginLua::OnProjectileHitBlock(cProjectileEntity & a_Projectile)
+{
+	cCSLock Lock(m_CriticalSection);
+	bool res = false;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PROJECTILE_HIT_BLOCK];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Projectile, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
+bool cPluginLua::OnProjectileHitEntity(cProjectileEntity & a_Projectile, cEntity & a_HitEntity)
+{
+	cCSLock Lock(m_CriticalSection);
+	bool res = false;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PROJECTILE_HIT_ENTITY];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Projectile, &a_HitEntity, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
 bool cPluginLua::OnSpawnedEntity(cWorld & a_World, cEntity & a_Entity)
 {
 	cCSLock Lock(m_CriticalSection);
@@ -1383,6 +1495,7 @@ const char * cPluginLua::GetHookFnName(int a_HookType)
 {
 	switch (a_HookType)
 	{
+		case cPluginManager::HOOK_BLOCK_SPREAD:                 return "OnBlockSpread";
 		case cPluginManager::HOOK_BLOCK_TO_PICKUPS:             return "OnBlockToPickups";
 		case cPluginManager::HOOK_CHAT:                         return "OnChat";
 		case cPluginManager::HOOK_CHUNK_AVAILABLE:              return "OnChunkAvailable";
@@ -1469,6 +1582,40 @@ bool cPluginLua::AddHookRef(int a_HookType, int a_FnRefIdx)
 
 
 
+int cPluginLua::CallFunctionFromForeignState(
+	const AString & a_FunctionName,
+	cLuaState & a_ForeignState,
+	int a_ParamStart,
+	int a_ParamEnd
+)
+{
+	cCSLock Lock(m_CriticalSection);
+	
+	// Call the function:
+	int NumReturns = m_LuaState.CallFunctionWithForeignParams(a_FunctionName, a_ForeignState, a_ParamStart, a_ParamEnd);
+	if (NumReturns < 0)
+	{
+		// The call has failed, an error has already been output to the log, so just silently bail out with the same error
+		return NumReturns;
+	}
+	
+	// Copy all the return values:
+	int Top = lua_gettop(m_LuaState);
+	int res = a_ForeignState.CopyStackFrom(m_LuaState, Top - NumReturns + 1, Top);
+	
+	// Remove the return values off this stack:
+	if (NumReturns > 0)
+	{
+		lua_pop(m_LuaState, NumReturns);
+	}
+	
+	return res;
+}
+
+
+
+
+
 AString cPluginLua::HandleWebRequest(const HTTPRequest * a_Request )
 {
 	cCSLock Lock(m_CriticalSection);
diff --git a/src/Bindings/PluginLua.h b/src/Bindings/PluginLua.h
index c01f5ca89..59542d23a 100644
--- a/src/Bindings/PluginLua.h
+++ b/src/Bindings/PluginLua.h
@@ -35,7 +35,33 @@ class cPluginLua :
 public:
 	// tolua_end
 	
-	cPluginLua( const AString & a_PluginDirectory );
+	/** A RAII-style mutex lock for accessing the internal LuaState.
+	This will be the only way to retrieve the plugin's LuaState;
+	therefore it directly supports accessing the LuaState of the locked plugin.
+	Usage:
+		cPluginLua::cOperation Op(SomePlugin);
+		Op().Call(...)  // Call a function in the plugin's LuaState
+	*/
+	class cOperation
+	{
+	public:
+		cOperation(cPluginLua & a_Plugin) :
+			m_Plugin(a_Plugin),
+			m_Lock(a_Plugin.m_CriticalSection)
+		{
+		}
+
+		cLuaState & operator ()(void) { return m_Plugin.m_LuaState; }
+		
+	protected:
+		cPluginLua & m_Plugin;
+		
+		/** RAII lock for m_Plugin.m_CriticalSection */
+		cCSLock m_Lock;
+	} ;
+	
+	
+	cPluginLua(const AString & a_PluginDirectory);
 	~cPluginLua();
 
 	virtual void OnDisable(void) override;
@@ -43,6 +69,7 @@ public:
 
 	virtual void Tick(float a_Dt) override;
 
+	virtual bool OnBlockSpread              (cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, eSpreadSource a_Source) override;
 	virtual bool OnBlockToPickups           (cWorld * a_World, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, cItems & a_Pickups) override;
 	virtual bool OnChat                     (cPlayer * a_Player, AString & a_Message) override;
 	virtual bool OnChunkAvailable           (cWorld * a_World, int a_ChunkX, int a_ChunkZ) override;
@@ -64,6 +91,7 @@ public:
 	virtual bool OnPlayerAnimation          (cPlayer & a_Player, int a_Animation) override;
 	virtual bool OnPlayerBreakingBlock      (cPlayer & a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
 	virtual bool OnPlayerBrokenBlock        (cPlayer & a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
+	virtual bool OnPlayerDestroyed          (cPlayer & a_Player) override;
 	virtual bool OnPlayerEating             (cPlayer & a_Player) override;
 	virtual bool OnPlayerFished             (cPlayer & a_Player, const cItems & a_Reward) override;
 	virtual bool OnPlayerFishing            (cPlayer & a_Player, cItems & a_Reward) override;
@@ -85,6 +113,8 @@ public:
 	virtual bool OnPluginsLoaded            (void) override;
 	virtual bool OnPostCrafting             (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe) override;
 	virtual bool OnPreCrafting              (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe) override;
+	virtual bool OnProjectileHitBlock       (cProjectileEntity & a_Projectile) override;
+	virtual bool OnProjectileHitEntity      (cProjectileEntity & a_Projectile, cEntity & a_HitEntity) override;
 	virtual bool OnSpawnedEntity            (cWorld & a_World, cEntity & a_Entity) override;
 	virtual bool OnSpawnedMonster           (cWorld & a_World, cMonster & a_Monster) override;
 	virtual bool OnSpawningEntity           (cWorld & a_World, cEntity & a_Entity) override;
@@ -105,7 +135,7 @@ public:
 	
 	virtual void ClearConsoleCommands(void) override;
 
-	/// Returns true if the plugin contains the function for the specified hook type, using the old-style registration (#121)
+	/** Returns true if the plugin contains the function for the specified hook type, using the old-style registration (#121) */
 	bool CanAddOldStyleHook(int a_HookType);
 	
 	// cWebPlugin override
@@ -115,26 +145,26 @@ public:
 	virtual AString HandleWebRequest(const HTTPRequest * a_Request ) override;
 	bool AddWebTab(const AString & a_Title, lua_State * a_LuaState, int a_FunctionReference);	// >> EXPORTED IN MANUALBINDINGS <<
 	
-	/// Binds the command to call the function specified by a Lua function reference. Simply adds to CommandMap.
+	/** Binds the command to call the function specified by a Lua function reference. Simply adds to CommandMap. */
 	void BindCommand(const AString & a_Command, int a_FnRef);
 
-	/// Binds the console command to call the function specified by a Lua function reference. Simply adds to CommandMap.
+	/** Binds the console command to call the function specified by a Lua function reference. Simply adds to CommandMap. */
 	void BindConsoleCommand(const AString & a_Command, int a_FnRef);
 
 	cLuaState & GetLuaState(void) { return m_LuaState; }
 
 	cCriticalSection & GetCriticalSection(void) { return m_CriticalSection; }
 	
-	/// Removes a previously referenced object (luaL_unref())
+	/** Removes a previously referenced object (luaL_unref()) */
 	void Unreference(int a_LuaRef);
 	
-	/// Calls the plugin-specified "cLuaWindow closing" callback. Returns true only if the callback returned true
+	/** Calls the plugin-specified "cLuaWindow closing" callback. Returns true only if the callback returned true */
 	bool CallbackWindowClosing(int a_FnRef, cWindow & a_Window, cPlayer & a_Player, bool a_CanRefuse);
 	
-	/// Calls the plugin-specified "cLuaWindow slot changed" callback.
+	/** Calls the plugin-specified "cLuaWindow slot changed" callback. */
 	void CallbackWindowSlotChanged(int a_FnRef, cWindow & a_Window, int a_SlotNum);
 	
-	/// Returns the name of Lua function that should handle the specified hook type in the older (#121) API
+	/** Returns the name of Lua function that should handle the specified hook type in the older (#121) API */
 	static const char * GetHookFnName(int a_HookType);
 	
 	/** Adds a Lua function to be called for the specified hook.
@@ -143,37 +173,47 @@ public:
 	*/
 	bool AddHookRef(int a_HookType, int a_FnRefIdx);
 	
+	/** Calls a function in this plugin's LuaState with parameters copied over from a_ForeignState.
+	The values that the function returns are placed onto a_ForeignState.
+	Returns the number of values returned, if successful, or negative number on failure. */
+	int CallFunctionFromForeignState(
+		const AString & a_FunctionName,
+		cLuaState & a_ForeignState,
+		int a_ParamStart,
+		int a_ParamEnd
+	);
+	
 	// The following templates allow calls to arbitrary Lua functions residing in the plugin:
 	
-	/// Call a Lua function with 0 args
+	/** Call a Lua function with 0 args */
 	template <typename FnT> bool Call(FnT a_Fn)
 	{
 		cCSLock Lock(m_CriticalSection);
 		return m_LuaState.Call(a_Fn);
 	}
 
-	/// Call a Lua function with 1 arg
+	/** Call a Lua function with 1 arg */
 	template <typename FnT, typename ArgT0> bool Call(FnT a_Fn, ArgT0 a_Arg0)
 	{
 		cCSLock Lock(m_CriticalSection);
 		return m_LuaState.Call(a_Fn, a_Arg0);
 	}
 
-	/// Call a Lua function with 2 args
+	/** Call a Lua function with 2 args */
 	template <typename FnT, typename ArgT0, typename ArgT1> bool Call(FnT a_Fn, ArgT0 a_Arg0, ArgT1 a_Arg1)
 	{
 		cCSLock Lock(m_CriticalSection);
 		return m_LuaState.Call(a_Fn, a_Arg0, a_Arg1);
 	}
 
-	/// Call a Lua function with 3 args
+	/** Call a Lua function with 3 args */
 	template <typename FnT, typename ArgT0, typename ArgT1, typename ArgT2> bool Call(FnT a_Fn, ArgT0 a_Arg0, ArgT1 a_Arg1, ArgT2 a_Arg2)
 	{
 		cCSLock Lock(m_CriticalSection);
 		return m_LuaState.Call(a_Fn, a_Arg0, a_Arg1, a_Arg2);
 	}
 
-	/// Call a Lua function with 4 args
+	/** Call a Lua function with 4 args */
 	template <typename FnT, typename ArgT0, typename ArgT1, typename ArgT2, typename ArgT3> bool Call(FnT a_Fn, ArgT0 a_Arg0, ArgT1 a_Arg1, ArgT2 a_Arg2, ArgT3 a_Arg3)
 	{
 		cCSLock Lock(m_CriticalSection);
@@ -181,13 +221,13 @@ public:
 	}
 
 protected:
-	/// Maps command name into Lua function reference
+	/** Maps command name into Lua function reference */
 	typedef std::map<AString, int> CommandMap;
 	
-	/// Provides an array of Lua function references
+	/** Provides an array of Lua function references */
 	typedef std::vector<cLuaState::cRef *> cLuaRefs;
 	
-	/// Maps hook types into arrays of Lua function references to call for each hook type
+	/** Maps hook types into arrays of Lua function references to call for each hook type */
 	typedef std::map<int, cLuaRefs> cHookMap;
 	
 	cCriticalSection m_CriticalSection;
@@ -198,7 +238,7 @@ protected:
 	
 	cHookMap m_HookMap;
 	
-	/// Releases all Lua references and closes the LuaState
+	/** Releases all Lua references and closes the LuaState */
 	void Close(void);
 } ;  // tolua_export
 
diff --git a/src/Bindings/PluginManager.cpp b/src/Bindings/PluginManager.cpp
index 24bb914d1..6a5356c0b 100644
--- a/src/Bindings/PluginManager.cpp
+++ b/src/Bindings/PluginManager.cpp
@@ -56,7 +56,7 @@ void cPluginManager::ReloadPlugins(void)
 
 void cPluginManager::FindPlugins(void)
 {
-	AString PluginsPath = FILE_IO_PREFIX + AString( "Plugins/" );
+	AString PluginsPath = GetPluginsPath() + "/";
 
 	// First get a clean list of only the currently running plugins, we don't want to mess those up
 	for (PluginMap::iterator itr = m_Plugins.begin(); itr != m_Plugins.end();)
@@ -205,6 +205,27 @@ void cPluginManager::Tick(float a_Dt)
 
 
 
+bool cPluginManager::CallHookBlockSpread(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, eSpreadSource a_Source)
+{
+	HookMap::iterator Plugins = m_Hooks.find(HOOK_BLOCK_SPREAD);
+	if (Plugins == m_Hooks.end())
+	{
+		return false;
+	}
+	for (PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr)
+	{
+		if ((*itr)->OnBlockSpread(a_World, a_BlockX, a_BlockY, a_BlockZ, a_Source))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
 bool cPluginManager::CallHookBlockToPickups(
 	cWorld * a_World, cEntity * a_Digger,
 	int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta,
@@ -248,7 +269,7 @@ bool cPluginManager::CallHookChat(cPlayer * a_Player, AString & a_Message)
 	{
 		AStringVector Split(StringSplit(a_Message, " "));
 		ASSERT(!Split.empty());  // This should not happen - we know there's at least one char in the message so the split needs to be at least one item long
-		a_Player->SendMessage(Printf("%s[INFO] %sUnknown command: \"%s\"", cChatColor::Yellow.c_str(), cChatColor::White.c_str(), Split[0].c_str()));
+		a_Player->SendMessageInfo(Printf("Unknown command: \"%s\"", a_Message.c_str()));
 		LOGINFO("Player %s issued an unknown command: \"%s\"", a_Player->GetName().c_str(), a_Message.c_str());
 		return true;  // Cancel sending
 	}
@@ -673,6 +694,27 @@ bool cPluginManager::CallHookPlayerBrokenBlock(cPlayer & a_Player, int a_BlockX,
 
 
 
+bool cPluginManager::CallHookPlayerDestroyed(cPlayer & a_Player)
+{
+	HookMap::iterator Plugins = m_Hooks.find(HOOK_PLAYER_DESTROYED);
+	if (Plugins == m_Hooks.end())
+	{
+		return false;
+	}
+	for (PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr)
+	{
+		if ((*itr)->OnPlayerDestroyed(a_Player))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
 bool cPluginManager::CallHookPlayerEating(cPlayer & a_Player)
 {
 	HookMap::iterator Plugins = m_Hooks.find(HOOK_PLAYER_EATING);
@@ -1112,6 +1154,48 @@ bool cPluginManager::CallHookPreCrafting(const cPlayer * a_Player, const cCrafti
 
 
 
+bool cPluginManager::CallHookProjectileHitBlock(cProjectileEntity & a_Projectile)
+{
+	HookMap::iterator Plugins = m_Hooks.find(HOOK_PROJECTILE_HIT_BLOCK);
+	if (Plugins == m_Hooks.end())
+	{
+		return false;
+	}
+	for (PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr)
+	{
+		if ((*itr)->OnProjectileHitBlock(a_Projectile))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
+bool cPluginManager::CallHookProjectileHitEntity(cProjectileEntity & a_Projectile, cEntity & a_HitEntity)
+{
+	HookMap::iterator Plugins = m_Hooks.find(HOOK_PROJECTILE_HIT_ENTITY);
+	if (Plugins == m_Hooks.end())
+	{
+		return false;
+	}
+	for (PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr)
+	{
+		if ((*itr)->OnProjectileHitEntity(a_Projectile, a_HitEntity))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
 bool cPluginManager::CallHookSpawnedEntity(cWorld & a_World, cEntity & a_Entity)
 {
 	HookMap::iterator Plugins = m_Hooks.find(HOOK_SPAWNED_ENTITY);
@@ -1371,7 +1455,7 @@ bool cPluginManager::HandleCommand(cPlayer * a_Player, const AString & a_Command
 		!a_Player->HasPermission(cmd->second.m_Permission)
 	)
 	{
-		a_Player->SendMessage(Printf("%s[INFO] %sForbidden command; insufficient privileges: \"%s\"", cChatColor::Rose.c_str(), cChatColor::White.c_str(), Split[0].c_str()));
+		a_Player->SendMessageFailure(Printf("Forbidden command; insufficient privileges: \"%s\"", Split[0].c_str()));
 		LOGINFO("Player %s tried to execute forbidden command: \"%s\"", a_Player->GetName().c_str(), Split[0].c_str());
 		a_WasCommandForbidden = true;
 		return false;
@@ -1736,6 +1820,21 @@ bool cPluginManager::IsValidHookType(int a_HookType)
 
 
 
+bool cPluginManager::DoWithPlugin(const AString & a_PluginName, cPluginCallback & a_Callback)
+{
+	// TODO: Implement locking for plugins
+	PluginMap::iterator itr = m_Plugins.find(a_PluginName);
+	if ((itr == m_Plugins.end()) || (itr->second == NULL))
+	{
+		return false;
+	}
+	return a_Callback.Item(itr->second);
+}
+
+
+
+
+
 bool cPluginManager::AddPlugin(cPlugin * a_Plugin)
 {
 	m_Plugins[a_Plugin->GetDirectory()] = a_Plugin;
diff --git a/src/Bindings/PluginManager.h b/src/Bindings/PluginManager.h
index 9936f5a35..512bc1351 100644
--- a/src/Bindings/PluginManager.h
+++ b/src/Bindings/PluginManager.h
@@ -18,6 +18,9 @@ class cChunkDesc;
 // fwd: Entities/Entity.h
 class cEntity;
 
+// fwd: Entities/ProjectileEntity.h
+class cProjectileEntity;
+
 // fwd: Mobs/Monster.h
 class cMonster;
 
@@ -58,6 +61,7 @@ public:																	// tolua_export
 	// tolua_begin
 	enum PluginHook
 	{
+		HOOK_BLOCK_SPREAD,
 		HOOK_BLOCK_TO_PICKUPS,
 		HOOK_CHAT,
 		HOOK_CHUNK_AVAILABLE,
@@ -79,6 +83,7 @@ public:																	// tolua_export
 		HOOK_LOGIN,
 		HOOK_PLAYER_BREAKING_BLOCK,
 		HOOK_PLAYER_BROKEN_BLOCK,
+		HOOK_PLAYER_DESTROYED,
 		HOOK_PLAYER_EATING,
 		HOOK_PLAYER_FISHED,
 		HOOK_PLAYER_FISHING,
@@ -100,6 +105,8 @@ public:																	// tolua_export
 		HOOK_PLUGINS_LOADED,
 		HOOK_POST_CRAFTING,
 		HOOK_PRE_CRAFTING,
+		HOOK_PROJECTILE_HIT_BLOCK,
+		HOOK_PROJECTILE_HIT_ENTITY,
 		HOOK_SPAWNED_ENTITY,
 		HOOK_SPAWNED_MONSTER,
 		HOOK_SPAWNING_ENTITY,
@@ -122,17 +129,23 @@ public:																	// tolua_export
 	} ;
 	// tolua_end
 
-	/// Used as a callback for enumerating bound commands
+	/** Used as a callback for enumerating bound commands */
 	class cCommandEnumCallback
 	{
 	public:
+		virtual ~cCommandEnumCallback() {}
+		
 		/** Called for each command; return true to abort enumeration
 		For console commands, a_Permission is not used (set to empty string)
 		*/
 		virtual bool Command(const AString & a_Command, const cPlugin * a_Plugin, const AString & a_Permission, const AString & a_HelpString) = 0;
 	} ;
 	
-	/// Returns the instance of the Plugin Manager (there is only ever one)
+	/** The interface used for enumerating and extern-calling plugins */
+	typedef cItemCallback<cPlugin> cPluginCallback;
+	
+	
+	/** Returns the instance of the Plugin Manager (there is only ever one) */
 	static cPluginManager * Get(void);							// tolua_export
 
 	typedef std::map< AString, cPlugin * > PluginMap;
@@ -143,12 +156,13 @@ public:																	// tolua_export
 	void FindPlugins();													// tolua_export
 	void ReloadPlugins();												// tolua_export
 	
-	/// Adds the plugin to the list of plugins called for the specified hook type. Handles multiple adds as a single add
+	/** Adds the plugin to the list of plugins called for the specified hook type. Handles multiple adds as a single add */
 	void AddHook(cPlugin * a_Plugin, int a_HookType);
 
 	unsigned int GetNumPlugins() const;  // tolua_export
 	
 	// Calls for individual hooks. Each returns false if the action is to continue or true if the plugin wants to abort
+	bool CallHookBlockSpread              (cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, eSpreadSource a_Source);
 	bool CallHookBlockToPickups           (cWorld * a_World, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, cItems & a_Pickups);
 	bool CallHookChat                     (cPlayer * a_Player, AString & a_Message);
 	bool CallHookChunkAvailable           (cWorld * a_World, int a_ChunkX, int a_ChunkZ);
@@ -170,6 +184,7 @@ public:																	// tolua_export
 	bool CallHookPlayerAnimation          (cPlayer & a_Player, int a_Animation);
 	bool CallHookPlayerBreakingBlock      (cPlayer & a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 	bool CallHookPlayerBrokenBlock        (cPlayer & a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
+	bool CallHookPlayerDestroyed          (cPlayer & a_Player);
 	bool CallHookPlayerEating             (cPlayer & a_Player);
 	bool CallHookPlayerFished             (cPlayer & a_Player, const cItems a_Reward);
 	bool CallHookPlayerFishing            (cPlayer & a_Player, cItems a_Reward);
@@ -191,6 +206,8 @@ public:																	// tolua_export
 	bool CallHookPluginsLoaded            (void);
 	bool CallHookPostCrafting             (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe);
 	bool CallHookPreCrafting              (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe);
+	bool CallHookProjectileHitBlock       (cProjectileEntity & a_Projectile);
+	bool CallHookProjectileHitEntity      (cProjectileEntity & a_Projectile, cEntity & a_HitEntity);
 	bool CallHookSpawnedEntity            (cWorld & a_World, cEntity & a_Entity);
 	bool CallHookSpawnedMonster           (cWorld & a_World, cMonster & a_Monster);
 	bool CallHookSpawningEntity           (cWorld & a_World, cEntity & a_Entity);
@@ -206,46 +223,46 @@ public:																	// tolua_export
 	bool DisablePlugin(const AString & a_PluginName);  // tolua_export
 	bool LoadPlugin   (const AString & a_PluginName);  // tolua_export
 
-	/// Removes all hooks the specified plugin has registered
+	/** Removes all hooks the specified plugin has registered */
 	void RemoveHooks(cPlugin * a_Plugin);
 	
-	/// Removes the plugin from the internal structures and deletes its object.
+	/** Removes the plugin from the internal structures and deletes its object. */
 	void RemovePlugin(cPlugin * a_Plugin);
 	
-	/// Removes all command bindings that the specified plugin has made
+	/** Removes all command bindings that the specified plugin has made */
 	void RemovePluginCommands(cPlugin * a_Plugin);
 	
-	/// Binds a command to the specified plugin. Returns true if successful, false if command already bound.
+	/** Binds a command to the specified plugin. Returns true if successful, false if command already bound. */
 	bool BindCommand(const AString & a_Command, cPlugin * a_Plugin, const AString & a_Permission, const AString & a_HelpString);  // Exported in ManualBindings.cpp, without the a_Plugin param
 	
-	/// Calls a_Callback for each bound command, returns true if all commands were enumerated
+	/** Calls a_Callback for each bound command, returns true if all commands were enumerated */
 	bool ForEachCommand(cCommandEnumCallback & a_Callback);  // Exported in ManualBindings.cpp
 	
-	/// Returns true if the command is in the command map
+	/** Returns true if the command is in the command map */
 	bool IsCommandBound(const AString & a_Command);  // tolua_export
 	
-	/// Returns the permission needed for the specified command; empty string if command not found
+	/** Returns the permission needed for the specified command; empty string if command not found */
 	AString GetCommandPermission(const AString & a_Command);  // tolua_export
 	
-	/// Executes the command, as if it was requested by a_Player. Checks permissions first. Returns true if executed.
+	/** Executes the command, as if it was requested by a_Player. Checks permissions first. Returns true if executed. */
 	bool ExecuteCommand(cPlayer * a_Player, const AString & a_Command);  // tolua_export
 	
-	/// Executes the command, as if it was requested by a_Player. Permisssions are not checked. Returns true if executed (false if not found)
+	/** Executes the command, as if it was requested by a_Player. Permisssions are not checked. Returns true if executed (false if not found) */
 	bool ForceExecuteCommand(cPlayer * a_Player, const AString & a_Command);  // tolua_export
 	
-	/// Removes all console command bindings that the specified plugin has made
+	/** Removes all console command bindings that the specified plugin has made */
 	void RemovePluginConsoleCommands(cPlugin * a_Plugin);
 	
-	/// Binds a console command to the specified plugin. Returns true if successful, false if command already bound.
+	/** Binds a console command to the specified plugin. Returns true if successful, false if command already bound. */
 	bool BindConsoleCommand(const AString & a_Command, cPlugin * a_Plugin, const AString & a_HelpString);  // Exported in ManualBindings.cpp, without the a_Plugin param
 	
-	/// Calls a_Callback for each bound console command, returns true if all commands were enumerated
+	/** Calls a_Callback for each bound console command, returns true if all commands were enumerated */
 	bool ForEachConsoleCommand(cCommandEnumCallback & a_Callback);  // Exported in ManualBindings.cpp
 	
-	/// Returns true if the console command is in the command map
+	/** Returns true if the console command is in the command map */
 	bool IsConsoleCommandBound(const AString & a_Command);  // tolua_export
 	
-	/// Executes the command split into a_Split, as if it was given on the console. Returns true if executed. Output is sent to the a_Output callback
+	/** Executes the command split into a_Split, as if it was given on the console. Returns true if executed. Output is sent to the a_Output callback */
 	bool ExecuteConsoleCommand(const AStringVector & a_Split, cCommandOutputCallback & a_Output);
 	
 	/** Appends all commands beginning with a_Text (case-insensitive) into a_Results.
@@ -253,9 +270,17 @@ public:																	// tolua_export
 	*/
 	void TabCompleteCommand(const AString & a_Text, AStringVector & a_Results, cPlayer * a_Player);
 	
-	/// Returns true if the specified hook type is within the allowed range
+	/** Returns true if the specified hook type is within the allowed range */
 	static bool IsValidHookType(int a_HookType);
 	
+	/** Calls the specified callback with the plugin object of the specified plugin.
+	Returns false if plugin not found, and the value that the callback has returned otherwise. */
+	bool DoWithPlugin(const AString & a_PluginName, cPluginCallback & a_Callback);
+	
+	/** Returns the path where individual plugins' folders are expected.
+	The path doesn't end in a slash. */
+	static AString GetPluginsPath(void) { return FILE_IO_PREFIX + AString("Plugins"); }  // tolua_export
+	
 private:
 	friend class cRoot;
 	
@@ -281,22 +306,22 @@ private:
 	cPluginManager();
 	virtual ~cPluginManager();
 
-	/// Reloads all plugins, defaulting to settings.ini for settings location
+	/** Reloads all plugins, defaulting to settings.ini for settings location */
 	void ReloadPluginsNow(void);
 
-	/// Reloads all plugins with a cIniFile object expected to be initialised to settings.ini
+	/** Reloads all plugins with a cIniFile object expected to be initialised to settings.ini */
 	void ReloadPluginsNow(cIniFile & a_SettingsIni);
 
-	/// Unloads all plugins
+	/** Unloads all plugins */
 	void UnloadPluginsNow(void);
 
-	/// Handles writing default plugins if 'Plugins' key not found using a cIniFile object expected to be intialised to settings.ini
+	/** Handles writing default plugins if 'Plugins' key not found using a cIniFile object expected to be intialised to settings.ini */
 	void InsertDefaultPlugins(cIniFile & a_SettingsIni);
 
-	/// Adds the plugin into the internal list of plugins and initializes it. If initialization fails, the plugin is removed again.
+	/** Adds the plugin into the internal list of plugins and initializes it. If initialization fails, the plugin is removed again. */
 	bool AddPlugin(cPlugin * a_Plugin);
 
-	/// Tries to match a_Command to the internal table of commands, if a match is found, the corresponding plugin is called. Returns true if the command is handled.
+	/** Tries to match a_Command to the internal table of commands, if a match is found, the corresponding plugin is called. Returns true if the command is handled. */
 	bool HandleCommand(cPlayer * a_Player, const AString & a_Command, bool a_ShouldCheckPermissions, bool & a_WasCommandForbidden);	
 	bool HandleCommand(cPlayer * a_Player, const AString & a_Command, bool a_ShouldCheckPermissions)
 	{
diff --git a/src/Bindings/WebPlugin.cpp b/src/Bindings/WebPlugin.cpp
index 3b71d553c..bf45405ba 100644
--- a/src/Bindings/WebPlugin.cpp
+++ b/src/Bindings/WebPlugin.cpp
@@ -110,4 +110,4 @@ AString cWebPlugin::SafeString( const AString & a_String )
 		RetVal.push_back( c );
 	}
 	return RetVal;
-}
\ No newline at end of file
+}
diff --git a/src/Bindings/lua5.1.dll b/src/Bindings/lua51.dll
index 515cf8b30..515cf8b30 100644
--- a/src/Bindings/lua5.1.dll
+++ b/src/Bindings/lua51.dll
diff --git a/src/Bindings/tolua++.exe b/src/Bindings/tolua++.exe
index e5cec6d78..ba3a6b0c7 100644
--- a/src/Bindings/tolua++.exe
+++ b/src/Bindings/tolua++.exe