cBlockArea object added (with only minimal testing so far)

git-svn-id: http://mc-server.googlecode.com/svn/trunk@641 0a769ca7-a7f5-676a-18bf-c427514a06d6

VC2008/GenerateBindings.cmd

@@ -0,0 +1,3 @@
+set ALLTOLUA_WAIT=N
+cd ..\source
+AllToLua.bat

VC2008/MCServer.vcproj

@@ -265,6 +265,14 @@
 			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
 			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
 			>
+			<File
+				RelativePath="..\source\BlockArea.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\source\BlockArea.h"
+				>
+			</File>
 			<File
 				RelativePath="..\source\BlockID.cpp"
 				>
@@ -1604,6 +1612,43 @@
 			<Filter
 				Name="Bindings"
 				>
+				<File
+					RelativePath="..\source\AllToLua.pkg"
+					>
+					<FileConfiguration
+						Name="Debug|Win32"
+						ExcludedFromBuild="true"
+						>
+						<Tool
+							Name="VCCustomBuildTool"
+							CommandLine="GenerateBindings.cmd"
+							AdditionalDependencies="&quot;cTorch.h&quot;;&quot;cStairs.h&quot;;&quot;cLadder.h&quot;;&quot;../iniFile/iniFile.h&quot;;&quot;BlockID.h&quot;;&quot;PacketID.h&quot;;&quot;Defines.h&quot;;&quot;LuaFunctions.h&quot;;&quot;cStringMap.h&quot;;&quot;cChatColor.h&quot;;&quot;cClientHandle.h&quot;;&quot;cEntity.h&quot;;&quot;cPawn.h&quot;;&quot;cPlayer.h&quot;;&quot;cPluginManager.h&quot;;&quot;cPlugin.h&quot;;&quot;cPlugin_NewLua.h&quot;;&quot;cPlugin_Lua.h&quot;;&quot;cServer.h&quot;;&quot;cWorld.h&quot;;&quot;cInventory.h&quot;;&quot;cItem.h&quot;;&quot;cWebAdmin.h&quot;;&quot;cWebPlugin.h&quot;;&quot;cWebPlugin_Lua.h&quot;;&quot;cPickup.h&quot;;&quot;cRoot.h&quot;;&quot;cTCPLink.h&quot;;&quot;Vector3f.h&quot;;&quot;Vector3d.h&quot;;&quot;Vector3i.h&quot;;&quot;Matrix4f.h&quot;;&quot;cCuboid.h&quot;;&quot;cMCLogger.h&quot;;&quot;cTracer.h&quot;;&quot;cGroup.h&quot;;&quot;BlockArea.h&quot;;&quot;packets/cPacket_Login.h&quot;;&quot;packets/cPacket_BlockDig.h&quot;;&quot;packets/cPacket_BlockPlace.h&quot;"
+							Outputs="Bindings.cpp"
+						/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32"
+						ExcludedFromBuild="true"
+						>
+						<Tool
+							Name="VCCustomBuildTool"
+							CommandLine="GenerateBindings.cmd"
+							AdditionalDependencies="&quot;cTorch.h&quot;;&quot;cStairs.h&quot;;&quot;cLadder.h&quot;;&quot;../iniFile/iniFile.h&quot;;&quot;BlockID.h&quot;;&quot;PacketID.h&quot;;&quot;Defines.h&quot;;&quot;LuaFunctions.h&quot;;&quot;cStringMap.h&quot;;&quot;cChatColor.h&quot;;&quot;cClientHandle.h&quot;;&quot;cEntity.h&quot;;&quot;cPawn.h&quot;;&quot;cPlayer.h&quot;;&quot;cPluginManager.h&quot;;&quot;cPlugin.h&quot;;&quot;cPlugin_NewLua.h&quot;;&quot;cPlugin_Lua.h&quot;;&quot;cServer.h&quot;;&quot;cWorld.h&quot;;&quot;cInventory.h&quot;;&quot;cItem.h&quot;;&quot;cWebAdmin.h&quot;;&quot;cWebPlugin.h&quot;;&quot;cWebPlugin_Lua.h&quot;;&quot;cPickup.h&quot;;&quot;cRoot.h&quot;;&quot;cTCPLink.h&quot;;&quot;Vector3f.h&quot;;&quot;Vector3d.h&quot;;&quot;Vector3i.h&quot;;&quot;Matrix4f.h&quot;;&quot;cCuboid.h&quot;;&quot;cMCLogger.h&quot;;&quot;cTracer.h&quot;;&quot;cGroup.h&quot;;&quot;BlockArea.h&quot;;&quot;packets/cPacket_Login.h&quot;;&quot;packets/cPacket_BlockDig.h&quot;;&quot;packets/cPacket_BlockPlace.h&quot;"
+							Outputs="Bindings.cpp"
+						/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release profiled|Win32"
+						ExcludedFromBuild="true"
+						>
+						<Tool
+							Name="VCCustomBuildTool"
+							CommandLine="GenerateBindings.cmd"
+							AdditionalDependencies="&quot;cTorch.h&quot;;&quot;cStairs.h&quot;;&quot;cLadder.h&quot;;&quot;../iniFile/iniFile.h&quot;;&quot;BlockID.h&quot;;&quot;PacketID.h&quot;;&quot;Defines.h&quot;;&quot;LuaFunctions.h&quot;;&quot;cStringMap.h&quot;;&quot;cChatColor.h&quot;;&quot;cClientHandle.h&quot;;&quot;cEntity.h&quot;;&quot;cPawn.h&quot;;&quot;cPlayer.h&quot;;&quot;cPluginManager.h&quot;;&quot;cPlugin.h&quot;;&quot;cPlugin_NewLua.h&quot;;&quot;cPlugin_Lua.h&quot;;&quot;cServer.h&quot;;&quot;cWorld.h&quot;;&quot;cInventory.h&quot;;&quot;cItem.h&quot;;&quot;cWebAdmin.h&quot;;&quot;cWebPlugin.h&quot;;&quot;cWebPlugin_Lua.h&quot;;&quot;cPickup.h&quot;;&quot;cRoot.h&quot;;&quot;cTCPLink.h&quot;;&quot;Vector3f.h&quot;;&quot;Vector3d.h&quot;;&quot;Vector3i.h&quot;;&quot;Matrix4f.h&quot;;&quot;cCuboid.h&quot;;&quot;cMCLogger.h&quot;;&quot;cTracer.h&quot;;&quot;cGroup.h&quot;;&quot;BlockArea.h&quot;;&quot;packets/cPacket_Login.h&quot;;&quot;packets/cPacket_BlockDig.h&quot;;&quot;packets/cPacket_BlockPlace.h&quot;"
+							Outputs="Bindings.cpp"
+						/>
+					</FileConfiguration>
+				</File>
 				<File
 					RelativePath="..\source\Bindings.cpp"
 					>

source/AllToLua.pkg

@@ -3,6 +3,23 @@ $#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same acr
 
 $#include "tolua_base.h"
 
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// NOTE: when changing the BLOCKTYPE or NIBBLETYPE types, you need to change them both in this file and in ChunkDef.h
+// (for some reason, just including the ChunkDef.h file doesn't work in ToLua)
+
+typedef char BLOCKTYPE;
+typedef unsigned char NIBBLETYPE;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+
+
+
 $cfile "cTorch.h"
 $cfile "cStairs.h"
 $cfile "cStep.h"
@@ -43,6 +60,7 @@ $cfile "cCuboid.h"
 $cfile "cMCLogger.h"
 $cfile "cTracer.h"
 $cfile "cGroup.h"
+$cfile "BlockArea.h"
 $cfile "packets/cPacket_Login.h"
 $cfile "packets/cPacket_BlockDig.h"
 $cfile "packets/cPacket_BlockPlace.h"

source/Bindings.h

@@ -1,6 +1,6 @@
 /*
 ** Lua binding: AllToLua
-** Generated automatically by tolua++-1.0.92 on 07/02/12 10:32:19.
+** Generated automatically by tolua++-1.0.92 on 07/02/12 18:28:58.
 */
 
 /* Exported function */

source/BlockArea.cpp

@@ -0,0 +1,626 @@
+
+// BlockArea.cpp
+
+// Implements the cBlockArea object representing an area of block data that can be queried from cWorld and then accessed again without further queries
+// The object also supports writing the blockdata back into cWorld, even into other coords
+
+#include "Globals.h"
+#include "BlockArea.h"
+#include "cWorld.h"
+
+
+
+
+
+cBlockArea::cBlockArea(void) :
+	m_SizeX(0),
+	m_SizeY(0),
+	m_SizeZ(0),
+	m_BlockTypes(NULL),
+	m_BlockMetas(NULL),
+	m_BlockLight(NULL),
+	m_BlockSkyLight(NULL)
+{
+}
+
+
+
+
+
+cBlockArea::~cBlockArea()
+{
+	Clear();
+}
+
+
+
+
+
+void cBlockArea::Clear(void)
+{
+	delete[] m_BlockTypes;    m_BlockTypes = NULL;
+	delete[] m_BlockMetas;    m_BlockMetas = NULL;
+	delete[] m_BlockLight;    m_BlockLight = NULL;
+	delete[] m_BlockSkyLight; m_BlockSkyLight = NULL;
+	m_SizeX = 0;
+	m_SizeY = 0;
+	m_SizeZ = 0;
+}
+
+
+
+
+bool cBlockArea::Read(cWorld * a_World, 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);
+	}
+	
+	// Check coords validity:
+	if (a_MinBlockY < 0)
+	{
+		LOGWARNING("cBlockArea:Read(): MinBlockY less than zero, adjusting to zero");
+		a_MinBlockY = 0;
+	}
+	else if (a_MinBlockY >= cChunkDef::Height)
+	{
+		LOGWARNING("cBlockArea::Read(): MinBlockY more than chunk height, adjusting to chunk height");
+		a_MinBlockY = cChunkDef::Height - 1;
+	}
+	if (a_MaxBlockY < 0)
+	{
+		LOGWARNING("cBlockArea:Read(): MaxBlockY less than zero, adjusting to zero");
+		a_MaxBlockY = 0;
+	}
+	else if (a_MinBlockY >= cChunkDef::Height)
+	{
+		LOGWARNING("cBlockArea::Read(): MaxBlockY more than chunk height, adjusting to chunk height");
+		a_MaxBlockY = cChunkDef::Height - 1;
+	}
+	
+	// Allocate the needed memory:
+	Clear();
+	if (!SetSize(a_MaxBlockX - a_MinBlockX, a_MaxBlockY - a_MinBlockY, a_MaxBlockZ - a_MinBlockZ, a_DataTypes))
+	{
+		return false;
+	}
+	m_OriginX = a_MinBlockX;
+	m_OriginY = a_MinBlockY;
+	m_OriginZ = a_MinBlockZ;
+	cChunkReader Reader(*this);
+	
+	// Convert block coords to chunks coords:
+	int MinChunkX, MaxChunkX;
+	int MinChunkZ, MaxChunkZ;
+	cChunkDef::AbsoluteToRelative(a_MinBlockX, a_MinBlockY, a_MinBlockZ, MinChunkX, MinChunkZ);
+	cChunkDef::AbsoluteToRelative(a_MaxBlockX, a_MaxBlockY, a_MaxBlockZ, MaxChunkX, MaxChunkZ);
+	
+	// Query block data:
+	if (!a_World->ForEachChunkInRect(MinChunkX, MaxChunkX, MinChunkZ, MaxChunkZ, Reader))
+	{
+		Clear();
+		return false;
+	}
+	return true;
+}
+
+
+
+
+
+bool cBlockArea::Write(cWorld * a_World, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes)
+{
+	// TODO
+	ASSERT(!"Not implemented yet");
+	return false;
+}
+
+
+
+
+
+
+void cBlockArea::SetRelBlockType(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType)
+{
+	if (m_BlockTypes == NULL)
+	{
+		LOGWARNING("cBlockArea: BlockTypes have not been read!");
+		return;
+	}
+	m_BlockTypes[MakeIndex(a_RelX, a_RelY, a_RelZ)] = a_BlockType;
+}
+
+
+
+
+
+void cBlockArea::SetBlockType(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType)
+{
+	SetRelBlockType(a_BlockX - m_OriginX, a_BlockY - m_OriginY, a_BlockZ - m_OriginZ, a_BlockType);
+}
+
+
+
+
+
+void cBlockArea::SetRelBlockMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_BlockMeta)
+{
+	SetRelNibble(a_RelX, a_RelY, a_RelZ, a_BlockMeta, m_BlockMetas);
+}
+
+
+
+
+
+void cBlockArea::SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockMeta)
+{
+	SetNibble(a_BlockX, a_BlockY, a_BlockZ, a_BlockMeta, m_BlockMetas);
+}
+
+
+
+
+
+void cBlockArea::SetRelBlockLight(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_BlockLight)
+{
+	SetRelNibble(a_RelX, a_RelY, a_RelZ, a_BlockLight, m_BlockLight);
+}
+
+
+
+
+
+void cBlockArea::SetBlockLight(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockLight)
+{
+	SetNibble(a_BlockX, a_BlockY, a_BlockZ, a_BlockLight, m_BlockLight);
+}
+
+
+
+
+
+void cBlockArea::SetRelBlockSkyLight(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_BlockSkyLight)
+{
+	SetRelNibble(a_RelX, a_RelY, a_RelZ, a_BlockSkyLight, m_BlockSkyLight);
+}
+
+
+
+
+
+void cBlockArea::SetBlockSkyLight(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockSkyLight)
+{
+	SetNibble(a_BlockX, a_BlockY, a_BlockZ, a_BlockSkyLight, m_BlockSkyLight);
+}
+
+
+
+
+
+BLOCKTYPE cBlockArea::GetRelBlockType(int a_RelX,   int a_RelY,   int a_RelZ)
+{
+	if (m_BlockTypes == NULL)
+	{
+		LOGWARNING("cBlockArea: BlockTypes have not been read!");
+		return E_BLOCK_AIR;
+	}
+	return m_BlockTypes[MakeIndex(a_RelX, a_RelY, a_RelZ)];
+}
+
+
+
+
+
+BLOCKTYPE cBlockArea::GetBlockType(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	return GetRelBlockType(a_BlockX - m_OriginX, a_BlockY - m_OriginY, a_BlockZ - m_OriginZ);
+}
+
+
+
+
+
+NIBBLETYPE cBlockArea::GetRelBlockMeta(int a_RelX, int a_RelY, int a_RelZ)
+{
+	return GetRelNibble(a_RelX, a_RelY, a_RelZ, m_BlockMetas);
+}
+
+
+
+
+
+NIBBLETYPE cBlockArea::GetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	return GetNibble(a_BlockX, a_BlockY, a_BlockZ, m_BlockMetas);
+}
+
+
+
+
+
+NIBBLETYPE cBlockArea::GetRelBlockLight(int a_RelX, int a_RelY, int a_RelZ)
+{
+	return GetRelNibble(a_RelX, a_RelY, a_RelZ, m_BlockLight);
+}
+
+
+
+
+
+NIBBLETYPE cBlockArea::GetBlockLight(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	return GetNibble(a_BlockX, a_BlockY, a_BlockZ, m_BlockLight);
+}
+
+
+
+
+
+NIBBLETYPE cBlockArea::GetRelBlockSkyLight(int a_RelX, int a_RelY, int a_RelZ)
+{
+	return GetRelNibble(a_RelX, a_RelY, a_RelZ, m_BlockSkyLight);
+}
+
+
+
+
+
+NIBBLETYPE cBlockArea::GetBlockSkyLight(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	return GetNibble(a_BlockX, a_BlockY, a_BlockZ, m_BlockSkyLight);
+}
+
+
+
+
+
+int cBlockArea::GetDataTypes(void) const
+{
+	int res = 0;
+	if (m_BlockTypes != NULL)
+	{
+		res |= baTypes;
+	}
+	if (m_BlockMetas != NULL)
+	{
+		res |= baMetas;
+	}
+	if (m_BlockLight != NULL)
+	{
+		res |= baLight;
+	}
+	if (m_BlockSkyLight != NULL)
+	{
+		res |= baSkyLight;
+	}
+	return res;
+}
+
+
+
+
+
+bool cBlockArea::SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes)
+{
+	ASSERT(m_BlockTypes == NULL);  // Has been cleared
+	
+	if (a_DataTypes & baTypes)
+	{
+		m_BlockTypes = new BLOCKTYPE[a_SizeX * a_SizeY * a_SizeZ];
+		if (m_BlockTypes == NULL)
+		{
+			return false;
+		}
+	}
+	if (a_DataTypes & baMetas)
+	{
+		m_BlockMetas = new NIBBLETYPE[a_SizeX * a_SizeY * a_SizeZ];
+		if (m_BlockMetas == NULL)
+		{
+			delete[] m_BlockTypes;
+			return false;
+		}
+	}
+	if (a_DataTypes & baLight)
+	{
+		m_BlockLight = new NIBBLETYPE[a_SizeX * a_SizeY * a_SizeZ];
+		if (m_BlockLight == NULL)
+		{
+			delete[] m_BlockMetas;
+			delete[] m_BlockTypes;
+			return false;
+		}
+	}
+	if (a_DataTypes & baSkyLight)
+	{
+		m_BlockSkyLight = new NIBBLETYPE[a_SizeX * a_SizeY * a_SizeZ];
+		if (m_BlockSkyLight == NULL)
+		{
+			delete[] m_BlockLight;
+			delete[] m_BlockMetas;
+			delete[] m_BlockTypes;
+			return false;
+		}
+	}
+	m_SizeX = a_SizeX;
+	m_SizeY = a_SizeY;
+	m_SizeZ = a_SizeZ;
+	return true;
+}
+
+
+
+
+
+int cBlockArea::MakeIndex(int a_RelX, int a_RelY, int a_RelZ)
+{
+	return a_RelX + a_RelZ * m_SizeZ + a_RelY * m_SizeX * m_SizeZ;
+}
+
+
+
+
+
+void cBlockArea::SetRelNibble(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Value, NIBBLETYPE * a_Array)
+{
+	if (a_Array == NULL)
+	{
+		LOGWARNING("cBlockArea: datatype has not been read!");
+		return;
+	}
+	a_Array[MakeIndex(a_RelX, a_RelY, a_RelZ)] = a_Value;
+}
+
+
+
+
+
+void cBlockArea::SetNibble(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Value, NIBBLETYPE * a_Array)
+{
+	SetRelNibble(a_BlockX - m_OriginX, a_BlockY - m_OriginY, a_BlockZ - m_OriginZ, a_Value, a_Array);
+}
+
+
+
+
+
+NIBBLETYPE cBlockArea::GetRelNibble(int a_RelX,   int a_RelY,   int a_RelZ,   NIBBLETYPE * a_Array)
+{
+	if (a_Array == NULL)
+	{
+		LOGWARNING("cBlockArea: datatype has not been read!");
+		return 16;
+	}
+	return a_Array[MakeIndex(a_RelX, a_RelY, a_RelZ)];
+}
+
+
+
+
+
+NIBBLETYPE cBlockArea::GetNibble(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE * a_Array)
+{
+	return GetRelNibble(a_BlockX - m_OriginX, a_BlockY - m_OriginY, a_BlockZ - m_OriginZ, a_Array);
+}
+
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cBlockArea::cChunkReader:
+
+cBlockArea::cChunkReader::cChunkReader(cBlockArea & a_Area) :
+	m_Area(a_Area),
+	m_OriginX(a_Area.m_OriginX),
+	m_OriginY(a_Area.m_OriginY),
+	m_OriginZ(a_Area.m_OriginZ)
+{
+}
+
+
+
+
+
+void cBlockArea::cChunkReader::CopyNibbles(NIBBLETYPE * a_AreaDst, const NIBBLETYPE * a_ChunkSrc)
+{
+	int SizeY = m_Area.m_SizeY;
+	int MinY = m_OriginY;
+	
+	// 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_OriginX;
+	if (OffX < 0)
+	{
+		BaseX = -OffX;
+		SizeX += OffX;  // SizeX is decreased, OffX is negative
+		OffX = 0;
+	}
+	else
+	{
+		BaseX = 0;
+	}
+	OffZ = m_CurrentChunkZ * cChunkDef::Width - m_OriginZ;
+	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_OriginX + m_Area.m_SizeX)
+	{
+		SizeX -= (m_CurrentChunkX + 1) * cChunkDef::Width - (m_OriginX + m_Area.m_SizeX);
+	}
+	if ((m_CurrentChunkZ + 1) * cChunkDef::Width > m_OriginZ + m_Area.m_SizeZ)
+	{
+		SizeZ -= (m_CurrentChunkZ + 1) * cChunkDef::Width - (m_OriginZ + m_Area.m_SizeZ);
+	}
+
+	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::BlockTypes(const BLOCKTYPE * a_BlockTypes)
+{
+	if (m_Area.m_BlockTypes == NULL)
+	{
+		// Don't want BlockTypes
+		return;
+	}
+	
+	int SizeY = m_Area.m_SizeY;
+	int MinY = m_OriginY;
+	
+	// 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_OriginX;
+	if (OffX < 0)
+	{
+		BaseX = -OffX;
+		SizeX += OffX;  // SizeX is decreased, OffX is negative
+		OffX = 0;
+	}
+	else
+	{
+		BaseX = 0;
+	}
+	OffZ = m_CurrentChunkZ * cChunkDef::Width - m_OriginZ;
+	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_OriginX + m_Area.m_SizeX)
+	{
+		SizeX -= (m_CurrentChunkX + 1) * cChunkDef::Width - (m_OriginX + m_Area.m_SizeX);
+	}
+	if ((m_CurrentChunkZ + 1) * cChunkDef::Width > m_OriginZ + m_Area.m_SizeZ)
+	{
+		SizeZ -= (m_CurrentChunkZ + 1) * cChunkDef::Width - (m_OriginZ + m_Area.m_SizeZ);
+	}
+
+	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;
+				m_Area.m_BlockTypes[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = cChunkDef::GetBlock(a_BlockTypes, ChunkX, ChunkY, ChunkZ);
+			}  // for x
+		}  // for z
+	}  // for y
+}
+
+
+
+
+
+void cBlockArea::cChunkReader::BlockMeta(const NIBBLETYPE * a_BlockMetas)
+{
+	if (m_Area.m_BlockMetas == NULL)
+	{
+		// Don't want metas
+		return;
+	}
+	CopyNibbles(m_Area.m_BlockMetas, a_BlockMetas);
+}
+
+
+
+
+
+void cBlockArea::cChunkReader::BlockLight(const NIBBLETYPE * a_BlockLight)
+{
+	if (m_Area.m_BlockLight == NULL)
+	{
+		// Don't want light
+		return;
+	}
+	CopyNibbles(m_Area.m_BlockLight, a_BlockLight);
+}
+
+
+
+
+
+void cBlockArea::cChunkReader::BlockSkyLight(const NIBBLETYPE * a_BlockSkyLight)
+{
+	if (m_Area.m_BlockSkyLight == NULL)
+	{
+		// Don't want skylight
+		return;
+	}
+	CopyNibbles(m_Area.m_BlockSkyLight, a_BlockSkyLight);
+}
+
+
+
+
+

source/BlockArea.h

@@ -0,0 +1,138 @@
+
+// BlockArea.h
+
+// Interfaces to the cBlockArea object representing an area of block data that can be queried from cWorld and then accessed again without further queries
+// The object also supports writing the blockdata back into cWorld, even into other coords
+
+
+
+
+
+#pragma once
+
+
+
+
+
+// fwd: "cWorld.h"
+class cWorld;
+
+
+
+
+
+// tolua_begin
+class cBlockArea
+{
+	// tolua_end
+	DISALLOW_COPY_AND_ASSIGN(cBlockArea);
+	// tolua_begin
+	
+public:
+
+	/// What data is to be queried (bit-mask)
+	enum
+	{
+		baTypes    = 1,
+		baMetas    = 2,
+		baLight    = 4,
+		baSkyLight = 8,
+	} ;
+	
+	cBlockArea(void);
+	~cBlockArea();
+	
+	/// Clears the data stored to reclaim memory
+	void Clear(void);
+	
+	/// Reads an area of blocks specified. Returns true if successful. All coords are inclusive.
+	bool Read(cWorld * a_World, int a_MinBlockX, int a_MaxBlockX, int a_MinBlockY, int a_MaxBlockY, int a_MinBlockZ, int a_MaxBlockZ, int a_DataTypes = baTypes | baMetas);
+	
+	/// Writes the area back into cWorld at the coords specified. Returns true if successful.
+	bool Write(cWorld * a_World, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes = baTypes | baMetas);
+	
+	// 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
+	
+	// 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);
+	void SetRelBlockMeta    (int a_RelX,   int a_RelY,   int a_RelZ,   NIBBLETYPE a_BlockMeta);
+	void SetBlockMeta       (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockMeta);
+	void SetRelBlockLight   (int a_RelX,   int a_RelY,   int a_RelZ,   NIBBLETYPE a_BlockLight);
+	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);
+
+	// Getters:
+	BLOCKTYPE  GetRelBlockType    (int a_RelX,   int a_RelY,   int a_RelZ);
+	BLOCKTYPE  GetBlockType       (int a_BlockX, int a_BlockY, int a_BlockZ);
+	NIBBLETYPE GetRelBlockMeta    (int a_RelX,   int a_RelY,   int a_RelZ);
+	NIBBLETYPE GetBlockMeta       (int a_BlockX, int a_BlockY, int a_BlockZ);
+	NIBBLETYPE GetRelBlockLight   (int a_RelX,   int a_RelY,   int a_RelZ);
+	NIBBLETYPE GetBlockLight      (int a_BlockX, int a_BlockY, int a_BlockZ);
+	NIBBLETYPE GetRelBlockSkyLight(int a_RelX,   int a_RelY,   int a_RelZ);
+	NIBBLETYPE GetBlockSkyLight   (int a_BlockX, int a_BlockY, int a_BlockZ);
+	
+	/// Returns the datatypes that are stored in the object (bitmask of baXXX values)
+	int GetDataTypes(void) const;
+
+protected:
+
+	// tolua_end
+	
+	class cChunkReader :
+		public cChunkDataCallback
+	{
+	public:
+		cChunkReader(cBlockArea & a_Area);
+		
+	protected:
+		cBlockArea & m_Area;
+		int m_OriginX;
+		int m_OriginY;
+		int m_OriginZ;
+		int m_CurrentChunkX;
+		int m_CurrentChunkZ;
+		
+		void CopyNibbles(NIBBLETYPE * a_AreaDst, const NIBBLETYPE * a_ChunkSrc);
+		
+		// cChunkDataCallback overrides:
+		virtual bool Coords       (int a_ChunkX, int a_ChunkZ) override;
+		virtual void BlockTypes   (const BLOCKTYPE *  a_BlockTypes)    override;
+		virtual void BlockMeta    (const NIBBLETYPE * a_BlockMetas)    override;
+		virtual void BlockLight   (const NIBBLETYPE * a_BlockLight)    override;
+		virtual void BlockSkyLight(const NIBBLETYPE * a_BlockSkyLight) override;
+	} ;
+	
+	// tolua_begin
+	
+	int m_OriginX;
+	int m_OriginY;
+	int m_OriginZ;
+	int m_SizeX;
+	int m_SizeY;
+	int m_SizeZ;
+	
+	BLOCKTYPE *  m_BlockTypes;
+	NIBBLETYPE * m_BlockMetas;     // Each meta is stored as a separate byte for faster access
+	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
+	
+	bool SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes);
+	
+	int MakeIndex(int a_RelX, int a_RelY, int a_RelZ);
+	
+	// Basic Setters:
+	void SetRelNibble(int a_RelX,   int a_RelY,   int a_RelZ,   NIBBLETYPE a_Value, NIBBLETYPE * a_Array);
+	void SetNibble   (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Value, NIBBLETYPE * a_Array);
+
+	// Basic Getters:
+	NIBBLETYPE GetRelNibble(int a_RelX,   int a_RelY,   int a_RelZ,   NIBBLETYPE * a_Array);
+	NIBBLETYPE GetNibble   (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE * a_Array);
+} ;
+// tolua_end
+
+
+
+

source/ChunkDef.h

@@ -41,6 +41,10 @@ typedef std::list<cBlockEntity *>   cBlockEntityList;
 
 
 
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// NOTE: when changing the BLOCKTYPE or NIBBLETYPE types, you need to change them both in this file and in AllToLua.pkg
+// (for some reason, just including the ChunkDef.h file in AllToLua.pkg doesn't work in ToLua)
+
 /// The datatype used by blockdata
 typedef char BLOCKTYPE;
 
@@ -50,6 +54,8 @@ typedef unsigned char NIBBLETYPE;
 /// The type used by the heightmap
 typedef unsigned char HEIGHTTYPE;
 
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 
 
 

source/cChunkMap.cpp

@@ -1165,6 +1165,35 @@ bool cChunkMap::IsChunkLighted(int a_ChunkX, int a_ChunkZ)
 
 
 
+bool cChunkMap::ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback)
+{
+	bool Result = true;
+	cCSLock Lock(m_CSLayers);
+	for (int z = a_MinChunkZ; z <= a_MaxChunkZ; z++)
+	{
+		for (int x = a_MinChunkX; x <= a_MaxChunkX; x++)
+		{
+			cChunkPtr Chunk = GetChunkNoLoad(x, ZERO_CHUNK_Y, z);
+			if ((Chunk == NULL) || (!Chunk->IsValid()))
+			{
+				// Not present / not valid
+				Result = false;
+				continue;
+			}
+			if (!a_Callback.Coords(x, z))
+			{
+				continue;
+			}
+			Chunk->GetAllData(a_Callback);
+		}
+	}
+	return Result;
+}
+
+
+
+
+
 void cChunkMap::GetChunkStats(int & a_NumChunksValid, int & a_NumChunksDirty)
 {
 	a_NumChunksValid = 0;

source/cChunkMap.h

@@ -171,6 +171,9 @@ public:
 	
 	bool IsChunkLighted(int a_ChunkX, int a_ChunkZ);
 	
+	/// Calls the callback for each chunk in the coords specified (all cords are inclusive). Returns true if all chunks have been processed successfully
+	bool ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback);
+	
 	/// Returns the number of valid chunks and the number of dirty chunks
 	void GetChunkStats(int & a_NumChunksValid, int & a_NumChunksDirty);
 	

source/cWorld.cpp

@@ -50,8 +50,6 @@
 
 #include "Vector3d.h"
 
-#include <time.h>
-
 #include "tolua++.h"
 
 #ifndef _WIN32
@@ -1819,6 +1817,15 @@ bool cWorld::IsChunkLighted(int a_ChunkX, int a_ChunkZ)
 
 
 
+bool cWorld::ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback)
+{
+	return m_ChunkMap->ForEachChunkInRect(a_MinChunkX, a_MaxChunkX, a_MinChunkZ, a_MaxChunkZ, a_Callback);
+}
+
+
+
+
+
 void cWorld::SaveAllChunks(void)
 {
 	LOG("Saving all chunks...");

source/cWorld.h

@@ -210,6 +210,9 @@ public:
 	
 	bool IsChunkLighted(int a_ChunkX, int a_ChunkZ);
 	
+	/// Calls the callback for each chunk in the coords specified (all cords are inclusive). Returns true if all chunks have been processed successfully
+	bool ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback);
+
 	void SetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_BlockMeta );						//tolua_export
 	void FastSetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_BlockMeta );					//tolua_export
 	char GetBlock( int a_X, int a_Y, int a_Z );															//tolua_export