11 files changed, 207 insertions, 1 deletions

diff --git a/src/Bindings/LuaState.cpp b/src/Bindings/LuaState.cpp
index 9fe93ccc2..ba2f3c5e0 100644
--- a/src/Bindings/LuaState.cpp
+++ b/src/Bindings/LuaState.cpp
@@ -859,6 +859,32 @@ void cLuaState::GetStackValue(int a_StackPos, eWeather & a_ReturnedVal)
 
 
 
+void cLuaState::GetStackValue(int a_StackPos, pBoundingBox & a_ReturnedVal)
+{
+	tolua_Error err;
+	if (tolua_isusertype(m_LuaState, a_StackPos, "cBoundingBox", false, &err))
+	{
+		a_ReturnedVal = *((cBoundingBox **)lua_touserdata(m_LuaState, a_StackPos));
+	}
+}
+
+
+
+
+
+void cLuaState::GetStackValue(int a_StackPos, pWorld & a_ReturnedVal)
+{
+	tolua_Error err;
+	if (tolua_isusertype(m_LuaState, a_StackPos, "cWorld", false, &err))
+	{
+		a_ReturnedVal = *((cWorld **)lua_touserdata(m_LuaState, a_StackPos));
+	}
+}
+
+
+
+
+
 bool cLuaState::CallFunction(int a_NumResults)
 {
 	ASSERT (m_NumCurrentFunctionArgs >= 0);  // A function must be pushed to stack first
diff --git a/src/Bindings/LuaState.h b/src/Bindings/LuaState.h
index eeb93fd4d..44f187701 100644
--- a/src/Bindings/LuaState.h
+++ b/src/Bindings/LuaState.h
@@ -59,6 +59,10 @@ class cTNTEntity;
 class cCreeper;
 class cHopperEntity;
 class cBlockEntity;
+class cBoundingBox;
+
+typedef cBoundingBox * pBoundingBox;
+typedef cWorld *       pWorld;
 
 
 
@@ -230,6 +234,12 @@ public:
 	/** Retrieve value at a_StackPos, if it is a valid number, converting and clamping it to eWeather.
 	If not, a_Value is unchanged. */
 	void GetStackValue(int a_StackPos, eWeather & a_Value);
+
+	/** Retrieve value at a_StackPos, if it is a valid cBoundingBox class. If not, a_Value is unchanged */
+	void GetStackValue(int a_StackPos, pBoundingBox & a_Value);
+	
+	/** Retrieve value at a_StackPos, if it is a valid cWorld class. If not, a_Value is unchanged */
+	void GetStackValue(int a_StackPos, pWorld & a_Value);
 	
 
 	// Include the cLuaState::Call() overload implementation that is generated by the gen_LuaState_Call.lua script:
@@ -328,6 +338,14 @@ protected:
 	*/
 	bool PushFunction(int a_FnRef);
 	
+	/** Pushes a function that has been saved as a reference.
+	Returns true if successful. Logs a warning on failure
+	*/
+	bool PushFunction(const cRef & a_FnRef)
+	{
+		return PushFunction((int)a_FnRef);
+	}
+	
 	/** Pushes a function that is stored in a referenced table by name
 	Returns true if successful. Logs a warning on failure
 	*/
diff --git a/src/Bindings/ManualBindings.cpp b/src/Bindings/ManualBindings.cpp
index adf10a72f..b7ea65759 100644
--- a/src/Bindings/ManualBindings.cpp
+++ b/src/Bindings/ManualBindings.cpp
@@ -679,6 +679,75 @@ static int tolua_ForEachInChunk(lua_State * tolua_S)
 template <
 	class Ty1,
 	class Ty2,
+	bool (Ty1::*Func1)(const cBoundingBox &, cItemCallback<Ty2> &)
+>
+static int tolua_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 = NULL;
+	cBoundingBox * Box = NULL;
+	L.GetStackValues(1, Self, Box);
+	ASSERT(Self != NULL);  // We have verified the type at the top, so we should get valid objects here
+	ASSERT(Box != NULL);
+	
+	// Create a reference for the function:
+	cLuaState::cRef FnRef(L, 3);
+
+	// 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:
+		// 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;
+		}
+		cLuaState & m_LuaState;
+		cLuaState::cRef & m_FnRef;
+	} Callback(L, FnRef);
+
+	bool bRetVal = (Self->*Func1)(*Box, Callback);
+	
+	FnRef.UnRef();
+
+	/* Push return value on stack */
+	tolua_pushboolean(tolua_S, bRetVal);
+	return 1;
+}
+
+
+
+
+
+template <
+	class Ty1,
+	class Ty2,
 	bool (Ty1::*Func1)(cItemCallback<Ty2> &)
 >
 static int tolua_ForEach(lua_State * tolua_S)
@@ -3327,6 +3396,7 @@ void ManualBindings::Bind(lua_State * tolua_S)
 			tolua_function(tolua_S, "ForEachBlockEntityInChunk", tolua_ForEachInChunk<cWorld, cBlockEntity,   &cWorld::ForEachBlockEntityInChunk>);
 			tolua_function(tolua_S, "ForEachChestInChunk",       tolua_ForEachInChunk<cWorld, cChestEntity,   &cWorld::ForEachChestInChunk>);
 			tolua_function(tolua_S, "ForEachEntity",             tolua_ForEach<       cWorld, cEntity,        &cWorld::ForEachEntity>);
+			tolua_function(tolua_S, "ForEachEntityInBox",        tolua_ForEachInBox<  cWorld, cEntity,        &cWorld::ForEachEntityInBox>);
 			tolua_function(tolua_S, "ForEachEntityInChunk",      tolua_ForEachInChunk<cWorld, cEntity,        &cWorld::ForEachEntityInChunk>);
 			tolua_function(tolua_S, "ForEachFurnaceInChunk",     tolua_ForEachInChunk<cWorld, cFurnaceEntity, &cWorld::ForEachFurnaceInChunk>);
 			tolua_function(tolua_S, "ForEachPlayer",             tolua_ForEach<       cWorld, cPlayer,        &cWorld::ForEachPlayer>);
diff --git a/src/Bindings/gen_LuaState_Call.lua b/src/Bindings/gen_LuaState_Call.lua
index 2d8630d12..7f62573c7 100644
--- a/src/Bindings/gen_LuaState_Call.lua
+++ b/src/Bindings/gen_LuaState_Call.lua
@@ -109,7 +109,7 @@ local function WriteOverload(f, a_NumParams, a_NumReturns)
 	
 	-- Write the function signature:
 	f:write("bool Call(")
-	f:write("FnT a_Function")
+	f:write("const FnT & a_Function")
 	for i = 1, a_NumParams do
 		f:write(", ParamT", i, " a_Param", i)
 	end
diff --git a/src/BoundingBox.h b/src/BoundingBox.h
index 793466302..928e62afa 100644
--- a/src/BoundingBox.h
+++ b/src/BoundingBox.h
@@ -80,6 +80,17 @@ public:
 	/// Calculates the intersection of the two bounding boxes; returns true if nonempty
 	bool Intersect(const cBoundingBox & a_Other, cBoundingBox & a_Intersection);
 	
+	double GetMinX(void) const { return m_Min.x; }
+	double GetMinY(void) const { return m_Min.y; }
+	double GetMinZ(void) const { return m_Min.z; }
+
+	double GetMaxX(void) const { return m_Max.x; }
+	double GetMaxY(void) const { return m_Max.y; }
+	double GetMaxZ(void) const { return m_Max.z; }
+	
+	const Vector3d & GetMin(void) const { return m_Min; }
+	const Vector3d & GetMax(void) const { return m_Max; }
+	
 protected:
 	Vector3d m_Min;
 	Vector3d m_Max;
diff --git a/src/Chunk.cpp b/src/Chunk.cpp
index 95b8c8e5e..9fb178bc3 100644
--- a/src/Chunk.cpp
+++ b/src/Chunk.cpp
@@ -37,6 +37,7 @@
 #include "MobSpawner.h"
 #include "BlockInServerPluginInterface.h"
 #include "SetChunkData.h"
+#include "BoundingBox.h"
 
 #include "json/json.h"
 
@@ -1959,6 +1960,30 @@ bool cChunk::ForEachEntity(cEntityCallback & a_Callback)
 
 
 
+bool cChunk::ForEachEntityInBox(const cBoundingBox & a_Box, cEntityCallback & a_Callback)
+{
+	// The entity list is locked by the parent chunkmap's CS
+	for (cEntityList::iterator itr = m_Entities.begin(), itr2 = itr; itr != m_Entities.end(); itr = itr2)
+	{
+		++itr2;
+		cBoundingBox EntBox((*itr)->GetPosition(), (*itr)->GetWidth() / 2, (*itr)->GetHeight());
+		if (!EntBox.DoesIntersect(a_Box))
+		{
+			// The entity is not in the specified box
+			continue;
+		}
+		if (a_Callback.Item(*itr))
+		{
+			return false;
+		}
+	}  // for itr - m_Entitites[]
+	return true;
+}
+
+
+
+
+
 bool cChunk::DoWithEntityByID(int a_EntityID, cEntityCallback & a_Callback, bool & a_CallbackResult)
 {
 	// The entity list is locked by the parent chunkmap's CS
diff --git a/src/Chunk.h b/src/Chunk.h
index 3b5d1254e..0f4928b90 100644
--- a/src/Chunk.h
+++ b/src/Chunk.h
@@ -216,6 +216,10 @@ public:
 	/** Calls the callback for each entity; returns true if all entities processed, false if the callback aborted by returning true */
 	bool ForEachEntity(cEntityCallback & a_Callback);  // Lua-accessible
 
+	/** Calls the callback for each entity that has a nonempty intersection with the specified boundingbox.
+	Returns true if all entities processed, false if the callback aborted by returning true. */
+	bool ForEachEntityInBox(const cBoundingBox & a_Box, cEntityCallback & a_Callback);  // Lua-accessible
+
 	/** Calls the callback if the entity with the specified ID is found, with the entity object as the callback param. Returns true if entity found. */
 	bool DoWithEntityByID(int a_EntityID, cEntityCallback & a_Callback, bool & a_CallbackResult);  // Lua-accessible
 
diff --git a/src/ChunkMap.cpp b/src/ChunkMap.cpp
index f14d680d4..8c765c8c9 100644
--- a/src/ChunkMap.cpp
+++ b/src/ChunkMap.cpp
@@ -1775,6 +1775,38 @@ bool cChunkMap::ForEachEntityInChunk(int a_ChunkX, int a_ChunkZ, cEntityCallback
 
 
 
+bool cChunkMap::ForEachEntityInBox(const cBoundingBox & a_Box, cEntityCallback & a_Callback)
+{
+	// Calculate the chunk range for the box:
+	int MinChunkX = (int)floor(a_Box.GetMinX() / cChunkDef::Width);
+	int MinChunkZ = (int)floor(a_Box.GetMinZ() / cChunkDef::Width);
+	int MaxChunkX = (int)floor((a_Box.GetMaxX() + cChunkDef::Width) / cChunkDef::Width);
+	int MaxChunkZ = (int)floor((a_Box.GetMaxZ() + cChunkDef::Width) / cChunkDef::Width);
+	
+	// Iterate over each chunk in the range:
+	cCSLock Lock(m_CSLayers);
+	for (int z = MinChunkZ; z <= MaxChunkZ; z++)
+	{
+		for (int x = MinChunkX; x <= MaxChunkX; x++)
+		{
+			cChunkPtr Chunk = GetChunkNoGen(x, z);
+			if ((Chunk == NULL) || !Chunk->IsValid())
+			{
+				continue;
+			}
+			if (!Chunk->ForEachEntityInBox(a_Box, a_Callback))
+			{
+				return false;
+			}
+		}  // for x
+	}  // for z
+	return true;
+}
+
+
+
+
+
 void cChunkMap::DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_BlockY, double a_BlockZ, cVector3iArray & a_BlocksAffected)
 {
 	// Don't explode if outside of Y range (prevents the following test running into unallocated memory):
diff --git a/src/ChunkMap.h b/src/ChunkMap.h
index 6a379e51d..8c564d0de 100644
--- a/src/ChunkMap.h
+++ b/src/ChunkMap.h
@@ -36,6 +36,7 @@ class cBlockArea;
 class cMobCensus;
 class cMobSpawner;
 class cSetChunkData;
+class cBoundingBox;
 
 typedef std::list<cClientHandle *>         cClientHandleList;
 typedef cChunk *                           cChunkPtr;
@@ -209,6 +210,11 @@ public:
 	/** Calls the callback for each entity in the specified chunk; returns true if all entities processed, false if the callback aborted by returning true */
 	bool ForEachEntityInChunk(int a_ChunkX, int a_ChunkZ, cEntityCallback & a_Callback);  // Lua-accessible
 
+	/** Calls the callback for each entity that has a nonempty intersection with the specified boundingbox.
+	Returns true if all entities processed, false if the callback aborted by returning true.
+	If any chunk in the box is missing, ignores the entities in that chunk silently. */
+	bool ForEachEntityInBox(const cBoundingBox & a_Box, cEntityCallback & a_Callback);  // Lua-accessible
+
 	/** Destroys and returns a list of blocks destroyed in the explosion at the specified coordinates */
 	void DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_BlockY, double a_BlockZ, cVector3iArray & a_BlockAffected);
 	
diff --git a/src/World.cpp b/src/World.cpp
index dd6017f0d..2a3336dee 100644
--- a/src/World.cpp
+++ b/src/World.cpp
@@ -2696,6 +2696,15 @@ bool cWorld::ForEachEntityInChunk(int a_ChunkX, int a_ChunkZ, cEntityCallback &
 
 
 
+bool cWorld::ForEachEntityInBox(const cBoundingBox & a_Box, cEntityCallback & a_Callback)
+{
+	return m_ChunkMap->ForEachEntityInBox(a_Box, a_Callback);
+}
+
+
+
+
+
 bool cWorld::DoWithEntityByID(int a_UniqueID, cEntityCallback & a_Callback)
 {
 	return m_ChunkMap->DoWithEntityByID(a_UniqueID, a_Callback);
diff --git a/src/World.h b/src/World.h
index 49e30694e..49932ac9d 100644
--- a/src/World.h
+++ b/src/World.h
@@ -324,6 +324,11 @@ public:
 	/** Calls the callback for each entity in the specified chunk; returns true if all entities processed, false if the callback aborted by returning true */
 	bool ForEachEntityInChunk(int a_ChunkX, int a_ChunkZ, cEntityCallback & a_Callback);  // Exported in ManualBindings.cpp
 
+	/** Calls the callback for each entity that has a nonempty intersection with the specified boundingbox.
+	Returns true if all entities processed, false if the callback aborted by returning true.
+	If any chunk in the box is missing, ignores the entities in that chunk silently. */
+	bool ForEachEntityInBox(const cBoundingBox & a_Box, cEntityCallback & a_Callback);  // Exported in ManualBindings.cpp
+
 	/** Calls the callback if the entity with the specified ID is found, with the entity object as the callback param. Returns true if entity found and callback returned false. */
 	bool DoWithEntityByID(int a_UniqueID, cEntityCallback & a_Callback);  // Exported in ManualBindings.cpp