11 files changed, 2234 insertions, 675 deletions

diff --git a/src/Bindings/CMakeLists.txt b/src/Bindings/CMakeLists.txt
index 2614ef9b2..747f22157 100644
--- a/src/Bindings/CMakeLists.txt
+++ b/src/Bindings/CMakeLists.txt
@@ -16,6 +16,7 @@ SET (SRCS
 	LuaUDPEndpoint.cpp
 	LuaWindow.cpp
 	ManualBindings.cpp
+	ManualBindings_BlockArea.cpp
 	ManualBindings_Network.cpp
 	ManualBindings_RankManager.cpp
 	ManualBindings_World.cpp
diff --git a/src/Bindings/LuaState.cpp b/src/Bindings/LuaState.cpp
index 947e337fc..d18b6efcd 100644
--- a/src/Bindings/LuaState.cpp
+++ b/src/Bindings/LuaState.cpp
@@ -1762,6 +1762,30 @@ bool cLuaState::CheckParamEnd(int a_Param)
 
 
 
+bool cLuaState::CheckParamSelf(const char * a_SelfClassName)
+{
+	tolua_Error tolua_err;
+	if (tolua_isusertype(m_LuaState, 1, a_SelfClassName, 0, &tolua_err) && !lua_isnil(m_LuaState, 1))
+	{
+		return true;
+	}
+
+	// Not the correct parameter
+	lua_Debug entry;
+	VERIFY(lua_getstack(m_LuaState, 0,   &entry));
+	VERIFY(lua_getinfo (m_LuaState, "n", &entry));
+	AString ErrMsg = Printf(
+		"Error in function '%s'. The 'self' parameter is not of the expected type, \"instance of %s\". Make sure you're using the correct calling convention (obj:fn() instead of obj.fn()).",
+		(entry.name != nullptr) ? entry.name : "<unknown>", a_SelfClassName
+	);
+	tolua_error(m_LuaState, ErrMsg.c_str(), &tolua_err);
+	return false;
+}
+
+
+
+
+
 bool cLuaState::IsParamUserType(int a_Param, AString a_UserType)
 {
 	ASSERT(IsValid());
diff --git a/src/Bindings/LuaState.h b/src/Bindings/LuaState.h
index 4320ce40e..674c7a240 100644
--- a/src/Bindings/LuaState.h
+++ b/src/Bindings/LuaState.h
@@ -788,6 +788,10 @@ public:
 	/** Returns true if the specified parameter on the stack is nil (indicating an end-of-parameters) */
 	bool CheckParamEnd(int a_Param);
 
+	/** Returns true if the first parameter is an instance of the expected class name.
+	Returns false and logs a special warning ("wrong calling convention") if not. */
+	bool CheckParamSelf(const char * a_SelfClassName);
+
 	bool IsParamUserType(int a_Param, AString a_UserType);
 
 	bool IsParamNumber(int a_Param);
diff --git a/src/Bindings/ManualBindings.cpp b/src/Bindings/ManualBindings.cpp
index d8bd8b023..2c2de6296 100644
--- a/src/Bindings/ManualBindings.cpp
+++ b/src/Bindings/ManualBindings.cpp
@@ -31,7 +31,6 @@
 #include "../BlockEntities/FlowerPotEntity.h"
 #include "../Generating/ChunkDesc.h"
 #include "../LineBlockTracer.h"
-#include "../WorldStorage/SchematicFileSerializer.h"
 #include "../CompositeChat.h"
 #include "../StringCompression.h"
 #include "../CommandOutput.h"
@@ -133,6 +132,46 @@ int cManualBindings::lua_do_error(lua_State * L, const char * a_pFormat, ...)
 
 
 
+int cManualBindings::ApiParamError(lua_State * a_LuaState, const char * a_MsgFormat, ...)
+{
+	// Retrieve current function name
+	lua_Debug entry;
+	VERIFY(lua_getstack(a_LuaState, 0, &entry));
+	VERIFY(lua_getinfo(a_LuaState, "n", &entry));
+
+	// Compose the error message:
+	va_list argp;
+	va_start(argp, a_MsgFormat);
+	AString msg;
+
+	#ifdef __clang__
+		#pragma clang diagnostic push
+		#pragma clang diagnostic ignored "-Wformat-nonliteral"
+	#endif
+
+	AppendVPrintf(msg, a_MsgFormat, argp);
+
+	#ifdef __clang__
+		#pragma clang diagnostic pop
+	#endif
+
+	va_end(argp);
+	AString errorMsg = Printf("%s: %s", (entry.name != nullptr) ? entry.name : "<unknown function>", msg.c_str());
+
+	// Log everything into the console:
+	LOGWARNING("%s", errorMsg.c_str());
+	// cLuaState::LogStackTrace(a_LuaState);  // Do NOT log stack trace, it is already output as part of the Lua error handling
+	cLuaState::LogStackValues(a_LuaState, "Parameters on the stack");
+
+	// Raise Lua error:
+	lua_pushstring(a_LuaState, errorMsg.c_str());
+	return lua_error(a_LuaState);
+}
+
+
+
+
+
 // Lua bound functions with special return types
 static int tolua_Clamp(lua_State * tolua_S)
 {
@@ -3199,324 +3238,6 @@ static int tolua_cHopperEntity_GetOutputBlockPos(lua_State * tolua_S)
 
 
 
-static int tolua_cBlockArea_GetBlockTypeMeta(lua_State * tolua_S)
-{
-	// function cBlockArea::GetBlockTypeMeta()
-	// Exported manually because tolua generates extra input params for the outputs
-
-	cLuaState L(tolua_S);
-	if (
-		!L.CheckParamUserType(1, "cBlockArea") ||
-		!L.CheckParamNumber  (2, 4)
-	)
-	{
-		return 0;
-	}
-
-	cBlockArea * self = reinterpret_cast<cBlockArea *>(tolua_tousertype(tolua_S, 1, nullptr));
-	if (self == nullptr)
-	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetRelBlockTypeMeta'", nullptr);
-		return 0;
-	}
-	int BlockX = static_cast<int>(tolua_tonumber(tolua_S, 2, 0));
-	int BlockY = static_cast<int>(tolua_tonumber(tolua_S, 3, 0));
-	int BlockZ = static_cast<int>(tolua_tonumber(tolua_S, 4, 0));
-	BLOCKTYPE BlockType;
-	NIBBLETYPE BlockMeta;
-	self->GetBlockTypeMeta(BlockX, BlockY, BlockZ, BlockType, BlockMeta);
-	tolua_pushnumber(tolua_S, BlockType);
-	tolua_pushnumber(tolua_S, BlockMeta);
-	return 2;
-}
-
-
-
-
-
-static int tolua_cBlockArea_GetOrigin(lua_State * tolua_S)
-{
-	// function cBlockArea::GetOrigin()
-	// Returns all three coords of the origin point
-	// Exported manually because there's no direct C++ equivalent,
-	// plus tolua would generate extra input params for the outputs
-
-	cLuaState L(tolua_S);
-	if (!L.CheckParamUserType(1, "cBlockArea"))
-	{
-		return 0;
-	}
-
-	cBlockArea * self = reinterpret_cast<cBlockArea *>(tolua_tousertype(tolua_S, 1, nullptr));
-	if (self == nullptr)
-	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetOrigin'", nullptr);
-		return 0;
-	}
-
-	// Push the three origin coords:
-	lua_pushnumber(tolua_S, self->GetOriginX());
-	lua_pushnumber(tolua_S, self->GetOriginY());
-	lua_pushnumber(tolua_S, self->GetOriginZ());
-	return 3;
-}
-
-
-
-
-
-static int tolua_cBlockArea_GetNonAirCropRelCoords(lua_State * tolua_S)
-{
-	// function cBlockArea::GetNonAirCropRelCoords()
-	// Exported manually because tolua would generate extra input params for the outputs
-
-	cLuaState L(tolua_S);
-	if (!L.CheckParamUserType(1, "cBlockArea"))
-	{
-		return 0;
-	}
-
-	cBlockArea * self = nullptr;
-	BLOCKTYPE IgnoreBlockType = E_BLOCK_AIR;
-	L.GetStackValues(1, self, IgnoreBlockType);
-	if (self == nullptr)
-	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetNonAirCropRelCoords'", nullptr);
-		return 0;
-	}
-
-	// Calculate the crop coords:
-	int MinRelX, MinRelY, MinRelZ, MaxRelX, MaxRelY, MaxRelZ;
-	self->GetNonAirCropRelCoords(MinRelX, MinRelY, MinRelZ, MaxRelX, MaxRelY, MaxRelZ, IgnoreBlockType);
-
-	// Push the six crop coords:
-	L.Push(MinRelX, MinRelY, MinRelZ, MaxRelX, MaxRelY, MaxRelZ);
-	return 6;
-}
-
-
-
-
-
-static int tolua_cBlockArea_GetRelBlockTypeMeta(lua_State * tolua_S)
-{
-	// function cBlockArea::GetRelBlockTypeMeta()
-	// Exported manually because tolua generates extra input params for the outputs
-
-	cLuaState L(tolua_S);
-	if (
-		!L.CheckParamUserType(1, "cBlockArea") ||
-		!L.CheckParamNumber  (2, 4)
-	)
-	{
-		return 0;
-	}
-
-	cBlockArea * self = reinterpret_cast<cBlockArea *>(tolua_tousertype(tolua_S, 1, nullptr));
-	if (self == nullptr)
-	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetRelBlockTypeMeta'", nullptr);
-		return 0;
-	}
-	int BlockX = static_cast<int>(tolua_tonumber(tolua_S, 2, 0));
-	int BlockY = static_cast<int>(tolua_tonumber(tolua_S, 3, 0));
-	int BlockZ = static_cast<int>(tolua_tonumber(tolua_S, 4, 0));
-	BLOCKTYPE BlockType;
-	NIBBLETYPE BlockMeta;
-	self->GetRelBlockTypeMeta(BlockX, BlockY, BlockZ, BlockType, BlockMeta);
-	tolua_pushnumber(tolua_S, BlockType);
-	tolua_pushnumber(tolua_S, BlockMeta);
-	return 2;
-}
-
-
-
-
-
-static int tolua_cBlockArea_GetSize(lua_State * tolua_S)
-{
-	// function cBlockArea::GetSize()
-	// Returns all three sizes of the area
-	// Exported manually because there's no direct C++ equivalent,
-	// plus tolua would generate extra input params for the outputs
-
-	cLuaState L(tolua_S);
-	if (!L.CheckParamUserType(1, "cBlockArea"))
-	{
-		return 0;
-	}
-
-	cBlockArea * self = reinterpret_cast<cBlockArea *>(tolua_tousertype(tolua_S, 1, nullptr));
-	if (self == nullptr)
-	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetSize'", nullptr);
-		return 0;
-	}
-
-	// Push the three origin coords:
-	lua_pushnumber(tolua_S, self->GetSizeX());
-	lua_pushnumber(tolua_S, self->GetSizeY());
-	lua_pushnumber(tolua_S, self->GetSizeZ());
-	return 3;
-}
-
-
-
-
-
-static int tolua_cBlockArea_GetCoordRange(lua_State * tolua_S)
-{
-	// function cBlockArea::GetCoordRange()
-	// Returns all three sizes of the area, miuns one, so that they represent the maximum coord value
-	// Exported manually because there's no direct C++ equivalent,
-	// plus tolua would generate extra input params for the outputs
-
-	cLuaState L(tolua_S);
-	if (!L.CheckParamUserType(1, "cBlockArea"))
-	{
-		return 0;
-	}
-
-	cBlockArea * self = reinterpret_cast<cBlockArea *>(tolua_tousertype(tolua_S, 1, nullptr));
-	if (self == nullptr)
-	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetSize'", nullptr);
-		return 0;
-	}
-
-	// Push the three origin coords:
-	lua_pushnumber(tolua_S, self->GetSizeX() - 1);
-	lua_pushnumber(tolua_S, self->GetSizeY() - 1);
-	lua_pushnumber(tolua_S, self->GetSizeZ() - 1);
-	return 3;
-}
-
-
-
-
-
-static int tolua_cBlockArea_LoadFromSchematicFile(lua_State * tolua_S)
-{
-	// function cBlockArea::LoadFromSchematicFile
-	// Exported manually because function has been moved to SchematicFileSerializer.cpp
-	cLuaState L(tolua_S);
-	if (
-		!L.CheckParamUserType(1, "cBlockArea") ||
-		!L.CheckParamString  (2) ||
-		!L.CheckParamEnd     (3)
-	)
-	{
-		return 0;
-	}
-	cBlockArea * self = reinterpret_cast<cBlockArea *>(tolua_tousertype(tolua_S, 1, nullptr));
-	if (self == nullptr)
-	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::LoadFromSchematicFile'", nullptr);
-		return 0;
-	}
-
-	AString Filename = tolua_tostring(tolua_S, 2, 0);
-	bool res = cSchematicFileSerializer::LoadFromSchematicFile(*self, Filename);
-	tolua_pushboolean(tolua_S, res);
-	return 1;
-}
-
-
-
-
-
-static int tolua_cBlockArea_LoadFromSchematicString(lua_State * tolua_S)
-{
-	// function cBlockArea::LoadFromSchematicString
-	// Exported manually because function has been moved to SchematicFileSerializer.cpp
-	cLuaState L(tolua_S);
-	if (
-		!L.CheckParamUserType(1, "cBlockArea") ||
-		!L.CheckParamString  (2) ||
-		!L.CheckParamEnd     (3)
-	)
-	{
-		return 0;
-	}
-	cBlockArea * self = reinterpret_cast<cBlockArea *>(tolua_tousertype(tolua_S, 1, nullptr));
-	if (self == nullptr)
-	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::LoadFromSchematicFile'", nullptr);
-		return 0;
-	}
-
-	AString Data;
-	L.GetStackValue(2, Data);
-	bool res = cSchematicFileSerializer::LoadFromSchematicString(*self, Data);
-	tolua_pushboolean(tolua_S, res);
-	return 1;
-}
-
-
-
-
-
-static int tolua_cBlockArea_SaveToSchematicFile(lua_State * tolua_S)
-{
-	// function cBlockArea::SaveToSchematicFile
-	// Exported manually because function has been moved to SchematicFileSerializer.cpp
-	cLuaState L(tolua_S);
-	if (
-		!L.CheckParamUserType(1, "cBlockArea") ||
-		!L.CheckParamString  (2) ||
-		!L.CheckParamEnd     (3)
-	)
-	{
-		return 0;
-	}
-	cBlockArea * self = reinterpret_cast<cBlockArea *>(tolua_tousertype(tolua_S, 1, nullptr));
-	if (self == nullptr)
-	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::SaveToSchematicFile'", nullptr);
-		return 0;
-	}
-	AString Filename = tolua_tostring(tolua_S, 2, 0);
-	bool res = cSchematicFileSerializer::SaveToSchematicFile(*self, Filename);
-	tolua_pushboolean(tolua_S, res);
-	return 1;
-}
-
-
-
-
-
-static int tolua_cBlockArea_SaveToSchematicString(lua_State * tolua_S)
-{
-	// function cBlockArea::SaveToSchematicString
-	// Exported manually because function has been moved to SchematicFileSerializer.cpp
-	cLuaState L(tolua_S);
-	if (
-		!L.CheckParamUserType(1, "cBlockArea") ||
-		!L.CheckParamEnd     (2)
-	)
-	{
-		return 0;
-	}
-	cBlockArea * self = reinterpret_cast<cBlockArea *>(tolua_tousertype(tolua_S, 1, nullptr));
-	if (self == nullptr)
-	{
-		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::SaveToSchematicFile'", nullptr);
-		return 0;
-	}
-
-	AString Data;
-	if (cSchematicFileSerializer::SaveToSchematicString(*self, Data))
-	{
-		L.Push(Data);
-		return 1;
-	}
-	return 0;
-}
-
-
-
-
-
 static int tolua_cBoundingBox_CalcLineIntersection(lua_State * a_LuaState)
 {
 	/* Function signatures:
@@ -4031,19 +3752,6 @@ void cManualBindings::Bind(lua_State * tolua_S)
 		tolua_function(tolua_S, "Base64Decode",          tolua_Base64Decode);
 		tolua_function(tolua_S, "md5",                   tolua_md5_obsolete);  // OBSOLETE, use cCryptoHash.md5() instead
 
-		tolua_beginmodule(tolua_S, "cBlockArea");
-			tolua_function(tolua_S, "GetBlockTypeMeta",        tolua_cBlockArea_GetBlockTypeMeta);
-			tolua_function(tolua_S, "GetCoordRange",           tolua_cBlockArea_GetCoordRange);
-			tolua_function(tolua_S, "GetOrigin",               tolua_cBlockArea_GetOrigin);
-			tolua_function(tolua_S, "GetNonAirCropRelCoords",  tolua_cBlockArea_GetNonAirCropRelCoords);
-			tolua_function(tolua_S, "GetRelBlockTypeMeta",     tolua_cBlockArea_GetRelBlockTypeMeta);
-			tolua_function(tolua_S, "GetSize",                 tolua_cBlockArea_GetSize);
-			tolua_function(tolua_S, "LoadFromSchematicFile",   tolua_cBlockArea_LoadFromSchematicFile);
-			tolua_function(tolua_S, "LoadFromSchematicString", tolua_cBlockArea_LoadFromSchematicString);
-			tolua_function(tolua_S, "SaveToSchematicFile",     tolua_cBlockArea_SaveToSchematicFile);
-			tolua_function(tolua_S, "SaveToSchematicString",   tolua_cBlockArea_SaveToSchematicString);
-		tolua_endmodule(tolua_S);
-
 		tolua_beginmodule(tolua_S, "cBoundingBox");
 			tolua_function(tolua_S, "CalcLineIntersection", tolua_cBoundingBox_CalcLineIntersection);
 			tolua_function(tolua_S, "Intersect",            tolua_cBoundingBox_Intersect);
@@ -4228,6 +3936,7 @@ void cManualBindings::Bind(lua_State * tolua_S)
 		BindNetwork(tolua_S);
 		BindRankManager(tolua_S);
 		BindWorld(tolua_S);
+		BindBlockArea(tolua_S);
 
 	tolua_endmodule(tolua_S);
 }
diff --git a/src/Bindings/ManualBindings.h b/src/Bindings/ManualBindings.h
index 98e3e88ef..889e33664 100644
--- a/src/Bindings/ManualBindings.h
+++ b/src/Bindings/ManualBindings.h
@@ -41,6 +41,10 @@ protected:
 	Implemented in ManualBindings_World.cpp. */
 	static void BindWorld(lua_State * tolua_S);
 
+	/** Binds the manually implemented cBlockArea API functions to tlua_S.
+	Implemented in ManualBindings_BlockArea.cpp. */
+	static void BindBlockArea(lua_State * tolua_S);
+
 
 public:
 	// Helper functions:
@@ -48,6 +52,11 @@ public:
 	static int tolua_do_error(lua_State * L, const char * a_pMsg, tolua_Error * a_pToLuaError);
 	static int lua_do_error(lua_State * L, const char * a_pFormat, ...);
 
+	/** Formats and prints the message, prefixed with the current function name, then logs the stack contents and raises a Lua error.
+	To be used for bindings when they detect bad parameters.
+	Doesn't return, but a dummy return type is provided so that Lua API functions may do "return ApiParamError(...)". */
+	static int ApiParamError(lua_State * a_LuaState, const char * a_MsgFormat, ...);
+
 
 	/** Binds the DoWith(ItemName) functions of regular classes. */
 	template <
@@ -243,10 +252,11 @@ public:
 
 
 
+	/** Template for the bindings for the DoWithXYZAt(X, Y, Z) functions that don't need to check their coords. */
 	template <
-		class Ty1,
-		class Ty2,
-		bool (Ty1::*DoWithFn)(int, int, int, cItemCallback<Ty2> &)
+		class SELF,
+		class ITEM,
+		bool (SELF::*DoWithFn)(int, int, int, cItemCallback<ITEM> &)
 	>
 	static int DoWithXYZ(lua_State * tolua_S)
 	{
@@ -262,7 +272,7 @@ public:
 		}
 
 		// Get parameters:
-		Ty1 * Self = nullptr;
+		SELF * Self = nullptr;
 		int BlockX = 0;
 		int BlockY = 0;
 		int BlockZ = 0;
@@ -277,7 +287,7 @@ public:
 			return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #5");
 		}
 
-		class cLuaCallback : public cItemCallback<Ty2>
+		class cLuaCallback : public cItemCallback<ITEM>
 		{
 		public:
 			cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FnRef):
@@ -287,7 +297,81 @@ public:
 			}
 
 		private:
-			virtual bool Item(Ty2 * a_Item) override
+			virtual bool Item(ITEM * a_Item) override
+			{
+				bool ret = false;
+				m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, ret);
+				return ret;
+			}
+			cLuaState & m_LuaState;
+			cLuaState::cRef & m_FnRef;
+		} Callback(L, FnRef);
+
+		// Call the DoWith function:
+		bool res = (Self->*DoWithFn)(BlockX, BlockY, BlockZ, Callback);
+
+		// Push the result as the return value:
+		L.Push(res);
+		return 1;
+	}
+
+
+
+
+
+	/** Template 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, cItemCallback<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 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");
+		}
+		if (!(Self->*CoordCheckFn)(BlockX, BlockY, BlockZ))
+		{
+			return lua_do_error(tolua_S, Printf("Error in function call '#funcname#': The provided coordinates ({%d, %d, %d}) are not valid",
+				BlockX, BlockY, BlockZ
+			).c_str());
+		}
+
+		class cLuaCallback : public cItemCallback<ITEM>
+		{
+		public:
+			cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FnRef):
+				m_LuaState(a_LuaState),
+				m_FnRef(a_FnRef)
+			{
+			}
+
+		private:
+			virtual bool Item(ITEM * a_Item) override
 			{
 				bool ret = false;
 				m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, ret);
diff --git a/src/Bindings/ManualBindings_BlockArea.cpp b/src/Bindings/ManualBindings_BlockArea.cpp
new file mode 100644
index 000000000..14462c6e9
--- /dev/null
+++ b/src/Bindings/ManualBindings_BlockArea.cpp
@@ -0,0 +1,998 @@
+// ManualBindings_BlockArea.cpp
+
+// Implements the manual bindings for functions in the cBlockArea class
+
+#include "Globals.h"
+#include "tolua++/include/tolua++.h"
+#include "../BlockArea.h"
+#include "../World.h"
+#include "ManualBindings.h"
+#include "LuaState.h"
+#include "PluginLua.h"
+#include "../WorldStorage/SchematicFileSerializer.h"
+
+
+
+
+
+
+/** Reads params that together form a Cuboid.
+These can be:
+	- 6 numbers (MinX, MaxX, MinY, MaxY, MinZ, MaxZ)
+	- 2 Vector3-s (Min, Max)
+	- cCuboid
+Returns the index of the first parameter following the Cuboid spec.
+Raises an Api error if the params don't specify a Cuboid.
+*/
+static int readCuboidOverloadParams(cLuaState & a_LuaState, int a_StartParam, cCuboid & a_Cuboid)
+{
+	if (a_LuaState.IsParamNumber(a_StartParam))
+	{
+		// Assume the 6-number version:
+		if (!a_LuaState.GetStackValues(a_StartParam, a_Cuboid.p1.x, a_Cuboid.p2.x, a_Cuboid.p1.y, a_Cuboid.p2.y, a_Cuboid.p1.z, a_Cuboid.p2.z))
+		{
+			return cManualBindings::ApiParamError(a_LuaState, "Cannot read the bounds parameters, expected 6 numbers.");
+		}
+		return a_StartParam + 6;
+	}
+	else if (a_LuaState.IsParamUserType(a_StartParam, "cCuboid"))
+	{
+		// Assume the cCuboid version:
+		cCuboid * c;
+		if (!a_LuaState.GetStackValues(a_StartParam, c))
+		{
+			return cManualBindings::ApiParamError(a_LuaState, "Cannot read the bounds parameter, expected a cCuboid instance.");
+		}
+		a_Cuboid = *c;
+		return a_StartParam + 1;
+	}
+	else
+	{
+		// Assume the 2-Vector3i version:
+		Vector3i * p1;
+		Vector3i * p2;
+		if (!a_LuaState.GetStackValues(a_StartParam, p1, p2))
+		{
+			return cManualBindings::ApiParamError(a_LuaState, "Cannot read the bounds parameter, expected two Vector3i instances.");
+		}
+		a_Cuboid.p1 = *p1;
+		a_Cuboid.p2 = *p2;
+		return a_StartParam + 2;
+	}
+}
+
+
+
+
+
+/** Reads params that together form a Vector3i.
+These can be:
+	- 3 numbers (x, y, z)
+	- Vector3i
+Returns the index of the first parameter following the Vector3i spec.
+Raises an Api error if the params don't specify a Vector3i.
+*/
+static int readVector3iOverloadParams(cLuaState & a_LuaState, int a_StartParam, Vector3i & a_Coords, const char * a_ParamName)
+{
+	if (a_LuaState.IsParamNumber(a_StartParam))
+	{
+		// Assume the 3-number version:
+		if (!a_LuaState.GetStackValues(a_StartParam, a_Coords.x, a_Coords.y, a_Coords.z))
+		{
+			return cManualBindings::ApiParamError(a_LuaState, "Cannot read the %s, expected 3 numbers.", a_ParamName);
+		}
+		return a_StartParam + 3;
+	}
+	else
+	{
+		// Assume the Vector3i version:
+		Vector3i * c;
+		if (!a_LuaState.GetStackValues(a_StartParam, c))
+		{
+			return cManualBindings::ApiParamError(a_LuaState, "Cannot read the %s, expected a Vector3i instance.", a_ParamName);
+		}
+		a_Coords = *c;
+		return a_StartParam + 1;
+	}
+}
+
+
+
+
+
+/** Binding for the cBlockArea::Create() functions. Supports two overloads and one default parameter. */
+static int tolua_cBlockArea_Create(lua_State * a_LuaState)
+{
+	cLuaState L(a_LuaState);
+	if (!L.CheckParamSelf("cBlockArea"))
+	{
+		return 0;
+	}
+	cBlockArea * self = nullptr;
+	if (!L.GetStackValues(1, self))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read self.");
+	}
+	if (self == nullptr)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid 'self', must not be nil.");
+	}
+
+	int dataTypes = cBlockArea::baTypes | cBlockArea::baMetas | cBlockArea::baBlockEntities;
+	Vector3i size;
+	auto dataTypesIdx = readVector3iOverloadParams(L, 2, size, "size");
+	L.GetStackValue(dataTypesIdx, dataTypes);
+	if (!cBlockArea::IsValidDataTypeCombination(dataTypes))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid combination of baDataTypes specified (%d).", dataTypes);
+	}
+
+	// Create the area:
+	if ((size.x <= 0) || (size.y <= 0) || (size.z <= 0))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid sizes, must be greater than zero, got {%d, %d, %d}", size.x, size.y, size.z);
+	}
+	ASSERT(self != nullptr);
+	self->Create(size, dataTypes);
+	return 0;
+}
+
+
+
+
+
+/** Bindings for the cBlockArea:FillRelCuboid() functions. Supports coord overloads and one default parameter. */
+static int tolua_cBlockArea_FillRelCuboid(lua_State * a_LuaState)
+{
+	// Check the common params:
+	cLuaState L(a_LuaState);
+	if (!L.CheckParamSelf("cBlockArea"))
+	{
+		return 0;
+	}
+
+	// Get the common params:
+	cBlockArea * self = nullptr;
+	if (!L.GetStackValues(1, self))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read self.");
+	}
+	if (self == nullptr)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid 'self', must not be nil.");
+	}
+
+	// Check and get the overloaded params:
+	cCuboid bounds;
+	auto nextIdx = readCuboidOverloadParams(L, 2, bounds);
+	int dataTypes = cBlockArea::baTypes | cBlockArea::baMetas | cBlockArea::baBlockEntities;
+	BLOCKTYPE blockType;
+	NIBBLETYPE blockMeta = 0, blockLight = 0, blockSkyLight = 0x0f;
+	if (!L.GetStackValues(nextIdx, dataTypes, blockType))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read the datatypes or block type params");
+	}
+	L.GetStackValues(nextIdx + 2, blockMeta, blockLight, blockSkyLight);  // These values are optional
+	if (!cBlockArea::IsValidDataTypeCombination(dataTypes))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid baDataTypes combination (%d).", dataTypes);
+	}
+
+	// Check the coords, shift if needed:
+	bounds.Sort();
+	bounds.ClampX(0, self->GetSizeX());
+	bounds.ClampY(0, self->GetSizeY());
+	bounds.ClampZ(0, self->GetSizeZ());
+
+	// Do the actual Fill:
+	self->FillRelCuboid(bounds, dataTypes, blockType, blockMeta, blockLight, blockSkyLight);
+	return 0;
+}
+
+
+
+
+
+static int tolua_cBlockArea_GetBlockTypeMeta(lua_State * a_LuaState)
+{
+	// function cBlockArea::GetBlockTypeMeta()
+
+	cLuaState L(a_LuaState);
+	if (!L.CheckParamSelf("cBlockArea"))
+	{
+		return 0;
+	}
+
+	cBlockArea * self;
+	if (!L.GetStackValues(1, self))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read 'self'");
+	}
+	if (self == nullptr)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid 'self', must not be nil.");
+	}
+
+	Vector3i coords;
+	readVector3iOverloadParams(L, 2, coords, "coords");
+	if (!self->IsValidCoords(coords))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Coords ({%d, %d, %d}) out of range ({%d, %d, %d} - {%d, %d, %d}).",
+			coords.x, coords.y, coords.z,
+			self->GetOriginX(), self->GetOriginY(), self->GetOriginZ(),
+			self->GetOriginX() + self->GetSizeX() - 1, self->GetOriginY() + self->GetSizeY() - 1, self->GetOriginZ() + self->GetSizeZ() - 1
+		);
+	}
+	BLOCKTYPE blockType;
+	NIBBLETYPE blockMeta;
+	self->GetBlockTypeMeta(coords.x, coords.y, coords.z, blockType, blockMeta);
+	L.Push(blockType, blockMeta);
+	return 2;
+}
+
+
+
+
+
+static int tolua_cBlockArea_GetCoordRange(lua_State * a_LuaState)
+{
+	// function cBlockArea::GetCoordRange()
+	// Returns all three sizes of the area, each minus one, so that they represent the maximum coord value
+	// Exported manually because there's no direct C++ equivalent,
+	// plus tolua would generate extra input params for the outputs
+
+	cLuaState L(a_LuaState);
+	if (!L.CheckParamSelf("cBlockArea"))
+	{
+		return 0;
+	}
+
+	cBlockArea * self;
+	if (!L.GetStackValues(1, self))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read the 'self' parameter.");
+	}
+	if (self == nullptr)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid 'self', must not be nil.");
+	}
+
+	L.Push(self->GetSizeX() - 1, self->GetSizeY() - 1, self->GetSizeZ() - 1);
+	return 3;
+}
+
+
+
+
+
+static int tolua_cBlockArea_GetNonAirCropRelCoords(lua_State * a_LuaState)
+{
+	// function cBlockArea::GetNonAirCropRelCoords()
+	// Exported manually because tolua would generate extra input params for the outputs
+
+	cLuaState L(a_LuaState);
+	if (!L.CheckParamSelf("cBlockArea"))
+	{
+		return 0;
+	}
+
+	cBlockArea * self = nullptr;
+	BLOCKTYPE ignoreBlockType = E_BLOCK_AIR;
+	if (!L.GetStackValues(1, self, ignoreBlockType))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read params");
+	}
+	if (self == nullptr)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid 'self', must not be nil");
+	}
+	if (!self->HasBlockTypes())
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "The area doesn't contain baTypes datatype");
+	}
+
+	// Calculate the crop coords:
+	int minRelX, minRelY, minRelZ, maxRelX, maxRelY, maxRelZ;
+	self->GetNonAirCropRelCoords(minRelX, minRelY, minRelZ, maxRelX, maxRelY, maxRelZ, ignoreBlockType);
+
+	// Push the six crop coords:
+	L.Push(minRelX, minRelY, minRelZ, maxRelX, maxRelY, maxRelZ);
+	return 6;
+}
+
+
+
+
+
+static int tolua_cBlockArea_GetOrigin(lua_State * a_LuaState)
+{
+	// function cBlockArea::GetOrigin()
+	// Returns all three coords of the origin point
+	// Exported manually because there's no direct C++ equivalent,
+	// plus tolua would generate extra input params for the outputs
+
+	cLuaState L(a_LuaState);
+	if (!L.CheckParamSelf("cBlockArea"))
+	{
+		return 0;
+	}
+
+	cBlockArea * self;
+	if (!L.GetStackValues(1, self))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read the 'self' parameter.");
+	}
+	if (self == nullptr)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid 'self', must not be nil.");
+	}
+
+	// Push the three origin coords:
+	L.Push(self->GetOriginX(), self->GetOriginY(), self->GetOriginZ());
+	return 3;
+}
+
+
+
+
+
+static int tolua_cBlockArea_GetRelBlockTypeMeta(lua_State * a_LuaState)
+{
+	// function cBlockArea::GetRelBlockTypeMeta()
+	// Exported manually because tolua generates extra input params for the outputs
+
+	cLuaState L(a_LuaState);
+	if (!L.CheckParamSelf("cBlockArea"))
+	{
+		return 0;
+	}
+
+	cBlockArea * self;
+	if (!L.GetStackValues(1, self))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read the 'self' parameter.");
+	}
+	if (self == nullptr)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid 'self', must not be nil.");
+	}
+	if (!self->HasBlockTypes())
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "The area doesn't contain baTypes datatype");
+	}
+	if (!self->HasBlockMetas())
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "The area doesn't contain baMetas datatype");
+	}
+
+	Vector3i coords;
+	readVector3iOverloadParams(L, 2, coords, "coords");
+	if (!self->IsValidRelCoords(coords))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "The coords ({%d, %d, %d}) are out of range (max {%d, %d, %d}).",
+			coords.x, coords.y, coords.z,
+			self->GetSizeX() - 1, self->GetSizeY() - 1, self->GetSizeZ() - 1
+		);
+	}
+	BLOCKTYPE blockType;
+	NIBBLETYPE blockMeta;
+	self->GetRelBlockTypeMeta(coords.x, coords.y, coords.z, blockType, blockMeta);
+	L.Push(blockType, blockMeta);
+	return 2;
+}
+
+
+
+
+
+static int tolua_cBlockArea_GetSize(lua_State * a_LuaState)
+{
+	// function cBlockArea::GetSize()
+	// Returns all three sizes of the area
+	// Exported manually because there's no direct C++ equivalent,
+	// plus tolua would generate extra input params for the outputs
+
+	cLuaState L(a_LuaState);
+	if (!L.CheckParamSelf("cBlockArea"))
+	{
+		return 0;
+	}
+
+	cBlockArea * self;
+	if (!L.GetStackValues(1, self))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read the 'self' parameter.");
+	}
+	if (self == nullptr)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid 'self', must not be nil.");
+	}
+
+	L.Push(self->GetSizeX(), self->GetSizeY(), self->GetSizeZ());
+	return 3;
+}
+
+
+
+
+
+static int tolua_cBlockArea_LoadFromSchematicFile(lua_State * a_LuaState)
+{
+	// function cBlockArea::LoadFromSchematicFile
+	// Exported manually because function has been moved to SchematicFileSerializer.cpp
+	cLuaState L(a_LuaState);
+	if (
+		!L.CheckParamSelf("cBlockArea") ||
+		!L.CheckParamString(2) ||
+		!L.CheckParamEnd(3)
+	)
+	{
+		return 0;
+	}
+	cBlockArea * self;
+	AString fileName;
+	if (!L.GetStackValues(1, self, fileName))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read the parameters.");
+	}
+	if (self == nullptr)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid 'self', must not be nil.");
+	}
+
+	L.Push(cSchematicFileSerializer::LoadFromSchematicFile(*self, fileName));
+	return 1;
+}
+
+
+
+
+
+static int tolua_cBlockArea_LoadFromSchematicString(lua_State * a_LuaState)
+{
+	// function cBlockArea::LoadFromSchematicString
+	// Exported manually because function has been moved to SchematicFileSerializer.cpp
+	cLuaState L(a_LuaState);
+	if (
+		!L.CheckParamSelf("cBlockArea") ||
+		!L.CheckParamString(2) ||
+		!L.CheckParamEnd(3)
+	)
+	{
+		return 0;
+	}
+	cBlockArea * self;
+	AString data;
+	if (!L.GetStackValues(1, self, data))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read the parameters.");
+	}
+	if (self == nullptr)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid 'self', must not be nil.");
+	}
+
+	L.Push(cSchematicFileSerializer::LoadFromSchematicString(*self, data));
+	return 1;
+}
+
+
+
+
+
+/** Bindings for the cBlockArea:Read() functions. Supports three overloads and one default parameter. */
+static int tolua_cBlockArea_Read(lua_State * a_LuaState)
+{
+	// Check the common params:
+	cLuaState L(a_LuaState);
+	if (
+		!L.CheckParamSelf("cBlockArea") ||
+		!L.CheckParamUserType(2, "cWorld")
+	)
+	{
+		return 0;
+	}
+
+	// Get the common params:
+	cBlockArea * self = nullptr;
+	cWorld * world = nullptr;
+	if (!L.GetStackValues(1, self, world))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read self or world.");
+	}
+	if (world == nullptr)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid world instance. The world must be not nil.");
+	}
+
+	// Check and get the overloaded params:
+	cCuboid bounds;
+	int dataTypes = cBlockArea::baTypes | cBlockArea::baMetas | cBlockArea::baBlockEntities;
+	auto dataTypesIdx = readCuboidOverloadParams(L, 3, bounds);
+	L.GetStackValues(dataTypesIdx, dataTypes);
+	if (!cBlockArea::IsValidDataTypeCombination(dataTypes))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid baDataTypes combination (%d).", dataTypes);
+	}
+
+	// Check the coords, shift if needed:
+	bounds.Sort();
+	if (bounds.p1.y < 0)
+	{
+		LOGWARNING("cBlockArea:Read(): MinBlockY less than zero, adjusting to zero. Coords: {%d, %d, %d} - {%d, %d, %d}",
+			bounds.p1.x, bounds.p1.y, bounds.p1.z, bounds.p2.x, bounds.p2.y, bounds.p2.z
+		);
+		L.LogStackTrace();
+		bounds.p1.y = 0;
+	}
+	else if (bounds.p1.y >= cChunkDef::Height)
+	{
+		LOGWARNING("cBlockArea:Read(): MinBlockY more than chunk height, adjusting to chunk height. Coords: {%d, %d, %d} - {%d, %d, %d}",
+			bounds.p1.x, bounds.p1.y, bounds.p1.z, bounds.p2.x, bounds.p2.y, bounds.p2.z
+		);
+		L.LogStackTrace();
+		bounds.p1.y = cChunkDef::Height - 1;
+	}
+	if (bounds.p2.y < 0)
+	{
+		LOGWARNING("cBlockArea:Read(): MaxBlockY less than zero, adjusting to zero. Coords: {%d, %d, %d} - {%d, %d, %d}",
+			bounds.p1.x, bounds.p1.y, bounds.p1.z, bounds.p2.x, bounds.p2.y, bounds.p2.z
+		);
+		L.LogStackTrace();
+		bounds.p2.y = 0;
+	}
+	else if (bounds.p2.y > cChunkDef::Height)
+	{
+		LOGWARNING("cBlockArea:Read(): MaxBlockY more than chunk height, adjusting to chunk height. Coords: {%d, %d, %d} - {%d, %d, %d}",
+			bounds.p1.x, bounds.p1.y, bounds.p1.z, bounds.p2.x, bounds.p2.y, bounds.p2.z
+		);
+		L.LogStackTrace();
+		bounds.p2.y = cChunkDef::Height;
+	}
+
+	// Do the actual read:
+	L.Push(self->Read(*world, bounds, dataTypes));
+	return 1;
+}
+
+
+
+
+
+/** Bindings for the cBlockArea:RelLine() functions. Supports two overloads and one default parameter.
+Also supports "bastard overloads" (Vector3i, x, y, z), but we don't advertise those. */
+static int tolua_cBlockArea_RelLine(lua_State * a_LuaState)
+{
+	// Check the common params:
+	cLuaState L(a_LuaState);
+	if (!L.CheckParamSelf("cBlockArea"))
+	{
+		return 0;
+	}
+
+	// Get the common params:
+	cBlockArea * self = nullptr;
+	if (!L.GetStackValues(1, self))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read self.");
+	}
+
+	// Check and get the overloaded params:
+	Vector3i p1;
+	auto idx = readVector3iOverloadParams(L, 2, p1, "start coords");
+	Vector3i p2;
+	idx = readVector3iOverloadParams(L, idx, p2, "end coords");
+	int dataTypes = cBlockArea::baTypes | cBlockArea::baMetas | cBlockArea::baBlockEntities;
+	BLOCKTYPE blockType;
+	NIBBLETYPE blockMeta, blockLight, blockSkyLight;
+	L.GetStackValues(idx, dataTypes, blockType, blockMeta, blockLight, blockSkyLight);
+	if (!cBlockArea::IsValidDataTypeCombination(dataTypes))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid baDataTypes combination (%d).", dataTypes);
+	}
+
+	// Draw the line:
+	self->RelLine(p1, p2, dataTypes, blockType, blockMeta, blockLight, blockSkyLight);
+	return 0;
+}
+
+
+
+
+
+static int tolua_cBlockArea_SaveToSchematicFile(lua_State * a_LuaState)
+{
+	// function cBlockArea::SaveToSchematicFile
+	// Exported manually because function has been moved to SchematicFileSerializer.cpp
+	cLuaState L(a_LuaState);
+	if (
+		!L.CheckParamSelf("cBlockArea") ||
+		!L.CheckParamString(2) ||
+		!L.CheckParamEnd(3)
+	)
+	{
+		return 0;
+	}
+	cBlockArea * self;
+	AString fileName;
+	if (!L.GetStackValues(1, self, fileName))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read the parameters.");
+	}
+	if (self == nullptr)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid 'self', must not be nil.");
+	}
+
+	L.Push(cSchematicFileSerializer::SaveToSchematicFile(*self, fileName));
+	return 1;
+}
+
+
+
+
+
+static int tolua_cBlockArea_SaveToSchematicString(lua_State * a_LuaState)
+{
+	// function cBlockArea::SaveToSchematicString
+	// Exported manually because function has been moved to SchematicFileSerializer.cpp
+	cLuaState L(a_LuaState);
+	if (
+		!L.CheckParamSelf("cBlockArea") ||
+		!L.CheckParamEnd(2)
+	)
+	{
+		return 0;
+	}
+	cBlockArea * self;
+	if (!L.GetStackValues(1, self))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read the 'self' parameter.");
+	}
+	if (self == nullptr)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid 'self', must not be nil.");
+	}
+
+	AString data;
+	if (cSchematicFileSerializer::SaveToSchematicString(*self, data))
+	{
+		L.Push(data);
+		return 1;
+	}
+	return 0;
+}
+
+
+
+
+
+/** Bindings for the cBlockArea:Write() functions. Supports two overloads and one default parameter. */
+static int tolua_cBlockArea_Write(lua_State * a_LuaState)
+{
+	// Check the common params:
+	cLuaState L(a_LuaState);
+	if (
+		!L.CheckParamSelf("cBlockArea") ||
+		!L.CheckParamUserType(2, "cWorld")
+	)
+	{
+		return 0;
+	}
+
+	// Get the common params:
+	cBlockArea * self = nullptr;
+	cWorld * world = nullptr;
+	if (!L.GetStackValues(1, self, world))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read self or world.");
+	}
+	if (world == nullptr)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid world instance. The world must be not nil.");
+	}
+
+	// Check and get the overloaded params:
+	Vector3i coords;
+	int dataTypes = cBlockArea::baTypes | cBlockArea::baMetas | cBlockArea::baBlockEntities;
+	auto dataTypesIdx = readVector3iOverloadParams(L, 3, coords, "coords");
+	L.GetStackValues(dataTypesIdx, dataTypes);
+
+	// Check the dataType parameter validity:
+	if (!cBlockArea::IsValidDataTypeCombination(dataTypes))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Invalid datatype combination (%d).", dataTypes);
+	}
+	if ((self->GetDataTypes() & dataTypes) != dataTypes)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Requesting datatypes not present in the cBlockArea. Got only 0x%02x, requested 0x%02x",
+			self->GetDataTypes(), dataTypes
+		);
+	}
+
+	// Check and adjust the coord params:
+	// TODO: Should we report this as a failure? Because the result is definitely not what the plugin assumed
+	//   ... Or should we silently clone-crop-write the cBlockArea so that the API call does what would be naturally expected?
+	//   ... Or should we change the cBlockArea::Write() to allow out-of-range Y coords and do the cropping there?
+	//   ... NOTE: We already support auto-crop in cBlockArea::Merge() itself
+	if (coords.y < 0)
+	{
+		LOGWARNING("cBlockArea:Write(): MinBlockY less than zero, adjusting to zero");
+		L.LogStackTrace();
+		coords.y = 0;
+	}
+	else if (coords.y > cChunkDef::Height - self->GetSizeY())
+	{
+		LOGWARNING("cBlockArea:Write(): MinBlockY + m_SizeY more than chunk height, adjusting to chunk height");
+		L.LogStackTrace();
+		coords.y = cChunkDef::Height - self->GetSizeY();
+	}
+
+	// Do the actual write:
+	L.Push(self->Write(*world, coords, dataTypes));
+	return 1;
+}
+
+
+
+
+
+/** Templated bindings for the GetBlock___() functions.
+DataType is either BLOCKTYPE or NIBBLETYPE.
+DataTypeFlag is the ba___ constant used for the datatype being queried.
+Fn is the getter function.
+Also supports the Vector3i overloads (TODO: document these (?)). */
+template <
+	typename DataType,
+	int DataTypeFlag,
+	DataType (cBlockArea::*Fn)(int, int, int) const
+>
+static int GetBlock(lua_State * a_LuaState)
+{
+	// Check the common params:
+	cLuaState L(a_LuaState);
+	if (!L.CheckParamSelf("cBlockArea"))
+	{
+		return 0;
+	}
+
+	// Read the common params:
+	cBlockArea * self;
+	if (!L.GetStackValues(1, self))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read the 'self' param.");
+	}
+
+	// Check the datatype's presence:
+	if ((self->GetDataTypes() & DataTypeFlag) == 0)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "The area doesn't contain the datatype (%d).", DataTypeFlag);
+	}
+
+	// Read the overloaded params:
+	Vector3i coords;
+	readVector3iOverloadParams(L, 2, coords, "coords");
+	if (!self->IsValidCoords(coords))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "The coords ({%d, %d, %d}) are out of range ({%d, %d, %d} - {%d, %d, %d}).",
+			coords.x, coords.y, coords.z,
+			self->GetOriginX(), self->GetOriginY(), self->GetOriginZ(),
+			self->GetOriginX() + self->GetSizeX() - 1, self->GetOriginY() + self->GetSizeY() - 1, self->GetOriginZ() + self->GetSizeZ() - 1
+		);
+	}
+
+	// Get the block info:
+	L.Push((self->*Fn)(coords.x, coords.y, coords.z));
+	return 1;
+}
+
+
+
+
+
+/** Templated bindings for the GetRelBlock___() functions.
+DataType is either BLOCKTYPE or NIBBLETYPE.
+DataTypeFlag is the ba___ constant used for the datatype being queried.
+Fn is the getter function.
+Also supports the Vector3i overloads (TODO: document these (?)). */
+template <
+	typename DataType,
+	int DataTypeFlag,
+	DataType (cBlockArea::*Fn)(int, int, int) const
+>
+static int GetRelBlock(lua_State * a_LuaState)
+{
+	// Check the common params:
+	cLuaState L(a_LuaState);
+	if (!L.CheckParamSelf("cBlockArea"))
+	{
+		return 0;
+	}
+
+	// Read the common params:
+	cBlockArea * self;
+	if (!L.GetStackValues(1, self))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read the 'self' param.");
+	}
+
+	// Check the datatype's presence:
+	if ((self->GetDataTypes() & DataTypeFlag) == 0)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "The area doesn't contain the datatype (%d).", DataTypeFlag);
+	}
+
+	// Read the overloaded params:
+	Vector3i coords;
+	readVector3iOverloadParams(L, 2, coords, "coords");
+	if (!self->IsValidRelCoords(coords))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "The coords ({%d, %d, %d}) are out of range ({%d, %d, %d}).",
+			coords.x, coords.y, coords.z,
+			self->GetSizeX(), self->GetSizeY(), self->GetSizeZ()
+		);
+	}
+
+	// Get the block info:
+	L.Push((self->*Fn)(coords.x, coords.y, coords.z));
+	return 0;
+}
+
+
+
+
+
+/** Templated bindings for the SetBlock___() functions.
+DataType is either BLOCKTYPE or NIBBLETYPE.
+DataTypeFlag is the ba___ constant used for the datatypebeing manipulated.
+Fn is the setter function.
+Also supports the Vector3i overloads (TODO: document these (?)). */
+template <
+	typename DataType,
+	int DataTypeFlag,
+	void (cBlockArea::*Fn)(int, int, int, DataType)
+>
+static int SetBlock(lua_State * a_LuaState)
+{
+	// Check the common params:
+	cLuaState L(a_LuaState);
+	if (!L.CheckParamSelf("cBlockArea"))
+	{
+		return 0;
+	}
+
+	// Read the common params:
+	cBlockArea * self;
+	if (!L.GetStackValues(1, self))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read the 'self' param.");
+	}
+
+	// Check the datatype's presence:
+	if ((self->GetDataTypes() & DataTypeFlag) == 0)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "The area doesn't contain the datatype (%d).", DataTypeFlag);
+	}
+
+	// Read the overloaded params:
+	Vector3i coords;
+	auto idx = readVector3iOverloadParams(L, 2, coords, "coords");
+	if (!self->IsValidCoords(coords))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "The coords ({%d, %d, %d}) are out of range ({%d, %d, %d} - {%d, %d, %d}).",
+			coords.x, coords.y, coords.z,
+			self->GetOriginX(), self->GetOriginY(), self->GetOriginZ(),
+			self->GetOriginX() + self->GetSizeX() - 1, self->GetOriginY() + self->GetSizeY() - 1, self->GetOriginZ() + self->GetSizeZ() - 1
+		);
+	}
+	DataType data;
+	L.GetStackValues(idx, data);
+
+	// Set the block info:
+	(self->*Fn)(coords.x, coords.y, coords.z, data);
+	return 0;
+}
+
+
+
+
+
+/** Templated bindings for the SetRelBlock___() functions.
+DataType is either BLOCKTYPE or NIBBLETYPE.
+DataTypeFlag is the ba___ constant used for the datatypebeing manipulated.
+Fn is the setter function.
+Also supports the Vector3i overloads (TODO: document these (?)). */
+template <
+	typename DataType,
+	int DataTypeFlag,
+	void (cBlockArea::*Fn)(int, int, int, DataType)
+>
+static int SetRelBlock(lua_State * a_LuaState)
+{
+	// Check the common params:
+	cLuaState L(a_LuaState);
+	if (!L.CheckParamSelf("cBlockArea"))
+	{
+		return 0;
+	}
+
+	// Read the common params:
+	cBlockArea * self;
+	if (!L.GetStackValues(1, self))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "Cannot read the 'self' param.");
+	}
+
+	// Check the datatype's presence:
+	if ((self->GetDataTypes() & DataTypeFlag) == 0)
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "The area doesn't contain the datatype (%d).", DataTypeFlag);
+	}
+
+	// Read the overloaded params:
+	Vector3i coords;
+	auto idx = readVector3iOverloadParams(L, 2, coords, "coords");
+	if (!self->IsValidRelCoords(coords))
+	{
+		return cManualBindings::ApiParamError(a_LuaState, "The coords ({%d, %d, %d}) are out of range ({%d, %d, %d}).",
+			coords.x, coords.y, coords.z,
+			self->GetSizeX(), self->GetSizeY(), self->GetSizeZ()
+		);
+	}
+	DataType data;
+	L.GetStackValues(idx, data);
+
+	// Set the block info:
+	(self->*Fn)(coords.x, coords.y, coords.z, data);
+	return 0;
+}
+
+
+
+
+
+void cManualBindings::BindBlockArea(lua_State * a_LuaState)
+{
+	tolua_beginmodule(a_LuaState, nullptr);
+		tolua_beginmodule(a_LuaState, "cBlockArea");
+			tolua_function(a_LuaState, "Create",                  tolua_cBlockArea_Create);
+			tolua_function(a_LuaState, "DoWithBlockEntityAt",     DoWithXYZ<cBlockArea, cBlockEntity, &cBlockArea::DoWithBlockEntityAt,    &cBlockArea::IsValidCoords>);
+			tolua_function(a_LuaState, "DoWithBlockEntityRelAt",  DoWithXYZ<cBlockArea, cBlockEntity, &cBlockArea::DoWithBlockEntityRelAt, &cBlockArea::IsValidRelCoords>);
+			tolua_function(a_LuaState, "FillRelCuboid",           tolua_cBlockArea_FillRelCuboid);
+			tolua_function(a_LuaState, "ForEachBlockEntity",      ForEach<  cBlockArea, cBlockEntity, &cBlockArea::ForEachBlockEntity>);
+			tolua_function(a_LuaState, "GetBlockLight",           GetBlock<NIBBLETYPE, cBlockArea::baLight,    &cBlockArea::GetRelBlockLight>);
+			tolua_function(a_LuaState, "GetBlockMeta",            GetBlock<NIBBLETYPE, cBlockArea::baMetas,    &cBlockArea::GetRelBlockMeta>);
+			tolua_function(a_LuaState, "GetBlockSkyLight",        GetBlock<NIBBLETYPE, cBlockArea::baSkyLight, &cBlockArea::GetRelBlockSkyLight>);
+			tolua_function(a_LuaState, "GetBlockType",            GetBlock<BLOCKTYPE,  cBlockArea::baTypes,    &cBlockArea::GetRelBlockType>);
+			tolua_function(a_LuaState, "GetBlockTypeMeta",        tolua_cBlockArea_GetBlockTypeMeta);
+			tolua_function(a_LuaState, "GetCoordRange",           tolua_cBlockArea_GetCoordRange);
+			tolua_function(a_LuaState, "GetNonAirCropRelCoords",  tolua_cBlockArea_GetNonAirCropRelCoords);
+			tolua_function(a_LuaState, "GetOrigin",               tolua_cBlockArea_GetOrigin);
+			tolua_function(a_LuaState, "GetRelBlockLight",        GetRelBlock<NIBBLETYPE, cBlockArea::baLight,    &cBlockArea::GetRelBlockLight>);
+			tolua_function(a_LuaState, "GetRelBlockMeta",         GetRelBlock<NIBBLETYPE, cBlockArea::baMetas,    &cBlockArea::GetRelBlockMeta>);
+			tolua_function(a_LuaState, "GetRelBlockSkyLight",     GetRelBlock<NIBBLETYPE, cBlockArea::baSkyLight, &cBlockArea::GetRelBlockSkyLight>);
+			tolua_function(a_LuaState, "GetRelBlockType",         GetRelBlock<BLOCKTYPE,  cBlockArea::baTypes,    &cBlockArea::GetRelBlockType>);
+			tolua_function(a_LuaState, "GetRelBlockTypeMeta",     tolua_cBlockArea_GetRelBlockTypeMeta);
+			tolua_function(a_LuaState, "GetSize",                 tolua_cBlockArea_GetSize);
+			tolua_function(a_LuaState, "LoadFromSchematicFile",   tolua_cBlockArea_LoadFromSchematicFile);
+			tolua_function(a_LuaState, "LoadFromSchematicString", tolua_cBlockArea_LoadFromSchematicString);
+			tolua_function(a_LuaState, "Read",                    tolua_cBlockArea_Read);
+			tolua_function(a_LuaState, "RelLine",                 tolua_cBlockArea_RelLine);
+			tolua_function(a_LuaState, "SaveToSchematicFile",     tolua_cBlockArea_SaveToSchematicFile);
+			tolua_function(a_LuaState, "SaveToSchematicString",   tolua_cBlockArea_SaveToSchematicString);
+			tolua_function(a_LuaState, "SetBlockType",            SetBlock<BLOCKTYPE,  cBlockArea::baTypes,    &cBlockArea::SetRelBlockType>);
+			tolua_function(a_LuaState, "SetBlockMeta",            SetBlock<NIBBLETYPE, cBlockArea::baMetas,    &cBlockArea::SetRelBlockMeta>);
+			tolua_function(a_LuaState, "SetBlockLight",           SetBlock<NIBBLETYPE, cBlockArea::baLight,    &cBlockArea::SetRelBlockLight>);
+			tolua_function(a_LuaState, "SetBlockSkyLight",        SetBlock<NIBBLETYPE, cBlockArea::baSkyLight, &cBlockArea::SetRelBlockSkyLight>);
+			tolua_function(a_LuaState, "SetRelBlockType",         SetRelBlock<BLOCKTYPE,  cBlockArea::baTypes,    &cBlockArea::SetRelBlockType>);
+			tolua_function(a_LuaState, "SetRelBlockMeta",         SetRelBlock<NIBBLETYPE, cBlockArea::baMetas,    &cBlockArea::SetRelBlockMeta>);
+			tolua_function(a_LuaState, "SetRelBlockLight",        SetRelBlock<NIBBLETYPE, cBlockArea::baLight,    &cBlockArea::SetRelBlockLight>);
+			tolua_function(a_LuaState, "SetRelBlockSkyLight",     SetRelBlock<NIBBLETYPE, cBlockArea::baSkyLight, &cBlockArea::SetRelBlockSkyLight>);
+			tolua_function(a_LuaState, "Write",                   tolua_cBlockArea_Write);
+		tolua_endmodule(a_LuaState);
+	tolua_endmodule(a_LuaState);
+}
+
+
+
+
diff --git a/src/BlockArea.cpp b/src/BlockArea.cpp
index bca5544f9..a35c391fa 100644
--- a/src/BlockArea.cpp
+++ b/src/BlockArea.cpp
@@ -14,6 +14,7 @@
 #include "Blocks/BlockHandler.h"
 #include "Cuboid.h"
 #include "ChunkData.h"
+#include "BlockEntities/BlockEntity.h"
 
 
 
@@ -317,12 +318,37 @@ cBlockArea::~cBlockArea()
 
 
 
+bool cBlockArea::IsValidDataTypeCombination(int a_DataTypes)
+{
+	// BlockEntities require that BlockTypes be present, too
+	if ((a_DataTypes & baBlockEntities) != 0)
+	{
+		if ((a_DataTypes & baTypes) == 0)
+		{
+			return false;
+		}
+	}
+
+	// All other combinations are considered valid
+	return true;
+}
+
+
+
+
+
 void cBlockArea::Clear(void)
 {
 	delete[] m_BlockTypes;    m_BlockTypes    = nullptr;
 	delete[] m_BlockMetas;    m_BlockMetas    = nullptr;
 	delete[] m_BlockLight;    m_BlockLight    = nullptr;
 	delete[] m_BlockSkyLight; m_BlockSkyLight = nullptr;
+	if (m_BlockEntities != nullptr)
+	{
+		ClearBlockEntities(*m_BlockEntities);
+		m_BlockEntities.reset();
+	}
+	m_BlockEntities.reset();
 	m_Origin.Set(0, 0, 0);
 	m_Size.Set(0, 0, 0);
 }
@@ -333,13 +359,10 @@ void cBlockArea::Clear(void)
 
 void cBlockArea::Create(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes)
 {
-	if ((a_SizeX < 0) || (a_SizeY < 0) || (a_SizeZ < 0))
-	{
-		LOGWARNING("Creating a cBlockArea with a negative size! Call to Create ignored. (%d, %d, %d)",
-			a_SizeX, a_SizeY, a_SizeZ
-		);
-		return;
-	}
+	ASSERT(a_SizeX > 0);
+	ASSERT(a_SizeY > 0);
+	ASSERT(a_SizeZ > 0);
+	ASSERT(IsValidDataTypeCombination(a_DataTypes));
 
 	// Warn if the height is too much, but proceed with the creation:
 	if (a_SizeY > cChunkDef::Height)
@@ -381,6 +404,10 @@ void cBlockArea::Create(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes)
 			m_BlockSkyLight[i] = 0x0f;
 		}
 	}
+	if ((a_DataTypes & baBlockEntities) != 0)
+	{
+		m_BlockEntities = cpp14::make_unique<cBlockEntities>();
+	}
 	m_Size.Set(a_SizeX, a_SizeY, a_SizeZ);
 	m_Origin.Set(0, 0, 0);
 }
@@ -434,57 +461,60 @@ void cBlockArea::SetOrigin(const Vector3i & a_Origin)
 
 
 
+bool cBlockArea::IsValidRelCoords(int a_RelX, int a_RelY, int a_RelZ) const
+{
+	return (
+		(a_RelX >= 0) && (a_RelX < m_Size.x) &&
+		(a_RelY >= 0) && (a_RelY < m_Size.y) &&
+		(a_RelZ >= 0) && (a_RelZ < m_Size.z)
+	);
+}
+
+
+
+
+
+bool cBlockArea::IsValidRelCoords(const Vector3i & a_RelCoords) const
+{
+	return IsValidRelCoords(a_RelCoords.x, a_RelCoords.y, a_RelCoords.z);
+}
+
+
+
+
+
+bool cBlockArea::IsValidCoords(int a_BlockX, int a_BlockY, int a_BlockZ) const
+{
+	return IsValidRelCoords(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z);
+}
+
+
+
+
+
+bool cBlockArea::IsValidCoords(const Vector3i & a_Coords) const
+{
+	return IsValidRelCoords(a_Coords - m_Origin);
+}
+
+
+
+
+
 bool cBlockArea::Read(cForEachChunkProvider & a_ForEachChunkProvider, int a_MinBlockX, int a_MaxBlockX, int a_MinBlockY, int a_MaxBlockY, int a_MinBlockZ, int a_MaxBlockZ, int a_DataTypes)
 {
-	// Normalize the coords:
-	if (a_MinBlockX > a_MaxBlockX)
-	{
-		std::swap(a_MinBlockX, a_MaxBlockX);
-	}
-	if (a_MinBlockY > a_MaxBlockY)
-	{
-		std::swap(a_MinBlockY, a_MaxBlockY);
-	}
-	if (a_MinBlockZ > a_MaxBlockZ)
-	{
-		std::swap(a_MinBlockZ, a_MaxBlockZ);
-	}
+	ASSERT(IsValidDataTypeCombination(a_DataTypes));
+	ASSERT(cChunkDef::IsValidHeight(a_MinBlockY));
+	ASSERT(cChunkDef::IsValidHeight(a_MaxBlockY));
+	ASSERT(a_MinBlockX <= a_MaxBlockX);
+	ASSERT(a_MinBlockY <= a_MaxBlockX);
+	ASSERT(a_MinBlockZ <= a_MaxBlockZ);
 
 	// Include the Max coords:
 	a_MaxBlockX += 1;
 	a_MaxBlockY += 1;
 	a_MaxBlockZ += 1;
 
-	// Check coords validity:
-	if (a_MinBlockY < 0)
-	{
-		LOGWARNING("%s: MinBlockY less than zero, adjusting to zero. Coords: {%d, %d, %d} - {%d, %d, %d}",
-			__FUNCTION__, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_MaxBlockX, a_MaxBlockY, a_MaxBlockZ
-		);
-		a_MinBlockY = 0;
-	}
-	else if (a_MinBlockY >= cChunkDef::Height)
-	{
-		LOGWARNING("%s: MinBlockY more than chunk height, adjusting to chunk height. Coords: {%d, %d, %d} - {%d, %d, %d}",
-			__FUNCTION__, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_MaxBlockX, a_MaxBlockY, a_MaxBlockZ
-		);
-		a_MinBlockY = cChunkDef::Height - 1;
-	}
-	if (a_MaxBlockY < 0)
-	{
-		LOGWARNING("%s: MaxBlockY less than zero, adjusting to zero. Coords: {%d, %d, %d} - {%d, %d, %d}",
-			__FUNCTION__, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_MaxBlockX, a_MaxBlockY, a_MaxBlockZ
-		);
-		a_MaxBlockY = 0;
-	}
-	else if (a_MaxBlockY > cChunkDef::Height)
-	{
-		LOGWARNING("%s: MaxBlockY more than chunk height, adjusting to chunk height. Coords: {%d, %d, %d} - {%d, %d, %d}",
-			__FUNCTION__, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_MaxBlockX, a_MaxBlockY, a_MaxBlockZ
-		);
-		a_MaxBlockY = cChunkDef::Height;
-	}
-
 	// Allocate the needed memory:
 	Clear();
 	if (!SetSize(a_MaxBlockX - a_MinBlockX, a_MaxBlockY - a_MinBlockY, a_MaxBlockZ - a_MinBlockZ, a_DataTypes))
@@ -547,19 +577,8 @@ bool cBlockArea::Read(cForEachChunkProvider & a_ForEachChunkProvider, const Vect
 bool cBlockArea::Write(cForEachChunkProvider & a_ForEachChunkProvider, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes)
 {
 	ASSERT((a_DataTypes & GetDataTypes()) == a_DataTypes);  // Are you requesting only the data that I have?
-	a_DataTypes = a_DataTypes & GetDataTypes();  // For release builds, silently cut off the datatypes that I don't have
-
-	// Check coords validity:
-	if (a_MinBlockY < 0)
-	{
-		LOGWARNING("%s: MinBlockY less than zero, adjusting to zero", __FUNCTION__);
-		a_MinBlockY = 0;
-	}
-	else if (a_MinBlockY > cChunkDef::Height - m_Size.y)
-	{
-		LOGWARNING("%s: MinBlockY + m_SizeY more than chunk height, adjusting to chunk height", __FUNCTION__);
-		a_MinBlockY = std::max(cChunkDef::Height - m_Size.y, 0);
-	}
+	ASSERT(cChunkDef::IsValidHeight(a_MinBlockY));
+	ASSERT(cChunkDef::IsValidHeight(a_MinBlockY + m_Size.y - 1));
 
 	return a_ForEachChunkProvider.WriteBlockArea(*this, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_DataTypes);
 }
@@ -609,6 +628,15 @@ void cBlockArea::CopyTo(cBlockArea & a_Into) const
 	{
 		memcpy(a_Into.m_BlockSkyLight, m_BlockSkyLight, BlockCount * sizeof(NIBBLETYPE));
 	}
+	if (HasBlockEntities())
+	{
+		ClearBlockEntities(*(a_Into.m_BlockEntities));
+		for (const auto & keyPair: *m_BlockEntities)
+		{
+			const auto & pos = keyPair.second->GetPos();
+			a_Into.m_BlockEntities->insert({keyPair.first, keyPair.second->Clone(pos.x, pos.y, pos.z)});
+		}
+	}
 }
 
 
@@ -705,6 +733,40 @@ void cBlockArea::Crop(int a_AddMinX, int a_SubMaxX, int a_AddMinY, int a_SubMaxY
 	{
 		CropNibbles(m_BlockSkyLight, a_AddMinX, a_SubMaxX, a_AddMinY, a_SubMaxY, a_AddMinZ, a_SubMaxZ);
 	}
+
+	auto maxX = m_Size.x - a_SubMaxX;
+	auto maxY = m_Size.y - a_SubMaxY;
+	auto maxZ = m_Size.z - a_SubMaxZ;
+
+	// Move and crop block Entities:
+	cBlockEntities oldBE;
+	std::swap(oldBE, *m_BlockEntities);
+	for (const auto & keyPair: oldBE)
+	{
+		auto & be = keyPair.second;
+		auto posX = be->GetPosX();
+		auto posY = be->GetPosY();
+		auto posZ = be->GetPosZ();
+		if (
+			(posX < a_AddMinX) || (posX >= maxX) ||
+			(posY < a_AddMinY) || (posY >= maxY) ||
+			(posZ < a_AddMinZ) || (posZ >= maxZ)
+		)
+		{
+			// The block entity is out of new coord range, remove it:
+			delete be;
+		}
+		else
+		{
+			// The block entity is within the new coords, recalculate its coords to match the new area:
+			posX -= a_AddMinX;
+			posY -= a_AddMinY;
+			posZ -= a_AddMinZ;
+			be->SetPos(posX, posY, posZ);
+			m_BlockEntities->insert({MakeIndex(posX, posY, posZ), std::move(be)});
+		}
+	}
+
 	m_Origin.Move(a_AddMinX, a_AddMinY, a_AddMinZ);
 	m_Size.x -= a_AddMinX + a_SubMaxX;
 	m_Size.y -= a_AddMinY + a_SubMaxY;
@@ -733,6 +795,20 @@ void cBlockArea::Expand(int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMa
 	{
 		ExpandNibbles(m_BlockSkyLight, a_SubMinX, a_AddMaxX, a_SubMinY, a_AddMaxY, a_SubMinZ, a_AddMaxZ);
 	}
+
+	// Move block entities:
+	cBlockEntities oldBE;
+	std::swap(oldBE, *m_BlockEntities);
+	for (const auto & keyPair: oldBE)
+	{
+		auto & be = keyPair.second;
+		auto posX = be->GetPosX() + a_SubMinX;
+		auto posY = be->GetPosY() + a_SubMinY;
+		auto posZ = be->GetPosZ() + a_SubMinZ;
+		be->SetPos(posX, posY, posZ);
+		m_BlockEntities->insert({MakeIndex(posX, posY, posZ), std::move(be)});
+	}
+
 	m_Origin.Move(-a_SubMinX, -a_SubMinY, -a_SubMinZ);
 	m_Size.x += a_SubMinX + a_AddMaxX;
 	m_Size.y += a_SubMinY + a_AddMaxY;
@@ -813,6 +889,12 @@ void cBlockArea::Fill(int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_Block
 			m_BlockSkyLight[i] = a_BlockSkyLight;
 		}
 	}
+
+	// If the area contains block entities, remove those not matching and replace with whatever block entity block was filled
+	if (HasBlockEntities() && ((a_DataTypes & baTypes) != 0))
+	{
+		RescanBlockEntities();
+	}
 }
 
 
@@ -860,6 +942,12 @@ void cBlockArea::FillRelCuboid(int a_MinRelX, int a_MaxRelX, int a_MinRelY, int
 			m_BlockSkyLight[MakeIndex(x, y, z)] = a_BlockSkyLight;
 		}  // for x, z, y
 	}
+
+	// If the area contains block entities, remove those in the affected cuboid and replace with whatever block entity block was filled:
+	if (HasBlockEntities() && ((a_DataTypes & baTypes) != 0))
+	{
+		RescanBlockEntities();
+	}
 }
 
 
@@ -1054,6 +1142,23 @@ void cBlockArea::RotateCCW(void)
 	delete[] NewTypes;   NewTypes = nullptr;
 	delete[] NewMetas;   NewMetas = nullptr;
 
+	// Rotate the BlockEntities:
+	if (HasBlockEntities())
+	{
+		cBlockEntities oldBE;
+		std::swap(oldBE, *m_BlockEntities);
+		for (const auto & keyPair: oldBE)
+		{
+			auto & be = keyPair.second;
+			auto newX = be->GetPosZ();
+			auto newY = be->GetPosY();
+			auto newZ = m_Size.x - be->GetPosX() - 1;
+			auto newIdx = newX + newZ * m_Size.z + newY * m_Size.x * m_Size.z;
+			be->SetPos(newX, newY, newZ);
+			m_BlockEntities->insert({newIdx, std::move(be)});
+		}
+	}
+
 	std::swap(m_Size.x, m_Size.z);
 }
 
@@ -1099,6 +1204,23 @@ void cBlockArea::RotateCW(void)
 	delete[] NewTypes;   NewTypes = nullptr;
 	delete[] NewMetas;   NewMetas = nullptr;
 
+	// Rotate the BlockEntities:
+	if (HasBlockEntities())
+	{
+		cBlockEntities oldBE;
+		std::swap(oldBE, *m_BlockEntities);
+		for (const auto & keyPair: oldBE)
+		{
+			auto & be = keyPair.second;
+			auto newX = m_Size.z - be->GetPosZ() - 1;
+			auto newY = be->GetPosY();
+			auto newZ = be->GetPosX();
+			auto newIdx = newX + newZ * m_Size.z + newY * m_Size.x * m_Size.z;
+			be->SetPos(newX, newY, newZ);
+			m_BlockEntities->insert({newIdx, std::move(be)});
+		}
+	}
+
 	std::swap(m_Size.x, m_Size.z);
 }
 
@@ -1140,6 +1262,23 @@ void cBlockArea::MirrorXY(void)
 			}  // for x
 		}  // for z
 	}  // for y
+
+	// Mirror the BlockEntities:
+	if (HasBlockEntities())
+	{
+		cBlockEntities oldBE;
+		std::swap(oldBE, *m_BlockEntities);
+		for (const auto & keyPair: oldBE)
+		{
+			auto & be = keyPair.second;
+			auto newX = be->GetPosX();
+			auto newY = be->GetPosY();
+			auto newZ = MaxZ - be->GetPosZ();
+			auto newIdx = MakeIndex(newX, newY, newZ);
+			be->SetPos(newX, newY, newZ);
+			m_BlockEntities->insert({newIdx, std::move(be)});
+		}
+	}
 }
 
 
@@ -1180,6 +1319,23 @@ void cBlockArea::MirrorXZ(void)
 			}  // for x
 		}  // for z
 	}  // for y
+
+	// Mirror the BlockEntities:
+	if (HasBlockEntities())
+	{
+		cBlockEntities oldBE;
+		std::swap(oldBE, *m_BlockEntities);
+		for (const auto & keyPair: oldBE)
+		{
+			auto & be = keyPair.second;
+			auto newX = be->GetPosX();
+			auto newY = MaxY - be->GetPosY();
+			auto newZ = be->GetPosZ();
+			auto newIdx = MakeIndex(newX, newY, newZ);
+			be->SetPos(newX, newY, newZ);
+			m_BlockEntities->insert({newIdx, std::move(be)});
+		}
+	}
 }
 
 
@@ -1220,6 +1376,23 @@ void cBlockArea::MirrorYZ(void)
 			}  // for x
 		}  // for z
 	}  // for y
+
+	// Mirror the BlockEntities:
+	if (HasBlockEntities())
+	{
+		cBlockEntities oldBE;
+		std::swap(oldBE, *m_BlockEntities);
+		for (const auto & keyPair: oldBE)
+		{
+			auto & be = keyPair.second;
+			auto newX = MaxX - be->GetPosX();
+			auto newY = be->GetPosY();
+			auto newZ = be->GetPosZ();
+			auto newIdx = MakeIndex(newX, newY, newZ);
+			be->SetPos(newX, newY, newZ);
+			m_BlockEntities->insert({newIdx, std::move(be)});
+		}
+	}
 }
 
 
@@ -1264,6 +1437,24 @@ void cBlockArea::RotateCCWNoMeta(void)
 		std::swap(m_BlockMetas, NewMetas);
 		delete[] NewMetas;   NewMetas = nullptr;
 	}
+
+	// Rotate the BlockEntities:
+	if (HasBlockEntities())
+	{
+		cBlockEntities oldBE;
+		std::swap(oldBE, *m_BlockEntities);
+		for (const auto & keyPair: oldBE)
+		{
+			auto & be = keyPair.second;
+			auto newX = be->GetPosZ();
+			auto newY = be->GetPosY();
+			auto newZ = m_Size.x - be->GetPosX() - 1;
+			auto newIdx = newX + newZ * m_Size.z + newY * m_Size.x * m_Size.z;
+			be->SetPos(newX, newY, newZ);
+			m_BlockEntities->insert({newIdx, std::move(be)});
+		}
+	}
+
 	std::swap(m_Size.x, m_Size.z);
 }
 
@@ -1309,6 +1500,24 @@ void cBlockArea::RotateCWNoMeta(void)
 		std::swap(m_BlockMetas, NewMetas);
 		delete[] NewMetas;   NewMetas = nullptr;
 	}
+
+	// Rotate the BlockEntities:
+	if (HasBlockEntities())
+	{
+		cBlockEntities oldBE;
+		std::swap(oldBE, *m_BlockEntities);
+		for (const auto & keyPair: oldBE)
+		{
+			auto & be = keyPair.second;
+			auto newX = m_Size.z - be->GetPosZ() - 1;
+			auto newY = be->GetPosY();
+			auto newZ = be->GetPosX();
+			auto newIdx = newX + newZ * m_Size.z + newY * m_Size.x * m_Size.z;
+			be->SetPos(newX, newY, newZ);
+			m_BlockEntities->insert({newIdx, std::move(be)});
+		}
+	}
+
 	std::swap(m_Size.x, m_Size.z);
 }
 
@@ -1347,6 +1556,23 @@ void cBlockArea::MirrorXYNoMeta(void)
 			}  // for z
 		}  // for y
 	}  // if (HasBlockMetas)
+
+	// Mirror the BlockEntities:
+	if (HasBlockEntities())
+	{
+		cBlockEntities oldBE;
+		std::swap(oldBE, *m_BlockEntities);
+		for (const auto & keyPair: oldBE)
+		{
+			auto & be = keyPair.second;
+			auto newX = be->GetPosX();
+			auto newY = be->GetPosY();
+			auto newZ = MaxZ - be->GetPosZ();
+			auto newIdx = MakeIndex(newX, newY, newZ);
+			be->SetPos(newX, newY, newZ);
+			m_BlockEntities->insert({newIdx, std::move(be)});
+		}
+	}
 }
 
 
@@ -1384,6 +1610,23 @@ void cBlockArea::MirrorXZNoMeta(void)
 			}  // for z
 		}  // for y
 	}  // if (HasBlockMetas)
+
+	// Mirror the BlockEntities:
+	if (HasBlockEntities())
+	{
+		cBlockEntities oldBE;
+		std::swap(oldBE, *m_BlockEntities);
+		for (const auto & keyPair: oldBE)
+		{
+			auto & be = keyPair.second;
+			auto newX = be->GetPosX();
+			auto newY = MaxY - be->GetPosY();
+			auto newZ = be->GetPosZ();
+			auto newIdx = MakeIndex(newX, newY, newZ);
+			be->SetPos(newX, newY, newZ);
+			m_BlockEntities->insert({newIdx, std::move(be)});
+		}
+	}
 }
 
 
@@ -1421,6 +1664,23 @@ void cBlockArea::MirrorYZNoMeta(void)
 			}  // for z
 		}  // for y
 	}  // if (HasBlockMetas)
+
+	// Mirror the BlockEntities:
+	if (HasBlockEntities())
+	{
+		cBlockEntities oldBE;
+		std::swap(oldBE, *m_BlockEntities);
+		for (const auto & keyPair: oldBE)
+		{
+			auto & be = keyPair.second;
+			auto newX = MaxX - be->GetPosX();
+			auto newY = be->GetPosY();
+			auto newZ = be->GetPosZ();
+			auto newIdx = MakeIndex(newX, newY, newZ);
+			be->SetPos(newX, newY, newZ);
+			m_BlockEntities->insert({newIdx, std::move(be)});
+		}
+	}
 }
 
 
@@ -1429,12 +1689,29 @@ void cBlockArea::MirrorYZNoMeta(void)
 
 void cBlockArea::SetRelBlockType(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType)
 {
-	if (m_BlockTypes == nullptr)
+	ASSERT(m_BlockTypes != nullptr);
+	auto idx = MakeIndex(a_RelX, a_RelY, a_RelZ);
+	m_BlockTypes[idx] = a_BlockType;
+
+	// Update the block entities, if appropriate:
+	if (HasBlockEntities())
 	{
-		LOGWARNING("cBlockArea: BlockTypes have not been read!");
-		return;
+		auto itr = m_BlockEntities->find(idx);
+		if (itr != m_BlockEntities->end())
+		{
+			if (itr->second->GetBlockType() == a_BlockType)
+			{
+				// The block entity is for the same block type, keep the current one
+				return;
+			}
+			m_BlockEntities->erase(itr);
+		}
+		if (cBlockEntity::IsBlockEntityBlockType(a_BlockType))
+		{
+			NIBBLETYPE meta = HasBlockMetas() ? m_BlockMetas[idx] : 0;
+			m_BlockEntities->insert({idx, cBlockEntity::CreateByBlockType(a_BlockType, meta, a_RelX, a_RelY, a_RelZ)});
+		}
 	}
-	m_BlockTypes[MakeIndex(a_RelX, a_RelY, a_RelZ)] = a_BlockType;
 }
 
 
@@ -1609,6 +1886,25 @@ void cBlockArea::SetRelBlockTypeMeta(int a_RelX,   int a_RelY,   int a_RelZ,   B
 	{
 		m_BlockMetas[idx] = a_BlockMeta;
 	}
+
+	// Update the block entities, if appropriate:
+	if (HasBlockEntities())
+	{
+		auto itr = m_BlockEntities->find(idx);
+		if (itr != m_BlockEntities->end())
+		{
+			if (itr->second->GetBlockType() == a_BlockType)
+			{
+				// The block entity is for the same block type, keep the current one
+				return;
+			}
+			m_BlockEntities->erase(itr);
+		}
+		if (cBlockEntity::IsBlockEntityBlockType(a_BlockType))
+		{
+			m_BlockEntities->insert({idx, cBlockEntity::CreateByBlockType(a_BlockType, a_BlockMeta, a_RelX, a_RelY, a_RelZ)});
+		}
+	}
 }
 
 
@@ -1828,6 +2124,10 @@ int cBlockArea::GetDataTypes(void) const
 	{
 		res |= baSkyLight;
 	}
+	if (m_BlockEntities != nullptr)
+	{
+		res |= baBlockEntities;
+	}
 	return res;
 }
 
@@ -1838,8 +2138,9 @@ int cBlockArea::GetDataTypes(void) const
 bool cBlockArea::SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes)
 {
 	ASSERT(m_BlockTypes == nullptr);  // Has been cleared
+	ASSERT(IsValidDataTypeCombination(a_DataTypes));
 
-	if (a_DataTypes & baTypes)
+	if ((a_DataTypes & baTypes) != 0)
 	{
 		m_BlockTypes = new BLOCKTYPE[a_SizeX * a_SizeY * a_SizeZ];
 		if (m_BlockTypes == nullptr)
@@ -1847,7 +2148,7 @@ bool cBlockArea::SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes)
 			return false;
 		}
 	}
-	if (a_DataTypes & baMetas)
+	if ((a_DataTypes & baMetas) != 0)
 	{
 		m_BlockMetas = new NIBBLETYPE[a_SizeX * a_SizeY * a_SizeZ];
 		if (m_BlockMetas == nullptr)
@@ -1857,7 +2158,7 @@ bool cBlockArea::SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes)
 			return false;
 		}
 	}
-	if (a_DataTypes & baLight)
+	if ((a_DataTypes & baLight) != 0)
 	{
 		m_BlockLight = new NIBBLETYPE[a_SizeX * a_SizeY * a_SizeZ];
 		if (m_BlockLight == nullptr)
@@ -1869,7 +2170,7 @@ bool cBlockArea::SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes)
 			return false;
 		}
 	}
-	if (a_DataTypes & baSkyLight)
+	if ((a_DataTypes & baSkyLight) != 0)
 	{
 		m_BlockSkyLight = new NIBBLETYPE[a_SizeX * a_SizeY * a_SizeZ];
 		if (m_BlockSkyLight == nullptr)
@@ -1883,6 +2184,22 @@ bool cBlockArea::SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes)
 			return false;
 		}
 	}
+	if ((a_DataTypes & baBlockEntities) != 0)
+	{
+		m_BlockEntities = cpp14::make_unique<cBlockEntities>();
+		if (m_BlockEntities == nullptr)
+		{
+			delete[] m_BlockSkyLight;
+			m_BlockSkyLight = nullptr;
+			delete[] m_BlockLight;
+			m_BlockLight = nullptr;
+			delete[] m_BlockMetas;
+			m_BlockMetas = nullptr;
+			delete[] m_BlockTypes;
+			m_BlockTypes = nullptr;
+			return false;
+		}
+	}
 	m_Size.Set(a_SizeX, a_SizeY, a_SizeZ);
 	return true;
 }
@@ -1907,276 +2224,101 @@ int cBlockArea::MakeIndex(int a_RelX, int a_RelY, int a_RelZ) const
 
 
 
-void cBlockArea::SetRelNibble(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Value, NIBBLETYPE * a_Array)
+bool cBlockArea::DoWithBlockEntityRelAt(int a_RelX, int a_RelY, int a_RelZ, cItemCallback<cBlockEntity> & a_Callback)
 {
-	if (a_Array == nullptr)
+	ASSERT(IsValidRelCoords(a_RelX, a_RelY, a_RelZ));
+	if (!HasBlockEntities())
 	{
-		LOGWARNING("cBlockArea: datatype has not been read!");
-		return;
+		return false;
 	}
-	a_Array[MakeIndex(a_RelX, a_RelY, a_RelZ)] = a_Value;
+	auto idx = MakeIndex(a_RelX, a_RelY, a_RelZ);
+	auto itr = m_BlockEntities->find(idx);
+	if (itr == m_BlockEntities->end())
+	{
+		return false;
+	}
+	return a_Callback.Item(itr->second);
 }
 
 
 
 
 
-void cBlockArea::SetNibble(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Value, NIBBLETYPE * a_Array)
+bool cBlockArea::DoWithBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cItemCallback<cBlockEntity> & a_Callback)
 {
-	SetRelNibble(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z, a_Value, a_Array);
+	return DoWithBlockEntityRelAt(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z, a_Callback);
 }
 
 
 
 
 
-NIBBLETYPE cBlockArea::GetRelNibble(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE * a_Array) const
+bool cBlockArea::ForEachBlockEntity(cItemCallback<cBlockEntity> & a_Callback)
 {
-	if (a_Array == nullptr)
+	if (!HasBlockEntities())
 	{
-		LOGWARNING("cBlockArea: datatype has not been read!");
-		return 16;
+		return true;
 	}
-	return a_Array[MakeIndex(a_RelX, a_RelY, a_RelZ)];
+	for (auto & keyPair: *m_BlockEntities)
+	{
+		if (a_Callback.Item(keyPair.second))
+		{
+			return false;
+		}
+	}
+	return true;
 }
 
 
 
 
 
-NIBBLETYPE cBlockArea::GetNibble(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE * a_Array) const
+void cBlockArea::SetRelNibble(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Value, NIBBLETYPE * a_Array)
 {
-	return GetRelNibble(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z, a_Array);
+	if (a_Array == nullptr)
+	{
+		LOGWARNING("cBlockArea: datatype has not been read!");
+		return;
+	}
+	a_Array[MakeIndex(a_RelX, a_RelY, a_RelZ)] = a_Value;
 }
 
 
 
 
 
-
-////////////////////////////////////////////////////////////////////////////////
-// cBlockArea::cChunkReader:
-
-cBlockArea::cChunkReader::cChunkReader(cBlockArea & a_Area) :
-	m_Area(a_Area),
-	m_Origin(a_Area.m_Origin.x, a_Area.m_Origin.y, a_Area.m_Origin.z),
-	m_CurrentChunkX(0),
-	m_CurrentChunkZ(0)
+void cBlockArea::SetNibble(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Value, NIBBLETYPE * a_Array)
 {
+	SetRelNibble(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z, a_Value, a_Array);
 }
 
 
 
 
 
-void cBlockArea::cChunkReader::CopyNibbles(NIBBLETYPE * a_AreaDst, const NIBBLETYPE * a_ChunkSrc)
+NIBBLETYPE cBlockArea::GetRelNibble(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE * a_Array) const
 {
-	int SizeY = m_Area.m_Size.y;
-	int MinY = m_Origin.y;
-
-	// SizeX, SizeZ are the dmensions of the block data to copy from the current chunk (size of the geometric union)
-	// OffX, OffZ are the offsets of the current chunk data from the area origin
-	// BaseX, BaseZ are the offsets of the area data within the current chunk from the chunk borders
-	int SizeX = cChunkDef::Width;
-	int SizeZ = cChunkDef::Width;
-	int OffX, OffZ;
-	int BaseX, BaseZ;
-	OffX = m_CurrentChunkX * cChunkDef::Width - m_Origin.x;
-	if (OffX < 0)
-	{
-		BaseX = -OffX;
-		SizeX += OffX;  // SizeX is decreased, OffX is negative
-		OffX = 0;
-	}
-	else
-	{
-		BaseX = 0;
-	}
-	OffZ = m_CurrentChunkZ * cChunkDef::Width - m_Origin.z;
-	if (OffZ < 0)
-	{
-		BaseZ = -OffZ;
-		SizeZ += OffZ;  // SizeZ is decreased, OffZ is negative
-		OffZ = 0;
-	}
-	else
-	{
-		BaseZ = 0;
-	}
-	// If the chunk extends beyond the area in the X or Z axis, cut off the Size:
-	if ((m_CurrentChunkX + 1) * cChunkDef::Width > m_Origin.x + m_Area.m_Size.x)
-	{
-		SizeX -= (m_CurrentChunkX + 1) * cChunkDef::Width - (m_Origin.x + m_Area.m_Size.x);
-	}
-	if ((m_CurrentChunkZ + 1) * cChunkDef::Width > m_Origin.z + m_Area.m_Size.z)
+	if (a_Array == nullptr)
 	{
-		SizeZ -= (m_CurrentChunkZ + 1) * cChunkDef::Width - (m_Origin.z + m_Area.m_Size.z);
+		LOGWARNING("cBlockArea: datatype has not been read!");
+		return 16;
 	}
-
-	for (int y = 0; y < SizeY; y++)
-	{
-		int ChunkY = MinY + y;
-		int AreaY = y;
-		for (int z = 0; z < SizeZ; z++)
-		{
-			int ChunkZ = BaseZ + z;
-			int AreaZ = OffZ + z;
-			for (int x = 0; x < SizeX; x++)
-			{
-				int ChunkX = BaseX + x;
-				int AreaX = OffX + x;
-				a_AreaDst[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = cChunkDef::GetNibble(a_ChunkSrc, ChunkX, ChunkY, ChunkZ);
-			}  // for x
-		}  // for z
-	}  // for y
+	return a_Array[MakeIndex(a_RelX, a_RelY, a_RelZ)];
 }
 
 
 
 
 
-bool cBlockArea::cChunkReader::Coords(int a_ChunkX, int a_ChunkZ)
+NIBBLETYPE cBlockArea::GetNibble(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE * a_Array) const
 {
-	m_CurrentChunkX = a_ChunkX;
-	m_CurrentChunkZ = a_ChunkZ;
-	return true;
+	return GetRelNibble(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z, a_Array);
 }
 
 
 
 
 
-void cBlockArea::cChunkReader::ChunkData(const cChunkData & a_BlockBuffer)
-{
-	int SizeY = m_Area.m_Size.y;
-	int MinY = m_Origin.y;
-
-	// SizeX, SizeZ are the dimensions of the block data to copy from the current chunk (size of the geometric union)
-	// OffX, OffZ are the offsets of the current chunk data from the area origin
-	// BaseX, BaseZ are the offsets of the area data within the current chunk from the chunk borders
-	int SizeX = cChunkDef::Width;
-	int SizeZ = cChunkDef::Width;
-	int OffX, OffZ;
-	int BaseX, BaseZ;
-	OffX = m_CurrentChunkX * cChunkDef::Width - m_Origin.x;
-	if (OffX < 0)
-	{
-		BaseX = -OffX;
-		SizeX += OffX;  // SizeX is decreased, OffX is negative
-		OffX = 0;
-	}
-	else
-	{
-		BaseX = 0;
-	}
-	OffZ = m_CurrentChunkZ * cChunkDef::Width - m_Origin.z;
-	if (OffZ < 0)
-	{
-		BaseZ = -OffZ;
-		SizeZ += OffZ;  // SizeZ is decreased, OffZ is negative
-		OffZ = 0;
-	}
-	else
-	{
-		BaseZ = 0;
-	}
-	// If the chunk extends beyond the area in the X or Z axis, cut off the Size:
-	if ((m_CurrentChunkX + 1) * cChunkDef::Width > m_Origin.x + m_Area.m_Size.x)
-	{
-		SizeX -= (m_CurrentChunkX + 1) * cChunkDef::Width - (m_Origin.x + m_Area.m_Size.x);
-	}
-	if ((m_CurrentChunkZ + 1) * cChunkDef::Width > m_Origin.z + m_Area.m_Size.z)
-	{
-		SizeZ -= (m_CurrentChunkZ + 1) * cChunkDef::Width - (m_Origin.z + m_Area.m_Size.z);
-	}
-
-	// Copy the blocktypes:
-	if (m_Area.m_BlockTypes != nullptr)
-	{
-		for (int y = 0; y < SizeY; y++)
-		{
-			int InChunkY = MinY + y;
-			int AreaY = y;
-			for (int z = 0; z < SizeZ; z++)
-			{
-				int InChunkZ = BaseZ + z;
-				int AreaZ = OffZ + z;
-				for (int x = 0; x < SizeX; x++)
-				{
-					int InChunkX = BaseX + x;
-					int AreaX = OffX + x;
-					m_Area.m_BlockTypes[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetBlock(InChunkX, InChunkY, InChunkZ);
-				}  // for x
-			}  // for z
-		}  // for y
-	}
-
-	// Copy the block metas:
-	if (m_Area.m_BlockMetas != nullptr)
-	{
-		for (int y = 0; y < SizeY; y++)
-		{
-			int InChunkY = MinY + y;
-			int AreaY = y;
-			for (int z = 0; z < SizeZ; z++)
-			{
-				int InChunkZ = BaseZ + z;
-				int AreaZ = OffZ + z;
-				for (int x = 0; x < SizeX; x++)
-				{
-					int InChunkX = BaseX + x;
-					int AreaX = OffX + x;
-					m_Area.m_BlockMetas[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetMeta(InChunkX, InChunkY, InChunkZ);
-				}  // for x
-			}  // for z
-		}  // for y
-	}
-
-	// Copy the blocklight:
-	if (m_Area.m_BlockLight != nullptr)
-	{
-		for (int y = 0; y < SizeY; y++)
-		{
-			int InChunkY = MinY + y;
-			int AreaY = y;
-			for (int z = 0; z < SizeZ; z++)
-			{
-				int InChunkZ = BaseZ + z;
-				int AreaZ = OffZ + z;
-				for (int x = 0; x < SizeX; x++)
-				{
-					int InChunkX = BaseX + x;
-					int AreaX = OffX + x;
-					m_Area.m_BlockLight[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetBlockLight(InChunkX, InChunkY, InChunkZ);
-				}  // for x
-			}  // for z
-		}  // for y
-	}
-
-	// Copy the skylight:
-	if (m_Area.m_BlockSkyLight != nullptr)
-	{
-		for (int y = 0; y < SizeY; y++)
-		{
-			int InChunkY = MinY + y;
-			int AreaY = y;
-			for (int z = 0; z < SizeZ; z++)
-			{
-				int InChunkZ = BaseZ + z;
-				int AreaZ = OffZ + z;
-				for (int x = 0; x < SizeX; x++)
-				{
-					int InChunkX = BaseX + x;
-					int AreaX = OffX + x;
-					m_Area.m_BlockSkyLight[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetSkyLight(InChunkX, InChunkY, InChunkZ);
-				}  // for x
-			}  // for z
-		}  // for y
-	}
-}
-
-
-
 
 void cBlockArea::CropBlockTypes(int a_AddMinX, int a_SubMaxX, int a_AddMinY, int a_SubMaxY, int a_AddMinZ, int a_SubMaxZ)
 {
@@ -2295,6 +2437,11 @@ void cBlockArea::RelSetData(
 	NIBBLETYPE a_BlockLight, NIBBLETYPE a_BlockSkyLight
 )
 {
+	if (!IsValidCoords(a_RelX, a_RelY, a_RelZ))
+	{
+		return;
+	}
+
 	int Index = MakeIndex(a_RelX, a_RelY, a_RelZ);
 	if ((a_DataTypes & baTypes) != 0)
 	{
@@ -2312,6 +2459,27 @@ void cBlockArea::RelSetData(
 	{
 		m_BlockSkyLight[Index] = a_BlockSkyLight;
 	}
+
+	// Update the block entities, if appropriate:
+	if (HasBlockEntities())
+	{
+		auto itr = m_BlockEntities->find(Index);
+		if (itr != m_BlockEntities->end())
+		{
+			if (itr->second->GetBlockType() == a_BlockType)
+			{
+				// The block entity is for the same block type, keep the current one
+				return;
+			}
+			// The block entity is for a different block type, remove it:
+			m_BlockEntities->erase(itr);
+		}
+		if (cBlockEntity::IsBlockEntityBlockType(a_BlockType))
+		{
+			// The block type should have a block entity attached to it, create an empty one:
+			m_BlockEntities->insert({Index, cBlockEntity::CreateByBlockType(a_BlockType, a_BlockMeta, a_RelX, a_RelY, a_RelZ)});
+		}
+	}
 }
 
 
@@ -2354,7 +2522,7 @@ void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_Rel
 				a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(),
 				m_Size.x, m_Size.y, m_Size.z
 			);
-			return;
+			break;
 		}  // case msOverwrite
 
 		case cBlockArea::msFillAir:
@@ -2368,7 +2536,7 @@ void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_Rel
 				a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(),
 				m_Size.x, m_Size.y, m_Size.z
 			);
-			return;
+			break;
 		}  // case msFillAir
 
 		case cBlockArea::msImprint:
@@ -2382,7 +2550,7 @@ void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_Rel
 				a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(),
 				m_Size.x, m_Size.y, m_Size.z
 			);
-			return;
+			break;
 		}  // case msImprint
 
 		case cBlockArea::msLake:
@@ -2396,7 +2564,7 @@ void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_Rel
 				a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(),
 				m_Size.x, m_Size.y, m_Size.z
 			);
-			return;
+			break;
 		}  // case msLake
 
 		case cBlockArea::msSpongePrint:
@@ -2410,7 +2578,7 @@ void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_Rel
 				a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(),
 				m_Size.x, m_Size.y, m_Size.z
 			);
-			return;
+			break;
 		}  // case msSpongePrint
 
 		case cBlockArea::msDifference:
@@ -2424,7 +2592,7 @@ void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_Rel
 				a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(),
 				m_Size.x, m_Size.y, m_Size.z
 			);
-			return;
+			break;
 		}  // case msDifference
 
 		case cBlockArea::msSimpleCompare:
@@ -2438,7 +2606,7 @@ void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_Rel
 				a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(),
 				m_Size.x, m_Size.y, m_Size.z
 			);
-			return;
+			break;
 		}  // case msSimpleCompare
 
 		case cBlockArea::msMask:
@@ -2452,14 +2620,407 @@ void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_Rel
 				a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(),
 				m_Size.x, m_Size.y, m_Size.z
 			);
-			return;
+			break;
 		}  // case msMask
+
+		#ifndef __clang__  // Clang complains about a default case in a switch with all cases covered
+		default:
+		{
+			LOGWARNING("Unknown block area merge strategy: %d", a_Strategy);
+			ASSERT(!"Unknown block area merge strategy");
+			return;
+		}
+		#endif
 	}  // switch (a_Strategy)
 
-	LOGWARNING("Unknown block area merge strategy: %d", a_Strategy);
-	ASSERT(!"Unknown block area merge strategy");
-	return;
+	if (HasBlockEntities())
+	{
+		if (a_Src.HasBlockEntities())
+		{
+			MergeBlockEntities(a_RelX, a_RelY, a_RelZ, a_Src);
+		}
+		else
+		{
+			RescanBlockEntities();
+		}
+	}
+}
+
+
+
+
+
+void cBlockArea::ClearBlockEntities(cBlockEntities & a_BlockEntities)
+{
+	for (auto & keyPair: a_BlockEntities)
+	{
+		delete keyPair.second;
+	}
+	a_BlockEntities.clear();
+}
+
+
+
+
+
+void cBlockArea::MergeBlockEntities(int a_RelX, int a_RelY, int a_RelZ, const cBlockArea & a_Src)
+{
+	// Only supported with both BlockEntities and BlockTypes (caller should check):
+	ASSERT(HasBlockTypes());
+	ASSERT(HasBlockEntities());
+	ASSERT(a_Src.HasBlockTypes());
+	ASSERT(a_Src.HasBlockEntities());
+
+	// Remove block entities that no longer match the block at their coords:
+	RemoveNonMatchingBlockEntities();
+
+	// Clone BEs from a_Src wherever a BE is missing:
+	for (int y = 0; y < m_Size.y; ++y) for (int z = 0; z < m_Size.z; ++z) for (int x = 0; x < m_Size.x; ++x)
+	{
+		auto idx = MakeIndex(x, y, z);
+		auto type = m_BlockTypes[idx];
+		if (!cBlockEntity::IsBlockEntityBlockType(type))
+		{
+			continue;
+		}
+
+		// This block should have a block entity, check that there is one:
+		auto itr = m_BlockEntities->find(idx);
+		if (itr != m_BlockEntities->end())
+		{
+			// There is one already
+			continue;
+		}
+
+		// Copy a BE from a_Src, if it exists there:
+		auto srcX = x + a_RelX;
+		auto srcY = y + a_RelY;
+		auto srcZ = z + a_RelZ;
+		if (a_Src.IsValidRelCoords(srcX, srcY, srcZ))
+		{
+			auto srcIdx = a_Src.MakeIndex(srcX, srcY, srcZ);
+			auto itrSrc = a_Src.m_BlockEntities->find(srcIdx);
+			if (itrSrc == a_Src.m_BlockEntities->end())
+			{
+				m_BlockEntities->insert({idx, itrSrc->second->Clone(x, y, z)});
+				continue;
+			}
+		}
+		// No BE found in a_Src, insert a new empty one:
+		NIBBLETYPE meta = HasBlockMetas() ? m_BlockMetas[idx] : 0;
+		m_BlockEntities->insert({idx, cBlockEntity::CreateByBlockType(type, meta, x, y, z)});
+	}  // for x, z, y
+}
+
+
+
+
+
+void cBlockArea::RescanBlockEntities(void)
+{
+	// Only supported with both BlockEntities and BlockTypes
+	if (!HasBlockEntities() || !HasBlockTypes())
+	{
+		return;
+	}
+
+	// Remove block entities that no longer match the block at their coords:
+	RemoveNonMatchingBlockEntities();
+
+	// Add block entities for all block types that should have a BE assigned to them:
+	for (int y = 0; y < m_Size.y; ++y) for (int z = 0; z < m_Size.z; ++z) for (int x = 0; x < m_Size.x; ++x)
+	{
+		auto idx = MakeIndex(x, y, z);
+		auto type = m_BlockTypes[idx];
+		if (!cBlockEntity::IsBlockEntityBlockType(type))
+		{
+			continue;
+		}
+		// This block should have a block entity, check that there is one:
+		auto itr = m_BlockEntities->find(idx);
+		if (itr != m_BlockEntities->end())
+		{
+			continue;
+		}
+		// Create a new BE for this block:
+		NIBBLETYPE meta = HasBlockMetas() ? m_BlockMetas[idx] : 0;
+		m_BlockEntities->insert({idx, cBlockEntity::CreateByBlockType(type, meta, x, y, z)});
+	}  // for x, z, y
+}
+
+
+
+
+
+void cBlockArea::RemoveNonMatchingBlockEntities(void)
+{
+	// Only supported with both BlockEntities and BlockTypes:
+	ASSERT(HasBlockTypes());
+	ASSERT(HasBlockEntities());
+
+	cBlockEntities oldBE;
+	std::swap(oldBE, *m_BlockEntities);
+	for (auto & keyPair: oldBE)
+	{
+		auto type = m_BlockTypes[keyPair.first];
+		if (type == keyPair.second->GetBlockType())
+		{
+			m_BlockEntities->insert({keyPair.first, std::move(keyPair.second)});
+		}
+		else
+		{
+			delete keyPair.second;
+		}
+	}
 }
 
 
 
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cBlockArea::cChunkReader:
+
+cBlockArea::cChunkReader::cChunkReader(cBlockArea & a_Area) :
+	m_Area(a_Area),
+	m_AreaBounds(cCuboid(a_Area.GetOrigin(), a_Area.GetOrigin() + a_Area.GetSize())),
+	m_Origin(a_Area.m_Origin.x, a_Area.m_Origin.y, a_Area.m_Origin.z),
+	m_CurrentChunkX(0),
+	m_CurrentChunkZ(0)
+{
+}
+
+
+
+
+
+void cBlockArea::cChunkReader::CopyNibbles(NIBBLETYPE * a_AreaDst, const NIBBLETYPE * a_ChunkSrc)
+{
+	int SizeY = m_Area.m_Size.y;
+	int MinY = m_Origin.y;
+
+	// SizeX, SizeZ are the dmensions of the block data to copy from the current chunk (size of the geometric union)
+	// OffX, OffZ are the offsets of the current chunk data from the area origin
+	// BaseX, BaseZ are the offsets of the area data within the current chunk from the chunk borders
+	int SizeX = cChunkDef::Width;
+	int SizeZ = cChunkDef::Width;
+	int OffX, OffZ;
+	int BaseX, BaseZ;
+	OffX = m_CurrentChunkX * cChunkDef::Width - m_Origin.x;
+	if (OffX < 0)
+	{
+		BaseX = -OffX;
+		SizeX += OffX;  // SizeX is decreased, OffX is negative
+		OffX = 0;
+	}
+	else
+	{
+		BaseX = 0;
+	}
+	OffZ = m_CurrentChunkZ * cChunkDef::Width - m_Origin.z;
+	if (OffZ < 0)
+	{
+		BaseZ = -OffZ;
+		SizeZ += OffZ;  // SizeZ is decreased, OffZ is negative
+		OffZ = 0;
+	}
+	else
+	{
+		BaseZ = 0;
+	}
+	// If the chunk extends beyond the area in the X or Z axis, cut off the Size:
+	if ((m_CurrentChunkX + 1) * cChunkDef::Width > m_Origin.x + m_Area.m_Size.x)
+	{
+		SizeX -= (m_CurrentChunkX + 1) * cChunkDef::Width - (m_Origin.x + m_Area.m_Size.x);
+	}
+	if ((m_CurrentChunkZ + 1) * cChunkDef::Width > m_Origin.z + m_Area.m_Size.z)
+	{
+		SizeZ -= (m_CurrentChunkZ + 1) * cChunkDef::Width - (m_Origin.z + m_Area.m_Size.z);
+	}
+
+	for (int y = 0; y < SizeY; y++)
+	{
+		int ChunkY = MinY + y;
+		int AreaY = y;
+		for (int z = 0; z < SizeZ; z++)
+		{
+			int ChunkZ = BaseZ + z;
+			int AreaZ = OffZ + z;
+			for (int x = 0; x < SizeX; x++)
+			{
+				int ChunkX = BaseX + x;
+				int AreaX = OffX + x;
+				a_AreaDst[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = cChunkDef::GetNibble(a_ChunkSrc, ChunkX, ChunkY, ChunkZ);
+			}  // for x
+		}  // for z
+	}  // for y
+}
+
+
+
+
+
+bool cBlockArea::cChunkReader::Coords(int a_ChunkX, int a_ChunkZ)
+{
+	m_CurrentChunkX = a_ChunkX;
+	m_CurrentChunkZ = a_ChunkZ;
+	return true;
+}
+
+
+
+
+
+void cBlockArea::cChunkReader::ChunkData(const cChunkData & a_BlockBuffer)
+{
+	int SizeY = m_Area.m_Size.y;
+	int MinY = m_Origin.y;
+
+	// SizeX, SizeZ are the dimensions of the block data to copy from the current chunk (size of the geometric union)
+	// OffX, OffZ are the offsets of the current chunk data from the area origin
+	// BaseX, BaseZ are the offsets of the area data within the current chunk from the chunk borders
+	int SizeX = cChunkDef::Width;
+	int SizeZ = cChunkDef::Width;
+	int OffX, OffZ;
+	int BaseX, BaseZ;
+	OffX = m_CurrentChunkX * cChunkDef::Width - m_Origin.x;
+	if (OffX < 0)
+	{
+		BaseX = -OffX;
+		SizeX += OffX;  // SizeX is decreased, OffX is negative
+		OffX = 0;
+	}
+	else
+	{
+		BaseX = 0;
+	}
+	OffZ = m_CurrentChunkZ * cChunkDef::Width - m_Origin.z;
+	if (OffZ < 0)
+	{
+		BaseZ = -OffZ;
+		SizeZ += OffZ;  // SizeZ is decreased, OffZ is negative
+		OffZ = 0;
+	}
+	else
+	{
+		BaseZ = 0;
+	}
+	// If the chunk extends beyond the area in the X or Z axis, cut off the Size:
+	if ((m_CurrentChunkX + 1) * cChunkDef::Width > m_Origin.x + m_Area.m_Size.x)
+	{
+		SizeX -= (m_CurrentChunkX + 1) * cChunkDef::Width - (m_Origin.x + m_Area.m_Size.x);
+	}
+	if ((m_CurrentChunkZ + 1) * cChunkDef::Width > m_Origin.z + m_Area.m_Size.z)
+	{
+		SizeZ -= (m_CurrentChunkZ + 1) * cChunkDef::Width - (m_Origin.z + m_Area.m_Size.z);
+	}
+
+	// Copy the blocktypes:
+	if (m_Area.m_BlockTypes != nullptr)
+	{
+		for (int y = 0; y < SizeY; y++)
+		{
+			int InChunkY = MinY + y;
+			int AreaY = y;
+			for (int z = 0; z < SizeZ; z++)
+			{
+				int InChunkZ = BaseZ + z;
+				int AreaZ = OffZ + z;
+				for (int x = 0; x < SizeX; x++)
+				{
+					int InChunkX = BaseX + x;
+					int AreaX = OffX + x;
+					m_Area.m_BlockTypes[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetBlock(InChunkX, InChunkY, InChunkZ);
+				}  // for x
+			}  // for z
+		}  // for y
+	}
+
+	// Copy the block metas:
+	if (m_Area.m_BlockMetas != nullptr)
+	{
+		for (int y = 0; y < SizeY; y++)
+		{
+			int InChunkY = MinY + y;
+			int AreaY = y;
+			for (int z = 0; z < SizeZ; z++)
+			{
+				int InChunkZ = BaseZ + z;
+				int AreaZ = OffZ + z;
+				for (int x = 0; x < SizeX; x++)
+				{
+					int InChunkX = BaseX + x;
+					int AreaX = OffX + x;
+					m_Area.m_BlockMetas[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetMeta(InChunkX, InChunkY, InChunkZ);
+				}  // for x
+			}  // for z
+		}  // for y
+	}
+
+	// Copy the blocklight:
+	if (m_Area.m_BlockLight != nullptr)
+	{
+		for (int y = 0; y < SizeY; y++)
+		{
+			int InChunkY = MinY + y;
+			int AreaY = y;
+			for (int z = 0; z < SizeZ; z++)
+			{
+				int InChunkZ = BaseZ + z;
+				int AreaZ = OffZ + z;
+				for (int x = 0; x < SizeX; x++)
+				{
+					int InChunkX = BaseX + x;
+					int AreaX = OffX + x;
+					m_Area.m_BlockLight[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetBlockLight(InChunkX, InChunkY, InChunkZ);
+				}  // for x
+			}  // for z
+		}  // for y
+	}
+
+	// Copy the skylight:
+	if (m_Area.m_BlockSkyLight != nullptr)
+	{
+		for (int y = 0; y < SizeY; y++)
+		{
+			int InChunkY = MinY + y;
+			int AreaY = y;
+			for (int z = 0; z < SizeZ; z++)
+			{
+				int InChunkZ = BaseZ + z;
+				int AreaZ = OffZ + z;
+				for (int x = 0; x < SizeX; x++)
+				{
+					int InChunkX = BaseX + x;
+					int AreaX = OffX + x;
+					m_Area.m_BlockSkyLight[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetSkyLight(InChunkX, InChunkY, InChunkZ);
+				}  // for x
+			}  // for z
+		}  // for y
+	}
+}
+
+
+
+
+void cBlockArea::cChunkReader::BlockEntity(cBlockEntity * a_BlockEntity)
+{
+	if (!m_Area.HasBlockEntities())
+	{
+		return;
+	}
+	if (!m_AreaBounds.IsInside(a_BlockEntity->GetPos()))
+	{
+		return;
+	}
+	auto areaX = a_BlockEntity->GetPosX() - m_Area.m_Origin.x;
+	auto areaY = a_BlockEntity->GetPosY() - m_Area.m_Origin.y;
+	auto areaZ = a_BlockEntity->GetPosZ() - m_Area.m_Origin.z;
+	int Idx = cChunkDef::MakeIndex(areaX, areaY, areaZ);
+	m_Area.m_BlockEntities->insert({Idx, a_BlockEntity->Clone(areaX, areaY, areaZ)});
+}
+
+
+
+
+
diff --git a/src/BlockArea.h b/src/BlockArea.h
index 2100345e4..583b998c2 100644
--- a/src/BlockArea.h
+++ b/src/BlockArea.h
@@ -5,6 +5,8 @@
 // The object also supports writing the blockdata back into cWorld, even into other coords
 
 // NOTE: All Nibble values (meta, blocklight, skylight) are stored one-nibble-per-byte for faster access / editting!
+// NOTE: Lua bindings for this object explicitly check parameter values. C++ code is expected to pass in valid params, so the functions ASSERT on invalid params.
+//    This includes the datatypes (must be present / valid combination), coords and sizes.
 
 
 
@@ -15,6 +17,7 @@
 #include "ForEachChunkProvider.h"
 #include "Vector3.h"
 #include "ChunkDataCallback.h"
+#include "Cuboid.h"
 
 
 
@@ -38,10 +41,12 @@ public:
 	/** What data is to be queried (bit-mask) */
 	enum
 	{
-		baTypes    = 1,
-		baMetas    = 2,
-		baLight    = 4,
-		baSkyLight = 8,
+		baTypes         =  1,
+		baMetas         =  2,
+		baLight         =  4,
+		baSkyLight      =  8,
+		// baEntities   = 16,  // Not supported yet
+		baBlockEntities = 32,
 	} ;
 
 	/** The per-block strategy to use when merging another block area into this object.
@@ -61,20 +66,26 @@ public:
 	cBlockArea(void);
 	~cBlockArea();
 
+	/** Returns true if the datatype combination is valid.
+	Invalid combinations include BlockEntities without BlockTypes. */
+	static bool IsValidDataTypeCombination(int a_DataTypes);
+
 	/** Clears the data stored to reclaim memory */
 	void Clear(void);
 
+	// tolua_end
+
 	/** Creates a new area of the specified size and contents.
 	Origin is set to all zeroes.
-	BlockTypes are set to air, block metas to zero, blocklights to zero and skylights to full light.
-	*/
-	void Create(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes = baTypes | baMetas);
+	BlockTypes are set to air, block metas to zero, blocklights to zero and skylights to full light. */
+	void Create(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes = baTypes | baMetas | baBlockEntities);
 
 	/** Creates a new area of the specified size and contents.
 	Origin is set to all zeroes.
-	BlockTypes are set to air, block metas to zero, blocklights to zero and skylights to full light.
-	*/
-	void Create(const Vector3i & a_Size, int a_DataTypes = baTypes | baMetas);
+	BlockTypes are set to air, block metas to zero, blocklights to zero and skylights to full light. */
+	void Create(const Vector3i & a_Size, int a_DataTypes = baTypes | baMetas | baBlockEntities);
+
+	// tolua_begin
 
 	/** Resets the origin. No other changes are made, contents are untouched. */
 	void SetOrigin(int a_OriginX, int a_OriginY, int a_OriginZ);
@@ -82,23 +93,39 @@ public:
 	/** Resets the origin. No other changes are made, contents are untouched. */
 	void SetOrigin(const Vector3i & a_Origin);
 
+	/** Returns true if the specified relative coords are within this area's coord range (0 - m_Size). */
+	bool IsValidRelCoords(int a_RelX, int a_RelY, int a_RelZ) const;
+
+	/** Returns true if the specified relative coords are within this area's coord range (0 - m_Size). */
+	bool IsValidRelCoords(const Vector3i & a_RelCoords) const;
+
+	/** Returns true if the specified coords are within this area's coord range (as indicated by m_Origin). */
+	bool IsValidCoords(int a_BlockX, int a_BlockY, int a_BlockZ) const;
+
+	/** Returns true if the specified coords are within this area's coord range (as indicated by m_Origin). */
+	bool IsValidCoords(const Vector3i & a_Coords) const;
+
+	// tolua_end
+
 	/** Reads an area of blocks specified. Returns true if successful. All coords are inclusive. */
-	bool Read(cForEachChunkProvider & a_ForEachChunkProvider, int a_MinBlockX, int a_MaxBlockX, int a_MinBlockY, int a_MaxBlockY, int a_MinBlockZ, int a_MaxBlockZ, int a_DataTypes = baTypes | baMetas);
+	bool Read(cForEachChunkProvider & a_ForEachChunkProvider, int a_MinBlockX, int a_MaxBlockX, int a_MinBlockY, int a_MaxBlockY, int a_MinBlockZ, int a_MaxBlockZ, int a_DataTypes = baTypes | baMetas | baBlockEntities);
 
 	/** Reads an area of blocks specified. Returns true if successful. The bounds are included in the read area. */
-	bool Read(cForEachChunkProvider & a_ForEachChunkProvider, const cCuboid & a_Bounds, int a_DataTypes = baTypes | baMetas);
+	bool Read(cForEachChunkProvider & a_ForEachChunkProvider, const cCuboid & a_Bounds, int a_DataTypes = baTypes | baMetas | baBlockEntities);
 
 	/** Reads an area of blocks specified. Returns true if successful. The bounds are included in the read area. */
-	bool Read(cForEachChunkProvider & a_ForEachChunkProvider, const Vector3i & a_Point1, const Vector3i & a_Point2, int a_DataTypes = baTypes | baMetas);
+	bool Read(cForEachChunkProvider & a_ForEachChunkProvider, const Vector3i & a_Point1, const Vector3i & a_Point2, int a_DataTypes = baTypes | baMetas | baBlockEntities);
 
 	// TODO: Write() is not too good an interface: if it fails, there's no way to repeat only for the parts that didn't write
 	// A better way may be to return a list of cBlockAreas for each part that didn't succeed writing, so that the caller may try again
 
-	/** Writes the area back into cWorld at the coords specified. Returns true if successful in all chunks, false if only partially / not at all */
-	bool Write(cForEachChunkProvider & a_ForEachChunkProvider, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes = baTypes | baMetas);
+	/** Writes the area back into cWorld at the coords specified. Returns true if successful in all chunks, false if only partially / not at all. */
+	bool Write(cForEachChunkProvider & a_ForEachChunkProvider, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes = baTypes | baMetas | baBlockEntities);
 
-	/** Writes the area back into cWorld at the coords specified. Returns true if successful in all chunks, false if only partially / not at all */
-	bool Write(cForEachChunkProvider & a_ForEachChunkProvider, const Vector3i & a_MinCoords, int a_DataTypes = baTypes | baMetas);
+	/** Writes the area back into cWorld at the coords specified. Returns true if successful in all chunks, false if only partially / not at all. */
+	bool Write(cForEachChunkProvider & a_ForEachChunkProvider, const Vector3i & a_MinCoords, int a_DataTypes = baTypes | baMetas | baBlockEntities);
+
+	// tolua_begin
 
 	/** Copies this object's contents into the specified BlockArea. */
 	void CopyTo(cBlockArea & a_Into) const;
@@ -117,6 +144,10 @@ public:
 
 	/** Merges another block area into this one, using the specified block combinating strategy
 	This function combines another BlockArea into the current object.
+	The a_RelX, a_RelY and a_RelZ parameters specify the coords of this BA where a_Src should be copied.
+	If both areas contain baBlockEntities, the BEs are merged (with preference of keeping this' ones) (MergeBlockEntities()).
+	If only this contains BEs, but a_Src doesn't, the BEs are checked after merge to remove the overwritten ones and create
+	the missing ones (UpdateBlockEntities()).
 	The strategy parameter specifies how individual blocks are combined together, using the table below.
 
 	| area block |                 result              |
@@ -191,6 +222,8 @@ public:
 	/** Fills the entire block area with the specified data */
 	void Fill(int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta = 0, NIBBLETYPE a_BlockLight = 0, NIBBLETYPE a_BlockSkyLight = 0x0f);
 
+	// tolua_end
+
 	/** Fills a cuboid inside the block area with the specified data */
 	void FillRelCuboid(int a_MinRelX, int a_MaxRelX, int a_MinRelY, int a_MaxRelY, int a_MinRelZ, int a_MaxRelZ,
 		int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta = 0,
@@ -203,18 +236,20 @@ public:
 		NIBBLETYPE a_BlockLight = 0, NIBBLETYPE a_BlockSkyLight = 0x0f
 	);
 
-	/** Draws a line from between two points with the specified data */
+	/** Draws a line between two points with the specified data. The line endpoints needn't be valid coords inside the area. */
 	void RelLine(int a_RelX1, int a_RelY1, int a_RelZ1, int a_RelX2, int a_RelY2, int a_RelZ2,
 		int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta = 0,
 		NIBBLETYPE a_BlockLight = 0, NIBBLETYPE a_BlockSkyLight = 0x0f
 	);
 
-	/** Draws a line from between two points with the specified data */
+	/** Draws a line between two points with the specified data. The line endpoints needn't be valid coords inside the area. */
 	void RelLine(const Vector3i & a_Point1, const Vector3i & a_Point2,
 		int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta = 0,
 		NIBBLETYPE a_BlockLight = 0, NIBBLETYPE a_BlockSkyLight = 0x0f
 	);
 
+	// tolua_begin
+
 	/** Rotates the entire area counter-clockwise around the Y axis */
 	void RotateCCW(void);
 
@@ -245,6 +280,8 @@ public:
 	/** Mirrors the entire area around the YZ plane, doesn't use blockhandlers for block meta */
 	void MirrorYZNoMeta(void);
 
+	// tolua_end
+
 	// Setters:
 	void SetRelBlockType    (int a_RelX,   int a_RelY,   int a_RelZ,   BLOCKTYPE  a_BlockType);
 	void SetBlockType       (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE  a_BlockType);
@@ -254,8 +291,14 @@ public:
 	void SetBlockLight      (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockLight);
 	void SetRelBlockSkyLight(int a_RelX,   int a_RelY,   int a_RelZ,   NIBBLETYPE a_BlockSkyLight);
 	void SetBlockSkyLight   (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockSkyLight);
-	void SetWEOffset        (int a_OffsetX, int a_OffsetY, int a_OffsetZ);
-	void SetWEOffset        (const Vector3i & a_Offset);
+
+	// tolua_begin
+
+	void SetWEOffset (int a_OffsetX, int a_OffsetY, int a_OffsetZ);
+	void SetWEOffset (const Vector3i & a_Offset);
+	const Vector3i & GetWEOffset  (void) const {return m_WEOffset;}
+
+	// tolua_end
 
 	// Getters:
 	BLOCKTYPE  GetRelBlockType    (int a_RelX,   int a_RelY,   int a_RelZ)   const;
@@ -266,21 +309,14 @@ public:
 	NIBBLETYPE GetBlockLight      (int a_BlockX, int a_BlockY, int a_BlockZ) const;
 	NIBBLETYPE GetRelBlockSkyLight(int a_RelX,   int a_RelY,   int a_RelZ)   const;
 	NIBBLETYPE GetBlockSkyLight   (int a_BlockX, int a_BlockY, int a_BlockZ) const;
-	const Vector3i & GetWEOffset  (void)                                     const {return m_WEOffset;}
 
 	void SetBlockTypeMeta   (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType,   NIBBLETYPE a_BlockMeta);
 	void SetRelBlockTypeMeta(int a_RelX,   int a_RelY,   int a_RelZ,   BLOCKTYPE a_BlockType,   NIBBLETYPE a_BlockMeta);
 
-	// tolua_end
-
-	// These need manual exporting, tolua generates the binding as requiring 2 extra input params
 	void GetBlockTypeMeta   (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const;
 	void GetRelBlockTypeMeta(int a_RelX,   int a_RelY,   int a_RelZ,   BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const;
 
-	// GetSize() is already exported manually to return 3 numbers, can't auto-export
 	const Vector3i & GetSize(void) const { return m_Size; }
-
-	// GetOrigin() is already exported manually to return 3 numbers, can't auto-export
 	const Vector3i & GetOrigin(void) const { return m_Origin; }
 
 	// tolua_begin
@@ -303,6 +339,7 @@ public:
 	bool HasBlockMetas    (void) const { return (m_BlockMetas    != nullptr); }
 	bool HasBlockLights   (void) const { return (m_BlockLight    != nullptr); }
 	bool HasBlockSkyLights(void) const { return (m_BlockSkyLight != nullptr); }
+	bool HasBlockEntities (void) const { return (m_BlockEntities != nullptr); }
 
 	/** Returns the count of blocks that are not air.
 	Returns 0 if blocktypes not available. Block metas are ignored (if present, air with any meta is still considered air). */
@@ -333,11 +370,32 @@ public:
 	size_t       GetBlockCount(void) const { return static_cast<size_t>(m_Size.x * m_Size.y * m_Size.z); }
 	int MakeIndex(int a_RelX, int a_RelY, int a_RelZ) const;
 
+	/** Calls the callback for the block entity at the specified coords.
+	Returns false if there is no block entity at those coords, or the block area doesn't have baBlockEntities.
+	Returns the value that the callback has returned if there is a block entity. */
+	bool DoWithBlockEntityRelAt(int a_RelX, int a_RelY, int a_RelZ, cItemCallback<cBlockEntity> & a_Callback);
+
+	/** Calls the callback for the block entity at the specified coords.
+	Returns false if there is no block entity at those coords.
+	Returns the value that the callback has returned if there is a block entity. */
+	bool DoWithBlockEntityAt   (int a_BlockX, int a_BlockY, int a_BlockZ, cItemCallback<cBlockEntity> & a_Callback);
+
+	/** Calls the callback for all the block entities.
+	If the callback returns true, aborts the enumeration and returns false.
+	If the callback returns true, continues with the next BE.
+	Returns true if all block entities have been enumerated (including the case when there is none or the area is without baBlockEntities). */
+	bool ForEachBlockEntity(cItemCallback<cBlockEntity> & a_Callback);
+
+	/** Direct read-only access to block entities. */
+	const cBlockEntities & GetBlockEntities(void) const { ASSERT(HasBlockEntities()); return *m_BlockEntities; }
+
+
 protected:
+
 	friend class cChunkDesc;
 	friend class cSchematicFileSerializer;
 
-	class cChunkReader :
+	class cChunkReader:
 		public cChunkDataCallback
 	{
 	public:
@@ -345,6 +403,7 @@ protected:
 
 	protected:
 		cBlockArea & m_Area;
+		cCuboid m_AreaBounds;  ///< Bounds of the whole area being read, in world coords
 		Vector3i m_Origin;
 		int m_CurrentChunkX;
 		int m_CurrentChunkZ;
@@ -354,6 +413,7 @@ protected:
 		// cChunkDataCallback overrides:
 		virtual bool Coords(int a_ChunkX, int a_ChunkZ) override;
 		virtual void ChunkData(const cChunkData &  a_BlockTypes) override;
+		virtual void BlockEntity(cBlockEntity * a_BlockEntity) override;
 	} ;
 
 	typedef NIBBLETYPE * NIBBLEARRAY;
@@ -371,6 +431,11 @@ protected:
 	NIBBLETYPE * m_BlockLight;     // Each light value is stored as a separate byte for faster access
 	NIBBLETYPE * m_BlockSkyLight;  // Each light value is stored as a separate byte for faster access
 
+	/** The block entities contained within the area.
+	Only valid if the area was created / read with the baBlockEntities flag.
+	The block entities are owned by this object. */
+	std::unique_ptr<cBlockEntities> m_BlockEntities;
+
 	/** Clears the data stored and prepares a fresh new block area with the specified dimensions */
 	bool SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes);
 
@@ -390,7 +455,8 @@ protected:
 	void ExpandBlockTypes(int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMaxY, int a_SubMinZ, int a_AddMaxZ);
 	void ExpandNibbles   (NIBBLEARRAY & a_Array, int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMaxY, int a_SubMinZ, int a_AddMaxZ);
 
-	/** Sets the specified datatypes at the specified location. */
+	/** Sets the specified datatypes at the specified location.
+	If the coords are not valid, ignores the call (so that RelLine() can work simply). */
 	void RelSetData(
 		int a_RelX, int a_RelY, int a_RelZ,
 		int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta,
@@ -399,6 +465,21 @@ protected:
 
 	template <bool MetasValid>
 	void MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_RelY, int a_RelZ, eMergeStrategy a_Strategy, const NIBBLETYPE * SrcMetas, NIBBLETYPE * DstMetas);
+
+	/** Clears the block entities from the specified container, freeing each blockentity. */
+	static void ClearBlockEntities(cBlockEntities & a_BlockEntities);
+
+	/** Updates m_BlockEntities to remove BEs that no longer match the blocktype at their coords, and clones from a_Src the BEs that are missing.
+	a_RelX, a_RelY and a_RelZ are relative coords that should be added to all BEs from a_Src before checking them.
+	If a block should have a BE but one cannot be found in either this or a_Src, a new one is created. */
+	void MergeBlockEntities(int a_RelX, int a_RelY, int a_RelZ, const cBlockArea & a_Src);
+
+	/** Updates m_BlockEntities to remove BEs that no longer match the blocktype at their coords, and add new BEs that are missing. */
+	void RescanBlockEntities(void);
+
+	/** Removes from m_BlockEntities those BEs that no longer match the blocktype at their coords. */
+	void RemoveNonMatchingBlockEntities(void);
+
 	// tolua_begin
 } ;
 // tolua_end
diff --git a/src/BlockEntities/BlockEntity.cpp b/src/BlockEntities/BlockEntity.cpp
index f0716dd08..f60eb5622 100644
--- a/src/BlockEntities/BlockEntity.cpp
+++ b/src/BlockEntities/BlockEntity.cpp
@@ -25,11 +25,57 @@
 
 
 
+void cBlockEntity::SetPos(int a_NewBlockX, int a_NewBlockY, int a_NewBlockZ)
+{
+	ASSERT(m_World == nullptr);  // Cannot move block entities that represent world blocks (only use this for cBlockArea's BEs)
+	m_PosX = a_NewBlockX;
+	m_PosY = a_NewBlockY;
+	m_PosZ = a_NewBlockZ;
+}
+
+
+
+
+
+bool cBlockEntity::IsBlockEntityBlockType(BLOCKTYPE a_BlockType)
+{
+	switch (a_BlockType)
+	{
+		case E_BLOCK_BEACON:
+		case E_BLOCK_BREWING_STAND:
+		case E_BLOCK_CHEST:
+		case E_BLOCK_COMMAND_BLOCK:
+		case E_BLOCK_DISPENSER:
+		case E_BLOCK_DROPPER:
+		case E_BLOCK_ENDER_CHEST:
+		case E_BLOCK_FLOWER_POT:
+		case E_BLOCK_FURNACE:
+		case E_BLOCK_HEAD:
+		case E_BLOCK_HOPPER:
+		case E_BLOCK_JUKEBOX:
+		case E_BLOCK_LIT_FURNACE:
+		case E_BLOCK_MOB_SPAWNER:
+		case E_BLOCK_NOTE_BLOCK:
+		case E_BLOCK_SIGN_POST:
+		case E_BLOCK_TRAPPED_CHEST:
+		case E_BLOCK_WALLSIGN:
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
 cBlockEntity * cBlockEntity::CreateByBlockType(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World)
 {
 	switch (a_BlockType)
 	{
 		case E_BLOCK_BEACON:        return new cBeaconEntity      (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
+		case E_BLOCK_BREWING_STAND: return new cBrewingstandEntity(a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
 		case E_BLOCK_CHEST:         return new cChestEntity       (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
 		case E_BLOCK_COMMAND_BLOCK: return new cCommandBlockEntity(a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
 		case E_BLOCK_DISPENSER:     return new cDispenserEntity   (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
@@ -37,16 +83,15 @@ cBlockEntity * cBlockEntity::CreateByBlockType(BLOCKTYPE a_BlockType, NIBBLETYPE
 		case E_BLOCK_ENDER_CHEST:   return new cEnderChestEntity  (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
 		case E_BLOCK_FLOWER_POT:    return new cFlowerPotEntity   (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
 		case E_BLOCK_FURNACE:       return new cFurnaceEntity     (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
-		case E_BLOCK_BREWING_STAND: return new cBrewingstandEntity(a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
 		case E_BLOCK_HEAD:          return new cMobHeadEntity     (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
 		case E_BLOCK_HOPPER:        return new cHopperEntity      (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
-		case E_BLOCK_MOB_SPAWNER:   return new cMobSpawnerEntity  (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
 		case E_BLOCK_JUKEBOX:       return new cJukeboxEntity     (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
 		case E_BLOCK_LIT_FURNACE:   return new cFurnaceEntity     (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
+		case E_BLOCK_MOB_SPAWNER:   return new cMobSpawnerEntity  (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
+		case E_BLOCK_NOTE_BLOCK:    return new cNoteEntity        (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
 		case E_BLOCK_SIGN_POST:     return new cSignEntity        (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
 		case E_BLOCK_TRAPPED_CHEST: return new cChestEntity       (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
 		case E_BLOCK_WALLSIGN:      return new cSignEntity        (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
-		case E_BLOCK_NOTE_BLOCK:    return new cNoteEntity        (a_BlockType, a_BlockMeta, a_BlockX, a_BlockY, a_BlockZ, a_World);
 	}
 	LOGD("%s: Requesting creation of an unknown block entity - block type %d (%s)",
 		__FUNCTION__, a_BlockType, ItemTypeToString(a_BlockType).c_str()
diff --git a/src/BlockEntities/BlockEntity.h b/src/BlockEntities/BlockEntity.h
index 6c69e8260..5b7184775 100644
--- a/src/BlockEntities/BlockEntity.h
+++ b/src/BlockEntities/BlockEntity.h
@@ -64,6 +64,14 @@ public:
 		m_World = a_World;
 	}
 
+	/** Updates the internally stored position.
+	Note that this should not ever be used for world-contained block entities, it is meant only for when BEs in a cBlockArea are manipulated.
+	Asserts when the block entity is assigned to a world. */
+	void SetPos(int a_NewBlockX, int a_NewBlockY, int a_NewBlockZ);
+
+	/** Returns true if the specified blocktype is supposed to have an associated block entity. */
+	static bool IsBlockEntityBlockType(BLOCKTYPE a_BlockType);
+
 	/** Creates a new block entity for the specified block type
 	If a_World is valid, then the entity is created bound to that world
 	Returns nullptr for unknown block types. */
diff --git a/src/Chunk.cpp b/src/Chunk.cpp
index 849b0e2f5..99f643437 100644
--- a/src/Chunk.cpp
+++ b/src/Chunk.cpp
@@ -408,7 +408,7 @@ void cChunk::WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlock
 {
 	if ((a_DataTypes & (cBlockArea::baTypes | cBlockArea::baMetas)) != (cBlockArea::baTypes | cBlockArea::baMetas))
 	{
-		LOGWARNING("cChunk::WriteBlockArea(): unsupported datatype request, can write only types + metas (0x%x), requested 0x%x. Ignoring.",
+		LOGWARNING("cChunk::WriteBlockArea(): unsupported datatype request, can write only types + metas together (0x%x), requested 0x%x. Ignoring.",
 			(cBlockArea::baTypes | cBlockArea::baMetas), a_DataTypes & (cBlockArea::baTypes | cBlockArea::baMetas)
 		);
 		return;
@@ -420,16 +420,16 @@ void cChunk::WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlock
 	int BlockEndX   = std::min(a_MinBlockX + a_Area.GetSizeX(), (m_PosX + 1) * cChunkDef::Width);
 	int BlockStartZ = std::max(a_MinBlockZ, m_PosZ * cChunkDef::Width);
 	int BlockEndZ   = std::min(a_MinBlockZ + a_Area.GetSizeZ(), (m_PosZ + 1) * cChunkDef::Width);
-	int SizeX = BlockEndX - BlockStartX;
+	int SizeX = BlockEndX - BlockStartX;  // Size of the union
 	int SizeZ = BlockEndZ - BlockStartZ;
-	int OffX = BlockStartX - m_PosX * cChunkDef::Width;
+	int SizeY = std::min(a_Area.GetSizeY(), cChunkDef::Height - a_MinBlockY);
+	int OffX = BlockStartX - m_PosX * cChunkDef::Width;  // Offset within the chunk where the union starts
 	int OffZ = BlockStartZ - m_PosZ * cChunkDef::Width;
-	int BaseX = BlockStartX - a_MinBlockX;
+	int BaseX = BlockStartX - a_MinBlockX;  // Offset within the area where the union starts
 	int BaseZ = BlockStartZ - a_MinBlockZ;
-	int SizeY = std::min(a_Area.GetSizeY(), cChunkDef::Height - a_MinBlockY);
 
-	// TODO: Improve this by not calling FastSetBlock() and doing the processing here
-	// so that the heightmap is touched only once for each column.
+	// Copy blocktype and blockmeta:
+	// TODO: Right now each changed block is transmitted to all clients as a separate packet. Optimize this for larger areas.
 	BLOCKTYPE *  AreaBlockTypes = a_Area.GetBlockTypes();
 	NIBBLETYPE * AreaBlockMetas = a_Area.GetBlockMetas();
 	for (int y = 0; y < SizeY; y++)
@@ -451,6 +451,50 @@ void cChunk::WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlock
 			}  // for x
 		}  // for z
 	}  // for y
+
+	// Erase all affected block entities:
+	cCuboid affectedArea(OffX, a_MinBlockY, OffZ, OffX + SizeX - 1, a_MinBlockY + SizeY - 1, OffZ + SizeZ - 1);
+	for (auto itr = m_BlockEntities.begin(); itr != m_BlockEntities.end();)
+	{
+		if (affectedArea.IsInside(itr->second->GetPos()))
+		{
+			itr = m_BlockEntities.erase(itr);
+		}
+		else
+		{
+			++itr;
+		}
+	}
+
+	// Clone block entities from a_Area into this chunk:
+	if ((a_DataTypes & cBlockArea::baBlockEntities) != 0)
+	{
+		for (const auto & keyPair: a_Area.GetBlockEntities())
+		{
+			auto & be = keyPair.second;
+			auto posX = be->GetPosX() + a_MinBlockX;
+			auto posY = be->GetPosY() + a_MinBlockY;
+			auto posZ = be->GetPosZ() + a_MinBlockZ;
+			if (
+				(posX < m_PosX * cChunkDef::Width) || (posX >= m_PosX * cChunkDef::Width + cChunkDef::Width) ||
+				(posZ < m_PosZ * cChunkDef::Width) || (posZ >= m_PosZ * cChunkDef::Width + cChunkDef::Width)
+			)
+			{
+				continue;
+			}
+			// This block entity is inside the chunk, clone it (and remove any that is there currently):
+			auto idx = MakeIndex(posX - m_PosX * cChunkDef::Width, posY, posZ - m_PosZ * cChunkDef::Width);
+			auto itr = m_BlockEntities.find(idx);
+			if (itr != m_BlockEntities.end())
+			{
+				m_BlockEntities.erase(itr);
+			}
+			auto clone = be->Clone(posX, posY, posZ);
+			clone->SetWorld(m_World);
+			AddBlockEntityClean(clone);
+			BroadcastBlockEntity(posX, posY, posZ);
+		}
+	}
 }