37 files changed, 546 insertions, 1592 deletions

diff --git a/src/Bindings/ManualBindings.h b/src/Bindings/ManualBindings.h
index a23c5d2e4..780c6ce41 100644
--- a/src/Bindings/ManualBindings.h
+++ b/src/Bindings/ManualBindings.h
@@ -211,228 +211,6 @@ public:
 
 
 
-	/** Template for the bindings for the DoWithXYZAt(X, Y, Z) functions that don't need to check their coords. */
-	template <
-		class SELF,
-		class ITEM,
-		bool (SELF::*DoWithFn)(int, int, int, cFunctionRef<bool(ITEM &)>)
-	>
-	static int DoWithXYZ(lua_State * tolua_S)
-	{
-		// Check params:
-		cLuaState L(tolua_S);
-		if (
-			!L.CheckParamNumber(2, 4) ||
-			!L.CheckParamFunction(5) ||
-			!L.CheckParamEnd(6)
-		)
-		{
-			return 0;
-		}
-
-		// Get parameters:
-		SELF * Self = nullptr;
-		int BlockX = 0;
-		int BlockY = 0;
-		int BlockZ = 0;
-		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");
-		}
-
-		// Call the DoWith function:
-		bool res = (Self->*DoWithFn)(BlockX, BlockY, BlockZ, [&](ITEM & a_Item)
-			{
-				bool ret = false;
-				L.Call(FnRef, &a_Item, cLuaState::Return, ret);
-				return ret;
-			}
-		);
-
-		// Push the result as the return value:
-		L.Push(res);
-		return 1;
-	}
-
-
-
-
-
-	/** Template for the bindings for the DoWithXYZAt(X, Y, Z) functions that need to check their coords. */
-	template <
-		class SELF,
-		class ITEM,
-		bool (SELF::*DoWithFn)(int, int, int, cFunctionRef<bool(ITEM &)>),
-		bool (SELF::*CoordCheckFn)(int, int, int) const
-	>
-	static int DoWithXYZ(lua_State * tolua_S)
-	{
-		// Check params:
-		cLuaState L(tolua_S);
-		if (
-			!L.CheckParamNumber(2, 4) ||
-			!L.CheckParamFunction(5) ||
-			!L.CheckParamEnd(6)
-		)
-		{
-			return 0;
-		}
-
-		// Get parameters:
-		SELF * Self = nullptr;
-		int BlockX = 0;
-		int BlockY = 0;
-		int BlockZ = 0;
-		cLuaState::cRef FnRef;
-		L.GetStackValues(1, Self, BlockX, BlockY, BlockZ, FnRef);
-		if (Self == nullptr)
-		{
-			return L.ApiParamError("Invalid 'self'");
-		}
-		if (!FnRef.IsValid())
-		{
-			return L.ApiParamError("Expected a valid callback function for parameter #5");
-		}
-		if (!(Self->*CoordCheckFn)(BlockX, BlockY, BlockZ))
-		{
-			return L.FApiParamError("The provided coordinates ({0}) are not valid",
-				Vector3i{BlockX, BlockY, BlockZ}
-			);
-		}
-
-		// Call the DoWith function:
-		bool res = (Self->*DoWithFn)(BlockX, BlockY, BlockZ, [&](ITEM & a_Item)
-			{
-				bool ret = false;
-				L.Call(FnRef, &a_Item, cLuaState::Return, ret);
-				return ret;
-			}
-		);
-
-		// Push the result as the return value:
-		L.Push(res);
-		return 1;
-	}
-
-
-
-
-
-	template <
-		class Ty1,
-		class Ty2,
-		bool (Ty1::*ForEachFn)(int, int, cFunctionRef<bool(Ty2 &)>)
-	>
-	static int ForEachInChunk(lua_State * tolua_S)
-	{
-		// Check params:
-		cLuaState L(tolua_S);
-		if (
-			!L.CheckParamNumber(2, 3) ||
-			!L.CheckParamFunction(4) ||
-			!L.CheckParamEnd(5)
-		)
-		{
-			return 0;
-		}
-
-		// Get parameters:
-		Ty1 * Self = nullptr;
-		int ChunkX = 0;
-		int ChunkZ = 0;
-		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");
-		}
-
-		// Call the DoWith function:
-		bool res = (Self->*ForEachFn)(ChunkX, ChunkZ, [&](Ty2 & a_Item)
-			{
-				bool ret = false;
-				L.Call(FnRef, &a_Item, cLuaState::Return, ret);
-				return ret;
-			}
-		);
-
-		// Push the result as the return value:
-		L.Push(res);
-		return 1;
-	}
-
-
-
-
-
-	template <
-		class Ty1,
-		class Ty2,
-		bool (Ty1::*ForEachFn)(const cBoundingBox &, cFunctionRef<bool(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)", static_cast<void *>(Self), static_cast<void *>(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");
-		}
-
-		bool res = (Self->*ForEachFn)(*Box, [&](Ty2 & a_Item)
-			{
-				bool ret = false;
-				if (!L.Call(FnRef, &a_Item, cLuaState::Return, ret))
-				{
-					LOGWARNING("Failed to call Lua callback");
-					L.LogStackTrace();
-					return true;  // Abort enumeration
-				}
-
-				return ret;
-			}
-		);
-
-		// Push the result as the return value:
-		L.Push(res);
-		return 1;
-	}
-
-
-
-
-
 	template <
 		class Ty1,
 		class Ty2,
diff --git a/src/Bindings/ManualBindings_BlockArea.cpp b/src/Bindings/ManualBindings_BlockArea.cpp
index 5f281fadc..a53a7bebf 100644
--- a/src/Bindings/ManualBindings_BlockArea.cpp
+++ b/src/Bindings/ManualBindings_BlockArea.cpp
@@ -15,6 +15,66 @@
 
 
 
+/** Template for the bindings for the DoWithXYZAt(X, Y, Z) functions that need to check their coords. */
+template <
+	class SELF,
+	class ITEM,
+	bool (SELF::*DoWithFn)(int, int, int, cFunctionRef<bool(ITEM &)>),
+	bool (SELF::*CoordCheckFn)(int, int, int) const
+>
+static int DoWithXYZ(lua_State * tolua_S)
+{
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamNumber(2, 4) ||
+		!L.CheckParamFunction(5) ||
+		!L.CheckParamEnd(6)
+	)
+	{
+		return 0;
+	}
+
+	// Get parameters:
+	SELF * Self = nullptr;
+	int BlockX = 0;
+	int BlockY = 0;
+	int BlockZ = 0;
+	cLuaState::cRef FnRef;
+	L.GetStackValues(1, Self, BlockX, BlockY, BlockZ, FnRef);
+	if (Self == nullptr)
+	{
+		return L.ApiParamError("Invalid 'self'");
+	}
+	if (!FnRef.IsValid())
+	{
+		return L.ApiParamError("Expected a valid callback function for parameter #5");
+	}
+	if (!(Self->*CoordCheckFn)(BlockX, BlockY, BlockZ))
+	{
+		return L.FApiParamError("The provided coordinates ({0}) are not valid",
+			Vector3i{BlockX, BlockY, BlockZ}
+		);
+	}
+
+	// Call the DoWith function:
+	bool res = (Self->*DoWithFn)(BlockX, BlockY, BlockZ, [&](ITEM & a_Item)
+		{
+			bool ret = false;
+			L.Call(FnRef, &a_Item, cLuaState::Return, ret);
+			return ret;
+		}
+	);
+
+	// Push the result as the return value:
+	L.Push(res);
+	return 1;
+}
+
+
+
+
+
 /** Reads params that together form a Cuboid.
 These can be:
 	- 6 numbers (MinX, MaxX, MinY, MaxY, MinZ, MaxZ)
diff --git a/src/Bindings/ManualBindings_World.cpp b/src/Bindings/ManualBindings_World.cpp
index 0a748c55d..db797483d 100644
--- a/src/Bindings/ManualBindings_World.cpp
+++ b/src/Bindings/ManualBindings_World.cpp
@@ -12,6 +12,23 @@
 #include "PluginLua.h"
 #include "LuaChunkStay.h"
 
+#include "BlockEntities/BeaconEntity.h"
+#include "BlockEntities/BedEntity.h"
+#include "BlockEntities/BrewingstandEntity.h"
+#include "BlockEntities/ChestEntity.h"
+#include "BlockEntities/CommandBlockEntity.h"
+#include "BlockEntities/DispenserEntity.h"
+#include "BlockEntities/DropSpenserEntity.h"
+#include "BlockEntities/DropperEntity.h"
+#include "BlockEntities/FlowerPotEntity.h"
+#include "BlockEntities/FurnaceEntity.h"
+#include "BlockEntities/HopperEntity.h"
+#include "BlockEntities/MobHeadEntity.h"
+#include "BlockEntities/NoteEntity.h"
+
+
+
+
 
 /** Check that a Lua parameter is either a vector or 3 numbers in sequence
 \param L The Lua state
@@ -50,6 +67,183 @@ static bool GetStackVectorOr3Numbers(cLuaState & L, int a_Index, Vector3<T> & a_
 
 
 
+/** Template for the bindings for the DoWithXYZAt(X, Y, Z) functions that don't need to check their coords. */
+template <class BlockEntityType, BLOCKTYPE... BlockTypes>
+static int DoWithBlockEntityAt(lua_State * tolua_S)
+{
+	cLuaState L(tolua_S);
+	int OffsetIndex;
+
+	// Check params:
+	if (
+		!L.CheckParamSelf("cWorld") ||
+		!CheckParamVectorOr3Numbers(L, "Vector3<int>", 2, OffsetIndex) ||
+		!L.CheckParamFunction(OffsetIndex) ||
+		!L.CheckParamEnd(OffsetIndex + 1)
+	)
+	{
+		return 0;
+	}
+
+	cWorld * Self = nullptr;
+	Vector3i Position;
+	cLuaState::cRef FnRef;
+
+	// Get parameters:
+	if (
+		!L.GetStackValues(1, Self) ||
+		!GetStackVectorOr3Numbers(L, 2, Position) ||
+		!L.GetStackValues(OffsetIndex, FnRef)
+	)
+	{
+		return 0;
+	}
+
+	if (Self == nullptr)
+	{
+		return L.ApiParamError("Invalid 'self'");
+	}
+	if (!FnRef.IsValid())
+	{
+		return L.ApiParamError("Expected a valid callback function for parameter %i", OffsetIndex);
+	}
+
+	// Call the DoWith function:
+	bool res = Self->DoWithBlockEntityAt(Position, [&L, &FnRef](cBlockEntity & a_BlockEntity)
+	{
+		if constexpr (sizeof...(BlockTypes) != 0)
+		{
+			if (((a_BlockEntity.GetBlockType() != BlockTypes) && ...))
+			{
+				return false;
+			}
+		}
+
+		bool ret = false;
+		L.Call(FnRef, static_cast<BlockEntityType *>(&a_BlockEntity), cLuaState::Return, ret);
+		return ret;
+	});
+
+	// Push the result as the return value:
+	L.Push(res);
+	return 1;
+}
+
+
+
+
+
+template <
+	class Ty1,
+	class Ty2,
+	bool (Ty1::*ForEachFn)(const cBoundingBox &, cFunctionRef<bool(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))
+	{
+		return L.ApiParamError("Invalid world (%p) or boundingbox (%p)", static_cast<void *>(Self), static_cast<void *>(Box));
+	}
+	if (!FnRef.IsValid())
+	{
+		return L.ApiParamError("Expected a valid callback function for parameter #2");
+	}
+
+	bool res = (Self->*ForEachFn)(*Box, [&](Ty2 & a_Item)
+		{
+			bool ret = false;
+			if (!L.Call(FnRef, &a_Item, cLuaState::Return, ret))
+			{
+				LOGWARNING("Failed to call Lua callback");
+				L.LogStackTrace();
+				return true;  // Abort enumeration
+			}
+
+			return ret;
+		}
+	);
+
+	// Push the result as the return value:
+	L.Push(res);
+	return 1;
+}
+
+
+
+
+
+template <class BlockEntityType, BLOCKTYPE... BlockTypes>
+static int ForEachBlockEntityInChunk(lua_State * tolua_S)
+{
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamSelf("cWorld") ||
+		!L.CheckParamNumber(2, 3) ||
+		!L.CheckParamFunction(4) ||
+		!L.CheckParamEnd(5)
+	)
+	{
+		return 0;
+	}
+
+	// Get parameters:
+	cWorld * Self = nullptr;
+	int ChunkX = 0;
+	int ChunkZ = 0;
+	cLuaState::cRef FnRef;
+	L.GetStackValues(1, Self, ChunkX, ChunkZ, FnRef);
+	if (Self == nullptr)
+	{
+		return L.ApiParamError("Error in function call '#funcname#': Invalid 'self'");
+	}
+	if (!FnRef.IsValid())
+	{
+		return L.ApiParamError("Expected a valid callback function for parameter #4");
+	}
+
+	// Call the ForEach function:
+	bool res = Self->ForEachBlockEntityInChunk(ChunkX, ChunkZ, [&L, &FnRef](cBlockEntity & a_BlockEntity)
+	{
+		if constexpr (sizeof...(BlockTypes) != 0)
+		{
+			if (((a_BlockEntity.GetBlockType() != BlockTypes) && ...))
+			{
+				return false;
+			}
+		}
+
+		bool ret = false;
+		L.Call(FnRef, static_cast<BlockEntityType *>(&a_BlockEntity), cLuaState::Return, ret);
+		return ret;
+	});
+
+	// Push the result as the return value:
+	L.Push(res);
+	return 1;
+}
+
+
+
+
+
 static int tolua_cWorld_BroadcastBlockAction(lua_State * tolua_S)
 {
 	/* Function signature:
@@ -566,6 +760,53 @@ static int tolua_cWorld_FastSetBlock(lua_State * tolua_S)
 
 
 
+static int tolua_cWorld_ForEachEntityInChunk(lua_State * tolua_S)
+{
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cWorld") ||
+		!L.CheckParamNumber(2, 3) ||
+		!L.CheckParamFunction(4) ||
+		!L.CheckParamEnd(5)
+	)
+	{
+		return 0;
+	}
+
+	// Get parameters:
+	cWorld * Self = nullptr;
+	int ChunkX = 0;
+	int ChunkZ = 0;
+	cLuaState::cRef FnRef;
+	L.GetStackValues(1, Self, ChunkX, ChunkZ, FnRef);
+	if (Self == nullptr)
+	{
+		return L.ApiParamError("Invalid 'self'");
+	}
+	if (!FnRef.IsValid())
+	{
+		return L.ApiParamError("Expected a valid callback function for parameter #4");
+	}
+
+	// Call the DoWith function:
+	bool res = Self->ForEachEntityInChunk(ChunkX, ChunkZ, [&](cEntity & a_Item)
+		{
+			bool ret = false;
+			L.Call(FnRef, &a_Item, cLuaState::Return, ret);
+			return ret;
+		}
+	);
+
+	// Push the result as the return value:
+	L.Push(res);
+	return 1;
+}
+
+
+
+
+
 static int tolua_cWorld_ForEachLoadedChunk(lua_State * tolua_S)
 {
 	// Exported manually, because tolua doesn't support converting functions to functor types.
@@ -1347,35 +1588,35 @@ void cManualBindings::BindWorld(lua_State * tolua_S)
 			tolua_function(tolua_S, "BroadcastParticleEffect",      tolua_cWorld_BroadcastParticleEffect);
 			tolua_function(tolua_S, "ChunkStay",                    tolua_cWorld_ChunkStay);
 			tolua_function(tolua_S, "DoExplosionAt",                tolua_cWorld_DoExplosionAt);
-			tolua_function(tolua_S, "DoWithBeaconAt",               DoWithXYZ<cWorld, cBeaconEntity,       &cWorld::DoWithBeaconAt>);
-			tolua_function(tolua_S, "DoWithBedAt",                  DoWithXYZ<cWorld, cBedEntity,          &cWorld::DoWithBedAt>);
-			tolua_function(tolua_S, "DoWithBlockEntityAt",          DoWithXYZ<cWorld, cBlockEntity,        &cWorld::DoWithBlockEntityAt>);
-			tolua_function(tolua_S, "DoWithBrewingstandAt",         DoWithXYZ<cWorld, cBrewingstandEntity, &cWorld::DoWithBrewingstandAt>);
-			tolua_function(tolua_S, "DoWithChestAt",                DoWithXYZ<cWorld, cChestEntity,        &cWorld::DoWithChestAt>);
-			tolua_function(tolua_S, "DoWithCommandBlockAt",         DoWithXYZ<cWorld, cCommandBlockEntity, &cWorld::DoWithCommandBlockAt>);
-			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, "DoWithFlowerPotAt",            DoWithXYZ<cWorld, cFlowerPotEntity,    &cWorld::DoWithFlowerPotAt>);
-			tolua_function(tolua_S, "DoWithFurnaceAt",              DoWithXYZ<cWorld, cFurnaceEntity,      &cWorld::DoWithFurnaceAt>);
-			tolua_function(tolua_S, "DoWithHopperAt",               DoWithXYZ<cWorld, cHopperEntity,       &cWorld::DoWithHopperAt>);
-			tolua_function(tolua_S, "DoWithMobHeadAt",              DoWithXYZ<cWorld, cMobHeadEntity,      &cWorld::DoWithMobHeadAt>);
+			tolua_function(tolua_S, "DoWithBeaconAt",               DoWithBlockEntityAt<cBeaconEntity, E_BLOCK_BEACON>);
+			tolua_function(tolua_S, "DoWithBedAt",                  DoWithBlockEntityAt<cBedEntity, E_BLOCK_BED>);
+			tolua_function(tolua_S, "DoWithBlockEntityAt",          DoWithBlockEntityAt<cBlockEntity>);
+			tolua_function(tolua_S, "DoWithBrewingstandAt",         DoWithBlockEntityAt<cBrewingstandEntity, E_BLOCK_BREWING_STAND>);
+			tolua_function(tolua_S, "DoWithChestAt",                DoWithBlockEntityAt<cChestEntity, E_BLOCK_CHEST, E_BLOCK_TRAPPED_CHEST>);
+			tolua_function(tolua_S, "DoWithCommandBlockAt",         DoWithBlockEntityAt<cCommandBlockEntity, E_BLOCK_COMMAND_BLOCK>);
+			tolua_function(tolua_S, "DoWithDispenserAt",            DoWithBlockEntityAt<cDispenserEntity, E_BLOCK_DISPENSER>);
+			tolua_function(tolua_S, "DoWithDropSpenserAt",          DoWithBlockEntityAt<cDropSpenserEntity, E_BLOCK_DISPENSER, E_BLOCK_DROPPER>);
+			tolua_function(tolua_S, "DoWithDropperAt",              DoWithBlockEntityAt<cDropperEntity, E_BLOCK_DROPPER>);
+			tolua_function(tolua_S, "DoWithEntityByID",             DoWithID<cWorld, cEntity, &cWorld::DoWithEntityByID>);
+			tolua_function(tolua_S, "DoWithFlowerPotAt",            DoWithBlockEntityAt<cFlowerPotEntity, E_BLOCK_FLOWER_POT>);
+			tolua_function(tolua_S, "DoWithFurnaceAt",              DoWithBlockEntityAt<cFurnaceEntity, E_BLOCK_FURNACE, E_BLOCK_LIT_FURNACE>);
+			tolua_function(tolua_S, "DoWithHopperAt",               DoWithBlockEntityAt<cHopperEntity, E_BLOCK_HOPPER>);
+			tolua_function(tolua_S, "DoWithMobHeadAt",              DoWithBlockEntityAt<cMobHeadEntity, E_BLOCK_HEAD>);
 			tolua_function(tolua_S, "DoWithNearestPlayer",          tolua_cWorld_DoWithNearestPlayer);
-			tolua_function(tolua_S, "DoWithNoteBlockAt",            DoWithXYZ<cWorld, cNoteEntity,         &cWorld::DoWithNoteBlockAt>);
-			tolua_function(tolua_S, "DoWithPlayer",                 DoWith<   cWorld, cPlayer,             &cWorld::DoWithPlayer>);
+			tolua_function(tolua_S, "DoWithNoteBlockAt",            DoWithBlockEntityAt<cNoteEntity, E_BLOCK_NOTE_BLOCK>);
+			tolua_function(tolua_S, "DoWithPlayer",                 DoWith<cWorld, cPlayer, &cWorld::DoWithPlayer>);
 			tolua_function(tolua_S, "DoWithPlayerByUUID",           tolua_cWorld_DoWithPlayerByUUID);
 			tolua_function(tolua_S, "FastSetBlock",                 tolua_cWorld_FastSetBlock);
-			tolua_function(tolua_S, "FindAndDoWithPlayer",          DoWith<   cWorld, cPlayer,             &cWorld::FindAndDoWithPlayer>);
-			tolua_function(tolua_S, "ForEachBlockEntityInChunk",    ForEachInChunk<cWorld, cBlockEntity,   &cWorld::ForEachBlockEntityInChunk>);
-			tolua_function(tolua_S, "ForEachBrewingstandInChunk",   ForEachInChunk<cWorld, cBrewingstandEntity, &cWorld::ForEachBrewingstandInChunk>);
-			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, "FindAndDoWithPlayer",          DoWith<cWorld, cPlayer, &cWorld::FindAndDoWithPlayer>);
+			tolua_function(tolua_S, "ForEachBlockEntityInChunk",    ForEachBlockEntityInChunk<cBlockEntity>);
+			tolua_function(tolua_S, "ForEachBrewingstandInChunk",   ForEachBlockEntityInChunk<cBrewingstandEntity, E_BLOCK_BREWING_STAND>);
+			tolua_function(tolua_S, "ForEachChestInChunk",          ForEachBlockEntityInChunk<cChestEntity, E_BLOCK_CHEST, E_BLOCK_TRAPPED_CHEST>);
+			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",         tolua_cWorld_ForEachEntityInChunk);
+			tolua_function(tolua_S, "ForEachFurnaceInChunk",        ForEachBlockEntityInChunk<cFurnaceEntity, E_BLOCK_FURNACE, E_BLOCK_LIT_FURNACE>);
 			tolua_function(tolua_S, "ForEachLoadedChunk",           tolua_cWorld_ForEachLoadedChunk);
-			tolua_function(tolua_S, "ForEachPlayer",                ForEach<       cWorld, cPlayer,        &cWorld::ForEachPlayer>);
+			tolua_function(tolua_S, "ForEachPlayer",                ForEach<cWorld, cPlayer, &cWorld::ForEachPlayer>);
 			tolua_function(tolua_S, "GetBlock",                     tolua_cWorld_GetBlock);
 			tolua_function(tolua_S, "GetBlockBlockLight",           tolua_cWorld_GetBlockBlockLight);
 			tolua_function(tolua_S, "GetBlockInfo",                 tolua_cWorld_GetBlockInfo);
diff --git a/src/BlockEntities/BedEntity.cpp b/src/BlockEntities/BedEntity.cpp
index 3d7005b12..7f5f90639 100644
--- a/src/BlockEntities/BedEntity.cpp
+++ b/src/BlockEntities/BedEntity.cpp
@@ -56,12 +56,4 @@ void cBedEntity::SendTo(cClientHandle & a_Client)
 void cBedEntity::SetColor(short a_Color)
 {
 	m_Color = a_Color;
-	auto Pos = GetPos();
-
-	// If the bed entity is send immediately, the client (maybe) still has not the bed.
-	// Fix that by delaying the broadcast of the bed entity by a tick:
-	m_World->ScheduleTask(1, [Pos](cWorld & a_World)
-	{
-		a_World.BroadcastBlockEntity(Pos);
-	});
 }
diff --git a/src/BlockEntities/ChestEntity.cpp b/src/BlockEntities/ChestEntity.cpp
index 039d62287..9ede18759 100644
--- a/src/BlockEntities/ChestEntity.cpp
+++ b/src/BlockEntities/ChestEntity.cpp
@@ -146,24 +146,25 @@ bool cChestEntity::UsedBy(cPlayer * a_Player)
 
 void cChestEntity::ScanNeighbours()
 {
-	// Callback for finding neighbouring chest:
-	auto FindNeighbour = [this](cChestEntity & a_Chest)
+	// Callback for finding neighbouring chest.
+	auto FindNeighbour = [this](cBlockEntity & a_BlockEntity)
 	{
-		if (a_Chest.GetBlockType() != m_BlockType)
+		if (a_BlockEntity.GetBlockType() != m_BlockType)
 		{
 			// Neighboring block is not the same type of chest
-			return true;
+			return false;
 		}
-		m_Neighbour = &a_Chest;
-		return false;
+
+		m_Neighbour = static_cast<cChestEntity *>(&a_BlockEntity);
+		return true;
 	};
 
 	// Scan horizontally adjacent blocks for any neighbouring chest of the same type:
 	if (
-		m_World->DoWithChestAt(m_Pos.x - 1, m_Pos.y, m_Pos.z,     FindNeighbour) ||
-		m_World->DoWithChestAt(m_Pos.x + 1, m_Pos.y, m_Pos.z,     FindNeighbour) ||
-		m_World->DoWithChestAt(m_Pos.x,     m_Pos.y, m_Pos.z - 1, FindNeighbour) ||
-		m_World->DoWithChestAt(m_Pos.x,     m_Pos.y, m_Pos.z + 1, FindNeighbour)
+		m_World->DoWithBlockEntityAt(m_Pos.addedX(-1), FindNeighbour) ||
+		m_World->DoWithBlockEntityAt(m_Pos.addedX(+1), FindNeighbour) ||
+		m_World->DoWithBlockEntityAt(m_Pos.addedZ(-1), FindNeighbour) ||
+		m_World->DoWithBlockEntityAt(m_Pos.addedX(+1), FindNeighbour)
 	)
 	{
 		m_Neighbour->m_Neighbour = this;
diff --git a/src/BlockEntities/CommandBlockEntity.cpp b/src/BlockEntities/CommandBlockEntity.cpp
index c1e2cd430..34b0fd5f5 100644
--- a/src/BlockEntities/CommandBlockEntity.cpp
+++ b/src/BlockEntities/CommandBlockEntity.cpp
@@ -43,15 +43,6 @@ bool cCommandBlockEntity::UsedBy(cPlayer * a_Player)
 void cCommandBlockEntity::SetCommand(const AString & a_Cmd)
 {
 	m_Command = a_Cmd;
-
-	/*
-	Vanilla requires that the server send a Block Entity Update after a command has been set
-	Therefore, command blocks don't support on-the-fly (when window is open) updating of a command and therefore...
-	...the following code can't be put in UsedBy just before the window opens
-
-	Just documenting my experience in getting this to work :P
-	*/
-	m_World->BroadcastBlockEntity(GetPos());
 }
 
 
@@ -60,7 +51,6 @@ void cCommandBlockEntity::SetCommand(const AString & a_Cmd)
 
 void cCommandBlockEntity::SetLastOutput(const AString & a_LastOut)
 {
-	m_World->BroadcastBlockEntity(GetPos());
 	m_LastOutput = a_LastOut;
 }
 
@@ -180,7 +170,6 @@ void cCommandBlockEntity::Execute()
 		{
 			// Overwrite field
 			m_CmdBlock->SetLastOutput(cClientHandle::FormatChatPrefix(m_CmdBlock->GetWorld()->ShouldUseChatPrefixes(), "SUCCESS", cChatColor::Green, cChatColor::White) + a_Text);
-			m_CmdBlock->GetWorld()->BroadcastBlockEntity(m_CmdBlock->GetPos());
 		}
 	};
 
diff --git a/src/BlockEntities/MobHeadEntity.cpp b/src/BlockEntities/MobHeadEntity.cpp
index 14773a0f1..72d039e7e 100644
--- a/src/BlockEntities/MobHeadEntity.cpp
+++ b/src/BlockEntities/MobHeadEntity.cpp
@@ -33,7 +33,6 @@ void cMobHeadEntity::SetType(const eMobHeadType & a_Type)
 		m_OwnerUUID = cUUID{};
 	}
 	m_Type = a_Type;
-	m_World->BroadcastBlockEntity(GetPos());
 }
 
 
@@ -43,7 +42,6 @@ void cMobHeadEntity::SetType(const eMobHeadType & a_Type)
 void cMobHeadEntity::SetRotation(eMobHeadRotation a_Rotation)
 {
 	m_Rotation = a_Rotation;
-	m_World->BroadcastBlockEntity(GetPos());
 }
 
 
@@ -70,8 +68,6 @@ void cMobHeadEntity::SetOwner(const cPlayer & a_Owner)
 			break;
 		}
 	}
-
-	m_World->BroadcastBlockEntity(GetPos());
 }
 
 
@@ -89,7 +85,6 @@ void cMobHeadEntity::SetOwner(const cUUID & a_OwnerUUID, const AString & a_Owner
 	m_OwnerName = a_OwnerName;
 	m_OwnerTexture = a_OwnerTexture;
 	m_OwnerTextureSignature = a_OwnerTextureSignature;
-	m_World->BroadcastBlockEntity(GetPos());
 }
 
 
diff --git a/src/BlockEntities/MobSpawnerEntity.cpp b/src/BlockEntities/MobSpawnerEntity.cpp
index 78312edb1..8e5585b89 100644
--- a/src/BlockEntities/MobSpawnerEntity.cpp
+++ b/src/BlockEntities/MobSpawnerEntity.cpp
@@ -70,6 +70,7 @@ bool cMobSpawnerEntity::UsedBy(cPlayer * a_Player)
 		{
 			a_Player->GetInventory().RemoveOneEquippedItem();
 		}
+		m_World->BroadcastBlockEntity(GetPos());
 		FLOGD("Changed monster spawner at {0} to type {1}.", GetPos(), cMonster::MobTypeToString(MonsterType));
 		return true;
 	}
@@ -105,6 +106,7 @@ bool cMobSpawnerEntity::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk)
 	if (m_SpawnDelay <= 0)
 	{
 		SpawnEntity();
+		m_World->BroadcastBlockEntity(GetPos());
 		return true;
 	}
 	else
@@ -121,7 +123,6 @@ bool cMobSpawnerEntity::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk)
 void cMobSpawnerEntity::ResetTimer(void)
 {
 	m_SpawnDelay = GetRandomProvider().RandInt<short>(m_MinSpawnDelay, m_MaxSpawnDelay);
-	m_World->BroadcastBlockEntity(GetPos());
 }
 
 
diff --git a/src/BlockType.h b/src/BlockType.h
index f98d9db82..4814c5a68 100644
--- a/src/BlockType.h
+++ b/src/BlockType.h
@@ -1181,36 +1181,3 @@ extern AString ItemToFullString(const cItem & a_Item);
 extern cItem GetIniItemSet(cIniFile & a_IniFile, const char * a_Section, const char * a_Key, const char * a_Default);
 
 // tolua_end
-
-
-
-
-
-/** Base case for IsOneOf to handle empty template aguments. */
-template <class = void>
-bool IsOneOf(BLOCKTYPE a_BlockType)
-{
-	return false;
-}
-
-
-/** Returns true if a_BlockType is equal to any of the variadic template arguments.
-Some example usage:
-\code
-	IsOneOf<>(E_BLOCK_AIR)                           == false
-	IsOneOf<E_BLOCK_AIR>(E_BLOCK_DIRT)               == false
-	IsOneOf<E_BLOCK_AIR, E_BLOCK_DIRT>(E_BLOCK_DIRT) == true
-\endcode
-The implementation is ugly but it is equivalent to this C++17 fold expression:
-\code
-	((a_BlockType == Types) || ...)
-\endcode
-Just written to be valid without fold expressions or SFINAE. */
-template <BLOCKTYPE Head, BLOCKTYPE ... Tail>
-bool IsOneOf(BLOCKTYPE a_BlockType)
-{
-	return ((a_BlockType == Head) || (IsOneOf<Tail...>(a_BlockType)));
-}
-
-
-
diff --git a/src/Blocks/BlockBed.cpp b/src/Blocks/BlockBed.cpp
index 58ff720c8..4fd3eba54 100644
--- a/src/Blocks/BlockBed.cpp
+++ b/src/Blocks/BlockBed.cpp
@@ -158,12 +158,12 @@ bool cBlockBedHandler::OnUse(
 
 void cBlockBedHandler::OnPlacedByPlayer(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer & a_Player, const sSetBlock & a_BlockChange) const
 {
-	a_Player.GetWorld()->DoWithBedAt(a_BlockChange.GetX(), a_BlockChange.GetY(), a_BlockChange.GetZ(), [&](cBedEntity & a_Bed)
-		{
-			a_Bed.SetColor(a_Player.GetEquippedItem().m_ItemDamage);
-			return true;
-		}
-	);
+	a_Player.GetWorld()->DoWithBlockEntityAt(a_BlockChange.GetAbsolutePos(), [&a_Player](cBlockEntity & a_BlockEntity)
+	{
+		ASSERT(a_BlockEntity.GetBlockType() == E_BLOCK_BED);
+		static_cast<cBedEntity &>(a_BlockEntity).SetColor(a_Player.GetEquippedItem().m_ItemDamage);
+		return false;
+	});
 }
 
 
diff --git a/src/Blocks/BlockEnchantingTable.h b/src/Blocks/BlockEnchantingTable.h
index c921d8f27..33d7092e3 100644
--- a/src/Blocks/BlockEnchantingTable.h
+++ b/src/Blocks/BlockEnchantingTable.h
@@ -32,7 +32,7 @@ private:
 	) const override
 	{
 		AString WindowName = "Enchant";
-		a_WorldInterface.DoWithBlockEntityAt(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, [&WindowName](cBlockEntity & a_Entity)
+		a_WorldInterface.DoWithBlockEntityAt(a_BlockPos, [&WindowName](cBlockEntity & a_Entity)
 		{
 			if (a_Entity.GetBlockType() != E_BLOCK_ENCHANTMENT_TABLE)
 			{
@@ -46,7 +46,7 @@ private:
 				WindowName = CustomName;
 			}
 
-			return true;
+			return false;
 		});
 
 		cWindow * Window = new cEnchantingWindow(a_BlockPos, std::move(WindowName));
diff --git a/src/Blocks/BlockNoteBlock.h b/src/Blocks/BlockNoteBlock.h
index ac1ab7238..566b9bef5 100644
--- a/src/Blocks/BlockNoteBlock.h
+++ b/src/Blocks/BlockNoteBlock.h
@@ -26,18 +26,15 @@ private:
 		const Vector3i a_BlockPos
 	) const override
 	{
-		a_WorldInterface.DoWithBlockEntityAt(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, [](cBlockEntity & a_BlockEntity)
+		a_WorldInterface.DoWithBlockEntityAt(a_BlockPos, [](cBlockEntity & a_BlockEntity)
 		{
 			if (a_BlockEntity.GetBlockType() != E_BLOCK_NOTE_BLOCK)
 			{
 				return false;
 			}
 
-			auto & NoteEntity = static_cast<cNoteEntity &>(a_BlockEntity);
-
-			NoteEntity.MakeSound();
-
-			return true;
+			static_cast<cNoteEntity &>(a_BlockEntity).MakeSound();
+			return false;
 		});
 	}
 };
diff --git a/src/Blocks/WorldInterface.h b/src/Blocks/WorldInterface.h
index 2a39ffbc2..4ae3f33c9 100644
--- a/src/Blocks/WorldInterface.h
+++ b/src/Blocks/WorldInterface.h
@@ -4,13 +4,11 @@
 #include "../FunctionRef.h"
 #include "../Mobs/MonsterTypes.h"
 
-class cBedEntity;
 class cBlockEntity;
 class cBroadcastInterface;
 class cItems;
 class cPlayer;
 
-using cBedCallback         = cFunctionRef<bool(cBedEntity   &)>;
 using cBlockEntityCallback = cFunctionRef<bool(cBlockEntity &)>;
 using cPlayerListCallback  = cFunctionRef<bool(cPlayer      &)>;
 using cEntityCallback      = cFunctionRef<bool(cEntity      &)>;
@@ -32,10 +30,8 @@ public:
 
 	virtual void DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_BlockY, double a_BlockZ, bool a_CanCauseFire, eExplosionSource a_Source, void * a_SourceData) = 0;
 
-	virtual bool DoWithBedAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBedCallback a_Callback) = 0;
-
 	/** Calls the callback for the block entity at the specified coords; returns false if there's no block entity at those coords, true if found */
-	virtual bool DoWithBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBlockEntityCallback a_Callback) = 0;
+	virtual bool DoWithBlockEntityAt(Vector3i a_Position, cBlockEntityCallback a_Callback) = 0;
 
 	/** Spawns item pickups for each item in the list. May compress pickups if too many entities: */
 	virtual void SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_FlyAwaySpeed = 1.0, bool IsPlayerCreated = false) = 0;
diff --git a/src/Chunk.cpp b/src/Chunk.cpp
index 161a42512..09b0f0f99 100644
--- a/src/Chunk.cpp
+++ b/src/Chunk.cpp
@@ -12,21 +12,6 @@
 #include "ClientHandle.h"
 #include "Server.h"
 #include "Defines.h"
-#include "BlockEntities/BeaconEntity.h"
-#include "BlockEntities/BedEntity.h"
-#include "BlockEntities/BrewingstandEntity.h"
-#include "BlockEntities/ChestEntity.h"
-#include "BlockEntities/CommandBlockEntity.h"
-#include "BlockEntities/DispenserEntity.h"
-#include "BlockEntities/DropperEntity.h"
-#include "BlockEntities/FlowerPotEntity.h"
-#include "BlockEntities/FurnaceEntity.h"
-#include "BlockEntities/HopperEntity.h"
-#include "BlockEntities/JukeboxEntity.h"
-#include "BlockEntities/MobHeadEntity.h"
-#include "BlockEntities/MobSpawnerEntity.h"
-#include "BlockEntities/NoteEntity.h"
-#include "BlockEntities/SignEntity.h"
 #include "Entities/Pickup.h"
 #include "Item.h"
 #include "Noise/Noise.h"
@@ -468,7 +453,6 @@ void cChunk::WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlock
 			auto clone = be->Clone({posX, posY, posZ});
 			clone->SetWorld(m_World);
 			AddBlockEntity(std::move(clone));
-			m_World->BroadcastBlockEntity({posX, posY, posZ});
 		}
 	}
 }
@@ -789,28 +773,34 @@ void cChunk::MoveEntityToNewChunk(OwnedEntity a_Entity)
 
 void cChunk::BroadcastPendingBlockChanges(void)
 {
-	if (m_PendingSendBlocks.empty())
+	if (const auto PendingBlocksCount = m_PendingSendBlocks.size(); PendingBlocksCount >= 10240)
 	{
-		return;
-	}
-
-	if (m_PendingSendBlocks.size() >= 10240)
-	{
-		// Resend the full chunk
-		for (auto ClientHandle : m_LoadedByClient)
+		// Resend the full chunk:
+		for (const auto ClientHandle : m_LoadedByClient)
 		{
 			m_World->ForceSendChunkTo(m_PosX, m_PosZ, cChunkSender::Priority::Medium, ClientHandle);
 		}
 	}
-	else
+	else if (PendingBlocksCount != 0)
 	{
-		// Only send block changes
-		for (auto ClientHandle : m_LoadedByClient)
+		// Send block changes:
+		for (const auto ClientHandle : m_LoadedByClient)
 		{
 			ClientHandle->SendBlockChanges(m_PosX, m_PosZ, m_PendingSendBlocks);
 		}
 	}
+
+	// Send block entity changes:
+	for (const auto Entity : m_PendingSendBlockEntities)
+	{
+		for (const auto ClientHandle : m_LoadedByClient)
+		{
+			Entity->SendTo(*ClientHandle);
+		}
+	}
+
 	m_PendingSendBlocks.clear();
+	m_PendingSendBlockEntities.clear();
 }
 
 
@@ -823,12 +813,12 @@ void cChunk::CheckBlocks()
 	cBlockInServerPluginInterface PluginInterface(*m_World);
 
 	// Process a limited number of blocks since cBlockHandler::Check may queue more to tick
-	auto Count = m_ToTickBlocks.size();
+	auto Count = m_BlocksToCheck.size();
 
 	while (Count != 0)
 	{
-		const auto Pos = m_ToTickBlocks.front();
-		m_ToTickBlocks.pop();
+		const auto Pos = m_BlocksToCheck.front();
+		m_BlocksToCheck.pop();
 		Count--;
 
 		cBlockHandler::For(GetBlock(Pos)).Check(ChunkInterface, PluginInterface, Pos, *this);
@@ -1265,8 +1255,8 @@ void cChunk::SetBlock(Vector3i a_RelPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_Blo
 {
 	FastSetBlock(a_RelPos, a_BlockType, a_BlockMeta);
 
-	// Tick this block's neighbors via cBlockHandler::Check:
-	m_ToTickBlocks.push(a_RelPos);
+	// Queue a check of this block's neighbors:
+	m_BlocksToCheck.push(a_RelPos);
 
 	// Wake up the simulators for this block:
 	GetWorld()->GetSimulatorManager()->WakeUp(*this, a_RelPos);
@@ -1370,22 +1360,26 @@ void cChunk::FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockT
 
 void cChunk::SendBlockTo(int a_RelX, int a_RelY, int a_RelZ, cClientHandle * a_Client)
 {
+	const auto BlockEntity = GetBlockEntityRel({ a_RelX, a_RelY, a_RelZ });
 
 	if (a_Client == nullptr)
 	{
-		// Queue the block for all clients in the chunk (will be sent in Tick())
+		// Queue the block (entity) for all clients in the chunk (will be sent in BroadcastPendingBlockChanges()):
 		m_PendingSendBlocks.emplace_back(m_PosX, m_PosZ, a_RelX, a_RelY, a_RelZ, GetBlock(a_RelX, a_RelY, a_RelZ), GetMeta(a_RelX, a_RelY, a_RelZ));
+		if (BlockEntity != nullptr)
+		{
+			m_PendingSendBlockEntities.push_back(BlockEntity);
+		}
 		return;
 	}
 
-	Vector3i wp = PositionToWorldPosition(a_RelX, a_RelY, a_RelZ);
-	a_Client->SendBlockChange(wp.x, wp.y, wp.z, GetBlock(a_RelX, a_RelY, a_RelZ), GetMeta(a_RelX, a_RelY, a_RelZ));
+	const auto Position = PositionToWorldPosition(a_RelX, a_RelY, a_RelZ);
+	a_Client->SendBlockChange(Position.x, Position.y, Position.z, GetBlock(a_RelX, a_RelY, a_RelZ), GetMeta(a_RelX, a_RelY, a_RelZ));
 
 	// FS #268 - if a BlockEntity digging is cancelled by a plugin, the entire block entity must be re-sent to the client:
-	cBlockEntity * Block = GetBlockEntity(wp.x, wp.y, wp.z);
-	if (Block != nullptr)
+	if (BlockEntity != nullptr)
 	{
-		Block->SendTo(*a_Client);
+		BlockEntity->SendTo(*a_Client);
 	}
 }
 
@@ -1508,39 +1502,12 @@ void cChunk::SetAreaBiome(int a_MinRelX, int a_MaxRelX, int a_MinRelZ, int a_Max
 
 
 
-bool cChunk::SetSignLines(int a_PosX, int a_PosY, int a_PosZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4)
-{
-	// Also sends update packets to all clients in the chunk
-	auto Entity = GetBlockEntity(a_PosX, a_PosY, a_PosZ);
-	if (Entity == nullptr)
-	{
-		return false;  // Not a block entity
-	}
-	if (
-		(Entity->GetBlockType() != E_BLOCK_WALLSIGN) &&
-		(Entity->GetBlockType() != E_BLOCK_SIGN_POST)
-	)
-	{
-		return false;  // Not a sign
-	}
-
-	MarkDirty();
-	auto Sign = static_cast<cSignEntity *>(Entity);
-	Sign->SetLines(a_Line1, a_Line2, a_Line3, a_Line4);
-	m_World->BroadcastBlockEntity({a_PosX, a_PosY, a_PosZ});
-	return true;
-}
-
-
-
-
-
 void cChunk::RemoveBlockEntity(cBlockEntity * a_BlockEntity)
 {
 	MarkDirty();
 	ASSERT(a_BlockEntity != nullptr);
-	auto idx = static_cast<size_t>(cChunkDef::MakeIndex(a_BlockEntity->GetRelX(), a_BlockEntity->GetPosY(), a_BlockEntity->GetRelZ()));
-	m_BlockEntities.erase(idx);
+	m_BlockEntities.erase(static_cast<size_t>(cChunkDef::MakeIndex(a_BlockEntity->GetRelX(), a_BlockEntity->GetPosY(), a_BlockEntity->GetRelZ())));
+	m_PendingSendBlockEntities.erase(std::remove(m_PendingSendBlockEntities.begin(), m_PendingSendBlockEntities.end(), a_BlockEntity), m_PendingSendBlockEntities.end());
 }
 
 
@@ -1745,308 +1712,39 @@ bool cChunk::DoWithEntityByID(UInt32 a_EntityID, cEntityCallback a_Callback, boo
 
 
 
-template <class tyEntity, BLOCKTYPE... tBlocktype>
-bool cChunk::GenericForEachBlockEntity(cFunctionRef<bool(tyEntity &)> a_Callback)
+bool cChunk::ForEachBlockEntity(cBlockEntityCallback a_Callback)
 {
 	// The blockentity list is locked by the parent chunkmap's CS
+
 	for (auto & KeyPair : m_BlockEntities)
 	{
-		cBlockEntity * Block = KeyPair.second.get();
-		if (
-			(sizeof...(tBlocktype) == 0) ||  // Let empty list mean all block entities
-			(IsOneOf<tBlocktype...>(Block->GetBlockType()))
-		)
+		if (a_Callback(*KeyPair.second))
 		{
-			if (a_Callback(*static_cast<tyEntity *>(Block)))
-			{
-				return false;
-			}
+			return false;
 		}
-	}  // for KeyPair - m_BlockEntitites[]
-	return true;
-}
-
-
-
-
-
-bool cChunk::ForEachBlockEntity(cBlockEntityCallback a_Callback)
-{
-	return GenericForEachBlockEntity<cBlockEntity>(a_Callback);
-}
-
-
-
-
-
-bool cChunk::ForEachBrewingstand(cBrewingstandCallback a_Callback)
-{
-	return GenericForEachBlockEntity<cBrewingstandEntity,
-		E_BLOCK_BREWING_STAND
-	>(a_Callback);
-}
-
-
-
-
-
-bool cChunk::ForEachChest(cChestCallback a_Callback)
-{
-	return GenericForEachBlockEntity<cChestEntity,
-		E_BLOCK_CHEST
-	>(a_Callback);
-}
-
-
-
-
-
-bool cChunk::ForEachDispenser(cDispenserCallback a_Callback)
-{
-	return GenericForEachBlockEntity<cDispenserEntity,
-		E_BLOCK_DISPENSER
-	>(a_Callback);
-}
-
-
-
-
-
-bool cChunk::ForEachDropper(cDropperCallback a_Callback)
-{
-	return GenericForEachBlockEntity<cDropperEntity,
-		E_BLOCK_DROPPER
-	>(a_Callback);
-}
-
-
-
-
-
-bool cChunk::ForEachDropSpenser(cDropSpenserCallback a_Callback)
-{
-	return GenericForEachBlockEntity<cDropSpenserEntity,
-		E_BLOCK_DISPENSER,
-		E_BLOCK_DROPPER
-	>(a_Callback);
-}
-
-
-
-
-
-bool cChunk::ForEachFurnace(cFurnaceCallback a_Callback)
-{
-	return GenericForEachBlockEntity<cFurnaceEntity,
-		E_BLOCK_FURNACE,
-		E_BLOCK_LIT_FURNACE
-	>(a_Callback);
-}
-
-
-
-
-
-template <class tyEntity, BLOCKTYPE... tBlocktype>
-bool cChunk::GenericDoWithBlockEntityAt(Vector3i a_Position, cFunctionRef<bool(tyEntity &)> a_Callback)
-{
-	// The blockentity list is locked by the parent chunkmap's CS
-	cBlockEntity * Block = GetBlockEntityRel(a_Position);
-	if (Block == nullptr)
-	{
-		return false;  // No block entity here
 	}
-	if (
-		(sizeof...(tBlocktype) != 0) &&  // Let empty list mean all block entities
-		(!IsOneOf<tBlocktype...>(Block->GetBlockType()))
-	)
-	{
-		return false;  // Not any of the given tBlocktypes
-	}
-	return !a_Callback(*static_cast<tyEntity *>(Block));
-}
-
 
-
-
-
-bool cChunk::DoWithBlockEntityAt(Vector3i a_Position, cBlockEntityCallback a_Callback)
-{
-	return GenericDoWithBlockEntityAt<cBlockEntity>(a_Position, a_Callback);
-}
-
-
-
-
-
-bool cChunk::DoWithBeaconAt(Vector3i a_Position, cBeaconCallback a_Callback)
-{
-	return GenericDoWithBlockEntityAt<cBeaconEntity,
-		E_BLOCK_BEACON
-	>(a_Position, a_Callback);
-}
-
-
-
-
-
-bool cChunk::DoWithBedAt(Vector3i a_Position, cBedCallback a_Callback)
-{
-	return GenericDoWithBlockEntityAt<cBedEntity,
-		E_BLOCK_BED
-	>(a_Position, a_Callback);
-}
-
-
-
-
-
-bool cChunk::DoWithBrewingstandAt(Vector3i a_Position, cBrewingstandCallback a_Callback)
-{
-	return GenericDoWithBlockEntityAt<cBrewingstandEntity,
-		E_BLOCK_BREWING_STAND
-	>(a_Position, a_Callback);
-}
-
-
-
-
-
-bool cChunk::DoWithChestAt(Vector3i a_Position, cChestCallback a_Callback)
-{
-	return GenericDoWithBlockEntityAt<cChestEntity,
-		E_BLOCK_CHEST,
-		E_BLOCK_TRAPPED_CHEST
-	>(a_Position, a_Callback);
-}
-
-
-
-
-
-bool cChunk::DoWithDispenserAt(Vector3i a_Position, cDispenserCallback a_Callback)
-{
-	return GenericDoWithBlockEntityAt<cDispenserEntity,
-		E_BLOCK_DISPENSER
-	>(a_Position, a_Callback);
-}
-
-
-
-
-
-bool cChunk::DoWithDropperAt(Vector3i a_Position, cDropperCallback a_Callback)
-{
-	return GenericDoWithBlockEntityAt<cDropperEntity,
-		E_BLOCK_DROPPER
-	>(a_Position, a_Callback);
-}
-
-
-
-
-
-bool cChunk::DoWithDropSpenserAt(Vector3i a_Position, cDropSpenserCallback a_Callback)
-{
-	return GenericDoWithBlockEntityAt<cDropSpenserEntity,
-		E_BLOCK_DISPENSER,
-		E_BLOCK_DROPPER
-	>(a_Position, a_Callback);
-}
-
-
-
-
-
-bool cChunk::DoWithFurnaceAt(Vector3i a_Position, cFurnaceCallback a_Callback)
-{
-	return GenericDoWithBlockEntityAt<cFurnaceEntity,
-		E_BLOCK_FURNACE,
-		E_BLOCK_LIT_FURNACE
-	>(a_Position, a_Callback);
-}
-
-
-
-
-
-bool cChunk::DoWithHopperAt(Vector3i a_Position, cHopperCallback a_Callback)
-{
-	return GenericDoWithBlockEntityAt<cHopperEntity,
-		E_BLOCK_HOPPER
-	>(a_Position, a_Callback);
-}
-
-
-
-
-
-bool cChunk::DoWithNoteBlockAt(Vector3i a_Position, cNoteBlockCallback a_Callback)
-{
-	return GenericDoWithBlockEntityAt<cNoteEntity,
-		E_BLOCK_NOTE_BLOCK
-	>(a_Position, a_Callback);
-}
-
-
-
-
-
-bool cChunk::DoWithCommandBlockAt(Vector3i a_Position, cCommandBlockCallback a_Callback)
-{
-	return GenericDoWithBlockEntityAt<cCommandBlockEntity,
-		E_BLOCK_COMMAND_BLOCK
-	>(a_Position, a_Callback);
-}
-
-
-
-
-
-bool cChunk::DoWithMobHeadAt(Vector3i a_Position, cMobHeadCallback a_Callback)
-{
-	return GenericDoWithBlockEntityAt<cMobHeadEntity,
-		E_BLOCK_HEAD
-	>(a_Position, a_Callback);
-}
-
-
-
-
-
-bool cChunk::DoWithFlowerPotAt(Vector3i a_Position, cFlowerPotCallback a_Callback)
-{
-	return GenericDoWithBlockEntityAt<cFlowerPotEntity,
-		E_BLOCK_FLOWER_POT
-	>(a_Position, a_Callback);
+	return true;
 }
 
 
 
 
 
-bool cChunk::GetSignLines(Vector3i a_Position, AString & a_Line1, AString & a_Line2, AString & a_Line3, AString & a_Line4)
+bool cChunk::DoWithBlockEntityAt(Vector3i a_Position, cBlockEntityCallback a_Callback)
 {
 	// The blockentity list is locked by the parent chunkmap's CS
-	auto Entity = GetBlockEntity(a_Position);
-	if (Entity == nullptr)
-	{
-		return false;  // Not a block entity
-	}
-	if (
-		(Entity->GetBlockType() != E_BLOCK_WALLSIGN) &&
-		(Entity->GetBlockType() != E_BLOCK_SIGN_POST)
-	)
+
+	const auto BlockEntity = GetBlockEntityRel(a_Position);
+	if (BlockEntity == nullptr)
 	{
-		return false;  // Not a sign
+		return false;  // No block entity here
 	}
 
-	auto Sign = static_cast<cSignEntity *>(Entity);
-	a_Line1 = Sign->GetLine(0);
-	a_Line2 = Sign->GetLine(1);
-	a_Line3 = Sign->GetLine(2);
-	a_Line4 = Sign->GetLine(3);
-	return true;
+	const bool Result = a_Callback(*BlockEntity);
+	m_PendingSendBlockEntities.push_back(BlockEntity);
+	MarkDirty();
+	return Result;
 }
 
 
diff --git a/src/Chunk.h b/src/Chunk.h
index ce735df8e..c51794d24 100644
--- a/src/Chunk.h
+++ b/src/Chunk.h
@@ -2,7 +2,6 @@
 #pragma once
 
 #include "BlockEntities/BlockEntity.h"
-#include "Entities/Entity.h"
 #include "ChunkData.h"
 
 #include "Simulator/FireSimulator.h"
@@ -19,19 +18,8 @@ class cWorld;
 class cClientHandle;
 class cPlayer;
 class cChunkMap;
-class cBeaconEntity;
-class cBedEntity;
-class cBrewingstandEntity;
 class cBoundingBox;
-class cChestEntity;
 class cChunkDataCallback;
-class cCommandBlockEntity;
-class cDispenserEntity;
-class cFurnaceEntity;
-class cHopperEntity;
-class cNoteEntity;
-class cMobHeadEntity;
-class cFlowerPotEntity;
 class cBlockArea;
 class cBlockArea;
 class cFluidSimulatorData;
@@ -212,9 +200,6 @@ public:
 	Sends the chunk to all relevant clients. */
 	void SetAreaBiome(int a_MinRelX, int a_MaxRelX, int a_MinRelZ, int a_MaxRelZ, EMCSBiome a_Biome);
 
-	/** Sets the sign text. Returns true if successful. Also sends update packets to all clients in the chunk */
-	bool SetSignLines(int a_RelX, int a_RelY, int a_RelZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4);
-
 	int GetHeight( int a_X, int a_Z) const;
 
 	/** Returns true if it is sunny at the specified location. This takes into account biomes. */
@@ -259,84 +244,12 @@ public:
 	/** 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(UInt32 a_EntityID, cEntityCallback a_Callback, bool & a_CallbackResult) const;  // Lua-accessible
 
-	/** Calls the callback for each tyEntity; returns true if all block entities processed, false if the callback aborted by returning true
-	tBlocktypes are all blocktypes convertible to tyEntity which are to be called. If no block type is given the callback is called for every block entity
-	Accessible only from within Chunk.cpp */
-	template <class tyEntity, BLOCKTYPE... tBlocktype>
-	bool GenericForEachBlockEntity(cFunctionRef<bool(tyEntity &)> a_Callback);
-
 	/** Calls the callback for each block entity; returns true if all block entities processed, false if the callback aborted by returning true */
 	bool ForEachBlockEntity(cBlockEntityCallback a_Callback);  // Lua-accessible
 
-	/** Calls the callback for each brewingstand; returns true if all brewingstands processed, false if the callback aborted by returning true */
-	bool ForEachBrewingstand(cBrewingstandCallback a_Callback);  // Lua-accessible
-
-	/** Calls the callback for each chest; returns true if all chests processed, false if the callback aborted by returning true */
-	bool ForEachChest(cChestCallback a_Callback);  // Lua-accessible
-
-	/** Calls the callback for each dispenser; returns true if all dispensers processed, false if the callback aborted by returning true */
-	bool ForEachDispenser(cDispenserCallback a_Callback);
-
-	/** Calls the callback for each dropper; returns true if all droppers processed, false if the callback aborted by returning true */
-	bool ForEachDropper(cDropperCallback a_Callback);
-
-	/** Calls the callback for each dropspenser; returns true if all dropspensers processed, false if the callback aborted by returning true */
-	bool ForEachDropSpenser(cDropSpenserCallback a_Callback);
-
-	/** Calls the callback for each furnace; returns true if all furnaces processed, false if the callback aborted by returning true */
-	bool ForEachFurnace(cFurnaceCallback a_Callback);  // Lua-accessible
-
-	/** Calls the callback for the tyEntity at the specified coords; returns false if there's no such block entity at those coords, true if found
-	tBlocktype is a list of the blocktypes to be called. If no BLOCKTYPE template arguments are given the callback is called for any block entity
-	Accessible only from within Chunk.cpp */
-	template <class tyEntity, BLOCKTYPE... tBlocktype>
-	bool GenericDoWithBlockEntityAt(Vector3i a_Position, cFunctionRef<bool(tyEntity &)> a_Callback);
-
-	/** Calls the callback for the block entity at the specified coords; returns false if there's no block entity at those coords, true if found */
+	/** Calls the callback for the block entity at the specified coords; returns false if there's no block entity at those coords, and whatever the callback returns if found. */
 	bool DoWithBlockEntityAt(Vector3i a_Position, cBlockEntityCallback a_Callback);  // Lua-acessible
 
-	/** Calls the callback for the beacon at the specified coords; returns false if there's no beacon at those coords, true if found */
-	bool DoWithBeaconAt(Vector3i a_Position, cBeaconCallback a_Callback);  // Lua-acessible
-
-	/** Calls the callback for the brewingstand at the specified coords; returns false if there's no brewingstand at those coords, true if found */
-	bool DoWithBrewingstandAt(Vector3i a_Position, cBrewingstandCallback a_Callback);  // Lua-acessible
-
-	/** Calls the callback for the bed at the specified coords; returns false if there's no bed at those coords, true if found */
-	bool DoWithBedAt(Vector3i a_Position, cBedCallback a_Callback);  // Lua-acessible
-
-	/** Calls the callback for the chest at the specified coords; returns false if there's no chest at those coords, true if found */
-	bool DoWithChestAt(Vector3i a_Position, cChestCallback a_Callback);  // Lua-acessible
-
-	/** Calls the callback for the dispenser at the specified coords; returns false if there's no dispenser at those coords or callback returns true, returns true if found */
-	bool DoWithDispenserAt(Vector3i a_Position, cDispenserCallback a_Callback);
-
-	/** Calls the callback for the dispenser at the specified coords; returns false if there's no dropper at those coords or callback returns true, returns true if found */
-	bool DoWithDropperAt(Vector3i a_Position, cDropperCallback a_Callback);
-
-	/** Calls the callback for the dispenser at the specified coords; returns false if there's no dropspenser at those coords or callback returns true, returns true if found */
-	bool DoWithDropSpenserAt(Vector3i a_Position, cDropSpenserCallback a_Callback);
-
-	/** Calls the callback for the furnace at the specified coords; returns false if there's no furnace at those coords or callback returns true, returns true if found */
-	bool DoWithFurnaceAt(Vector3i a_Position, cFurnaceCallback a_Callback);  // Lua-accessible
-
-	/** Calls the callback for the hopper at the specified coords; returns false if there's no hopper at those coords or callback returns true, returns true if found */
-	bool DoWithHopperAt(Vector3i a_Position, cHopperCallback a_Callback);  // Lua-accessible
-
-	/** Calls the callback for the noteblock at the specified coords; returns false if there's no noteblock at those coords or callback returns true, returns true if found */
-	bool DoWithNoteBlockAt(Vector3i a_Position, cNoteBlockCallback a_Callback);
-
-	/** Calls the callback for the command block at the specified coords; returns false if there's no command block at those coords or callback returns true, returns true if found */
-	bool DoWithCommandBlockAt(Vector3i a_Position, cCommandBlockCallback a_Callback);
-
-	/** Calls the callback for the mob head block at the specified coords; returns false if there's no mob head block at those coords or callback returns true, returns true if found */
-	bool DoWithMobHeadAt(Vector3i a_Position, cMobHeadCallback a_Callback);
-
-	/** Calls the callback for the flower pot at the specified coords; returns false if there's no flower pot at those coords or callback returns true, returns true if found */
-	bool DoWithFlowerPotAt(Vector3i a_Position, cFlowerPotCallback a_Callback);
-
-	/** Retrieves the test on the sign at the specified coords; returns false if there's no sign at those coords, true if found */
-	bool GetSignLines (Vector3i a_Position, AString & a_Line1, AString & a_Line2, AString & a_Line3, AString & a_Line4);  // Lua-accessible
-
 	/** Use block entity on coordinate.
 	returns true if the use was successful, return false to use the block as a "normal" block */
 	bool UseBlockEntity(cPlayer * a_Player, int a_X, int a_Y, int a_Z);  // [x, y, z] in world block coords
@@ -529,9 +442,9 @@ public:
 	as at least one requests is active the chunk will be ticked). */
 	void SetAlwaysTicked(bool a_AlwaysTicked);
 
-	cChunkClientHandles GetAllClients(void) const
+	const auto & GetAllClients(void) const
 	{
-		return cChunkClientHandles(m_LoadedByClient);
+		return m_LoadedByClient;
 	}
 
 	/** Converts the coord relative to this chunk into an absolute coord.
@@ -570,8 +483,19 @@ private:
 	bool m_IsDirty;        // True if the chunk has changed since it was last saved
 	bool m_IsSaving;       // True if the chunk is being saved
 
-	std::queue<Vector3i>  m_ToTickBlocks;
-	sSetBlockVector       m_PendingSendBlocks;  ///< Blocks that have changed and need to be sent to all clients
+	/** Blocks that have changed and need to be sent to all clients.
+	The protocol has a provision for coalescing block changes, and this is the buffer.
+	It will collect the block changes that occur in a tick, before being flushed in BroadcastPendingSendBlocks. */
+	sSetBlockVector m_PendingSendBlocks;
+
+	/** Block entities that have been touched and need to be sent to all clients.
+	Because block changes are buffered and we need to happen after them, this buffer exists too.
+	Pointers to block entities that were destroyed are guaranteed to be removed from this array by RemoveBlockEntity. */
+	std::vector<cBlockEntity *> m_PendingSendBlockEntities;
+
+	/** A queue of relative positions to call cBlockHandler::Check on.
+	Processed at the end of each tick by CheckBlocks. */
+	std::queue<Vector3i> m_BlocksToCheck;
 
 	// A critical section is not needed, because all chunk access is protected by its parent ChunkMap's csLayers
 	std::vector<cClientHandle *> m_LoadedByClient;
diff --git a/src/ChunkDef.h b/src/ChunkDef.h
index 9e97d53fc..673ae347a 100644
--- a/src/ChunkDef.h
+++ b/src/ChunkDef.h
@@ -98,33 +98,6 @@ public:
 
 
 
-/** Non-owning view of a chunk's client handles. */
-class cChunkClientHandles
-{
-public:
-	using const_iterator = std::vector<cClientHandle *>::const_iterator;
-	using iterator = const_iterator;
-
-	explicit cChunkClientHandles(const std::vector<cClientHandle *> & a_Container):
-		m_Begin(a_Container.cbegin()),
-		m_End(a_Container.cend())
-	{
-	}
-
-	const_iterator begin()  const { return m_Begin; }
-	const_iterator cbegin() const { return m_Begin; }
-
-	const_iterator end()  const { return m_End; }
-	const_iterator cend() const { return m_End; }
-
-private:
-	const_iterator m_Begin, m_End;
-};
-
-
-
-
-
 /** Constants used throughout the code, useful typedefs and utility functions */
 class cChunkDef
 {
diff --git a/src/ChunkMap.cpp b/src/ChunkMap.cpp
index dbd6f8cf3..7bdd1c649 100644
--- a/src/ChunkMap.cpp
+++ b/src/ChunkMap.cpp
@@ -11,7 +11,6 @@
 #include "Generating/Trees.h"  // used in cChunkMap::ReplaceTreeBlocks() for tree block discrimination
 #include "BlockArea.h"
 #include "Bindings/PluginManager.h"
-#include "Entities/TNTEntity.h"
 #include "Blocks/BlockHandler.h"
 #include "MobCensus.h"
 #include "MobSpawner.h"
@@ -20,7 +19,6 @@
 #include "Blocks/ChunkInterface.h"
 #include "Entities/Pickup.h"
 #include "DeadlockDetect.h"
-#include "BlockEntities/BlockEntity.h"
 
 
 
@@ -840,8 +838,8 @@ void cChunkMap::CompareChunkClients(int a_ChunkX1, int a_ChunkZ1, int a_ChunkX2,
 
 void cChunkMap::CompareChunkClients(cChunk * a_Chunk1, cChunk * a_Chunk2, cClientDiffCallback & a_Callback)
 {
-	auto Clients1 = a_Chunk1->GetAllClients();
-	auto Clients2 = a_Chunk2->GetAllClients();
+	const auto & Clients1 = a_Chunk1->GetAllClients();
+	const auto & Clients2 = a_Chunk2->GetAllClients();
 
 	// Find "removed" clients:
 	for (auto * Client : Clients1)
@@ -1074,360 +1072,17 @@ bool cChunkMap::ForEachBlockEntityInChunk(int a_ChunkX, int a_ChunkZ, cBlockEnti
 
 
 
-bool cChunkMap::ForEachBrewingstandInChunk(int a_ChunkX, int a_ChunkZ, cBrewingstandCallback a_Callback)
+bool cChunkMap::DoWithBlockEntityAt(const Vector3i a_Position, cBlockEntityCallback a_Callback)
 {
+	const auto ChunkPosition = cChunkDef::BlockToChunk(a_Position);
+	const auto Relative = cChunkDef::AbsoluteToRelative(a_Position, ChunkPosition);
 	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(a_ChunkX, a_ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->ForEachBrewingstand(a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::ForEachChestInChunk(int a_ChunkX, int a_ChunkZ, cChestCallback a_Callback)
-{
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(a_ChunkX, a_ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->ForEachChest(a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::ForEachDispenserInChunk(int a_ChunkX, int a_ChunkZ, cDispenserCallback a_Callback)
-{
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(a_ChunkX, a_ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->ForEachDispenser(a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::ForEachDropperInChunk(int a_ChunkX, int a_ChunkZ, cDropperCallback a_Callback)
-{
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(a_ChunkX, a_ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->ForEachDropper(a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::ForEachDropSpenserInChunk(int a_ChunkX, int a_ChunkZ, cDropSpenserCallback a_Callback)
-{
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(a_ChunkX, a_ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->ForEachDropSpenser(a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::ForEachFurnaceInChunk(int a_ChunkX, int a_ChunkZ, cFurnaceCallback a_Callback)
-{
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(a_ChunkX, a_ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->ForEachFurnace(a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::DoWithBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBlockEntityCallback a_Callback)
-{
-	int ChunkX, ChunkZ;
-	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
-	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(ChunkX, ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->DoWithBlockEntityAt({ BlockX, BlockY, BlockZ }, a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::DoWithBeaconAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBeaconCallback a_Callback)
-{
-	int ChunkX, ChunkZ;
-	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
-	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(ChunkX, ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->DoWithBeaconAt({ BlockX, BlockY, BlockZ }, a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::DoWithBedAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBedCallback a_Callback)
-{
-	int ChunkX, ChunkZ;
-	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
-	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(ChunkX, ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->DoWithBedAt({ BlockX, BlockY, BlockZ }, a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::DoWithBrewingstandAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBrewingstandCallback a_Callback)
-{
-	int ChunkX, ChunkZ;
-	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
-	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(ChunkX, ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->DoWithBrewingstandAt({ BlockX, BlockY, BlockZ }, a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::DoWithChestAt(int a_BlockX, int a_BlockY, int a_BlockZ, cChestCallback a_Callback)
-{
-	int ChunkX, ChunkZ;
-	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
-	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(ChunkX, ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->DoWithChestAt({ BlockX, BlockY, BlockZ }, a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::DoWithDispenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDispenserCallback a_Callback)
-{
-	int ChunkX, ChunkZ;
-	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
-	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(ChunkX, ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->DoWithDispenserAt({ BlockX, BlockY, BlockZ }, a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::DoWithDropperAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropperCallback a_Callback)
-{
-	int ChunkX, ChunkZ;
-	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
-	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(ChunkX, ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->DoWithDropperAt({ BlockX, BlockY, BlockZ }, a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::DoWithDropSpenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropSpenserCallback a_Callback)
-{
-	int ChunkX, ChunkZ;
-	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
-	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(ChunkX, ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->DoWithDropSpenserAt({ BlockX, BlockY, BlockZ }, a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::DoWithFurnaceAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFurnaceCallback a_Callback)
-{
-	int ChunkX, ChunkZ;
-	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
-	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(ChunkX, ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->DoWithFurnaceAt({ BlockX, BlockY, BlockZ }, a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::DoWithHopperAt(int a_BlockX, int a_BlockY, int a_BlockZ, cHopperCallback a_Callback)
-{
-	int ChunkX, ChunkZ;
-	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
-	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(ChunkX, ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->DoWithHopperAt({ BlockX, BlockY, BlockZ }, a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::DoWithNoteBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cNoteBlockCallback a_Callback)
-{
-	int ChunkX, ChunkZ;
-	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
-	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(ChunkX, ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->DoWithNoteBlockAt({ BlockX, BlockY, BlockZ }, a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cCommandBlockCallback a_Callback)
-{
-	int ChunkX, ChunkZ;
-	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
-	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(ChunkX, ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->DoWithCommandBlockAt({ BlockX, BlockY, BlockZ }, a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::DoWithMobHeadAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadCallback a_Callback)
-{
-	int ChunkX, ChunkZ;
-	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
-	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(ChunkX, ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->DoWithMobHeadAt({ BlockX, BlockY, BlockZ }, a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::DoWithFlowerPotAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFlowerPotCallback a_Callback)
-{
-	int ChunkX, ChunkZ;
-	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
-	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(ChunkX, ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->DoWithFlowerPotAt({ BlockX, BlockY, BlockZ }, a_Callback);
-}
-
-
-
-
-
-bool cChunkMap::GetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, AString & a_Line1, AString & a_Line2, AString & a_Line3, AString & a_Line4)
-{
-	int ChunkX, ChunkZ;
-	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
-	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
-	cCSLock Lock(m_CSChunks);
-	const auto Chunk = FindChunk(ChunkX, ChunkZ);
+	const auto Chunk = FindChunk(ChunkPosition.m_ChunkX, ChunkPosition.m_ChunkZ);
 	if ((Chunk == nullptr) || !Chunk->IsValid())
 	{
 		return false;
 	}
-	return Chunk->GetSignLines({ BlockX, BlockY, BlockZ }, a_Line1, a_Line2, a_Line3, a_Line4);
+	return Chunk->DoWithBlockEntityAt(Relative, a_Callback);
 }
 
 
@@ -1479,23 +1134,6 @@ void cChunkMap::ChunkLoadFailed(int a_ChunkX, int a_ChunkZ)
 
 
 
-bool cChunkMap::SetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4)
-{
-	cCSLock Lock(m_CSChunks);
-	int ChunkX, ChunkZ;
-	cChunkDef::BlockToChunk(a_BlockX, a_BlockZ, ChunkX, ChunkZ);
-	const auto Chunk = FindChunk(ChunkX, ChunkZ);
-	if ((Chunk == nullptr) || !Chunk->IsValid())
-	{
-		return false;
-	}
-	return Chunk->SetSignLines(a_BlockX, a_BlockY, a_BlockZ, a_Line1, a_Line2, a_Line3, a_Line4);
-}
-
-
-
-
-
 void cChunkMap::MarkChunkRegenerating(int a_ChunkX, int a_ChunkZ)
 {
 	cCSLock Lock(m_CSChunks);
diff --git a/src/ChunkMap.h b/src/ChunkMap.h
index 99a1d764d..d0aeb867c 100644
--- a/src/ChunkMap.h
+++ b/src/ChunkMap.h
@@ -18,19 +18,6 @@ class cItems;
 class cChunkStay;
 class cChunk;
 class cPlayer;
-class cBeaconEntity;
-class cBedEntity;
-class cBrewingstandEntity;
-class cChestEntity;
-class cDispenserEntity;
-class cDropperEntity;
-class cDropSpenserEntity;
-class cFurnaceEntity;
-class cHopperEntity;
-class cNoteEntity;
-class cCommandBlockEntity;
-class cMobHeadEntity;
-class cFlowerPotEntity;
 class cBlockArea;
 class cMobCensus;
 class cMobSpawner;
@@ -40,22 +27,9 @@ class cDeadlockDetect;
 struct SetChunkData;
 
 typedef std::list<cClientHandle *> cClientHandleList;
-using cEntityCallback       = cFunctionRef<bool(cEntity             &)>;
-using cBeaconCallback       = cFunctionRef<bool(cBeaconEntity       &)>;
-using cBedCallback          = cFunctionRef<bool(cBedEntity          &)>;
-using cBlockEntityCallback  = cFunctionRef<bool(cBlockEntity        &)>;
-using cBrewingstandCallback = cFunctionRef<bool(cBrewingstandEntity &)>;
-using cChestCallback        = cFunctionRef<bool(cChestEntity        &)>;
-using cChunkCallback        = cFunctionRef<bool(cChunk              &)>;
-using cDispenserCallback    = cFunctionRef<bool(cDispenserEntity    &)>;
-using cDropperCallback      = cFunctionRef<bool(cDropperEntity      &)>;
-using cDropSpenserCallback  = cFunctionRef<bool(cDropSpenserEntity  &)>;
-using cFurnaceCallback      = cFunctionRef<bool(cFurnaceEntity      &)>;
-using cHopperCallback       = cFunctionRef<bool(cHopperEntity       &)>;
-using cNoteBlockCallback    = cFunctionRef<bool(cNoteEntity         &)>;
-using cCommandBlockCallback = cFunctionRef<bool(cCommandBlockEntity &)>;
-using cMobHeadCallback      = cFunctionRef<bool(cMobHeadEntity      &)>;
-using cFlowerPotCallback    = cFunctionRef<bool(cFlowerPotEntity    &)>;
+using cChunkCallback        = cFunctionRef<bool(cChunk       &)>;
+using cEntityCallback       = cFunctionRef<bool(cEntity      &)>;
+using cBlockEntityCallback  = cFunctionRef<bool(cBlockEntity &)>;
 
 
 
@@ -228,88 +202,9 @@ public:
 	Returns true if all block entities processed, false if the callback aborted by returning true. */
 	bool ForEachBlockEntityInChunk(int a_ChunkX, int a_ChunkZ, cBlockEntityCallback a_Callback);  // Lua-accessible
 
-	/** Calls the callback for brewingstand in the specified chunk.
-	Returns true if all brewingstands processed, false if the callback aborted by returning true. */
-	bool ForEachBrewingstandInChunk(int a_ChunkX, int a_ChunkZ, cBrewingstandCallback a_Callback);  // Lua-accessible
-
-	/** Calls the callback for each chest in the specified chunk.
-	Returns true if all chests processed, false if the callback aborted by returning true. */
-	bool ForEachChestInChunk(int a_ChunkX, int a_ChunkZ, cChestCallback a_Callback);  // Lua-accessible
-
-	/** Calls the callback for each dispenser in the specified chunk.
-	Returns true if all dispensers processed, false if the callback aborted by returning true. */
-	bool ForEachDispenserInChunk(int a_ChunkX, int a_ChunkZ, cDispenserCallback a_Callback);
-
-	/** Calls the callback for each dropper in the specified chunk.
-	Returns true if all droppers processed, false if the callback aborted by returning true. */
-	bool ForEachDropperInChunk(int a_ChunkX, int a_ChunkZ, cDropperCallback a_Callback);
-
-	/** Calls the callback for each dropspenser in the specified chunk.
-	Returns true if all dropspensers processed, false if the callback aborted by returning true. */
-	bool ForEachDropSpenserInChunk(int a_ChunkX, int a_ChunkZ, cDropSpenserCallback a_Callback);
-
-	/** Calls the callback for each furnace in the specified chunk.
-	Returns true if all furnaces processed, false if the callback aborted by returning true. */
-	bool ForEachFurnaceInChunk(int a_ChunkX, int a_ChunkZ, cFurnaceCallback a_Callback);  // Lua-accessible
-
 	/** Calls the callback for the block entity at the specified coords.
-	Returns false if there's no block entity at those coords, true if found. */
-	bool DoWithBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBlockEntityCallback a_Callback);  // Lua-acessible
-
-	/** Calls the callback for the beacon at the specified coords.
-	Returns false if there's no beacon at those coords, true if found. */
-	bool DoWithBeaconAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBeaconCallback a_Callback);  // Lua-acessible
-
-	/** Calls the callback for the bed at the specified coords.
-	Returns false if there's no bed at those coords, true if found. */
-	bool DoWithBedAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBedCallback a_Callback);  // Lua-acessible
-
-	/** Calls the callback for the brewingstand at the specified coords; returns false if there's no brewingstand at those coords, true if found */
-	bool DoWithBrewingstandAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBrewingstandCallback a_Callback);  // Lua-acessible
-
-	/** Calls the callback for the chest at the specified coords.
-	Returns false if there's no chest at those coords, true if found. */
-	bool DoWithChestAt(int a_BlockX, int a_BlockY, int a_BlockZ, cChestCallback a_Callback);  // Lua-acessible
-
-	/** Calls the callback for the dispenser at the specified coords.
-	Returns false if there's no dispenser at those coords or callback returns true, returns true if found. */
-	bool DoWithDispenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDispenserCallback a_Callback);  // Lua-accessible
-
-	/** Calls the callback for the dropper at the specified coords.
-	Returns false if there's no dropper at those coords or callback returns true, returns true if found. */
-	bool DoWithDropperAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropperCallback a_Callback);  // Lua-accessible
-
-	/** Calls the callback for the dropspenser at the specified coords.
-	Returns false if there's no dropspenser at those coords or callback returns true, returns true if found. */
-	bool DoWithDropSpenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropSpenserCallback a_Callback);  // Lua-accessible
-
-	/** Calls the callback for the furnace at the specified coords.
-	Returns false if there's no furnace at those coords or callback returns true, returns true if found. */
-	bool DoWithFurnaceAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFurnaceCallback a_Callback);  // Lua-accessible
-
-	/** Calls the callback for the hopper at the specified coords.
-	Returns false if there's no hopper at those coords or callback returns true, returns true if found. */
-	bool DoWithHopperAt(int a_BlockX, int a_BlockY, int a_BlockZ, cHopperCallback a_Callback);  // Lua-accessible
-
-	/** Calls the callback for the noteblock at the specified coords.
-	Returns false if there's no noteblock at those coords or callback returns true, returns true if found. */
-	bool DoWithNoteBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cNoteBlockCallback a_Callback);  // Lua-accessible
-
-	/** Calls the callback for the command block at the specified coords.
-	Returns false if there's no command block at those coords or callback returns true, returns true if found. */
-	bool DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cCommandBlockCallback a_Callback);  // Lua-accessible
-
-	/** Calls the callback for the mob head block at the specified coords.
-	Returns false if there's no mob head block at those coords or callback returns true, returns true if found. */
-	bool DoWithMobHeadAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadCallback a_Callback);  // Lua-accessible
-
-	/** Calls the callback for the flower pot at the specified coords.
-	Returns false if there's no flower pot at those coords or callback returns true, returns true if found. */
-	bool DoWithFlowerPotAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFlowerPotCallback a_Callback);  // Lua-accessible
-
-	/** Retrieves the test on the sign at the specified coords.
-	Returns false if there's no sign at those coords, true if found. */
-	bool GetSignLines (int a_BlockX, int a_BlockY, int a_BlockZ, AString & a_Line1, AString & a_Line2, AString & a_Line3, AString & a_Line4);  // Lua-accessible
+	Returns false if there's no block entity at those coords, and whatever the callback returns if found. */
+	bool DoWithBlockEntityAt(Vector3i a_Position, cBlockEntityCallback a_Callback);  // Lua-acessible
 
 	/** Queues the chunk for preparing - making sure that it's generated and lit.
 	The specified chunk is queued to be loaded or generated, and lit if needed.
@@ -324,9 +219,6 @@ public:
 	/** Marks the chunk as failed-to-load */
 	void ChunkLoadFailed(int a_ChunkX, int a_ChunkZ);
 
-	/** Sets the sign text. Returns true if sign text changed. */
-	bool SetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4);
-
 	/** Marks the chunk as being regenerated - all its clients want that chunk again (used by cWorld::RegenerateChunk()) */
 	void MarkChunkRegenerating(int a_ChunkX, int a_ChunkZ);
 
diff --git a/src/ChunkSender.cpp b/src/ChunkSender.cpp
index 2ab9a5a4d..1fa74977f 100644
--- a/src/ChunkSender.cpp
+++ b/src/ChunkSender.cpp
@@ -121,7 +121,7 @@ void cChunkSender::QueueSendChunkTo(int a_ChunkX, int a_ChunkZ, Priority a_Prior
 
 
 
-void cChunkSender::QueueSendChunkTo(int a_ChunkX, int a_ChunkZ, Priority a_Priority, cChunkClientHandles a_Clients)
+void cChunkSender::QueueSendChunkTo(int a_ChunkX, int a_ChunkZ, Priority a_Priority, const std::vector<cClientHandle *> & a_Clients)
 {
 	{
 		cChunkCoords Chunk{a_ChunkX, a_ChunkZ};
diff --git a/src/ChunkSender.h b/src/ChunkSender.h
index 7fe47c360..75d261af5 100644
--- a/src/ChunkSender.h
+++ b/src/ChunkSender.h
@@ -72,7 +72,7 @@ public:
 
 	/** Queues a chunk to be sent to a specific client */
 	void QueueSendChunkTo(int a_ChunkX, int a_ChunkZ, Priority a_Priority, cClientHandle * a_Client);
-	void QueueSendChunkTo(int a_ChunkX, int a_ChunkZ, Priority a_Priority, cChunkClientHandles a_Client);
+	void QueueSendChunkTo(int a_ChunkX, int a_ChunkZ, Priority a_Priority, const std::vector<cClientHandle *> & a_Clients);
 
 protected:
 
diff --git a/src/Items/ItemBanner.h b/src/Items/ItemBanner.h
index 7b9e6d05b..3f082c5a5 100644
--- a/src/Items/ItemBanner.h
+++ b/src/Items/ItemBanner.h
@@ -203,13 +203,15 @@ public:
 		}
 
 		const auto BannerPos = AddFaceDirection(a_ClickedBlockPos, a_ClickedBlockFace);
-		return a_World.DoWithBlockEntityAt(BannerPos.x, BannerPos.y, BannerPos.z, [Color](cBlockEntity & a_BlockEntity)
+		a_World.DoWithBlockEntityAt(BannerPos, [Color](cBlockEntity & a_BlockEntity)
 		{
 			ASSERT((a_BlockEntity.GetBlockType() == E_BLOCK_STANDING_BANNER) || (a_BlockEntity.GetBlockType() == E_BLOCK_WALL_BANNER));
 
 			auto & Banner = static_cast<cBannerEntity &>(a_BlockEntity);
 			Banner.SetBaseColor(Color);
-			return true;
+			return false;
 		});
+
+		return true;
 	}
 };
diff --git a/src/Items/ItemEnchantingTable.h b/src/Items/ItemEnchantingTable.h
index c8eb42cac..12835cb4a 100644
--- a/src/Items/ItemEnchantingTable.h
+++ b/src/Items/ItemEnchantingTable.h
@@ -46,16 +46,12 @@ private:
 		}
 
 		const auto PlacePos = AddFaceDirection(a_ClickedBlockPos, a_ClickedBlockFace);
-		a_World.DoWithBlockEntityAt(PlacePos.x, PlacePos.y, PlacePos.z, [&a_EquippedItem](cBlockEntity & a_Entity)
+		a_World.DoWithBlockEntityAt(PlacePos, [&a_EquippedItem](cBlockEntity & a_Entity)
 		{
-			if (a_Entity.GetBlockType() != E_BLOCK_ENCHANTMENT_TABLE)
-			{
-				return true;
-			}
+			ASSERT(a_Entity.GetBlockType() == E_BLOCK_ENCHANTMENT_TABLE);
 
-			auto & EnchantingTable = static_cast<cEnchantingTableEntity &>(a_Entity);
-			EnchantingTable.SetCustomName(a_EquippedItem.m_CustomName);
-			return true;
+			static_cast<cEnchantingTableEntity &>(a_Entity).SetCustomName(a_EquippedItem.m_CustomName);
+			return false;
 		});
 
 		return true;
diff --git a/src/Items/ItemMobHead.h b/src/Items/ItemMobHead.h
index ef16f6c96..f1e963e1f 100644
--- a/src/Items/ItemMobHead.h
+++ b/src/Items/ItemMobHead.h
@@ -75,26 +75,22 @@ public:
 		auto BlockMeta = static_cast<NIBBLETYPE>(a_ClickedBlockFace);
 
 		// Use a callback to set the properties of the mob head block entity:
-		a_World.DoWithBlockEntityAt(a_PlacePos.x, a_PlacePos.y, a_PlacePos.z, [&](cBlockEntity & a_BlockEntity)
-			{
-				if (a_BlockEntity.GetBlockType() != E_BLOCK_HEAD)
-				{
-					return false;
-				}
-				auto & MobHeadEntity = static_cast<cMobHeadEntity &>(a_BlockEntity);
+		a_World.DoWithBlockEntityAt(a_PlacePos, [&](cBlockEntity & a_BlockEntity)
+		{
+			ASSERT(a_BlockEntity.GetBlockType() == E_BLOCK_HEAD);
 
-				int Rotation = 0;
-				if (BlockMeta == 1)
-				{
-					Rotation = FloorC(a_Player.GetYaw() * 16.0f / 360.0f + 0.5f) & 0x0f;
-				}
+			auto & MobHeadEntity = static_cast<cMobHeadEntity &>(a_BlockEntity);
 
-				MobHeadEntity.SetType(HeadType);
-				MobHeadEntity.SetRotation(static_cast<eMobHeadRotation>(Rotation));
-				MobHeadEntity.GetWorld()->BroadcastBlockEntity(MobHeadEntity.GetPos());
-				return false;
+			int Rotation = 0;
+			if (BlockMeta == 1)
+			{
+				Rotation = FloorC(a_Player.GetYaw() * 16.0f / 360.0f + 0.5f) & 0x0f;
 			}
-		);
+
+			MobHeadEntity.SetType(HeadType);
+			MobHeadEntity.SetRotation(static_cast<eMobHeadRotation>(Rotation));
+			return false;
+		});
 	}
 
 
@@ -243,23 +239,23 @@ public:
 				return false;
 			}
 
-			// If it is a mob head, check the correct head type using the block entity:
-			if (BlockType == E_BLOCK_HEAD)
-			{
-				bool IsWitherHead = false;
-				a_World.DoWithBlockEntityAt(BlockX, BlockY, BlockZ, [&](cBlockEntity & a_Entity)
+			// If it is a mob head, check it's a wither skull using the block entity:
+			if (
+				(BlockType == E_BLOCK_HEAD) &&
+				!a_World.DoWithBlockEntityAt({ BlockX, BlockY, BlockZ }, [&](cBlockEntity & a_BlockEntity)
+				{
+					if (a_BlockEntity.GetBlockType() != E_BLOCK_HEAD)
 					{
-						ASSERT(a_Entity.GetBlockType() == E_BLOCK_HEAD);
-						auto & MobHead = static_cast<cMobHeadEntity &>(a_Entity);
-						IsWitherHead = (MobHead.GetType() == SKULL_TYPE_WITHER);
-						return true;
+						return false;
 					}
-				);
-				if (!IsWitherHead)
-				{
-					return false;
-				}
+
+					return static_cast<cMobHeadEntity &>(a_BlockEntity).GetType() == SKULL_TYPE_WITHER;
+				})
+			)
+			{
+				return false;
 			}
+
 			// Matched, continue checking
 			AirBlocks.emplace_back(BlockX, BlockY, BlockZ, E_BLOCK_AIR, 0);
 		}  // for i - a_Image
diff --git a/src/Mobs/Path.cpp b/src/Mobs/Path.cpp
index 378051163..e9c4e6ca7 100644
--- a/src/Mobs/Path.cpp
+++ b/src/Mobs/Path.cpp
@@ -2,6 +2,7 @@
 #include "Globals.h"
 
 #include "Path.h"
+#include "BlockType.h"
 #include "../BlockInfo.h"
 #include "../Chunk.h"
 
diff --git a/src/Mobs/PathFinder.cpp b/src/Mobs/PathFinder.cpp
index 423c4a0c6..9e63b7362 100644
--- a/src/Mobs/PathFinder.cpp
+++ b/src/Mobs/PathFinder.cpp
@@ -1,5 +1,6 @@
 #include "Globals.h"
 #include "PathFinder.h"
+#include "BlockType.h"
 #include "../BlockInfo.h"
 #include "../Chunk.h"
 
diff --git a/src/Protocol/Protocol_1_11.cpp b/src/Protocol/Protocol_1_11.cpp
index 15197ad07..db4ed5502 100644
--- a/src/Protocol/Protocol_1_11.cpp
+++ b/src/Protocol/Protocol_1_11.cpp
@@ -30,13 +30,8 @@ Implements the 1.11 protocol classes:
 
 #include "../Mobs/IncludeAllMonsters.h"
 
-#include "../BlockEntities/BannerEntity.h"
-#include "../BlockEntities/BeaconEntity.h"
 #include "../BlockEntities/BedEntity.h"
-#include "../BlockEntities/CommandBlockEntity.h"
-#include "../BlockEntities/MobHeadEntity.h"
 #include "../BlockEntities/MobSpawnerEntity.h"
-#include "../BlockEntities/FlowerPotEntity.h"
 
 #include "../Root.h"
 #include "../Server.h"
diff --git a/src/Protocol/Protocol_1_9.cpp b/src/Protocol/Protocol_1_9.cpp
index 4ebf826bf..0669e6a1a 100644
--- a/src/Protocol/Protocol_1_9.cpp
+++ b/src/Protocol/Protocol_1_9.cpp
@@ -45,13 +45,7 @@ Implements the 1.9 protocol classes:
 #include "../Mobs/IncludeAllMonsters.h"
 #include "../UI/HorseWindow.h"
 
-#include "../BlockEntities/BannerEntity.h"
-#include "../BlockEntities/BeaconEntity.h"
-#include "../BlockEntities/CommandBlockEntity.h"
-#include "../BlockEntities/MobHeadEntity.h"
 #include "../BlockEntities/MobSpawnerEntity.h"
-#include "../BlockEntities/FlowerPotEntity.h"
-#include "../Bindings/PluginManager.h"
 
 
 
diff --git a/src/Simulator/IncrementalRedstoneSimulator/CommandBlockHandler.h b/src/Simulator/IncrementalRedstoneSimulator/CommandBlockHandler.h
index c216d12bc..0a5ffe136 100644
--- a/src/Simulator/IncrementalRedstoneSimulator/CommandBlockHandler.h
+++ b/src/Simulator/IncrementalRedstoneSimulator/CommandBlockHandler.h
@@ -31,9 +31,14 @@ namespace CommandBlockHandler
 			return;
 		}
 
-		a_Chunk.DoWithCommandBlockAt(a_Position, [](cCommandBlockEntity & a_CommandBlock)
+		a_Chunk.DoWithBlockEntityAt(a_Position, [](cBlockEntity & a_BlockEntity)
 		{
-			a_CommandBlock.Activate();
+			if (a_BlockEntity.GetBlockType() != E_BLOCK_COMMAND_BLOCK)
+			{
+				return false;
+			}
+
+			static_cast<cCommandBlockEntity &>(a_BlockEntity).Activate();
 			return false;
 		});
 	}
diff --git a/src/Simulator/IncrementalRedstoneSimulator/DropSpenserHandler.h b/src/Simulator/IncrementalRedstoneSimulator/DropSpenserHandler.h
index 309fa757a..4dd87e972 100644
--- a/src/Simulator/IncrementalRedstoneSimulator/DropSpenserHandler.h
+++ b/src/Simulator/IncrementalRedstoneSimulator/DropSpenserHandler.h
@@ -46,9 +46,14 @@ namespace DropSpenserHandler
 
 		if (IsPoweredNow && !WasPoweredPreviously)
 		{
-			a_Chunk.DoWithDropSpenserAt(a_Position, [](cDropSpenserEntity & a_DropSpenser)
+			a_Chunk.DoWithBlockEntityAt(a_Position, [](cBlockEntity & a_BlockEntity)
 			{
-				a_DropSpenser.Activate();
+				if ((a_BlockEntity.GetBlockType() != E_BLOCK_DISPENSER) && (a_BlockEntity.GetBlockType() != E_BLOCK_DROPPER))
+				{
+					return false;
+				}
+
+				static_cast<cDropSpenserEntity &>(a_BlockEntity).Activate();
 				return false;
 			});
 		}
diff --git a/src/Simulator/IncrementalRedstoneSimulator/HopperHandler.h b/src/Simulator/IncrementalRedstoneSimulator/HopperHandler.h
index 998a98677..379f7c7d8 100644
--- a/src/Simulator/IncrementalRedstoneSimulator/HopperHandler.h
+++ b/src/Simulator/IncrementalRedstoneSimulator/HopperHandler.h
@@ -30,9 +30,14 @@ namespace HopperHandler
 			return;
 		}
 
-		a_Chunk.DoWithHopperAt(a_Position, [Power](cHopperEntity & a_Hopper)
+		a_Chunk.DoWithBlockEntityAt(a_Position, [Power](cBlockEntity & a_BlockEntity)
 		{
-			a_Hopper.SetLocked(Power != 0);
+			if (a_BlockEntity.GetBlockType() != E_BLOCK_HOPPER)
+			{
+				return false;
+			}
+
+			static_cast<cHopperEntity &>(a_BlockEntity).SetLocked(Power != 0);
 			return false;
 		});
 	}
diff --git a/src/Simulator/IncrementalRedstoneSimulator/IncrementalRedstoneSimulator.h b/src/Simulator/IncrementalRedstoneSimulator/IncrementalRedstoneSimulator.h
index e8cd4bf5d..b13d1f6f5 100644
--- a/src/Simulator/IncrementalRedstoneSimulator/IncrementalRedstoneSimulator.h
+++ b/src/Simulator/IncrementalRedstoneSimulator/IncrementalRedstoneSimulator.h
@@ -1,6 +1,7 @@
 
 #pragma once
 
+#include "BlockType.h"
 #include "../RedstoneSimulator.h"
 #include "RedstoneSimulatorChunkData.h"
 
diff --git a/src/Simulator/IncrementalRedstoneSimulator/NoteBlockHandler.h b/src/Simulator/IncrementalRedstoneSimulator/NoteBlockHandler.h
index 6a2f66737..8bd639357 100644
--- a/src/Simulator/IncrementalRedstoneSimulator/NoteBlockHandler.h
+++ b/src/Simulator/IncrementalRedstoneSimulator/NoteBlockHandler.h
@@ -31,9 +31,14 @@ namespace NoteBlockHandler
 			return;
 		}
 
-		a_Chunk.DoWithNoteBlockAt(a_Position, [](cNoteEntity & a_NoteBlock)
+		a_Chunk.DoWithBlockEntityAt(a_Position, [](cBlockEntity & a_BlockEntity)
 		{
-			a_NoteBlock.MakeSound();
+			if (a_BlockEntity.GetBlockType() != E_BLOCK_NOTE_BLOCK)
+			{
+				return false;
+			}
+
+			static_cast<cNoteEntity &>(a_BlockEntity).MakeSound();
 			return false;
 		});
 	}
diff --git a/src/Simulator/IncrementalRedstoneSimulator/RedstoneHandler.cpp b/src/Simulator/IncrementalRedstoneSimulator/RedstoneHandler.cpp
index 63da4c0dc..ab6b35c0b 100644
--- a/src/Simulator/IncrementalRedstoneSimulator/RedstoneHandler.cpp
+++ b/src/Simulator/IncrementalRedstoneSimulator/RedstoneHandler.cpp
@@ -5,6 +5,7 @@
 #include "RedstoneDataHelper.h"
 #include "ForEachSourceCallback.h"
 
+#include "BlockType.h"
 #include "CommandBlockHandler.h"
 #include "DaylightSensorHandler.h"
 #include "DoorHandler.h"
diff --git a/src/Simulator/IncrementalRedstoneSimulator/TrappedChestHandler.h b/src/Simulator/IncrementalRedstoneSimulator/TrappedChestHandler.h
index 619401d80..145c5dc83 100644
--- a/src/Simulator/IncrementalRedstoneSimulator/TrappedChestHandler.h
+++ b/src/Simulator/IncrementalRedstoneSimulator/TrappedChestHandler.h
@@ -22,14 +22,16 @@ namespace TrappedChestHandler
 	static unsigned char GetPowerLevel(cChunk & a_Chunk, Vector3i a_Position)
 	{
 		int NumberOfPlayers = 0;
-		VERIFY(
-			!a_Chunk.DoWithChestAt(a_Position, [&](cChestEntity & a_Chest)
+		a_Chunk.DoWithBlockEntityAt(a_Position, [&NumberOfPlayers](cBlockEntity & a_BlockEntity)
+		{
+			if (a_BlockEntity.GetBlockType() != E_BLOCK_TRAPPED_CHEST)
 			{
-				ASSERT(a_Chest.GetBlockType() == E_BLOCK_TRAPPED_CHEST);
-				NumberOfPlayers = a_Chest.GetNumberOfPlayers();
-				return true;
-			})
-		);
+				return false;
+			}
+
+			NumberOfPlayers = static_cast<cChestEntity &>(a_BlockEntity).GetNumberOfPlayers();
+			return false;
+		});
 
 		return static_cast<unsigned char>(std::min(NumberOfPlayers, 15));
 	}
diff --git a/src/Simulator/VaporizeFluidSimulator.cpp b/src/Simulator/VaporizeFluidSimulator.cpp
index 82f71c03f..6256c8e78 100644
--- a/src/Simulator/VaporizeFluidSimulator.cpp
+++ b/src/Simulator/VaporizeFluidSimulator.cpp
@@ -5,6 +5,7 @@
 
 #include "Globals.h"
 #include "VaporizeFluidSimulator.h"
+#include "BlockType.h"
 #include "../OpaqueWorld.h"
 #include "../Chunk.h"
 #include "../Blocks/BroadcastInterface.h"
diff --git a/src/World.cpp b/src/World.cpp
index 84f8bb9c6..0a03110e2 100644
--- a/src/World.cpp
+++ b/src/World.cpp
@@ -29,7 +29,7 @@
 #include "Entities/TNTEntity.h"
 
 #include "BlockEntities/CommandBlockEntity.h"
-#include "BlockEntities/BeaconEntity.h"
+#include "BlockEntities/SignEntity.h"
 
 // Simulators:
 #include "Simulator/FloodyFluidSimulator.h"
@@ -1342,60 +1342,6 @@ bool cWorld::ForEachBlockEntityInChunk(int a_ChunkX, int a_ChunkZ, cBlockEntityC
 
 
 
-bool cWorld::ForEachBrewingstandInChunk(int a_ChunkX, int a_ChunkZ, cBrewingstandCallback a_Callback)
-{
-	return m_ChunkMap.ForEachBrewingstandInChunk(a_ChunkX, a_ChunkZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::ForEachChestInChunk(int a_ChunkX, int a_ChunkZ, cChestCallback a_Callback)
-{
-	return m_ChunkMap.ForEachChestInChunk(a_ChunkX, a_ChunkZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::ForEachDispenserInChunk(int a_ChunkX, int a_ChunkZ, cDispenserCallback a_Callback)
-{
-	return m_ChunkMap.ForEachDispenserInChunk(a_ChunkX, a_ChunkZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::ForEachDropperInChunk(int a_ChunkX, int a_ChunkZ, cDropperCallback a_Callback)
-{
-	return m_ChunkMap.ForEachDropperInChunk(a_ChunkX, a_ChunkZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::ForEachDropSpenserInChunk(int a_ChunkX, int a_ChunkZ, cDropSpenserCallback a_Callback)
-{
-	return m_ChunkMap.ForEachDropSpenserInChunk(a_ChunkX, a_ChunkZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::ForEachFurnaceInChunk(int a_ChunkX, int a_ChunkZ, cFurnaceCallback a_Callback)
-{
-	return m_ChunkMap.ForEachFurnaceInChunk(a_ChunkX, a_ChunkZ, a_Callback);
-}
-
-
-
-
-
 void cWorld::DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_BlockY, double a_BlockZ, bool a_CanCauseFire, eExplosionSource a_Source, void * a_SourceData)
 {
 	cLock Lock(*this);
@@ -1431,126 +1377,9 @@ void cWorld::DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_Blo
 
 
 
-bool cWorld::DoWithBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBlockEntityCallback a_Callback)
-{
-	return m_ChunkMap.DoWithBlockEntityAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::DoWithBeaconAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBeaconCallback a_Callback)
-{
-	return m_ChunkMap.DoWithBeaconAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::DoWithBedAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBedCallback a_Callback)
-{
-	return m_ChunkMap.DoWithBedAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::DoWithBrewingstandAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBrewingstandCallback a_Callback)
-{
-	return m_ChunkMap.DoWithBrewingstandAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::DoWithChestAt(int a_BlockX, int a_BlockY, int a_BlockZ, cChestCallback a_Callback)
-{
-	return m_ChunkMap.DoWithChestAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::DoWithDispenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDispenserCallback a_Callback)
-{
-	return m_ChunkMap.DoWithDispenserAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::DoWithDropperAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropperCallback a_Callback)
-{
-	return m_ChunkMap.DoWithDropperAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::DoWithDropSpenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropSpenserCallback a_Callback)
-{
-	return m_ChunkMap.DoWithDropSpenserAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::DoWithFurnaceAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFurnaceCallback a_Callback)
+bool cWorld::DoWithBlockEntityAt(const Vector3i a_Position, cBlockEntityCallback a_Callback)
 {
-	return m_ChunkMap.DoWithFurnaceAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::DoWithHopperAt(int a_BlockX, int a_BlockY, int a_BlockZ, cHopperCallback a_Callback)
-{
-	return m_ChunkMap.DoWithHopperAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::DoWithNoteBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cNoteBlockCallback a_Callback)
-{
-	return m_ChunkMap.DoWithNoteBlockAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cCommandBlockCallback a_Callback)
-{
-	return m_ChunkMap.DoWithCommandBlockAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::DoWithMobHeadAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadCallback a_Callback)
-{
-	return m_ChunkMap.DoWithMobHeadAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
-}
-
-
-
-
-
-bool cWorld::DoWithFlowerPotAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFlowerPotCallback a_Callback)
-{
-	return m_ChunkMap.DoWithFlowerPotAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
+	return m_ChunkMap.DoWithBlockEntityAt(a_Position, a_Callback);
 }
 
 
@@ -1559,7 +1388,20 @@ bool cWorld::DoWithFlowerPotAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFlower
 
 bool cWorld::GetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, AString & a_Line1, AString & a_Line2, AString & a_Line3, AString & a_Line4)
 {
-	return m_ChunkMap.GetSignLines(a_BlockX, a_BlockY, a_BlockZ, a_Line1, a_Line2, a_Line3, a_Line4);
+	return DoWithBlockEntityAt({ a_BlockX, a_BlockY, a_BlockZ }, [&a_Line1, &a_Line2, &a_Line3, &a_Line4](cBlockEntity & a_BlockEntity)
+	{
+		if ((a_BlockEntity.GetBlockType() != E_BLOCK_WALLSIGN) && (a_BlockEntity.GetBlockType() != E_BLOCK_SIGN_POST))
+		{
+			return false;  // Not a sign
+		}
+
+		const auto & Sign = static_cast<cSignEntity &>(a_BlockEntity);
+		a_Line1 = Sign.GetLine(0);
+		a_Line2 = Sign.GetLine(1);
+		a_Line3 = Sign.GetLine(2);
+		a_Line4 = Sign.GetLine(3);
+		return true;
+	});
 }
 
 
@@ -2672,6 +2514,8 @@ void cWorld::ChunkLoadFailed(int a_ChunkX, int a_ChunkZ)
 
 bool cWorld::SetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4, cPlayer * a_Player)
 {
+	// TODO: rvalue these strings
+
 	AString Line1(a_Line1);
 	AString Line2(a_Line2);
 	AString Line3(a_Line3);
@@ -2682,7 +2526,18 @@ bool cWorld::SetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, const AStrin
 		return false;
 	}
 
-	if (m_ChunkMap.SetSignLines(a_BlockX, a_BlockY, a_BlockZ, Line1, Line2, Line3, Line4))
+	if (
+		DoWithBlockEntityAt({ a_BlockX, a_BlockY, a_BlockZ }, [&Line1, &Line2, &Line3, &Line4](cBlockEntity & a_BlockEntity)
+		{
+			if ((a_BlockEntity.GetBlockType() != E_BLOCK_WALLSIGN) && (a_BlockEntity.GetBlockType() != E_BLOCK_SIGN_POST))
+			{
+				return false;  // Not a sign
+			}
+
+			static_cast<cSignEntity &>(a_BlockEntity).SetLines(Line1, Line2, Line3, Line4);
+			return true;
+		})
+	)
 	{
 		cRoot::Get()->GetPluginManager()->CallHookUpdatedSign(*this, a_BlockX, a_BlockY, a_BlockZ, Line1, Line2, Line3, Line4, a_Player);
 		return true;
@@ -2697,12 +2552,16 @@ bool cWorld::SetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, const AStrin
 
 bool cWorld::SetCommandBlockCommand(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Command)
 {
-	return DoWithCommandBlockAt(a_BlockX, a_BlockY, a_BlockZ, [&](cCommandBlockEntity & a_CommandBlock)
+	return DoWithBlockEntityAt({ a_BlockX, a_BlockY, a_BlockZ }, [&](cBlockEntity & a_BlockEntity)
+	{
+		if (a_BlockEntity.GetBlockType() != E_BLOCK_COMMAND_BLOCK)
 		{
-			a_CommandBlock.SetCommand(a_Command);
 			return false;
 		}
-	);
+
+		static_cast<cCommandBlockEntity &>(a_BlockEntity).SetCommand(a_Command);
+		return true;
+	});
 }
 
 
diff --git a/src/World.h b/src/World.h
index 0f0ade751..9bb1f8b6b 100644
--- a/src/World.h
+++ b/src/World.h
@@ -615,71 +615,14 @@ public:
 	/** Calls the callback for each block entity in the specified chunk; returns true if all block entities processed, false if the callback aborted by returning true */
 	bool ForEachBlockEntityInChunk(int a_ChunkX, int a_ChunkZ, cBlockEntityCallback a_Callback);  // Exported in ManualBindings.cpp
 
-	/** Calls the callback for each brewingstand in the specified chunk; returns true if all brewingstands processed, false if the callback aborted by returning true */
-	bool ForEachBrewingstandInChunk(int a_ChunkX, int a_ChunkZ, cBrewingstandCallback a_Callback);  // Exported in ManualBindings.cpp
-
-	/** Calls the callback for each chest in the specified chunk; returns true if all chests processed, false if the callback aborted by returning true */
-	bool ForEachChestInChunk(int a_ChunkX, int a_ChunkZ, cChestCallback a_Callback);  // Exported in ManualBindings.cpp
-
-	/** Calls the callback for each dispenser in the specified chunk; returns true if all dispensers processed, false if the callback aborted by returning true */
-	bool ForEachDispenserInChunk(int a_ChunkX, int a_ChunkZ, cDispenserCallback a_Callback);
-
-	/** Calls the callback for each dropper in the specified chunk; returns true if all droppers processed, false if the callback aborted by returning true */
-	bool ForEachDropperInChunk(int a_ChunkX, int a_ChunkZ, cDropperCallback a_Callback);
-
-	/** Calls the callback for each dropspenser in the specified chunk; returns true if all dropspensers processed, false if the callback aborted by returning true */
-	bool ForEachDropSpenserInChunk(int a_ChunkX, int a_ChunkZ, cDropSpenserCallback a_Callback);
-
-	/** Calls the callback for each furnace in the specified chunk; returns true if all furnaces processed, false if the callback aborted by returning true */
-	bool ForEachFurnaceInChunk(int a_ChunkX, int a_ChunkZ, cFurnaceCallback a_Callback);  // Exported in ManualBindings.cpp
-
 	/** Does an explosion with the specified strength at the specified coordinates.
 	Executes the HOOK_EXPLODING and HOOK_EXPLODED hooks as part of the processing.
 	a_SourceData exact type depends on the a_Source, see the declaration of the esXXX constants in Defines.h for details.
 	Exported to Lua manually in ManualBindings_World.cpp in order to support the variable a_SourceData param. */
 	virtual void DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_BlockY, double a_BlockZ, bool a_CanCauseFire, eExplosionSource a_Source, void * a_SourceData) override;
 
-	/** Calls the callback for the block entity at the specified coords; returns false if there's no block entity at those coords, true if found */
-	virtual bool DoWithBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBlockEntityCallback a_Callback) override;  // Exported in ManualBindings.cpp
-
-	/** Calls the callback for the beacon at the specified coords; returns false if there's no beacon at those coords, true if found */
-	bool DoWithBeaconAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBeaconCallback a_Callback);  // Exported in ManualBindings.cpp
-
-	/** Calls the callback for the bed at the specified coords; returns false if there's no bed at those coords, true if found */
-	virtual bool DoWithBedAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBedCallback a_Callback) override;  // Exported in ManualBindings.cpp
-
-	/** Calls the callback for the brewingstand at the specified coords; returns false if there's no brewingstand at those coords, true if found */
-	bool DoWithBrewingstandAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBrewingstandCallback a_Callback);  // Lua-acessible
-
-	/** Calls the callback for the chest at the specified coords; returns false if there's no chest at those coords, true if found */
-	bool DoWithChestAt(int a_BlockX, int a_BlockY, int a_BlockZ, cChestCallback a_Callback);  // Exported in ManualBindings.cpp
-
-	/** Calls the callback for the dispenser at the specified coords; returns false if there's no dispenser at those coords or callback returns true, returns true if found */
-	bool DoWithDispenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDispenserCallback a_Callback);  // Exported in ManualBindings.cpp
-
-	/** Calls the callback for the dropper at the specified coords; returns false if there's no dropper at those coords or callback returns true, returns true if found */
-	bool DoWithDropperAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropperCallback a_Callback);  // Exported in ManualBindings.cpp
-
-	/** Calls the callback for the dropspenser at the specified coords; returns false if there's no dropspenser at those coords or callback returns true, returns true if found */
-	bool DoWithDropSpenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropSpenserCallback a_Callback);  // Exported in ManualBindings.cpp
-
-	/** Calls the callback for the furnace at the specified coords; returns false if there's no furnace at those coords or callback returns true, returns true if found */
-	bool DoWithFurnaceAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFurnaceCallback a_Callback);  // Exported in ManualBindings.cpp
-
-	/** Calls the callback for the hopper at the specified coords; returns false if there's no hopper at those coords or callback returns true, returns true if found */
-	bool DoWithHopperAt(int a_BlockX, int a_BlockY, int a_BlockZ, cHopperCallback a_Callback);  // Exported in ManualBindings.cpp
-
-	/** Calls the callback for the noteblock at the specified coords; returns false if there's no noteblock at those coords or callback returns true, returns true if found */
-	bool DoWithNoteBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cNoteBlockCallback a_Callback);  // Exported in ManualBindings.cpp
-
-	/** Calls the callback for the command block at the specified coords; returns false if there's no command block at those coords or callback returns true, returns true if found */
-	bool DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cCommandBlockCallback a_Callback);  // Exported in ManualBindings.cpp
-
-	/** Calls the callback for the mob head block at the specified coords; returns false if there's no mob head block at those coords or callback returns true, returns true if found */
-	bool DoWithMobHeadAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadCallback a_Callback);  // Exported in ManualBindings.cpp
-
-	/** Calls the callback for the flower pot at the specified coords; returns false if there's no flower pot at those coords or callback returns true, returns true if found */
-	bool DoWithFlowerPotAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFlowerPotCallback a_Callback);  // Exported in ManualBindings.cpp
+	/** Calls the callback for the block entity at the specified coords; returns false if there's no block entity at those coords, and whatever the callback returns if found. */
+	virtual bool DoWithBlockEntityAt(Vector3i a_Position, cBlockEntityCallback a_Callback) override;  // Exported in ManualBindings.cpp
 
 	/** Retrieves the test on the sign at the specified coords; returns false if there's no sign at those coords, true if found */
 	bool GetSignLines (int a_BlockX, int a_BlockY, int a_BlockZ, AString & a_Line1, AString & a_Line2, AString & a_Line3, AString & a_Line4);  // Exported in ManualBindings.cpp