Moved cWorld manual bindings out into a separate file.

src/Bindings/CMakeLists.txt

@@ -18,6 +18,7 @@ SET (SRCS
 	ManualBindings.cpp
 	ManualBindings_Network.cpp
 	ManualBindings_RankManager.cpp
+	ManualBindings_World.cpp
 	Plugin.cpp
 	PluginLua.cpp
 	PluginManager.cpp

src/Bindings/LuaState.cpp

@@ -107,7 +107,7 @@ void cLuaState::Create(void)
 void cLuaState::RegisterAPILibs(void)
 {
 	tolua_AllToLua_open(m_LuaState);
-	ManualBindings::Bind(m_LuaState);
+	cManualBindings::Bind(m_LuaState);
 	DeprecatedBindings::Bind(m_LuaState);
 	luaopen_lsqlite3(m_LuaState);
 	luaopen_lxp(m_LuaState);

src/Bindings/ManualBindings.h

@@ -1,34 +1,567 @@
+
+// ManualBindings.h
+
+// Declares the cManualBindings class used as a namespace for functions exported to the Lua API manually
+
+
+
+
+
 #pragma once
 
-struct lua_State;
-class cPluginLua;
+#include "LuaState.h"
+
+
+
+
+// fwd:
+struct tolua_Error;
 
 
 
 
 
 /** Provides namespace for the bindings. */
-class ManualBindings
+class cManualBindings
 {
 public:
 	/** Binds all the manually implemented functions to tolua_S. */
 	static void Bind(lua_State * tolua_S);
 	
 protected:
+	/** Binds the manually implemented cNetwork-related API to tolua_S.
+	Implemented in ManualBindings_Network.cpp. */
+	static void BindNetwork(lua_State * tolua_S);
+
 	/** Binds the manually implemented cRankManager glue code to tolua_S.
 	Implemented in ManualBindings_RankManager.cpp. */
 	static void BindRankManager(lua_State * tolua_S);
 
-	/** Binds the manually implemented cNetwork-related API to tolua_S.
-	Implemented in ManualBindings_Network.cpp. */
-	static void BindNetwork(lua_State * tolua_S);
+	/** Binds the manually implemented cWorld API functions to tolua_S.
+	Implemented in ManualBindings_World.cpp. */
+	static void BindWorld(lua_State * tolua_S);
+
+
+public:
+	// Helper functions:
+	static cPluginLua * GetLuaPlugin(lua_State * L);
+	static int tolua_do_error(lua_State * L, const char * a_pMsg, tolua_Error * a_pToLuaError);
+	static int lua_do_error(lua_State * L, const char * a_pFormat, ...);
+
+
+	/** Binds the DoWith(ItemName) functions of regular classes. */
+	template <
+		class Ty1,
+		class Ty2,
+		bool (Ty1::*DoWithFn)(const AString &, cItemCallback<Ty2> &)
+	>
+	static int DoWith(lua_State * tolua_S)
+	{
+		// Check params:
+		cLuaState L(tolua_S);
+		if (
+			!L.CheckParamString(2) ||
+			!L.CheckParamFunction(3)
+		)
+		{
+			return 0;
+		}
+
+		// Get parameters:
+		Ty1 * Self;
+		AString ItemName;
+		cLuaState::cRef FnRef;
+		L.GetStackValues(1, Self, ItemName, FnRef);
+		if (Self == nullptr)
+		{
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'");
+		}
+		if (ItemName.empty() || (ItemName[0] == 0))
+		{
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a non-empty string for parameter #1");
+		}
+		if (!FnRef.IsValid())
+		{
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #2");
+		}
+
+		class cLuaCallback : public cItemCallback<Ty2>
+		{
+		public:
+			cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FnRef):
+				m_LuaState(a_LuaState),
+				m_FnRef(a_FnRef)
+			{
+			}
+
+		private:
+			virtual bool Item(Ty2 * a_Item) override
+			{
+				bool ret = false;
+				m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, ret);
+				return ret;
+			}
+			cLuaState & m_LuaState;
+			cLuaState::cRef & m_FnRef;
+		} Callback(L, FnRef);
+
+		// Call the DoWith function:
+		bool res = (Self->*DoWithFn)(ItemName, Callback);
+
+		// Push the result as the return value:
+		L.Push(res);
+		return 1;
+	}
+
+
+
+
+
+	/** Template for static functions DoWith(ItemName), on a type that has a static ::Get() function. */
+	template <
+		class Ty1,
+		class Ty2,
+		bool (Ty1::*DoWithFn)(const AString &, cItemCallback<Ty2> &)
+	>
+	static int StaticDoWith(lua_State * tolua_S)
+	{
+		// Check params:
+		cLuaState L(tolua_S);
+		if (
+			!L.CheckParamString(2) ||
+			!L.CheckParamFunction(3)
+		)
+		{
+			return 0;
+		}
+
+		// Get parameters:
+		AString ItemName;
+		cLuaState::cRef FnRef;
+		L.GetStackValues(2, ItemName, FnRef);
+		if (ItemName.empty() || (ItemName[0] == 0))
+		{
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a non-empty string for parameter #1");
+		}
+		if (!FnRef.IsValid())
+		{
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #2");
+		}
+
+		class cLuaCallback : public cItemCallback<Ty2>
+		{
+		public:
+			cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FnRef):
+				m_LuaState(a_LuaState),
+				m_FnRef(a_FnRef)
+			{
+			}
+
+		private:
+			virtual bool Item(Ty2 * a_Item) override
+			{
+				bool ret = false;
+				m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, ret);
+				return ret;
+			}
+			cLuaState & m_LuaState;
+			cLuaState::cRef & m_FnRef;
+		} Callback(L, FnRef);
+
+		// Call the DoWith function:
+		bool res = (Ty1::Get()->*DoWithFn)(ItemName, Callback);
+
+		// Push the result as the return value:
+		L.Push(res);
+		return 1;
+	}
+
+
+
+
+
+	template <
+		class Ty1,
+		class Ty2,
+		bool (Ty1::*DoWithFn)(UInt32, cItemCallback<Ty2> &)
+	>
+	static int DoWithID(lua_State * tolua_S)
+	{
+		// Check params:
+		cLuaState L(tolua_S);
+		if (
+			!L.CheckParamNumber(2) ||
+			!L.CheckParamFunction(3)
+		)
+		{
+			return 0;
+		}
+
+		// Get parameters:
+		Ty1 * Self = nullptr;
+		int ItemID;
+		cLuaState::cRef FnRef;
+		L.GetStackValues(1, Self, ItemID, FnRef);
+		if (Self == nullptr)
+		{
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'");
+		}
+		if (!FnRef.IsValid())
+		{
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #2");
+		}
+
+		class cLuaCallback : public cItemCallback<Ty2>
+		{
+		public:
+			cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FnRef):
+				m_LuaState(a_LuaState),
+				m_FnRef(a_FnRef)
+			{
+			}
+
+		private:
+			virtual bool Item(Ty2 * a_Item) override
+			{
+				bool ret = false;
+				m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, ret);
+				return ret;
+			}
+			cLuaState & m_LuaState;
+			cLuaState::cRef & m_FnRef;
+		} Callback(L, FnRef);
+
+		// Call the DoWith function:
+		bool res = (Self->*DoWithFn)(ItemID, Callback);
+
+		// Push the result as the return value:
+		L.Push(res);
+		return 1;
+	}
+
+
+
+
+
+	template <
+		class Ty1,
+		class Ty2,
+		bool (Ty1::*DoWithFn)(int, int, int, cItemCallback<Ty2> &)
+	>
+	static int DoWithXYZ(lua_State * tolua_S)
+	{
+		// Check params:
+		cLuaState L(tolua_S);
+		if (
+			!L.CheckParamNumber(2, 5) ||
+			!L.CheckParamFunction(6)
+		)
+		{
+			return 0;
+		}
+
+		// Get parameters:
+		Ty1 * Self = nullptr;
+		int BlockX, BlockY, BlockZ;
+		cLuaState::cRef FnRef;
+		L.GetStackValues(1, Self, BlockX, BlockY, BlockZ, FnRef);
+		if (Self == nullptr)
+		{
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'");
+		}
+		if (!FnRef.IsValid())
+		{
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #5");
+		}
+
+		class cLuaCallback : public cItemCallback<Ty2>
+		{
+		public:
+			cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FnRef):
+				m_LuaState(a_LuaState),
+				m_FnRef(a_FnRef)
+			{
+			}
+
+		private:
+			virtual bool Item(Ty2 * a_Item) override
+			{
+				bool ret = false;
+				m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, ret);
+				return ret;
+			}
+			cLuaState & m_LuaState;
+			cLuaState::cRef & m_FnRef;
+		} Callback(L, FnRef);
+
+		// Call the DoWith function:
+		bool res = (Self->*DoWithFn)(BlockX, BlockY, BlockZ, Callback);
+
+		// Push the result as the return value:
+		L.Push(res);
+		return 1;
+	}
+
+
+
+
+
+	template <
+		class Ty1,
+		class Ty2,
+		bool (Ty1::*ForEachFn)(int, int, cItemCallback<Ty2> &)
+	>
+	static int ForEachInChunk(lua_State * tolua_S)
+	{
+		// Check params:
+		cLuaState L(tolua_S);
+		if (
+			!L.CheckParamNumber(2, 4) ||
+			!L.CheckParamFunction(5)
+		)
+		{
+			return 0;
+		}
+
+		// Get parameters:
+		Ty1 * Self = nullptr;
+		int ChunkX, ChunkZ;
+		cLuaState::cRef FnRef;
+		L.GetStackValues(1, Self, ChunkX, ChunkZ, FnRef);
+		if (Self == nullptr)
+		{
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'");
+		}
+		if (!FnRef.IsValid())
+		{
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #4");
+		}
+
+		class cLuaCallback : public cItemCallback<Ty2>
+		{
+		public:
+			cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FnRef):
+				m_LuaState(a_LuaState),
+				m_FnRef(a_FnRef)
+			{
+			}
+
+		private:
+			virtual bool Item(Ty2 * a_Item) override
+			{
+				bool ret = false;
+				m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, ret);
+				return ret;
+			}
+			cLuaState & m_LuaState;
+			cLuaState::cRef & m_FnRef;
+		} Callback(L, FnRef);
+
+		// Call the DoWith function:
+		bool res = (Self->*ForEachFn)(ChunkX, ChunkZ, Callback);
+
+		// Push the result as the return value:
+		L.Push(res);
+		return 1;
+	}
+
+
+
+
+
+	template <
+		class Ty1,
+		class Ty2,
+		bool (Ty1::*ForEachFn)(const cBoundingBox &, cItemCallback<Ty2> &)
+	>
+	static int ForEachInBox(lua_State * tolua_S)
+	{
+		// Check params:
+		cLuaState L(tolua_S);
+		if (
+			!L.CheckParamUserType(1, "cWorld") ||
+			!L.CheckParamUserType(2, "cBoundingBox") ||
+			!L.CheckParamFunction(3) ||
+			!L.CheckParamEnd(4)
+		)
+		{
+			return 0;
+		}
+
+		// Get the params:
+		Ty1 * Self = nullptr;
+		cBoundingBox * Box = nullptr;
+		cLuaState::cRef FnRef;
+		L.GetStackValues(1, Self, Box, FnRef);
+		if ((Self == nullptr) || (Box == nullptr))
+		{
+			LOGWARNING("Invalid world (%p) or boundingbox (%p)", Self, Box);
+			L.LogStackTrace();
+			return 0;
+		}
+		if (!FnRef.IsValid())
+		{
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #2");
+		}
+
+		// Callback wrapper for the Lua function:
+		class cLuaCallback : public cItemCallback<Ty2>
+		{
+		public:
+			cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FuncRef) :
+				m_LuaState(a_LuaState),
+				m_FnRef(a_FuncRef)
+			{
+			}
+
+		private:
+			cLuaState & m_LuaState;
+			cLuaState::cRef & m_FnRef;
+
+			// cItemCallback<Ty2> overrides:
+			virtual bool Item(Ty2 * a_Item) override
+			{
+				bool res = false;
+				if (!m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, res))
+				{
+					LOGWARNING("Failed to call Lua callback");
+					m_LuaState.LogStackTrace();
+					return true;  // Abort enumeration
+				}
+
+				return res;
+			}
+		} Callback(L, FnRef);
+
+		bool res = (Self->*ForEachFn)(*Box, Callback);
+
+		// Push the result as the return value:
+		L.Push(res);
+		return 1;
+	}
+
+
+
+
+
+	template <
+		class Ty1,
+		class Ty2,
+		bool (Ty1::*ForEachFn)(cItemCallback<Ty2> &)
+	>
+	static int ForEach(lua_State * tolua_S)
+	{
+		// Check params:
+		cLuaState L(tolua_S);
+		if (
+			!L.CheckParamFunction(2) ||
+			!L.CheckParamEnd(3)
+		)
+		{
+			return 0;
+		}
+
+		// Get the params:
+		Ty1 * Self = nullptr;
+		cLuaState::cRef FnRef;
+		L.GetStackValues(1, Self, FnRef);
+		if (Self == nullptr)
+		{
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'.");
+		}
+		if (!FnRef.IsValid())
+		{
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #1");
+		}
+
+		class cLuaCallback : public cItemCallback<Ty2>
+		{
+		public:
+			cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FnRef):
+				m_LuaState(a_LuaState),
+				m_FnRef(a_FnRef)
+			{
+			}
+
+		private:
+			cLuaState & m_LuaState;
+			cLuaState::cRef & m_FnRef;
+
+			virtual bool Item(Ty2 * a_Item) override
+			{
+				bool res = false;  // By default continue the enumeration
+				m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, res);
+				return res;
+			}
+		} Callback(L, FnRef);
+
+		// Call the enumeration:
+		bool res = (Self->*ForEachFn)(Callback);
+
+		// Push the return value:
+		L.Push(res);
+		return 1;
+	}
+
+
+
+
+
+	/** Implements bindings for ForEach() functions in a class that is static (has a ::Get() static function). */
+	template <
+		class Ty1,
+		class Ty2,
+		bool (Ty1::*ForEachFn)(cItemCallback<Ty2> &)
+	>
+	static int StaticForEach(lua_State * tolua_S)
+	{
+		// Check params:
+		cLuaState L(tolua_S);
+		if (
+			!L.CheckParamFunction(2) ||
+			!L.CheckParamEnd(3)
+		)
+		{
+			return 0;
+		}
+
+		// Get the params:
+		cLuaState::cRef FnRef(L, 2);
+		if (!FnRef.IsValid())
+		{
+			return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #1");
+		}
+
+		class cLuaCallback : public cItemCallback<Ty2>
+		{
+		public:
+			cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FnRef):
+				m_LuaState(a_LuaState),
+				m_FnRef(a_FnRef)
+			{
+			}
+
+		private:
+			cLuaState & m_LuaState;
+			cLuaState::cRef & m_FnRef;
+
+			virtual bool Item(Ty2 * a_Item) override
+			{
+				bool res = false;  // By default continue the enumeration
+				m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, res);
+				return res;
+			}
+		} Callback(L, FnRef);
+
+		// Call the enumeration:
+		bool res = (Ty1::Get()->*ForEachFn)(Callback);
+
+		// Push the return value:
+		L.Push(res);
+		return 1;
+	}
 };
 
 
 
 
-extern cPluginLua * GetLuaPlugin(lua_State * L);
-
-
-
-

src/Bindings/ManualBindings_Network.cpp

@@ -39,7 +39,7 @@ static int tolua_cNetwork_Connect(lua_State * L)
 	}
 	
 	// Get the plugin instance:
-	cPluginLua * Plugin = GetLuaPlugin(L);
+	cPluginLua * Plugin = cManualBindings::GetLuaPlugin(L);
 	if (Plugin == nullptr)
 	{
 		// An error message has been already printed in GetLuaPlugin()
@@ -92,7 +92,7 @@ static int tolua_cNetwork_CreateUDPEndpoint(lua_State * L)
 	}
 	
 	// Get the plugin instance:
-	cPluginLua * Plugin = GetLuaPlugin(L);
+	cPluginLua * Plugin = cManualBindings::GetLuaPlugin(L);
 	if (Plugin == nullptr)
 	{
 		// An error message has been already printed in GetLuaPlugin()
@@ -171,7 +171,7 @@ static int tolua_cNetwork_HostnameToIP(lua_State * L)
 	}
 	
 	// Get the plugin instance:
-	cPluginLua * Plugin = GetLuaPlugin(L);
+	cPluginLua * Plugin = cManualBindings::GetLuaPlugin(L);
 	if (Plugin == nullptr)
 	{
 		// An error message has been already printed in GetLuaPlugin()
@@ -212,7 +212,7 @@ static int tolua_cNetwork_IPToHostname(lua_State * L)
 	}
 	
 	// Get the plugin instance:
-	cPluginLua * Plugin = GetLuaPlugin(L);
+	cPluginLua * Plugin = cManualBindings::GetLuaPlugin(L);
 	if (Plugin == nullptr)
 	{
 		// An error message has been already printed in GetLuaPlugin()
@@ -253,7 +253,7 @@ static int tolua_cNetwork_Listen(lua_State * L)
 	}
 	
 	// Get the plugin instance:
-	cPluginLua * Plugin = GetLuaPlugin(L);
+	cPluginLua * Plugin = cManualBindings::GetLuaPlugin(L);
 	if (Plugin == nullptr)
 	{
 		// An error message has been already printed in GetLuaPlugin()
@@ -913,17 +913,17 @@ static int tolua_cUDPEndpoint_Send(lua_State * L)
 ////////////////////////////////////////////////////////////////////////////////
 // Register the bindings:
 
-void ManualBindings::BindNetwork(lua_State * tolua_S)
+void cManualBindings::BindNetwork(lua_State * tolua_S)
 {
 	// Create the cNetwork API classes:
 	tolua_usertype(tolua_S, "cNetwork");
-	tolua_cclass(tolua_S, "cNetwork", "cNetwork", "", nullptr);
-	tolua_usertype(tolua_S, "cTCPLink");
-	tolua_cclass(tolua_S, "cTCPLink", "cTCPLink", "", nullptr);
 	tolua_usertype(tolua_S, "cServerHandle");
-	tolua_cclass(tolua_S, "cServerHandle", "cServerHandle", "", tolua_collect_cServerHandle);
+	tolua_usertype(tolua_S, "cTCPLink");
 	tolua_usertype(tolua_S, "cUDPEndpoint");
-	tolua_cclass(tolua_S, "cUDPEndpoint", "cUDPEndpoint", "", tolua_collect_cUDPEndpoint);
+	tolua_cclass(tolua_S, "cNetwork",      "cNetwork",      "", nullptr);
+	tolua_cclass(tolua_S, "cServerHandle", "cServerHandle", "", tolua_collect_cServerHandle);
+	tolua_cclass(tolua_S, "cTCPLink",      "cTCPLink",      "", nullptr);
+	tolua_cclass(tolua_S, "cUDPEndpoint",  "cUDPEndpoint",  "", tolua_collect_cUDPEndpoint);
 	
 	// Fill in the functions (alpha-sorted):
 	tolua_beginmodule(tolua_S, "cNetwork");

src/Bindings/ManualBindings_RankManager.cpp

@@ -1280,7 +1280,7 @@ static int tolua_cRankManager_SetRankVisuals(lua_State * L)
 
 
 
-void ManualBindings::BindRankManager(lua_State * tolua_S)
+void cManualBindings::BindRankManager(lua_State * tolua_S)
 {
 	// Create the cRankManager class in the API:
 	tolua_usertype(tolua_S, "cRankManager");

src/Bindings/ManualBindings_World.cpp

@@ -0,0 +1,588 @@
+
+// ManualBindings_World.cpp
+
+// Implements the manual Lua API bindings for the cWorld class
+
+#include "Globals.h"
+#include "tolua++/include/tolua++.h"
+#include "../World.h"
+#include "../Broadcaster.h"
+#include "ManualBindings.h"
+#include "LuaState.h"
+#include "PluginLua.h"
+#include "LuaChunkStay.h"
+
+
+
+
+
+static int tolua_cWorld_BroadcastParticleEffect(lua_State * tolua_S)
+{
+	/* Function signature:
+	World:BroadcastParticleEffect("Name", PosX, PosY, PosZ, OffX, OffY, OffZ, ParticleData, ParticleAmount, [ExcludeClient], [OptionalParam1], [OptionalParam2]
+	*/
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cWorld") ||
+		!L.CheckParamString  (2) ||
+		!L.CheckParamNumber  (3, 10)
+	)
+	{
+		return 0;
+	}
+	
+	// Read the params:
+	cWorld * World = nullptr;
+	AString Name;
+	float PosX, PosY, PosZ, OffX, OffY, OffZ;
+	float ParticleData;
+	int ParticleAmmount;
+	cClientHandle * ExcludeClient = nullptr;
+	L.GetStackValues(1, World, Name, PosX, PosY, PosZ, OffX, OffY, OffZ, ParticleData, ParticleAmmount, ExcludeClient);
+	if (World == nullptr)
+	{
+		LOGWARNING("World:BroadcastParticleEffect(): invalid world parameter");
+		L.LogStackTrace();
+		return 0;
+	}
+
+	// Read up to 2 more optional data params:
+	std::array<int, 2> data;
+	for (int i = 0; (i < 2) && L.IsParamNumber(11 + i); i++)
+	{
+		L.GetStackValue(11 + i, data[i]);
+	}
+
+	World->GetBroadcaster().BroadcastParticleEffect(Name, Vector3f(PosX, PosY, PosZ), Vector3f(OffX, OffY, OffZ), ParticleData, ParticleAmmount, ExcludeClient);
+
+	return 0;
+}
+
+
+
+
+
+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 = cManualBindings::GetLuaPlugin(tolua_S);
+	if (Plugin == nullptr)
+	{
+		return 0;
+	}
+	
+	// Read the params:
+	cWorld * World = (cWorld *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (World == nullptr)
+	{
+		LOGWARNING("World:ChunkStay(): invalid world parameter");
+		L.LogStackTrace();
+		return 0;
+	}
+
+	cLuaChunkStay * ChunkStay = new cLuaChunkStay(*Plugin);
+
+	if (!ChunkStay->AddChunks(2))
+	{
+		delete ChunkStay;
+		ChunkStay = nullptr;
+		return 0;
+	}
+
+	ChunkStay->Enable(*World->GetChunkMap(), 3, 4);
+	return 0;
+}
+
+
+
+
+
+static int tolua_cWorld_GetBlockInfo(lua_State * tolua_S)
+{
+	// Exported manually, because tolua would generate useless additional parameters (a_BlockType .. a_BlockSkyLight)
+	// Function signature: GetBlockInfo(BlockX, BlockY, BlockZ) -> BlockValid, [BlockType, BlockMeta, BlockSkyLight, BlockBlockLight]
+
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cWorld") ||
+		!L.CheckParamNumber(2, 4) ||
+		!L.CheckParamEnd(5)
+	)
+	{
+		return 0;
+	}
+
+	// Get params:
+	cWorld * Self = nullptr;
+	int BlockX, BlockY, BlockZ;
+	L.GetStackValues(1, Self, BlockX, BlockY, BlockZ);
+	if (Self == nullptr)
+	{
+		return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'");
+	}
+
+	// Call the function:
+	BLOCKTYPE BlockType;
+	NIBBLETYPE BlockMeta, BlockSkyLight, BlockBlockLight;
+	bool res = Self->GetBlockInfo(BlockX, BlockY, BlockZ, BlockType, BlockMeta, BlockSkyLight, BlockBlockLight);
+
+	// Push the returned values:
+	L.Push(res);
+	if (res)
+	{
+		L.Push(BlockType);
+		L.Push(BlockMeta);
+		L.Push(BlockSkyLight);
+		L.Push(BlockBlockLight);
+		return 5;
+	}
+	return 1;
+}
+
+
+
+
+
+static int tolua_cWorld_GetBlockTypeMeta(lua_State * tolua_S)
+{
+	// Exported manually, because tolua would generate useless additional parameters (a_BlockType, a_BlockMeta)
+	// Function signature: GetBlockTypeMeta(BlockX, BlockY, BlockZ) -> BlockValid, [BlockType, BlockMeta]
+
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cWorld") ||
+		!L.CheckParamNumber(2, 4) ||
+		!L.CheckParamEnd(5)
+	)
+	{
+		return 0;
+	}
+
+	// Get params:
+	cWorld * Self = nullptr;
+	int BlockX, BlockY, BlockZ;
+	L.GetStackValues(1, Self, BlockX, BlockY, BlockZ);
+	if (Self == nullptr)
+	{
+		return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'");
+	}
+
+	// Call the function:
+	BLOCKTYPE BlockType;
+	NIBBLETYPE BlockMeta;
+	bool res = Self->GetBlockTypeMeta(BlockX, BlockY, BlockZ, BlockType, BlockMeta);
+
+	// Push the returned values:
+	L.Push(res);
+	if (res)
+	{
+		L.Push(BlockType);
+		L.Push(BlockMeta);
+		return 3;
+	}
+	return 1;
+}
+
+
+
+
+
+static int tolua_cWorld_GetSignLines(lua_State * tolua_S)
+{
+	// Exported manually, because tolua would generate useless additional parameters (a_Line1 .. a_Line4)
+
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cWorld") ||
+		!L.CheckParamNumber(2, 4) ||
+		!L.CheckParamEnd(5)
+	)
+	{
+		return 0;
+	}
+
+	// Get params:
+	cWorld * Self = nullptr;
+	int BlockX, BlockY, BlockZ;
+	L.GetStackValues(1, Self, BlockX, BlockY, BlockZ);
+	if (Self == nullptr)
+	{
+		return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'");
+	}
+
+	// Call the function:
+	AString Line1, Line2, Line3, Line4;
+	bool res = Self->GetSignLines(BlockX, BlockY, BlockZ, Line1, Line2, Line3, Line4);
+
+	// Push the returned values:
+	L.Push(res);
+	if (res)
+	{
+		L.Push(Line1);
+		L.Push(Line2);
+		L.Push(Line3);
+		L.Push(Line4);
+		return 5;
+	}
+	return 1;
+}
+
+
+
+
+
+static int tolua_cWorld_PrepareChunk(lua_State * tolua_S)
+{
+	/* Function signature:
+	World:PrepareChunk(ChunkX, ChunkZ, Callback)
+	*/
+	
+	// Check the param types:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType     (1, "cWorld") ||
+		!L.CheckParamNumber       (2, 3) ||
+		!L.CheckParamFunctionOrNil(4)
+	)
+	{
+		return 0;
+	}
+	
+	// Read the params:
+	cWorld * world = nullptr;
+	int chunkX = 0, chunkZ = 0;
+	L.GetStackValues(1, world, chunkX, chunkZ);
+	if (world == nullptr)
+	{
+		LOGWARNING("World:PrepareChunk(): invalid world parameter");
+		L.LogStackTrace();
+		return 0;
+	}
+
+	// Wrap the Lua callback inside a C++ callback class:
+	class cCallback:
+		public cChunkCoordCallback
+	{
+	public:
+		cCallback(lua_State * a_LuaState):
+			m_LuaState(a_LuaState),
+			m_Callback(m_LuaState, 4)
+		{
+		}
+
+		// cChunkCoordCallback override:
+		virtual void Call(int a_CBChunkX, int a_CBChunkZ) override
+		{
+			if (m_Callback.IsValid())
+			{
+				m_LuaState.Call(m_Callback, a_CBChunkX, a_CBChunkZ);
+			}
+
+			// This is the last reference of this object, we must delete it so that it doesn't leak:
+			delete this;
+		}
+
+	protected:
+		cLuaState m_LuaState;
+		cLuaState::cRef m_Callback;
+	};
+	cCallback * callback = new cCallback(tolua_S);
+
+	// Call the chunk preparation:
+	world->PrepareChunk(chunkX, chunkZ, callback);
+	return 0;
+}
+
+
+
+
+
+class cLuaWorldTask :
+	public cWorld::cTask,
+	public cPluginLua::cResettable
+{
+public:
+	cLuaWorldTask(cPluginLua & a_Plugin, int a_FnRef) :
+		cPluginLua::cResettable(a_Plugin),
+		m_FnRef(a_FnRef)
+	{
+	}
+
+protected:
+	int m_FnRef;
+	
+	// cWorld::cTask overrides:
+	virtual void Run(cWorld & a_World) override
+	{
+		cCSLock Lock(m_CSPlugin);
+		if (m_Plugin != nullptr)
+		{
+			m_Plugin->Call(m_FnRef, &a_World);
+		}
+	}
+} ;
+
+
+
+
+
+static int tolua_cWorld_QueueTask(lua_State * tolua_S)
+{
+	// Binding for cWorld::QueueTask
+	// Params: function
+	
+	// Retrieve the cPlugin from the LuaState:
+	cPluginLua * Plugin = cManualBindings::GetLuaPlugin(tolua_S);
+	if (Plugin == nullptr)
+	{
+		// An error message has been already printed in GetLuaPlugin()
+		return 0;
+	}
+
+	// Retrieve the args:
+	cWorld * self = (cWorld *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (self == nullptr)
+	{
+		return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Not called on an object instance");
+	}
+	if (!lua_isfunction(tolua_S, 2))
+	{
+		return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a function for parameter #1");
+	}
+
+	// Create a reference to the function:
+	int FnRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX);
+	if (FnRef == LUA_REFNIL)
+	{
+		return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Could not get function reference of parameter #1");
+	}
+
+	auto task = std::make_shared<cLuaWorldTask>(*Plugin, FnRef);
+	Plugin->AddResettable(task);
+	self->QueueTask(task);
+	return 0;
+}
+
+
+
+
+
+static int tolua_cWorld_SetSignLines(lua_State * tolua_S)
+{
+	// Exported manually, because tolua would generate useless additional return values (a_Line1 .. a_Line4)
+
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cWorld") ||
+		!L.CheckParamNumber(2, 4) ||
+		!L.CheckParamString(5, 8) ||
+		!L.CheckParamEnd(9)
+	)
+	{
+		return 0;
+	}
+
+	// Get params:
+	cWorld * Self = nullptr;
+	int BlockX, BlockY, BlockZ;
+	AString Line1, Line2, Line3, Line4;
+	L.GetStackValues(1, Self, BlockX, BlockY, BlockZ, Line1, Line2, Line3, Line4);
+	if (Self == nullptr)
+	{
+		return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'");
+	}
+
+	// Call the function:
+	bool res = Self->SetSignLines(BlockX, BlockY, BlockZ, Line1, Line2, Line3, Line4);
+
+	// Push the returned values:
+	L.Push(res);
+	return 1;
+}
+
+
+
+
+
+class cLuaScheduledWorldTask :
+	public cWorld::cTask,
+	public cPluginLua::cResettable
+{
+public:
+	cLuaScheduledWorldTask(cPluginLua & a_Plugin, int a_FnRef) :
+		cPluginLua::cResettable(a_Plugin),
+		m_FnRef(a_FnRef)
+	{
+	}
+
+protected:
+	int m_FnRef;
+	
+	// cWorld::cTask overrides:
+	virtual void Run(cWorld & a_World) override
+	{
+		cCSLock Lock(m_CSPlugin);
+		if (m_Plugin != nullptr)
+		{
+			m_Plugin->Call(m_FnRef, &a_World);
+		}
+	}
+};
+
+
+
+
+
+static int tolua_cWorld_ScheduleTask(lua_State * tolua_S)
+{
+	// Binding for cWorld::ScheduleTask
+	// Params: function, Ticks
+	
+	// Retrieve the cPlugin from the LuaState:
+	cPluginLua * Plugin = cManualBindings::GetLuaPlugin(tolua_S);
+	if (Plugin == nullptr)
+	{
+		// An error message has been already printed in GetLuaPlugin()
+		return 0;
+	}
+
+	// Retrieve the args:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cWorld") ||
+		!L.CheckParamNumber  (2) ||
+		!L.CheckParamFunction(3)
+	)
+	{
+		return 0;
+	}
+	cWorld * World = (cWorld *)tolua_tousertype(tolua_S, 1, nullptr);
+	if (World == nullptr)
+	{
+		return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Not called on an object instance");
+	}
+
+	// Create a reference to the function:
+	int FnRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX);
+	if (FnRef == LUA_REFNIL)
+	{
+		return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Could not get function reference of parameter #1");
+	}
+	
+	int DelayTicks = (int)tolua_tonumber(tolua_S, 2, 0);
+
+	auto task = std::make_shared<cLuaScheduledWorldTask>(*Plugin, FnRef);
+	Plugin->AddResettable(task);
+	World->ScheduleTask(DelayTicks, task);
+	return 0;
+}
+
+
+
+
+
+
+static int tolua_cWorld_TryGetHeight(lua_State * tolua_S)
+{
+	/* Exported manually, because tolua would require the out-only param a_Height to be used when calling
+	Function signature: world:TryGetHeight(a_World, a_BlockX, a_BlockZ) -> IsValid, Height
+	*/
+
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cWorld") ||
+		!L.CheckParamNumber(2, 3) ||
+		!L.CheckParamEnd(4)
+	)
+	{
+		return 0;
+	}
+
+	// Get params:
+	cWorld * self = nullptr;
+	int BlockX, BlockZ;
+	L.GetStackValues(1, self, BlockX, BlockZ);
+	if (self == nullptr)
+	{
+		tolua_error(tolua_S, "Invalid 'self' in function 'TryGetHeight'", nullptr);
+		return 0;
+	}
+
+	// Call the implementation:
+	int Height = 0;
+	bool res = self->TryGetHeight(BlockX, BlockZ, Height);
+	L.Push(res ? 1 : 0);
+	if (res)
+	{
+		L.Push(Height);
+		return 2;
+	}
+	return 1;
+}
+
+
+
+
+
+void cManualBindings::BindWorld(lua_State * tolua_S)
+{
+	tolua_beginmodule(tolua_S, nullptr);
+		tolua_beginmodule(tolua_S, "cWorld");
+			tolua_function(tolua_S, "BroadcastParticleEffect",   tolua_cWorld_BroadcastParticleEffect);
+			tolua_function(tolua_S, "ChunkStay",                 tolua_cWorld_ChunkStay);
+			tolua_function(tolua_S, "DoWithBlockEntityAt",       DoWithXYZ<cWorld, cBlockEntity,        &cWorld::DoWithBlockEntityAt>);
+			tolua_function(tolua_S, "DoWithBeaconAt",            DoWithXYZ<cWorld, cBeaconEntity,       &cWorld::DoWithBeaconAt>);
+			tolua_function(tolua_S, "DoWithChestAt",             DoWithXYZ<cWorld, cChestEntity,        &cWorld::DoWithChestAt>);
+			tolua_function(tolua_S, "DoWithDispenserAt",         DoWithXYZ<cWorld, cDispenserEntity,    &cWorld::DoWithDispenserAt>);
+			tolua_function(tolua_S, "DoWithDropSpenserAt",       DoWithXYZ<cWorld, cDropSpenserEntity,  &cWorld::DoWithDropSpenserAt>);
+			tolua_function(tolua_S, "DoWithDropperAt",           DoWithXYZ<cWorld, cDropperEntity,      &cWorld::DoWithDropperAt>);
+			tolua_function(tolua_S, "DoWithEntityByID",          DoWithID< cWorld, cEntity,             &cWorld::DoWithEntityByID>);
+			tolua_function(tolua_S, "DoWithFurnaceAt",           DoWithXYZ<cWorld, cFurnaceEntity,      &cWorld::DoWithFurnaceAt>);
+			tolua_function(tolua_S, "DoWithNoteBlockAt",         DoWithXYZ<cWorld, cNoteEntity,         &cWorld::DoWithNoteBlockAt>);
+			tolua_function(tolua_S, "DoWithCommandBlockAt",      DoWithXYZ<cWorld, cCommandBlockEntity, &cWorld::DoWithCommandBlockAt>);
+			tolua_function(tolua_S, "DoWithMobHeadAt",           DoWithXYZ<cWorld, cMobHeadEntity,      &cWorld::DoWithMobHeadAt>);
+			tolua_function(tolua_S, "DoWithFlowerPotAt",         DoWithXYZ<cWorld, cFlowerPotEntity,    &cWorld::DoWithFlowerPotAt>);
+			tolua_function(tolua_S, "DoWithPlayer",              DoWith<   cWorld, cPlayer,             &cWorld::DoWithPlayer>);
+			tolua_function(tolua_S, "FindAndDoWithPlayer",       DoWith<   cWorld, cPlayer,             &cWorld::FindAndDoWithPlayer>);
+			tolua_function(tolua_S, "DoWithPlayerByUUID",        DoWith<   cWorld, cPlayer,             &cWorld::DoWithPlayerByUUID>);
+			tolua_function(tolua_S, "ForEachBlockEntityInChunk", ForEachInChunk<cWorld, cBlockEntity,   &cWorld::ForEachBlockEntityInChunk>);
+			tolua_function(tolua_S, "ForEachChestInChunk",       ForEachInChunk<cWorld, cChestEntity,   &cWorld::ForEachChestInChunk>);
+			tolua_function(tolua_S, "ForEachEntity",             ForEach<       cWorld, cEntity,        &cWorld::ForEachEntity>);
+			tolua_function(tolua_S, "ForEachEntityInBox",        ForEachInBox<  cWorld, cEntity,        &cWorld::ForEachEntityInBox>);
+			tolua_function(tolua_S, "ForEachEntityInChunk",      ForEachInChunk<cWorld, cEntity,        &cWorld::ForEachEntityInChunk>);
+			tolua_function(tolua_S, "ForEachFurnaceInChunk",     ForEachInChunk<cWorld, cFurnaceEntity, &cWorld::ForEachFurnaceInChunk>);
+			tolua_function(tolua_S, "ForEachPlayer",             ForEach<       cWorld, cPlayer,        &cWorld::ForEachPlayer>);
+			tolua_function(tolua_S, "GetBlockInfo",              tolua_cWorld_GetBlockInfo);
+			tolua_function(tolua_S, "GetBlockTypeMeta",          tolua_cWorld_GetBlockTypeMeta);
+			tolua_function(tolua_S, "GetSignLines",              tolua_cWorld_GetSignLines);
+			tolua_function(tolua_S, "PrepareChunk",              tolua_cWorld_PrepareChunk);
+			tolua_function(tolua_S, "QueueTask",                 tolua_cWorld_QueueTask);
+			tolua_function(tolua_S, "ScheduleTask",              tolua_cWorld_ScheduleTask);
+			tolua_function(tolua_S, "SetSignLines",              tolua_cWorld_SetSignLines);
+			tolua_function(tolua_S, "TryGetHeight",              tolua_cWorld_TryGetHeight);
+		tolua_endmodule(tolua_S);
+	tolua_endmodule(tolua_S);
+}
+
+
+
+