9 files changed, 755 insertions, 194 deletions

diff --git a/source/Bindings.cpp b/source/Bindings.cpp
index 98c286e2e..77d64f661 100644
--- a/source/Bindings.cpp
+++ b/source/Bindings.cpp
@@ -1,6 +1,6 @@
 /*
 ** Lua binding: AllToLua
-** Generated automatically by tolua++-1.0.92 on 08/21/13 10:18:57.
+** Generated automatically by tolua++-1.0.92 on 08/21/13 19:38:47.
 */
 
 #ifndef __cplusplus
@@ -9307,41 +9307,6 @@ static int tolua_AllToLua_cPluginManager_ReloadPlugins00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: AddHook of class  cPluginManager */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_AddHook00
-static int tolua_AllToLua_cPluginManager_AddHook00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
-     !tolua_isusertype(tolua_S,2,"cPlugin",0,&tolua_err) ||
-     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,4,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  cPluginManager* self = (cPluginManager*)  tolua_tousertype(tolua_S,1,0);
-  cPlugin* a_Plugin = ((cPlugin*)  tolua_tousertype(tolua_S,2,0));
-  cPluginManager::PluginHook a_Hook = ((cPluginManager::PluginHook) (int)  tolua_tonumber(tolua_S,3,0));
-#ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddHook'", NULL);
-#endif
-  {
-   self->AddHook(a_Plugin,a_Hook);
-  }
- }
- return 0;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'AddHook'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-
 /* method: GetNumPlugins of class  cPluginManager */
 #ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_GetNumPlugins00
 static int tolua_AllToLua_cPluginManager_GetNumPlugins00(lua_State* tolua_S)
@@ -28072,11 +28037,12 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
    tolua_constant(tolua_S,"HOOK_WEATHER_CHANGED",cPluginManager::HOOK_WEATHER_CHANGED);
    tolua_constant(tolua_S,"HOOK_WEATHER_CHANGING",cPluginManager::HOOK_WEATHER_CHANGING);
    tolua_constant(tolua_S,"HOOK_WORLD_TICK",cPluginManager::HOOK_WORLD_TICK);
+   tolua_constant(tolua_S,"HOOK_NUM_HOOKS",cPluginManager::HOOK_NUM_HOOKS);
+   tolua_constant(tolua_S,"HOOK_MAX",cPluginManager::HOOK_MAX);
    tolua_function(tolua_S,"Get",tolua_AllToLua_cPluginManager_Get00);
    tolua_function(tolua_S,"GetPlugin",tolua_AllToLua_cPluginManager_GetPlugin00);
    tolua_function(tolua_S,"FindPlugins",tolua_AllToLua_cPluginManager_FindPlugins00);
    tolua_function(tolua_S,"ReloadPlugins",tolua_AllToLua_cPluginManager_ReloadPlugins00);
-   tolua_function(tolua_S,"AddHook",tolua_AllToLua_cPluginManager_AddHook00);
    tolua_function(tolua_S,"GetNumPlugins",tolua_AllToLua_cPluginManager_GetNumPlugins00);
    tolua_function(tolua_S,"DisablePlugin",tolua_AllToLua_cPluginManager_DisablePlugin00);
    tolua_function(tolua_S,"LoadPlugin",tolua_AllToLua_cPluginManager_LoadPlugin00);
diff --git a/source/Bindings.h b/source/Bindings.h
index 53221cf0b..7d9240e3f 100644
--- a/source/Bindings.h
+++ b/source/Bindings.h
@@ -1,6 +1,6 @@
 /*
 ** Lua binding: AllToLua
-** Generated automatically by tolua++-1.0.92 on 08/21/13 10:18:58.
+** Generated automatically by tolua++-1.0.92 on 08/21/13 19:38:48.
 */
 
 /* Exported function */
diff --git a/source/LuaState.h b/source/LuaState.h
index aa2a4af0f..caba2484d 100644
--- a/source/LuaState.h
+++ b/source/LuaState.h
@@ -77,7 +77,7 @@ public:
 		bool IsValid(void) const {return (m_Ref != LUA_REFNIL); }
 		
 		/// Allows to use this class wherever an int (i. e. ref) is to be used
-		operator int(void) { return m_Ref; }
+		operator int(void) const { return m_Ref; }
 		
 	protected:
 		cLuaState & m_LuaState;
diff --git a/source/ManualBindings.cpp b/source/ManualBindings.cpp
index c975997a5..4ed5c1a16 100644
--- a/source/ManualBindings.cpp
+++ b/source/ManualBindings.cpp
@@ -755,6 +755,157 @@ static int tolua_cPluginManager_GetAllPlugins(lua_State * tolua_S)
 
 
 
+static int tolua_cPluginManager_AddHook_FnRef(cPluginManager * a_PluginManager, cLuaState & S, int a_ParamIdx)
+{
+	// Helper function for cPluginmanager:AddHook() binding
+	// Takes care of the new case (#121): args are HOOK_TYPE and CallbackFunction
+	// The arg types have already been checked
+	
+	// Retrieve the cPlugin from the LuaState:
+	cPluginLua * Plugin = GetLuaPlugin(S);
+	if (Plugin == NULL)
+	{
+		// An error message has been already printed in GetLuaPlugin()
+		return 0;
+	}
+	
+	// Retrieve and check the hook type
+	int HookType = (int)tolua_tonumber(S, a_ParamIdx, -1);
+	if (!a_PluginManager->IsValidHookType(HookType))
+	{
+		LOGWARNING("cPluginManager.AddHook(): Invalid HOOK_TYPE parameter: %d", HookType);
+		S.LogStackTrace();
+		return 0;
+	}
+	
+	// Add the hook to the plugin
+	if (!Plugin->AddHookRef(HookType, a_ParamIdx + 1))
+	{
+		LOGWARNING("cPluginManager.AddHook(): Cannot add hook %d, unknown error.", HookType);
+		S.LogStackTrace();
+		return 0;
+	}
+	a_PluginManager->AddHook(Plugin, HookType);
+	
+	// Success
+	return 0;
+}
+
+
+
+
+
+static int tolua_cPluginManager_AddHook_DefFn(cPluginManager * a_PluginManager, cLuaState & S, int a_ParamIdx)
+{
+	// Helper function for cPluginmanager:AddHook() binding
+	// Takes care of the old case (#121): args are cPluginLua and HOOK_TYPE
+	// The arg types have already been checked
+	
+	// Retrieve and check the cPlugin parameter
+	cPluginLua * Plugin = (cPluginLua *)tolua_tousertype(S, a_ParamIdx, NULL);
+	if (Plugin == NULL)
+	{
+		LOGWARNING("cPluginManager.AddHook(): Invalid Plugin parameter, expected a valid cPlugin object. Hook not added");
+		S.LogStackTrace();
+		return 0;
+	}
+	if (Plugin != GetLuaPlugin(S))
+	{
+		// The plugin parameter passed to us is not our stored plugin. Disallow this!
+		LOGWARNING("cPluginManager.AddHook(): Invalid Plugin parameter, cannot add hook to foreign plugins. Hook not added.");
+		S.LogStackTrace();
+		return 0;
+	}
+	
+	// Retrieve and check the hook type
+	int HookType = (int)tolua_tonumber(S, a_ParamIdx + 1, -1);
+	if (!a_PluginManager->IsValidHookType(HookType))
+	{
+		LOGWARNING("cPluginManager.AddHook(): Invalid HOOK_TYPE parameter: %d", HookType);
+		S.LogStackTrace();
+		return 0;
+	}
+	
+	// Get the standard name for the callback function:
+	const char * FnName = cPluginLua::GetHookFnName(HookType);
+	if (FnName == NULL)
+	{
+		LOGWARNING("cPluginManager.AddHook(): Unknown hook type (%d). Hook not added.", HookType);
+		S.LogStackTrace();
+		return 0;
+	}
+
+	// Retrieve the function to call and add it to the plugin:
+	lua_pushstring(S, FnName);
+	bool res = Plugin->AddHookRef(HookType, 1);
+	lua_pop(S, 1);  // Pop the function off the stack
+	if (!res)
+	{
+		LOGWARNING("cPluginManager.AddHook(): Function %s not found. Hook not added.", FnName);
+		S.LogStackTrace();
+		return 0;
+	}
+	a_PluginManager->AddHook(Plugin, HookType);
+	
+	// Success
+	return 0;
+}
+
+
+
+
+
+static int tolua_cPluginManager_AddHook(lua_State * tolua_S)
+{
+	/*
+	Function signatures:
+	cPluginManager.AddHook(HOOK_TYPE, CallbackFunction)        -- (1) recommended
+	cPluginManager:Get():AddHook(HOOK_TYPE, CallbackFunction)  -- (2) accepted silently
+	cPluginManager:Get():AddHook(Plugin, HOOK_TYPE)            -- (3) old style (#121), accepted but complained about
+	cPluginManager.AddHook(Plugin, HOOK_TYPE)                  -- (4) old style (#121) mangled, accepted but complained about
+	*/
+	
+	cLuaState S(tolua_S);
+	cPluginManager * PlgMgr = cPluginManager::Get();
+
+	// If the first param is a cPluginManager, use it instead of the global one:
+	int ParamIdx = 1;
+	tolua_Error err;
+	if (tolua_isusertype(S, 1, "cPluginManager", 0, &err))
+	{
+		// Style 2 or 3, retrieve the PlgMgr instance
+		PlgMgr = (cPluginManager *)tolua_tousertype(S, 1, NULL);
+		if (PlgMgr == NULL)
+		{
+			LOGWARNING("Malformed plugin, use cPluginManager.AddHook(HOOK_TYPE, CallbackFunction). Fixing the call for you.");
+			S.LogStackTrace();
+			PlgMgr = cPluginManager::Get();
+		}
+		ParamIdx += 1;
+	}
+	
+	if (lua_isnumber(S, ParamIdx) && lua_isfunction(S, ParamIdx + 1))
+	{
+		// The next params are a number and a function, assume style 1 or 2
+		return tolua_cPluginManager_AddHook_FnRef(PlgMgr, S, ParamIdx);
+	}
+	else if (tolua_isusertype(S, ParamIdx, "cPlugin", 0, &err) && lua_isnumber(S, ParamIdx + 1))
+	{
+		// The next params are a cPlugin and a number, assume style 3 or 4
+		return tolua_cPluginManager_AddHook_DefFn(PlgMgr, S, ParamIdx);
+	}
+	
+	AString ParamDesc;
+	Printf(ParamDesc, "%s, %s, %s", S.GetTypeText(1).c_str(), S.GetTypeText(2).c_str(), S.GetTypeText(3).c_str());
+	LOGWARNING("cPluginManager.AddHook(): bad parameters. Expected HOOK_TYPE and CallbackFunction, got %s. Hook not added.", ParamDesc.c_str());
+	S.LogStackTrace();
+	return 0;
+}
+
+
+
+
+
 static int tolua_cPluginManager_ForEachCommand(lua_State * tolua_S)
 {
 	int NumArgs = lua_gettop(tolua_S) - 1;  /* This includes 'self' */
@@ -1699,6 +1850,7 @@ void ManualBindings::Bind(lua_State * tolua_S)
 			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, "AddHook",               tolua_cPluginManager_AddHook);
 		tolua_endmodule(tolua_S);
 		
 		tolua_beginmodule(tolua_S, "cPlayer");
diff --git a/source/Plugin.h b/source/Plugin.h
index 2595b9470..6e3e5f1d2 100644
--- a/source/Plugin.h
+++ b/source/Plugin.h
@@ -118,7 +118,7 @@ public:
 	Returns true if the hook can be added (handler exists)
 	Descendants should also log the specific error message as a warning if they return false.
 	*/
-	virtual bool CanAddHook(cPluginManager::PluginHook a_Hook) = 0;
+	virtual bool CanAddHook(int a_Hook) = 0;
 	
 	// tolua_begin
 	const AString & GetName(void) const  { return m_Name; }
diff --git a/source/PluginLua.cpp b/source/PluginLua.cpp
index 44b36f8f8..1c8cbef47 100644
--- a/source/PluginLua.cpp
+++ b/source/PluginLua.cpp
@@ -36,10 +36,33 @@ cPluginLua::cPluginLua(const AString & a_PluginDirectory) :
 cPluginLua::~cPluginLua()
 {
 	cCSLock Lock(m_CriticalSection);
+	Close();
+}
+
+
+
+
+
+void cPluginLua::Close(void)
+{
 	if (m_LuaState.IsValid())
 	{
+		// Release all the references in the hook map:
+		for (cHookMap::iterator itrH = m_HookMap.begin(), endH = m_HookMap.end(); itrH != endH; ++itrH)
+		{
+			for (cLuaRefs::iterator itrR = itrH->second.begin(), endR = itrH->second.end(); itrR != endR; ++itrR)
+			{
+				delete *itrR;
+			}  // for itrR - itrH->second[]
+		}  // for itrH - m_HookMap[]
+		m_HookMap.clear();
+		
 		m_LuaState.Close();
 	}
+	else
+	{
+		ASSERT(m_HookMap.empty());
+	}
 }
 
 
@@ -73,7 +96,7 @@ bool cPluginLua::Initialize(void)
 		AString Path = PluginPath + *itr;
 		if (!m_LuaState.LoadFile(Path))
 		{
-			m_LuaState.Close();
+			Close();
 			return false;
 		}
 	}  // for itr - Files[]
@@ -83,14 +106,14 @@ bool cPluginLua::Initialize(void)
 	if (!m_LuaState.Call("Initialize", this, cLuaState::Return, res))
 	{
 		LOGWARNING("Error in plugin %s: Cannot call the Initialize() function. Plugin is temporarily disabled.", GetName().c_str());
-		m_LuaState.Close();
+		Close();
 		return false;
 	}
 
 	if (!res)
 	{
 		LOGINFO("Plugin %s: Initialize() call failed, plugin is temporarily disabled.", GetName().c_str());
-		m_LuaState.Close();
+		Close();
 		return false;
 	}
 
@@ -118,7 +141,11 @@ void cPluginLua::OnDisable(void)
 void cPluginLua::Tick(float a_Dt)
 {
 	cCSLock Lock(m_CriticalSection);
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_TICK), a_Dt);
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_TICK];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_Dt);
+	}
 }
 
 
@@ -129,8 +156,16 @@ bool cPluginLua::OnBlockToPickups(cWorld * a_World, cEntity * a_Digger, int a_Bl
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_BLOCK_TO_PICKUPS), a_World, a_Digger, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, &a_Pickups, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_BLOCK_TO_PICKUPS];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_World, a_Digger, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, &a_Pickups, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -141,8 +176,16 @@ bool cPluginLua::OnChat(cPlayer * a_Player, AString & a_Message)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_CHAT), a_Player, a_Message, cLuaState::Return, res, a_Message);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_CHAT];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_Player, a_Message, cLuaState::Return, res, a_Message);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -153,8 +196,16 @@ bool cPluginLua::OnChunkAvailable(cWorld * a_World, int a_ChunkX, int a_ChunkZ)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_CHUNK_AVAILABLE), a_World, a_ChunkX, a_ChunkZ, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_CHUNK_AVAILABLE];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_World, a_ChunkX, a_ChunkZ, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -165,8 +216,16 @@ bool cPluginLua::OnChunkGenerated(cWorld * a_World, int a_ChunkX, int a_ChunkZ,
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_CHUNK_GENERATED), a_World, a_ChunkX, a_ChunkZ, a_ChunkDesc, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_CHUNK_GENERATED];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_World, a_ChunkX, a_ChunkZ, a_ChunkDesc, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -177,8 +236,16 @@ bool cPluginLua::OnChunkGenerating(cWorld * a_World, int a_ChunkX, int a_ChunkZ,
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_CHUNK_GENERATING), a_World, a_ChunkX, a_ChunkZ, a_ChunkDesc, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_CHUNK_GENERATING];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_World, a_ChunkX, a_ChunkZ, a_ChunkDesc, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -189,8 +256,16 @@ bool cPluginLua::OnChunkUnloaded(cWorld * a_World, int a_ChunkX, int a_ChunkZ)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_CHUNK_UNLOADED), a_World, a_ChunkX, a_ChunkZ, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_CHUNK_UNLOADED];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_World, a_ChunkX, a_ChunkZ, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -201,8 +276,16 @@ bool cPluginLua::OnChunkUnloading(cWorld * a_World, int a_ChunkX, int a_ChunkZ)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_CHUNK_UNLOADING), a_World, a_ChunkX, a_ChunkZ, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_CHUNK_UNLOADING];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_World, a_ChunkX, a_ChunkZ, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -213,8 +296,16 @@ bool cPluginLua::OnCollectingPickup(cPlayer * a_Player, cPickup * a_Pickup)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_COLLECTING_PICKUP), a_Player, a_Pickup, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_COLLECTING_PICKUP];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_Player, a_Pickup, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -225,8 +316,16 @@ bool cPluginLua::OnCraftingNoRecipe(const cPlayer * a_Player, const cCraftingGri
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_CRAFTING_NO_RECIPE), (cPlayer *)a_Player, a_Grid, a_Recipe, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_CRAFTING_NO_RECIPE];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), (cPlayer *)a_Player, a_Grid, a_Recipe, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -237,8 +336,16 @@ bool cPluginLua::OnDisconnect(cPlayer * a_Player, const AString & a_Reason)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_DISCONNECT), a_Player, a_Reason, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_DISCONNECT];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_Player, a_Reason, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -249,8 +356,16 @@ bool cPluginLua::OnExecuteCommand(cPlayer * a_Player, const AStringVector & a_Sp
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_EXECUTE_COMMAND), a_Player, a_Split, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_EXECUTE_COMMAND];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_Player, a_Split, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -261,26 +376,33 @@ bool cPluginLua::OnExploded(cWorld & a_World, double a_ExplosionSize, bool a_Can
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	const char * FnName = GetHookFnName(cPluginManager::HOOK_EXPLODED);
-	switch (a_Source)
-	{
-		case esOther:            m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData,               cLuaState::Return, res); break;
-		case esPrimedTNT:        m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, (cTNTEntity *)a_SourceData, cLuaState::Return, res); break;
-		case esCreeper:          m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, (cCreeper *)a_SourceData,   cLuaState::Return, res); break;
-		case esBed:              m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, (Vector3i *)a_SourceData,   cLuaState::Return, res); break;
-		case esEnderCrystal:     m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, (Vector3i *)a_SourceData,   cLuaState::Return, res); break;
-		case esGhastFireball:    m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData,               cLuaState::Return, res); break;
-		case esWitherSkullBlack:
-		case esWitherSkullBlue:  m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData, cLuaState::Return, res); break;
-		case esWitherBirth:      m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData, cLuaState::Return, res); break;
-		case esPlugin:           m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData, cLuaState::Return, res); break;
-		default:
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_EXPLODED];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		switch (a_Source)
 		{
-			ASSERT(!"Unhandled ExplosionSource");
-			return false;
+			case esOther:            m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData,               cLuaState::Return, res); break;
+			case esPrimedTNT:        m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, (cTNTEntity *)a_SourceData, cLuaState::Return, res); break;
+			case esCreeper:          m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, (cCreeper *)a_SourceData,   cLuaState::Return, res); break;
+			case esBed:              m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, (Vector3i *)a_SourceData,   cLuaState::Return, res); break;
+			case esEnderCrystal:     m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, (Vector3i *)a_SourceData,   cLuaState::Return, res); break;
+			case esGhastFireball:    m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData,               cLuaState::Return, res); break;
+			case esWitherSkullBlack:
+			case esWitherSkullBlue:  m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData, cLuaState::Return, res); break;
+			case esWitherBirth:      m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData, cLuaState::Return, res); break;
+			case esPlugin:           m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData, cLuaState::Return, res); break;
+			default:
+			{
+				ASSERT(!"Unhandled ExplosionSource");
+				return false;
+			}
+		}
+		if (res)
+		{
+			return true;
 		}
 	}
-	return res;
+	return false;
 }
 
 
@@ -291,26 +413,33 @@ bool cPluginLua::OnExploding(cWorld & a_World, double & a_ExplosionSize, bool &
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	const char * FnName = GetHookFnName(cPluginManager::HOOK_EXPLODING);
-	switch (a_Source)
-	{
-		case esOther:            m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData,               cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
-		case esPrimedTNT:        m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, (cTNTEntity *)a_SourceData, cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
-		case esCreeper:          m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, (cCreeper *)a_SourceData,   cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
-		case esBed:              m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, (Vector3i *)a_SourceData,   cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
-		case esEnderCrystal:     m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, (Vector3i *)a_SourceData,   cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
-		case esGhastFireball:    m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData,               cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
-		case esWitherSkullBlack:
-		case esWitherSkullBlue:  m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData,               cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
-		case esWitherBirth:      m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData,               cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
-		case esPlugin:           m_LuaState.Call(FnName, &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData,               cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
-		default:
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_EXPLODING];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		switch (a_Source)
 		{
-			ASSERT(!"Unhandled ExplosionSource");
-			return false;
+			case esOther:            m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData,               cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
+			case esPrimedTNT:        m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, (cTNTEntity *)a_SourceData, cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
+			case esCreeper:          m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, (cCreeper *)a_SourceData,   cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
+			case esBed:              m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, (Vector3i *)a_SourceData,   cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
+			case esEnderCrystal:     m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, (Vector3i *)a_SourceData,   cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
+			case esGhastFireball:    m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData,               cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
+			case esWitherSkullBlack:
+			case esWitherSkullBlue:  m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData,               cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
+			case esWitherBirth:      m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData,               cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
+			case esPlugin:           m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData,               cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
+			default:
+			{
+				ASSERT(!"Unhandled ExplosionSource");
+				return false;
+			}
+		}
+		if (res)
+		{
+			return true;
 		}
 	}
-	return res;
+	return false;
 }
 
 
@@ -321,8 +450,16 @@ bool cPluginLua::OnHandshake(cClientHandle * a_Client, const AString & a_Usernam
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_HANDSHAKE), a_Client, a_Username, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_HANDSHAKE];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_Client, a_Username, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -333,8 +470,17 @@ bool cPluginLua::OnHopperPullingItem(cWorld & a_World, cHopperEntity & a_Hopper,
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_HOPPER_PULLING_ITEM), &a_World, &a_Hopper, a_DstSlotNum, &a_SrcEntity, a_SrcSlotNum, cLuaState::Return, res);
-	return res;
+
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_HOPPER_PULLING_ITEM];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_World, &a_Hopper, a_DstSlotNum, &a_SrcEntity, a_SrcSlotNum, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -345,8 +491,16 @@ bool cPluginLua::OnHopperPushingItem(cWorld & a_World, cHopperEntity & a_Hopper,
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_HOPPER_PUSHING_ITEM), &a_World, &a_Hopper, a_SrcSlotNum, &a_DstEntity, a_DstSlotNum, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_HOPPER_PUSHING_ITEM];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_World, &a_Hopper, a_SrcSlotNum, &a_DstEntity, a_DstSlotNum, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -357,8 +511,16 @@ bool cPluginLua::OnKilling(cEntity & a_Victim, cEntity * a_Killer)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_KILLING), &a_Victim, a_Killer, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_KILLING];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Victim, a_Killer, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -369,8 +531,16 @@ bool cPluginLua::OnLogin(cClientHandle * a_Client, int a_ProtocolVersion, const
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_LOGIN), a_Client, a_ProtocolVersion, a_Username, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_LOGIN];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_Client, a_ProtocolVersion, a_Username, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -381,8 +551,16 @@ bool cPluginLua::OnPlayerAnimation(cPlayer & a_Player, int a_Animation)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_ANIMATION), &a_Player, a_Animation, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_ANIMATION];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Player, a_Animation, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -393,8 +571,16 @@ bool cPluginLua::OnPlayerBreakingBlock(cPlayer & a_Player, int a_BlockX, int a_B
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_BREAKING_BLOCK), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_BlockType, a_BlockMeta, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_BREAKING_BLOCK];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_BlockType, a_BlockMeta, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -405,8 +591,16 @@ bool cPluginLua::OnPlayerBrokenBlock(cPlayer & a_Player, int a_BlockX, int a_Blo
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_BROKEN_BLOCK), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_BlockType, a_BlockMeta, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_BROKEN_BLOCK];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_BlockType, a_BlockMeta, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -417,8 +611,16 @@ bool cPluginLua::OnPlayerEating(cPlayer & a_Player)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_EATING), &a_Player, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_EATING];
+	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;
 }
 
 
@@ -429,8 +631,16 @@ bool cPluginLua::OnPlayerJoined(cPlayer & a_Player)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_JOINED), &a_Player, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_JOINED];
+	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;
 }
 
 
@@ -441,8 +651,16 @@ bool cPluginLua::OnPlayerLeftClick(cPlayer & a_Player, int a_BlockX, int a_Block
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_LEFT_CLICK), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_Status, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_LEFT_CLICK];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_Status, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -453,8 +671,16 @@ bool cPluginLua::OnPlayerMoved(cPlayer & a_Player)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_MOVING), &a_Player, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_MOVING];
+	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;
 }
 
 
@@ -465,8 +691,16 @@ bool cPluginLua::OnPlayerPlacedBlock(cPlayer & a_Player, int a_BlockX, int a_Blo
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_PLACED_BLOCK), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, a_BlockType, a_BlockMeta, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_PLACED_BLOCK];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, a_BlockType, a_BlockMeta, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -477,8 +711,16 @@ bool cPluginLua::OnPlayerPlacingBlock(cPlayer & a_Player, int a_BlockX, int a_Bl
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_PLACING_BLOCK), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, a_BlockType, a_BlockMeta, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_PLACING_BLOCK];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, a_BlockType, a_BlockMeta, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -489,8 +731,16 @@ bool cPluginLua::OnPlayerRightClick(cPlayer & a_Player, int a_BlockX, int a_Bloc
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_RIGHT_CLICK), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_RIGHT_CLICK];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -501,8 +751,16 @@ bool cPluginLua::OnPlayerRightClickingEntity(cPlayer & a_Player, cEntity & a_Ent
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_RIGHT_CLICKING_ENTITY), &a_Player, &a_Entity, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_RIGHT_CLICKING_ENTITY];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Player, &a_Entity, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -513,8 +771,16 @@ bool cPluginLua::OnPlayerShooting(cPlayer & a_Player)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_SHOOTING), &a_Player, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_SHOOTING];
+	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;
 }
 
 
@@ -525,8 +791,16 @@ bool cPluginLua::OnPlayerSpawned(cPlayer & a_Player)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_SPAWNED), &a_Player, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_SPAWNED];
+	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;
 }
 
 
@@ -537,8 +811,16 @@ bool cPluginLua::OnPlayerTossingItem(cPlayer & a_Player)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_TOSSING_ITEM), &a_Player, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_TOSSING_ITEM];
+	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;
 }
 
 
@@ -549,8 +831,16 @@ bool cPluginLua::OnPlayerUsedBlock(cPlayer & a_Player, int a_BlockX, int a_Block
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_USED_BLOCK), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, a_BlockType, a_BlockMeta, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_USED_BLOCK];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, a_BlockType, a_BlockMeta, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -561,8 +851,16 @@ bool cPluginLua::OnPlayerUsedItem(cPlayer & a_Player, int a_BlockX, int a_BlockY
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_USED_ITEM), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_USED_ITEM];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -573,8 +871,16 @@ bool cPluginLua::OnPlayerUsingBlock(cPlayer & a_Player, int a_BlockX, int a_Bloc
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_USING_BLOCK), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, a_BlockType, a_BlockMeta, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_USING_BLOCK];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, a_BlockType, a_BlockMeta, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -585,8 +891,16 @@ bool cPluginLua::OnPlayerUsingItem(cPlayer & a_Player, int a_BlockX, int a_Block
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PLAYER_USING_ITEM), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_USING_ITEM];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -597,8 +911,16 @@ bool cPluginLua::OnPostCrafting(const cPlayer * a_Player, const cCraftingGrid *
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_POST_CRAFTING), a_Player, a_Grid, a_Recipe, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_POST_CRAFTING];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_Player, a_Grid, a_Recipe, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -609,8 +931,16 @@ bool cPluginLua::OnPreCrafting(const cPlayer * a_Player, const cCraftingGrid * a
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_PRE_CRAFTING), a_Player, a_Grid, a_Recipe, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PRE_CRAFTING];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_Player, a_Grid, a_Recipe, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -621,8 +951,16 @@ bool cPluginLua::OnSpawnedEntity(cWorld & a_World, cEntity & a_Entity)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_SPAWNED_ENTITY), &a_World, &a_Entity, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_SPAWNED_ENTITY];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_World, &a_Entity, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -633,8 +971,16 @@ bool cPluginLua::OnSpawnedMonster(cWorld & a_World, cMonster & a_Monster)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_SPAWNED_MONSTER), &a_World, &a_Monster, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_SPAWNED_MONSTER];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_World, &a_Monster, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -645,8 +991,16 @@ bool cPluginLua::OnSpawningEntity(cWorld & a_World, cEntity & a_Entity)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_SPAWNING_ENTITY), &a_World, &a_Entity, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_SPAWNING_ENTITY];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_World, &a_Entity, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -657,8 +1011,16 @@ bool cPluginLua::OnSpawningMonster(cWorld & a_World, cMonster & a_Monster)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_SPAWNING_MONSTER), &a_World, &a_Monster, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_SPAWNING_MONSTER];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_World, &a_Monster, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -669,8 +1031,16 @@ bool cPluginLua::OnTakeDamage(cEntity & a_Receiver, TakeDamageInfo & a_TDI)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_TAKE_DAMAGE), &a_Receiver, &a_TDI, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_TAKE_DAMAGE];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Receiver, &a_TDI, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -686,8 +1056,16 @@ bool cPluginLua::OnUpdatedSign(
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_UPDATED_SIGN), a_World, a_BlockX, a_BlockY, a_BlockZ, a_Line1, a_Line2, a_Line3, a_Line4, a_Player, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_UPDATED_SIGN];
+	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_Line1, a_Line2, a_Line3, a_Line4, a_Player, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -703,8 +1081,16 @@ bool cPluginLua::OnUpdatingSign(
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_UPDATING_SIGN), a_World, a_BlockX, a_BlockY, a_BlockZ, a_Line1, a_Line2, a_Line3, a_Line4, a_Player, cLuaState::Return, res, a_Line1, a_Line2, a_Line3, a_Line4);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_UPDATING_SIGN];
+	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_Line1, a_Line2, a_Line3, a_Line4, a_Player, cLuaState::Return, res, a_Line1, a_Line2, a_Line3, a_Line4);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -715,8 +1101,16 @@ bool cPluginLua::OnWeatherChanged(cWorld & a_World)
 {
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_WEATHER_CHANGED), &a_World, cLuaState::Return, res);
-	return res;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_WEATHER_CHANGED];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_World, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 
@@ -728,9 +1122,18 @@ bool cPluginLua::OnWeatherChanging(cWorld & a_World, eWeather & a_NewWeather)
 	cCSLock Lock(m_CriticalSection);
 	bool res = false;
 	int NewWeather = a_NewWeather;
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_WEATHER_CHANGING), &a_World, a_NewWeather, cLuaState::Return, res, NewWeather);
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_WEATHER_CHANGING];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_World, NewWeather, cLuaState::Return, res, NewWeather);
+		if (res)
+		{
+			a_NewWeather = (eWeather)NewWeather;
+			return true;
+		}
+	}
 	a_NewWeather = (eWeather)NewWeather;
-	return res;
+	return false;
 }
 
 
@@ -740,7 +1143,11 @@ bool cPluginLua::OnWeatherChanging(cWorld & a_World, eWeather & a_NewWeather)
 bool cPluginLua::OnWorldTick(cWorld & a_World, float a_Dt)
 {
 	cCSLock Lock(m_CriticalSection);
-	m_LuaState.Call(GetHookFnName(cPluginManager::HOOK_WORLD_TICK), &a_World, a_Dt);
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_WORLD_TICK];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_World, a_Dt);
+	}
 	return false;
 }
 
@@ -833,7 +1240,7 @@ void cPluginLua::ClearConsoleCommands(void)
 
 
 
-bool cPluginLua::CanAddHook(cPluginManager::PluginHook a_Hook)
+bool cPluginLua::CanAddHook(int a_Hook)
 {
 	const char * FnName = GetHookFnName(a_Hook);
 	if (FnName == NULL)
@@ -854,18 +1261,7 @@ bool cPluginLua::CanAddHook(cPluginManager::PluginHook a_Hook)
 	);
 	
 	// Lua stacktrace:
-	LOGWARNING("Stack trace:");
-	lua_Debug entry;
-	int depth = 0; 
-	while (lua_getstack(m_LuaState, depth, &entry))
-	{
-		int status = lua_getinfo(m_LuaState, "Sln", &entry);
-		assert(status);
-
-		LOGWARNING("  %s(%d): %s", entry.short_src, entry.currentline, entry.name ? entry.name : "?");
-		depth++;
-	}
-	LOGWARNING("Stack trace end");
+	m_LuaState.LogStackTrace();
 
 	return false;
 }
@@ -874,7 +1270,7 @@ bool cPluginLua::CanAddHook(cPluginManager::PluginHook a_Hook)
 
 
 
-const char * cPluginLua::GetHookFnName(cPluginManager::PluginHook a_Hook)
+const char * cPluginLua::GetHookFnName(int a_Hook)
 {
 	switch (a_Hook)
 	{
@@ -931,6 +1327,18 @@ const char * cPluginLua::GetHookFnName(cPluginManager::PluginHook a_Hook)
 
 
 
+bool cPluginLua::AddHookRef(int a_HookType, int a_FnRefIdx)
+{
+	ASSERT(m_CriticalSection.IsLockedByCurrentThread());  // It probably has to be, how else would we have a LuaState?
+	
+	m_HookMap[a_HookType].push_back(new cLuaState::cRef(m_LuaState, a_FnRefIdx));
+	return true;
+}
+
+
+
+
+
 AString cPluginLua::HandleWebRequest(const HTTPRequest * a_Request )
 {
 	cCSLock Lock(m_CriticalSection);
diff --git a/source/PluginLua.h b/source/PluginLua.h
index 300fadc8b..877de2274 100644
--- a/source/PluginLua.h
+++ b/source/PluginLua.h
@@ -100,7 +100,7 @@ public:
 	
 	virtual void ClearConsoleCommands(void) override;
 
-	virtual bool CanAddHook(cPluginManager::PluginHook a_Hook) override;
+	virtual bool CanAddHook(int a_Hook) override;
 	
 	// cWebPlugin override
 	virtual const AString GetWebTitle(void) const {return GetName(); }
@@ -128,18 +128,35 @@ public:
 	/// Calls the plugin-specified "cLuaWindow slot changed" callback.
 	void CallbackWindowSlotChanged(int a_FnRef, cWindow & a_Window, int a_SlotNum);
 	
-protected:
-	cCriticalSection m_CriticalSection;
-	cLuaState m_LuaState;
+	/// 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.
+	The function has to be on the Lua stack at the specified index a_FnRefIdx
+	Returns true if the hook was added successfully.
+	*/
+	bool AddHookRef(int a_HookType, int a_FnRefIdx);
+
+protected:
 	/// Maps command name into Lua function reference
 	typedef std::map<AString, int> CommandMap;
 	
+	/// 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
+	typedef std::map<int, cLuaRefs> cHookMap;
+	
+	cCriticalSection m_CriticalSection;
+	cLuaState m_LuaState;
+	
 	CommandMap m_Commands;
 	CommandMap m_ConsoleCommands;
-
-	/// Returns the name of Lua function that should handle the specified hook
-	const char * GetHookFnName(cPluginManager::PluginHook a_Hook);
+	
+	cHookMap m_HookMap;
+	
+	/// Releases all Lua references and closes the LuaState
+	void Close(void);
 } ;  // tolua_export
 
 
diff --git a/source/PluginManager.cpp b/source/PluginManager.cpp
index e6ff3e6e2..a2726bd58 100644
--- a/source/PluginManager.cpp
+++ b/source/PluginManager.cpp
@@ -61,7 +61,7 @@ void cPluginManager::FindPlugins(void)
 	// 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();)
 	{
-		if( itr->second == NULL )
+		if (itr->second == NULL)
 		{
 			PluginMap::iterator thiz = itr;
 			++thiz;
@@ -1585,6 +1585,15 @@ void cPluginManager::TabCompleteCommand(const AString & a_Text, AStringVector &
 
 
 
+bool cPluginManager::IsValidHookType(int a_HookType)
+{
+	return ((a_HookType >= 0) && (a_HookType <= HOOK_MAX));
+}
+
+
+
+
+
 bool cPluginManager::AddPlugin(cPlugin * a_Plugin)
 {
 	m_Plugins[a_Plugin->GetDirectory()] = a_Plugin;
@@ -1603,7 +1612,7 @@ bool cPluginManager::AddPlugin(cPlugin * a_Plugin)
 
 
 
-void cPluginManager::AddHook(cPlugin * a_Plugin, PluginHook a_Hook)
+void cPluginManager::AddHook(cPlugin * a_Plugin, int a_Hook)
 {
 	if (!a_Plugin)
 	{
diff --git a/source/PluginManager.h b/source/PluginManager.h
index 0933d389f..816e4a40c 100644
--- a/source/PluginManager.h
+++ b/source/PluginManager.h
@@ -110,6 +110,10 @@ public:																	// tolua_export
 		
 		// Note that if a hook type is added, it may need processing in cPlugin::CanAddHook() descendants,
 		//   and it definitely needs adding in cPluginLua::GetHookFnName() !
+		
+		// Keep these two as the last items, they are used for validity checking and get their values automagically
+		HOOK_NUM_HOOKS,
+		HOOK_MAX = HOOK_NUM_HOOKS - 1,
 	} ;
 	// tolua_end
 
@@ -133,7 +137,9 @@ public:																	// tolua_export
 
 	void FindPlugins();													// tolua_export
 	void ReloadPlugins();												// tolua_export
-	void AddHook( cPlugin* a_Plugin, PluginHook a_Hook );				// tolua_export
+	
+	/// 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
 	
@@ -237,6 +243,9 @@ 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
+	static bool IsValidHookType(int a_HookType);
+	
 private:
 	friend class cRoot;
 	
@@ -248,7 +257,7 @@ private:
 		AString   m_HelpString;
 	} ;
 	
-	typedef std::map< cPluginManager::PluginHook, cPluginManager::PluginList > HookMap;
+	typedef std::map<int, cPluginManager::PluginList> HookMap;
 	typedef std::map<AString, cCommandReg> CommandMap;
 
 	PluginList m_DisablePluginList;